@unpackjs/core 1.7.7 → 1.7.9

package/compiled/portfinder/index.js

@@ -1,38 +1,21 @@
 (() => {
   var __webpack_modules__ = {
-    515: function (module, exports, __nccwpck_require__) {
-      module = __nccwpck_require__.nmd(module);
+    594: function (__unused_webpack_module, exports) {
       (function (global, factory) {
         true ? factory(exports) : 0;
       })(this, function (exports) {
         "use strict";
-        function slice(arrayLike, start) {
-          start = start | 0;
-          var newLen = Math.max(arrayLike.length - start, 0);
-          var newArr = Array(newLen);
-          for (var idx = 0; idx < newLen; idx++) {
-            newArr[idx] = arrayLike[start + idx];
-          }
-          return newArr;
+        function apply(fn, ...args) {
+          return (...callArgs) => fn(...args, ...callArgs);
         }
-        var apply = function (fn) {
-          var args = slice(arguments, 1);
-          return function () {
-            var callArgs = slice(arguments);
-            return fn.apply(null, args.concat(callArgs));
-          };
-        };
-        var initialParams = function (fn) {
-          return function () {
-            var args = slice(arguments);
+        function initialParams(fn) {
+          return function (...args) {
             var callback = args.pop();
-            fn.call(this, args, callback);
+            return fn.call(this, args, callback);
           };
-        };
-        function isObject(value) {
-          var type = typeof value;
-          return value != null && (type == "object" || type == "function");
         }
+        var hasQueueMicrotask =
+          typeof queueMicrotask === "function" && queueMicrotask;
         var hasSetImmediate =
           typeof setImmediate === "function" && setImmediate;
         var hasNextTick =
@@ -41,23 +24,27 @@
           setTimeout(fn, 0);
         }
         function wrap(defer) {
-          return function (fn) {
-            var args = slice(arguments, 1);
-            defer(function () {
-              fn.apply(null, args);
-            });
-          };
+          return (fn, ...args) => defer(() => fn(...args));
         }
-        var _defer;
-        if (hasSetImmediate) {
-          _defer = setImmediate;
+        var _defer$1;
+        if (hasQueueMicrotask) {
+          _defer$1 = queueMicrotask;
+        } else if (hasSetImmediate) {
+          _defer$1 = setImmediate;
         } else if (hasNextTick) {
-          _defer = process.nextTick;
+          _defer$1 = process.nextTick;
         } else {
-          _defer = fallback;
+          _defer$1 = fallback;
         }
-        var setImmediate$1 = wrap(_defer);
+        var setImmediate$1 = wrap(_defer$1);
         function asyncify(func) {
+          if (isAsync(func)) {
+            return function (...args) {
+              const callback = args.pop();
+              const promise = func.apply(this, args);
+              return handlePromise(promise, callback);
+            };
+          }
           return initialParams(function (args, callback) {
             var result;
             try {
@@ -65,357 +52,123 @@
             } catch (e) {
               return callback(e);
             }
-            if (isObject(result) && typeof result.then === "function") {
-              result.then(
-                function (value) {
-                  invokeCallback(callback, null, value);
-                },
-                function (err) {
-                  invokeCallback(callback, err.message ? err : new Error(err));
-                },
-              );
+            if (result && typeof result.then === "function") {
+              return handlePromise(result, callback);
             } else {
               callback(null, result);
             }
           });
         }
+        function handlePromise(promise, callback) {
+          return promise.then(
+            (value) => {
+              invokeCallback(callback, null, value);
+            },
+            (err) => {
+              invokeCallback(
+                callback,
+                err && (err instanceof Error || err.message)
+                  ? err
+                  : new Error(err),
+              );
+            },
+          );
+        }
         function invokeCallback(callback, error, value) {
           try {
             callback(error, value);
-          } catch (e) {
-            setImmediate$1(rethrow, e);
+          } catch (err) {
+            setImmediate$1((e) => {
+              throw e;
+            }, err);
           }
         }
-        function rethrow(error) {
-          throw error;
-        }
-        var supportsSymbol = typeof Symbol === "function";
         function isAsync(fn) {
-          return supportsSymbol && fn[Symbol.toStringTag] === "AsyncFunction";
+          return fn[Symbol.toStringTag] === "AsyncFunction";
+        }
+        function isAsyncGenerator(fn) {
+          return fn[Symbol.toStringTag] === "AsyncGenerator";
+        }
+        function isAsyncIterable(obj) {
+          return typeof obj[Symbol.asyncIterator] === "function";
         }
         function wrapAsync(asyncFn) {
+          if (typeof asyncFn !== "function")
+            throw new Error("expected a function");
           return isAsync(asyncFn) ? asyncify(asyncFn) : asyncFn;
         }
+        function awaitify(asyncFn, arity) {
+          if (!arity) arity = asyncFn.length;
+          if (!arity) throw new Error("arity is undefined");
+          function awaitable(...args) {
+            if (typeof args[arity - 1] === "function") {
+              return asyncFn.apply(this, args);
+            }
+            return new Promise((resolve, reject) => {
+              args[arity - 1] = (err, ...cbArgs) => {
+                if (err) return reject(err);
+                resolve(cbArgs.length > 1 ? cbArgs : cbArgs[0]);
+              };
+              asyncFn.apply(this, args);
+            });
+          }
+          return awaitable;
+        }
         function applyEach$1(eachfn) {
-          return function (fns) {
-            var args = slice(arguments, 1);
-            var go = initialParams(function (args, callback) {
+          return function applyEach(fns, ...callArgs) {
+            const go = awaitify(function (callback) {
               var that = this;
               return eachfn(
                 fns,
-                function (fn, cb) {
-                  wrapAsync(fn).apply(that, args.concat(cb));
+                (fn, cb) => {
+                  wrapAsync(fn).apply(that, callArgs.concat(cb));
                 },
                 callback,
               );
             });
-            if (args.length) {
-              return go.apply(this, args);
-            } else {
-              return go;
-            }
+            return go;
           };
         }
-        var freeGlobal =
-          typeof global == "object" &&
-          global &&
-          global.Object === Object &&
-          global;
-        var freeSelf =
-          typeof self == "object" && self && self.Object === Object && self;
-        var root = freeGlobal || freeSelf || Function("return this")();
-        var Symbol$1 = root.Symbol;
-        var objectProto = Object.prototype;
-        var hasOwnProperty = objectProto.hasOwnProperty;
-        var nativeObjectToString = objectProto.toString;
-        var symToStringTag$1 = Symbol$1 ? Symbol$1.toStringTag : undefined;
-        function getRawTag(value) {
-          var isOwn = hasOwnProperty.call(value, symToStringTag$1),
-            tag = value[symToStringTag$1];
-          try {
-            value[symToStringTag$1] = undefined;
-            var unmasked = true;
-          } catch (e) {}
-          var result = nativeObjectToString.call(value);
-          if (unmasked) {
-            if (isOwn) {
-              value[symToStringTag$1] = tag;
-            } else {
-              delete value[symToStringTag$1];
-            }
-          }
-          return result;
-        }
-        var objectProto$1 = Object.prototype;
-        var nativeObjectToString$1 = objectProto$1.toString;
-        function objectToString(value) {
-          return nativeObjectToString$1.call(value);
-        }
-        var nullTag = "[object Null]";
-        var undefinedTag = "[object Undefined]";
-        var symToStringTag = Symbol$1 ? Symbol$1.toStringTag : undefined;
-        function baseGetTag(value) {
-          if (value == null) {
-            return value === undefined ? undefinedTag : nullTag;
-          }
-          return symToStringTag && symToStringTag in Object(value)
-            ? getRawTag(value)
-            : objectToString(value);
-        }
-        var asyncTag = "[object AsyncFunction]";
-        var funcTag = "[object Function]";
-        var genTag = "[object GeneratorFunction]";
-        var proxyTag = "[object Proxy]";
-        function isFunction(value) {
-          if (!isObject(value)) {
-            return false;
-          }
-          var tag = baseGetTag(value);
-          return (
-            tag == funcTag ||
-            tag == genTag ||
-            tag == asyncTag ||
-            tag == proxyTag
+        function _asyncMap(eachfn, arr, iteratee, callback) {
+          arr = arr || [];
+          var results = [];
+          var counter = 0;
+          var _iteratee = wrapAsync(iteratee);
+          return eachfn(
+            arr,
+            (value, _, iterCb) => {
+              var index = counter++;
+              _iteratee(value, (err, v) => {
+                results[index] = v;
+                iterCb(err);
+              });
+            },
+            (err) => {
+              callback(err, results);
+            },
           );
         }
-        var MAX_SAFE_INTEGER = 9007199254740991;
-        function isLength(value) {
+        function isArrayLike(value) {
           return (
-            typeof value == "number" &&
-            value > -1 &&
-            value % 1 == 0 &&
-            value <= MAX_SAFE_INTEGER
+            value &&
+            typeof value.length === "number" &&
+            value.length >= 0 &&
+            value.length % 1 === 0
           );
         }
-        function isArrayLike(value) {
-          return value != null && isLength(value.length) && !isFunction(value);
-        }
-        var breakLoop = {};
-        function noop() {}
+        const breakLoop = {};
         function once(fn) {
-          return function () {
+          function wrapper(...args) {
             if (fn === null) return;
             var callFn = fn;
             fn = null;
-            callFn.apply(this, arguments);
-          };
-        }
-        var iteratorSymbol = typeof Symbol === "function" && Symbol.iterator;
-        var getIterator = function (coll) {
-          return (
-            iteratorSymbol && coll[iteratorSymbol] && coll[iteratorSymbol]()
-          );
-        };
-        function baseTimes(n, iteratee) {
-          var index = -1,
-            result = Array(n);
-          while (++index < n) {
-            result[index] = iteratee(index);
+            callFn.apply(this, args);
           }
-          return result;
+          Object.assign(wrapper, fn);
+          return wrapper;
         }
-        function isObjectLike(value) {
-          return value != null && typeof value == "object";
-        }
-        var argsTag = "[object Arguments]";
-        function baseIsArguments(value) {
-          return isObjectLike(value) && baseGetTag(value) == argsTag;
-        }
-        var objectProto$3 = Object.prototype;
-        var hasOwnProperty$2 = objectProto$3.hasOwnProperty;
-        var propertyIsEnumerable = objectProto$3.propertyIsEnumerable;
-        var isArguments = baseIsArguments(
-          (function () {
-            return arguments;
-          })(),
-        )
-          ? baseIsArguments
-          : function (value) {
-              return (
-                isObjectLike(value) &&
-                hasOwnProperty$2.call(value, "callee") &&
-                !propertyIsEnumerable.call(value, "callee")
-              );
-            };
-        var isArray = Array.isArray;
-        function stubFalse() {
-          return false;
-        }
-        var freeExports =
-          typeof exports == "object" && exports && !exports.nodeType && exports;
-        var freeModule =
-          freeExports &&
-          "object" == "object" &&
-          module &&
-          !module.nodeType &&
-          module;
-        var moduleExports = freeModule && freeModule.exports === freeExports;
-        var Buffer = moduleExports ? root.Buffer : undefined;
-        var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;
-        var isBuffer = nativeIsBuffer || stubFalse;
-        var MAX_SAFE_INTEGER$1 = 9007199254740991;
-        var reIsUint = /^(?:0|[1-9]\d*)$/;
-        function isIndex(value, length) {
-          var type = typeof value;
-          length = length == null ? MAX_SAFE_INTEGER$1 : length;
-          return (
-            !!length &&
-            (type == "number" || (type != "symbol" && reIsUint.test(value))) &&
-            value > -1 &&
-            value % 1 == 0 &&
-            value < length
-          );
-        }
-        var argsTag$1 = "[object Arguments]";
-        var arrayTag = "[object Array]";
-        var boolTag = "[object Boolean]";
-        var dateTag = "[object Date]";
-        var errorTag = "[object Error]";
-        var funcTag$1 = "[object Function]";
-        var mapTag = "[object Map]";
-        var numberTag = "[object Number]";
-        var objectTag = "[object Object]";
-        var regexpTag = "[object RegExp]";
-        var setTag = "[object Set]";
-        var stringTag = "[object String]";
-        var weakMapTag = "[object WeakMap]";
-        var arrayBufferTag = "[object ArrayBuffer]";
-        var dataViewTag = "[object DataView]";
-        var float32Tag = "[object Float32Array]";
-        var float64Tag = "[object Float64Array]";
-        var int8Tag = "[object Int8Array]";
-        var int16Tag = "[object Int16Array]";
-        var int32Tag = "[object Int32Array]";
-        var uint8Tag = "[object Uint8Array]";
-        var uint8ClampedTag = "[object Uint8ClampedArray]";
-        var uint16Tag = "[object Uint16Array]";
-        var uint32Tag = "[object Uint32Array]";
-        var typedArrayTags = {};
-        typedArrayTags[float32Tag] =
-          typedArrayTags[float64Tag] =
-          typedArrayTags[int8Tag] =
-          typedArrayTags[int16Tag] =
-          typedArrayTags[int32Tag] =
-          typedArrayTags[uint8Tag] =
-          typedArrayTags[uint8ClampedTag] =
-          typedArrayTags[uint16Tag] =
-          typedArrayTags[uint32Tag] =
-            true;
-        typedArrayTags[argsTag$1] =
-          typedArrayTags[arrayTag] =
-          typedArrayTags[arrayBufferTag] =
-          typedArrayTags[boolTag] =
-          typedArrayTags[dataViewTag] =
-          typedArrayTags[dateTag] =
-          typedArrayTags[errorTag] =
-          typedArrayTags[funcTag$1] =
-          typedArrayTags[mapTag] =
-          typedArrayTags[numberTag] =
-          typedArrayTags[objectTag] =
-          typedArrayTags[regexpTag] =
-          typedArrayTags[setTag] =
-          typedArrayTags[stringTag] =
-          typedArrayTags[weakMapTag] =
-            false;
-        function baseIsTypedArray(value) {
-          return (
-            isObjectLike(value) &&
-            isLength(value.length) &&
-            !!typedArrayTags[baseGetTag(value)]
-          );
-        }
-        function baseUnary(func) {
-          return function (value) {
-            return func(value);
-          };
-        }
-        var freeExports$1 =
-          typeof exports == "object" && exports && !exports.nodeType && exports;
-        var freeModule$1 =
-          freeExports$1 &&
-          "object" == "object" &&
-          module &&
-          !module.nodeType &&
-          module;
-        var moduleExports$1 =
-          freeModule$1 && freeModule$1.exports === freeExports$1;
-        var freeProcess = moduleExports$1 && freeGlobal.process;
-        var nodeUtil = (function () {
-          try {
-            var types =
-              freeModule$1 &&
-              freeModule$1.require &&
-              freeModule$1.require("util").types;
-            if (types) {
-              return types;
-            }
-            return (
-              freeProcess && freeProcess.binding && freeProcess.binding("util")
-            );
-          } catch (e) {}
-        })();
-        var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
-        var isTypedArray = nodeIsTypedArray
-          ? baseUnary(nodeIsTypedArray)
-          : baseIsTypedArray;
-        var objectProto$2 = Object.prototype;
-        var hasOwnProperty$1 = objectProto$2.hasOwnProperty;
-        function arrayLikeKeys(value, inherited) {
-          var isArr = isArray(value),
-            isArg = !isArr && isArguments(value),
-            isBuff = !isArr && !isArg && isBuffer(value),
-            isType = !isArr && !isArg && !isBuff && isTypedArray(value),
-            skipIndexes = isArr || isArg || isBuff || isType,
-            result = skipIndexes ? baseTimes(value.length, String) : [],
-            length = result.length;
-          for (var key in value) {
-            if (
-              (inherited || hasOwnProperty$1.call(value, key)) &&
-              !(
-                skipIndexes &&
-                (key == "length" ||
-                  (isBuff && (key == "offset" || key == "parent")) ||
-                  (isType &&
-                    (key == "buffer" ||
-                      key == "byteLength" ||
-                      key == "byteOffset")) ||
-                  isIndex(key, length))
-              )
-            ) {
-              result.push(key);
-            }
-          }
-          return result;
-        }
-        var objectProto$5 = Object.prototype;
-        function isPrototype(value) {
-          var Ctor = value && value.constructor,
-            proto =
-              (typeof Ctor == "function" && Ctor.prototype) || objectProto$5;
-          return value === proto;
-        }
-        function overArg(func, transform) {
-          return function (arg) {
-            return func(transform(arg));
-          };
-        }
-        var nativeKeys = overArg(Object.keys, Object);
-        var objectProto$4 = Object.prototype;
-        var hasOwnProperty$3 = objectProto$4.hasOwnProperty;
-        function baseKeys(object) {
-          if (!isPrototype(object)) {
-            return nativeKeys(object);
-          }
-          var result = [];
-          for (var key in Object(object)) {
-            if (hasOwnProperty$3.call(object, key) && key != "constructor") {
-              result.push(key);
-            }
-          }
-          return result;
-        }
-        function keys(object) {
-          return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+        function getIterator(coll) {
+          return coll[Symbol.iterator] && coll[Symbol.iterator]();
         }
         function createArrayIterator(coll) {
           var i = -1;
@@ -434,7 +187,7 @@
           };
         }
         function createObjectIterator(obj) {
-          var okeys = keys(obj);
+          var okeys = obj ? Object.keys(obj) : [];
           var i = -1;
           var len = okeys.length;
           return function next() {
@@ -445,7 +198,7 @@
             return i < len ? { value: obj[key], key } : null;
           };
         }
-        function iterator(coll) {
+        function createIterator(coll) {
           if (isArrayLike(coll)) {
             return createArrayIterator(coll);
           }
@@ -455,71 +208,140 @@
             : createObjectIterator(coll);
         }
         function onlyOnce(fn) {
-          return function () {
+          return function (...args) {
             if (fn === null) throw new Error("Callback was already called.");
             var callFn = fn;
             fn = null;
-            callFn.apply(this, arguments);
+            callFn.apply(this, args);
           };
         }
-        function _eachOfLimit(limit) {
-          return function (obj, iteratee, callback) {
-            callback = once(callback || noop);
-            if (limit <= 0 || !obj) {
-              return callback(null);
-            }
-            var nextElem = iterator(obj);
-            var done = false;
-            var running = 0;
-            var looping = false;
-            function iterateeCallback(err, value) {
-              running -= 1;
-              if (err) {
-                done = true;
-                callback(err);
-              } else if (value === breakLoop || (done && running <= 0)) {
-                done = true;
-                return callback(null);
-              } else if (!looping) {
-                replenish();
-              }
-            }
-            function replenish() {
-              looping = true;
-              while (running < limit && !done) {
-                var elem = nextElem();
-                if (elem === null) {
+        function asyncEachOfLimit(generator, limit, iteratee, callback) {
+          let done = false;
+          let canceled = false;
+          let awaiting = false;
+          let running = 0;
+          let idx = 0;
+          function replenish() {
+            if (running >= limit || awaiting || done) return;
+            awaiting = true;
+            generator
+              .next()
+              .then(({ value, done: iterDone }) => {
+                if (canceled || done) return;
+                awaiting = false;
+                if (iterDone) {
                   done = true;
                   if (running <= 0) {
                     callback(null);
                   }
                   return;
                 }
-                running += 1;
-                iteratee(elem.value, elem.key, onlyOnce(iterateeCallback));
-              }
-              looping = false;
+                running++;
+                iteratee(value, idx, iterateeCallback);
+                idx++;
+                replenish();
+              })
+              .catch(handleError);
+          }
+          function iterateeCallback(err, result) {
+            running -= 1;
+            if (canceled) return;
+            if (err) return handleError(err);
+            if (err === false) {
+              done = true;
+              canceled = true;
+              return;
+            }
+            if (result === breakLoop || (done && running <= 0)) {
+              done = true;
+              return callback(null);
             }
             replenish();
-          };
+          }
+          function handleError(err) {
+            if (canceled) return;
+            awaiting = false;
+            done = true;
+            callback(err);
+          }
+          replenish();
         }
+        var eachOfLimit$2 = (limit) => (obj, iteratee, callback) => {
+          callback = once(callback);
+          if (limit <= 0) {
+            throw new RangeError("concurrency limit cannot be less than 1");
+          }
+          if (!obj) {
+            return callback(null);
+          }
+          if (isAsyncGenerator(obj)) {
+            return asyncEachOfLimit(obj, limit, iteratee, callback);
+          }
+          if (isAsyncIterable(obj)) {
+            return asyncEachOfLimit(
+              obj[Symbol.asyncIterator](),
+              limit,
+              iteratee,
+              callback,
+            );
+          }
+          var nextElem = createIterator(obj);
+          var done = false;
+          var canceled = false;
+          var running = 0;
+          var looping = false;
+          function iterateeCallback(err, value) {
+            if (canceled) return;
+            running -= 1;
+            if (err) {
+              done = true;
+              callback(err);
+            } else if (err === false) {
+              done = true;
+              canceled = true;
+            } else if (value === breakLoop || (done && running <= 0)) {
+              done = true;
+              return callback(null);
+            } else if (!looping) {
+              replenish();
+            }
+          }
+          function replenish() {
+            looping = true;
+            while (running < limit && !done) {
+              var elem = nextElem();
+              if (elem === null) {
+                done = true;
+                if (running <= 0) {
+                  callback(null);
+                }
+                return;
+              }
+              running += 1;
+              iteratee(elem.value, elem.key, onlyOnce(iterateeCallback));
+            }
+            looping = false;
+          }
+          replenish();
+        };
         function eachOfLimit(coll, limit, iteratee, callback) {
-          _eachOfLimit(limit)(coll, wrapAsync(iteratee), callback);
-        }
-        function doLimit(fn, limit) {
-          return function (iterable, iteratee, callback) {
-            return fn(iterable, limit, iteratee, callback);
-          };
+          return eachOfLimit$2(limit)(coll, wrapAsync(iteratee), callback);
         }
+        var eachOfLimit$1 = awaitify(eachOfLimit, 4);
         function eachOfArrayLike(coll, iteratee, callback) {
-          callback = once(callback || noop);
+          callback = once(callback);
           var index = 0,
             completed = 0,
-            length = coll.length;
+            { length } = coll,
+            canceled = false;
           if (length === 0) {
             callback(null);
           }
           function iteratorCallback(err, value) {
+            if (err === false) {
+              canceled = true;
+            }
+            if (canceled === true) return;
             if (err) {
               callback(err);
             } else if (++completed === length || value === breakLoop) {
@@ -530,113 +352,49 @@
             iteratee(coll[index], index, onlyOnce(iteratorCallback));
           }
         }
-        var eachOfGeneric = doLimit(eachOfLimit, Infinity);
-        var eachOf = function (coll, iteratee, callback) {
+        function eachOfGeneric(coll, iteratee, callback) {
+          return eachOfLimit$1(coll, Infinity, iteratee, callback);
+        }
+        function eachOf(coll, iteratee, callback) {
           var eachOfImplementation = isArrayLike(coll)
             ? eachOfArrayLike
             : eachOfGeneric;
-          eachOfImplementation(coll, wrapAsync(iteratee), callback);
-        };
-        function doParallel(fn) {
-          return function (obj, iteratee, callback) {
-            return fn(eachOf, obj, wrapAsync(iteratee), callback);
-          };
-        }
-        function _asyncMap(eachfn, arr, iteratee, callback) {
-          callback = callback || noop;
-          arr = arr || [];
-          var results = [];
-          var counter = 0;
-          var _iteratee = wrapAsync(iteratee);
-          eachfn(
-            arr,
-            function (value, _, callback) {
-              var index = counter++;
-              _iteratee(value, function (err, v) {
-                results[index] = v;
-                callback(err);
-              });
-            },
-            function (err) {
-              callback(err, results);
-            },
-          );
-        }
-        var map = doParallel(_asyncMap);
-        var applyEach = applyEach$1(map);
-        function doParallelLimit(fn) {
-          return function (obj, limit, iteratee, callback) {
-            return fn(_eachOfLimit(limit), obj, wrapAsync(iteratee), callback);
-          };
-        }
-        var mapLimit = doParallelLimit(_asyncMap);
-        var mapSeries = doLimit(mapLimit, 1);
-        var applyEachSeries = applyEach$1(mapSeries);
-        function arrayEach(array, iteratee) {
-          var index = -1,
-            length = array == null ? 0 : array.length;
-          while (++index < length) {
-            if (iteratee(array[index], index, array) === false) {
-              break;
-            }
-          }
-          return array;
-        }
-        function createBaseFor(fromRight) {
-          return function (object, iteratee, keysFunc) {
-            var index = -1,
-              iterable = Object(object),
-              props = keysFunc(object),
-              length = props.length;
-            while (length--) {
-              var key = props[fromRight ? length : ++index];
-              if (iteratee(iterable[key], key, iterable) === false) {
-                break;
-              }
-            }
-            return object;
-          };
-        }
-        var baseFor = createBaseFor();
-        function baseForOwn(object, iteratee) {
-          return object && baseFor(object, iteratee, keys);
-        }
-        function baseFindIndex(array, predicate, fromIndex, fromRight) {
-          var length = array.length,
-            index = fromIndex + (fromRight ? 1 : -1);
-          while (fromRight ? index-- : ++index < length) {
-            if (predicate(array[index], index, array)) {
-              return index;
-            }
-          }
-          return -1;
-        }
-        function baseIsNaN(value) {
-          return value !== value;
-        }
-        function strictIndexOf(array, value, fromIndex) {
-          var index = fromIndex - 1,
-            length = array.length;
-          while (++index < length) {
-            if (array[index] === value) {
-              return index;
-            }
-          }
-          return -1;
-        }
-        function baseIndexOf(array, value, fromIndex) {
-          return value === value
-            ? strictIndexOf(array, value, fromIndex)
-            : baseFindIndex(array, baseIsNaN, fromIndex);
+          return eachOfImplementation(coll, wrapAsync(iteratee), callback);
+        }
+        var eachOf$1 = awaitify(eachOf, 3);
+        function map(coll, iteratee, callback) {
+          return _asyncMap(eachOf$1, coll, iteratee, callback);
+        }
+        var map$1 = awaitify(map, 3);
+        var applyEach = applyEach$1(map$1);
+        function eachOfSeries(coll, iteratee, callback) {
+          return eachOfLimit$1(coll, 1, iteratee, callback);
+        }
+        var eachOfSeries$1 = awaitify(eachOfSeries, 3);
+        function mapSeries(coll, iteratee, callback) {
+          return _asyncMap(eachOfSeries$1, coll, iteratee, callback);
+        }
+        var mapSeries$1 = awaitify(mapSeries, 3);
+        var applyEachSeries = applyEach$1(mapSeries$1);
+        const PROMISE_SYMBOL = Symbol("promiseCallback");
+        function promiseCallback() {
+          let resolve, reject;
+          function callback(err, ...args) {
+            if (err) return reject(err);
+            resolve(args.length > 1 ? args : args[0]);
+          }
+          callback[PROMISE_SYMBOL] = new Promise((res, rej) => {
+            (resolve = res), (reject = rej);
+          });
+          return callback;
         }
-        var auto = function (tasks, concurrency, callback) {
-          if (typeof concurrency === "function") {
+        function auto(tasks, concurrency, callback) {
+          if (typeof concurrency !== "number") {
             callback = concurrency;
             concurrency = null;
           }
-          callback = once(callback || noop);
-          var keys$$1 = keys(tasks);
-          var numTasks = keys$$1.length;
+          callback = once(callback || promiseCallback());
+          var numTasks = Object.keys(tasks).length;
           if (!numTasks) {
             return callback(null);
           }
@@ -645,13 +403,15 @@
           }
           var results = {};
           var runningTasks = 0;
+          var canceled = false;
           var hasError = false;
           var listeners = Object.create(null);
           var readyTasks = [];
           var readyToCheck = [];
           var uncheckedDependencies = {};
-          baseForOwn(tasks, function (task, key) {
-            if (!isArray(task)) {
+          Object.keys(tasks).forEach((key) => {
+            var task = tasks[key];
+            if (!Array.isArray(task)) {
               enqueueTask(key, [task]);
               readyToCheck.push(key);
               return;
@@ -664,7 +424,7 @@
               return;
             }
             uncheckedDependencies[key] = remainingDependencies;
-            arrayEach(dependencies, function (dependencyName) {
+            dependencies.forEach((dependencyName) => {
               if (!tasks[dependencyName]) {
                 throw new Error(
                   "async.auto task `" +
@@ -675,7 +435,7 @@
                     dependencies.join(", "),
                 );
               }
-              addListener(dependencyName, function () {
+              addListener(dependencyName, () => {
                 remainingDependencies--;
                 if (remainingDependencies === 0) {
                   enqueueTask(key, task);
@@ -686,11 +446,10 @@
           checkForDeadlocks();
           processQueue();
           function enqueueTask(key, task) {
-            readyTasks.push(function () {
-              runTask(key, task);
-            });
+            readyTasks.push(() => runTask(key, task));
           }
           function processQueue() {
+            if (canceled) return;
             if (readyTasks.length === 0 && runningTasks === 0) {
               return callback(null, results);
             }
@@ -708,26 +467,29 @@
           }
           function taskComplete(taskName) {
             var taskListeners = listeners[taskName] || [];
-            arrayEach(taskListeners, function (fn) {
-              fn();
-            });
+            taskListeners.forEach((fn) => fn());
             processQueue();
           }
           function runTask(key, task) {
             if (hasError) return;
-            var taskCallback = onlyOnce(function (err, result) {
+            var taskCallback = onlyOnce((err, ...result) => {
               runningTasks--;
-              if (arguments.length > 2) {
-                result = slice(arguments, 1);
+              if (err === false) {
+                canceled = true;
+                return;
+              }
+              if (result.length < 2) {
+                [result] = result;
               }
               if (err) {
                 var safeResults = {};
-                baseForOwn(results, function (val, rkey) {
-                  safeResults[rkey] = val;
+                Object.keys(results).forEach((rkey) => {
+                  safeResults[rkey] = results[rkey];
                 });
                 safeResults[key] = result;
                 hasError = true;
                 listeners = Object.create(null);
+                if (canceled) return;
                 callback(err, safeResults);
               } else {
                 results[key] = result;
@@ -748,7 +510,7 @@
             while (readyToCheck.length) {
               currentTask = readyToCheck.pop();
               counter++;
-              arrayEach(getDependents(currentTask), function (dependent) {
+              getDependents(currentTask).forEach((dependent) => {
                 if (--uncheckedDependencies[dependent] === 0) {
                   readyToCheck.push(dependent);
                 }
@@ -762,194 +524,78 @@
           }
           function getDependents(taskName) {
             var result = [];
-            baseForOwn(tasks, function (task, key) {
-              if (isArray(task) && baseIndexOf(task, taskName, 0) >= 0) {
+            Object.keys(tasks).forEach((key) => {
+              const task = tasks[key];
+              if (Array.isArray(task) && task.indexOf(taskName) >= 0) {
                 result.push(key);
               }
             });
             return result;
           }
-        };
-        function arrayMap(array, iteratee) {
-          var index = -1,
-            length = array == null ? 0 : array.length,
-            result = Array(length);
-          while (++index < length) {
-            result[index] = iteratee(array[index], index, array);
-          }
-          return result;
-        }
-        var symbolTag = "[object Symbol]";
-        function isSymbol(value) {
-          return (
-            typeof value == "symbol" ||
-            (isObjectLike(value) && baseGetTag(value) == symbolTag)
-          );
-        }
-        var INFINITY = 1 / 0;
-        var symbolProto = Symbol$1 ? Symbol$1.prototype : undefined;
-        var symbolToString = symbolProto ? symbolProto.toString : undefined;
-        function baseToString(value) {
-          if (typeof value == "string") {
-            return value;
-          }
-          if (isArray(value)) {
-            return arrayMap(value, baseToString) + "";
-          }
-          if (isSymbol(value)) {
-            return symbolToString ? symbolToString.call(value) : "";
-          }
-          var result = value + "";
-          return result == "0" && 1 / value == -INFINITY ? "-0" : result;
-        }
-        function baseSlice(array, start, end) {
-          var index = -1,
-            length = array.length;
-          if (start < 0) {
-            start = -start > length ? 0 : length + start;
-          }
-          end = end > length ? length : end;
-          if (end < 0) {
-            end += length;
-          }
-          length = start > end ? 0 : (end - start) >>> 0;
-          start >>>= 0;
-          var result = Array(length);
-          while (++index < length) {
-            result[index] = array[index + start];
-          }
-          return result;
-        }
-        function castSlice(array, start, end) {
-          var length = array.length;
-          end = end === undefined ? length : end;
-          return !start && end >= length ? array : baseSlice(array, start, end);
+          return callback[PROMISE_SYMBOL];
         }
-        function charsEndIndex(strSymbols, chrSymbols) {
-          var index = strSymbols.length;
-          while (
-            index-- &&
-            baseIndexOf(chrSymbols, strSymbols[index], 0) > -1
-          ) {}
-          return index;
-        }
-        function charsStartIndex(strSymbols, chrSymbols) {
-          var index = -1,
-            length = strSymbols.length;
-          while (
-            ++index < length &&
-            baseIndexOf(chrSymbols, strSymbols[index], 0) > -1
-          ) {}
-          return index;
-        }
-        function asciiToArray(string) {
-          return string.split("");
-        }
-        var rsAstralRange = "\\ud800-\\udfff";
-        var rsComboMarksRange = "\\u0300-\\u036f";
-        var reComboHalfMarksRange = "\\ufe20-\\ufe2f";
-        var rsComboSymbolsRange = "\\u20d0-\\u20ff";
-        var rsComboRange =
-          rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange;
-        var rsVarRange = "\\ufe0e\\ufe0f";
-        var rsZWJ = "\\u200d";
-        var reHasUnicode = RegExp(
-          "[" + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + "]",
-        );
-        function hasUnicode(string) {
-          return reHasUnicode.test(string);
-        }
-        var rsAstralRange$1 = "\\ud800-\\udfff";
-        var rsComboMarksRange$1 = "\\u0300-\\u036f";
-        var reComboHalfMarksRange$1 = "\\ufe20-\\ufe2f";
-        var rsComboSymbolsRange$1 = "\\u20d0-\\u20ff";
-        var rsComboRange$1 =
-          rsComboMarksRange$1 + reComboHalfMarksRange$1 + rsComboSymbolsRange$1;
-        var rsVarRange$1 = "\\ufe0e\\ufe0f";
-        var rsAstral = "[" + rsAstralRange$1 + "]";
-        var rsCombo = "[" + rsComboRange$1 + "]";
-        var rsFitz = "\\ud83c[\\udffb-\\udfff]";
-        var rsModifier = "(?:" + rsCombo + "|" + rsFitz + ")";
-        var rsNonAstral = "[^" + rsAstralRange$1 + "]";
-        var rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}";
-        var rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]";
-        var rsZWJ$1 = "\\u200d";
-        var reOptMod = rsModifier + "?";
-        var rsOptVar = "[" + rsVarRange$1 + "]?";
-        var rsOptJoin =
-          "(?:" +
-          rsZWJ$1 +
-          "(?:" +
-          [rsNonAstral, rsRegional, rsSurrPair].join("|") +
-          ")" +
-          rsOptVar +
-          reOptMod +
-          ")*";
-        var rsSeq = rsOptVar + reOptMod + rsOptJoin;
-        var rsSymbol =
-          "(?:" +
-          [
-            rsNonAstral + rsCombo + "?",
-            rsCombo,
-            rsRegional,
-            rsSurrPair,
-            rsAstral,
-          ].join("|") +
-          ")";
-        var reUnicode = RegExp(
-          rsFitz + "(?=" + rsFitz + ")|" + rsSymbol + rsSeq,
-          "g",
-        );
-        function unicodeToArray(string) {
-          return string.match(reUnicode) || [];
-        }
-        function stringToArray(string) {
-          return hasUnicode(string)
-            ? unicodeToArray(string)
-            : asciiToArray(string);
-        }
-        function toString(value) {
-          return value == null ? "" : baseToString(value);
-        }
-        var reTrim = /^\s+|\s+$/g;
-        function trim(string, chars, guard) {
-          string = toString(string);
-          if (string && (guard || chars === undefined)) {
-            return string.replace(reTrim, "");
-          }
-          if (!string || !(chars = baseToString(chars))) {
-            return string;
-          }
-          var strSymbols = stringToArray(string),
-            chrSymbols = stringToArray(chars),
-            start = charsStartIndex(strSymbols, chrSymbols),
-            end = charsEndIndex(strSymbols, chrSymbols) + 1;
-          return castSlice(strSymbols, start, end).join("");
-        }
-        var FN_ARGS = /^(?:async\s+)?(function)?\s*[^\(]*\(\s*([^\)]*)\)/m;
+        var FN_ARGS =
+          /^(?:async\s)?(?:function)?\s*(?:\w+\s*)?\(([^)]+)\)(?:\s*{)/;
+        var ARROW_FN_ARGS =
+          /^(?:async\s)?\s*(?:\(\s*)?((?:[^)=\s]\s*)*)(?:\)\s*)?=>/;
         var FN_ARG_SPLIT = /,/;
         var FN_ARG = /(=.+)?(\s*)$/;
-        var STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm;
+        function stripComments(string) {
+          let stripped = "";
+          let index = 0;
+          let endBlockComment = string.indexOf("*/");
+          while (index < string.length) {
+            if (string[index] === "/" && string[index + 1] === "/") {
+              let endIndex = string.indexOf("\n", index);
+              index = endIndex === -1 ? string.length : endIndex;
+            } else if (
+              endBlockComment !== -1 &&
+              string[index] === "/" &&
+              string[index + 1] === "*"
+            ) {
+              let endIndex = string.indexOf("*/", index);
+              if (endIndex !== -1) {
+                index = endIndex + 2;
+                endBlockComment = string.indexOf("*/", index);
+              } else {
+                stripped += string[index];
+                index++;
+              }
+            } else {
+              stripped += string[index];
+              index++;
+            }
+          }
+          return stripped;
+        }
         function parseParams(func) {
-          func = func.toString().replace(STRIP_COMMENTS, "");
-          func = func.match(FN_ARGS)[2].replace(" ", "");
-          func = func ? func.split(FN_ARG_SPLIT) : [];
-          func = func.map(function (arg) {
-            return trim(arg.replace(FN_ARG, ""));
-          });
-          return func;
+          const src = stripComments(func.toString());
+          let match = src.match(FN_ARGS);
+          if (!match) {
+            match = src.match(ARROW_FN_ARGS);
+          }
+          if (!match)
+            throw new Error(
+              "could not parse args in autoInject\nSource:\n" + src,
+            );
+          let [, args] = match;
+          return args
+            .replace(/\s/g, "")
+            .split(FN_ARG_SPLIT)
+            .map((arg) => arg.replace(FN_ARG, "").trim());
         }
         function autoInject(tasks, callback) {
           var newTasks = {};
-          baseForOwn(tasks, function (taskFn, key) {
+          Object.keys(tasks).forEach((key) => {
+            var taskFn = tasks[key];
             var params;
             var fnIsAsync = isAsync(taskFn);
             var hasNoDeps =
               (!fnIsAsync && taskFn.length === 1) ||
               (fnIsAsync && taskFn.length === 0);
-            if (isArray(taskFn)) {
-              params = taskFn.slice(0, -1);
-              taskFn = taskFn[taskFn.length - 1];
+            if (Array.isArray(taskFn)) {
+              params = [...taskFn];
+              taskFn = params.pop();
               newTasks[key] = params.concat(
                 params.length > 0 ? newTask : taskFn,
               );
@@ -966,177 +612,259 @@
               newTasks[key] = params.concat(newTask);
             }
             function newTask(results, taskCb) {
-              var newArgs = arrayMap(params, function (name) {
-                return results[name];
-              });
+              var newArgs = params.map((name) => results[name]);
               newArgs.push(taskCb);
-              wrapAsync(taskFn).apply(null, newArgs);
+              wrapAsync(taskFn)(...newArgs);
             }
           });
-          auto(newTasks, callback);
-        }
-        function DLL() {
-          this.head = this.tail = null;
-          this.length = 0;
+          return auto(newTasks, callback);
+        }
+        class DLL {
+          constructor() {
+            this.head = this.tail = null;
+            this.length = 0;
+          }
+          removeLink(node) {
+            if (node.prev) node.prev.next = node.next;
+            else this.head = node.next;
+            if (node.next) node.next.prev = node.prev;
+            else this.tail = node.prev;
+            node.prev = node.next = null;
+            this.length -= 1;
+            return node;
+          }
+          empty() {
+            while (this.head) this.shift();
+            return this;
+          }
+          insertAfter(node, newNode) {
+            newNode.prev = node;
+            newNode.next = node.next;
+            if (node.next) node.next.prev = newNode;
+            else this.tail = newNode;
+            node.next = newNode;
+            this.length += 1;
+          }
+          insertBefore(node, newNode) {
+            newNode.prev = node.prev;
+            newNode.next = node;
+            if (node.prev) node.prev.next = newNode;
+            else this.head = newNode;
+            node.prev = newNode;
+            this.length += 1;
+          }
+          unshift(node) {
+            if (this.head) this.insertBefore(this.head, node);
+            else setInitial(this, node);
+          }
+          push(node) {
+            if (this.tail) this.insertAfter(this.tail, node);
+            else setInitial(this, node);
+          }
+          shift() {
+            return this.head && this.removeLink(this.head);
+          }
+          pop() {
+            return this.tail && this.removeLink(this.tail);
+          }
+          toArray() {
+            return [...this];
+          }
+          *[Symbol.iterator]() {
+            var cur = this.head;
+            while (cur) {
+              yield cur.data;
+              cur = cur.next;
+            }
+          }
+          remove(testFn) {
+            var curr = this.head;
+            while (curr) {
+              var { next } = curr;
+              if (testFn(curr)) {
+                this.removeLink(curr);
+              }
+              curr = next;
+            }
+            return this;
+          }
         }
         function setInitial(dll, node) {
           dll.length = 1;
           dll.head = dll.tail = node;
         }
-        DLL.prototype.removeLink = function (node) {
-          if (node.prev) node.prev.next = node.next;
-          else this.head = node.next;
-          if (node.next) node.next.prev = node.prev;
-          else this.tail = node.prev;
-          node.prev = node.next = null;
-          this.length -= 1;
-          return node;
-        };
-        DLL.prototype.empty = function () {
-          while (this.head) this.shift();
-          return this;
-        };
-        DLL.prototype.insertAfter = function (node, newNode) {
-          newNode.prev = node;
-          newNode.next = node.next;
-          if (node.next) node.next.prev = newNode;
-          else this.tail = newNode;
-          node.next = newNode;
-          this.length += 1;
-        };
-        DLL.prototype.insertBefore = function (node, newNode) {
-          newNode.prev = node.prev;
-          newNode.next = node;
-          if (node.prev) node.prev.next = newNode;
-          else this.head = newNode;
-          node.prev = newNode;
-          this.length += 1;
-        };
-        DLL.prototype.unshift = function (node) {
-          if (this.head) this.insertBefore(this.head, node);
-          else setInitial(this, node);
-        };
-        DLL.prototype.push = function (node) {
-          if (this.tail) this.insertAfter(this.tail, node);
-          else setInitial(this, node);
-        };
-        DLL.prototype.shift = function () {
-          return this.head && this.removeLink(this.head);
-        };
-        DLL.prototype.pop = function () {
-          return this.tail && this.removeLink(this.tail);
-        };
-        DLL.prototype.toArray = function () {
-          var arr = Array(this.length);
-          var curr = this.head;
-          for (var idx = 0; idx < this.length; idx++) {
-            arr[idx] = curr.data;
-            curr = curr.next;
-          }
-          return arr;
-        };
-        DLL.prototype.remove = function (testFn) {
-          var curr = this.head;
-          while (!!curr) {
-            var next = curr.next;
-            if (testFn(curr)) {
-              this.removeLink(curr);
-            }
-            curr = next;
-          }
-          return this;
-        };
-        function queue(worker, concurrency, payload) {
+        function queue$1(worker, concurrency, payload) {
           if (concurrency == null) {
             concurrency = 1;
           } else if (concurrency === 0) {
-            throw new Error("Concurrency must not be zero");
+            throw new RangeError("Concurrency must not be zero");
           }
           var _worker = wrapAsync(worker);
           var numRunning = 0;
           var workersList = [];
+          const events = {
+            error: [],
+            drain: [],
+            saturated: [],
+            unsaturated: [],
+            empty: [],
+          };
+          function on(event, handler) {
+            events[event].push(handler);
+          }
+          function once(event, handler) {
+            const handleAndRemove = (...args) => {
+              off(event, handleAndRemove);
+              handler(...args);
+            };
+            events[event].push(handleAndRemove);
+          }
+          function off(event, handler) {
+            if (!event)
+              return Object.keys(events).forEach((ev) => (events[ev] = []));
+            if (!handler) return (events[event] = []);
+            events[event] = events[event].filter((ev) => ev !== handler);
+          }
+          function trigger(event, ...args) {
+            events[event].forEach((handler) => handler(...args));
+          }
           var processingScheduled = false;
-          function _insert(data, insertAtFront, callback) {
+          function _insert(data, insertAtFront, rejectOnError, callback) {
             if (callback != null && typeof callback !== "function") {
               throw new Error("task callback must be a function");
             }
             q.started = true;
-            if (!isArray(data)) {
-              data = [data];
-            }
-            if (data.length === 0 && q.idle()) {
-              return setImmediate$1(function () {
-                q.drain();
-              });
+            var res, rej;
+            function promiseCallback(err, ...args) {
+              if (err) return rejectOnError ? rej(err) : res();
+              if (args.length <= 1) return res(args[0]);
+              res(args);
             }
-            for (var i = 0, l = data.length; i < l; i++) {
-              var item = { data: data[i], callback: callback || noop };
-              if (insertAtFront) {
-                q._tasks.unshift(item);
-              } else {
-                q._tasks.push(item);
-              }
+            var item = q._createTaskItem(
+              data,
+              rejectOnError ? promiseCallback : callback || promiseCallback,
+            );
+            if (insertAtFront) {
+              q._tasks.unshift(item);
+            } else {
+              q._tasks.push(item);
             }
             if (!processingScheduled) {
               processingScheduled = true;
-              setImmediate$1(function () {
+              setImmediate$1(() => {
                 processingScheduled = false;
                 q.process();
               });
             }
+            if (rejectOnError || !callback) {
+              return new Promise((resolve, reject) => {
+                res = resolve;
+                rej = reject;
+              });
+            }
           }
-          function _next(tasks) {
-            return function (err) {
+          function _createCB(tasks) {
+            return function (err, ...args) {
               numRunning -= 1;
               for (var i = 0, l = tasks.length; i < l; i++) {
                 var task = tasks[i];
-                var index = baseIndexOf(workersList, task, 0);
+                var index = workersList.indexOf(task);
                 if (index === 0) {
                   workersList.shift();
                 } else if (index > 0) {
                   workersList.splice(index, 1);
                 }
-                task.callback.apply(task, arguments);
+                task.callback(err, ...args);
                 if (err != null) {
-                  q.error(err, task.data);
+                  trigger("error", err, task.data);
                 }
               }
               if (numRunning <= q.concurrency - q.buffer) {
-                q.unsaturated();
+                trigger("unsaturated");
               }
               if (q.idle()) {
-                q.drain();
+                trigger("drain");
               }
               q.process();
             };
           }
+          function _maybeDrain(data) {
+            if (data.length === 0 && q.idle()) {
+              setImmediate$1(() => trigger("drain"));
+              return true;
+            }
+            return false;
+          }
+          const eventMethod = (name) => (handler) => {
+            if (!handler) {
+              return new Promise((resolve, reject) => {
+                once(name, (err, data) => {
+                  if (err) return reject(err);
+                  resolve(data);
+                });
+              });
+            }
+            off(name);
+            on(name, handler);
+          };
           var isProcessing = false;
           var q = {
             _tasks: new DLL(),
+            _createTaskItem(data, callback) {
+              return { data, callback };
+            },
+            *[Symbol.iterator]() {
+              yield* q._tasks[Symbol.iterator]();
+            },
             concurrency,
             payload,
-            saturated: noop,
-            unsaturated: noop,
             buffer: concurrency / 4,
-            empty: noop,
-            drain: noop,
-            error: noop,
             started: false,
             paused: false,
-            push: function (data, callback) {
-              _insert(data, false, callback);
+            push(data, callback) {
+              if (Array.isArray(data)) {
+                if (_maybeDrain(data)) return;
+                return data.map((datum) =>
+                  _insert(datum, false, false, callback),
+                );
+              }
+              return _insert(data, false, false, callback);
+            },
+            pushAsync(data, callback) {
+              if (Array.isArray(data)) {
+                if (_maybeDrain(data)) return;
+                return data.map((datum) =>
+                  _insert(datum, false, true, callback),
+                );
+              }
+              return _insert(data, false, true, callback);
             },
-            kill: function () {
-              q.drain = noop;
+            kill() {
+              off();
               q._tasks.empty();
             },
-            unshift: function (data, callback) {
-              _insert(data, true, callback);
+            unshift(data, callback) {
+              if (Array.isArray(data)) {
+                if (_maybeDrain(data)) return;
+                return data.map((datum) =>
+                  _insert(datum, true, false, callback),
+                );
+              }
+              return _insert(data, true, false, callback);
+            },
+            unshiftAsync(data, callback) {
+              if (Array.isArray(data)) {
+                if (_maybeDrain(data)) return;
+                return data.map((datum) =>
+                  _insert(datum, true, true, callback),
+                );
+              }
+              return _insert(data, true, true, callback);
             },
-            remove: function (testFn) {
+            remove(testFn) {
               q._tasks.remove(testFn);
             },
-            process: function () {
+            process() {
               if (isProcessing) {
                 return;
               }
@@ -1158,32 +886,32 @@
                 }
                 numRunning += 1;
                 if (q._tasks.length === 0) {
-                  q.empty();
+                  trigger("empty");
                 }
                 if (numRunning === q.concurrency) {
-                  q.saturated();
+                  trigger("saturated");
                 }
-                var cb = onlyOnce(_next(tasks));
+                var cb = onlyOnce(_createCB(tasks));
                 _worker(data, cb);
               }
               isProcessing = false;
             },
-            length: function () {
+            length() {
               return q._tasks.length;
             },
-            running: function () {
+            running() {
               return numRunning;
             },
-            workersList: function () {
+            workersList() {
               return workersList;
             },
-            idle: function () {
+            idle() {
               return q._tasks.length + numRunning === 0;
             },
-            pause: function () {
+            pause() {
               q.paused = true;
             },
-            resume: function () {
+            resume() {
               if (q.paused === false) {
                 return;
               }
@@ -1191,264 +919,265 @@
               setImmediate$1(q.process);
             },
           };
+          Object.defineProperties(q, {
+            saturated: { writable: false, value: eventMethod("saturated") },
+            unsaturated: { writable: false, value: eventMethod("unsaturated") },
+            empty: { writable: false, value: eventMethod("empty") },
+            drain: { writable: false, value: eventMethod("drain") },
+            error: { writable: false, value: eventMethod("error") },
+          });
           return q;
         }
-        function cargo(worker, payload) {
-          return queue(worker, 1, payload);
+        function cargo$1(worker, payload) {
+          return queue$1(worker, 1, payload);
+        }
+        function cargo(worker, concurrency, payload) {
+          return queue$1(worker, concurrency, payload);
         }
-        var eachOfSeries = doLimit(eachOfLimit, 1);
         function reduce(coll, memo, iteratee, callback) {
-          callback = once(callback || noop);
+          callback = once(callback);
           var _iteratee = wrapAsync(iteratee);
-          eachOfSeries(
+          return eachOfSeries$1(
             coll,
-            function (x, i, callback) {
-              _iteratee(memo, x, function (err, v) {
+            (x, i, iterCb) => {
+              _iteratee(memo, x, (err, v) => {
                 memo = v;
-                callback(err);
+                iterCb(err);
               });
             },
-            function (err) {
-              callback(err, memo);
-            },
+            (err) => callback(err, memo),
           );
         }
-        function seq() {
-          var _functions = arrayMap(arguments, wrapAsync);
-          return function () {
-            var args = slice(arguments);
+        var reduce$1 = awaitify(reduce, 4);
+        function seq(...functions) {
+          var _functions = functions.map(wrapAsync);
+          return function (...args) {
             var that = this;
             var cb = args[args.length - 1];
             if (typeof cb == "function") {
               args.pop();
             } else {
-              cb = noop;
+              cb = promiseCallback();
             }
-            reduce(
+            reduce$1(
               _functions,
               args,
-              function (newargs, fn, cb) {
+              (newargs, fn, iterCb) => {
                 fn.apply(
                   that,
-                  newargs.concat(function (err) {
-                    var nextargs = slice(arguments, 1);
-                    cb(err, nextargs);
+                  newargs.concat((err, ...nextargs) => {
+                    iterCb(err, nextargs);
                   }),
                 );
               },
-              function (err, results) {
-                cb.apply(that, [err].concat(results));
-              },
+              (err, results) => cb(err, ...results),
             );
+            return cb[PROMISE_SYMBOL];
           };
         }
-        var compose = function () {
-          return seq.apply(null, slice(arguments).reverse());
-        };
-        var _concat = Array.prototype.concat;
-        var concatLimit = function (coll, limit, iteratee, callback) {
-          callback = callback || noop;
+        function compose(...args) {
+          return seq(...args.reverse());
+        }
+        function mapLimit(coll, limit, iteratee, callback) {
+          return _asyncMap(eachOfLimit$2(limit), coll, iteratee, callback);
+        }
+        var mapLimit$1 = awaitify(mapLimit, 4);
+        function concatLimit(coll, limit, iteratee, callback) {
           var _iteratee = wrapAsync(iteratee);
-          mapLimit(
+          return mapLimit$1(
             coll,
             limit,
-            function (val, callback) {
-              _iteratee(val, function (err) {
-                if (err) return callback(err);
-                return callback(null, slice(arguments, 1));
+            (val, iterCb) => {
+              _iteratee(val, (err, ...args) => {
+                if (err) return iterCb(err);
+                return iterCb(err, args);
               });
             },
-            function (err, mapResults) {
+            (err, mapResults) => {
               var result = [];
               for (var i = 0; i < mapResults.length; i++) {
                 if (mapResults[i]) {
-                  result = _concat.apply(result, mapResults[i]);
+                  result = result.concat(...mapResults[i]);
                 }
               }
               return callback(err, result);
             },
-          );
-        };
-        var concat = doLimit(concatLimit, Infinity);
-        var concatSeries = doLimit(concatLimit, 1);
-        var constant = function () {
-          var values = slice(arguments);
-          var args = [null].concat(values);
-          return function () {
-            var callback = arguments[arguments.length - 1];
-            return callback.apply(this, args);
+          );
+        }
+        var concatLimit$1 = awaitify(concatLimit, 4);
+        function concat(coll, iteratee, callback) {
+          return concatLimit$1(coll, Infinity, iteratee, callback);
+        }
+        var concat$1 = awaitify(concat, 3);
+        function concatSeries(coll, iteratee, callback) {
+          return concatLimit$1(coll, 1, iteratee, callback);
+        }
+        var concatSeries$1 = awaitify(concatSeries, 3);
+        function constant$1(...args) {
+          return function (...ignoredArgs) {
+            var callback = ignoredArgs.pop();
+            return callback(null, ...args);
           };
-        };
-        function identity(value) {
-          return value;
         }
         function _createTester(check, getResult) {
-          return function (eachfn, arr, iteratee, cb) {
-            cb = cb || noop;
+          return (eachfn, arr, _iteratee, cb) => {
             var testPassed = false;
             var testResult;
+            const iteratee = wrapAsync(_iteratee);
             eachfn(
               arr,
-              function (value, _, callback) {
-                iteratee(value, function (err, result) {
-                  if (err) {
-                    callback(err);
-                  } else if (check(result) && !testResult) {
+              (value, _, callback) => {
+                iteratee(value, (err, result) => {
+                  if (err || err === false) return callback(err);
+                  if (check(result) && !testResult) {
                     testPassed = true;
                     testResult = getResult(true, value);
-                    callback(null, breakLoop);
-                  } else {
-                    callback();
+                    return callback(null, breakLoop);
                   }
+                  callback();
                 });
               },
-              function (err) {
-                if (err) {
-                  cb(err);
-                } else {
-                  cb(null, testPassed ? testResult : getResult(false));
-                }
+              (err) => {
+                if (err) return cb(err);
+                cb(null, testPassed ? testResult : getResult(false));
               },
             );
           };
         }
-        function _findGetResult(v, x) {
-          return x;
-        }
-        var detect = doParallel(_createTester(identity, _findGetResult));
-        var detectLimit = doParallelLimit(
-          _createTester(identity, _findGetResult),
-        );
-        var detectSeries = doLimit(detectLimit, 1);
+        function detect(coll, iteratee, callback) {
+          return _createTester(
+            (bool) => bool,
+            (res, item) => item,
+          )(eachOf$1, coll, iteratee, callback);
+        }
+        var detect$1 = awaitify(detect, 3);
+        function detectLimit(coll, limit, iteratee, callback) {
+          return _createTester(
+            (bool) => bool,
+            (res, item) => item,
+          )(eachOfLimit$2(limit), coll, iteratee, callback);
+        }
+        var detectLimit$1 = awaitify(detectLimit, 4);
+        function detectSeries(coll, iteratee, callback) {
+          return _createTester(
+            (bool) => bool,
+            (res, item) => item,
+          )(eachOfLimit$2(1), coll, iteratee, callback);
+        }
+        var detectSeries$1 = awaitify(detectSeries, 3);
         function consoleFunc(name) {
-          return function (fn) {
-            var args = slice(arguments, 1);
-            args.push(function (err) {
-              var args = slice(arguments, 1);
+          return (fn, ...args) =>
+            wrapAsync(fn)(...args, (err, ...resultArgs) => {
               if (typeof console === "object") {
                 if (err) {
                   if (console.error) {
                     console.error(err);
                   }
                 } else if (console[name]) {
-                  arrayEach(args, function (x) {
-                    console[name](x);
-                  });
+                  resultArgs.forEach((x) => console[name](x));
                 }
               }
             });
-            wrapAsync(fn).apply(null, args);
-          };
         }
         var dir = consoleFunc("dir");
-        function doDuring(fn, test, callback) {
-          callback = onlyOnce(callback || noop);
-          var _fn = wrapAsync(fn);
+        function doWhilst(iteratee, test, callback) {
+          callback = onlyOnce(callback);
+          var _fn = wrapAsync(iteratee);
           var _test = wrapAsync(test);
-          function next(err) {
+          var results;
+          function next(err, ...args) {
             if (err) return callback(err);
-            var args = slice(arguments, 1);
-            args.push(check);
-            _test.apply(this, args);
+            if (err === false) return;
+            results = args;
+            _test(...args, check);
           }
           function check(err, truth) {
             if (err) return callback(err);
-            if (!truth) return callback(null);
+            if (err === false) return;
+            if (!truth) return callback(null, ...results);
             _fn(next);
           }
-          check(null, true);
-        }
-        function doWhilst(iteratee, test, callback) {
-          callback = onlyOnce(callback || noop);
-          var _iteratee = wrapAsync(iteratee);
-          var next = function (err) {
-            if (err) return callback(err);
-            var args = slice(arguments, 1);
-            if (test.apply(this, args)) return _iteratee(next);
-            callback.apply(null, [null].concat(args));
-          };
-          _iteratee(next);
+          return check(null, true);
         }
+        var doWhilst$1 = awaitify(doWhilst, 3);
         function doUntil(iteratee, test, callback) {
-          doWhilst(
+          const _test = wrapAsync(test);
+          return doWhilst$1(
             iteratee,
-            function () {
-              return !test.apply(this, arguments);
+            (...args) => {
+              const cb = args.pop();
+              _test(...args, (err, truth) => cb(err, !truth));
             },
             callback,
           );
         }
-        function during(test, fn, callback) {
-          callback = onlyOnce(callback || noop);
-          var _fn = wrapAsync(fn);
-          var _test = wrapAsync(test);
-          function next(err) {
-            if (err) return callback(err);
-            _test(check);
-          }
-          function check(err, truth) {
-            if (err) return callback(err);
-            if (!truth) return callback(null);
-            _fn(next);
-          }
-          _test(check);
-        }
         function _withoutIndex(iteratee) {
-          return function (value, index, callback) {
-            return iteratee(value, callback);
-          };
+          return (value, index, callback) => iteratee(value, callback);
         }
-        function eachLimit(coll, iteratee, callback) {
-          eachOf(coll, _withoutIndex(wrapAsync(iteratee)), callback);
+        function eachLimit$2(coll, iteratee, callback) {
+          return eachOf$1(coll, _withoutIndex(wrapAsync(iteratee)), callback);
         }
-        function eachLimit$1(coll, limit, iteratee, callback) {
-          _eachOfLimit(limit)(
+        var each = awaitify(eachLimit$2, 3);
+        function eachLimit(coll, limit, iteratee, callback) {
+          return eachOfLimit$2(limit)(
             coll,
             _withoutIndex(wrapAsync(iteratee)),
             callback,
           );
         }
-        var eachSeries = doLimit(eachLimit$1, 1);
+        var eachLimit$1 = awaitify(eachLimit, 4);
+        function eachSeries(coll, iteratee, callback) {
+          return eachLimit$1(coll, 1, iteratee, callback);
+        }
+        var eachSeries$1 = awaitify(eachSeries, 3);
         function ensureAsync(fn) {
           if (isAsync(fn)) return fn;
-          return initialParams(function (args, callback) {
+          return function (...args) {
+            var callback = args.pop();
             var sync = true;
-            args.push(function () {
-              var innerArgs = arguments;
+            args.push((...innerArgs) => {
               if (sync) {
-                setImmediate$1(function () {
-                  callback.apply(null, innerArgs);
-                });
+                setImmediate$1(() => callback(...innerArgs));
               } else {
-                callback.apply(null, innerArgs);
+                callback(...innerArgs);
               }
             });
             fn.apply(this, args);
             sync = false;
-          });
-        }
-        function notId(v) {
-          return !v;
-        }
-        var every = doParallel(_createTester(notId, notId));
-        var everyLimit = doParallelLimit(_createTester(notId, notId));
-        var everySeries = doLimit(everyLimit, 1);
-        function baseProperty(key) {
-          return function (object) {
-            return object == null ? undefined : object[key];
           };
         }
+        function every(coll, iteratee, callback) {
+          return _createTester(
+            (bool) => !bool,
+            (res) => !res,
+          )(eachOf$1, coll, iteratee, callback);
+        }
+        var every$1 = awaitify(every, 3);
+        function everyLimit(coll, limit, iteratee, callback) {
+          return _createTester(
+            (bool) => !bool,
+            (res) => !res,
+          )(eachOfLimit$2(limit), coll, iteratee, callback);
+        }
+        var everyLimit$1 = awaitify(everyLimit, 4);
+        function everySeries(coll, iteratee, callback) {
+          return _createTester(
+            (bool) => !bool,
+            (res) => !res,
+          )(eachOfSeries$1, coll, iteratee, callback);
+        }
+        var everySeries$1 = awaitify(everySeries, 3);
         function filterArray(eachfn, arr, iteratee, callback) {
           var truthValues = new Array(arr.length);
           eachfn(
             arr,
-            function (x, index, callback) {
-              iteratee(x, function (err, v) {
+            (x, index, iterCb) => {
+              iteratee(x, (err, v) => {
                 truthValues[index] = !!v;
-                callback(err);
+                iterCb(err);
               });
             },
-            function (err) {
+            (err) => {
               if (err) return callback(err);
               var results = [];
               for (var i = 0; i < arr.length; i++) {
@@ -1462,70 +1191,69 @@
           var results = [];
           eachfn(
             coll,
-            function (x, index, callback) {
-              iteratee(x, function (err, v) {
-                if (err) {
-                  callback(err);
-                } else {
-                  if (v) {
-                    results.push({ index, value: x });
-                  }
-                  callback();
+            (x, index, iterCb) => {
+              iteratee(x, (err, v) => {
+                if (err) return iterCb(err);
+                if (v) {
+                  results.push({ index, value: x });
                 }
+                iterCb(err);
               });
             },
-            function (err) {
-              if (err) {
-                callback(err);
-              } else {
-                callback(
-                  null,
-                  arrayMap(
-                    results.sort(function (a, b) {
-                      return a.index - b.index;
-                    }),
-                    baseProperty("value"),
-                  ),
-                );
-              }
+            (err) => {
+              if (err) return callback(err);
+              callback(
+                null,
+                results.sort((a, b) => a.index - b.index).map((v) => v.value),
+              );
             },
           );
         }
         function _filter(eachfn, coll, iteratee, callback) {
           var filter = isArrayLike(coll) ? filterArray : filterGeneric;
-          filter(eachfn, coll, wrapAsync(iteratee), callback || noop);
+          return filter(eachfn, coll, wrapAsync(iteratee), callback);
+        }
+        function filter(coll, iteratee, callback) {
+          return _filter(eachOf$1, coll, iteratee, callback);
         }
-        var filter = doParallel(_filter);
-        var filterLimit = doParallelLimit(_filter);
-        var filterSeries = doLimit(filterLimit, 1);
+        var filter$1 = awaitify(filter, 3);
+        function filterLimit(coll, limit, iteratee, callback) {
+          return _filter(eachOfLimit$2(limit), coll, iteratee, callback);
+        }
+        var filterLimit$1 = awaitify(filterLimit, 4);
+        function filterSeries(coll, iteratee, callback) {
+          return _filter(eachOfSeries$1, coll, iteratee, callback);
+        }
+        var filterSeries$1 = awaitify(filterSeries, 3);
         function forever(fn, errback) {
-          var done = onlyOnce(errback || noop);
+          var done = onlyOnce(errback);
           var task = wrapAsync(ensureAsync(fn));
           function next(err) {
             if (err) return done(err);
+            if (err === false) return;
             task(next);
           }
-          next();
+          return next();
         }
-        var groupByLimit = function (coll, limit, iteratee, callback) {
-          callback = callback || noop;
+        var forever$1 = awaitify(forever, 2);
+        function groupByLimit(coll, limit, iteratee, callback) {
           var _iteratee = wrapAsync(iteratee);
-          mapLimit(
+          return mapLimit$1(
             coll,
             limit,
-            function (val, callback) {
-              _iteratee(val, function (err, key) {
-                if (err) return callback(err);
-                return callback(null, { key, val });
+            (val, iterCb) => {
+              _iteratee(val, (err, key) => {
+                if (err) return iterCb(err);
+                return iterCb(err, { key, val });
               });
             },
-            function (err, mapResults) {
+            (err, mapResults) => {
               var result = {};
-              var hasOwnProperty = Object.prototype.hasOwnProperty;
+              var { hasOwnProperty } = Object.prototype;
               for (var i = 0; i < mapResults.length; i++) {
                 if (mapResults[i]) {
-                  var key = mapResults[i].key;
-                  var val = mapResults[i].val;
+                  var { key } = mapResults[i];
+                  var { val } = mapResults[i];
                   if (hasOwnProperty.call(result, key)) {
                     result[key].push(val);
                   } else {
@@ -1536,148 +1264,228 @@
               return callback(err, result);
             },
           );
-        };
-        var groupBy = doLimit(groupByLimit, Infinity);
-        var groupBySeries = doLimit(groupByLimit, 1);
+        }
+        var groupByLimit$1 = awaitify(groupByLimit, 4);
+        function groupBy(coll, iteratee, callback) {
+          return groupByLimit$1(coll, Infinity, iteratee, callback);
+        }
+        function groupBySeries(coll, iteratee, callback) {
+          return groupByLimit$1(coll, 1, iteratee, callback);
+        }
         var log = consoleFunc("log");
         function mapValuesLimit(obj, limit, iteratee, callback) {
-          callback = once(callback || noop);
+          callback = once(callback);
           var newObj = {};
           var _iteratee = wrapAsync(iteratee);
-          eachOfLimit(
+          return eachOfLimit$2(limit)(
             obj,
-            limit,
-            function (val, key, next) {
-              _iteratee(val, key, function (err, result) {
+            (val, key, next) => {
+              _iteratee(val, key, (err, result) => {
                 if (err) return next(err);
                 newObj[key] = result;
-                next();
+                next(err);
               });
             },
-            function (err) {
-              callback(err, newObj);
-            },
+            (err) => callback(err, newObj),
           );
         }
-        var mapValues = doLimit(mapValuesLimit, Infinity);
-        var mapValuesSeries = doLimit(mapValuesLimit, 1);
-        function has(obj, key) {
-          return key in obj;
+        var mapValuesLimit$1 = awaitify(mapValuesLimit, 4);
+        function mapValues(obj, iteratee, callback) {
+          return mapValuesLimit$1(obj, Infinity, iteratee, callback);
         }
-        function memoize(fn, hasher) {
+        function mapValuesSeries(obj, iteratee, callback) {
+          return mapValuesLimit$1(obj, 1, iteratee, callback);
+        }
+        function memoize(fn, hasher = (v) => v) {
           var memo = Object.create(null);
           var queues = Object.create(null);
-          hasher = hasher || identity;
           var _fn = wrapAsync(fn);
-          var memoized = initialParams(function memoized(args, callback) {
-            var key = hasher.apply(null, args);
-            if (has(memo, key)) {
-              setImmediate$1(function () {
-                callback.apply(null, memo[key]);
-              });
-            } else if (has(queues, key)) {
+          var memoized = initialParams((args, callback) => {
+            var key = hasher(...args);
+            if (key in memo) {
+              setImmediate$1(() => callback(null, ...memo[key]));
+            } else if (key in queues) {
               queues[key].push(callback);
             } else {
               queues[key] = [callback];
-              _fn.apply(
-                null,
-                args.concat(function () {
-                  var args = slice(arguments);
-                  memo[key] = args;
-                  var q = queues[key];
-                  delete queues[key];
-                  for (var i = 0, l = q.length; i < l; i++) {
-                    q[i].apply(null, args);
-                  }
-                }),
-              );
+              _fn(...args, (err, ...resultArgs) => {
+                if (!err) {
+                  memo[key] = resultArgs;
+                }
+                var q = queues[key];
+                delete queues[key];
+                for (var i = 0, l = q.length; i < l; i++) {
+                  q[i](err, ...resultArgs);
+                }
+              });
             }
           });
           memoized.memo = memo;
           memoized.unmemoized = fn;
           return memoized;
         }
-        var _defer$1;
+        var _defer;
         if (hasNextTick) {
-          _defer$1 = process.nextTick;
+          _defer = process.nextTick;
         } else if (hasSetImmediate) {
-          _defer$1 = setImmediate;
+          _defer = setImmediate;
         } else {
-          _defer$1 = fallback;
+          _defer = fallback;
         }
-        var nextTick = wrap(_defer$1);
-        function _parallel(eachfn, tasks, callback) {
-          callback = callback || noop;
+        var nextTick = wrap(_defer);
+        var _parallel = awaitify((eachfn, tasks, callback) => {
           var results = isArrayLike(tasks) ? [] : {};
           eachfn(
             tasks,
-            function (task, key, callback) {
-              wrapAsync(task)(function (err, result) {
-                if (arguments.length > 2) {
-                  result = slice(arguments, 1);
+            (task, key, taskCb) => {
+              wrapAsync(task)((err, ...result) => {
+                if (result.length < 2) {
+                  [result] = result;
                 }
                 results[key] = result;
-                callback(err);
+                taskCb(err);
               });
             },
-            function (err) {
-              callback(err, results);
-            },
+            (err) => callback(err, results),
           );
+        }, 3);
+        function parallel(tasks, callback) {
+          return _parallel(eachOf$1, tasks, callback);
         }
-        function parallelLimit(tasks, callback) {
-          _parallel(eachOf, tasks, callback);
-        }
-        function parallelLimit$1(tasks, limit, callback) {
-          _parallel(_eachOfLimit(limit), tasks, callback);
+        function parallelLimit(tasks, limit, callback) {
+          return _parallel(eachOfLimit$2(limit), tasks, callback);
         }
-        var queue$1 = function (worker, concurrency) {
+        function queue(worker, concurrency) {
           var _worker = wrapAsync(worker);
-          return queue(
-            function (items, cb) {
+          return queue$1(
+            (items, cb) => {
               _worker(items[0], cb);
             },
             concurrency,
             1,
           );
-        };
-        var priorityQueue = function (worker, concurrency) {
-          var q = queue$1(worker, concurrency);
-          q.push = function (data, priority, callback) {
-            if (callback == null) callback = noop;
-            if (typeof callback !== "function") {
-              throw new Error("task callback must be a function");
-            }
-            q.started = true;
-            if (!isArray(data)) {
-              data = [data];
+        }
+        class Heap {
+          constructor() {
+            this.heap = [];
+            this.pushCount = Number.MIN_SAFE_INTEGER;
+          }
+          get length() {
+            return this.heap.length;
+          }
+          empty() {
+            this.heap = [];
+            return this;
+          }
+          percUp(index) {
+            let p;
+            while (
+              index > 0 &&
+              smaller(this.heap[index], this.heap[(p = parent(index))])
+            ) {
+              let t = this.heap[index];
+              this.heap[index] = this.heap[p];
+              this.heap[p] = t;
+              index = p;
             }
-            if (data.length === 0) {
-              return setImmediate$1(function () {
-                q.drain();
-              });
+          }
+          percDown(index) {
+            let l;
+            while ((l = leftChi(index)) < this.heap.length) {
+              if (
+                l + 1 < this.heap.length &&
+                smaller(this.heap[l + 1], this.heap[l])
+              ) {
+                l = l + 1;
+              }
+              if (smaller(this.heap[index], this.heap[l])) {
+                break;
+              }
+              let t = this.heap[index];
+              this.heap[index] = this.heap[l];
+              this.heap[l] = t;
+              index = l;
             }
-            priority = priority || 0;
-            var nextNode = q._tasks.head;
-            while (nextNode && priority >= nextNode.priority) {
-              nextNode = nextNode.next;
+          }
+          push(node) {
+            node.pushCount = ++this.pushCount;
+            this.heap.push(node);
+            this.percUp(this.heap.length - 1);
+          }
+          unshift(node) {
+            return this.heap.push(node);
+          }
+          shift() {
+            let [top] = this.heap;
+            this.heap[0] = this.heap[this.heap.length - 1];
+            this.heap.pop();
+            this.percDown(0);
+            return top;
+          }
+          toArray() {
+            return [...this];
+          }
+          *[Symbol.iterator]() {
+            for (let i = 0; i < this.heap.length; i++) {
+              yield this.heap[i].data;
             }
-            for (var i = 0, l = data.length; i < l; i++) {
-              var item = { data: data[i], priority, callback };
-              if (nextNode) {
-                q._tasks.insertBefore(nextNode, item);
-              } else {
-                q._tasks.push(item);
+          }
+          remove(testFn) {
+            let j = 0;
+            for (let i = 0; i < this.heap.length; i++) {
+              if (!testFn(this.heap[i])) {
+                this.heap[j] = this.heap[i];
+                j++;
               }
             }
-            setImmediate$1(q.process);
+            this.heap.splice(j);
+            for (let i = parent(this.heap.length - 1); i >= 0; i--) {
+              this.percDown(i);
+            }
+            return this;
+          }
+        }
+        function leftChi(i) {
+          return (i << 1) + 1;
+        }
+        function parent(i) {
+          return ((i + 1) >> 1) - 1;
+        }
+        function smaller(x, y) {
+          if (x.priority !== y.priority) {
+            return x.priority < y.priority;
+          } else {
+            return x.pushCount < y.pushCount;
+          }
+        }
+        function priorityQueue(worker, concurrency) {
+          var q = queue(worker, concurrency);
+          var { push, pushAsync } = q;
+          q._tasks = new Heap();
+          q._createTaskItem = ({ data, priority }, callback) => ({
+            data,
+            priority,
+            callback,
+          });
+          function createDataItems(tasks, priority) {
+            if (!Array.isArray(tasks)) {
+              return { data: tasks, priority };
+            }
+            return tasks.map((data) => ({ data, priority }));
+          }
+          q.push = function (data, priority = 0, callback) {
+            return push(createDataItems(data, priority), callback);
+          };
+          q.pushAsync = function (data, priority = 0, callback) {
+            return pushAsync(createDataItems(data, priority), callback);
           };
           delete q.unshift;
+          delete q.unshiftAsync;
           return q;
-        };
+        }
         function race(tasks, callback) {
-          callback = once(callback || noop);
-          if (!isArray(tasks))
+          callback = once(callback);
+          if (!Array.isArray(tasks))
             return callback(
               new TypeError(
                 "First argument to race must be an array of functions",
@@ -1688,88 +1496,86 @@
             wrapAsync(tasks[i])(callback);
           }
         }
+        var race$1 = awaitify(race, 2);
         function reduceRight(array, memo, iteratee, callback) {
-          var reversed = slice(array).reverse();
-          reduce(reversed, memo, iteratee, callback);
+          var reversed = [...array].reverse();
+          return reduce$1(reversed, memo, iteratee, callback);
         }
         function reflect(fn) {
           var _fn = wrapAsync(fn);
           return initialParams(function reflectOn(args, reflectCallback) {
-            args.push(function callback(error, cbArg) {
+            args.push((error, ...cbArgs) => {
+              let retVal = {};
               if (error) {
-                reflectCallback(null, { error });
-              } else {
-                var value;
-                if (arguments.length <= 2) {
-                  value = cbArg;
-                } else {
-                  value = slice(arguments, 1);
+                retVal.error = error;
+              }
+              if (cbArgs.length > 0) {
+                var value = cbArgs;
+                if (cbArgs.length <= 1) {
+                  [value] = cbArgs;
                 }
-                reflectCallback(null, { value });
+                retVal.value = value;
               }
+              reflectCallback(null, retVal);
             });
             return _fn.apply(this, args);
           });
         }
         function reflectAll(tasks) {
           var results;
-          if (isArray(tasks)) {
-            results = arrayMap(tasks, reflect);
+          if (Array.isArray(tasks)) {
+            results = tasks.map(reflect);
           } else {
             results = {};
-            baseForOwn(tasks, function (task, key) {
-              results[key] = reflect.call(this, task);
+            Object.keys(tasks).forEach((key) => {
+              results[key] = reflect.call(this, tasks[key]);
             });
           }
           return results;
         }
-        function reject$1(eachfn, arr, iteratee, callback) {
-          _filter(
+        function reject$2(eachfn, arr, _iteratee, callback) {
+          const iteratee = wrapAsync(_iteratee);
+          return _filter(
             eachfn,
             arr,
-            function (value, cb) {
-              iteratee(value, function (err, v) {
+            (value, cb) => {
+              iteratee(value, (err, v) => {
                 cb(err, !v);
               });
             },
             callback,
           );
         }
-        var reject = doParallel(reject$1);
-        var rejectLimit = doParallelLimit(reject$1);
-        var rejectSeries = doLimit(rejectLimit, 1);
-        function constant$1(value) {
+        function reject(coll, iteratee, callback) {
+          return reject$2(eachOf$1, coll, iteratee, callback);
+        }
+        var reject$1 = awaitify(reject, 3);
+        function rejectLimit(coll, limit, iteratee, callback) {
+          return reject$2(eachOfLimit$2(limit), coll, iteratee, callback);
+        }
+        var rejectLimit$1 = awaitify(rejectLimit, 4);
+        function rejectSeries(coll, iteratee, callback) {
+          return reject$2(eachOfSeries$1, coll, iteratee, callback);
+        }
+        var rejectSeries$1 = awaitify(rejectSeries, 3);
+        function constant(value) {
           return function () {
             return value;
           };
         }
+        const DEFAULT_TIMES = 5;
+        const DEFAULT_INTERVAL = 0;
         function retry(opts, task, callback) {
-          var DEFAULT_TIMES = 5;
-          var DEFAULT_INTERVAL = 0;
           var options = {
             times: DEFAULT_TIMES,
-            intervalFunc: constant$1(DEFAULT_INTERVAL),
+            intervalFunc: constant(DEFAULT_INTERVAL),
           };
-          function parseTimes(acc, t) {
-            if (typeof t === "object") {
-              acc.times = +t.times || DEFAULT_TIMES;
-              acc.intervalFunc =
-                typeof t.interval === "function"
-                  ? t.interval
-                  : constant$1(+t.interval || DEFAULT_INTERVAL);
-              acc.errorFilter = t.errorFilter;
-            } else if (typeof t === "number" || typeof t === "string") {
-              acc.times = +t || DEFAULT_TIMES;
-            } else {
-              throw new Error("Invalid arguments for async.retry");
-            }
-          }
           if (arguments.length < 3 && typeof opts === "function") {
-            callback = task || noop;
+            callback = task || promiseCallback();
             task = opts;
           } else {
             parseTimes(options, opts);
-            callback = callback || noop;
+            callback = callback || promiseCallback();
           }
           if (typeof task !== "function") {
             throw new Error("Invalid arguments for async.retry");
@@ -1777,56 +1583,105 @@
           var _task = wrapAsync(task);
           var attempt = 1;
           function retryAttempt() {
-            _task(function (err) {
+            _task((err, ...args) => {
+              if (err === false) return;
               if (
                 err &&
                 attempt++ < options.times &&
                 (typeof options.errorFilter != "function" ||
                   options.errorFilter(err))
               ) {
-                setTimeout(retryAttempt, options.intervalFunc(attempt));
+                setTimeout(retryAttempt, options.intervalFunc(attempt - 1));
               } else {
-                callback.apply(null, arguments);
+                callback(err, ...args);
               }
             });
           }
           retryAttempt();
+          return callback[PROMISE_SYMBOL];
+        }
+        function parseTimes(acc, t) {
+          if (typeof t === "object") {
+            acc.times = +t.times || DEFAULT_TIMES;
+            acc.intervalFunc =
+              typeof t.interval === "function"
+                ? t.interval
+                : constant(+t.interval || DEFAULT_INTERVAL);
+            acc.errorFilter = t.errorFilter;
+          } else if (typeof t === "number" || typeof t === "string") {
+            acc.times = +t || DEFAULT_TIMES;
+          } else {
+            throw new Error("Invalid arguments for async.retry");
+          }
         }
-        var retryable = function (opts, task) {
+        function retryable(opts, task) {
           if (!task) {
             task = opts;
             opts = null;
           }
+          let arity = (opts && opts.arity) || task.length;
+          if (isAsync(task)) {
+            arity += 1;
+          }
           var _task = wrapAsync(task);
-          return initialParams(function (args, callback) {
+          return initialParams((args, callback) => {
+            if (args.length < arity - 1 || callback == null) {
+              args.push(callback);
+              callback = promiseCallback();
+            }
             function taskFn(cb) {
-              _task.apply(null, args.concat(cb));
+              _task(...args, cb);
             }
             if (opts) retry(opts, taskFn, callback);
             else retry(taskFn, callback);
+            return callback[PROMISE_SYMBOL];
           });
-        };
+        }
         function series(tasks, callback) {
-          _parallel(eachOfSeries, tasks, callback);
+          return _parallel(eachOfSeries$1, tasks, callback);
+        }
+        function some(coll, iteratee, callback) {
+          return _createTester(Boolean, (res) => res)(
+            eachOf$1,
+            coll,
+            iteratee,
+            callback,
+          );
         }
-        var some = doParallel(_createTester(Boolean, identity));
-        var someLimit = doParallelLimit(_createTester(Boolean, identity));
-        var someSeries = doLimit(someLimit, 1);
+        var some$1 = awaitify(some, 3);
+        function someLimit(coll, limit, iteratee, callback) {
+          return _createTester(Boolean, (res) => res)(
+            eachOfLimit$2(limit),
+            coll,
+            iteratee,
+            callback,
+          );
+        }
+        var someLimit$1 = awaitify(someLimit, 4);
+        function someSeries(coll, iteratee, callback) {
+          return _createTester(Boolean, (res) => res)(
+            eachOfSeries$1,
+            coll,
+            iteratee,
+            callback,
+          );
+        }
+        var someSeries$1 = awaitify(someSeries, 3);
         function sortBy(coll, iteratee, callback) {
           var _iteratee = wrapAsync(iteratee);
-          map(
+          return map$1(
             coll,
-            function (x, callback) {
-              _iteratee(x, function (err, criteria) {
-                if (err) return callback(err);
-                callback(null, { value: x, criteria });
+            (x, iterCb) => {
+              _iteratee(x, (err, criteria) => {
+                if (err) return iterCb(err);
+                iterCb(err, { value: x, criteria });
               });
             },
-            function (err, results) {
+            (err, results) => {
               if (err) return callback(err);
               callback(
                 null,
-                arrayMap(results.sort(comparator), baseProperty("value")),
+                results.sort(comparator).map((v) => v.value),
               );
             },
           );
@@ -1836,9 +1691,10 @@
             return a < b ? -1 : a > b ? 1 : 0;
           }
         }
+        var sortBy$1 = awaitify(sortBy, 3);
         function timeout(asyncFn, milliseconds, info) {
           var fn = wrapAsync(asyncFn);
-          return initialParams(function (args, callback) {
+          return initialParams((args, callback) => {
             var timedOut = false;
             var timer;
             function timeoutCallback() {
@@ -1853,103 +1709,105 @@
               timedOut = true;
               callback(error);
             }
-            args.push(function () {
+            args.push((...cbArgs) => {
               if (!timedOut) {
-                callback.apply(null, arguments);
+                callback(...cbArgs);
                 clearTimeout(timer);
               }
             });
             timer = setTimeout(timeoutCallback, milliseconds);
-            fn.apply(null, args);
+            fn(...args);
           });
         }
-        var nativeCeil = Math.ceil;
-        var nativeMax = Math.max;
-        function baseRange(start, end, step, fromRight) {
-          var index = -1,
-            length = nativeMax(nativeCeil((end - start) / (step || 1)), 0),
-            result = Array(length);
-          while (length--) {
-            result[fromRight ? length : ++index] = start;
-            start += step;
+        function range(size) {
+          var result = Array(size);
+          while (size--) {
+            result[size] = size;
           }
           return result;
         }
-        function timeLimit(count, limit, iteratee, callback) {
+        function timesLimit(count, limit, iteratee, callback) {
           var _iteratee = wrapAsync(iteratee);
-          mapLimit(baseRange(0, count, 1), limit, _iteratee, callback);
+          return mapLimit$1(range(count), limit, _iteratee, callback);
+        }
+        function times(n, iteratee, callback) {
+          return timesLimit(n, Infinity, iteratee, callback);
+        }
+        function timesSeries(n, iteratee, callback) {
+          return timesLimit(n, 1, iteratee, callback);
         }
-        var times = doLimit(timeLimit, Infinity);
-        var timesSeries = doLimit(timeLimit, 1);
         function transform(coll, accumulator, iteratee, callback) {
-          if (arguments.length <= 3) {
+          if (arguments.length <= 3 && typeof accumulator === "function") {
             callback = iteratee;
             iteratee = accumulator;
-            accumulator = isArray(coll) ? [] : {};
+            accumulator = Array.isArray(coll) ? [] : {};
           }
-          callback = once(callback || noop);
+          callback = once(callback || promiseCallback());
           var _iteratee = wrapAsync(iteratee);
-          eachOf(
+          eachOf$1(
             coll,
-            function (v, k, cb) {
+            (v, k, cb) => {
               _iteratee(accumulator, v, k, cb);
             },
-            function (err) {
-              callback(err, accumulator);
-            },
+            (err) => callback(err, accumulator),
           );
+          return callback[PROMISE_SYMBOL];
         }
         function tryEach(tasks, callback) {
           var error = null;
           var result;
-          callback = callback || noop;
-          eachSeries(
+          return eachSeries$1(
             tasks,
-            function (task, callback) {
-              wrapAsync(task)(function (err, res) {
-                if (arguments.length > 2) {
-                  result = slice(arguments, 1);
+            (task, taskCb) => {
+              wrapAsync(task)((err, ...args) => {
+                if (err === false) return taskCb(err);
+                if (args.length < 2) {
+                  [result] = args;
                 } else {
-                  result = res;
+                  result = args;
                 }
                 error = err;
-                callback(!err);
+                taskCb(err ? null : {});
               });
             },
-            function () {
-              callback(error, result);
-            },
+            () => callback(error, result),
           );
         }
+        var tryEach$1 = awaitify(tryEach);
         function unmemoize(fn) {
-          return function () {
-            return (fn.unmemoized || fn).apply(null, arguments);
-          };
+          return (...args) => (fn.unmemoized || fn)(...args);
         }
         function whilst(test, iteratee, callback) {
-          callback = onlyOnce(callback || noop);
-          var _iteratee = wrapAsync(iteratee);
-          if (!test()) return callback(null);
-          var next = function (err) {
+          callback = onlyOnce(callback);
+          var _fn = wrapAsync(iteratee);
+          var _test = wrapAsync(test);
+          var results = [];
+          function next(err, ...rest) {
             if (err) return callback(err);
-            if (test()) return _iteratee(next);
-            var args = slice(arguments, 1);
-            callback.apply(null, [null].concat(args));
-          };
-          _iteratee(next);
+            results = rest;
+            if (err === false) return;
+            _test(check);
+          }
+          function check(err, truth) {
+            if (err) return callback(err);
+            if (err === false) return;
+            if (!truth) return callback(null, ...results);
+            _fn(next);
+          }
+          return _test(check);
         }
+        var whilst$1 = awaitify(whilst, 3);
         function until(test, iteratee, callback) {
-          whilst(
-            function () {
-              return !test.apply(this, arguments);
-            },
+          const _test = wrapAsync(test);
+          return whilst$1(
+            (cb) => _test((err, truth) => cb(err, !truth)),
             iteratee,
             callback,
           );
         }
-        var waterfall = function (tasks, callback) {
-          callback = once(callback || noop);
-          if (!isArray(tasks))
+        function waterfall(tasks, callback) {
+          callback = once(callback);
+          if (!Array.isArray(tasks))
             return callback(
               new Error(
                 "First argument to waterfall must be an array of functions",
@@ -1959,17 +1817,18 @@
           var taskIndex = 0;
           function nextTask(args) {
             var task = wrapAsync(tasks[taskIndex++]);
-            args.push(onlyOnce(next));
-            task.apply(null, args);
+            task(...args, onlyOnce(next));
           }
-          function next(err) {
+          function next(err, ...args) {
+            if (err === false) return;
             if (err || taskIndex === tasks.length) {
-              return callback.apply(null, arguments);
+              return callback(err, ...args);
             }
-            nextTask(slice(arguments, 1));
+            nextTask(args);
           }
           nextTask([]);
-        };
+        }
+        var waterfall$1 = awaitify(waterfall);
         var index = {
           apply,
           applyEach,
@@ -1977,231 +1836,228 @@
           asyncify,
           auto,
           autoInject,
-          cargo,
+          cargo: cargo$1,
+          cargoQueue: cargo,
           compose,
-          concat,
-          concatLimit,
-          concatSeries,
-          constant,
-          detect,
-          detectLimit,
-          detectSeries,
+          concat: concat$1,
+          concatLimit: concatLimit$1,
+          concatSeries: concatSeries$1,
+          constant: constant$1,
+          detect: detect$1,
+          detectLimit: detectLimit$1,
+          detectSeries: detectSeries$1,
           dir,
-          doDuring,
           doUntil,
-          doWhilst,
-          during,
-          each: eachLimit,
+          doWhilst: doWhilst$1,
+          each,
           eachLimit: eachLimit$1,
-          eachOf,
-          eachOfLimit,
-          eachOfSeries,
-          eachSeries,
+          eachOf: eachOf$1,
+          eachOfLimit: eachOfLimit$1,
+          eachOfSeries: eachOfSeries$1,
+          eachSeries: eachSeries$1,
           ensureAsync,
-          every,
-          everyLimit,
-          everySeries,
-          filter,
-          filterLimit,
-          filterSeries,
-          forever,
+          every: every$1,
+          everyLimit: everyLimit$1,
+          everySeries: everySeries$1,
+          filter: filter$1,
+          filterLimit: filterLimit$1,
+          filterSeries: filterSeries$1,
+          forever: forever$1,
           groupBy,
-          groupByLimit,
+          groupByLimit: groupByLimit$1,
           groupBySeries,
           log,
-          map,
-          mapLimit,
-          mapSeries,
+          map: map$1,
+          mapLimit: mapLimit$1,
+          mapSeries: mapSeries$1,
           mapValues,
-          mapValuesLimit,
+          mapValuesLimit: mapValuesLimit$1,
           mapValuesSeries,
           memoize,
           nextTick,
-          parallel: parallelLimit,
-          parallelLimit: parallelLimit$1,
+          parallel,
+          parallelLimit,
           priorityQueue,
-          queue: queue$1,
-          race,
-          reduce,
+          queue,
+          race: race$1,
+          reduce: reduce$1,
           reduceRight,
           reflect,
           reflectAll,
-          reject,
-          rejectLimit,
-          rejectSeries,
+          reject: reject$1,
+          rejectLimit: rejectLimit$1,
+          rejectSeries: rejectSeries$1,
           retry,
           retryable,
           seq,
           series,
           setImmediate: setImmediate$1,
-          some,
-          someLimit,
-          someSeries,
-          sortBy,
+          some: some$1,
+          someLimit: someLimit$1,
+          someSeries: someSeries$1,
+          sortBy: sortBy$1,
           timeout,
           times,
-          timesLimit: timeLimit,
+          timesLimit,
           timesSeries,
           transform,
-          tryEach,
+          tryEach: tryEach$1,
           unmemoize,
           until,
-          waterfall,
-          whilst,
-          all: every,
-          allLimit: everyLimit,
-          allSeries: everySeries,
-          any: some,
-          anyLimit: someLimit,
-          anySeries: someSeries,
-          find: detect,
-          findLimit: detectLimit,
-          findSeries: detectSeries,
-          forEach: eachLimit,
-          forEachSeries: eachSeries,
+          waterfall: waterfall$1,
+          whilst: whilst$1,
+          all: every$1,
+          allLimit: everyLimit$1,
+          allSeries: everySeries$1,
+          any: some$1,
+          anyLimit: someLimit$1,
+          anySeries: someSeries$1,
+          find: detect$1,
+          findLimit: detectLimit$1,
+          findSeries: detectSeries$1,
+          flatMap: concat$1,
+          flatMapLimit: concatLimit$1,
+          flatMapSeries: concatSeries$1,
+          forEach: each,
+          forEachSeries: eachSeries$1,
           forEachLimit: eachLimit$1,
-          forEachOf: eachOf,
-          forEachOfSeries: eachOfSeries,
-          forEachOfLimit: eachOfLimit,
-          inject: reduce,
-          foldl: reduce,
+          forEachOf: eachOf$1,
+          forEachOfSeries: eachOfSeries$1,
+          forEachOfLimit: eachOfLimit$1,
+          inject: reduce$1,
+          foldl: reduce$1,
           foldr: reduceRight,
-          select: filter,
-          selectLimit: filterLimit,
-          selectSeries: filterSeries,
+          select: filter$1,
+          selectLimit: filterLimit$1,
+          selectSeries: filterSeries$1,
           wrapSync: asyncify,
+          during: whilst$1,
+          doDuring: doWhilst$1,
         };
-        exports["default"] = index;
+        exports.all = every$1;
+        exports.allLimit = everyLimit$1;
+        exports.allSeries = everySeries$1;
+        exports.any = some$1;
+        exports.anyLimit = someLimit$1;
+        exports.anySeries = someSeries$1;
         exports.apply = apply;
         exports.applyEach = applyEach;
         exports.applyEachSeries = applyEachSeries;
         exports.asyncify = asyncify;
         exports.auto = auto;
         exports.autoInject = autoInject;
-        exports.cargo = cargo;
+        exports.cargo = cargo$1;
+        exports.cargoQueue = cargo;
         exports.compose = compose;
-        exports.concat = concat;
-        exports.concatLimit = concatLimit;
-        exports.concatSeries = concatSeries;
-        exports.constant = constant;
-        exports.detect = detect;
-        exports.detectLimit = detectLimit;
-        exports.detectSeries = detectSeries;
+        exports.concat = concat$1;
+        exports.concatLimit = concatLimit$1;
+        exports.concatSeries = concatSeries$1;
+        exports.constant = constant$1;
+        exports.default = index;
+        exports.detect = detect$1;
+        exports.detectLimit = detectLimit$1;
+        exports.detectSeries = detectSeries$1;
         exports.dir = dir;
-        exports.doDuring = doDuring;
+        exports.doDuring = doWhilst$1;
         exports.doUntil = doUntil;
-        exports.doWhilst = doWhilst;
-        exports.during = during;
-        exports.each = eachLimit;
+        exports.doWhilst = doWhilst$1;
+        exports.during = whilst$1;
+        exports.each = each;
         exports.eachLimit = eachLimit$1;
-        exports.eachOf = eachOf;
-        exports.eachOfLimit = eachOfLimit;
-        exports.eachOfSeries = eachOfSeries;
-        exports.eachSeries = eachSeries;
+        exports.eachOf = eachOf$1;
+        exports.eachOfLimit = eachOfLimit$1;
+        exports.eachOfSeries = eachOfSeries$1;
+        exports.eachSeries = eachSeries$1;
         exports.ensureAsync = ensureAsync;
-        exports.every = every;
-        exports.everyLimit = everyLimit;
-        exports.everySeries = everySeries;
-        exports.filter = filter;
-        exports.filterLimit = filterLimit;
-        exports.filterSeries = filterSeries;
-        exports.forever = forever;
+        exports.every = every$1;
+        exports.everyLimit = everyLimit$1;
+        exports.everySeries = everySeries$1;
+        exports.filter = filter$1;
+        exports.filterLimit = filterLimit$1;
+        exports.filterSeries = filterSeries$1;
+        exports.find = detect$1;
+        exports.findLimit = detectLimit$1;
+        exports.findSeries = detectSeries$1;
+        exports.flatMap = concat$1;
+        exports.flatMapLimit = concatLimit$1;
+        exports.flatMapSeries = concatSeries$1;
+        exports.foldl = reduce$1;
+        exports.foldr = reduceRight;
+        exports.forEach = each;
+        exports.forEachLimit = eachLimit$1;
+        exports.forEachOf = eachOf$1;
+        exports.forEachOfLimit = eachOfLimit$1;
+        exports.forEachOfSeries = eachOfSeries$1;
+        exports.forEachSeries = eachSeries$1;
+        exports.forever = forever$1;
         exports.groupBy = groupBy;
-        exports.groupByLimit = groupByLimit;
+        exports.groupByLimit = groupByLimit$1;
         exports.groupBySeries = groupBySeries;
+        exports.inject = reduce$1;
         exports.log = log;
-        exports.map = map;
-        exports.mapLimit = mapLimit;
-        exports.mapSeries = mapSeries;
+        exports.map = map$1;
+        exports.mapLimit = mapLimit$1;
+        exports.mapSeries = mapSeries$1;
         exports.mapValues = mapValues;
-        exports.mapValuesLimit = mapValuesLimit;
+        exports.mapValuesLimit = mapValuesLimit$1;
         exports.mapValuesSeries = mapValuesSeries;
         exports.memoize = memoize;
         exports.nextTick = nextTick;
-        exports.parallel = parallelLimit;
-        exports.parallelLimit = parallelLimit$1;
+        exports.parallel = parallel;
+        exports.parallelLimit = parallelLimit;
         exports.priorityQueue = priorityQueue;
-        exports.queue = queue$1;
-        exports.race = race;
-        exports.reduce = reduce;
+        exports.queue = queue;
+        exports.race = race$1;
+        exports.reduce = reduce$1;
         exports.reduceRight = reduceRight;
         exports.reflect = reflect;
         exports.reflectAll = reflectAll;
-        exports.reject = reject;
-        exports.rejectLimit = rejectLimit;
-        exports.rejectSeries = rejectSeries;
+        exports.reject = reject$1;
+        exports.rejectLimit = rejectLimit$1;
+        exports.rejectSeries = rejectSeries$1;
         exports.retry = retry;
         exports.retryable = retryable;
+        exports.select = filter$1;
+        exports.selectLimit = filterLimit$1;
+        exports.selectSeries = filterSeries$1;
         exports.seq = seq;
         exports.series = series;
         exports.setImmediate = setImmediate$1;
-        exports.some = some;
-        exports.someLimit = someLimit;
-        exports.someSeries = someSeries;
-        exports.sortBy = sortBy;
+        exports.some = some$1;
+        exports.someLimit = someLimit$1;
+        exports.someSeries = someSeries$1;
+        exports.sortBy = sortBy$1;
         exports.timeout = timeout;
         exports.times = times;
-        exports.timesLimit = timeLimit;
+        exports.timesLimit = timesLimit;
         exports.timesSeries = timesSeries;
         exports.transform = transform;
-        exports.tryEach = tryEach;
+        exports.tryEach = tryEach$1;
         exports.unmemoize = unmemoize;
         exports.until = until;
-        exports.waterfall = waterfall;
-        exports.whilst = whilst;
-        exports.all = every;
-        exports.allLimit = everyLimit;
-        exports.allSeries = everySeries;
-        exports.any = some;
-        exports.anyLimit = someLimit;
-        exports.anySeries = someSeries;
-        exports.find = detect;
-        exports.findLimit = detectLimit;
-        exports.findSeries = detectSeries;
-        exports.forEach = eachLimit;
-        exports.forEachSeries = eachSeries;
-        exports.forEachLimit = eachLimit$1;
-        exports.forEachOf = eachOf;
-        exports.forEachOfSeries = eachOfSeries;
-        exports.forEachOfLimit = eachOfLimit;
-        exports.inject = reduce;
-        exports.foldl = reduce;
-        exports.foldr = reduceRight;
-        exports.select = filter;
-        exports.selectLimit = filterLimit;
-        exports.selectSeries = filterSeries;
+        exports.waterfall = waterfall$1;
+        exports.whilst = whilst$1;
         exports.wrapSync = asyncify;
         Object.defineProperty(exports, "__esModule", { value: true });
       });
     },
-    327: (module, exports, __nccwpck_require__) => {
-      "use strict";
-      function _typeof(obj) {
-        if (
-          typeof Symbol === "function" &&
-          typeof Symbol.iterator === "symbol"
-        ) {
-          _typeof = function _typeof(obj) {
-            return typeof obj;
-          };
-        } else {
-          _typeof = function _typeof(obj) {
-            return obj &&
-              typeof Symbol === "function" &&
-              obj.constructor === Symbol &&
-              obj !== Symbol.prototype
-              ? "symbol"
-              : typeof obj;
-          };
-        }
-        return _typeof(obj);
-      }
-      exports.log = log;
+    673: (module, exports, __nccwpck_require__) => {
       exports.formatArgs = formatArgs;
       exports.save = save;
       exports.load = load;
       exports.useColors = useColors;
       exports.storage = localstorage();
+      exports.destroy = (() => {
+        let warned = false;
+        return () => {
+          if (!warned) {
+            warned = true;
+            console.warn(
+              "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.",
+            );
+          }
+        };
+      })();
       exports.colors = [
         "#0000CC",
         "#0000FF",
@@ -2295,6 +2151,7 @@
         ) {
           return false;
         }
+        let m;
         return (
           (typeof document !== "undefined" &&
             document.documentElement &&
@@ -2306,8 +2163,8 @@
               (window.console.exception && window.console.table))) ||
           (typeof navigator !== "undefined" &&
             navigator.userAgent &&
-            navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) &&
-            parseInt(RegExp.$1, 10) >= 31) ||
+            (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) &&
+            parseInt(m[1], 10) >= 31) ||
           (typeof navigator !== "undefined" &&
             navigator.userAgent &&
             navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/))
@@ -2325,11 +2182,11 @@
         if (!this.useColors) {
           return;
         }
-        var c = "color: " + this.color;
+        const c = "color: " + this.color;
         args.splice(1, 0, c, "color: inherit");
-        var index = 0;
-        var lastC = 0;
-        args[0].replace(/%[a-zA-Z%]/g, function (match) {
+        let index = 0;
+        let lastC = 0;
+        args[0].replace(/%[a-zA-Z%]/g, (match) => {
           if (match === "%%") {
             return;
           }
@@ -2340,15 +2197,7 @@
         });
         args.splice(lastC, 0, c);
       }
-      function log() {
-        var _console;
-        return (
-          (typeof console === "undefined" ? "undefined" : _typeof(console)) ===
-            "object" &&
-          console.log &&
-          (_console = console).log.apply(_console, arguments)
-        );
-      }
+      exports.log = console.debug || console.log || (() => {});
       function save(namespaces) {
         try {
           if (namespaces) {
@@ -2359,7 +2208,7 @@
         } catch (error) {}
       }
       function load() {
-        var r;
+        let r;
         try {
           r = exports.storage.getItem("debug");
         } catch (error) {}
@@ -2373,8 +2222,8 @@
           return localStorage;
         } catch (error) {}
       }
-      module.exports = __nccwpck_require__(130)(exports);
-      var formatters = module.exports.formatters;
+      module.exports = __nccwpck_require__(864)(exports);
+      const { formatters } = module.exports;
       formatters.j = function (v) {
         try {
           return JSON.stringify(v);
@@ -2383,8 +2232,7 @@
         }
       };
     },
-    130: (module, __unused_webpack_exports, __nccwpck_require__) => {
-      "use strict";
+    864: (module, __unused_webpack_exports, __nccwpck_require__) => {
       function setup(env) {
         createDebug.debug = createDebug;
         createDebug.default = createDebug;
@@ -2393,16 +2241,16 @@
         createDebug.enable = enable;
         createDebug.enabled = enabled;
         createDebug.humanize = __nccwpck_require__(258);
-        Object.keys(env).forEach(function (key) {
+        createDebug.destroy = destroy;
+        Object.keys(env).forEach((key) => {
           createDebug[key] = env[key];
         });
-        createDebug.instances = [];
         createDebug.names = [];
         createDebug.skips = [];
         createDebug.formatters = {};
         function selectColor(namespace) {
-          var hash = 0;
-          for (var i = 0; i < namespace.length; i++) {
+          let hash = 0;
+          for (let i = 0; i < namespace.length; i++) {
             hash = (hash << 5) - hash + namespace.charCodeAt(i);
             hash |= 0;
           }
@@ -2410,21 +2258,17 @@
         }
         createDebug.selectColor = selectColor;
         function createDebug(namespace) {
-          var prevTime;
-          function debug() {
+          let prevTime;
+          let enableOverride = null;
+          let namespacesCache;
+          let enabledCache;
+          function debug(...args) {
             if (!debug.enabled) {
               return;
             }
-            for (
-              var _len = arguments.length, args = new Array(_len), _key = 0;
-              _key < _len;
-              _key++
-            ) {
-              args[_key] = arguments[_key];
-            }
-            var self = debug;
-            var curr = Number(new Date());
-            var ms = curr - (prevTime || curr);
+            const self = debug;
+            const curr = Number(new Date());
+            const ms = curr - (prevTime || curr);
             self.diff = ms;
             self.prev = prevTime;
             self.curr = curr;
@@ -2433,98 +2277,130 @@
             if (typeof args[0] !== "string") {
               args.unshift("%O");
             }
-            var index = 0;
-            args[0] = args[0].replace(
-              /%([a-zA-Z%])/g,
-              function (match, format) {
-                if (match === "%%") {
-                  return match;
-                }
-                index++;
-                var formatter = createDebug.formatters[format];
-                if (typeof formatter === "function") {
-                  var val = args[index];
-                  match = formatter.call(self, val);
-                  args.splice(index, 1);
-                  index--;
-                }
-                return match;
-              },
-            );
+            let index = 0;
+            args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+              if (match === "%%") {
+                return "%";
+              }
+              index++;
+              const formatter = createDebug.formatters[format];
+              if (typeof formatter === "function") {
+                const val = args[index];
+                match = formatter.call(self, val);
+                args.splice(index, 1);
+                index--;
+              }
+              return match;
+            });
             createDebug.formatArgs.call(self, args);
-            var logFn = self.log || createDebug.log;
+            const logFn = self.log || createDebug.log;
             logFn.apply(self, args);
           }
           debug.namespace = namespace;
-          debug.enabled = createDebug.enabled(namespace);
           debug.useColors = createDebug.useColors();
-          debug.color = selectColor(namespace);
-          debug.destroy = destroy;
+          debug.color = createDebug.selectColor(namespace);
           debug.extend = extend;
+          debug.destroy = createDebug.destroy;
+          Object.defineProperty(debug, "enabled", {
+            enumerable: true,
+            configurable: false,
+            get: () => {
+              if (enableOverride !== null) {
+                return enableOverride;
+              }
+              if (namespacesCache !== createDebug.namespaces) {
+                namespacesCache = createDebug.namespaces;
+                enabledCache = createDebug.enabled(namespace);
+              }
+              return enabledCache;
+            },
+            set: (v) => {
+              enableOverride = v;
+            },
+          });
           if (typeof createDebug.init === "function") {
             createDebug.init(debug);
           }
-          createDebug.instances.push(debug);
           return debug;
         }
-        function destroy() {
-          var index = createDebug.instances.indexOf(this);
-          if (index !== -1) {
-            createDebug.instances.splice(index, 1);
-            return true;
-          }
-          return false;
-        }
         function extend(namespace, delimiter) {
-          return createDebug(
+          const newDebug = createDebug(
             this.namespace +
               (typeof delimiter === "undefined" ? ":" : delimiter) +
               namespace,
           );
+          newDebug.log = this.log;
+          return newDebug;
         }
         function enable(namespaces) {
           createDebug.save(namespaces);
+          createDebug.namespaces = namespaces;
           createDebug.names = [];
           createDebug.skips = [];
-          var i;
-          var split = (typeof namespaces === "string" ? namespaces : "").split(
-            /[\s,]+/,
-          );
-          var len = split.length;
-          for (i = 0; i < len; i++) {
-            if (!split[i]) {
-              continue;
+          const split = (typeof namespaces === "string" ? namespaces : "")
+            .trim()
+            .replace(" ", ",")
+            .split(",")
+            .filter(Boolean);
+          for (const ns of split) {
+            if (ns[0] === "-") {
+              createDebug.skips.push(ns.slice(1));
+            } else {
+              createDebug.names.push(ns);
             }
-            namespaces = split[i].replace(/\*/g, ".*?");
-            if (namespaces[0] === "-") {
-              createDebug.skips.push(
-                new RegExp("^" + namespaces.substr(1) + "$"),
-              );
+          }
+        }
+        function matchesTemplate(search, template) {
+          let searchIndex = 0;
+          let templateIndex = 0;
+          let starIndex = -1;
+          let matchIndex = 0;
+          while (searchIndex < search.length) {
+            if (
+              templateIndex < template.length &&
+              (template[templateIndex] === search[searchIndex] ||
+                template[templateIndex] === "*")
+            ) {
+              if (template[templateIndex] === "*") {
+                starIndex = templateIndex;
+                matchIndex = searchIndex;
+                templateIndex++;
+              } else {
+                searchIndex++;
+                templateIndex++;
+              }
+            } else if (starIndex !== -1) {
+              templateIndex = starIndex + 1;
+              matchIndex++;
+              searchIndex = matchIndex;
             } else {
-              createDebug.names.push(new RegExp("^" + namespaces + "$"));
+              return false;
             }
           }
-          for (i = 0; i < createDebug.instances.length; i++) {
-            var instance = createDebug.instances[i];
-            instance.enabled = createDebug.enabled(instance.namespace);
+          while (
+            templateIndex < template.length &&
+            template[templateIndex] === "*"
+          ) {
+            templateIndex++;
           }
+          return templateIndex === template.length;
         }
         function disable() {
+          const namespaces = [
+            ...createDebug.names,
+            ...createDebug.skips.map((namespace) => "-" + namespace),
+          ].join(",");
           createDebug.enable("");
+          return namespaces;
         }
         function enabled(name) {
-          if (name[name.length - 1] === "*") {
-            return true;
-          }
-          var i;
-          var len;
-          for (i = 0, len = createDebug.skips.length; i < len; i++) {
-            if (createDebug.skips[i].test(name)) {
+          for (const skip of createDebug.skips) {
+            if (matchesTemplate(name, skip)) {
               return false;
             }
           }
-          for (i = 0, len = createDebug.names.length; i < len; i++) {
-            if (createDebug.names[i].test(name)) {
+          for (const ns of createDebug.names) {
+            if (matchesTemplate(name, ns)) {
               return true;
             }
           }
@@ -2536,37 +2412,44 @@
           }
           return val;
         }
+        function destroy() {
+          console.warn(
+            "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.",
+          );
+        }
         createDebug.enable(createDebug.load());
         return createDebug;
       }
       module.exports = setup;
     },
-    163: (module, __unused_webpack_exports, __nccwpck_require__) => {
-      "use strict";
+    473: (module, __unused_webpack_exports, __nccwpck_require__) => {
       if (
         typeof process === "undefined" ||
         process.type === "renderer" ||
         process.browser === true ||
         process.__nwjs
       ) {
-        module.exports = __nccwpck_require__(327);
+        module.exports = __nccwpck_require__(673);
       } else {
-        module.exports = __nccwpck_require__(83);
+        module.exports = __nccwpck_require__(873);
       }
     },
-    83: (module, exports, __nccwpck_require__) => {
-      "use strict";
-      var tty = __nccwpck_require__(18);
-      var util = __nccwpck_require__(23);
+    873: (module, exports, __nccwpck_require__) => {
+      const tty = __nccwpck_require__(18);
+      const util = __nccwpck_require__(23);
       exports.init = init;
       exports.log = log;
       exports.formatArgs = formatArgs;
       exports.save = save;
       exports.load = load;
       exports.useColors = useColors;
+      exports.destroy = util.deprecate(
+        () => {},
+        "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.",
+      );
       exports.colors = [6, 2, 3, 4, 5, 1];
       try {
-        var supportsColor = __nccwpck_require__(970);
+        const supportsColor = __nccwpck_require__(970);
         if (
           supportsColor &&
           (supportsColor.stderr || supportsColor).level >= 2
@@ -2582,17 +2465,13 @@
         }
       } catch (error) {}
       exports.inspectOpts = Object.keys(process.env)
-        .filter(function (key) {
-          return /^debug_/i.test(key);
-        })
-        .reduce(function (obj, key) {
-          var prop = key
+        .filter((key) => /^debug_/i.test(key))
+        .reduce((obj, key) => {
+          const prop = key
             .substring(6)
             .toLowerCase()
-            .replace(/_([a-z])/g, function (_, k) {
-              return k.toUpperCase();
-            });
-          var val = process.env[key];
+            .replace(/_([a-z])/g, (_, k) => k.toUpperCase());
+          let val = process.env[key];
           if (/^(yes|on|true|enabled)$/i.test(val)) {
             val = true;
           } else if (/^(no|off|false|disabled)$/i.test(val)) {
@@ -2611,12 +2490,11 @@
           : tty.isatty(process.stderr.fd);
       }
       function formatArgs(args) {
-        var name = this.namespace,
-          useColors = this.useColors;
+        const { namespace: name, useColors } = this;
         if (useColors) {
-          var c = this.color;
-          var colorCode = "[3" + (c < 8 ? c : "8;5;" + c);
-          var prefix = "  ".concat(colorCode, ";1m").concat(name, " ");
+          const c = this.color;
+          const colorCode = "[3" + (c < 8 ? c : "8;5;" + c);
+          const prefix = `  ${colorCode};1m${name} `;
           args[0] = prefix + args[0].split("\n").join("\n" + prefix);
           args.push(
             colorCode + "m+" + module.exports.humanize(this.diff) + "",
@@ -2631,8 +2509,10 @@
         }
         return new Date().toISOString() + " ";
       }
-      function log() {
-        return process.stderr.write(util.format.apply(util, arguments) + "\n");
+      function log(...args) {
+        return process.stderr.write(
+          util.formatWithOptions(exports.inspectOpts, ...args) + "\n",
+        );
       }
       function save(namespaces) {
         if (namespaces) {
@@ -2646,21 +2526,19 @@
       }
       function init(debug) {
         debug.inspectOpts = {};
-        var keys = Object.keys(exports.inspectOpts);
-        for (var i = 0; i < keys.length; i++) {
+        const keys = Object.keys(exports.inspectOpts);
+        for (let i = 0; i < keys.length; i++) {
           debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
         }
       }
-      module.exports = __nccwpck_require__(130)(exports);
-      var formatters = module.exports.formatters;
+      module.exports = __nccwpck_require__(864)(exports);
+      const { formatters } = module.exports;
       formatters.o = function (v) {
         this.inspectOpts.colors = this.useColors;
         return util
           .inspect(v, this.inspectOpts)
           .split("\n")
-          .map(function (str) {
-            return str.trim();
-          })
+          .map((str) => str.trim())
           .join(" ");
       };
       formatters.O = function (v) {
@@ -2874,19 +2752,19 @@
         return Math.round(ms / n) + " " + name + (isPlural ? "s" : "");
       }
     },
-    909: (__unused_webpack_module, exports, __nccwpck_require__) => {
+    599: (__unused_webpack_module, exports, __nccwpck_require__) => {
       "use strict";
-      var fs = __nccwpck_require__(896),
+      const fs = __nccwpck_require__(896),
         os = __nccwpck_require__(857),
         net = __nccwpck_require__(278),
         path = __nccwpck_require__(928),
-        _async = __nccwpck_require__(515),
-        debug = __nccwpck_require__(163),
+        _async = __nccwpck_require__(594),
+        debug = __nccwpck_require__(473),
         mkdirp = __nccwpck_require__(119).mkdirp;
-      var debugTestPort = debug("portfinder:testPort"),
+      const debugTestPort = debug("portfinder:testPort"),
         debugGetPort = debug("portfinder:getPort"),
         debugDefaultHosts = debug("portfinder:defaultHosts");
-      var internals = {};
+      const internals = {};
       internals.testPort = function (options, callback) {
         if (!callback) {
           callback = options;
@@ -2907,8 +2785,15 @@
             options.port,
           );
           options.server.removeListener("error", onError);
-          options.server.close();
-          callback(null, options.port);
+          options.server.close(function () {
+            debugTestPort(
+              "done w/ testPort(): Server closed",
+              options.host,
+              "port",
+              options.port,
+            );
+            callback(null, options.port);
+          });
         }
         function onError(err) {
           debugTestPort(
@@ -2923,7 +2808,7 @@
           if (!(err.code == "EADDRINUSE" || err.code == "EACCES")) {
             return callback(err);
           }
-          var nextPort = exports.nextPort(options.port);
+          const nextPort = exports.nextPort(options.port);
           if (nextPort > exports.highestPort) {
             return callback(new Error("No open ports available"));
           }
@@ -2949,6 +2834,9 @@
         exports.highestPort = port;
       };
       exports.basePath = "/tmp/portfinder";
+      exports.setBasePath = function (path) {
+        exports.basePath = path;
+      };
       exports.getPort = function (options, callback) {
         if (!callback) {
           callback = options;
@@ -2977,13 +2865,14 @@
             );
           }
         }
-        if (options.host) {
-          if (exports._defaultHosts.indexOf(options.host) !== -1) {
-            exports._defaultHosts.push(options.host);
-          }
+        if (
+          options.host &&
+          exports._defaultHosts.indexOf(options.host) === -1
+        ) {
+          exports._defaultHosts.push(options.host);
         }
-        var openPorts = [],
-          currentHost;
+        const openPorts = [];
+        let currentHost;
         return _async.eachSeries(
           exports._defaultHosts,
           function (host, next) {
@@ -3016,13 +2905,13 @@
               debugGetPort("in eachSeries() result callback: err is", err);
               if (err.code === "EADDRNOTAVAIL" || err.code === "EINVAL") {
                 if (options.host === currentHost) {
-                  var msg =
+                  const msg =
                     "Provided host " +
                     options.host +
                     " could NOT be bound. Please provide a different host address or hostname";
                   return callback(Error(msg));
                 } else {
-                  var idx = exports._defaultHosts.indexOf(currentHost);
+                  const idx = exports._defaultHosts.indexOf(currentHost);
                   exports._defaultHosts.splice(idx, 1);
                   return exports.getPort(options, callback);
                 }
@@ -3041,7 +2930,7 @@
               if (openPorts[0] <= options.stopPort) {
                 return callback(null, openPorts[0]);
               } else {
-                var msg =
+                const msg =
                   "No open ports found in between " +
                   options.startPort +
                   " and " +
@@ -3063,12 +2952,6 @@
         );
       };
       exports.getPortPromise = function (options) {
-        if (typeof Promise !== "function") {
-          throw Error(
-            "Native promise support is not available in this version of node." +
-              "Please install a polyfill and assign Promise to global.Promise before calling this method",
-          );
-        }
         if (!options) {
           options = {};
         }
@@ -3086,7 +2969,7 @@
           callback = options;
           options = {};
         }
-        var lastPort = null;
+        let lastPort = null;
         _async.timesSeries(
           count,
           function (index, asyncCallback) {
@@ -3105,6 +2988,19 @@
           callback,
         );
       };
+      exports.getPortsPromise = function (count, options) {
+        if (!options) {
+          options = {};
+        }
+        return new Promise(function (resolve, reject) {
+          exports.getPorts(count, options, function (err, ports) {
+            if (err) {
+              return reject(err);
+            }
+            resolve(ports);
+          });
+        });
+      };
       exports.getSocket = function (options, callback) {
         if (!callback) {
           callback = options;
@@ -3136,7 +3032,7 @@
           });
         }
         function checkAndTestSocket() {
-          var dir = path.dirname(options.path);
+          const dir = path.dirname(options.path);
           fs.stat(dir, function (err, stats) {
             if (err || !stats.isDirectory()) {
               return createAndTestSocket(dir);
@@ -3151,11 +3047,11 @@
         return port + 1;
       };
       exports.nextSocket = function (socketPath) {
-        var dir = path.dirname(socketPath),
+        const dir = path.dirname(socketPath),
           name = path.basename(socketPath, ".sock"),
           match = name.match(/^([a-zA-z]+)(\d*)$/i),
-          index = parseInt(match[2]),
           base = match[1];
+        let index = parseInt(match[2]);
         if (isNaN(index)) {
           index = 0;
         }
@@ -3163,7 +3059,7 @@
         return path.join(dir, base + index + ".sock");
       };
       exports._defaultHosts = (function () {
-        var interfaces = {};
+        let interfaces = {};
         try {
           interfaces = os.networkInterfaces();
         } catch (e) {
@@ -3172,13 +3068,13 @@
             throw e;
           }
         }
-        var interfaceNames = Object.keys(interfaces),
+        const interfaceNames = Object.keys(interfaces),
           hiddenButImportantHost = "0.0.0.0",
           results = [hiddenButImportantHost];
-        for (var i = 0; i < interfaceNames.length; i++) {
-          var _interface = interfaces[interfaceNames[i]];
-          for (var j = 0; j < _interface.length; j++) {
-            var curr = _interface[j];
+        for (let i = 0; i < interfaceNames.length; i++) {
+          const _interface = interfaces[interfaceNames[i]];
+          for (let j = 0; j < _interface.length; j++) {
+            const curr = _interface[j];
             results.push(curr.address);
           }
         }
@@ -3367,11 +3263,7 @@
     if (cachedModule !== undefined) {
       return cachedModule.exports;
     }
-    var module = (__webpack_module_cache__[moduleId] = {
-      id: moduleId,
-      loaded: false,
-      exports: {},
-    });
+    var module = (__webpack_module_cache__[moduleId] = { exports: {} });
     var threw = true;
     try {
       __webpack_modules__[moduleId].call(
@@ -3384,18 +3276,10 @@
     } finally {
       if (threw) delete __webpack_module_cache__[moduleId];
     }
-    module.loaded = true;
     return module.exports;
   }
-  (() => {
-    __nccwpck_require__.nmd = (module) => {
-      module.paths = [];
-      if (!module.children) module.children = [];
-      return module;
-    };
-  })();
   if (typeof __nccwpck_require__ !== "undefined")
     __nccwpck_require__.ab = __dirname + "/";
-  var __webpack_exports__ = __nccwpck_require__(909);
+  var __webpack_exports__ = __nccwpck_require__(599);
   module.exports = __webpack_exports__;
 })();