From e26d180646897475ebfd8db6c1211871259fa3aa Mon Sep 17 00:00:00 2001
From: Suguru Motegi <suguru.motegi@gmail.com>
Date: Mon, 27 May 2019 21:36:58 -0700
Subject: [PATCH] 1.14.0

---
 dist/aigle-es5.js     | 14431 ----------------------------------------
 dist/aigle-es5.min.js |  5918 ----------------
 dist/aigle.js         |   588 +-
 dist/aigle.min.js     |  1151 ++--
 package.json          |     2 +-
 5 files changed, 925 insertions(+), 21165 deletions(-)

diff --git a/dist/aigle-es5.js b/dist/aigle-es5.js
index 5cf0d64d..e69de29b 100644
--- a/dist/aigle-es5.js
+++ b/dist/aigle-es5.js
@@ -1,14431 +0,0 @@
-(function(f) {
-  if (typeof exports === 'object' && typeof module !== 'undefined') {
-    module.exports = f();
-  } else if (typeof define === 'function' && define.amd) {
-    define([], f);
-  } else {
-    var g;
-    if (typeof window !== 'undefined') {
-      g = window;
-    } else if (typeof global !== 'undefined') {
-      g = global;
-    } else if (typeof self !== 'undefined') {
-      g = self;
-    } else {
-      g = this;
-    }
-    g.Promise = f();
-  }
-})(function() {
-  var define, module, exports;
-  return (function() {
-    function r(e, n, t) {
-      function o(i, f) {
-        if (!n[i]) {
-          if (!e[i]) {
-            var c = 'function' == typeof require && require;
-            if (!f && c) {
-              return c(i, !0);
-            }
-            if (u) {
-              return u(i, !0);
-            }
-            var a = new Error("Cannot find module '" + i + "'");
-            throw ((a.code = 'MODULE_NOT_FOUND'), a);
-          }
-          var p = (n[i] = { exports: {} });
-          e[i][0].call(
-            p.exports,
-            function(r) {
-              var n = e[i][1][r];
-              return o(n || r);
-            },
-            p,
-            p.exports,
-            r,
-            e,
-            n,
-            t
-          );
-        }
-        return n[i].exports;
-      }
-      for (var u = 'function' == typeof require && require, i = 0; i < t.length; i++) {
-        o(t[i]);
-      }
-      return o;
-    }
-    return r;
-  })()(
-    {
-      1: [
-        function(require, module, exports) {
-          'use strict';
-
-          require('setimmediate');
-          module.exports = require('./lib/aigle');
-        },
-        { './lib/aigle': 2, setimmediate: 87 }
-      ],
-      2: [
-        function(require, module, exports) {
-          (function(process) {
-            'use strict';
-
-            var ref = require('aigle-core');
-            var AigleCore = ref.AigleCore;
-            var AigleProxy = ref.AigleProxy;
-
-            var Queue = require('./internal/queue');
-            var invokeAsync = require('./internal/async');
-            var ref$1 = require('./internal/util');
-            var VERSION = ref$1.VERSION;
-            var INTERNAL = ref$1.INTERNAL;
-            var PENDING = ref$1.PENDING;
-            var UNHANDLED = ref$1.UNHANDLED;
-            var errorObj = ref$1.errorObj;
-            var call0 = ref$1.call0;
-            var callResolve = ref$1.callResolve;
-            var callReject = ref$1.callReject;
-            var callReceiver = ref$1.callReceiver;
-            var printWarning = ref$1.printWarning;
-            var stackTraces = false;
-
-            var Aigle = /*@__PURE__*/ (function(AigleCore) {
-              function Aigle(executor) {
-                AigleCore.call(this);
-                this._resolved = 0;
-                this._value = undefined;
-                this._key = undefined;
-                this._receiver = undefined;
-                this._onFulfilled = undefined;
-                this._onRejected = undefined;
-                this._receivers = undefined;
-                if (executor === INTERNAL) {
-                  return;
-                }
-                this._execute(executor);
-              }
-
-              if (AigleCore) Aigle.__proto__ = AigleCore;
-              Aigle.prototype = Object.create(AigleCore && AigleCore.prototype);
-              Aigle.prototype.constructor = Aigle;
-
-              /**
-               * @param {Function} onFulfilled
-               * @param {Function} [onRejected]
-               * @return {Aigle} Returns an Aigle instance
-               */
-              Aigle.prototype.then = function then(onFulfilled, onRejected) {
-                return addAigle(this, new Aigle(INTERNAL), onFulfilled, onRejected);
-              };
-
-              /**
-               * @param {Object|Function} onRejected
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * return Aigle.reject(new TypeError('error'))
-               *   .catch(TypeError, error => console.log(error));
-               */
-              Aigle.prototype.catch = function catch$1(onRejected) {
-                var arguments$1 = arguments;
-
-                if (arguments.length > 1) {
-                  var l = arguments.length;
-                  onRejected = arguments[--l];
-                  if (typeof onRejected === 'function') {
-                    var errorTypes = Array(l);
-                    while (l--) {
-                      errorTypes[l] = arguments$1[l];
-                    }
-                    onRejected = createOnRejected(errorTypes, onRejected);
-                  }
-                }
-                return addAigle(this, new Aigle(INTERNAL), undefined, onRejected);
-              };
-
-              /**
-               * @param {Function} handler
-               * @return {Aigle} Returns an Aigle instance
-               */
-              Aigle.prototype.finally = function finally$1(handler) {
-                handler =
-                  typeof handler !== 'function' ? handler : createFinallyHandler(this, handler);
-                return addAigle(this, new Aigle(INTERNAL), handler, handler);
-              };
-
-              /**
-               * @return {string}
-               */
-              Aigle.prototype.toString = function toString() {
-                return '[object Promise]';
-              };
-
-              /**
-               * @return {boolean}
-               */
-              Aigle.prototype.isPending = function isPending() {
-                return this._resolved === 0;
-              };
-
-              /**
-               * @return {boolean}
-               */
-              Aigle.prototype.isFulfilled = function isFulfilled() {
-                return this._resolved === 1;
-              };
-
-              /**
-               * @return {boolean}
-               */
-              Aigle.prototype.isRejected = function isRejected() {
-                return this._resolved === 2;
-              };
-
-              /**
-               * @return {boolean}
-               */
-              Aigle.prototype.isCancelled = function isCancelled() {
-                return this._value instanceof CancellationError;
-              };
-
-              /**
-               * @return {*}
-               */
-              Aigle.prototype.value = function value() {
-                return this._resolved === 1 ? this._value : undefined;
-              };
-
-              /**
-               * @return {*}
-               */
-              Aigle.prototype.reason = function reason() {
-                return this._resolved === 2 ? this._value : undefined;
-              };
-
-              /**
-               * @example
-               * const { CancellationError } = Aigle;
-               * let cancelled = false;
-               * const promise = new Aigle((resolve, reject, onCancel) => {
-               *   setTimeout(resolve, 30, 'resolved');
-               *   onCancel(() => cancelled = true);
-               * });
-               * promise.cancel();
-               * promise.catch(error => {
-               *   console.log(error instanceof CancellationError); // true
-               *   console.log(cancelled); // true
-               * });
-               */
-              Aigle.prototype.cancel = function cancel() {
-                if (this._execute === execute || this._resolved !== 0) {
-                  return;
-                }
-                var ref = this;
-                var _onCancelQueue = ref._onCancelQueue;
-                if (_onCancelQueue) {
-                  var i = -1;
-                  var array = _onCancelQueue.array;
-                  this._onCancelQueue = undefined;
-                  while (++i < _onCancelQueue.length) {
-                    array[i]();
-                  }
-                }
-                this._resolved = 2;
-                this._value = new CancellationError('late cancellation observer');
-                if (this._parent) {
-                  this._parent.cancel();
-                }
-              };
-
-              Aigle.prototype.suppressUnhandledRejections = function suppressUnhandledRejections() {
-                this._receiver = INTERNAL;
-              };
-
-              /**
-               * @param {Function} handler
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const array = [1, 2, 3];
-               * Aigle.resolve(array)
-               *   .spread((arg1, arg2, arg3) => {
-               *     console.log(arg1, arg2, arg3); // 1, 2, 3
-               *   });
-               *
-               * @example
-               * const string = '123';
-               * Aigle.resolve(string)
-               *   .spread((arg1, arg2, arg3) => {
-               *     console.log(arg1, arg2, arg3); // 1, 2, 3
-               *   });
-               */
-              Aigle.prototype.spread = function spread(handler) {
-                return addReceiver(this, new Spread(handler));
-              };
-
-              /**
-               * `Aigle#all` will execute [`Aigle.all`](https://suguru03.github.io/aigle/docs/global.html#all) using a previous promise value.
-               * The value will be assigned as the first argument to [`Aigle.all`](https://suguru03.github.io/aigle/docs/global.html#all).
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const makeDelay = (num, delay) => {
-               *   return Aigle.delay(delay)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num;
-               *     });
-               * };
-               * Aigle.resolve([
-               *   makeDelay(1, 30),
-               *   makeDelay(2, 20),
-               *   makeDelay(3, 10)
-               * ])
-               * .all()
-               * .then(array => {
-               *   console.log(array); // [1, 2, 3];
-               *   console.log(order); // [3, 2, 1];
-               * });
-               */
-              Aigle.prototype.all = function all() {
-                return addProxy(this, All);
-              };
-
-              /**
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * Aigle.resolve([
-               *   new Aigle(resolve => setTimeout(() => resolve(1), 30)),
-               *   new Aigle(resolve => setTimeout(() => resolve(2), 20)),
-               *   new Aigle(resolve => setTimeout(() => resolve(3), 10))
-               * ])
-               * .race()
-               * .then(value => console.log(value)); // 3
-               */
-              Aigle.prototype.race = function race() {
-                return addProxy(this, Race);
-              };
-
-              /**
-               * `Aigle#props` will execute [`Aigle.props`](https://suguru03.github.io/aigle/docs/global.html#props) using a previous promise value.
-               * The value will be assigned as the first argument to [`Aigle.props`](https://suguru03.github.io/aigle/docs/global.html#props).
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const makeDelay = (num, delay) => {
-               *   return Aigle.delay(delay)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num;
-               *     });
-               * };
-               * Aigle.resolve({
-               *   a: makeDelay(1, 30),
-               *   b: makeDelay(2, 20),
-               *   c: makeDelay(3, 10)
-               * })
-               * .props()
-               * .then(object => {
-               *   console.log(object); // { a: 1, b: 2, c: 3 }
-               *   console.log(order); // [3, 2, 1]
-               * });
-               */
-              Aigle.prototype.props = function props() {
-                return addProxy(this, Props);
-              };
-
-              /**
-               * `Aigle#parallel` will execute [`Aigle.parallel`](https://suguru03.github.io/aigle/docs/global.html#parallel) using a previous promise value.
-               * The value will be assigned as the first argument to [`Aigle.parallel`](https://suguru03.github.io/aigle/docs/global.html#parallel).
-               * @example
-               *   Aigle.resolve([
-               *     () => Aigle.delay(30, 1),
-               *     Aigle.delay(20, 2),
-               *     3
-               *   ])
-               *   .parallel()
-               *   .then(array => {
-               *     console.log(array); // [1, 2, 3]
-               *   });
-               *
-               * @example
-               *   Aigle.resolve({
-               *     a: () => Aigle.delay(30, 1),
-               *     b: Aigle.delay(20, 2),
-               *     c: 3
-               *   })
-               *   .parallel()
-               *   .then(object => {
-               *     console.log(object); // { a: 1, b: 2, c: 3 }
-               *   });
-               */
-              Aigle.prototype.parallel = function parallel() {
-                return addProxy(this, Parallel);
-              };
-
-              /**
-               * `Aigle#series` has the same functionality as [`Aigle#parallel`](https://suguru03.github.io/aigle/docs/Aigle.html#parallel)
-               * and it works in series.
-               * @example
-               *   Aigle.resolve([
-               *     () => Aigle.delay(30, 1),
-               *     Aigle.delay(20, 2),
-               *     3
-               *   ])
-               *   .series()
-               *   .then(array => {
-               *     console.log(array); // [1, 2, 3]
-               *   });
-               *
-               * @example
-               *   Aigle.resolve({
-               *     a: () => Aigle.delay(30, 1),
-               *     b: Aigle.delay(20, 2),
-               *     c: 3
-               *   })
-               *   .series()
-               *   .then(object => {
-               *     console.log(object); // { a: 1, b: 2, c: 3 }
-               *   });
-               */
-              Aigle.prototype.series = function series() {
-                return addProxy(this, Series);
-              };
-
-              /**
-               * `Aigle#parallelLimit` has the same functionality as [`Aigle#parallel`](https://suguru03.github.io/aigle/docs/Aigle.html#parallel)
-               * and it works with concurrency.
-               * @param {number} [limit=8]
-               * @example
-               *   Aigle.resolve([
-               *     () => Aigle.delay(30, 1),
-               *     Aigle.delay(20, 2),
-               *     3
-               *   ])
-               *   .parallelLimit()
-               *   .then(array => {
-               *     console.log(array); // [1, 2, 3]
-               *   });
-               *
-               * @example
-               *   Aigle.resolve({
-               *     a: () => Aigle.delay(30, 1),
-               *     b: Aigle.delay(20, 2),
-               *     c: 3
-               *   })
-               *   .parallelLimit(2)
-               *   .then(object => {
-               *     console.log(object); // { a: 1, b: 2, c: 3 }
-               *   });
-               */
-              Aigle.prototype.parallelLimit = function parallelLimit(limit) {
-                return addProxy(this, ParallelLimit, limit);
-              };
-
-              /**
-               * `Aigle#each` will execute [`Aigle.each`](https://suguru03.github.io/aigle/docs/global.html#each) using a previous promise value and a defined iterator.
-               * The value will be assigned as the first argument to [`Aigle.each`](https://suguru03.github.io/aigle/docs/global.html#each) and
-               * the iterator will be assigned as the second argument.
-               * @param {Function} iterator
-               * @example
-               *   const order = [];
-               *   const collection = [1, 4, 2];
-               *   const iterator = (num, value, collection) => {
-               *     return Aigle.delay(num * 10)
-               *       .then(() => order.push(num));
-               *   };
-               *   return Aigle.resolve(collection)
-               *     .each(iterator)
-               *     .then(value => {
-               *       console.log(value); // undefined
-               *       console.log(order); // [1, 2, 4];
-               *     });
-               *
-               * @example
-               *   const order = [];
-               *   const collection = { a: 1, b: 4, c: 2 };
-               *   const iterator = (num, key, collection) => {
-               *     return Aigle.delay(num * 10)
-               *       .then(() => order.push(num));
-               *   };
-               *   return Aigle.resolve(collection)
-               *     .each(iterator)
-               *     .then(value => {
-               *       console.log(value); // undefined
-               *       console.log(order); // [1, 2, 4];
-               *     });
-               *
-               * @example
-               *   const order = [];
-               *   const collection = [1, 4, 2];
-               *   const iterator = (num, value, collection) => {
-               *     return Aigle.delay(num * 10)
-               *       .then(() => {
-               *         order.push(num);
-               *         return num !== 2; // break
-               *       });
-               *   };
-               *   return Aigle.resolve(collection)
-               *     .each(iterator)
-               *     .then(value => {
-               *       console.log(value); // undefined
-               *       console.log(order); // [1, 2];
-               *     });
-               */
-              Aigle.prototype.each = function each(iterator) {
-                return addProxy(this, Each, iterator);
-              };
-
-              /**
-               * @alias each
-               * @param {Function} iterator
-               */
-              Aigle.prototype.forEach = function forEach(iterator) {
-                return addProxy(this, Each, iterator);
-              };
-
-              /**
-               * `Aigle#eachSeries` is almost the same as [`Aigle#each`](https://suguru03.github.io/aigle/docs/Aigle.html#each), but it will work in series.
-               * @param {Function} iterator
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = (num, index, collection) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => order.push(num));
-               * };
-               * Aigle.resolve(collection)
-               *   .eachSeries(iterator)
-               *   .then(value => {
-               *     console.log(value); // undefined
-               *     console.log(order); // [1, 4, 2];
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = { a: 1, b: 4, c: 2 };
-               * const iterator = (num, index, collection) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => order.push(num));
-               * };
-               * Aigle.resolve(collection)
-               *   .eachSeries(iterator)
-               *   .then(value => {
-               *     console.log(value); // undefined
-               *     console.log(order); // [1, 4, 2];
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num !== 4; // break
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .eachSeries(iterator)
-               *   .then(value => {
-               *     console.log(value); // undefined
-               *     console.log(order); // [1, 4];
-               *   });
-               */
-              Aigle.prototype.eachSeries = function eachSeries(iterator) {
-                return addProxy(this, EachSeries, iterator);
-              };
-
-              /**
-               * @alias eachSeries
-               * @param {Function} iterator
-               */
-              Aigle.prototype.forEachSeries = function forEachSeries(iterator) {
-                return addProxy(this, EachSeries, iterator);
-              };
-
-              /**
-               * `Aigle#eachLimit` is almost the same as [`Aigle.each`](https://suguru03.github.io/aigle/docs/Aigle.html#each) and
-               * [`Aigle.eachSeries`](https://suguru03.github.io/aigle/docs/Aigle.html#eachSeries), but it will work with concurrency.
-               * @param {number} [limit=8]
-               * @param {Function} iterator
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const collection = [1, 5, 3, 4, 2];
-               * return Aigle.resolve(collection)
-               *   .eachLimit(2, (num, index, collection) => {
-               *     return new Aigle(resolve => setTimeout(() => {
-               *       console.log(num); // 1, 3, 5, 2, 4
-               *       resolve(num);
-               *     }, num * 10));
-               *   });
-               *
-               * @example
-               * const collection = [1, 5, 3, 4, 2];
-               * return Aigle.resolve(collection)
-               *   .eachLimit((num, index, collection) => {
-               *     return new Aigle(resolve => setTimeout(() => {
-               *       console.log(num); // 1, 2, 3, 4, 5
-               *       resolve(num);
-               *     }, num * 10));
-               *   });
-               */
-              Aigle.prototype.eachLimit = function eachLimit(limit, iterator) {
-                return addProxy(this, EachLimit, limit, iterator);
-              };
-
-              /**
-               * @alias eachLimit
-               * @param {number} [limit=8]
-               * @param {Function} iterator
-               */
-              Aigle.prototype.forEachLimit = function forEachLimit(limit, iterator) {
-                return addProxy(this, EachLimit, limit, iterator);
-              };
-
-              /**
-               * `Aigle#map` will execute [`Aigle.map`](https://suguru03.github.io/aigle/docs/global.html#map) using a previous promise value and a defined iterator.
-               * The value will be assigned as the first argument to [`Aigle.map`](https://suguru03.github.io/aigle/docs/global.html#map) and
-               * the iterator will be assigned as the second argument.
-               * @param {Function|string} iterator - if you define string, you can use shorthand which is similar to lodash
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num * 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .map(iterator)
-               *   .then(array => {
-               *     console.log(array); // [2, 8, 4]
-               *     console.log(order); // [1, 2, 4]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = { a: 1, b: 4, c: 2 };
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num * 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .map(iterator)
-               *   .then(array => {
-               *     console.log(array); // [2, 8, 4]
-               *     console.log(order); // [1, 2, 4]
-               *   });
-               *
-               * @example
-               * const collection = [{
-               *  uid: 1, name: 'test1'
-               * }, {
-               *  uid: 4, name: 'test4'
-               * }, {
-               *  uid: 2, name: 'test2'
-               * }];
-               * Aigle.resolve(collection)
-               *   .map('uid')
-               *   .then(uids => console.log(uids)); // [1, 4, 2]
-               *
-               * @example
-               * const collection = {
-               *   task1: { uid: 1, name: 'test1' },
-               *   task2: { uid: 4, name: 'test4' },
-               *   task3: { uid: 2, name: 'test2' }
-               * }];
-               * Aigle.resolve(collection)
-               *   .map('uid')
-               *   .then(uids => console.log(uids)); // [1, 4, 2]
-               */
-              Aigle.prototype.map = function map(iterator) {
-                return addProxy(this, Map, iterator);
-              };
-
-              /**
-               * `Aigle#mapSeries` is almost the same as [`Aigle#map`](https://suguru03.github.io/aigle/docs/Aigle.html#map), but it will work in series.
-               * @param {Function} iterator
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num * 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .mapSeries(iterator)
-               *   .then(array => {
-               *     console.log(array); // [2, 8, 4]
-               *     console.log(order); // [1, 4, 2]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = { a: 1, b: 4, c: 2 };
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num * 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .mapSeries(iterator)
-               *   .then(array => {
-               *     console.log(array); // [2, 8, 4]
-               *     console.log(order); // [1, 4, 2]
-               *   });
-               */
-              Aigle.prototype.mapSeries = function mapSeries(iterator) {
-                return addProxy(this, MapSeries, iterator);
-              };
-
-              /**
-               * `Aigle#mapLimit` is almost the same as [`Aigle#map`](https://suguru03.github.io/aigle/docs/Aigle.html#map)
-               * and [`Aigle#mapSeries`](https://suguru03.github.io/aigle/docs/Aigle.html#mapSeries)), but it will work with concurrency.
-               * @param {integer} [limit=8]
-               * @param {Function} iterator
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const collection = [1, 5, 3, 4, 2];
-               * const iterator = (num, index) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num * 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .mapLimit(2, iterator)
-               *   .then(array => {
-               *     console.log(array); // [2, 10, 6, 8, 4];
-               *     console.log(order); // [1, 3, 5, 2, 4];
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = {
-               *   task1: 1,
-               *   task2: 5,
-               *   task3: 3,
-               *   task4: 4,
-               *   task5: 2
-               * };
-               * const iterator = (num, key) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num * 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .mapLimit(2, iterator)
-               *   .then(array => {
-               *     console.log(array); // [2, 10, 6, 8, 4];
-               *     console.log(order); // [1, 3, 5, 2, 4];
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = [1, 5, 3, 4, 2];
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num * 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .mapLimit(iterator)
-               *   .then(array => {
-               *     console.log(array); // [2, 10, 6, 8, 4];
-               *     console.log(order); // [1, 2, 3, 4, 5];
-               *   });
-               */
-              Aigle.prototype.mapLimit = function mapLimit(limit, iterator) {
-                return addProxy(this, MapLimit, limit, iterator);
-              };
-
-              /**
-               * `Aigle#mapValues` will execute [`Aigle.mapValues`](https://suguru03.github.io/aigle/docs/global.html#mapValues) using a previous promise value and a defined iterator.
-               * The value will be assigned as the first argument to [`Aigle.mapValues`](https://suguru03.github.io/aigle/docs/global.html#mapValues) and
-               * the iterator will be assigned as the second argument.
-               * @param {Function|string} iterator - if you define string, you can use shorthand which is similar to lodash
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num * 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .mapValues(iterator)
-               *   .then(object => {
-               *     console.log(object); // { '0': 2, '1': 8, '2': 4 }
-               *     console.log(order); // [1, 2, 4]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = { a: 1, b: 4, c: 2 };
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num * 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .mapValues(iterator)
-               *   .then(object => {
-               *     console.log(object); // { a: 2, b: 8, c: 4 }
-               *     console.log(order); // [1, 2, 4]
-               *   });
-               *
-               * @example
-               * const collection = [{
-               *  uid: 1, name: 'test1'
-               * }, {
-               *  uid: 4, name: 'test4'
-               * }, {
-               *  uid: 2, name: 'test2'
-               * }];
-               * Aigle.resolve(collection)
-               *   .mapValues('uid')
-               *   .then(uids => console.log(uids)); // { '0': 1, '1': 4, '2': 2 }
-               *
-               * @example
-               * const collection = {
-               *   task1: { uid: 1, name: 'test1' },
-               *   task2: { uid: 4, name: 'test4' },
-               *   task3: { uid: 2, name: 'test2' }
-               * }];
-               * Aigle.resolve(collection)
-               *   .mapValues('uid')
-               *   .then(uids => console.log(uids)); // { task1: 1, task2: 4, task3: 2 }
-               */
-              Aigle.prototype.mapValues = function mapValues(iterator) {
-                return addProxy(this, MapValues, iterator);
-              };
-
-              /**
-               * `Aigle#mapValuesSeries` is almost the same as [`Aigle#mapValues`](https://suguru03.github.io/aigle/docs/Aigle.html#mapValues), but it will work in series.
-               * @param {Function} iterator
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num * 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .mapValuesSeries(iterator)
-               *   .then(object => {
-               *     console.log(object); // { '0': 2, '1': 8, '2': 4 }
-               *     console.log(order); // [1, 4, 2]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = { a: 1, b: 4, c: 2 };
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num * 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .mapValuesSeries(iterator)
-               *   .then(object => {
-               *     console.log(object); // { a: 2, b: 8, c: 4 }
-               *     console.log(order); // [1, 4, 2]
-               *   });
-               */
-              Aigle.prototype.mapValuesSeries = function mapValuesSeries(iterator) {
-                return addProxy(this, MapValuesSeries, iterator);
-              };
-
-              /**
-               * `Aigle#mapValuesLimit` is almost the same as [`Aigle#mapValues`](https://suguru03.github.io/aigle/docs/Aigle.html#mapValues)
-               * and [`Aigle#mapValuesSeries`](https://suguru03.github.io/aigle/docs/Aigle.html#mapValuesSeries)), but it will work with concurrency.
-               * @param {number} [limit=8]
-               * @param {Function} iterator
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const collection = [1, 5, 3, 4, 2];
-               * const iterator = (num, index) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num * 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .mapValuesLimit(2, iterator)
-               *   .then(object => {
-               *     console.log(object); // { '0': 2, '1': 10, '2': 6, '3': 8, '4': 4 }
-               *     console.log(order); // [1, 3, 5, 2, 4]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = { a: 1, b: 5, c: 3, d: 4, e: 2 };
-               * const iterator = (num, key) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num * 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .mapValuesLimit(2, iterator)
-               *   .then(object => {
-               *     console.log(object); // { a: 2, b: 10, c: 6, d: 8, e: 4 }
-               *     console.log(order); // [1, 3, 5, 2, 4]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = [1, 5, 3, 4, 2];
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num * 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .mapValuesLimit(iterator)
-               *   .then(object => {
-               *     console.log(object); // { '0': 2, '1': 10, '2': 6, '3': 8, '4': 4 }
-               *     console.log(order); // [1, 2, 3, 4, 5]
-               *   });
-               */
-              Aigle.prototype.mapValuesLimit = function mapValuesLimit(limit, iterator) {
-                return addProxy(this, MapValuesLimit, limit, iterator);
-              };
-
-              /**
-               * `Aigle#filter` will execute [`Aigle.filter`](https://suguru03.github.io/aigle/docs/global.html#filter) using a previous promise value and a defined iterator.
-               * The value will be assigned as the first argument to [`Aigle.filter`](https://suguru03.github.io/aigle/docs/global.html#filter) and
-               * the iterator will be assigned as the second argument.
-               * @param {Function|Array|Object|string} iterator
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = (num, index) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .filter(iterator)
-               *   .then(array => {
-               *     console.log(array); // [1];
-               *     console.log(order); // [1, 2, 4];
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = { a: 1, b: 4, c: 2 };
-               * const iterator = (num, key) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .filter(iterator)
-               *   .then(array => {
-               *     console.log(array); // [1];
-               *     console.log(order); // [1, 2, 4];
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = [{
-               *   name: 'bargey', active: false
-               * }, {
-               *   name: 'fread', active: true
-               * }];
-               * Aigle.resolve(collection)
-               *   .filter('active')
-               *   .then(array => {
-               *     console.log(array); // [{ name: 'fread', active: true }]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = [{
-               *   name: 'bargey', active: false
-               * }, {
-               *   name: 'fread', active: true
-               * }];
-               * Aigle.resolve(collection)
-               *   .filter(['name', 'fread'])
-               *   .then(array => {
-               *     console.log(array); // [{ name: 'fread', active: true }]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = [{
-               *   name: 'bargey', active: false
-               * }, {
-               *   name: 'fread', active: true
-               * }];
-               * Aigle.resolve(collection)
-               *   .filter({ name: 'fread', active: true })
-               *   .then(array => {
-               *     console.log(array); // [{ name: 'fread', active: true }]
-               *   });
-               */
-              Aigle.prototype.filter = function filter(iterator) {
-                return addProxy(this, Filter, iterator);
-              };
-
-              /**
-               * `Aigle#filterSeries` is almost the same as [`Aigle#filter`](https://suguru03.github.io/aigle/docs/Aigle.html#filter), but it will work in series.
-               * @param {Function} iterator
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = (num, index) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .filterSeries(iterator)
-               *   .then(array => {
-               *     console.log(array); // [1];
-               *     console.log(order); // [1, 4, 2];
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = { a: 1, b: 4, c: 2 };
-               * const iterator = (num, key) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .filterSeries(iterator)
-               *   .then(array => {
-               *     console.log(array); // [1];
-               *     console.log(order); // [1, 4, 2];
-               *   });
-               */
-              Aigle.prototype.filterSeries = function filterSeries(iterator) {
-                return addProxy(this, FilterSeries, iterator);
-              };
-
-              /**
-               * `Aigle#filterLimit` is almost the same as [`Aigle#filter`](https://suguru03.github.io/aigle/docs/Aigle.html#filter)
-               * and [`Aigle#filterSeries`](https://suguru03.github.io/aigle/docs/Aigle.html#filterSeries)), but it will work with concurrency.
-               * @param {integer} [limit=8]
-               * @param {Function} iterator
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const collection = [1, 5, 3, 4, 2];
-               * const iterator = (num, index) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .filterLimit(2, iterator)
-               *   .then(array => {
-               *     console.log(array); // [1, 5, 3];
-               *     console.log(order); // [1, 3, 5, 2, 4];
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = {
-               *   task1: 1,
-               *   task2: 5,
-               *   task3: 3,
-               *   task4: 4,
-               *   task5: 2
-               * };
-               * const iterator = (num, key) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .filterLimit(2, iterator)
-               *   .then(array => {
-               *     console.log(array); // [1, 5, 3];
-               *     console.log(order); // [1, 3, 5, 2, 4];
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = [1, 5, 3, 4, 2];
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .filterLimit(iterator)
-               *   .then(array => {
-               *     console.log(array); // [1, 5, 3];
-               *     console.log(order); // [1, 2, 3, 4, 5];
-               *   });
-               */
-              Aigle.prototype.filterLimit = function filterLimit(limit, iterator) {
-                return addProxy(this, FilterLimit, limit, iterator);
-              };
-
-              /**
-               * @param {Function|string} iterator
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = (num, index) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .reject(iterator)
-               *   .then(array => {
-               *     console.log(array); // [4, 2];
-               *     console.log(order); // [1, 2, 4];
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = { a: 1, b: 4, c: 2 };
-               * const iterator = (num, key) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .reject(iterator)
-               *   .then(array => {
-               *     console.log(array); // [4, 2];
-               *     console.log(order); // [1, 2, 4];
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = [{
-               *   name: 'bargey', active: false
-               * }, {
-               *   name: 'fread', active: true
-               * }];
-               * Aigle.collection(collection)
-               *   .reject('active')
-               *   .then(array => {
-               *     console.log(array); // [{ name: 'fread', active: false }]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = [{
-               *   name: 'bargey', active: false
-               * }, {
-               *   name: 'fread', active: true
-               * }];
-               * Aigle.collection(collection)
-               *   .reject(['name', 'bargey'])
-               *   .then(array => {
-               *     console.log(array); // [{ name: 'fread', active: false }]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = [{
-               *   name: 'bargey', active: false
-               * }, {
-               *   name: 'fread', active: true
-               * }];
-               * Aigle.collection(collection)
-               *   .reject({ name: 'bargey', active: false })
-               *   .then(array => {
-               *     console.log(array); // [{ name: 'fread', active: false }]
-               *   });
-               */
-              Aigle.prototype.reject = function reject(iterator) {
-                return addProxy(this, Reject, iterator);
-              };
-
-              /**
-               * @param {Function} iterator
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = (num, index) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .rejectSeries(iterator)
-               *   .then(array => {
-               *     console.log(array); // [4, 2];
-               *     console.log(order); // [1, 4, 2];
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = { a: 1, b: 4, c: 2 };
-               * const iterator = (num, key) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .rejectSeries(iterator)
-               *   .then(array => {
-               *     console.log(array); // [4, 2];
-               *     console.log(order); // [1, 4, 2];
-               *   });
-               */
-              Aigle.prototype.rejectSeries = function rejectSeries(iterator) {
-                return addProxy(this, RejectSeries, iterator);
-              };
-
-              /**
-               * @param {number} [limit=8]
-               * @param {Function} iterator
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const collection = [1, 5, 3, 4, 2];
-               * const iterator = (num, index) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .rejectLimit(2, iterator)
-               *   .then(array => {
-               *     console.log(array); // [4, 2]
-               *     console.log(order); // [1, 3, 5, 2, 4]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = { a: 1, b: 5, c: 3, d: 4, e: 2 };
-               * const iterator = (num, key) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .rejectLimit(2, iterator)
-               *   .then(array => {
-               *     console.log(array); // [4, 2]
-               *     console.log(order); // [1, 3, 5, 2, 4]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = [1, 5, 3, 4, 2];
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .rejectLimit(iterator)
-               *   .then(array => {
-               *     console.log(array); // [4, 2]
-               *     console.log(order); // [1, 2, 3, 4, 5]
-               *   });
-               */
-              Aigle.prototype.rejectLimit = function rejectLimit(limit, iterator) {
-                return addProxy(this, RejectLimit, limit, iterator);
-              };
-
-              /**
-               * `Aigle#find` will execute [`Aigle.find`](https://suguru03.github.io/aigle/docs/global.html#find) using a previous promise value and a defined iterator.
-               * The value will be assigned as the first argument to [`Aigle.find`](https://suguru03.github.io/aigle/docs/global.html#find) and
-               * the iterator will be assigned as the second argument.
-               * @param {Function|Array|Object|string} iterator
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2 === 0;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .find(iterator)
-               *   .then(value => {
-               *     console.log(value); // 2
-               *     console.log(order); // [1, 2];
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = { a: 1, b: 4, c: 2 };
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2 === 0;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .find(iterator)
-               *   .then(value => {
-               *     console.log(value); // 2
-               *     console.log(order); // [1, 2];
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return false;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .find(iterator)
-               *   .then(value => {
-               *     console.log(value); // undefined
-               *     console.log(order); // [1, 2, 4];
-               *   });
-               *
-               * @example
-               * const collection = [{
-               *   name: 'bargey', active: false
-               * }, {
-               *   name: 'fread', active: true
-               * }];
-               * Aigle.resolve(collection)
-               *   .find('active')
-               *   .then(object => {
-               *     console.log(object); // { name: 'fread', active: true }
-               *   });
-               *
-               * @example
-               * const collection = [{
-               *   name: 'bargey', active: false
-               * }, {
-               *   name: 'fread', active: true
-               * }];
-               * Aigle.resolve(collection)
-               *   .find(['name', 'fread'])
-               *   .then(object => {
-               *     console.log(object); // { name: 'fread', active: true }
-               *   });
-               *
-               * @example
-               * const collection = [{
-               *   name: 'bargey', active: false
-               * }, {
-               *   name: 'fread', active: true
-               * }];
-               * Aigle.resolve(collection)
-               *   .find({ name: 'fread', active: true })
-               *   .then(object => {
-               *     console.log(object); // { name: 'fread', active: true }
-               *   });
-               */
-              Aigle.prototype.find = function find(iterator) {
-                return addProxy(this, Find, iterator);
-              };
-
-              /**
-               * `Aigle#findSeries` is almost the same as [`Aigle#find`](https://suguru03.github.io/aigle/docs/Aigle.html#find), but it will work in series.
-               * @param {Function} iterator
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2 === 0;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .findSeries(iterator)
-               *   .then(value => {
-               *     console.log(value); // 4
-               *     console.log(order); // [1, 4];
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = { a: 1, b: 4, c: 2 };
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2 === 0;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .findSeries(iterator)
-               *   .then(value => {
-               *     console.log(value); // 4
-               *     console.log(order); // [1, 4];
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return false;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .findSeries(iterator)
-               *   .then(value => {
-               *     console.log(value); // undefined
-               *     console.log(order); // [1, 4, 2];
-               *   });
-               */
-              Aigle.prototype.findSeries = function findSeries(iterator) {
-                return addProxy(this, FindSeries, iterator);
-              };
-
-              /**
-               * `Aigle#findLimit` is almost the same as [`Aigle#find`](https://suguru03.github.io/aigle/docs/Aigle.html#find)
-               * and [`Aigle#findSeries`](https://suguru03.github.io/aigle/docs/Aigle.html#findSeries)), but it will work with concurrency.
-               * @param {integer} [limit=8]
-               * @param {Function} iterator
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const collection = [1, 5, 3, 4, 2];
-               * const iterator = (num, index) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2 === 0;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .findLimit(2, iterator)
-               *   .then(value => {
-               *     console.log(value); // 2
-               *     console.log(order); // [1, 3, 5, 2];
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = {
-               *   task1: 1,
-               *   task2: 5,
-               *   task3: 3,
-               *   task4: 4,
-               *   task5: 2
-               * };
-               * const iterator = (num, key) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2 === 0;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .findLimit(2, iterator)
-               *   .then(value => {
-               *     console.log(value); // 2
-               *     console.log(order); // [1, 3, 5, 2];
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = [1, 5, 3, 4, 2];
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2 === 0;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .findLimit(2, iterator)
-               *   .then(value => {
-               *     console.log(value); // 2
-               *     console.log(order); // [1, 2];
-               *   });
-               */
-              Aigle.prototype.findLimit = function findLimit(limit, iterator) {
-                return addProxy(this, FindLimit, limit, iterator);
-              };
-
-              /**
-               * `Aigle#findIndex` will execute [`Aigle.findIndex`](https://suguru03.github.io/aigle/docs/global.html#findIndex) using a previous promise value and a defined iterator.
-               * The value will be assigned as the first argument to [`Aigle.findIndex`](https://suguru03.github.io/aigle/docs/global.html#findIndex) and
-               * the iterator will be assigned as the second argument.
-               * @param {Function|Array|Object|string} iterator
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2 === 0;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .findIndex(iterator)
-               *   .then(index => {
-               *     console.log(index); // 2
-               *     console.log(order); // [1, 2];
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return false;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .findIndex(iterator)
-               *   .then(index => {
-               *     console.log(index); // -1
-               *     console.log(order); // [1, 2, 4];
-               *   });
-               *
-               * @example
-               * const collection = [{
-               *   name: 'bargey', active: false
-               * }, {
-               *   name: 'fread', active: true
-               * }];
-               * Aigle.resolve(collection)
-               *   .findIndex('active')
-               *   .then(index => {
-               *     console.log(index); // 1
-               *   });
-               *
-               * @example
-               * const collection = [{
-               *   name: 'bargey', active: false
-               * }, {
-               *   name: 'fread', active: true
-               * }];
-               * Aigle.resolve(collection)
-               *   .findIndex(['name', 'fread'])
-               *   .then(index => {
-               *     console.log(index); // 1
-               *   });
-               *
-               * @example
-               * const collection = [{
-               *   name: 'bargey', active: false
-               * }, {
-               *   name: 'fread', active: true
-               * }];
-               * Aigle.resolve(collection)
-               *   .findIndex({ name: 'fread', active: true })
-               *   .then(index => {
-               *     console.log(index); // 1
-               *   });
-               */
-              Aigle.prototype.findIndex = function findIndex(iterator) {
-                return addProxy(this, FindIndex, iterator);
-              };
-
-              /**
-               * `Aigle#findIndexSeries` is almost the same as [`Aigle#findIndex`](https://suguru03.github.io/aigle/docs/Aigle.html#findIndex), but it will work in series.
-               * @param {Function} iterator
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2 === 0;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .findIndexSeries(iterator)
-               *   .then(index => {
-               *     console.log(index); // 2
-               *     console.log(order); // [1, 4];
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return false;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .findIndexSeries(iterator)
-               *   .then(index => {
-               *     console.log(index); // -1
-               *     console.log(order); // [1, 4, 2];
-               *   });
-               */
-              Aigle.prototype.findIndexSeries = function findIndexSeries(iterator) {
-                return addProxy(this, FindIndexSeries, iterator);
-              };
-
-              /**
-               * `Aigle#findIndexLimit` is almost the same as [`Aigle#findIndex`](https://suguru03.github.io/aigle/docs/Aigle.html#findIndex)
-               * and [`Aigle#findIndexSeries`](https://suguru03.github.io/aigle/docs/Aigle.html#findIndexSeries)), but it will work with concurrency.
-               * @param {integer} [limit=8]
-               * @param {Function} iterator
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const collection = [1, 5, 3, 4, 2];
-               * const iterator = (num, index) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2 === 0;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .findIndexLimit(2, iterator)
-               *   .then(index => {
-               *     console.log(index); // 4
-               *     console.log(order); // [1, 3, 5, 2];
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = [1, 5, 3, 4, 2];
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2 === 0;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .findIndexLimit(2, iterator)
-               *   .then(index => {
-               *     console.log(index); // 4
-               *     console.log(order); // [1, 2];
-               *   });
-               */
-              Aigle.prototype.findIndexLimit = function findIndexLimit(limit, iterator) {
-                return addProxy(this, FindIndexLimit, limit, iterator);
-              };
-
-              /**
-               * @param {Function} iterator
-               * @return {Aigle} Returns an Aigle instance
-               */
-              Aigle.prototype.findKey = function findKey(iterator) {
-                return addProxy(this, FindKey, iterator);
-              };
-
-              /**
-               * @param {Function} iterator
-               * @return {Aigle} Returns an Aigle instance
-               */
-              Aigle.prototype.findKeySeries = function findKeySeries(iterator) {
-                return addProxy(this, FindKeySeries, iterator);
-              };
-
-              /**
-               * @param {integer} [limit=8]
-               * @param {Function} iterator
-               * @return {Aigle} Returns an Aigle instance
-               */
-              Aigle.prototype.findKeyLimit = function findKeyLimit(limit, iterator) {
-                return addProxy(this, FindKeyLimit, limit, iterator);
-              };
-
-              /**
-               * @param {*} iterator
-               * @param {*} [args]
-               * @return {Aigle} Returns an Aigle instance
-               */
-              Aigle.prototype.pick = function pick(iterator) {
-                var args = [],
-                  len = arguments.length - 1;
-                while (len-- > 0) args[len] = arguments[len + 1];
-
-                return addProxy(this, Pick, iterator, args);
-              };
-
-              /**
-               * @alias pickBySeries
-               * @param {Function} iterator
-               */
-              Aigle.prototype.pickSeries = function pickSeries(iterator) {
-                return this.pickBySeries(iterator);
-              };
-
-              /**
-               * @alias pickByLimit
-               * @param {number} [limit=8]
-               * @param {Function} iterator
-               */
-              Aigle.prototype.pickLimit = function pickLimit(limit, iterator) {
-                return this.pickByLimit(limit, iterator);
-              };
-
-              /**
-               * `Aigle#pickBy` will execute [`Aigle.pickBy`](https://suguru03.github.io/aigle/docs/global.html#pickBy) using a previous promise value and a defined iterator.
-               * The value will be assigned as the first argument to [`Aigle.pickBy`](https://suguru03.github.io/aigle/docs/global.html#pickBy) and
-               * the iterator will be assigned as the second argument.
-               * @param {Function|string} iterator
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .pickBy(iterator)
-               *   .then(object => {
-               *     console.log(object); // { '0': 1 }
-               *     console.log(order); // [1, 2, 4]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = { a: 1, b: 4, c: 2 };
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num * 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .pickBy(iterator)
-               *   .then(object => {
-               *     console.log(object); // { a: 1 }
-               *     console.log(order); // [1, 2, 4]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = [{
-               *   name: 'bargey', active: false
-               * }, {
-               *   name: 'fread', active: true
-               * }];
-               * Aigle.resolve(collection)
-               *   .pickBy('active')
-               *   .then(object => {
-               *     console.log(object); // { '1': { name: 'fread', active: true } }
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = [{
-               *   name: 'bargey', active: false
-               * }, {
-               *   name: 'fread', active: true
-               * }];
-               * Aigle.resolve(collection)
-               *   .pickBy(['name', 'fread'])
-               *   .then(object => {
-               *     console.log(object); // { '1': { name: 'fread', active: true } }
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = [{
-               *   name: 'bargey', active: false
-               * }, {
-               *   name: 'fread', active: true
-               * }];
-               * Aigle.resolve(collection)
-               *   .pickBy({ name: 'fread', active: true })
-               *   .then(object => {
-               *     console.log(object); // { '1': { name: 'fread', active: true } }
-               *   });
-               */
-              Aigle.prototype.pickBy = function pickBy(iterator) {
-                return addProxy(this, PickBy, iterator);
-              };
-
-              /**
-               * `Aigle#pickBySeries` is almost the same as [`Aigle#pickBy`](https://suguru03.github.io/aigle/docs/Aigle.html#pickBy), but it will work in series.
-               * @param {Function} iterator
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .pickBySeries(iterator)
-               *   .then(object => {
-               *     console.log(object); // { '0': 1 }
-               *     console.log(order); // [1, 4, 2]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = { a: 1, b: 4, c: 2 };
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num * 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .pickBySeries(iterator)
-               *   .then(object => {
-               *     console.log(object); // { a: 1 }
-               *     console.log(order); // [1, 4, 2]
-               *   });
-               */
-              Aigle.prototype.pickBySeries = function pickBySeries(iterator) {
-                return addProxy(this, PickBySeries, iterator);
-              };
-
-              /**
-               * `Aigle#pickByLimit` is almost the same as [`Aigle#pickBy`](https://suguru03.github.io/aigle/docs/Aigle.html#pickBy)
-               * and [`Aigle#pickBySeries`](https://suguru03.github.io/aigle/docs/Aigle.html#pickBySeries)), but it will work with concurrency.
-               * @param {number} [limit=8]
-               * @param {Function} iterator
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const collection = [1, 5, 3, 4, 2];
-               * const iterator = (num, index) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .pickByLimit(2, iterator)
-               *   .then(object => {
-               *     console.log(object); // { '0': 1, '1': 5, '2': 3 }
-               *     console.log(order); // [1, 3, 5, 2, 4]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = { a: 1, b: 5, c: 3, d: 4, e: 2 };
-               * const iterator = (num, key) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .pickByLimit(2, iterator)
-               *   .then(object => {
-               *     console.log(object); // { a: 1, b: 5, c: 3 }
-               *     console.log(order); // [1, 3, 5, 2, 4]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = [1, 5, 3, 4, 2];
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .pickByLimit(iterator)
-               *   .then(object => {
-               *     console.log(object); // { '0': 1, '1': 5, '2': 3 }
-               *     console.log(order); // [1, 2, 3, 4, 5]
-               *   });
-               */
-              Aigle.prototype.pickByLimit = function pickByLimit(limit, iterator) {
-                return addProxy(this, PickByLimit, limit, iterator);
-              };
-
-              /**
-               * @param {*} iterator
-               * @param {*} [args]
-               * @return {Aigle} Returns an Aigle instance
-               */
-              Aigle.prototype.omit = function omit(iterator) {
-                var args = [],
-                  len = arguments.length - 1;
-                while (len-- > 0) args[len] = arguments[len + 1];
-
-                return addProxy(this, Omit, iterator, args);
-              };
-
-              /**
-               * @alias omitBySeries
-               * @param {Function} iterator
-               */
-              Aigle.prototype.omitSeries = function omitSeries(iterator) {
-                return this.omitBySeries(iterator);
-              };
-
-              /**
-               * @alias omitByLimit
-               * @param {number} [limit=8]
-               * @param {Function} iterator
-               */
-              Aigle.prototype.omitLimit = function omitLimit(limit, iterator) {
-                return this.omitByLimit(limit, iterator);
-              };
-
-              /**
-               * `Aigle#omitBy` will execute [`Aigle.omitBy`](https://suguru03.github.io/aigle/docs/global.html#omitBy) using a previous promise value and a defined iterator.
-               * The value will be assigned as the first argument to [`Aigle.omitBy`](https://suguru03.github.io/aigle/docs/global.html#omitBy) and
-               * the iterator will be assigned as the second argument.
-               * @param {Function|Array|Object|string} iterator
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .omitBy(iterator)
-               *   .then(object => {
-               *     console.log(object); // { '1': 4, '2': 4 }
-               *     console.log(order); // [1, 2, 4]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = { a: 1, b: 4, c: 2 };
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .omitBy(iterator)
-               *   .then(object => {
-               *     console.log(object); // { b: 4, c: 2 }
-               *     console.log(order); // [1, 2, 4]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = [{
-               *   name: 'bargey', active: false
-               * }, {
-               *   name: 'fread', active: true
-               * }];
-               * Aigle.resolve(collection)
-               *   .omitBy('active')
-               *   .then(object => {
-               *     console.log(object); // { '0': { name: 'bargey', active: false } }
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = [{
-               *   name: 'bargey', active: false
-               * }, {
-               *   name: 'fread', active: true
-               * }];
-               * Aigle.resolve(collection)
-               *   .omitBy(['name', 'fread'])
-               *   .then(object => {
-               *     console.log(object); // { '0': { name: 'bargey', active: false } }
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = [{
-               *   name: 'bargey', active: false
-               * }, {
-               *   name: 'fread', active: true
-               * }];
-               * Aigle.resolve(collection)
-               *   .omitBy({ name: 'fread', active: true })
-               *   .then(object => {
-               *     console.log(object); // { '0': { name: 'bargey', active: false } }
-               *   });
-               */
-              Aigle.prototype.omitBy = function omitBy(iterator) {
-                return addProxy(this, OmitBy, iterator);
-              };
-
-              /**
-               * `Aigle#omitBySeries` is almost the same as [`Aigle#omitBy`](https://suguru03.github.io/aigle/docs/Aigle.html#omitBy), but it will work in series.
-               * @param {Function} iterator
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .omitBySeries(iterator)
-               *   .then(object => {
-               *     console.log(object); // { '1': 4, '2': 4 }
-               *     console.log(order); // [1, 4, 2]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = { a: 1, b: 4, c: 2 };
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .omitBySeries(iterator)
-               *   .then(object => {
-               *     console.log(object); // { b: 4, c: 2 }
-               *     console.log(order); // [1, 4, 2]
-               *   });
-               */
-              Aigle.prototype.omitBySeries = function omitBySeries(iterator) {
-                return addProxy(this, OmitBySeries, iterator);
-              };
-
-              /**
-               * `Aigle#omitByLimit` is almost the same as [`Aigle#omitBy`](https://suguru03.github.io/aigle/docs/Aigle.html#omitBy)
-               * and [`Aigle#omitBySeries`](https://suguru03.github.io/aigle/docs/Aigle.html#omitBySeries)), but it will work with concurrency.
-               * @param {number} [limit=8]
-               * @param {Function} iterator
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const collection = [1, 5, 3, 4, 2];
-               * const iterator = (num, index) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .omitByLimit(2, iterator)
-               *   .then(object => {
-               *     console.log(object); // { '3': 4, '4': 2 }
-               *     console.log(order); // [1, 3, 5, 2, 4]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = { a: 1, b: 5, c: 3, d: 4, e: 2 };
-               * const iterator = (num, key) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .omitByLimit(2, iterator)
-               *   .then(object => {
-               *     console.log(object); // { d: 4, e: 2 }
-               *     console.log(order); // [1, 3, 5, 2, 4]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = [1, 5, 3, 4, 2];
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .omitByLimit(iterator)
-               *   .then(object => {
-               *     console.log(object); // { '3': 4, '4': 2 }
-               *     console.log(order); // [1, 2, 3, 4, 5]
-               *   });
-               */
-              Aigle.prototype.omitByLimit = function omitByLimit(limit, iterator) {
-                return addProxy(this, OmitByLimit, limit, iterator);
-              };
-
-              /**
-               * @param {Function} iterator
-               * @param {*} result
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const collection = [1, 4, 2];
-               * const iterator = (result, num, index) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => result + num);
-               * };
-               * return Aigle.resolve(collection)
-               *  .reduce(iterator, 1)
-               *  .then(value => console.log(value)); // 8
-               *
-               * @example
-               * const collection = { a: 1, b: 4, c: 2 };
-               * const iterator = (result, num, key) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => result + num);
-               * };
-               * return Aigle.resolve(collection)
-               *   .reduce(iterator, '')
-               *   .then(value => console.log(value)); // '142'
-               */
-              Aigle.prototype.reduce = function reduce(iterator, result) {
-                return addProxy(this, Reduce, iterator, result);
-              };
-
-              /**
-               * @param {Function} iterator
-               * @param {Array|Object} [accumulator]
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = (result, num, index) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       result[index] = num;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .transform(iterator, {})
-               *   .then(object => {
-               *     console.log(object); // { '0': 1, '1': 4, '2': 2 }
-               *     console.log(order); // [1, 2, 4]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = (result, num, index) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       result.push(num);
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .transform(iterator, {})
-               *   .then(array => {
-               *     console.log(array); // [1, 2, 4]
-               *     console.log(order); // [1, 2, 4]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = { a: 1, b: 4, c: 2 };
-               * const iterator = (result, num, key) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       result.push(num);
-               *       return num !== 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .transform(iterator, [])
-               *   .then(array => {
-               *     console.log(array); // [1, 2]
-               *     console.log(order); // [1, 2]
-               *   });
-               */
-              Aigle.prototype.transform = function transform(iterator, accumulator) {
-                return addProxy(this, Transform, iterator, accumulator);
-              };
-
-              /**
-               * @param {Function} iterator
-               * @param {Array|Object} [accumulator]
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = (result, num, index) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       result[index] = num;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .transformSeries(iterator, {})
-               *   .then(object => {
-               *     console.log(object); // { '0': 1, '1': 4, '2': 2 }
-               *     console.log(order); // [1, 4, 2]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = (result, num, index) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       result.push(num);
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .transformSeries(iterator, {})
-               *   .then(array => {
-               *     console.log(array); // [1, 4, 2]
-               *     console.log(order); // [1, 4, 2]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = { a: 1, b: 4, c: 2 };
-               * const iterator = (result, num, key) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       result.push(num);
-               *       return num !== 4;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .transformSeries(iterator, [])
-               *   .then(array => {
-               *     console.log(array); // [1, 4]
-               *     console.log(order); // [1, 4]
-               *   });
-               */
-              Aigle.prototype.transformSeries = function transformSeries(iterator, accumulator) {
-                return addProxy(this, TransformSeries, iterator, accumulator);
-              };
-
-              /**
-               * @param {number} [limit=8]
-               * @param {Function} iterator
-               * @param {Array|Object} [accumulator]
-               * @example
-               * const order = [];
-               * const collection = [1, 5, 3, 4, 2];
-               * const iterator = (result, num, index) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       result[index] = num;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .transformLimit(2, iterator, {})
-               *   .then(object => {
-               *     console.log(object); // { '0': 1, '1': 5, '2': 3, '3': 4, '4': 2 }
-               *     console.log(order); // [1, 5, 3, 4, 2]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = [1, 5, 3, 4, 2];
-               * const iterator = (result, num, index) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       result.push(num);
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .transformLimit(2, iterator, {})
-               *   .then(array => {
-               *     console.log(array); // [1, 5, 3, 4, 2]
-               *     console.log(order); // [1, 5, 3, 4, 2]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = { a: 1, b: 5, c: 3, d: 4, e: 2 };
-               * const iterator = (result, num, key) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       result.push(num);
-               *       return num !== 4;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .transformLimit(2, iterator, [])
-               *   .then(array => {
-               *     console.log(array); // [1, 5, 3, 4]
-               *     console.log(order); // [1, 5, 3, 4]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = { a: 1, b: 5, c: 3, d: 4, e: 2 };
-               * const iterator = (result, num, key) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       result.push(num);
-               *       return num !== 4;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .transformLimit(iterator, [])
-               *   .then(array => {
-               *     console.log(array); // [1, 2, 3, 4]
-               *     console.log(order); // [1, 2, 3, 4]
-               *   });
-               */
-              Aigle.prototype.transformLimit = function transformLimit(
-                limit,
-                iterator,
-                accumulator
-              ) {
-                return addProxy(this, TransformLimit, limit, iterator, accumulator);
-              };
-
-              /**
-               * `Aigle#sortBy` will execute [`Aigle.sortBy`](https://suguru03.github.io/aigle/docs/global.html#sortBy) using a previous promise value and a defined iterator.
-               * The value will be assigned as the first argument to [`Aigle.sortBy`](https://suguru03.github.io/aigle/docs/global.html#sortBy) and
-               * the iterator will be assigned as the second argument.
-               * @param {Function|string} iterator
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .sortBy(iterator)
-               *   .then(array => {
-               *     console.log(array); // [1, 2, 4]
-               *     console.log(order); // [1, 2, 4]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = { a: 1, b: 4, c: 2 };
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .sortBy(iterator)
-               *   .then(array => {
-               *     console.log(array); // [1, 2, 4]
-               *     console.log(order); // [1, 2, 4]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = [{
-               *   uid: 2, name: 'bargey', uid: 2
-               * }, {
-               *   uid: 1, name: 'fread'
-               * }];
-               * Aigle.resolve(collection)
-               *   .sortBy('uid')
-               *   .then(array => {
-               *     console.log(array); // [{ uid: 1, name: 'fread' }, { uid: 2, name: 'bargey' ]
-               *   });
-               */
-              Aigle.prototype.sortBy = function sortBy(iterator) {
-                return addProxy(this, SortBy, iterator);
-              };
-
-              /**
-               * `Aigle#sortBySeries` is almost the same as [`Aigle#sortBy`](https://suguru03.github.io/aigle/docs/Aigle.html#sortBy), but it will work in series.
-               * @param {Function} iterator
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .sortBySeries(iterator)
-               *   .then(array => {
-               *     console.log(array); // [1, 2, 4]
-               *     console.log(order); // [1, 4, 2]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = { a: 1, b: 4, c: 2 };
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .sortBySeries(iterator)
-               *   .then(array => {
-               *     console.log(array); // [1, 2, 4]
-               *     console.log(order); // [1, 4, 2]
-               *   });
-               */
-              Aigle.prototype.sortBySeries = function sortBySeries(iterator) {
-                return addProxy(this, SortBySeries, iterator);
-              };
-
-              /**
-               * `Aigle#sortByLimit` is almost the same as [`Aigle#sortBy`](https://suguru03.github.io/aigle/docs/Aigle.html#sortBy)
-               * and [`Aigle#sortBySeries`](https://suguru03.github.io/aigle/docs/Aigle.html#sortBySeries)), but it will work with concurrency.
-               * @param {number} [limit=8]
-               * @param {Function} iterator
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const collection = [1, 5, 3, 4, 2];
-               * const iterator = (num, index) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .sortByLimit(2, iterator)
-               *   .then(array => {
-               *     console.log(array); // [1, 2, 3, 4, 5]
-               *     console.log(order); // [1, 3, 5, 2, 4]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = { a: 1, b: 5, c: 3, d: 4, e: 2 };
-               * const iterator = (num, key) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .sortByLimit(2, iterator)
-               *   .then(array => {
-               *     console.log(array); // [1, 2, 3, 4, 5]
-               *     console.log(order); // [1, 3, 5, 2, 4]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = [1, 5, 3, 4, 2];
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .sortByLimit(iterator)
-               *   .then(array => {
-               *     console.log(array); // [1, 2, 3, 4, 5]
-               *     console.log(order); // [1, 2, 3, 4, 5]
-               *   });
-               */
-              Aigle.prototype.sortByLimit = function sortByLimit(limit, iterator) {
-                return addProxy(this, SortByLimit, limit, iterator);
-              };
-
-              /**
-               * `Aigle#some` will execute [`Aigle.some`](https://suguru03.github.io/aigle/docs/global.html#some) using a previous promise value and a defined iterator.
-               * The value will be assigned as the first argument to [`Aigle.some`](https://suguru03.github.io/aigle/docs/global.html#some) and
-               * the iterator will be assigned as the second argument.
-               * @param {Function|string} iterator
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2 === 0;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .some(iterator)
-               *   .then(bool => {
-               *     console.log(bool); // true
-               *     console.log(order); // [1, 2]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = { a: 1, b: 4, c: 2 };
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2 === 0;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .some(iterator)
-               *   .then(bool => {
-               *     console.log(bool); // true
-               *     console.log(order); // [1, 2]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return false;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .some(iterator)
-               *   .then(bool => {
-               *     console.log(bool); // false
-               *     console.log(order); // [1, 2, 4]
-               *   });
-               *
-               * @example
-               * const collection = [{
-               *  uid: 1, active: false
-               * }, {
-               *  uid: 4, active: true
-               * }, {
-               *  uid: 2, active: true
-               * }];
-               * Aigle.resolve(collection)
-               *   .some('active')
-               *   .then(value => console.log(value)); // true
-               *
-               * @example
-               * const collection = [{
-               *  uid: 1, active: false
-               * }, {
-               *  uid: 4, active: true
-               * }, {
-               *  uid: 2, active: true
-               * }];
-               * Aigle.resolve(collection)
-               *   .some(['uid', 4])
-               *   .then(value => console.log(value)); // true
-               *
-               * @example
-               * const collection = [{
-               *  uid: 1, active: false
-               * }, {
-               *  uid: 4, active: true
-               * }, {
-               *  uid: 2, active: true
-               * }];
-               * Aigle.resolve(collection)
-               *   .some({ uid: 4 })
-               *   .then(value => console.log(value)); // true
-               */
-              Aigle.prototype.some = function some(iterator) {
-                return addProxy(this, Some, iterator);
-              };
-
-              /**
-               * `Aigle#someSeries` is almost the same as [`Aigle#some`](https://suguru03.github.io/aigle/docs/Aigle.html#some), but it will work in series.
-               * @param {Function} iterator
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2 === 0;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .someSeries(iterator)
-               *   .then(bool => {
-               *     console.log(bool); // true
-               *     console.log(order); // [1, 4]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = { a: 1, b: 4, c: 2 };
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2 === 0;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .someSeries(iterator)
-               *   .then(bool => {
-               *     console.log(bool); // true
-               *     console.log(order); // [1, 4]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return false;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .someSeries(iterator)
-               *   .then(bool => {
-               *     console.log(bool); // false
-               *     console.log(order); // [1, 4, 2]
-               *   });
-               */
-              Aigle.prototype.someSeries = function someSeries(iterator) {
-                return addProxy(this, SomeSeries, iterator);
-              };
-
-              /**
-               * `Aigle#someLimit` is almost the same as [`Aigle#some`](https://suguru03.github.io/aigle/docs/Aigle.html#some)
-               * and [`Aigle#someSeries`](https://suguru03.github.io/aigle/docs/Aigle.html#someSeries)), but it will work with concurrency.
-               * @param {number} [limit=8]
-               * @param {Function} iterator
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const collection = [1, 5, 3, 4, 2];
-               * const iterator = (num, index) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2 === 0;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .someLimit(2, iterator)
-               *   .then(bool => {
-               *     console.log(bool); // true
-               *     console.log(order); // [1, 3, 5, 2]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = { a: 1, b: 5, c: 3, d: 4, e: 2 };
-               * const iterator = (num, key) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2 === 0;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .someLimit(2, iterator)
-               *   .then(bool => {
-               *     console.log(bool); // true
-               *     console.log(order); // [1, 3, 5, 2]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = [1, 5, 3, 4, 2];
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2 === 0;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .someLimit(2, iterator)
-               *   .then(bool => {
-               *     console.log(bool); // true
-               *     console.log(order); // [1, 2]
-               *   });
-               */
-              Aigle.prototype.someLimit = function someLimit(limit, iterator) {
-                return addProxy(this, SomeLimit, limit, iterator);
-              };
-
-              /**
-               * `Aigle#every` will execute [`Aigle.every`](https://suguru03.github.io/aigle/docs/global.html#every) using a previous promise value and a defined iterator.
-               * The value will be assigned as the first argument to [`Aigle.every`](https://suguru03.github.io/aigle/docs/global.html#every) and
-               * the iterator will be assigned as the second argument.
-               * @param {Function|Array|Object|string} iterator
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = (num, index, collection) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return true;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .every(iterator)
-               *   .then(value => {
-               *     console.log(value); // true
-               *     console.log(order); // [1, 2, 4];
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = { a: 1, b: 4, c: 2 };
-               * const iterator = (num, key, collection) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return true;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .every(iterator)
-               *   .then(value => {
-               *     console.log(value); // true
-               *     console.log(order); // [1, 2, 4];
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return n % 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .every(iterator)
-               *   .then(value => {
-               *     console.log(value); // false
-               *     console.log(order); // [1, 2];
-               *   });
-               *
-               * @example
-               * const collection = [{
-               *  uid: 1, active: false
-               * }, {
-               *  uid: 4, active: true
-               * }, {
-               *  uid: 2, active: true
-               * }];
-               * Aigle.resolve(collection)
-               *   .every('active')
-               *   .then(value => console.log(value)); // false
-               *
-               * @example
-               * const collection = [{
-               *  uid: 1, active: false
-               * }, {
-               *  uid: 4, active: true
-               * }, {
-               *  uid: 2, active: true
-               * }];
-               * Aigle.resolve(collection)
-               *   .every('active')
-               *   .then(value => console.log(value)); // false
-               *
-               * @example
-               * const collection = [{
-               *  uid: 1, active: false
-               * }, {
-               *  uid: 4, active: true
-               * }, {
-               *  uid: 2, active: true
-               * }];
-               * Aigle.resolve(collection)
-               *   .every(['active', true])
-               *   .then(value => console.log(value)); // false
-               *
-               * @example
-               * const collection = [{
-               *  uid: 1, active: true
-               * }, {
-               *  uid: 4, active: true
-               * }, {
-               *  uid: 2, active: true
-               * }];
-               * Aigle.resolve(collection)
-               *   .every({ active: true })
-               *   .then(value => console.log(value)); // true
-               */
-              Aigle.prototype.every = function every(iterator) {
-                return addProxy(this, Every, iterator);
-              };
-
-              /**
-               * `Aigle#everySeries` is almost the same as [`Aigle#every`](https://suguru03.github.io/aigle/docs/Aigle.html#every), but it will work in series.
-               * @param {Function} iterator
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = (num, index, collection) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return true;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .everySeries(iterator)
-               *   .then(value => {
-               *     console.log(value); // true
-               *     console.log(order); // [1, 4, 2];
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = { a: 1, b: 4, c: 2 };
-               * const iterator = (num, key, collection) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return true;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .everySeries(iterator)
-               *   .then(value => {
-               *     console.log(value); // true
-               *     console.log(order); // [1, 4, 2];
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return n % 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .everySeries(iterator)
-               *   .then(value => {
-               *     console.log(value); // false
-               *     console.log(order); // [1, 4];
-               *   });
-               */
-              Aigle.prototype.everySeries = function everySeries(iterator) {
-                return addProxy(this, EverySeries, iterator);
-              };
-
-              /**
-               * `Aigle#everyLimit` is almost the same as [`Aigle#every`](https://suguru03.github.io/aigle/docs/Aigle.html#every) and
-               * [`Aigle#everySeries`](https://suguru03.github.io/aigle/docs/Aigle.html#everySeries), but it will work with concurrency.
-               * @param {number} [limit=8]
-               * @param {Function} iterator
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const collection = [1, 5, 3, 4, 2];
-               * const iterator = (num, index, collection) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return true;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .everyLimit(2, iterator)
-               *   .then(value => {
-               *     console.log(value); // true
-               *     console.log(order); // [1, 3, 5, 2, 4];
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = {
-               *   task1: 1,
-               *   task2: 5,
-               *   task3: 3,
-               *   task4: 4,
-               *   task5: 2
-               * };
-               * const iterator = (num, key, collection) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return true;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .everyLimit(2, iterator)
-               *   .then(value => {
-               *     console.log(value); // true
-               *     console.log(order); // [1, 3, 5, 2, 4];
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = [1, 5, 3, 4, 2];
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num === 4;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .everyLimit(iterator)
-               *   .then(value => {
-               *     console.log(value); // false
-               *     console.log(order); // [1, 2, 3, 4];
-               *   });
-               */
-              Aigle.prototype.everyLimit = function everyLimit(limit, iterator) {
-                return addProxy(this, EveryLimit, limit, iterator);
-              };
-
-              /**
-               * `Aigle#concat` will execute [`Aigle.concat`](https://suguru03.github.io/aigle/docs/global.html#concat) using a previous promise value and a defined iterator.
-               * The value will be assigned as the first argument to [`Aigle.concat`](https://suguru03.github.io/aigle/docs/global.html#concat) and
-               * the iterator will be assigned as the second argument.
-               * @param {Function} iterator
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = (num, index, collectioin) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .concat(iterator)
-               *   .then(array => {
-               *     console.log(array); // [1, 2, 4];
-               *     console.log(order); // [1, 2, 4];
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = { a: 1, b: 4, c: 2 };
-               * const iterator = (num, key, collection) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .concat(iterator)
-               *   .then(array => {
-               *     console.log(array); // [1, 2, 4];
-               *     console.log(order); // [1, 2, 4];
-               *   });
-               */
-              Aigle.prototype.concat = function concat(iterator) {
-                return addProxy(this, Concat, iterator);
-              };
-
-              /**
-               * `Aigle#concatSeries` is almost the same as [`Aigle#concat`](https://suguru03.github.io/aigle/docs/Aigle.html#concat), but it will work in series.
-               * @param {Function} iterator
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = (num, index, collection) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .concatSeries(iterator)
-               *   .then(array => {
-               *     console.log(array); // [1, 4, 2];
-               *     console.log(order); // [1, 4, 2];
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = { a: 1, b: 4, c: 2 };
-               * const iterator = (num, key, collection) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .concatSeries(iterator)
-               *   .then(array => {
-               *     console.log(array); // [1, 4, 2];
-               *     console.log(order); // [1, 4, 2];
-               *   });
-               */
-              Aigle.prototype.concatSeries = function concatSeries(iterator) {
-                return addProxy(this, ConcatSeries, iterator);
-              };
-
-              /**
-               * `Aigle#concatLimit` is almost the same as [`Aigle#concat`](https://suguru03.github.io/aigle/docs/Aigle.html#concat)
-               * and [`Aigle#concatSeries`](https://suguru03.github.io/aigle/docs/Aigle.html#concatSeries)), but it will work with concurrency.
-               * @param {integer} [limit=8]
-               * @param {Function} iterator
-               * @example
-               * const order = [];
-               * const collection = [1, 5, 3, 4, 2];
-               * const iterator = (num, index, collection) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .concatLimit(2, iterator)
-               *   .then(array => {
-               *     console.log(array); // [1, 3, 5, 2, 4];
-               *     console.log(order); // [1, 3, 5, 2, 4];
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = {
-               *   task1: 1,
-               *   task2: 5,
-               *   task3: 3,
-               *   task4: 4,
-               *   task5: 2
-               * };
-               * const iterator = (num, key, collection) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .concatLimit(2, iterator)
-               *   .then(array => {
-               *     console.log(array); // [1, 3, 5, 2, 4];
-               *     console.log(order); // [1, 3, 5, 2, 4];
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = [1, 5, 3, 4, 2];
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .concatLimit(iterator)
-               *   .then(array => {
-               *     console.log(array); // [1, 3, 5, 2, 4];
-               *     console.log(order); // [1, 3, 5, 2, 4];
-               *   });
-               */
-              Aigle.prototype.concatLimit = function concatLimit(limit, iterator) {
-                return addProxy(this, ConcatLimit, limit, iterator);
-              };
-
-              /**
-               * @param {Function|string} iterator
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = (num, index) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .groupBy(iterator)
-               *   .then(object => {
-               *     console.log(object); // { '0': [2, 4], '1': [1] };
-               *     console.log(order); // [1, 2, 4];
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = { a: 1, b: 4, c: 2 };
-               * const iterator = (num, key) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .groupBy(iterator)
-               *   .then(object => {
-               *     console.log(object); // { '0': [2, 4], '1': [1] };
-               *     console.log(order); // [1, 2, 4];
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = ['one', 'two', 'three'];
-               * Aigle.resolve(collection)
-               *   .groupBy('length')
-               *   .then(object => {
-               *     console.log(object); // { '3': ['one', 'two'], '5': ['three'] };
-               *   });
-               */
-              Aigle.prototype.groupBy = function groupBy(iterator) {
-                return addProxy(this, GroupBy, iterator);
-              };
-
-              /**
-               * @param {Function} iterator
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const collection = [1, 4, 2];
-               * const iterator = (num, index) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .groupBySeries(iterator)
-               *   .then(object => {
-               *     console.log(object); // { '0': [4, 2], '1': [1] };
-               *     console.log(order); // [1, 4, 2];
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = { a: 1, b: 4, c: 2 };
-               * const iterator = (num, key) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .groupBySeries(iterator)
-               *   .then(object => {
-               *     console.log(object); // { '0': [4, 2], '1': [1] };
-               *     console.log(order); // [1, 4, 2];
-               *   });
-               */
-              Aigle.prototype.groupBySeries = function groupBySeries(iterator) {
-                return addProxy(this, GroupBySeries, iterator);
-              };
-
-              /**
-               * @param {number} [limit=8]
-               * @param {Function} iterator
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const collection = [1, 5, 3, 4, 2];
-               * const iterator = (num, index) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .groupByLimit(2, iterator)
-               *   .then(object => {
-               *     console.log(object); // { '0': [2, 4], '1': [1, 3, 5] };
-               *     console.log(order); // [1, 3, 5, 2, 4];
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = {
-               *   task1: 1,
-               *   task2: 5,
-               *   task3: 3,
-               *   task4: 4,
-               *   task5: 2
-               * };
-               * const iterator = (num, key) => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .groupByLimit(2, iterator)
-               *   .then(object => {
-               *     console.log(object); // { '0': [2, 4], '1': [1, 3, 5] };
-               *     console.log(order); // [1, 3, 5, 2, 4];
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const collection = [1, 5, 3, 4, 2];
-               * const iterator = num => {
-               *   return Aigle.delay(num * 10)
-               *     .then(() => {
-               *       order.push(num);
-               *       return num % 2;
-               *     });
-               * };
-               * Aigle.resolve(collection)
-               *   .groupByLimit(iterator)
-               *   .then(object => {
-               *     console.log(object); // { '0': [2, 4], '1': [1, 3, 5] };
-               *     console.log(order); // [1, 2, 3, 4, 5];
-               *   });
-               */
-              Aigle.prototype.groupByLimit = function groupByLimit(limit, iterator) {
-                return addProxy(this, GroupByLimit, limit, iterator);
-              };
-
-              /**
-               * After a previous promise is resolved, the timer will be started with `ms`.
-               * After `ms`, the delay's promise will be resolved with the previous promise value.
-               * @param {number} ms
-               * @example
-               * Aigle.resolve()
-               *   .delay(10)
-               *   .then(value => console.log(value); // undefined
-               *
-               * @example
-               * Aigle.resolve('test')
-               *   .delay(10)
-               *   .then(value => console.log(value); // 'test'
-               */
-              Aigle.prototype.delay = function delay(ms) {
-                return addAigle(this, new Delay(ms));
-              };
-
-              /**
-               * @param {number} ms
-               * @param {*} [message]
-               * @example
-               * const { TimeoutError } = Aigle;
-               * Aigle.delay(100)
-               *   .timeout(10)
-               *   .catch(TimeoutError, error => {
-               *     console.log(error); // operation timed out
-               *   });
-               */
-              Aigle.prototype.timeout = function timeout(ms, message) {
-                return addReceiver(this, new Timeout(ms, message));
-              };
-
-              /**
-               * @param {Function} tester
-               * @param {Function} iterator
-               */
-              Aigle.prototype.whilst = function whilst$1(tester, iterator) {
-                return this.then(function(value) {
-                  return whilst(value, tester, iterator);
-                });
-              };
-
-              /**
-               * @param {Function} iterator
-               * @param {Function} tester
-               * @example
-               * const order = [];
-               * const tester = num => {
-               *   order.push(`t:${num}`);
-               *   return Aigle.delay(10)
-               *     .then(() => num !== 4);
-               * };
-               * const iterator = count => {
-               *   const num = ++count;
-               *   order.push(`i:${num}`);
-               *   return Aigle.delay(10)
-               *     .then(() => num);
-               * };
-               * Aigle.resolve(0)
-               *   .doWhilst(iterator, tester)
-               *   .then(value => {
-               *     console.log(value); // 4
-               *     console.log(order); // [ 'i:1', 't:1', 'i:2', 't:2', 'i:3', 't:3', 'i:4', 't:4' ]
-               *   });
-               */
-              Aigle.prototype.doWhilst = function doWhilst$1(iterator, tester) {
-                return this.then(function(value) {
-                  return doWhilst(value, iterator, tester);
-                });
-              };
-
-              /**
-               * @param {Function} tester
-               * @param {Function} iterator
-               */
-              Aigle.prototype.until = function until$1(tester, iterator) {
-                return this.then(function(value) {
-                  return until(value, tester, iterator);
-                });
-              };
-
-              /**
-               * @param {Function} iterator
-               * @param {Function} tester
-               * @example
-               * const order = [];
-               * const tester = num => {
-               *   order.push(`t:${num}`);
-               *   return Aigle.delay(10)
-               *     .then(() => num === 4);
-               * };
-               * const iterator = count => {
-               *   const num = ++count;
-               *   order.push(`i:${num}`);
-               *   return Aigle.delay(10)
-               *     .then(() => num);
-               * };
-               * Aigle.resolve(0)
-               *   .doUntil(iterator, tester)
-               *   .then(value => {
-               *     console.log(value); // 4
-               *     console.log(order); // [ 'i:1', 't:1', 'i:2', 't:2', 'i:3', 't:3', 'i:4', 't:4' ]
-               *   });
-               */
-              Aigle.prototype.doUntil = function doUntil$1(iterator, tester) {
-                return this.then(function(value) {
-                  return doUntil(value, iterator, tester);
-                });
-              };
-
-              /**
-               * @param {Function} onFulfilled
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * Aigle.resolve(3)
-               *   .thru(value => ++value)
-               *   .then(value => {
-               *     console.log(value); // 4;
-               *   });
-               */
-              Aigle.prototype.thru = function thru$1(onFulfilled) {
-                return this.then(function(value) {
-                  return thru(value, onFulfilled);
-                });
-              };
-
-              /**
-               * @param {Function} onFulfilled
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * Aigle.resolve([1, 4, 2])
-               *   .tap(array => array.pop())
-               *   .then(array => {
-               *     console.log(array); // [1, 4]
-               *   });
-               */
-              Aigle.prototype.tap = function tap$1(onFulfilled) {
-                return this.then(function(value) {
-                  return tap(value, onFulfilled);
-                });
-              };
-
-              /**
-               * @param {Function} iterator
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const timer = [30, 20, 10];
-               * const iterator = n => {
-               *   return Aigle.delay(timer[n])
-               *     .then(() => {
-               *       order.push(n);
-               *       return n;
-               *     });
-               * };
-               * Aigle.resolve(3)
-               *   .times(iterator)
-               *   .then(array => {
-               *     console.log(array); // [0, 1, 2]
-               *     console.log(order); // [2, 1, 0]
-               *   });
-               */
-              Aigle.prototype.times = function times(iterator) {
-                return addProxy(this, Times, iterator);
-              };
-
-              /**
-               * @param {Function} iterator
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const timer = [30, 20, 10];
-               * const iterator = n => {
-               *   return Aigle.delay(timer[n])
-               *     .then(() => {
-               *       order.push(n);
-               *       return n;
-               *     });
-               * };
-               * Aigle.resolve(3)
-               *   .timesSeries(iterator)
-               *   .then(array => {
-               *     console.log(array); // [0, 1, 2]
-               *     console.log(order); // [0, 1, 2]
-               *   });
-               */
-              Aigle.prototype.timesSeries = function timesSeries(iterator) {
-                return addProxy(this, TimesSeries, iterator);
-              };
-
-              /**
-               * @param {number} [limit=8]
-               * @param {Function} iterator
-               * @return {Aigle} Returns an Aigle instance
-               * @example
-               * const order = [];
-               * const timer = [30, 20, 10];
-               * const iterator = n => {
-               *   return Aigle.delay(timer[n])
-               *     .then(() => {
-               *       order.push(n);
-               *       return n;
-               *     });
-               * };
-               * Aigle.resolve(3)
-               *   .timesLimit(2, iterator)
-               *   .then(array => {
-               *     console.log(array); // [0, 1, 2]
-               *     console.log(order); // [1, 0, 2]
-               *   });
-               *
-               * @example
-               * const order = [];
-               * const timer = [30, 20, 10];
-               * const iterator = n => {
-               *   return Aigle.delay(timer[n])
-               *     .then(() => {
-               *       order.push(n);
-               *       return n;
-               *     });
-               * };
-               * Aigle.resolve(3)
-               *   .timesLimit(iterator)
-               *   .then(array => {
-               *     console.log(array); // [0, 1, 2]
-               *     console.log(order); // [2, 1, 0]
-               *   });
-               */
-              Aigle.prototype.timesLimit = function timesLimit(limit, iterator) {
-                return addProxy(this, TimesLimit, limit, iterator);
-              };
-
-              /**
-               * @param {Function} handler
-               */
-              Aigle.prototype.disposer = function disposer(handler) {
-                return new Disposer(this, handler);
-              };
-
-              /* internal functions */
-
-              Aigle.prototype._resolve = function _resolve(value) {
-                if (this._resolved !== 0) {
-                  return;
-                }
-                this._resolved = 1;
-                this._value = value;
-                if (this._receiver === undefined) {
-                  return;
-                }
-                this._callResolve();
-              };
-
-              Aigle.prototype._callResolve = function _callResolve() {
-                var ref = this;
-                var _receiver = ref._receiver;
-                this._receiver = undefined;
-                if (_receiver instanceof AigleProxy) {
-                  _receiver._callResolve(this._value, this._key);
-                } else if (this._key === INTERNAL) {
-                  _receiver._resolve(this._value);
-                } else {
-                  callResolve(_receiver, this._onFulfilled, this._value);
-                }
-                if (!this._receivers) {
-                  return;
-                }
-                var ref$1 = this;
-                var _value = ref$1._value;
-                var _key = ref$1._key;
-                var _receivers = ref$1._receivers;
-                this._receivers = undefined;
-                var i = -1;
-                var array = _receivers.array;
-                while (++i < _receivers.length) {
-                  var ref$2 = array[i];
-                  var receiver = ref$2.receiver;
-                  var onFulfilled = ref$2.onFulfilled;
-                  if (receiver instanceof AigleProxy) {
-                    receiver._callResolve(_value, _key);
-                  } else {
-                    callResolve(receiver, onFulfilled, _value);
-                  }
-                }
-              };
-
-              Aigle.prototype._reject = function _reject(reason) {
-                if (this._resolved !== 0) {
-                  return;
-                }
-                this._resolved = 2;
-                this._value = reason;
-                if (this._receiver === undefined) {
-                  this._receiver = UNHANDLED;
-                  invokeAsync(this);
-                  return;
-                }
-                stackTraces && reconstructStack(this);
-                this._callReject();
-              };
-
-              Aigle.prototype._callReject = function _callReject() {
-                var ref = this;
-                var _receiver = ref._receiver;
-                this._receiver = undefined;
-                if (_receiver === undefined || _receiver === UNHANDLED) {
-                  printWarning(this._value);
-                  process.emit('unhandledRejection', this._value);
-                  return;
-                }
-                if (_receiver === INTERNAL) {
-                  return;
-                }
-                if (_receiver instanceof AigleProxy) {
-                  _receiver._callReject(this._value);
-                } else if (this._key === INTERNAL) {
-                  _receiver._reject(this._value);
-                } else {
-                  callReject(_receiver, this._onRejected, this._value);
-                }
-                if (!this._receivers) {
-                  return;
-                }
-                var ref$1 = this;
-                var _value = ref$1._value;
-                var _receivers = ref$1._receivers;
-                this._receivers = undefined;
-                var i = -1;
-                var array = _receivers.array;
-                while (++i < _receivers.length) {
-                  var ref$2 = array[i];
-                  var receiver = ref$2.receiver;
-                  var onRejected = ref$2.onRejected;
-                  if (receiver instanceof AigleProxy) {
-                    receiver._callReject(_value);
-                  } else {
-                    callReject(receiver, onRejected, _value);
-                  }
-                }
-              };
-
-              Aigle.prototype._addReceiver = function _addReceiver(receiver, key) {
-                this._key = key;
-                this._receiver = receiver;
-              };
-
-              return Aigle;
-            })(AigleCore);
-
-            Aigle.prototype._execute = execute;
-
-            module.exports = Aigle;
-            module.exports.default = Aigle;
-
-            /* functions, classes */
-            var ref$2 = require('./all');
-            var all = ref$2.all;
-            var All = ref$2.All;
-            var attempt = require('./attempt');
-            var ref$3 = require('./race');
-            var race = ref$3.race;
-            var Race = ref$3.Race;
-            var ref$4 = require('./props');
-            var props = ref$4.props;
-            var Props = ref$4.Props;
-            var ref$5 = require('./parallel');
-            var parallel = ref$5.parallel;
-            var Parallel = ref$5.Parallel;
-            var ref$6 = require('./series');
-            var series = ref$6.series;
-            var Series = ref$6.Series;
-            var ref$7 = require('./parallelLimit');
-            var parallelLimit = ref$7.parallelLimit;
-            var ParallelLimit = ref$7.ParallelLimit;
-            var ref$8 = require('./each');
-            var each = ref$8.each;
-            var Each = ref$8.Each;
-            var ref$9 = require('./eachSeries');
-            var eachSeries = ref$9.eachSeries;
-            var EachSeries = ref$9.EachSeries;
-            var ref$10 = require('./eachLimit');
-            var eachLimit = ref$10.eachLimit;
-            var EachLimit = ref$10.EachLimit;
-            var ref$11 = require('./map');
-            var map = ref$11.map;
-            var Map = ref$11.Map;
-            var ref$12 = require('./mapSeries');
-            var mapSeries = ref$12.mapSeries;
-            var MapSeries = ref$12.MapSeries;
-            var ref$13 = require('./mapLimit');
-            var mapLimit = ref$13.mapLimit;
-            var MapLimit = ref$13.MapLimit;
-            var ref$14 = require('./mapValues');
-            var mapValues = ref$14.mapValues;
-            var MapValues = ref$14.MapValues;
-            var ref$15 = require('./mapValuesSeries');
-            var mapValuesSeries = ref$15.mapValuesSeries;
-            var MapValuesSeries = ref$15.MapValuesSeries;
-            var ref$16 = require('./mapValuesLimit');
-            var mapValuesLimit = ref$16.mapValuesLimit;
-            var MapValuesLimit = ref$16.MapValuesLimit;
-            var ref$17 = require('./filter');
-            var filter = ref$17.filter;
-            var Filter = ref$17.Filter;
-            var ref$18 = require('./filterSeries');
-            var filterSeries = ref$18.filterSeries;
-            var FilterSeries = ref$18.FilterSeries;
-            var ref$19 = require('./filterLimit');
-            var filterLimit = ref$19.filterLimit;
-            var FilterLimit = ref$19.FilterLimit;
-            var ref$20 = require('./reject');
-            var reject = ref$20.reject;
-            var Reject = ref$20.Reject;
-            var ref$21 = require('./rejectSeries');
-            var rejectSeries = ref$21.rejectSeries;
-            var RejectSeries = ref$21.RejectSeries;
-            var ref$22 = require('./rejectLimit');
-            var rejectLimit = ref$22.rejectLimit;
-            var RejectLimit = ref$22.RejectLimit;
-            var ref$23 = require('./find');
-            var find = ref$23.find;
-            var Find = ref$23.Find;
-            var ref$24 = require('./findSeries');
-            var findSeries = ref$24.findSeries;
-            var FindSeries = ref$24.FindSeries;
-            var ref$25 = require('./findLimit');
-            var findLimit = ref$25.findLimit;
-            var FindLimit = ref$25.FindLimit;
-            var ref$26 = require('./findIndex');
-            var findIndex = ref$26.findIndex;
-            var FindIndex = ref$26.FindIndex;
-            var ref$27 = require('./findIndexSeries');
-            var findIndexSeries = ref$27.findIndexSeries;
-            var FindIndexSeries = ref$27.FindIndexSeries;
-            var ref$28 = require('./findIndexLimit');
-            var findIndexLimit = ref$28.findIndexLimit;
-            var FindIndexLimit = ref$28.FindIndexLimit;
-            var ref$29 = require('./findKey');
-            var findKey = ref$29.findKey;
-            var FindKey = ref$29.FindKey;
-            var ref$30 = require('./findKeySeries');
-            var findKeySeries = ref$30.findKeySeries;
-            var FindKeySeries = ref$30.FindKeySeries;
-            var ref$31 = require('./findKeyLimit');
-            var findKeyLimit = ref$31.findKeyLimit;
-            var FindKeyLimit = ref$31.FindKeyLimit;
-            var ref$32 = require('./pick');
-            var pick = ref$32.pick;
-            var Pick = ref$32.Pick;
-            var ref$33 = require('./pickBy');
-            var pickBy = ref$33.pickBy;
-            var PickBy = ref$33.PickBy;
-            var ref$34 = require('./pickBySeries');
-            var pickBySeries = ref$34.pickBySeries;
-            var PickBySeries = ref$34.PickBySeries;
-            var ref$35 = require('./pickByLimit');
-            var pickByLimit = ref$35.pickByLimit;
-            var PickByLimit = ref$35.PickByLimit;
-            var ref$36 = require('./omit');
-            var omit = ref$36.omit;
-            var Omit = ref$36.Omit;
-            var ref$37 = require('./omitBy');
-            var omitBy = ref$37.omitBy;
-            var OmitBy = ref$37.OmitBy;
-            var ref$38 = require('./omitBySeries');
-            var omitBySeries = ref$38.omitBySeries;
-            var OmitBySeries = ref$38.OmitBySeries;
-            var ref$39 = require('./omitByLimit');
-            var omitByLimit = ref$39.omitByLimit;
-            var OmitByLimit = ref$39.OmitByLimit;
-            var ref$40 = require('./reduce');
-            var reduce = ref$40.reduce;
-            var Reduce = ref$40.Reduce;
-            var ref$41 = require('./transform');
-            var transform = ref$41.transform;
-            var Transform = ref$41.Transform;
-            var ref$42 = require('./transformSeries');
-            var transformSeries = ref$42.transformSeries;
-            var TransformSeries = ref$42.TransformSeries;
-            var ref$43 = require('./transformLimit');
-            var transformLimit = ref$43.transformLimit;
-            var TransformLimit = ref$43.TransformLimit;
-            var ref$44 = require('./sortBy');
-            var sortBy = ref$44.sortBy;
-            var SortBy = ref$44.SortBy;
-            var ref$45 = require('./sortBySeries');
-            var sortBySeries = ref$45.sortBySeries;
-            var SortBySeries = ref$45.SortBySeries;
-            var ref$46 = require('./sortByLimit');
-            var sortByLimit = ref$46.sortByLimit;
-            var SortByLimit = ref$46.SortByLimit;
-            var ref$47 = require('./some');
-            var some = ref$47.some;
-            var Some = ref$47.Some;
-            var ref$48 = require('./someSeries');
-            var someSeries = ref$48.someSeries;
-            var SomeSeries = ref$48.SomeSeries;
-            var ref$49 = require('./someLimit');
-            var someLimit = ref$49.someLimit;
-            var SomeLimit = ref$49.SomeLimit;
-            var ref$50 = require('./every');
-            var every = ref$50.every;
-            var Every = ref$50.Every;
-            var ref$51 = require('./everySeries');
-            var everySeries = ref$51.everySeries;
-            var EverySeries = ref$51.EverySeries;
-            var ref$52 = require('./everyLimit');
-            var everyLimit = ref$52.everyLimit;
-            var EveryLimit = ref$52.EveryLimit;
-            var ref$53 = require('./concat');
-            var concat = ref$53.concat;
-            var Concat = ref$53.Concat;
-            var ref$54 = require('./concatSeries');
-            var concatSeries = ref$54.concatSeries;
-            var ConcatSeries = ref$54.ConcatSeries;
-            var ref$55 = require('./concatLimit');
-            var concatLimit = ref$55.concatLimit;
-            var ConcatLimit = ref$55.ConcatLimit;
-            var ref$56 = require('./groupBy');
-            var groupBy = ref$56.groupBy;
-            var GroupBy = ref$56.GroupBy;
-            var ref$57 = require('./groupBySeries');
-            var groupBySeries = ref$57.groupBySeries;
-            var GroupBySeries = ref$57.GroupBySeries;
-            var ref$58 = require('./groupByLimit');
-            var groupByLimit = ref$58.groupByLimit;
-            var GroupByLimit = ref$58.GroupByLimit;
-            var ref$59 = require('./join');
-            var join = ref$59.join;
-            var Spread = ref$59.Spread;
-            var promisify = require('./promisify');
-            var promisifyAll = require('./promisifyAll');
-            var ref$60 = require('./delay');
-            var delay = ref$60.delay;
-            var Delay = ref$60.Delay;
-            var Timeout = require('./timeout');
-            var ref$61 = require('./whilst');
-            var whilst = ref$61.whilst;
-            var ref$62 = require('./doWhilst');
-            var doWhilst = ref$62.doWhilst;
-            var ref$63 = require('./until');
-            var until = ref$63.until;
-            var doUntil = require('./doUntil');
-            var retry = require('./retry');
-            var thru = require('./thru');
-            var tap = require('./tap');
-            var flow = require('./flow');
-            var ref$64 = require('./times');
-            var times = ref$64.times;
-            var Times = ref$64.Times;
-            var ref$65 = require('./timesSeries');
-            var timesSeries = ref$65.timesSeries;
-            var TimesSeries = ref$65.TimesSeries;
-            var ref$66 = require('./timesLimit');
-            var timesLimit = ref$66.timesLimit;
-            var TimesLimit = ref$66.TimesLimit;
-            var ref$67 = require('./using');
-            var using = ref$67.using;
-            var Disposer = ref$67.Disposer;
-            var ref$68 = require('./debug');
-            var resolveStack = ref$68.resolveStack;
-            var reconstructStack = ref$68.reconstructStack;
-            var ref$69 = require('./internal/mixin');
-            var createProxy = ref$69.createProxy;
-
-            Aigle.VERSION = VERSION;
-            Aigle.Aigle = Aigle;
-
-            /* core functions */
-            Aigle.resolve = _resolve;
-            Aigle.reject = _reject;
-
-            /* collections */
-            Aigle.all = all;
-            Aigle.race = race;
-            Aigle.props = props;
-            Aigle.series = series;
-            Aigle.parallel = parallel;
-            Aigle.parallelLimit = parallelLimit;
-            Aigle.each = each;
-            Aigle.eachSeries = eachSeries;
-            Aigle.eachLimit = eachLimit;
-            Aigle.forEach = each;
-            Aigle.forEachSeries = eachSeries;
-            Aigle.forEachLimit = eachLimit;
-            Aigle.map = map;
-            Aigle.mapSeries = mapSeries;
-            Aigle.mapLimit = mapLimit;
-            Aigle.mapValues = mapValues;
-            Aigle.mapValuesSeries = mapValuesSeries;
-            Aigle.mapValuesLimit = mapValuesLimit;
-            Aigle.filter = filter;
-            Aigle.filterSeries = filterSeries;
-            Aigle.filterLimit = filterLimit;
-            Aigle.rejectSeries = rejectSeries;
-            Aigle.rejectLimit = rejectLimit;
-            Aigle.find = find;
-            Aigle.findSeries = findSeries;
-            Aigle.findLimit = findLimit;
-            Aigle.findIndex = findIndex;
-            Aigle.findIndexSeries = findIndexSeries;
-            Aigle.findIndexLimit = findIndexLimit;
-            Aigle.findKey = findKey;
-            Aigle.findKeySeries = findKeySeries;
-            Aigle.findKeyLimit = findKeyLimit;
-            Aigle.detect = find;
-            Aigle.detectSeries = findSeries;
-            Aigle.detectLimit = findLimit;
-            Aigle.pick = pick;
-            Aigle.pickSeries = pickBySeries;
-            Aigle.pickLimit = pickByLimit;
-            Aigle.pickBy = pickBy;
-            Aigle.pickBySeries = pickBySeries;
-            Aigle.pickByLimit = pickByLimit;
-            Aigle.omit = omit;
-            Aigle.omitSeries = omitBySeries;
-            Aigle.omitLimit = omitByLimit;
-            Aigle.omitBy = omitBy;
-            Aigle.omitBySeries = omitBySeries;
-            Aigle.omitByLimit = omitByLimit;
-            Aigle.reduce = reduce;
-            Aigle.transform = transform;
-            Aigle.transformSeries = transformSeries;
-            Aigle.transformLimit = transformLimit;
-            Aigle.sortBy = sortBy;
-            Aigle.sortBySeries = sortBySeries;
-            Aigle.sortByLimit = sortByLimit;
-            Aigle.some = some;
-            Aigle.someSeries = someSeries;
-            Aigle.someLimit = someLimit;
-            Aigle.every = every;
-            Aigle.everySeries = everySeries;
-            Aigle.everyLimit = everyLimit;
-            Aigle.concat = concat;
-            Aigle.concatSeries = concatSeries;
-            Aigle.concatLimit = concatLimit;
-            Aigle.groupBy = groupBy;
-            Aigle.groupBySeries = groupBySeries;
-            Aigle.groupByLimit = groupByLimit;
-
-            Aigle.attempt = attempt;
-            Aigle.try = attempt;
-            Aigle.join = join;
-            Aigle.promisify = promisify;
-            Aigle.promisifyAll = promisifyAll;
-            Aigle.delay = delay;
-            Aigle.whilst = whilst;
-            Aigle.doWhilst = doWhilst;
-            Aigle.until = until;
-            Aigle.doUntil = doUntil;
-            Aigle.retry = retry;
-            Aigle.thru = thru;
-            Aigle.tap = tap;
-            Aigle.flow = flow;
-            Aigle.times = times;
-            Aigle.timesSeries = timesSeries;
-            Aigle.timesLimit = timesLimit;
-            Aigle.using = using;
-            Aigle.mixin = mixin;
-
-            /* debug */
-            Aigle.config = config;
-            Aigle.longStackTraces = longStackTraces;
-
-            /* errors */
-            var ref$70 = require('./error');
-            var CancellationError = ref$70.CancellationError;
-            var TimeoutError = ref$70.TimeoutError;
-            Aigle.CancellationError = CancellationError;
-            Aigle.TimeoutError = TimeoutError;
-
-            function _resolve(value) {
-              if (value instanceof AigleCore) {
-                return value;
-              }
-              var promise = new Aigle(INTERNAL);
-              callReceiver(promise, value);
-              return promise;
-            }
-
-            function _reject(reason, iterator) {
-              if (arguments.length === 2 && typeof iterator === 'function') {
-                return reject(reason, iterator);
-              }
-              var promise = new Aigle(INTERNAL);
-              promise._reject(reason);
-              return promise;
-            }
-
-            function execute(executor) {
-              var this$1 = this;
-
-              stackTraces && resolveStack(this);
-              try {
-                executor(
-                  function(value) {
-                    if (executor === undefined) {
-                      return;
-                    }
-                    executor = undefined;
-                    callReceiver(this$1, value);
-                  },
-                  function(reason) {
-                    if (executor === undefined) {
-                      return;
-                    }
-                    executor = undefined;
-                    this$1._reject(reason);
-                  }
-                );
-              } catch (e) {
-                if (executor === undefined) {
-                  return;
-                }
-                executor = undefined;
-                this._reject(e);
-              }
-            }
-
-            function executeWithCancel(executor) {
-              var this$1 = this;
-
-              stackTraces && resolveStack(this);
-              try {
-                executor(
-                  function(value) {
-                    if (executor === undefined) {
-                      return;
-                    }
-                    if (value instanceof Aigle && value._resolved === 0) {
-                      this$1._parent = value;
-                    }
-                    executor = undefined;
-                    callReceiver(this$1, value);
-                  },
-                  function(reason) {
-                    if (executor === undefined) {
-                      return;
-                    }
-                    executor = undefined;
-                    this$1._reject(reason);
-                  },
-                  function(handler) {
-                    if (typeof handler !== 'function') {
-                      throw new TypeError('onCancel must be function');
-                    }
-                    if (this$1._resolved !== 0) {
-                      return;
-                    }
-                    if (this$1._onCancelQueue === undefined) {
-                      this$1._onCancelQueue = new Queue();
-                    }
-                    this$1._onCancelQueue.push(handler);
-                  }
-                );
-              } catch (e) {
-                if (executor === undefined) {
-                  return;
-                }
-                executor = undefined;
-                this._reject(e);
-              }
-            }
-
-            function createOnRejected(errorTypes, onRejected) {
-              return function(reason) {
-                var l = errorTypes.length;
-                while (l--) {
-                  var errorType = errorTypes[l];
-                  if (errorType === Error || errorType.prototype instanceof Error) {
-                    if (reason instanceof errorType) {
-                      return onRejected(reason);
-                    }
-                  } else if (errorType(reason)) {
-                    return onRejected(reason);
-                  }
-                }
-                errorObj.e = reason;
-                return errorObj;
-              };
-            }
-
-            function createFinallyHandler(promise, handler) {
-              return function() {
-                var _resolved = promise._resolved;
-                var _value = promise._value;
-                var p = call0(handler);
-                if (p === errorObj) {
-                  return p;
-                }
-                if (p instanceof AigleCore) {
-                  switch (p._resolved) {
-                    case 1:
-                      p._value = _value;
-                      return p;
-                    case 2:
-                      return p;
-                  }
-                }
-                var receiver = new Aigle(INTERNAL);
-                if (!p || !p.then) {
-                  receiver._resolved = _resolved;
-                  receiver._value = _value;
-                } else if (_resolved === 1) {
-                  p.then(
-                    function() {
-                      return receiver._resolve(_value);
-                    },
-                    function(reason) {
-                      return receiver._reject(reason);
-                    }
-                  );
-                } else {
-                  p.then(
-                    function() {
-                      return receiver._reject(_value);
-                    },
-                    function(reason) {
-                      return receiver._reject(reason);
-                    }
-                  );
-                }
-                return receiver;
-              };
-            }
-
-            function addAigle(promise, receiver, onFulfilled, onRejected) {
-              stackTraces && resolveStack(receiver);
-              if (promise._receiver === undefined || promise._receiver === INTERNAL) {
-                promise._resolved !== 0 && invokeAsync(promise);
-                promise._receiver = receiver;
-                promise._onFulfilled = onFulfilled;
-                promise._onRejected = onRejected;
-              } else if (promise._receiver === UNHANDLED) {
-                promise._receiver = receiver;
-                promise._onFulfilled = onFulfilled;
-                promise._onRejected = onRejected;
-              } else {
-                if (!promise._receivers) {
-                  promise._receivers = new Queue();
-                }
-                promise._receivers.push({
-                  receiver: receiver,
-                  onFulfilled: onFulfilled,
-                  onRejected: onRejected
-                });
-              }
-              return receiver;
-            }
-
-            function addReceiver(promise, receiver) {
-              stackTraces && resolveStack(receiver);
-              promise._resolved !== 0 && invokeAsync(promise);
-              promise._receiver = receiver;
-              return receiver._promise;
-            }
-
-            function addProxy(promise, Proxy, arg1, arg2, arg3) {
-              if (stackTraces) {
-                stackTraces = false;
-                var receiver$1 = addProxy(promise, Proxy, arg1, arg2, arg3);
-                stackTraces = true;
-                resolveStack(receiver$1);
-                return receiver$1;
-              }
-              switch (promise._resolved) {
-                case 0:
-                  var receiver = new Proxy(PENDING, arg1, arg2, arg3);
-                  if (promise._receiver === undefined) {
-                    promise._receiver = receiver;
-                  } else {
-                    if (!promise._receivers) {
-                      promise._receivers = new Queue();
-                    }
-                    promise._receivers.push({ receiver: receiver });
-                  }
-                  return receiver._promise;
-                case 1:
-                  return new Proxy(promise._value, arg1, arg2, arg3)._execute();
-                case 2:
-                  return Aigle.reject(promise._value);
-              }
-            }
-
-            /**
-             * @param {Object} opts
-             * @param {boolean} [opts.longStackTraces]
-             * @param {boolean} [opts.cancellation]
-             */
-            function config(opts) {
-              opts = opts || {};
-              if (opts.longStackTraces !== undefined) {
-                stackTraces = !!opts.longStackTraces;
-              }
-              if (opts.cancellation !== undefined) {
-                Aigle.prototype._execute = opts.cancellation ? executeWithCancel : execute;
-              }
-            }
-
-            function longStackTraces() {
-              stackTraces = true;
-            }
-
-            /**
-             * Add functions which sources has to the Aigle class functions and static functions.
-             * The functions will be converted asynchronous functions.
-             * If an extended function returns a promise instance, the function will wait until the promise is resolved.
-             *
-             * @param {Object} sources
-             * @param {Object} [opts]
-             * @param {boolean} [opts.promisify=true]
-             * @param {boolean} [opts.override=false]
-             * @example
-             * Aigle.mixin(require('lodash'));
-             * const array = [1, 2, 3];
-             * return Aigle.map(array, n => Aigle.delay(10, n * 2))
-             *   .sum()
-             *   .then(value => {
-             *     console.log(value; // 12
-             *   });
-             *
-             * @example
-             * Aigle.mixin(require('lodash'));
-             * const array = [1.1, 1.4, 2.2];
-             * return Aigle.map(array, n => Aigle.delay(10, n * 2))
-             *   .uniqBy(n => Aigle.delay(10, Math.floor(n))
-             *   .then(array => {
-             *     console.log(array; // [2.2, 4.4]
-             *   });
-             */
-            function mixin(sources, opts) {
-              if (opts === void 0) opts = {};
-
-              var override = opts.override;
-              var promisify = opts.promisify;
-              if (promisify === void 0) promisify = true;
-              Object.getOwnPropertyNames(sources).forEach(function(key) {
-                var func = sources[key];
-                if (typeof func !== 'function' || (Aigle[key] && !override)) {
-                  return;
-                }
-                // check lodash chain
-                if (key === 'chain') {
-                  var obj = func();
-                  if (obj && obj.__chain__) {
-                    Aigle.chain = _resolve;
-                    Aigle.prototype.value = function() {
-                      return this;
-                    };
-                    return;
-                  }
-                }
-                var Proxy = createProxy(func, promisify);
-                Aigle[key] = function(value, arg1, arg2, arg3) {
-                  return new Proxy(value, arg1, arg2, arg3)._execute();
-                };
-                Aigle.prototype[key] = function(arg1, arg2, arg3) {
-                  return addProxy(this, Proxy, arg1, arg2, arg3);
-                };
-              });
-              return Aigle;
-            }
-          }.call(this, require('_process')));
-        },
-        {
-          './all': 3,
-          './attempt': 4,
-          './concat': 5,
-          './concatLimit': 6,
-          './concatSeries': 7,
-          './debug': 8,
-          './delay': 9,
-          './doUntil': 10,
-          './doWhilst': 11,
-          './each': 12,
-          './eachLimit': 13,
-          './eachSeries': 14,
-          './error': 15,
-          './every': 16,
-          './everyLimit': 17,
-          './everySeries': 18,
-          './filter': 19,
-          './filterLimit': 20,
-          './filterSeries': 21,
-          './find': 22,
-          './findIndex': 23,
-          './findIndexLimit': 24,
-          './findIndexSeries': 25,
-          './findKey': 26,
-          './findKeyLimit': 27,
-          './findKeySeries': 28,
-          './findLimit': 29,
-          './findSeries': 30,
-          './flow': 31,
-          './groupBy': 32,
-          './groupByLimit': 33,
-          './groupBySeries': 34,
-          './internal/async': 35,
-          './internal/mixin': 37,
-          './internal/queue': 38,
-          './internal/util': 39,
-          './join': 40,
-          './map': 41,
-          './mapLimit': 42,
-          './mapSeries': 43,
-          './mapValues': 44,
-          './mapValuesLimit': 45,
-          './mapValuesSeries': 46,
-          './omit': 47,
-          './omitBy': 48,
-          './omitByLimit': 49,
-          './omitBySeries': 50,
-          './parallel': 51,
-          './parallelLimit': 52,
-          './pick': 53,
-          './pickBy': 54,
-          './pickByLimit': 55,
-          './pickBySeries': 56,
-          './promisify': 57,
-          './promisifyAll': 58,
-          './props': 59,
-          './race': 60,
-          './reduce': 61,
-          './reject': 62,
-          './rejectLimit': 63,
-          './rejectSeries': 64,
-          './retry': 65,
-          './series': 66,
-          './some': 67,
-          './someLimit': 68,
-          './someSeries': 69,
-          './sortBy': 70,
-          './sortByLimit': 71,
-          './sortBySeries': 72,
-          './tap': 73,
-          './thru': 74,
-          './timeout': 75,
-          './times': 76,
-          './timesLimit': 77,
-          './timesSeries': 78,
-          './transform': 79,
-          './transformLimit': 80,
-          './transformSeries': 81,
-          './until': 82,
-          './using': 83,
-          './whilst': 84,
-          _process: 86,
-          'aigle-core': 85
-        }
-      ],
-      3: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('aigle-core');
-          var AigleProxy = ref.AigleProxy;
-
-          var Aigle = require('./aigle');
-          var ref$1 = require('./internal/util');
-          var INTERNAL = ref$1.INTERNAL;
-          var PENDING = ref$1.PENDING;
-          var iteratorSymbol = ref$1.iteratorSymbol;
-          var promiseArrayEach = ref$1.promiseArrayEach;
-          var promiseSetEach = ref$1.promiseSetEach;
-          var ref$2 = require('./props');
-          var callResolve = ref$2.callResolve;
-
-          var All = /*@__PURE__*/ (function(AigleProxy) {
-            function All(coll) {
-              AigleProxy.call(this);
-              this._promise = new Aigle(INTERNAL);
-              this._rest = undefined;
-              this._result = undefined;
-              if (coll === PENDING) {
-                this._callResolve = this._set;
-              } else {
-                this._callResolve = undefined;
-                this._set(coll);
-              }
-            }
-
-            if (AigleProxy) All.__proto__ = AigleProxy;
-            All.prototype = Object.create(AigleProxy && AigleProxy.prototype);
-            All.prototype.constructor = All;
-
-            All.prototype._set = function _set(coll) {
-              if (Array.isArray(coll)) {
-                var size = coll.length;
-                this._rest = size;
-                this._result = Array(size);
-                this._callResolve = callResolve;
-                promiseArrayEach(this, size, coll);
-              } else if (coll[iteratorSymbol]) {
-                var size$1 = coll.size;
-                this._rest = size$1;
-                this._result = Array(size$1);
-                this._callResolve = callResolve;
-                promiseSetEach(this, Infinity, coll);
-              } else {
-                this._rest = 0;
-                this._result = [];
-              }
-              if (this._rest === 0) {
-                this._promise._resolve(this._result);
-              }
-              return this;
-            };
-
-            All.prototype._execute = function _execute() {
-              return this._promise;
-            };
-
-            All.prototype._callReject = function _callReject(reason) {
-              this._promise._reject(reason);
-            };
-
-            return All;
-          })(AigleProxy);
-
-          module.exports = { all: all, All: All };
-
-          /**
-           * `Aigle.all` is almost the same functionality as `Promise.all`.
-           * It will return an Aigle instance.
-           * @param {Array} array
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const makeDelay = (num, delay) => {
-           *   return Aigle.delay(delay)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num;
-           *     });
-           * };
-           * Aigle.all([
-           *   makeDelay(1, 30),
-           *   makeDelay(2, 20),
-           *   makeDelay(3, 10)
-           * ])
-           * .then(array => {
-           *   console.log(array); // [1, 2, 3];
-           *   console.log(order); // [3, 2, 1];
-           * });
-           */
-          function all(array) {
-            return new All(array)._promise;
-          }
-        },
-        { './aigle': 2, './internal/util': 39, './props': 59, 'aigle-core': 85 }
-      ],
-      4: [
-        function(require, module, exports) {
-          'use strict';
-
-          var Aigle = require('./aigle');
-          var ref = require('./internal/util');
-          var INTERNAL = ref.INTERNAL;
-          var callResolve = ref.callResolve;
-
-          module.exports = attempt;
-
-          /**
-           * @param {function} handler
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * Aigle.attempt(() => {
-           *     throw Error('error');
-           *   })
-           *   .catch(error => console.log(error)); // error
-           */
-          function attempt(handler) {
-            var receiver = new Aigle(INTERNAL);
-            callResolve(receiver, handler);
-            return receiver;
-          }
-        },
-        { './aigle': 2, './internal/util': 39 }
-      ],
-      5: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./each');
-          var Each = ref.Each;
-          var ref$1 = require('./internal/util');
-          var concatArray = ref$1.concatArray;
-          var ref$2 = require('./internal/collection');
-          var setParallel = ref$2.setParallel;
-
-          var Concat = /*@__PURE__*/ (function(Each) {
-            function Concat(collection, iterator) {
-              Each.call(this, collection, iterator, set);
-            }
-
-            if (Each) Concat.__proto__ = Each;
-            Concat.prototype = Object.create(Each && Each.prototype);
-            Concat.prototype.constructor = Concat;
-
-            Concat.prototype._callResolve = function _callResolve(value, index) {
-              this._result[index] = value;
-              if (--this._rest === 0) {
-                this._promise._resolve(concatArray(this._result));
-              }
-            };
-
-            return Concat;
-          })(Each);
-
-          module.exports = { concat: concat, Concat: Concat };
-
-          function set(collection) {
-            setParallel.call(this, collection);
-            this._result = Array(this._rest);
-            return this;
-          }
-
-          /**
-           * `Aigle.concat` has almost the same functionality as `Array#concat`.
-           * It iterates all elements of `collection` and executes `iterator` using each element on parallel.
-           * The `iterator` needs to return a promise or something.
-           * If a promise is returned, the function will wait until the promise is fulfilled.
-           * Then the result will be assigned to an array, the role is the same as `Array#concat`.
-           * All of them are finished, the function will return an array as a result.
-           * @param {Array|Object} collection
-           * @param {Function} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = (num, index, collection) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num;
-           *     });
-           * };
-           * Aigle.concat(collection, iterator)
-           *   .then(array => {
-           *     console.log(array); // [1, 2, 4];
-           *     console.log(order); // [1, 2, 4];
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = { a: 1, b: 4, c: 2 };
-           * const iterator = (num, key, collection) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num;
-           *     });
-           * };
-           * Aigle.concat(collection, iterator)
-           *   .then(array => {
-           *     console.log(array); // [1, 2, 4];
-           *     console.log(order); // [1, 2, 4];
-           *   });
-           */
-          function concat(collection, iterator) {
-            return new Concat(collection, iterator)._execute();
-          }
-        },
-        { './each': 12, './internal/collection': 36, './internal/util': 39 }
-      ],
-      6: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./eachLimit');
-          var EachLimit = ref.EachLimit;
-          var ref$1 = require('./internal/util');
-          var concatArray = ref$1.concatArray;
-          var ref$2 = require('./internal/collection');
-          var setLimit = ref$2.setLimit;
-
-          var ConcatLimit = /*@__PURE__*/ (function(EachLimit) {
-            function ConcatLimit(collection, limit, iterator) {
-              EachLimit.call(this, collection, limit, iterator, set);
-            }
-
-            if (EachLimit) ConcatLimit.__proto__ = EachLimit;
-            ConcatLimit.prototype = Object.create(EachLimit && EachLimit.prototype);
-            ConcatLimit.prototype.constructor = ConcatLimit;
-
-            ConcatLimit.prototype._callResolve = function _callResolve(value, index) {
-              this._result[index] = value;
-              if (--this._rest === 0) {
-                this._promise._resolve(concatArray(this._result));
-              } else if (this._callRest-- > 0) {
-                this._iterate();
-              }
-            };
-
-            return ConcatLimit;
-          })(EachLimit);
-
-          module.exports = { concatLimit: concatLimit, ConcatLimit: ConcatLimit };
-
-          function set(collection) {
-            setLimit.call(this, collection);
-            this._result = Array(this._rest);
-            return this;
-          }
-
-          /**
-           * `Aigle.concatLimit` is almost the as [`Aigle.concat`](https://suguru03.github.io/aigle/docs/Aigle.html#concat) and
-           * [`Aigle.concatSeries`](https://suguru03.github.io/aigle/docs/Aigle.html#concatSeries), but it will work with concurrency.
-           * @param {Array|Object} collection
-           * @param {integer} [limit=8]
-           * @param {Function} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 5, 3, 4, 2];
-           * const iterator = (num, index, collection) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num;
-           *     });
-           * };
-           * Aigle.concatLimit(collection, 2, iterator)
-           *   .then(array => {
-           *     console.log(array); // [1, 3, 5, 2, 4];
-           *     console.log(order); // [1, 3, 5, 2, 4];
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = {
-           *   task1: 1,
-           *   task2: 5,
-           *   task3: 3,
-           *   task4: 4,
-           *   task5: 2
-           * };
-           * const iterator = (num, key, collection) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num;
-           *     });
-           * };
-           * Aigle.concatLimit(collection, 2, iterator)
-           *   .then(array => {
-           *     console.log(array); // [1, 3, 5, 2, 4];
-           *     console.log(order); // [1, 3, 5, 2, 4];
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [1, 5, 3, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num;
-           *     });
-           * };
-           * Aigle.concatLimit(collection, iterator)
-           *   .then(array => {
-           *     console.log(array); // [1, 2, 3, 4, 5];
-           *     console.log(order); // [1, 2, 3, 4, 5];
-           *   });
-           */
-          function concatLimit(collection, limit, iterator) {
-            return new ConcatLimit(collection, limit, iterator)._execute();
-          }
-        },
-        { './eachLimit': 13, './internal/collection': 36, './internal/util': 39 }
-      ],
-      7: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./eachSeries');
-          var EachSeries = ref.EachSeries;
-
-          var ConcatSeries = /*@__PURE__*/ (function(EachSeries) {
-            function ConcatSeries(collection, iterator) {
-              EachSeries.call(this, collection, iterator);
-              this._result = [];
-            }
-
-            if (EachSeries) ConcatSeries.__proto__ = EachSeries;
-            ConcatSeries.prototype = Object.create(EachSeries && EachSeries.prototype);
-            ConcatSeries.prototype.constructor = ConcatSeries;
-
-            ConcatSeries.prototype._callResolve = function _callResolve(value) {
-              var ref;
-
-              if (Array.isArray(value)) {
-                (ref = this._result).push.apply(ref, value);
-              } else if (value !== undefined) {
-                this._result.push(value);
-              }
-              if (--this._rest === 0) {
-                this._promise._resolve(this._result);
-              } else {
-                this._iterate();
-              }
-            };
-
-            return ConcatSeries;
-          })(EachSeries);
-
-          module.exports = { concatSeries: concatSeries, ConcatSeries: ConcatSeries };
-
-          /**
-           * `Aigle.concatSeries` is almost the as [`Aigle.concat`](https://suguru03.github.io/aigle/docs/Aigle.html#concat), but it will work in series.
-           * @param {Array|Object} collection
-           * @param {Function} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = (num, index, collection) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num;
-           *     });
-           * };
-           * Aigle.concatSeries(collection, iterator)
-           *   .then(array => {
-           *     console.log(array); // [1, 4, 2];
-           *     console.log(order); // [1, 4, 2];
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = { a: 1, b: 4, c: 2 };
-           * const iterator = (num, key, collection) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num;
-           *     });
-           * };
-           * Aigle.concatSeries(collection, iterator)
-           *   .then(array => {
-           *     console.log(array); // [1, 4, 2];
-           *     console.log(order); // [1, 4, 2];
-           *   });
-           */
-          function concatSeries(collection, iterator) {
-            return new ConcatSeries(collection, iterator)._execute();
-          }
-        },
-        { './eachSeries': 14 }
-      ],
-      8: [
-        function(require, module, exports) {
-          'use strict';
-
-          module.exports = {
-            resolveStack: resolveStack,
-            reconstructStack: reconstructStack
-          };
-
-          function resolveStack(promise) {
-            Error.captureStackTrace(promise);
-          }
-
-          function reconstructStack(promise) {
-            var stack = promise.stack;
-            var _value = promise._value;
-            if (_value instanceof Error === false || !stack) {
-              return;
-            }
-            if (!_value._reconstruct) {
-              _value.stack = reconstruct(_value.stack).join('\n');
-              _value._reconstruct = true;
-            }
-            var stacks = reconstruct(stack);
-            stacks[0] = '\nFrom previous event:';
-            _value.stack += stacks.join('\n');
-          }
-
-          function reconstruct(stack) {
-            var result = [];
-            var stacks = stack.split('\n');
-            for (var i = 0; i < stacks.length; i++) {
-              var s = stacks[i];
-              if (/node_modules/.test(s)) {
-                continue;
-              }
-              result.push(s);
-            }
-            return result;
-          }
-        },
-        {}
-      ],
-      9: [
-        function(require, module, exports) {
-          'use strict';
-
-          var Aigle = require('./aigle');
-          var ref = require('./internal/util');
-          var INTERNAL = ref.INTERNAL;
-
-          var Delay = /*@__PURE__*/ (function(Aigle) {
-            function Delay(ms) {
-              Aigle.call(this, INTERNAL);
-              this._ms = ms;
-              this._timer = undefined;
-            }
-
-            if (Aigle) Delay.__proto__ = Aigle;
-            Delay.prototype = Object.create(Aigle && Aigle.prototype);
-            Delay.prototype.constructor = Delay;
-
-            Delay.prototype._resolve = function _resolve(value) {
-              var this$1 = this;
-
-              this._timer = setTimeout(function() {
-                return Aigle.prototype._resolve.call(this$1, value);
-              }, this._ms);
-              return this;
-            };
-
-            Delay.prototype._reject = function _reject(reason) {
-              clearTimeout(this._timer);
-              Aigle.prototype._reject.call(this, reason);
-            };
-
-            return Delay;
-          })(Aigle);
-
-          module.exports = { delay: delay, Delay: Delay };
-
-          /**
-           * Return a promise which will be resolved with `value` after `ms`.
-           * @param {number} ms
-           * @param {*} value
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * Aigle.delay(10)
-           *   .then(value => console.log(value); // undefined
-           *
-           * @example
-           * Aigle.delay(10, 'test')
-           *   .then(value => console.log(value); // 'test'
-           */
-          function delay(ms, value) {
-            return new Delay(ms)._resolve(value);
-          }
-        },
-        { './aigle': 2, './internal/util': 39 }
-      ],
-      10: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./doWhilst');
-          var DoWhilst = ref.DoWhilst;
-          var ref$1 = require('./until');
-          var UntilTester = ref$1.UntilTester;
-
-          module.exports = doUntil;
-
-          /**
-           * @param {*} [value]
-           * @param {Function} iterator
-           * @param {Function} tester
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * let count = 0;
-           * const order = [];
-           * const tester = num => {
-           *   order.push(`t:${num}`);
-           *   return Aigle.delay(10)
-           *     .then(() => num === 4);
-           * };
-           * const iterator = () => {
-           *   const num = ++count;
-           *   order.push(`i:${num}`);
-           *   return Aigle.delay(10)
-           *     .then(() => num);
-           * };
-           * Aigle.doUntil(iterator, tester)
-           *   .then(value => {
-           *     console.log(value); // 4
-           *     console.log(count); // 4
-           *     console.log(order); // [ 'i:1', 't:1', 'i:2', 't:2', 'i:3', 't:3', 'i:4', 't:4' ]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const tester = num => {
-           *   order.push(`t:${num}`);
-           *   return Aigle.delay(10)
-           *     .then(() => num === 4);
-           * };
-           * const iterator = count => {
-           *   const num = ++count;
-           *   order.push(`i:${num}`);
-           *   return Aigle.delay(10)
-           *     .then(() => num);
-           * };
-           * Aigle.doUntil(0, iterator, tester)
-           *   .then(value => {
-           *     console.log(value); // 4
-           *     console.log(order); // [ 'i:1', 't:1', 'i:2', 't:2', 'i:3', 't:3', 'i:4', 't:4' ]
-           *   });
-           */
-          function doUntil(value, iterator, tester) {
-            if (typeof tester !== 'function') {
-              tester = iterator;
-              iterator = value;
-              value = undefined;
-            }
-            return new DoWhilst(new UntilTester(tester), iterator)._iterate(value);
-          }
-        },
-        { './doWhilst': 11, './until': 82 }
-      ],
-      11: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./whilst');
-          var AigleWhilst = ref.AigleWhilst;
-          var WhilstTester = ref.WhilstTester;
-
-          var DoWhilst = /*@__PURE__*/ (function(AigleWhilst) {
-            function DoWhilst(test, iterator) {
-              AigleWhilst.call(this, test, iterator);
-            }
-
-            if (AigleWhilst) DoWhilst.__proto__ = AigleWhilst;
-            DoWhilst.prototype = Object.create(AigleWhilst && AigleWhilst.prototype);
-            DoWhilst.prototype.constructor = DoWhilst;
-
-            DoWhilst.prototype._iterate = function _iterate(value) {
-              this._next(value);
-              return this._promise;
-            };
-
-            return DoWhilst;
-          })(AigleWhilst);
-
-          module.exports = { doWhilst: doWhilst, DoWhilst: DoWhilst };
-
-          /**
-           * @param {*} [value]
-           * @param {Function} iterator
-           * @param {Function} tester
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * let count = 0;
-           * const order = [];
-           * const tester = num => {
-           *   order.push(`t:${num}`);
-           *   return Aigle.delay(10)
-           *     .then(() => num !== 4);
-           * };
-           * const iterator = () => {
-           *   const num = ++count;
-           *   order.push(`i:${num}`);
-           *   return Aigle.delay(10)
-           *     .then(() => num);
-           * };
-           * Aigle.doWhilst(iterator, tester)
-           *   .then(value => {
-           *     console.log(value); // 4
-           *     console.log(count); // 4
-           *     console.log(order); // [ 'i:1', 't:1', 'i:2', 't:2', 'i:3', 't:3', 'i:4', 't:4' ]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const tester = num => {
-           *   order.push(`t:${num}`);
-           *   return Aigle.delay(10)
-           *     .then(() => num !== 4);
-           * };
-           * const iterator = count => {
-           *   const num = ++count;
-           *   order.push(`i:${num}`);
-           *   return Aigle.delay(10)
-           *     .then(() => num);
-           * };
-           * Aigle.doWhilst(0, iterator, tester)
-           *   .then(value => {
-           *     console.log(value); // 4
-           *     console.log(order); // [ 'i:1', 't:1', 'i:2', 't:2', 'i:3', 't:3', 'i:4', 't:4' ]
-           *   });
-           */
-          function doWhilst(value, iterator, tester) {
-            if (typeof tester !== 'function') {
-              tester = iterator;
-              iterator = value;
-              value = undefined;
-            }
-            return new DoWhilst(new WhilstTester(tester), iterator)._iterate(value);
-          }
-        },
-        { './whilst': 84 }
-      ],
-      12: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('aigle-core');
-          var AigleProxy = ref.AigleProxy;
-
-          var Aigle = require('./aigle');
-          var ref$1 = require('./internal/util');
-          var INTERNAL = ref$1.INTERNAL;
-          var PENDING = ref$1.PENDING;
-          var ref$2 = require('./internal/collection');
-          var execute = ref$2.execute;
-          var setParallel = ref$2.setParallel;
-
-          var Each = /*@__PURE__*/ (function(AigleProxy) {
-            function Each(collection, iterator, set) {
-              if (set === void 0) set = setDefault;
-
-              AigleProxy.call(this);
-              this._iterator = iterator;
-              this._promise = new Aigle(INTERNAL);
-              this._coll = undefined;
-              this._size = undefined;
-              this._rest = undefined;
-              this._keys = undefined;
-              this._result = undefined;
-              this._iterate = undefined;
-              if (collection === PENDING) {
-                this._set = set;
-                this._iterate = this._callResolve;
-                this._callResolve = execute;
-              } else {
-                set.call(this, collection);
-              }
-            }
-
-            if (AigleProxy) Each.__proto__ = AigleProxy;
-            Each.prototype = Object.create(AigleProxy && AigleProxy.prototype);
-            Each.prototype.constructor = Each;
-
-            Each.prototype._execute = function _execute() {
-              if (this._rest === 0) {
-                this._promise._resolve(this._result);
-              } else {
-                this._iterate();
-              }
-              return this._promise;
-            };
-
-            Each.prototype._callResolve = function _callResolve(value) {
-              if (--this._rest === 0 || value === false) {
-                this._promise._resolve(this._result);
-              }
-            };
-
-            Each.prototype._callReject = function _callReject(reason) {
-              this._promise._reject(reason);
-            };
-
-            return Each;
-          })(AigleProxy);
-
-          module.exports = { each: each, Each: Each };
-
-          function setDefault(collection) {
-            setParallel.call(this, collection);
-            this._result = collection;
-            return this;
-          }
-
-          /**
-           * `Aigle.each` iterates all elements of `collection` and execute `iterator` for each element on parallel.
-           * The iterator is called with three arguments. (value, index|key, collection)
-           * If the iterator returns `false` or a promise which has `false` as a result, the promise state will be `onFulfilled` immediately.
-           * ⚠ All elements are already executed and can't be stopped. If you care about it, you should use [`Aigle.eachSeries`](https://suguru03.github.io/aigle/docs/global.html#eachSeries).
-           * @param {Array|Object} collection
-           * @param {Function} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           *   const order = [];
-           *   const collection = [1, 4, 2];
-           *   const iterator = (num, index, collection) => {
-           *     return Aigle.delay(num * 10)
-           *       .then(() => order.push(num));
-           *   };
-           *   return Aigle.each(collection, iterator)
-           *     .then(value => {
-           *       console.log(value); // undefined
-           *       console.log(order); // [1, 2, 4];
-           *     });
-           *
-           * @example
-           *   const order = [];
-           *   const collection = { a: 1, b: 4, c: 2 };
-           *   const iterator = (num, key, collection) => {
-           *     return Aigle.delay(num * 10)
-           *       .then(() => order.push(num));
-           *   };
-           *   return Aigle.each(collection, iterator)
-           *     .then(value => {
-           *       console.log(value); // undefined
-           *       console.log(order); // [1, 2, 4];
-           *     });
-           *
-           * @example
-           *    const order = [];
-           *    const collection = [1, 4, 2];
-           *    const iterator = (num, index, collection) => {
-           *      return Aigle.delay(num * 10)
-           *        .then(() => {
-           *          order.push(num);
-           *          return num !== 2; // break
-           *        });
-           *    };
-           *    return Aigle.each(collection, iterator)
-           *      .then(value => {
-           *        console.log(value); // undefined
-           *        console.log(order); // [1, 2];
-           *      });
-           */
-          function each(collection, iterator) {
-            return new Each(collection, iterator)._execute();
-          }
-        },
-        { './aigle': 2, './internal/collection': 36, './internal/util': 39, 'aigle-core': 85 }
-      ],
-      13: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('aigle-core');
-          var AigleProxy = ref.AigleProxy;
-
-          var Aigle = require('./aigle');
-          var ref$1 = require('./internal/util');
-          var DEFAULT_LIMIT = ref$1.DEFAULT_LIMIT;
-          var INTERNAL = ref$1.INTERNAL;
-          var PENDING = ref$1.PENDING;
-          var ref$2 = require('./internal/collection');
-          var execute = ref$2.execute;
-          var setLimit = ref$2.setLimit;
-
-          var EachLimit = /*@__PURE__*/ (function(AigleProxy) {
-            function EachLimit(collection, limit, iterator, set) {
-              if (set === void 0) set = setDefault;
-
-              AigleProxy.call(this);
-              if (typeof limit === 'function') {
-                iterator = limit;
-                limit = DEFAULT_LIMIT;
-              }
-              this._iterator = iterator;
-              this._promise = new Aigle(INTERNAL);
-              this._index = 0;
-              this._limit = limit;
-              this._coll = undefined;
-              this._rest = undefined;
-              this._size = undefined;
-              this._keys = undefined;
-              this._result = undefined;
-              this._iterate = undefined;
-              this._callRest = undefined;
-              if (collection === PENDING) {
-                this._set = set;
-                this._iterate = this._callResolve;
-                this._callResolve = execute;
-              } else {
-                set.call(this, collection);
-              }
-            }
-
-            if (AigleProxy) EachLimit.__proto__ = AigleProxy;
-            EachLimit.prototype = Object.create(AigleProxy && AigleProxy.prototype);
-            EachLimit.prototype.constructor = EachLimit;
-
-            EachLimit.prototype._execute = function _execute() {
-              if (this._rest === 0) {
-                this._promise._resolve(this._result);
-              } else {
-                while (this._limit--) {
-                  this._iterate();
-                }
-              }
-              return this._promise;
-            };
-
-            EachLimit.prototype._callResolve = function _callResolve(value) {
-              if (value === false) {
-                this._callRest = 0;
-                this._promise._resolve(this._result);
-              } else if (--this._rest === 0) {
-                this._promise._resolve(this._result);
-              } else if (this._callRest-- > 0) {
-                this._iterate();
-              }
-            };
-
-            EachLimit.prototype._callReject = function _callReject(reason) {
-              this._callRest = 0;
-              this._promise._reject(reason);
-            };
-
-            return EachLimit;
-          })(AigleProxy);
-
-          module.exports = { eachLimit: eachLimit, EachLimit: EachLimit };
-
-          function setDefault(collection) {
-            setLimit.call(this, collection);
-            this._result = collection;
-            return this;
-          }
-
-          /**
-           * `Aigle.eachLimit` is almost same as [`Aigle.each`](https://suguru03.github.io/aigle/docs/Aigle.html#each)
-           *  and [`Aigle.eachSeries`](https://suguru03.github.io/aigle/docs/Aigle.html#eachSeries),
-           *  but it will work with concurrency.
-           * `limit` is concurrency, if it is not defined, concurrency is 8.
-           * @param {Array|Object} A - collection to iterate over
-           * @param {integer} [limit=8] - It is concurrncy, default is 8
-           * @param {Function} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 5, 3, 4, 2];
-           * const iterator = (num, index) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num;
-           *     });
-           * };
-           * Aigle.eachLimit(collection, 2, iterator)
-           *   .then(value => {
-           *     console.log(value); // undefined
-           *     console.log(order); // [1, 3, 5, 2, 4];
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = {
-           *   task1: 1,
-           *   task2: 5,
-           *   task3: 3,
-           *   task4: 4,
-           *   task5: 2
-           * };
-           * const iterator = (num, key) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num;
-           *     });
-           * };
-           * Aigle.eachLimit(collection, 2, iterator)
-           *   .then(value => {
-           *     console.log(value); // undefined
-           *     console.log(order); // [1, 3, 5, 2, 4];
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [1, 5, 3, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num;
-           *     });
-           * };
-           * Aigle.eachLimit(collection, iterator)
-           *   .then(value => {
-           *     console.log(value); // undefined
-           *     console.log(order); // [1, 2, 3, 4, 5];
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [1, 5, 3, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num !== 3;
-           *     });
-           * };
-           * Aigle.eachLimit(collection, iterator)
-           *   .then(value => {
-           *     console.log(value); // undefined
-           *     console.log(order); // [1, 2, 3];
-           *   });
-           */
-          function eachLimit(collection, limit, iterator) {
-            return new EachLimit(collection, limit, iterator)._execute();
-          }
-        },
-        { './aigle': 2, './internal/collection': 36, './internal/util': 39, 'aigle-core': 85 }
-      ],
-      14: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('aigle-core');
-          var AigleProxy = ref.AigleProxy;
-
-          var Aigle = require('./aigle');
-          var ref$1 = require('./internal/util');
-          var INTERNAL = ref$1.INTERNAL;
-          var PENDING = ref$1.PENDING;
-          var ref$2 = require('./internal/collection');
-          var execute = ref$2.execute;
-          var setSeries = ref$2.setSeries;
-
-          var EachSeries = /*@__PURE__*/ (function(AigleProxy) {
-            function EachSeries(collection, iterator, set) {
-              if (set === void 0) set = setDefault;
-
-              AigleProxy.call(this);
-              this._iterator = iterator;
-              this._promise = new Aigle(INTERNAL);
-              this._index = 0;
-              this._coll = undefined;
-              this._rest = undefined;
-              this._size = undefined;
-              this._keys = undefined;
-              this._result = undefined;
-              this._iterate = undefined;
-              if (collection === PENDING) {
-                this._set = set;
-                this._iterate = this._callResolve;
-                this._callResolve = execute;
-              } else {
-                set.call(this, collection);
-              }
-            }
-
-            if (AigleProxy) EachSeries.__proto__ = AigleProxy;
-            EachSeries.prototype = Object.create(AigleProxy && AigleProxy.prototype);
-            EachSeries.prototype.constructor = EachSeries;
-
-            EachSeries.prototype._execute = function _execute() {
-              if (this._rest === 0) {
-                this._promise._resolve(this._result);
-              } else {
-                this._iterate();
-              }
-              return this._promise;
-            };
-
-            EachSeries.prototype._callResolve = function _callResolve(value) {
-              if (--this._rest === 0 || value === false) {
-                this._promise._resolve(this._result);
-              } else {
-                this._iterate();
-              }
-            };
-
-            EachSeries.prototype._callReject = function _callReject(reason) {
-              this._promise._reject(reason);
-            };
-
-            return EachSeries;
-          })(AigleProxy);
-
-          module.exports = { eachSeries: eachSeries, EachSeries: EachSeries };
-
-          function setDefault(collection) {
-            setSeries.call(this, collection);
-            this._result = collection;
-            return this;
-          }
-
-          /**
-           * `Aigle.eachSeries` is almost the same as [`Aigle.each`](https://suguru03.github.io/aigle/docs/Aigle.html#each), but it will work in series.
-           * @param {Array|Object} collection
-           * @param {Function} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => order.push(num));
-           * };
-           * Aigle.eachSeries(collection, iterator)
-           *   .then(value => {
-           *     console.log(value); // undefined
-           *     console.log(order); // [1, 4, 2];
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = { a: 1, b: 4, c: 2 };
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => order.push(num));
-           * };
-           * Aigle.eachSeries(collection, iterator)
-           *   .then(value => {
-           *     console.log(value); // undefined
-           *     console.log(order); // [1, 4, 2];
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num !== 4; // break
-           *     });
-           * };
-           * Aigle.eachSeries(collection, iterator)
-           *   .then(value => {
-           *     console.log(value); // undefined
-           *     console.log(order); // [1, 4];
-           *   });
-           */
-          function eachSeries(collection, iterator) {
-            return new EachSeries(collection, iterator)._execute();
-          }
-        },
-        { './aigle': 2, './internal/collection': 36, './internal/util': 39, 'aigle-core': 85 }
-      ],
-      15: [
-        function(require, module, exports) {
-          'use strict';
-
-          var types = ['CancellationError', 'TimeoutError'];
-          var l = types.length;
-          while (l--) {
-            var name = types[l];
-            var Class = /*@__PURE__*/ (function(Error) {
-              function Class() {
-                Error.apply(this, arguments);
-              }
-              if (Error) Class.__proto__ = Error;
-              Class.prototype = Object.create(Error && Error.prototype);
-              Class.prototype.constructor = Class;
-
-              return Class;
-            })(Error);
-            Class.prototype.name = name;
-            exports[name] = Class;
-          }
-        },
-        {}
-      ],
-      16: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./each');
-          var Each = ref.Each;
-          var ref$1 = require('./internal/util');
-          var PENDING = ref$1.PENDING;
-          var ref$2 = require('./internal/collection');
-          var setShorthand = ref$2.setShorthand;
-
-          var Every = /*@__PURE__*/ (function(Each) {
-            function Every(collection, iterator) {
-              Each.call(this, collection, iterator);
-              this._result = true;
-              if (collection === PENDING) {
-                this._set = setShorthand;
-              } else {
-                setShorthand.call(this, collection);
-              }
-            }
-
-            if (Each) Every.__proto__ = Each;
-            Every.prototype = Object.create(Each && Each.prototype);
-            Every.prototype.constructor = Every;
-
-            Every.prototype._callResolve = function _callResolve(value) {
-              if (!value) {
-                this._promise._resolve(false);
-              } else if (--this._rest === 0) {
-                this._promise._resolve(true);
-              }
-            };
-
-            return Every;
-          })(Each);
-
-          module.exports = { every: every, Every: Every };
-
-          /**
-           * `Aigle.every` is similar to `Array#every`.
-           * If all elements return truthly or a promise which has a truthly value as a result,
-           * the result will be `true`, otherwise it will be `false`.
-           * @param {Array|Object} collection
-           * @param {Function|Array|Object|string} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = (num, index, collection) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return true;
-           *     });
-           * };
-           * Aigle.every(collection, iterator)
-           *   .then(value => {
-           *     console.log(value); // true
-           *     console.log(order); // [1, 2, 4];
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = { a: 1, b: 4, c: 2 };
-           * const iterator = (num, key, collection) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return true;
-           *     });
-           * };
-           * Aigle.every(collection, iterator)
-           *   .then(value => {
-           *     console.log(value); // true
-           *     console.log(order); // [1, 2, 4];
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return n % 2;
-           *     });
-           * };
-           * Aigle.every(collection, iterator)
-           *   .then(value => {
-           *     console.log(value); // false
-           *     console.log(order); // [1, 2];
-           *   });
-           *
-           * @example
-           * const collection = [{
-           *  uid: 1, active: false
-           * }, {
-           *  uid: 4, active: true
-           * }, {
-           *  uid: 2, active: true
-           * }];
-           * Aigle.every(collection, 'active')
-           *   .then(value => console.log(value)); // false
-           *
-           * @example
-           * const collection = [{
-           *  uid: 1, active: false
-           * }, {
-           *  uid: 4, active: true
-           * }, {
-           *  uid: 2, active: true
-           * }];
-           * Aigle.every(collection, ['active', true])
-           *   .then(value => console.log(value)); // false
-           *
-           * @example
-           * const collection = [{
-           *  uid: 1, active: true
-           * }, {
-           *  uid: 4, active: true
-           * }, {
-           *  uid: 2, active: true
-           * }];
-           * Aigle.every(collection, { active: true })
-           *   .then(value => console.log(value)); // true
-           */
-          function every(collection, iterator) {
-            return new Every(collection, iterator)._execute();
-          }
-        },
-        { './each': 12, './internal/collection': 36, './internal/util': 39 }
-      ],
-      17: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./eachLimit');
-          var EachLimit = ref.EachLimit;
-
-          var EveryLimit = /*@__PURE__*/ (function(EachLimit) {
-            function EveryLimit(collection, limit, iterator) {
-              EachLimit.call(this, collection, limit, iterator);
-              this._result = true;
-            }
-
-            if (EachLimit) EveryLimit.__proto__ = EachLimit;
-            EveryLimit.prototype = Object.create(EachLimit && EachLimit.prototype);
-            EveryLimit.prototype.constructor = EveryLimit;
-
-            EveryLimit.prototype._callResolve = function _callResolve(value) {
-              if (!value) {
-                this._promise._resolve(false);
-              } else if (--this._rest === 0) {
-                this._promise._resolve(true);
-              } else if (this._callRest-- > 0) {
-                this._iterate();
-              }
-            };
-
-            return EveryLimit;
-          })(EachLimit);
-
-          module.exports = { everyLimit: everyLimit, EveryLimit: EveryLimit };
-
-          /**
-           * @param {Array|Object} collection
-           * @param {integer} [limit=8]
-           * @param {Function} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 5, 3, 4, 2];
-           * const iterator = (num, index) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return true;
-           *     });
-           * };
-           * Aigle.everyLimit(collection, 2, iterator)
-           *   .then(value => {
-           *     console.log(value); // true
-           *     console.log(order); // [1, 3, 5, 2, 4];
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = {
-           *   task1: 1,
-           *   task2: 5,
-           *   task3: 3,
-           *   task4: 4,
-           *   task5: 2
-           * };
-           * const iterator = (num, key) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return true;
-           *     });
-           * };
-           * Aigle.everyLimit(collection, 2, iterator)
-           *   .then(value => {
-           *     console.log(value); // true
-           *     console.log(order); // [1, 3, 5, 2, 4];
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [1, 5, 3, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num === 4;
-           *     });
-           * };
-           * Aigle.everyLimit(collection, iterator)
-           *   .then(value => {
-           *     console.log(value); // false
-           *     console.log(order); // [1, 2, 3, 4];
-           *   });
-           */
-          function everyLimit(collection, limit, iterator) {
-            return new EveryLimit(collection, limit, iterator)._execute();
-          }
-        },
-        { './eachLimit': 13 }
-      ],
-      18: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./eachSeries.js');
-          var EachSeries = ref.EachSeries;
-
-          var EverySeries = /*@__PURE__*/ (function(EachSeries) {
-            function EverySeries(collection, iterator) {
-              EachSeries.call(this, collection, iterator);
-              this._result = true;
-            }
-
-            if (EachSeries) EverySeries.__proto__ = EachSeries;
-            EverySeries.prototype = Object.create(EachSeries && EachSeries.prototype);
-            EverySeries.prototype.constructor = EverySeries;
-
-            EverySeries.prototype._callResolve = function _callResolve(value) {
-              if (!value) {
-                this._promise._resolve(false);
-              } else if (--this._rest === 0) {
-                this._promise._resolve(true);
-              } else {
-                this._iterate();
-              }
-            };
-
-            return EverySeries;
-          })(EachSeries);
-
-          module.exports = { everySeries: everySeries, EverySeries: EverySeries };
-
-          /**
-           * `Aigle.everySeries` is almost the same as [`Aigle.every`](https://suguru03.github.io/aigle/docs/Aigle.html#every), but it will work in series.
-           * @param {Array|Object} collection
-           * @param {Function} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = (num, index, collection) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return true;
-           *     });
-           * };
-           * Aigle.everySeries(collection, iterator)
-           *   .then(value => {
-           *     console.log(value); // true
-           *     console.log(order); // [1, 4, 2];
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = { a: 1, b: 4, c: 2 };
-           * const iterator = (num, key, collection) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return true;
-           *     });
-           * };
-           * Aigle.everySeries(collection, iterator)
-           *   .then(value => {
-           *     console.log(value); // true
-           *     console.log(order); // [1, 4, 2];
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return n % 2;
-           *     });
-           * };
-           * Aigle.everySeries(collection, iterator)
-           *   .then(value => {
-           *     console.log(value); // false
-           *     console.log(order); // [1, 4];
-           *   });
-           */
-          function everySeries(collection, iterator) {
-            return new EverySeries(collection, iterator)._execute();
-          }
-        },
-        { './eachSeries.js': 14 }
-      ],
-      19: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./each');
-          var Each = ref.Each;
-          var ref$1 = require('./internal/collection');
-          var setShorthand = ref$1.setShorthand;
-          var ref$2 = require('./internal/util');
-          var INTERNAL = ref$2.INTERNAL;
-          var compactArray = ref$2.compactArray;
-
-          var Filter = /*@__PURE__*/ (function(Each) {
-            function Filter(collection, iterator) {
-              Each.call(this, collection, iterator, set);
-            }
-
-            if (Each) Filter.__proto__ = Each;
-            Filter.prototype = Object.create(Each && Each.prototype);
-            Filter.prototype.constructor = Filter;
-
-            return Filter;
-          })(Each);
-
-          Filter.prototype._set = set;
-
-          module.exports = { filter: filter, Filter: Filter };
-
-          function set(collection) {
-            setShorthand.call(this, collection);
-            this._result = Array(this._rest);
-            this._callResolve = this._keys === undefined ? callResolveArray : callResolveObject;
-            return this;
-          }
-
-          function callResolveArray(value, index) {
-            this._result[index] = value ? this._coll[index] : INTERNAL;
-            if (--this._rest === 0) {
-              this._promise._resolve(compactArray(this._result));
-            }
-          }
-
-          function callResolveObject(value, index) {
-            this._result[index] = value ? this._coll[this._keys[index]] : INTERNAL;
-            if (--this._rest === 0) {
-              this._promise._resolve(compactArray(this._result));
-            }
-          }
-
-          /**
-           * `Aigle.filter` has almost the same functionality as `Array#filter`.
-           * It iterates all elements of `collection` and executes `iterator` using each element on parallel.
-           * The `iterator` needs to return a promise or something.
-           * If a promise is returned, the function will wait until the promise is fulfilled.
-           * If the result is falsy, the element will be removed.
-           * All of them are finished, the function will return an array as a result.
-           * @param {Array|Object} collection
-           * @param {Function|Array|Object|string} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = (num, index) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2;
-           *     });
-           * };
-           * Aigle.filter(collection, iterator)
-           *   .then(array => {
-           *     console.log(array); // [1];
-           *     console.log(order); // [1, 2, 4];
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = { a: 1, b: 4, c: 2 };
-           * const iterator = (num, key) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2;
-           *     });
-           * };
-           * Aigle.filter(collection, iterator)
-           *   .then(array => {
-           *     console.log(array); // [1];
-           *     console.log(order); // [1, 2, 4];
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [{
-           *   name: 'bargey', active: false
-           * }, {
-           *   name: 'fread', active: true
-           * }];
-           * Aigle.filter(collection, 'active')
-           *   .then(array => {
-           *     console.log(array); // [{ name: 'fread', active: true }]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [{
-           *   name: 'bargey', active: false
-           * }, {
-           *   name: 'fread', active: true
-           * }];
-           * Aigle.filter(collection, ['name', 'fread'])
-           *   .then(array => {
-           *     console.log(array); // [{ name: 'fread', active: true }]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [{
-           *   name: 'bargey', active: false
-           * }, {
-           *   name: 'fread', active: true
-           * }];
-           * Aigle.filter(collection, { name: 'fread', active: true })
-           *   .then(array => {
-           *     console.log(array); // [{ name: 'fread', active: true }]
-           *   });
-           */
-          function filter(collection, iterator) {
-            return new Filter(collection, iterator)._execute();
-          }
-        },
-        { './each': 12, './internal/collection': 36, './internal/util': 39 }
-      ],
-      20: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./eachLimit');
-          var EachLimit = ref.EachLimit;
-          var ref$1 = require('./internal/collection');
-          var setLimit = ref$1.setLimit;
-          var ref$2 = require('./internal/util');
-          var INTERNAL = ref$2.INTERNAL;
-          var compactArray = ref$2.compactArray;
-
-          var FilterLimit = /*@__PURE__*/ (function(EachLimit) {
-            function FilterLimit(collection, limit, iterator) {
-              EachLimit.call(this, collection, limit, iterator, set);
-            }
-
-            if (EachLimit) FilterLimit.__proto__ = EachLimit;
-            FilterLimit.prototype = Object.create(EachLimit && EachLimit.prototype);
-            FilterLimit.prototype.constructor = FilterLimit;
-
-            return FilterLimit;
-          })(EachLimit);
-
-          module.exports = { filterLimit: filterLimit, FilterLimit: FilterLimit };
-
-          function set(collection) {
-            setLimit.call(this, collection);
-            this._result = Array(this._rest);
-            this._callResolve = this._keys === undefined ? callResolveArray : callResolveObject;
-            return this;
-          }
-
-          function callResolveArray(value, index) {
-            this._result[index] = value ? this._coll[index] : INTERNAL;
-            if (--this._rest === 0) {
-              this._promise._resolve(compactArray(this._result));
-            } else if (this._callRest-- > 0) {
-              this._iterate();
-            }
-          }
-
-          function callResolveObject(value, index) {
-            this._result[index] = value ? this._coll[this._keys[index]] : INTERNAL;
-            if (--this._rest === 0) {
-              this._promise._resolve(compactArray(this._result));
-            } else if (this._callRest-- > 0) {
-              this._iterate();
-            }
-          }
-
-          /**
-           * `Aigle.filterLimit` is almost the as [`Aigle.filter`](https://suguru03.github.io/aigle/docs/Aigle.html#filter) and
-           * [`Aigle.filterSeries`](https://suguru03.github.io/aigle/docs/Aigle.html#filterSeries), but it will work with concurrency.
-           * @param {Array|Object} collection
-           * @param {integer} [limit=8]
-           * @param {Function} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 5, 3, 4, 2];
-           * const iterator = (num, index) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2;
-           *     });
-           * };
-           * Aigle.filterLimit(collection, 2, iterator)
-           *   .then(array => {
-           *     console.log(array); // [1, 5, 3];
-           *     console.log(order); // [1, 3, 5, 2, 4];
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = {
-           *   task1: 1,
-           *   task2: 5,
-           *   task3: 3,
-           *   task4: 4,
-           *   task5: 2
-           * };
-           * const iterator = (num, key) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2;
-           *     });
-           * };
-           * Aigle.filterLimit(collection, 2, iterator)
-           *   .then(array => {
-           *     console.log(array); // [1, 5, 3];
-           *     console.log(order); // [1, 3, 5, 2, 4];
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [1, 5, 3, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2;
-           *     });
-           * };
-           * Aigle.filterLimit(collection, iterator)
-           *   .then(array => {
-           *     console.log(array); // [1, 5, 3];
-           *     console.log(order); // [1, 2, 3, 4, 5];
-           *   });
-           */
-          function filterLimit(collection, limit, iterator) {
-            return new FilterLimit(collection, limit, iterator)._execute();
-          }
-        },
-        { './eachLimit': 13, './internal/collection': 36, './internal/util': 39 }
-      ],
-      21: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./eachSeries');
-          var EachSeries = ref.EachSeries;
-          var ref$1 = require('./internal/collection');
-          var setSeries = ref$1.setSeries;
-          var ref$2 = require('./internal/util');
-          var INTERNAL = ref$2.INTERNAL;
-          var compactArray = ref$2.compactArray;
-
-          var FilterSeries = /*@__PURE__*/ (function(EachSeries) {
-            function FilterSeries(collection, iterator) {
-              EachSeries.call(this, collection, iterator, set);
-            }
-
-            if (EachSeries) FilterSeries.__proto__ = EachSeries;
-            FilterSeries.prototype = Object.create(EachSeries && EachSeries.prototype);
-            FilterSeries.prototype.constructor = FilterSeries;
-
-            return FilterSeries;
-          })(EachSeries);
-
-          module.exports = { filterSeries: filterSeries, FilterSeries: FilterSeries };
-
-          function set(collection) {
-            setSeries.call(this, collection);
-            this._result = Array(this._rest);
-            this._callResolve = this._keys === undefined ? callResolveArray : callResolveObject;
-            return this;
-          }
-
-          function callResolveArray(value, index) {
-            this._result[index] = value ? this._coll[index] : INTERNAL;
-            if (--this._rest === 0) {
-              this._promise._resolve(compactArray(this._result));
-            } else {
-              this._iterate();
-            }
-          }
-
-          function callResolveObject(value, index) {
-            this._result[index] = value ? this._coll[this._keys[index]] : INTERNAL;
-            if (--this._rest === 0) {
-              this._promise._resolve(compactArray(this._result));
-            } else {
-              this._iterate();
-            }
-          }
-
-          /**
-           * `Aigle.filterSeries` is almost the as [`Aigle.filter`](https://suguru03.github.io/aigle/docs/Aigle.html#filter), but it will work in series.
-           * @param {Array|Object} collection
-           * @param {Function} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = (num, index) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2;
-           *     });
-           * };
-           * Aigle.filterSeries(collection, iterator)
-           *   .then(array => {
-           *     console.log(array); // [1];
-           *     console.log(order); // [1, 4, 2];
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = { a: 1, b: 4, c: 2 };
-           * const iterator = (num, key) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2;
-           *     });
-           * };
-           * Aigle.filterSeries(collection, iterator)
-           *   .then(array => {
-           *     console.log(array); // [1];
-           *     console.log(order); // [1, 4, 2];
-           *   });
-           */
-          function filterSeries(collection, iterator) {
-            return new FilterSeries(collection, iterator)._execute();
-          }
-        },
-        { './eachSeries': 14, './internal/collection': 36, './internal/util': 39 }
-      ],
-      22: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./each');
-          var Each = ref.Each;
-          var ref$1 = require('./internal/collection');
-          var setShorthand = ref$1.setShorthand;
-
-          var Find = /*@__PURE__*/ (function(Each) {
-            function Find(collection, iterator) {
-              Each.call(this, collection, iterator, set);
-            }
-
-            if (Each) Find.__proto__ = Each;
-            Find.prototype = Object.create(Each && Each.prototype);
-            Find.prototype.constructor = Find;
-
-            return Find;
-          })(Each);
-
-          module.exports = { find: find, Find: Find };
-
-          function set(collection) {
-            setShorthand.call(this, collection);
-            this._callResolve = this._keys === undefined ? callResolveArray : callResolveObject;
-            return this;
-          }
-
-          function callResolveArray(value, index) {
-            if (value) {
-              this._size = 0;
-              this._promise._resolve(this._coll[index]);
-            } else if (--this._rest === 0) {
-              this._promise._resolve();
-            }
-          }
-
-          function callResolveObject(value, index) {
-            if (value) {
-              this._size = 0;
-              this._promise._resolve(this._coll[this._keys[index]]);
-            } else if (--this._rest === 0) {
-              this._promise._resolve();
-            }
-          }
-
-          /**
-           * `Aigle.find` has almost the same functionality as `Array#find`.
-           * It iterates all elements of `collection` and executes `iterator` using each element on parallel.
-           * The `iterator` needs to return a promise or something.
-           * If a promise is returned, the function will wait until the promise is fulfilled.
-           * If the result is truthly, the element will be returned as a result.
-           * @param {Array|Object} collection
-           * @param {Function|Array|Object|string} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2 === 0;
-           *     });
-           * };
-           * Aigle.find(collection, iterator)
-           *   .then(value => {
-           *     console.log(value); // 2
-           *     console.log(order); // [1, 2]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = { a: 1, b: 4, c: 2 };
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2 === 0;
-           *     });
-           * };
-           * Aigle.find(collection, iterator)
-           *   .then(value => {
-           *     console.log(value); // 2
-           *     console.log(order); // [1, 2]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return false;
-           *     });
-           * };
-           * Aigle.find(collection, iterator)
-           *   .then(value => {
-           *     console.log(value); // undefined
-           *     console.log(order); // [1, 2, 4]
-           *   });
-           *
-           * @example
-           * const collection = [{
-           *   name: 'bargey', active: false
-           * }, {
-           *   name: 'fread', active: true
-           * }];
-           * Aigle.find(collection, 'active')
-           *   .then(object => {
-           *     console.log(object); // { name: 'fread', active: true }
-           *   });
-           *
-           * @example
-           * const collection = [{
-           *   name: 'bargey', active: false
-           * }, {
-           *   name: 'fread', active: true
-           * }];
-           * Aigle.find(collection, ['name', 'fread'])
-           *   .then(object => {
-           *     console.log(object); // { name: 'fread', active: true }
-           *   });
-           *
-           * @example
-           * const collection = [{
-           *   name: 'bargey', active: false
-           * }, {
-           *   name: 'fread', active: true
-           * }];
-           * Aigle.find(collection, { name: 'fread', active: true })
-           *   .then(object => {
-           *     console.log(object); // { name: 'fread', active: true }
-           *   });
-           */
-          function find(collection, iterator) {
-            return new Find(collection, iterator)._execute();
-          }
-        },
-        { './each': 12, './internal/collection': 36 }
-      ],
-      23: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./each');
-          var Each = ref.Each;
-          var ref$1 = require('./internal/collection');
-          var setShorthand = ref$1.setShorthand;
-
-          var FindIndex = /*@__PURE__*/ (function(Each) {
-            function FindIndex(collection, iterator) {
-              Each.call(this, collection, iterator, set);
-              this._result = -1;
-            }
-
-            if (Each) FindIndex.__proto__ = Each;
-            FindIndex.prototype = Object.create(Each && Each.prototype);
-            FindIndex.prototype.constructor = FindIndex;
-
-            FindIndex.prototype._callResolve = function _callResolve(value, index) {
-              if (value) {
-                this._size = 0;
-                this._promise._resolve(index);
-              } else if (--this._rest === 0) {
-                this._promise._resolve(-1);
-              }
-            };
-
-            return FindIndex;
-          })(Each);
-
-          module.exports = { findIndex: findIndex, FindIndex: FindIndex };
-
-          function set(collection) {
-            setShorthand.call(this, collection);
-            if (this._keys !== undefined) {
-              this._rest = 0;
-            }
-            return this;
-          }
-
-          /**
-           * `Aigle.findIndex` is like `Aigle.find`, it will return the index of the first element which the iterator returns truthy.
-           * @param {Array} collection
-           * @param {Function|Array|Object|string} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2 === 0;
-           *     });
-           * };
-           * Aigle.findIndex(collection, iterator)
-           *   .then(index => {
-           *     console.log(index); // 2
-           *     console.log(order); // [1, 2]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return false;
-           *     });
-           * };
-           * Aigle.findIndex(collection, iterator)
-           *   .then(index => {
-           *     console.log(index); // -1
-           *     console.log(order); // [1, 2, 4]
-           *   });
-           *
-           * @example
-           * const collection = [{
-           *   name: 'bargey', active: false
-           * }, {
-           *   name: 'fread', active: true
-           * }];
-           * Aigle.findIndex(collection, 'active')
-           *   .then(index => {
-           *     console.log(index); // 1
-           *   });
-           *
-           * @example
-           * const collection = [{
-           *   name: 'bargey', active: false
-           * }, {
-           *   name: 'fread', active: true
-           * }];
-           * Aigle.findIndex(collection, ['name', 'fread'])
-           *   .then(index => {
-           *     console.log(index); // true
-           *   });
-           *
-           * @example
-           * const collection = [{
-           *   name: 'bargey', active: false
-           * }, {
-           *   name: 'fread', active: true
-           * }];
-           * Aigle.find(collection, { name: 'fread', active: true })
-           *   .then(index => {
-           *     console.log(index); // 1
-           *   });
-           */
-          function findIndex(collection, iterator) {
-            return new FindIndex(collection, iterator)._execute();
-          }
-        },
-        { './each': 12, './internal/collection': 36 }
-      ],
-      24: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./eachLimit');
-          var EachLimit = ref.EachLimit;
-          var ref$1 = require('./internal/collection');
-          var setLimit = ref$1.setLimit;
-
-          var FindIndexLimit = /*@__PURE__*/ (function(EachLimit) {
-            function FindIndexLimit(collection, limit, iterator) {
-              EachLimit.call(this, collection, limit, iterator, set);
-              this._result = -1;
-            }
-
-            if (EachLimit) FindIndexLimit.__proto__ = EachLimit;
-            FindIndexLimit.prototype = Object.create(EachLimit && EachLimit.prototype);
-            FindIndexLimit.prototype.constructor = FindIndexLimit;
-
-            FindIndexLimit.prototype._callResolve = function _callResolve(value, index) {
-              if (value) {
-                this._callRest = 0;
-                this._promise._resolve(index);
-              } else if (--this._rest === 0) {
-                this._promise._resolve(-1);
-              } else if (this._callRest-- > 0) {
-                this._iterate();
-              }
-            };
-
-            return FindIndexLimit;
-          })(EachLimit);
-
-          module.exports = { findIndexLimit: findIndexLimit, FindIndexLimit: FindIndexLimit };
-
-          function set(collection) {
-            setLimit.call(this, collection);
-            if (this._keys !== undefined) {
-              this._rest = 0;
-            }
-            return this;
-          }
-
-          /**
-           * `Aigle.findIndexLimit` is almost the as [`Aigle.findIndex`](https://suguru03.github.io/aigle/docs/Aigle.html#findIndex) and
-           * [`Aigle.findIndexSeries`](https://suguru03.github.io/aigle/docs/Aigle.html#findIndexSeries), but it will work with concurrency.
-           * @param {Array} collection
-           * @param {integer} [limit=8]
-           * @param {Function} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 5, 3, 4, 2];
-           * const iterator = (num, index) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2 === 0;
-           *     });
-           * };
-           * Aigle.findIndexLimit(collection, 2, iterator)
-           *   .then(index => {
-           *     console.log(index); // 4
-           *     console.log(order); // [1, 3, 5, 2];
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [1, 5, 3, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2 === 0;
-           *     });
-           * };
-           * Aigle.findIndexLimit(collection, iterator)
-           *   .then(index => {
-           *     console.log(index); // 4
-           *     console.log(order); // [1, 2];
-           *   });
-           */
-          function findIndexLimit(collection, limit, iterator) {
-            return new FindIndexLimit(collection, limit, iterator)._execute();
-          }
-        },
-        { './eachLimit': 13, './internal/collection': 36 }
-      ],
-      25: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./eachSeries');
-          var EachSeries = ref.EachSeries;
-          var ref$1 = require('./internal/collection');
-          var setSeries = ref$1.setSeries;
-
-          var FindIndexSeries = /*@__PURE__*/ (function(EachSeries) {
-            function FindIndexSeries(collection, iterator) {
-              EachSeries.call(this, collection, iterator, set);
-              this._result = -1;
-            }
-
-            if (EachSeries) FindIndexSeries.__proto__ = EachSeries;
-            FindIndexSeries.prototype = Object.create(EachSeries && EachSeries.prototype);
-            FindIndexSeries.prototype.constructor = FindIndexSeries;
-            FindIndexSeries.prototype._callResolve = function _callResolve(value, index) {
-              if (value) {
-                this._promise._resolve(index);
-              } else if (--this._rest === 0) {
-                this._promise._resolve(-1);
-              } else {
-                this._iterate();
-              }
-            };
-
-            return FindIndexSeries;
-          })(EachSeries);
-
-          module.exports = { findIndexSeries: findIndexSeries, FindIndexSeries: FindIndexSeries };
-
-          function set(collection) {
-            setSeries.call(this, collection);
-            if (this._keys !== undefined) {
-              this._rest = 0;
-            }
-            return this;
-          }
-
-          /**
-           * `Aigle.findIndexSeries` is almost the as [`Aigle.findIndex`](https://suguru03.github.io/aigle/docs/Aigle.html#findIndex), but it will work in series.
-           * @param {Array} collection
-           * @param {Function} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2 === 0;
-           *     });
-           * };
-           * Aigle.findIndexSeries(collection, iterator)
-           *   .then(index => {
-           *     console.log(index); // 1
-           *     console.log(order); // [1, 4];
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return false;
-           *     });
-           * };
-           * Aigle.findIndexSeries(collection, iterator)
-           *   .then(index => {
-           *     console.log(index); // -1
-           *     console.log(order); // [1, 4, 2];
-           *   });
-           */
-          function findIndexSeries(collection, iterator) {
-            return new FindIndexSeries(collection, iterator)._execute();
-          }
-        },
-        { './eachSeries': 14, './internal/collection': 36 }
-      ],
-      26: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./each');
-          var Each = ref.Each;
-          var ref$1 = require('./internal/collection');
-          var setShorthand = ref$1.setShorthand;
-
-          var FindKey = /*@__PURE__*/ (function(Each) {
-            function FindKey(collection, iterator) {
-              Each.call(this, collection, iterator, set);
-            }
-
-            if (Each) FindKey.__proto__ = Each;
-            FindKey.prototype = Object.create(Each && Each.prototype);
-            FindKey.prototype.constructor = FindKey;
-
-            return FindKey;
-          })(Each);
-
-          module.exports = { findKey: findKey, FindKey: FindKey };
-
-          function set(collection) {
-            setShorthand.call(this, collection);
-            this._callResolve = this._keys === undefined ? callResolveArray : callResolveObject;
-            return this;
-          }
-
-          function callResolveArray(value, index) {
-            if (value) {
-              this._size = 0;
-              this._promise._resolve('' + index);
-            } else if (--this._rest === 0) {
-              this._promise._resolve();
-            }
-          }
-
-          function callResolveObject(value, index) {
-            if (value) {
-              this._size = 0;
-              this._promise._resolve(this._keys[index]);
-            } else if (--this._rest === 0) {
-              this._promise._resolve();
-            }
-          }
-
-          /**
-           * @param {Array|Object} collection
-           * @param {Function|Array|Object|string} iterator
-           * @return {Aigle} Returns an Aigle instance
-           */
-          function findKey(collection, iterator) {
-            return new FindKey(collection, iterator)._execute();
-          }
-        },
-        { './each': 12, './internal/collection': 36 }
-      ],
-      27: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./eachLimit');
-          var EachLimit = ref.EachLimit;
-          var ref$1 = require('./internal/collection');
-          var setLimit = ref$1.setLimit;
-
-          var FindKeyLimit = /*@__PURE__*/ (function(EachLimit) {
-            function FindKeyLimit(collection, limit, iterator) {
-              EachLimit.call(this, collection, limit, iterator, set);
-            }
-
-            if (EachLimit) FindKeyLimit.__proto__ = EachLimit;
-            FindKeyLimit.prototype = Object.create(EachLimit && EachLimit.prototype);
-            FindKeyLimit.prototype.constructor = FindKeyLimit;
-
-            return FindKeyLimit;
-          })(EachLimit);
-
-          module.exports = { findKeyLimit: findKeyLimit, FindKeyLimit: FindKeyLimit };
-
-          function set(collection) {
-            setLimit.call(this, collection);
-            this._callResolve = this._keys === undefined ? callResolveArray : callResolveObject;
-            return this;
-          }
-
-          function callResolveArray(value, index) {
-            if (value) {
-              this._callRest = 0;
-              this._promise._resolve('' + index);
-            } else if (--this._rest === 0) {
-              this._promise._resolve();
-            } else if (this._callRest-- > 0) {
-              this._iterate();
-            }
-          }
-
-          function callResolveObject(value, index) {
-            if (value) {
-              this._callRest = 0;
-              this._promise._resolve(this._keys[index]);
-            } else if (--this._rest === 0) {
-              this._promise._resolve();
-            } else if (this._callRest-- > 0) {
-              this._iterate();
-            }
-          }
-
-          /**
-           * @param {Array|Object} collection
-           * @param {integer} [limit=8]
-           * @param {Function} iterator
-           * @return {Aigle} Returns an Aigle instance
-           */
-          function findKeyLimit(collection, limit, iterator) {
-            return new FindKeyLimit(collection, limit, iterator)._execute();
-          }
-        },
-        { './eachLimit': 13, './internal/collection': 36 }
-      ],
-      28: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./eachSeries');
-          var EachSeries = ref.EachSeries;
-          var ref$1 = require('./internal/collection');
-          var setSeries = ref$1.setSeries;
-
-          var FindKeySeries = /*@__PURE__*/ (function(EachSeries) {
-            function FindKeySeries(collection, iterator) {
-              EachSeries.call(this, collection, iterator, set);
-            }
-
-            if (EachSeries) FindKeySeries.__proto__ = EachSeries;
-            FindKeySeries.prototype = Object.create(EachSeries && EachSeries.prototype);
-            FindKeySeries.prototype.constructor = FindKeySeries;
-
-            return FindKeySeries;
-          })(EachSeries);
-
-          module.exports = { findKeySeries: findKeySeries, FindKeySeries: FindKeySeries };
-
-          function set(collection) {
-            setSeries.call(this, collection);
-            this._callResolve = this._keys === undefined ? callResolveArray : callResolveObject;
-            return this;
-          }
-
-          function callResolveArray(value, index) {
-            if (value) {
-              this._promise._resolve('' + index);
-            } else if (--this._rest === 0) {
-              this._promise._resolve();
-            } else {
-              this._iterate();
-            }
-          }
-
-          function callResolveObject(value, index) {
-            if (value) {
-              this._promise._resolve(this._keys[index]);
-            } else if (--this._rest === 0) {
-              this._promise._resolve();
-            } else {
-              this._iterate();
-            }
-          }
-
-          /**
-           * @param {Array|Object} collection
-           * @param {Function} iterator
-           * @return {Aigle} Returns an Aigle instance
-           */
-          function findKeySeries(collection, iterator) {
-            return new FindKeySeries(collection, iterator)._execute();
-          }
-        },
-        { './eachSeries': 14, './internal/collection': 36 }
-      ],
-      29: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./eachLimit');
-          var EachLimit = ref.EachLimit;
-          var ref$1 = require('./internal/collection');
-          var setLimit = ref$1.setLimit;
-
-          var FindLimit = /*@__PURE__*/ (function(EachLimit) {
-            function FindLimit(collection, limit, iterator) {
-              EachLimit.call(this, collection, limit, iterator, set);
-            }
-
-            if (EachLimit) FindLimit.__proto__ = EachLimit;
-            FindLimit.prototype = Object.create(EachLimit && EachLimit.prototype);
-            FindLimit.prototype.constructor = FindLimit;
-
-            return FindLimit;
-          })(EachLimit);
-
-          module.exports = { findLimit: findLimit, FindLimit: FindLimit };
-
-          function set(collection) {
-            setLimit.call(this, collection);
-            this._callResolve = this._keys === undefined ? callResolveArray : callResolveObject;
-            return this;
-          }
-
-          function callResolveArray(value, index) {
-            if (value) {
-              this._callRest = 0;
-              this._promise._resolve(this._coll[index]);
-            } else if (--this._rest === 0) {
-              this._promise._resolve();
-            } else if (this._callRest-- > 0) {
-              this._iterate();
-            }
-          }
-
-          function callResolveObject(value, index) {
-            if (value) {
-              this._callRest = 0;
-              this._promise._resolve(this._coll[this._keys[index]]);
-            } else if (--this._rest === 0) {
-              this._promise._resolve();
-            } else if (this._callRest-- > 0) {
-              this._iterate();
-            }
-          }
-
-          /**
-           * `Aigle.findLimit` is almost the as [`Aigle.find`](https://suguru03.github.io/aigle/docs/Aigle.html#find) and
-           * [`Aigle.findSeries`](https://suguru03.github.io/aigle/docs/Aigle.html#findSeries), but it will work with concurrency.
-           * @param {Array|Object} collection
-           * @param {integer} [limit=8]
-           * @param {Function} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 5, 3, 4, 2];
-           * const iterator = (num, index) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2 === 0;
-           *     });
-           * };
-           * Aigle.findLimit(collection, 2, iterator)
-           *   .then(value => {
-           *     console.log(value); // 2
-           *     console.log(order); // [1, 3, 5, 2];
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = { a: 1, b: 5, c: 3, d: 4, e: 2 };
-           * const iterator = (num, key) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2 === 0;
-           *     });
-           * };
-           * Aigle.findLimit(collection, 2, iterator)
-           *   .then(value => {
-           *     console.log(value); // 2
-           *     console.log(order); // [1, 3, 5, 2];
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [1, 5, 3, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2 === 0;
-           *     });
-           * };
-           * Aigle.findLimit(collection, iterator)
-           *   .then(value => {
-           *     console.log(value); // 2
-           *     console.log(order); // [1, 2];
-           *   });
-           */
-          function findLimit(collection, limit, iterator) {
-            return new FindLimit(collection, limit, iterator)._execute();
-          }
-        },
-        { './eachLimit': 13, './internal/collection': 36 }
-      ],
-      30: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./eachSeries');
-          var EachSeries = ref.EachSeries;
-          var ref$1 = require('./internal/collection');
-          var setSeries = ref$1.setSeries;
-
-          var FindSeries = /*@__PURE__*/ (function(EachSeries) {
-            function FindSeries(collection, iterator) {
-              EachSeries.call(this, collection, iterator, set);
-            }
-
-            if (EachSeries) FindSeries.__proto__ = EachSeries;
-            FindSeries.prototype = Object.create(EachSeries && EachSeries.prototype);
-            FindSeries.prototype.constructor = FindSeries;
-
-            return FindSeries;
-          })(EachSeries);
-
-          module.exports = { findSeries: findSeries, FindSeries: FindSeries };
-
-          function set(collection) {
-            setSeries.call(this, collection);
-            this._callResolve = this._keys === undefined ? callResolveArray : callResolveObject;
-            return this;
-          }
-
-          function callResolveArray(value, index) {
-            if (value) {
-              this._promise._resolve(this._coll[index]);
-            } else if (--this._rest === 0) {
-              this._promise._resolve();
-            } else {
-              this._iterate();
-            }
-          }
-
-          function callResolveObject(value, index) {
-            if (value) {
-              this._promise._resolve(this._coll[this._keys[index]]);
-            } else if (--this._rest === 0) {
-              this._promise._resolve();
-            } else {
-              this._iterate();
-            }
-          }
-
-          /**
-           * `Aigle.findSeries` is almost the as [`Aigle.find`](https://suguru03.github.io/aigle/docs/Aigle.html#find), but it will work in series.
-           * @param {Array|Object} collection
-           * @param {Function} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2 === 0;
-           *     });
-           * };
-           * Aigle.findSeries(collection, iterator)
-           *   .then(value => {
-           *     console.log(value); // 4
-           *     console.log(order); // [1, 4];
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = { a: 1, b: 4, c: 2 };
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2 === 0;
-           *     });
-           * };
-           * Aigle.findSeries(collection, iterator)
-           *   .then(value => {
-           *     console.log(value); // 4
-           *     console.log(order); // [1, 4];
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return false;
-           *     });
-           * };
-           * Aigle.findSeries(collection, iterator)
-           *   .then(value => {
-           *     console.log(value); // undefined
-           *     console.log(order); // [1, 4, 2];
-           *   });
-           */
-          function findSeries(collection, iterator) {
-            return new FindSeries(collection, iterator)._execute();
-          }
-        },
-        { './eachSeries': 14, './internal/collection': 36 }
-      ],
-      31: [
-        function(require, module, exports) {
-          'use strict';
-
-          var Aigle = require('./aigle');
-
-          module.exports = flow;
-
-          /**
-           * @param {Function[]} funcs
-           * @return {Function} Returns the new composite function
-           * @example
-           *   const add = (a, b) => Aigle.delay(10, a + b);
-           *   const square = n => Aigle.delay(10, n * n);
-           *   const addSquare = Aigle.flow(add, square);
-           *   return addSquare(1, 2).then(value => {
-           *     console.log(value); // 9
-           *   });
-           */
-          function flow() {
-            var funcs = [],
-              len = arguments.length;
-            while (len--) funcs[len] = arguments[len];
-
-            var ref = flatArray(funcs);
-            var handler = ref[0];
-            if (handler === void 0) handler = thru;
-            var handlers = ref.slice(1);
-            return function() {
-              var args = [],
-                len = arguments.length;
-              while (len--) args[len] = arguments[len];
-
-              return Aigle.resolve(handler.apply(void 0, args)).then(function(data) {
-                return Aigle.reduce(
-                  handlers,
-                  function(acc, func) {
-                    return func(acc);
-                  },
-                  data
-                );
-              });
-            };
-          }
-
-          function thru(arg) {
-            return arg;
-          }
-
-          function flatArray(args) {
-            var l = args.length;
-            var array = [];
-            var i = -1;
-            while (++i < l) {
-              var arg = args[i];
-              Array.isArray(arg) ? array.push.apply(array, arg) : array.push(arg);
-            }
-            return array;
-          }
-        },
-        { './aigle': 2 }
-      ],
-      32: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./each');
-          var Each = ref.Each;
-          var ref$1 = require('./internal/collection');
-          var setShorthand = ref$1.setShorthand;
-
-          var GroupBy = /*@__PURE__*/ (function(Each) {
-            function GroupBy(collection, iterator) {
-              Each.call(this, collection, iterator, set);
-              this._result = {};
-            }
-
-            if (Each) GroupBy.__proto__ = Each;
-            GroupBy.prototype = Object.create(Each && Each.prototype);
-            GroupBy.prototype.constructor = GroupBy;
-
-            return GroupBy;
-          })(Each);
-
-          module.exports = { groupBy: groupBy, GroupBy: GroupBy };
-
-          function set(collection) {
-            setShorthand.call(this, collection);
-            this._callResolve = this._keys === undefined ? callResolveArray : callResolveObject;
-            return this;
-          }
-
-          function callResolveArray(key, index) {
-            if (this._result[key]) {
-              this._result[key].push(this._coll[index]);
-            } else {
-              this._result[key] = [this._coll[index]];
-            }
-            if (--this._rest === 0) {
-              this._promise._resolve(this._result);
-            }
-          }
-
-          function callResolveObject(key, index) {
-            if (this._result[key]) {
-              this._result[key].push(this._coll[this._keys[index]]);
-            } else {
-              this._result[key] = [this._coll[this._keys[index]]];
-            }
-            if (--this._rest === 0) {
-              this._promise._resolve(this._result);
-            }
-          }
-
-          /**
-           * @param {Array|Object} collection
-           * @param {Function|string} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = (num, index) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2;
-           *     });
-           * };
-           * Aigle.groupBy(collection, iterator)
-           *   .then(object => {
-           *     console.log(object); // { '0': [2, 4], '1': [1] };
-           *     console.log(order); // [1, 2, 4];
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = { a: 1, b: 4, c: 2 };
-           * const iterator = (num, key) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2;
-           *     });
-           * };
-           * Aigle.groupBy(collection, iterator)
-           *   .then(object => {
-           *     console.log(object); // { '0': [2, 4], '1': [1] };
-           *     console.log(order); // [1, 2, 4];
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = ['one', 'two', 'three'];
-           * Aigle.groupBy(collection, 'length')
-           *   .then(object => {
-           *     console.log(object); // { '3': ['one', 'two'], '5': ['three'] };
-           *   });
-           *
-           * @example
-           * const collection = [{
-           *   name: 'bargey', active: false
-           * }, {
-           *   name: 'fread', active: true
-           * }];
-           * Aigle.groupBy(collection, ['active', true])
-           *   .then(object => {
-           *     console.log(object);
-           *     // { 'true': [{ name: 'fread', active: true }], 'false': [{ name: 'bargey', active: false }];
-           *   });
-           *
-           * @example
-           * const collection = [{
-           *   name: 'bargey', active: false
-           * }, {
-           *   name: 'fread', active: true
-           * }];
-           * Aigle.groupBy(collection, { active: true })
-           *   .then(object => {
-           *     console.log(object);
-           *     // { 'true': [{ name: 'fread', active: true }], 'false': [{ name: 'bargey', active: false }];
-           *   });
-           */
-          function groupBy(collection, iterator) {
-            return new GroupBy(collection, iterator)._execute();
-          }
-        },
-        { './each': 12, './internal/collection': 36 }
-      ],
-      33: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./eachLimit');
-          var EachLimit = ref.EachLimit;
-          var ref$1 = require('./internal/collection');
-          var setLimit = ref$1.setLimit;
-
-          var GroupByLimit = /*@__PURE__*/ (function(EachLimit) {
-            function GroupByLimit(collection, limit, iterator) {
-              EachLimit.call(this, collection, limit, iterator, set);
-              this._result = {};
-            }
-
-            if (EachLimit) GroupByLimit.__proto__ = EachLimit;
-            GroupByLimit.prototype = Object.create(EachLimit && EachLimit.prototype);
-            GroupByLimit.prototype.constructor = GroupByLimit;
-
-            return GroupByLimit;
-          })(EachLimit);
-
-          module.exports = { groupByLimit: groupByLimit, GroupByLimit: GroupByLimit };
-
-          function set(collection) {
-            setLimit.call(this, collection);
-            this._callResolve = this._keys === undefined ? callResolveArray : callResolveObject;
-            return this;
-          }
-
-          function callResolveArray(key, index) {
-            if (this._result[key]) {
-              this._result[key].push(this._coll[index]);
-            } else {
-              this._result[key] = [this._coll[index]];
-            }
-            if (--this._rest === 0) {
-              this._promise._resolve(this._result);
-            } else if (this._callRest-- > 0) {
-              this._iterate();
-            }
-          }
-
-          function callResolveObject(key, index) {
-            if (this._result[key]) {
-              this._result[key].push(this._coll[this._keys[index]]);
-            } else {
-              this._result[key] = [this._coll[this._keys[index]]];
-            }
-            if (--this._rest === 0) {
-              this._promise._resolve(this._result);
-            } else if (this._callRest-- > 0) {
-              this._iterate();
-            }
-          }
-
-          /**
-           * @param {Array|Object} collection
-           * @param {integer} [limit=8]
-           * @param {Function} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 5, 3, 4, 2];
-           * const iterator = (num, index) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2;
-           *     });
-           * };
-           * Aigle.groupByLimit(collection, 2, iterator)
-           *   .then(object => {
-           *     console.log(object); // { '0': [2, 4], '1': [1, 3, 5] };
-           *     console.log(order); // [1, 3, 5, 2, 4];
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = {
-           *   task1: 1,
-           *   task2: 5,
-           *   task3: 3,
-           *   task4: 4,
-           *   task5: 2
-           * };
-           * const iterator = (num, key) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2;
-           *     });
-           * };
-           * Aigle.groupByLimit(collection, 2, iterator)
-           *   .then(object => {
-           *     console.log(object); // { '0': [2, 4], '1': [1, 3, 5] };
-           *     console.log(order); // [1, 3, 5, 2, 4];
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [1, 5, 3, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2;
-           *     });
-           * };
-           * Aigle.groupByLimit(collection, iterator)
-           *   .then(object => {
-           *     console.log(object); // { '0': [2, 4], '1': [1, 3, 5] };
-           *     console.log(order); // [1, 2, 3, 4, 5];
-           *   });
-           */
-          function groupByLimit(collection, limit, iterator) {
-            return new GroupByLimit(collection, limit, iterator)._execute();
-          }
-        },
-        { './eachLimit': 13, './internal/collection': 36 }
-      ],
-      34: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./eachSeries');
-          var EachSeries = ref.EachSeries;
-          var ref$1 = require('./internal/collection');
-          var setSeries = ref$1.setSeries;
-
-          var GroupBySeries = /*@__PURE__*/ (function(EachSeries) {
-            function GroupBySeries(collection, iterator) {
-              EachSeries.call(this, collection, iterator, set);
-              this._result = {};
-            }
-
-            if (EachSeries) GroupBySeries.__proto__ = EachSeries;
-            GroupBySeries.prototype = Object.create(EachSeries && EachSeries.prototype);
-            GroupBySeries.prototype.constructor = GroupBySeries;
-
-            return GroupBySeries;
-          })(EachSeries);
-
-          module.exports = { groupBySeries: groupBySeries, GroupBySeries: GroupBySeries };
-
-          function set(collection) {
-            setSeries.call(this, collection);
-            this._callResolve = this._keys === undefined ? callResolveArray : callResolveObject;
-            return this;
-          }
-
-          function callResolveArray(key, index) {
-            if (this._result[key]) {
-              this._result[key].push(this._coll[index]);
-            } else {
-              this._result[key] = [this._coll[index]];
-            }
-            if (--this._rest === 0) {
-              this._promise._resolve(this._result);
-            } else {
-              this._iterate();
-            }
-          }
-
-          function callResolveObject(key, index) {
-            if (this._result[key]) {
-              this._result[key].push(this._coll[this._keys[index]]);
-            } else {
-              this._result[key] = [this._coll[this._keys[index]]];
-            }
-            if (--this._rest === 0) {
-              this._promise._resolve(this._result);
-            } else {
-              this._iterate();
-            }
-          }
-
-          /**
-           * @param {Array|Object} collection
-           * @param {Function} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = (num, index) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2;
-           *     });
-           * };
-           * Aigle.groupBySeries(collection, iterator)
-           *   .then(object => {
-           *     console.log(object); // { '0': [4, 2], '1': [1] };
-           *     console.log(order); // [1, 4, 2];
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = { a: 1, b: 4, c: 2 };
-           * const iterator = (num, key) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2;
-           *     });
-           * };
-           * Aigle.groupBySeries(collection, iterator)
-           *   .then(object => {
-           *     console.log(object); // { '0': [4, 2], '1': [1] };
-           *     console.log(order); // [1, 4, 2];
-           *   });
-           */
-          function groupBySeries(collection, iterator) {
-            return new GroupBySeries(collection, iterator)._execute();
-          }
-        },
-        { './eachSeries': 14, './internal/collection': 36 }
-      ],
-      35: [
-        function(require, module, exports) {
-          'use strict';
-
-          var queue = Array(8);
-          var len = 0;
-          var ticked = false;
-
-          function tick() {
-            var i = -1;
-            while (++i < len) {
-              var promise = queue[i];
-              queue[i] = undefined;
-              switch (promise._resolved) {
-                case 1:
-                  promise._callResolve();
-                  break;
-                case 2:
-                  promise._callReject();
-                  break;
-              }
-            }
-            len = 0;
-            ticked = false;
-          }
-
-          function invoke(promise) {
-            if (ticked === false) {
-              setImmediate(tick);
-              ticked = true;
-            }
-            queue[len++] = promise;
-          }
-
-          module.exports = invoke;
-        },
-        {}
-      ],
-      36: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./util');
-          var call3 = ref.call3;
-          var callProxyReciever = ref.callProxyReciever;
-
-          var ref$1 = [
-            [iterateArrayParallel, iterateObjectParallel],
-            [iterateArrayParallel, iterateObjectParallelWithOrder],
-            [iterateArraySeries, iterateObjectSeries]
-          ].map(createSet);
-          var setParallel = ref$1[0];
-          var setParallelWithOrder = ref$1[1];
-          var setSeries = ref$1[2];
-
-          var arrayIteratorList = [
-            iterateArrayParallel,
-            iterateArrayWithString,
-            iterateArrayWithObject,
-            iterateArrayWithArray
-          ];
-          var objectIteratorList = [
-            iterateObjectParallel,
-            iterateObjectWithString,
-            iterateObjectWithObject,
-            iterateObjectWithArray
-          ];
-          var ref$2 = [
-            [arrayIteratorList, objectIteratorList],
-            [
-              arrayIteratorList,
-              [iterateObjectParallelWithOrder].concat(objectIteratorList.slice(1))
-            ],
-            [
-              arrayIteratorList.slice(0, 3).concat([iteratePickWithArray]),
-              objectIteratorList.slice(0, 3).concat([iteratePickWithArray])
-            ],
-            [
-              arrayIteratorList.slice(0, 3).concat([iterateOmitWithArray]),
-              objectIteratorList.slice(0, 3).concat([iterateOmitWithArray])
-            ]
-          ].map(createSetShorthand);
-          var setShorthand = ref$2[0];
-          var setShorthandWithOrder = ref$2[1];
-          var setPickShorthand = ref$2[2];
-          var setOmitShorthand = ref$2[3];
-
-          module.exports = {
-            execute: execute,
-            setParallel: setParallel,
-            setParallelWithOrder: setParallelWithOrder,
-            setShorthand: setShorthand,
-            setShorthandWithOrder: setShorthandWithOrder,
-            setPickShorthand: setPickShorthand,
-            setOmitShorthand: setOmitShorthand,
-            setSeries: setSeries,
-            setLimit: setLimit
-          };
-
-          function execute(collection) {
-            this._callResolve = this._iterate;
-            this._set(collection);
-            this._execute();
-          }
-
-          function createSet(ref) {
-            var iterateArray = ref[0];
-            var iterateObject = ref[1];
-
-            return function set(collection) {
-              if (Array.isArray(collection)) {
-                this._coll = collection;
-                this._size = collection.length;
-                this._iterate = iterateArray;
-              } else if (collection && typeof collection === 'object') {
-                var keys = Object.keys(collection);
-                this._coll = collection;
-                this._size = keys.length;
-                this._keys = keys;
-                this._iterate = iterateObject;
-              } else {
-                this._size = 0;
-              }
-              this._rest = this._size;
-              return this;
-            };
-          }
-
-          function createSetShorthand(list) {
-            var ref = list.map(createIteratorGetter);
-            var getArrayIterator = ref[0];
-            var getObjectIterator = ref[1];
-            return function set(collection) {
-              if (Array.isArray(collection)) {
-                this._coll = collection;
-                this._size = collection.length;
-                this._iterate = getArrayIterator(this._iterator);
-              } else if (collection && typeof collection === 'object') {
-                var keys = Object.keys(collection);
-                this._coll = collection;
-                this._size = keys.length;
-                this._keys = keys;
-                this._iterate = getObjectIterator(this._iterator);
-              } else {
-                this._size = 0;
-              }
-              this._rest = this._size;
-              return this;
-            };
-          }
-
-          function createIteratorGetter(ref) {
-            var iterateParallel = ref[0];
-            var iterateWithString = ref[1];
-            var iterateWithObject = ref[2];
-            var iterateWithArray = ref[3];
-
-            return function(iterator) {
-              switch (typeof iterator) {
-                case 'function':
-                  return iterateParallel;
-                case 'string':
-                  return iterateWithString;
-                case 'object':
-                  return Array.isArray(iterator) ? iterateWithArray : iterateWithObject;
-              }
-            };
-          }
-
-          function setLimit(collection) {
-            setSeries.call(this, collection);
-            var ref = this;
-            var _limit = ref._limit;
-            var _size = ref._size;
-            this._limit = _limit < _size ? _limit : _size;
-            this._callRest = _size - this._limit;
-            return this;
-          }
-
-          function iterateArrayParallel() {
-            var ref = this;
-            var _rest = ref._rest;
-            var _iterator = ref._iterator;
-            var _coll = ref._coll;
-            var i = -1;
-            while (
-              ++i < _rest &&
-              callProxyReciever(call3(_iterator, _coll[i], i, _coll), this, i)
-            ) {}
-          }
-
-          function iterateObjectParallel() {
-            var ref = this;
-            var _rest = ref._rest;
-            var _iterator = ref._iterator;
-            var _coll = ref._coll;
-            var _keys = ref._keys;
-            var i = -1;
-            while (++i < _rest) {
-              var key = _keys[i];
-              if (callProxyReciever(call3(_iterator, _coll[key], key, _coll), this, i) === false) {
-                break;
-              }
-            }
-          }
-          function iterateObjectParallelWithOrder() {
-            var ref = this;
-            var _rest = ref._rest;
-            var _iterator = ref._iterator;
-            var _coll = ref._coll;
-            var _keys = ref._keys;
-            var _result = ref._result;
-            var i = -1;
-            while (++i < _rest) {
-              var key = _keys[i];
-              _result[key] = undefined;
-              if (callProxyReciever(call3(_iterator, _coll[key], key, _coll), this, i) === false) {
-                break;
-              }
-            }
-          }
-
-          function iterateArraySeries() {
-            var ref = this;
-            var _coll = ref._coll;
-            var i = this._index++;
-            callProxyReciever(call3(this._iterator, _coll[i], i, _coll), this, i);
-          }
-
-          function iterateObjectSeries() {
-            var ref = this;
-            var _coll = ref._coll;
-            var i = this._index++;
-            var key = this._keys[i];
-            callProxyReciever(call3(this._iterator, _coll[key], key, _coll), this, i);
-          }
-
-          function iterateArrayWithString() {
-            var ref = this;
-            var _iterator = ref._iterator;
-            var _coll = ref._coll;
-            var i = -1;
-            while (++i < this._size) {
-              var obj = _coll[i];
-              if (obj) {
-                this._callResolve(obj[_iterator], i);
-              } else {
-                this._callResolve(undefined, i);
-              }
-            }
-          }
-
-          function iterateObjectWithString() {
-            var ref = this;
-            var _iterator = ref._iterator;
-            var _coll = ref._coll;
-            var _keys = ref._keys;
-            var i = -1;
-            while (++i < this._size) {
-              var obj = _coll[_keys[i]];
-              if (obj) {
-                this._callResolve(obj[_iterator], i);
-              } else {
-                this._callResolve(undefined, i);
-              }
-            }
-          }
-
-          function iterateArrayWithArray() {
-            var ref = this;
-            var _coll = ref._coll;
-            var ref$1 = this._iterator;
-            var key = ref$1[0];
-            var value = ref$1[1];
-            var i = -1;
-            while (++i < this._size) {
-              var obj = _coll[i];
-              if (obj) {
-                this._callResolve(obj[key] === value, i);
-              } else {
-                this._callResolve(undefined, i);
-              }
-            }
-          }
-
-          function iterateObjectWithArray() {
-            var ref = this;
-            var _coll = ref._coll;
-            var _keys = ref._keys;
-            var ref$1 = this._iterator;
-            var key = ref$1[0];
-            var value = ref$1[1];
-            var i = -1;
-            while (++i < this._size) {
-              var obj = _coll[_keys[i]];
-              if (obj) {
-                this._callResolve(obj[key] === value, i);
-              } else {
-                this._callResolve(undefined, i);
-              }
-            }
-          }
-
-          function iterateArrayWithObject() {
-            var ref = this;
-            var object = ref._iterator;
-            var _coll = ref._coll;
-            var keys = Object.keys(object);
-            var i = -1;
-            first: while (++i < this._size) {
-              var obj = _coll[i];
-              if (!obj) {
-                this._callResolve(undefined, i);
-                continue;
-              }
-              var l = keys.length;
-              while (l--) {
-                var key = keys[l];
-                if (obj[key] !== object[key]) {
-                  this._callResolve(false, i);
-                  continue first;
-                }
-              }
-              this._callResolve(true, i);
-            }
-          }
-
-          function iterateObjectWithObject() {
-            var ref = this;
-            var object = ref._iterator;
-            var _coll = ref._coll;
-            var _keys = ref._keys;
-            var keys = Object.keys(object);
-            var i = -1;
-            first: while (++i < this._size) {
-              var obj = _coll[_keys[i]];
-              if (!obj) {
-                this._callResolve(undefined, i);
-                continue;
-              }
-              var l = keys.length;
-              while (l--) {
-                var key = keys[l];
-                if (obj[key] !== object[key]) {
-                  this._callResolve(false, i);
-                  continue first;
-                }
-              }
-              this._callResolve(true, i);
-            }
-          }
-
-          function iteratePickWithArray() {
-            var ref = this;
-            var _coll = ref._coll;
-            var _result = ref._result;
-            pick(this._iterator);
-            this._promise._resolve(_result);
-
-            function pick(array) {
-              var i = -1;
-              while (++i < array.length) {
-                var key = array[i];
-                if (Array.isArray(key)) {
-                  pick(key);
-                  continue;
-                }
-                if (_coll.hasOwnProperty(key)) {
-                  _result[key] = _coll[key];
-                }
-              }
-            }
-          }
-
-          function iterateOmitWithArray() {
-            var ref = this;
-            var _coll = ref._coll;
-            var _result = ref._result;
-            var map = {};
-            createMap(this._iterator);
-            Object.keys(_coll).forEach(function(key) {
-              if (map.hasOwnProperty(key) === false) {
-                _result[key] = _coll[key];
-              }
-            });
-            this._promise._resolve(_result);
-
-            function createMap(array) {
-              var i = -1;
-              while (++i < array.length) {
-                var key = array[i];
-                if (Array.isArray(key)) {
-                  createMap(key);
-                  continue;
-                }
-                map[key] = true;
-              }
-            }
-          }
-        },
-        { './util': 39 }
-      ],
-      37: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('aigle-core');
-          var AigleProxy = ref.AigleProxy;
-
-          var Aigle = require('../aigle');
-          var ref$1 = require('../map');
-          var map = ref$1.map;
-          var ref$2 = require('../mapValues');
-          var mapValues = ref$2.mapValues;
-          var ref$3 = require('./util');
-          var INTERNAL = ref$3.INTERNAL;
-          var PENDING = ref$3.PENDING;
-          var apply = ref$3.apply;
-          var callProxyReciever = ref$3.callProxyReciever;
-
-          module.exports = { createProxy: createProxy };
-
-          var MixinProxy = /*@__PURE__*/ (function(AigleProxy) {
-            function MixinProxy(func, exec, args) {
-              AigleProxy.call(this);
-              this._promise = new Aigle(INTERNAL);
-              this._func = func;
-              this._args = args;
-              this._execute = exec;
-              if (args[0] === PENDING) {
-                this._set = this._callResolve;
-                this._callResolve = exec;
-              }
-            }
-
-            if (AigleProxy) MixinProxy.__proto__ = AigleProxy;
-            MixinProxy.prototype = Object.create(AigleProxy && AigleProxy.prototype);
-            MixinProxy.prototype.constructor = MixinProxy;
-
-            MixinProxy.prototype._callResolve = function _callResolve(value) {
-              this._promise._resolve(value);
-            };
-
-            MixinProxy.prototype._callReject = function _callReject(reason) {
-              this._promise._reject(reason);
-            };
-
-            return MixinProxy;
-          })(AigleProxy);
-
-          function execute(value) {
-            var ref = this;
-            var _args = ref._args;
-            if (_args[0] === PENDING) {
-              _args[0] = value;
-              this._callResolve = this._set;
-            }
-            callProxyReciever(apply(this._func, _args), this);
-            return this._promise;
-          }
-
-          function executeWithPromisify(value) {
-            var this$1 = this;
-
-            var ref = this;
-            var _args = ref._args;
-            if (_args[0] === PENDING) {
-              _args[0] = value;
-              this._callResolve = this._set;
-            } else {
-              value = _args[0];
-            }
-            var iterator = _args[1];
-            var isFunc = typeof iterator === 'function';
-            if (isFunc && Array.isArray(value)) {
-              callIterator(this, map, function(array) {
-                var index = 0;
-                _args[1] = function() {
-                  return array[index++];
-                };
-                callProxyReciever(apply(this$1._func, _args), this$1);
-              });
-            } else if (isFunc && value && typeof value === 'object') {
-              callIterator(this, mapValues, function(object) {
-                var index = 0;
-                var keys = Object.keys(object);
-                _args[1] = function() {
-                  return object[keys[index++]];
-                };
-                callProxyReciever(apply(this$1._func, _args), this$1);
-              });
-            } else {
-              callProxyReciever(apply(this._func, _args), this);
-            }
-            return this._promise;
-          }
-
-          function callIterator(proxy, func, onFulfilled) {
-            var ref = proxy._args;
-            var collection = ref[0];
-            var iterator = ref[1];
-            var p = func(collection, function(value, key) {
-              return iterator(value, key, collection);
-            });
-            return p._resolved === 1
-              ? onFulfilled(p._value)
-              : p.then(onFulfilled, function(error) {
-                  return proxy._callReject(error);
-                });
-          }
-
-          /**
-           * @private
-           * @param {function} func
-           * @param {boolean} promisify
-           */
-          function createProxy(func, promisify) {
-            var exec = promisify ? executeWithPromisify : execute;
-            return /*@__PURE__*/ (function(MixinProxy) {
-              function anonymous() {
-                var args = [],
-                  len = arguments.length;
-                while (len--) args[len] = arguments[len];
-
-                MixinProxy.call(this, func, exec, args);
-              }
-
-              if (MixinProxy) anonymous.__proto__ = MixinProxy;
-              anonymous.prototype = Object.create(MixinProxy && MixinProxy.prototype);
-              anonymous.prototype.constructor = anonymous;
-
-              return anonymous;
-            })(MixinProxy);
-          }
-        },
-        { '../aigle': 2, '../map': 41, '../mapValues': 44, './util': 39, 'aigle-core': 85 }
-      ],
-      38: [
-        function(require, module, exports) {
-          'use strict';
-
-          var Queue = function Queue(size) {
-            if (size === void 0) size = 8;
-
-            this.array = Array(size);
-            this.length = 0;
-          };
-
-          Queue.prototype.push = function push(task) {
-            this.array[this.length++] = task;
-          };
-
-          module.exports = Queue;
-        },
-        {}
-      ],
-      39: [
-        function(require, module, exports) {
-          (function(process) {
-            'use strict';
-
-            var ref = require('aigle-core');
-            var AigleCore = ref.AigleCore;
-            var ref$1 = require('../../package.json');
-            var VERSION = ref$1.version;
-            var DEFAULT_LIMIT = 8;
-            var errorObj = { e: undefined };
-            var iteratorSymbol =
-              typeof Symbol === 'function' ? Symbol.iterator : function SYMBOL() {};
-            var isNode =
-              typeof process === 'object' &&
-              Object.prototype.toString.call(process) === '[object process]';
-
-            var iterators = [
-              createArrayIterator,
-              createObjectIterator,
-              createSetIterator,
-              createMapIterator
-            ].map(function(createIterator) {
-              return [callProxyReciever, callProxyRecieverWithFunc].map(createIterator);
-            });
-
-            var promiseArrayIterator = iterators[0][1];
-            var promiseObjectIterator = iterators[1][1];
-            var promiseSetIterator = iterators[2][1];
-            var promiseMapIterator = iterators[3][1];
-            var ref$2 = [createArrayEach, createObjectEach, createSetEach, createMapEach].map(
-              function(createEach, index) {
-                return iterators[index].map(createEach);
-              }
-            );
-            var ref$2_0 = ref$2[0];
-            var promiseArrayEach = ref$2_0[0];
-            var promiseArrayEachWithFunc = ref$2_0[1];
-            var ref$2_1 = ref$2[1];
-            var promiseObjectEach = ref$2_1[0];
-            var promiseObjectEachWithFunc = ref$2_1[1];
-            var ref$2_2 = ref$2[2];
-            var promiseSetEach = ref$2_2[0];
-            var promiseSetEachWithFunc = ref$2_2[1];
-            var ref$2_3 = ref$2[3];
-            var promiseMapEach = ref$2_3[0];
-            var promiseMapEachWithFunc = ref$2_3[1];
-
-            module.exports = {
-              VERSION: VERSION,
-              DEFAULT_LIMIT: DEFAULT_LIMIT,
-              INTERNAL: INTERNAL,
-              PENDING: PENDING,
-              UNHANDLED: UNHANDLED,
-              defaultIterator: defaultIterator,
-              errorObj: errorObj,
-              iteratorSymbol: iteratorSymbol,
-              call0: call0,
-              call1: call1,
-              call3: call3,
-              apply: apply,
-              callResolve: callResolve,
-              callReject: callReject,
-              callReceiver: callReceiver,
-              callThen: callThen,
-              callProxyReciever: callProxyReciever,
-              callProxyRecieverWithFunc: callProxyRecieverWithFunc,
-              promiseArrayIterator: promiseArrayIterator,
-              promiseArrayEach: promiseArrayEach,
-              promiseArrayEachWithFunc: promiseArrayEachWithFunc,
-              promiseObjectIterator: promiseObjectIterator,
-              promiseObjectEach: promiseObjectEach,
-              promiseObjectEachWithFunc: promiseObjectEachWithFunc,
-              promiseSetIterator: promiseSetIterator,
-              promiseSetEach: promiseSetEach,
-              promiseSetEachWithFunc: promiseSetEachWithFunc,
-              promiseMapIterator: promiseMapIterator,
-              promiseMapEach: promiseMapEach,
-              promiseMapEachWithFunc: promiseMapEachWithFunc,
-              compactArray: compactArray,
-              concatArray: concatArray,
-              clone: clone,
-              createEmptyObject: createEmptyObject,
-              sortArray: sortArray,
-              sortObject: sortObject,
-              printWarning: printWarning
-            };
-
-            function INTERNAL() {}
-
-            function PENDING() {}
-
-            function UNHANDLED() {}
-
-            function defaultIterator(n) {
-              return n;
-            }
-
-            function call0(handler) {
-              try {
-                return handler();
-              } catch (e) {
-                errorObj.e = e;
-                return errorObj;
-              }
-            }
-
-            function call1(handler, value) {
-              try {
-                return handler(value);
-              } catch (e) {
-                errorObj.e = e;
-                return errorObj;
-              }
-            }
-
-            function call3(handler, arg1, arg2, arg3) {
-              try {
-                return handler(arg1, arg2, arg3);
-              } catch (e) {
-                errorObj.e = e;
-                return errorObj;
-              }
-            }
-
-            function apply(handler, array) {
-              try {
-                switch (array.length) {
-                  case 0:
-                    return handler();
-                  case 1:
-                    return handler(array[0]);
-                  case 2:
-                    return handler(array[0], array[1]);
-                  case 3:
-                    return handler(array[0], array[1], array[2]);
-                  default:
-                    return handler.apply(null, array);
-                }
-              } catch (e) {
-                errorObj.e = e;
-                return errorObj;
-              }
-            }
-
-            function callResolve(receiver, onFulfilled, value) {
-              typeof onFulfilled === 'function'
-                ? callReceiver(receiver, call1(onFulfilled, value))
-                : receiver._resolve(value);
-            }
-
-            function callReject(receiver, onRejected, reason) {
-              typeof onRejected === 'function'
-                ? callReceiver(receiver, call1(onRejected, reason))
-                : receiver._reject(reason);
-            }
-
-            function callReceiver(receiver, promise) {
-              if (promise === errorObj) {
-                receiver._reject(errorObj.e);
-                return;
-              }
-              if (!promise || !promise.then) {
-                receiver._resolve(promise);
-                return;
-              }
-              if (promise instanceof AigleCore) {
-                switch (promise._resolved) {
-                  case 0:
-                    promise._addReceiver(receiver, INTERNAL);
-                    return;
-                  case 1:
-                    receiver._resolve(promise._value);
-                    return;
-                  case 2:
-                    promise.suppressUnhandledRejections();
-                    receiver._reject(promise._value);
-                    return;
-                }
-              }
-              callThen(promise, receiver);
-            }
-
-            function callThen(promise, receiver) {
-              promise.then(resolve, reject);
-
-              function resolve(value) {
-                receiver._resolve(value);
-              }
-
-              function reject(reason) {
-                receiver._reject(reason);
-              }
-            }
-
-            function callProxyThen(promise, receiver, key) {
-              promise.then(resolve, reject);
-
-              function resolve(value) {
-                receiver._callResolve(value, key);
-              }
-
-              function reject(reason) {
-                receiver._callReject(reason);
-              }
-            }
-
-            function callProxyReciever(promise, receiver, key) {
-              if (promise instanceof AigleCore) {
-                switch (promise._resolved) {
-                  case 0:
-                    promise._addReceiver(receiver, key);
-                    return true;
-                  case 1:
-                    receiver._callResolve(promise._value, key);
-                    return true;
-                  case 2:
-                    promise.suppressUnhandledRejections();
-                    receiver._callReject(promise._value);
-                    return false;
-                }
-              }
-              if (promise === errorObj) {
-                receiver._callReject(errorObj.e);
-                return false;
-              }
-              if (promise && promise.then) {
-                callProxyThen(promise, receiver, key);
-              } else {
-                receiver._callResolve(promise, key);
-              }
-              return true;
-            }
-
-            function callProxyRecieverWithFunc(promise, receiver, index) {
-              if (typeof promise === 'function') {
-                promise = promise();
-              }
-              return callProxyReciever(promise, receiver, index);
-            }
-
-            function createArrayIterator(handler) {
-              return function(receiver, coll, index) {
-                return handler(coll[index], receiver, index);
-              };
-            }
-
-            function createArrayEach(iterator) {
-              return function(receiver, times, coll) {
-                var i = -1;
-                while (++i < times && iterator(receiver, coll, i)) {}
-              };
-            }
-
-            function createObjectIterator(handler) {
-              return function(receiver, coll, index, result, keys) {
-                var key = keys[index];
-                result[key] = undefined;
-                return handler(coll[key], receiver, key);
-              };
-            }
-
-            function createObjectEach(iterator) {
-              return function(receiver, times, coll, result, keys) {
-                var i = -1;
-                while (++i < times && iterator(receiver, coll, i, result, keys)) {}
-              };
-            }
-
-            function createSetIterator(handler) {
-              return function(receiver, iter, index) {
-                var item = iter.next();
-                return item.done === false && handler(item.value, receiver, index);
-              };
-            }
-
-            function createSetEach(iterator) {
-              return function(receiver, times, coll) {
-                var iter = coll[iteratorSymbol]();
-                var i = -1;
-                while (++i < times && iterator(receiver, iter, i)) {}
-              };
-            }
-
-            function createMapIterator(handler) {
-              return function(receiver, iter, index, result) {
-                var item = iter.next();
-                if (item.done) {
-                  return false;
-                }
-                var ref = item.value;
-                var key = ref[0];
-                var promise = ref[1];
-                result.set(key, undefined);
-                return handler(promise, receiver, key);
-              };
-            }
-
-            function createMapEach(iterator) {
-              return function(receiver, times, coll, result) {
-                var iter = coll[iteratorSymbol]();
-                var i = -1;
-                while (++i < times && iterator(receiver, iter, i, result)) {}
-              };
-            }
-
-            function compactArray(array) {
-              var i = -1;
-              var l = array.length;
-              var result = [];
-              while (++i < l) {
-                var value = array[i];
-                if (value !== INTERNAL) {
-                  result.push(value);
-                }
-              }
-              return result;
-            }
-
-            function concatArray(array) {
-              var i = -1;
-              var l = array.length;
-              var result = [];
-              while (++i < l) {
-                var value = array[i];
-                if (Array.isArray(value)) {
-                  result.push.apply(result, value);
-                } else if (value !== undefined) {
-                  result.push(value);
-                }
-              }
-              return result;
-            }
-
-            function clone(target) {
-              return Array.isArray(target) ? cloneArray(target) : cloneObject(target);
-            }
-
-            function cloneArray(array) {
-              var l = array.length;
-              var result = Array(l);
-              while (l--) {
-                result[l] = array[l];
-              }
-              return result;
-            }
-
-            function cloneObject(object) {
-              var keys = Object.keys(object);
-              var l = keys.length;
-              var result = {};
-              while (l--) {
-                var key = keys[l];
-                result[key] = object[key];
-              }
-              return result;
-            }
-
-            function createEmptyObject(object, keys) {
-              var i = -1;
-              var l = keys.length;
-              var result = {};
-              while (++i < l) {
-                result[keys[i]] = undefined;
-              }
-              return result;
-            }
-
-            /**
-             * @private
-             * @param {Array} array
-             * @param {number[]} criteria
-             */
-            function sortArray(array, criteria) {
-              var l = array.length;
-              var indices = Array(l);
-              for (var i = 0; i < l; i++) {
-                indices[i] = i;
-              }
-              quickSort(criteria, 0, l - 1, indices);
-              var result = Array(l);
-              for (var n = 0; n < l; n++) {
-                var i$1 = indices[n];
-                result[n] = i$1 === undefined ? array[n] : array[i$1];
-              }
-              return result;
-            }
-
-            /**
-             * @private
-             * @param {Object} object
-             * @param {string[]} keys
-             * @param {number[]} criteria
-             */
-            function sortObject(object, keys, criteria) {
-              var l = keys.length;
-              var indices = Array(l);
-              for (var i = 0; i < l; i++) {
-                indices[i] = i;
-              }
-              quickSort(criteria, 0, l - 1, indices);
-              var result = Array(l);
-              for (var n = 0; n < l; n++) {
-                var i$1 = indices[n];
-                result[n] = object[keys[i$1 === undefined ? n : i$1]];
-              }
-              return result;
-            }
-
-            function partition(array, i, j, mid, indices) {
-              var l = i;
-              var r = j;
-              while (l <= r) {
-                i = l;
-                while (l < r && array[l] < mid) {
-                  l++;
-                }
-                while (r >= i && array[r] >= mid) {
-                  r--;
-                }
-                if (l > r) {
-                  break;
-                }
-                swap(array, indices, l++, r--);
-              }
-              return l;
-            }
-
-            function swap(array, indices, l, r) {
-              var n = array[l];
-              array[l] = array[r];
-              array[r] = n;
-              var i = indices[l];
-              indices[l] = indices[r];
-              indices[r] = i;
-            }
-
-            function quickSort(array, i, j, indices) {
-              if (i === j) {
-                return;
-              }
-              var k = i;
-              while (++k <= j && array[i] === array[k]) {
-                var l = k - 1;
-                if (indices[l] > indices[k]) {
-                  var i$1 = indices[l];
-                  indices[l] = indices[k];
-                  indices[k] = i$1;
-                }
-              }
-              if (k > j) {
-                return;
-              }
-              var p = array[i] > array[k] ? i : k;
-              k = partition(array, i, j, array[p], indices);
-              quickSort(array, i, k - 1, indices);
-              quickSort(array, k, j, indices);
-            }
-
-            function printWarning(message) {
-              isNode
-                ? console.warn('\u001b[31m' + message + '\u001b[0m\n')
-                : console.warn('%c' + message, 'color: red');
-            }
-          }.call(this, require('_process')));
-        },
-        { '../../package.json': 91, _process: 86, 'aigle-core': 85 }
-      ],
-      40: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('aigle-core');
-          var AigleProxy = ref.AigleProxy;
-
-          var Aigle = require('./aigle');
-          var ref$1 = require('./internal/util');
-          var INTERNAL = ref$1.INTERNAL;
-          var call1 = ref$1.call1;
-          var apply = ref$1.apply;
-          var callProxyReciever = ref$1.callProxyReciever;
-
-          var Join = /*@__PURE__*/ (function(AigleProxy) {
-            function Join(handler, size) {
-              AigleProxy.call(this);
-              this._promise = new Aigle(INTERNAL);
-              this._rest = size;
-              this._result = Array(size);
-              this._handler = handler;
-            }
-
-            if (AigleProxy) Join.__proto__ = AigleProxy;
-            Join.prototype = Object.create(AigleProxy && AigleProxy.prototype);
-            Join.prototype.constructor = Join;
-
-            Join.prototype._callResolve = function _callResolve(value, index) {
-              if (index === INTERNAL) {
-                return this._promise._resolve(value);
-              }
-              this._result[index] = value;
-              if (--this._rest !== 0) {
-                return;
-              }
-              var ref = this;
-              var _handler = ref._handler;
-              var _result = ref._result;
-              if (_handler === undefined) {
-                this._promise._resolve(_result);
-              } else {
-                callProxyReciever(apply(_handler, _result), this, INTERNAL);
-              }
-            };
-
-            Join.prototype._callReject = function _callReject(reason) {
-              this._promise._reject(reason);
-            };
-
-            return Join;
-          })(AigleProxy);
-
-          var Spread = /*@__PURE__*/ (function(AigleProxy) {
-            function Spread(handler) {
-              AigleProxy.call(this);
-              this._promise = new Aigle(INTERNAL);
-              this._handler = handler;
-            }
-
-            if (AigleProxy) Spread.__proto__ = AigleProxy;
-            Spread.prototype = Object.create(AigleProxy && AigleProxy.prototype);
-            Spread.prototype.constructor = Spread;
-
-            Spread.prototype._callResolve = function _callResolve(value, index) {
-              if (index === INTERNAL) {
-                return this._promise._resolve(value);
-              }
-              spread(this, value);
-            };
-
-            Spread.prototype._callReject = function _callReject(reason) {
-              this._promise._reject(reason);
-            };
-
-            return Spread;
-          })(AigleProxy);
-
-          module.exports = { join: join, Spread: Spread };
-
-          /**
-           * @example
-           * const p1 = Aigle.delay(20).then(() => 1);
-           * const p2 = Aigle.delay(10).then(() => 2);
-           * Aigle.join(p1, p2, (v1, v2) => {
-           *   console.log(v1, v2); // 1 2
-           * });
-           */
-          function join() {
-            var arguments$1 = arguments;
-
-            var l = arguments.length;
-            var handler = typeof arguments[l - 1] === 'function' ? arguments[--l] : undefined;
-            var receiver = new Join(handler, l);
-            while (l--) {
-              callProxyReciever(arguments$1[l], receiver, l);
-            }
-            return receiver._promise;
-          }
-
-          /**
-           * @private
-           * @param {AigleProxy} proxy
-           * @param {string|Array|Object} array
-           */
-          function spread(proxy, array) {
-            var _handler = proxy._handler;
-            if (_handler === undefined) {
-              return proxy._promise._resolve(array);
-            }
-            switch (typeof array) {
-              case 'string':
-                array = array.split('');
-                break;
-              case 'object':
-                if (Array.isArray(array)) {
-                  break;
-                }
-                if (array) {
-                  var keys = Object.keys(array);
-                  var l = keys.length;
-                  var arr = Array(l);
-                  while (l--) {
-                    arr[l] = array[keys[l]];
-                  }
-                  array = arr;
-                  break;
-                }
-              /* eslint no-fallthrough: 0 */
-              default:
-                /* eslint no-fallthrough: 1 */
-                return callProxyReciever(call1(_handler, array), proxy, INTERNAL);
-            }
-            callProxyReciever(apply(_handler, array), proxy, INTERNAL);
-          }
-        },
-        { './aigle': 2, './internal/util': 39, 'aigle-core': 85 }
-      ],
-      41: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./each');
-          var Each = ref.Each;
-          var ref$1 = require('./internal/collection');
-          var setShorthand = ref$1.setShorthand;
-
-          var Map = /*@__PURE__*/ (function(Each) {
-            function Map(collection, iterator) {
-              Each.call(this, collection, iterator, set);
-            }
-
-            if (Each) Map.__proto__ = Each;
-            Map.prototype = Object.create(Each && Each.prototype);
-            Map.prototype.constructor = Map;
-
-            Map.prototype._callResolve = function _callResolve(value, index) {
-              this._result[index] = value;
-              if (--this._rest === 0) {
-                this._promise._resolve(this._result);
-              }
-            };
-
-            return Map;
-          })(Each);
-
-          module.exports = { map: map, Map: Map };
-
-          function set(collection) {
-            setShorthand.call(this, collection);
-            this._result = Array(this._rest);
-            return this;
-          }
-
-          /**
-           * `Aigle.map` has almost the same functionality as `Array#map`.
-           * It iterates all elements of `collection` and executes `iterator` using each element on parallel.
-           * The `iterator` needs to return a promise or something.
-           * Then the result will be assigned to an array and the array order will be ensured.
-           * All of them are finished, the function will return an array as a result.
-           * @param {Array|Object} collection
-           * @param {Function|string} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num * 2;
-           *     });
-           * };
-           * Aigle.map(collection, iterator)
-           *   .then(array => {
-           *     console.log(array); // [2, 8, 4];
-           *     console.log(order); // [1, 2, 4];
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = { a: 1, b: 4, c: 2 };
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num * 2;
-           *     });
-           * };
-           * Aigle.map(collection, iterator)
-           *   .then(array => {
-           *     console.log(array); // [2, 8, 4];
-           *     console.log(order); // [1, 2, 4];
-           *   });
-           *
-           * @example
-           * const collection = [{
-           *  uid: 1, name: 'test1'
-           * }, {
-           *  uid: 4, name: 'test4'
-           * }, {
-           *  uid: 2, name: 'test2'
-           * }];
-           * Aigle.map(collection, 'uid')
-           *   .then(uids => console.log(uids)); // [1, 4, 2]
-           */
-          function map(collection, iterator) {
-            return new Map(collection, iterator)._execute();
-          }
-        },
-        { './each': 12, './internal/collection': 36 }
-      ],
-      42: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./eachLimit');
-          var EachLimit = ref.EachLimit;
-          var ref$1 = require('./internal/collection');
-          var setLimit = ref$1.setLimit;
-
-          var MapLimit = /*@__PURE__*/ (function(EachLimit) {
-            function MapLimit(collection, limit, iterator) {
-              EachLimit.call(this, collection, limit, iterator, set);
-            }
-
-            if (EachLimit) MapLimit.__proto__ = EachLimit;
-            MapLimit.prototype = Object.create(EachLimit && EachLimit.prototype);
-            MapLimit.prototype.constructor = MapLimit;
-
-            MapLimit.prototype._callResolve = function _callResolve(value, index) {
-              this._result[index] = value;
-              if (--this._rest === 0) {
-                this._promise._resolve(this._result);
-              } else if (this._callRest-- > 0) {
-                this._iterate();
-              }
-            };
-
-            return MapLimit;
-          })(EachLimit);
-
-          module.exports = { mapLimit: mapLimit, MapLimit: MapLimit };
-
-          function set(collection) {
-            setLimit.call(this, collection);
-            this._result = Array(this._rest);
-            return this;
-          }
-
-          /**
-           * `Aigle.mapLimit` is almost the smae as [`Aigle.map`](https://suguru03.github.io/aigle/docs/Aigle.html#map) and
-           * [`Aigle.mapSeries`](https://suguru03.github.io/aigle/docs/Aigle.html#mapSeries), but it will work with concurrency.
-           * @param {Array|Object} collection
-           * @param {integer} [limit=8]
-           * @param {Function} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 5, 3, 4, 2];
-           * const iterator = (num, index) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num * 2;
-           *     });
-           * };
-           * Aigle.mapLimit(collection, 2, iterator)
-           *   .then(array => {
-           *     console.log(array); // [2, 10, 6, 8, 4];
-           *     console.log(order); // [1, 3, 5, 2, 4];
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = { a: 1, b: 5, c: 3, d: 4, e: 2 };
-           * const iterator = (num, key) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num * 2;
-           *     });
-           * };
-           * Aigle.mapLimit(collection, 2, iterator)
-           *   .then(array => {
-           *     console.log(array); // [2, 10, 6, 8, 4];
-           *     console.log(order); // [1, 3, 5, 2, 4];
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [1, 5, 3, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num * 2;
-           *     });
-           * };
-           * Aigle.mapLimit(collection, iterator)
-           *   .then(array => {
-           *     console.log(array); // [2, 10, 6, 8, 4];
-           *     console.log(order); // [1, 2, 3, 4, 5];
-           *   });
-           */
-          function mapLimit(collection, limit, iterator) {
-            return new MapLimit(collection, limit, iterator)._execute();
-          }
-        },
-        { './eachLimit': 13, './internal/collection': 36 }
-      ],
-      43: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./eachSeries');
-          var EachSeries = ref.EachSeries;
-          var ref$1 = require('./internal/collection');
-          var setSeries = ref$1.setSeries;
-
-          var MapSeries = /*@__PURE__*/ (function(EachSeries) {
-            function MapSeries(collection, iterator) {
-              EachSeries.call(this, collection, iterator, set);
-            }
-
-            if (EachSeries) MapSeries.__proto__ = EachSeries;
-            MapSeries.prototype = Object.create(EachSeries && EachSeries.prototype);
-            MapSeries.prototype.constructor = MapSeries;
-
-            MapSeries.prototype._callResolve = function _callResolve(value, index) {
-              this._result[index] = value;
-              if (--this._rest === 0) {
-                this._promise._resolve(this._result);
-              } else {
-                this._iterate();
-              }
-            };
-
-            return MapSeries;
-          })(EachSeries);
-
-          module.exports = { mapSeries: mapSeries, MapSeries: MapSeries };
-
-          function set(collection) {
-            setSeries.call(this, collection);
-            this._result = Array(this._rest);
-            return this;
-          }
-
-          /**
-           * `Aigle.mapSeries` is almost the smae as [`Aigle.map`](https://suguru03.github.io/aigle/docs/Aigle.html#map), but it will work in series.
-           * @param {Array|Object} collection
-           * @param {Function} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num * 2;
-           *     });
-           * };
-           * Aigle.mapSeries(collection, iterator)
-           *   .then(array => {
-           *     console.log(array); // [2, 8, 4];
-           *     console.log(order); // [1, 4, 2];
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = { a: 1, b: 4, c: 2 };
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num * 2;
-           *     });
-           * };
-           * Aigle.mapSeries(collection, iterator)
-           *   .then(array => {
-           *     console.log(array); // [2, 8, 4];
-           *     console.log(order); // [1, 4, 2];
-           *   });
-           */
-          function mapSeries(collection, iterator) {
-            return new MapSeries(collection, iterator)._execute();
-          }
-        },
-        { './eachSeries': 14, './internal/collection': 36 }
-      ],
-      44: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./each');
-          var Each = ref.Each;
-          var ref$1 = require('./internal/collection');
-          var setShorthandWithOrder = ref$1.setShorthandWithOrder;
-
-          var MapValues = /*@__PURE__*/ (function(Each) {
-            function MapValues(collection, iterator) {
-              Each.call(this, collection, iterator, set);
-              this._result = {};
-            }
-
-            if (Each) MapValues.__proto__ = Each;
-            MapValues.prototype = Object.create(Each && Each.prototype);
-            MapValues.prototype.constructor = MapValues;
-
-            return MapValues;
-          })(Each);
-
-          module.exports = { mapValues: mapValues, MapValues: MapValues };
-
-          function set(collection) {
-            setShorthandWithOrder.call(this, collection);
-            this._callResolve = this._keys === undefined ? callResolveArray : callResolveObject;
-            return this;
-          }
-
-          function callResolveArray(value, index) {
-            this._result[index] = value;
-            if (--this._rest === 0) {
-              this._promise._resolve(this._result);
-            }
-          }
-
-          function callResolveObject(value, index) {
-            this._result[this._keys[index]] = value;
-            if (--this._rest === 0) {
-              this._promise._resolve(this._result);
-            }
-          }
-
-          /**
-           * `Aigle.mapValues` is similar to [`Aigle.map`](https://suguru03.github.io/aigle/docs/global.html#map).
-           * It returns an object instead of an array.
-           * @param {Array|Object} collection
-           * @param {Function|string} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num * 2;
-           *     });
-           * };
-           * Aigle.mapValues(collection, iterator)
-           *   .then(object => {
-           *     console.log(object); // { '0': 2, '1': 8, '2': 4 }
-           *     console.log(order); // [1, 2, 4]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = { a: 1, b: 4, c: 2 };
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num * 2;
-           *     });
-           * };
-           * Aigle.mapValues(collection, iterator)
-           *   .then(object => {
-           *     console.log(object); // { a: 2, b: 8, c: 4 }
-           *     console.log(order); // [1, 2, 4]
-           *   });
-           *
-           * @example
-           * const collection = {
-           *   task1: { uid: 1, name: 'test1' },
-           *   task2: { uid: 4, name: 'test4' },
-           *   task3: { uid: 2, name: 'test2' }
-           * }];
-           * Aigle.mapValues(collection, 'uid')
-           *   .then(uids => console.log(uids)); // { task1: 1, task2: 4, task3: 2 }
-           */
-          function mapValues(collection, iterator) {
-            return new MapValues(collection, iterator)._execute();
-          }
-        },
-        { './each': 12, './internal/collection': 36 }
-      ],
-      45: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./eachLimit');
-          var EachLimit = ref.EachLimit;
-          var ref$1 = require('./internal/collection');
-          var setLimit = ref$1.setLimit;
-          var ref$2 = require('./internal/util');
-          var createEmptyObject = ref$2.createEmptyObject;
-
-          var MapValuesLimit = /*@__PURE__*/ (function(EachLimit) {
-            function MapValuesLimit(collection, limit, iterator) {
-              EachLimit.call(this, collection, limit, iterator, set);
-            }
-
-            if (EachLimit) MapValuesLimit.__proto__ = EachLimit;
-            MapValuesLimit.prototype = Object.create(EachLimit && EachLimit.prototype);
-            MapValuesLimit.prototype.constructor = MapValuesLimit;
-
-            return MapValuesLimit;
-          })(EachLimit);
-
-          module.exports = { mapValuesLimit: mapValuesLimit, MapValuesLimit: MapValuesLimit };
-
-          function set(collection) {
-            setLimit.call(this, collection);
-            if (this._keys === undefined) {
-              this._result = {};
-              this._callResolve = callResolveArray;
-            } else {
-              this._result = createEmptyObject(collection, this._keys);
-              this._callResolve = callResolveObject;
-            }
-            return this;
-          }
-
-          function callResolveArray(value, index) {
-            this._result[index] = value;
-            if (--this._rest === 0) {
-              this._promise._resolve(this._result);
-            } else if (this._callRest-- > 0) {
-              this._iterate();
-            }
-          }
-
-          function callResolveObject(value, index) {
-            this._result[this._keys[index]] = value;
-            if (--this._rest === 0) {
-              this._promise._resolve(this._result);
-            } else if (this._callRest-- > 0) {
-              this._iterate();
-            }
-          }
-
-          /**
-           * `Aigle.mapValuesLimit` is almost the same as [`Aigle.mapValues`](https://suguru03.github.io/aigle/docs/Aigle.html#mapValues) and
-           * [`Aigle.mapValuesSeries`](https://suguru03.github.io/aigle/docs/Aigle.html#mapValuesSeries), but it will work with concurrency.
-           * @param {Array|Object} collection
-           * @param {integer} [limit=8]
-           * @param {Function} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 5, 3, 4, 2];
-           * const iterator = (num, index) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num * 2;
-           *     });
-           * };
-           * Aigle.mapValuesLimit(collection, 2, iterator)
-           *   .then(object => {
-           *     console.log(object); // { '0': 2, '1': 10, '2': 6, '3': 8, '4': 4 }
-           *     console.log(order); // [1, 3, 5, 2, 4]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = { a: 1, b: 5, c: 3, d: 4, e: 2 };
-           * const iterator = (num, key) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num * 2;
-           *     });
-           * };
-           * Aigle.mapValuesLimit(collection, 2, iterator)
-           *   .then(object => {
-           *     console.log(object); // { a: 2, b: 10, c: 6, d: 8, e: 4 }
-           *     console.log(order); // [1, 3, 5, 2, 4]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [1, 5, 3, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num * 2;
-           *     });
-           * };
-           * Aigle.mapValuesLimit(collection, iterator)
-           *   .then(object => {
-           *     console.log(object); // { '0': 2, '1': 10, '2': 6, '3': 8, '4': 4 }
-           *     console.log(order); // [1, 2, 3, 4, 5]
-           *   });
-           */
-          function mapValuesLimit(collection, limit, iterator) {
-            return new MapValuesLimit(collection, limit, iterator)._execute();
-          }
-        },
-        { './eachLimit': 13, './internal/collection': 36, './internal/util': 39 }
-      ],
-      46: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./eachSeries');
-          var EachSeries = ref.EachSeries;
-          var ref$1 = require('./internal/collection');
-          var setSeries = ref$1.setSeries;
-
-          var MapValuesSeries = /*@__PURE__*/ (function(EachSeries) {
-            function MapValuesSeries(collection, iterator) {
-              EachSeries.call(this, collection, iterator, set);
-              this._result = {};
-            }
-
-            if (EachSeries) MapValuesSeries.__proto__ = EachSeries;
-            MapValuesSeries.prototype = Object.create(EachSeries && EachSeries.prototype);
-            MapValuesSeries.prototype.constructor = MapValuesSeries;
-
-            return MapValuesSeries;
-          })(EachSeries);
-
-          module.exports = { mapValuesSeries: mapValuesSeries, MapValuesSeries: MapValuesSeries };
-
-          function set(collection) {
-            setSeries.call(this, collection);
-            this._callResolve = this._keys === undefined ? callResolveArray : callResolveObject;
-            return this;
-          }
-
-          function callResolveArray(value, index) {
-            this._result[index] = value;
-            if (--this._rest === 0) {
-              this._promise._resolve(this._result);
-            } else {
-              this._iterate();
-            }
-          }
-
-          function callResolveObject(value, index) {
-            this._result[this._keys[index]] = value;
-            if (--this._rest === 0) {
-              this._promise._resolve(this._result);
-            } else {
-              this._iterate();
-            }
-          }
-
-          /**
-           * `Aigle.mapValuesSeries` is almost the same as [`Aigle.mapValues`](https://suguru03.github.io/aigle/docs/Aigle.html#mapValues), but it will work in series.
-           * @param {Array|Object} collection
-           * @param {Function} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num * 2;
-           *     });
-           * };
-           * Aigle.mapValuesSeries(collection, iterator)
-           *   .then(object => {
-           *     console.log(object); // { '0': 2, '1': 8, '2': 4 };
-           *     console.log(order); // [1, 4, 2];
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = { a: 1, b: 4, c: 2 };
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num * 2;
-           *     });
-           * };
-           * Aigle.mapValuesSeries(collection, iterator)
-           *   .then(object => {
-           *     console.log(object); // { a: 2, b: 8, c: 4 }
-           *     console.log(order); // [1, 4, 2];
-           *   });
-           */
-          function mapValuesSeries(collection, iterator) {
-            return new MapValuesSeries(collection, iterator)._execute();
-          }
-        },
-        { './eachSeries': 14, './internal/collection': 36 }
-      ],
-      47: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./each');
-          var Each = ref.Each;
-          var ref$1 = require('./internal/collection');
-          var setOmitShorthand = ref$1.setOmitShorthand;
-
-          var Omit = /*@__PURE__*/ (function(Each) {
-            function Omit(collection, iterator, args) {
-              if (typeof iterator !== 'function') {
-                iterator = [iterator].concat(args);
-              }
-              Each.call(this, collection, iterator, set);
-              this._result = {};
-            }
-
-            if (Each) Omit.__proto__ = Each;
-            Omit.prototype = Object.create(Each && Each.prototype);
-            Omit.prototype.constructor = Omit;
-
-            return Omit;
-          })(Each);
-
-          module.exports = { omit: omit, Omit: Omit };
-
-          function set(collection) {
-            setOmitShorthand.call(this, collection);
-            this._callResolve = this._keys === undefined ? callResolveArray : callResolveObject;
-            return this;
-          }
-
-          function callResolveArray(value, index) {
-            if (!value) {
-              this._result[index] = this._coll[index];
-            }
-            if (--this._rest === 0) {
-              this._promise._resolve(this._result);
-            }
-          }
-
-          function callResolveObject(value, index) {
-            if (!value) {
-              var key = this._keys[index];
-              this._result[key] = this._coll[key];
-            }
-            if (--this._rest === 0) {
-              this._promise._resolve(this._result);
-            }
-          }
-
-          /**
-           * `Aigle.omit` has almost the same functionality as [`Aigle.filter`](https://suguru03.github.io/aigle/docs/global.html#filter).
-           * It will return an object as a result.
-           * @param {Array|Object} collection
-           * @param {Function|Array|Object|string} iterator
-           * @param {*} [args]
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2;
-           *     });
-           * };
-           * Aigle.omit(collection, iterator)
-           *   .then(object => {
-           *     console.log(object); // { '0': 1 }
-           *     console.log(order); // [1, 2, 4]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = { a: 1, b: 4, c: 2 };
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num * 2;
-           *     });
-           * };
-           * Aigle.omit(collection, iterator)
-           *   .then(object => {
-           *     console.log(object); // { a: 1 }
-           *     console.log(order); // [1, 2, 4]
-           *   });
-           *
-           */
-          function omit(collection, iterator) {
-            var args = [],
-              len = arguments.length - 2;
-            while (len-- > 0) args[len] = arguments[len + 2];
-
-            return new Omit(collection, iterator, args)._execute();
-          }
-        },
-        { './each': 12, './internal/collection': 36 }
-      ],
-      48: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./each');
-          var Each = ref.Each;
-          var ref$1 = require('./internal/collection');
-          var setShorthand = ref$1.setShorthand;
-
-          var OmitBy = /*@__PURE__*/ (function(Each) {
-            function OmitBy(collection, iterator) {
-              Each.call(this, collection, iterator, set);
-              this._result = {};
-            }
-
-            if (Each) OmitBy.__proto__ = Each;
-            OmitBy.prototype = Object.create(Each && Each.prototype);
-            OmitBy.prototype.constructor = OmitBy;
-
-            return OmitBy;
-          })(Each);
-
-          module.exports = { omitBy: omitBy, OmitBy: OmitBy };
-
-          function set(collection) {
-            setShorthand.call(this, collection);
-            this._callResolve = this._keys === undefined ? callResolveArray : callResolveObject;
-            return this;
-          }
-
-          function callResolveArray(value, index) {
-            if (!value) {
-              this._result[index] = this._coll[index];
-            }
-            if (--this._rest === 0) {
-              this._promise._resolve(this._result);
-            }
-          }
-
-          function callResolveObject(value, index) {
-            if (!value) {
-              var key = this._keys[index];
-              this._result[key] = this._coll[key];
-            }
-            if (--this._rest === 0) {
-              this._promise._resolve(this._result);
-            }
-          }
-
-          /**
-           * `Aigle.omitBy` has almost the same functionality as [`Aigle.reject`](https://suguru03.github.io/aigle/docs/global.html#reject).
-           * It will return an object as a result.
-           * @param {Array|Object} collection
-           * @param {Function|Array|Object|string} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2;
-           *     });
-           * };
-           * Aigle.omitBy(collection, iterator)
-           *   .then(object => {
-           *     console.log(object); // { '1': 4, '2': 4 }
-           *     console.log(order); // [1, 2, 4]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = { a: 1, b: 4, c: 2 };
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num * 2;
-           *     });
-           * };
-           * Aigle.omitBy(collection, iterator)
-           *   .then(object => {
-           *     console.log(object); // { b: 4, c: 2 }
-           *     console.log(order); // [1, 2, 4]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [{
-           *   name: 'bargey', active: false
-           * }, {
-           *   name: 'fread', active: true
-           * }];
-           * Aigle.omitBy(collection, 'active')
-           *   .then(object => {
-           *     console.log(object); // { '0': { name: 'bargey', active: false } }
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [{
-           *   name: 'bargey', active: false
-           * }, {
-           *   name: 'fread', active: true
-           * }];
-           * Aigle.omitBy(collection, ['name', 'fread'])
-           *   .then(object => {
-           *     console.log(object); // { '0': { name: 'bargey', active: false } }
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [{
-           *   name: 'bargey', active: false
-           * }, {
-           *   name: 'fread', active: true
-           * }];
-           * Aigle.omitBy(collection, { name: 'fread', active: true })
-           *   .then(object => {
-           *     console.log(object); // { '0': { name: 'bargey', active: false } }
-           *   });
-           */
-          function omitBy(collection, iterator) {
-            return new OmitBy(collection, iterator)._execute();
-          }
-        },
-        { './each': 12, './internal/collection': 36 }
-      ],
-      49: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./eachLimit');
-          var EachLimit = ref.EachLimit;
-          var ref$1 = require('./internal/collection');
-          var setLimit = ref$1.setLimit;
-
-          var OmitByLimit = /*@__PURE__*/ (function(EachLimit) {
-            function OmitByLimit(collection, limit, iterator) {
-              EachLimit.call(this, collection, limit, iterator, set);
-              this._result = {};
-            }
-
-            if (EachLimit) OmitByLimit.__proto__ = EachLimit;
-            OmitByLimit.prototype = Object.create(EachLimit && EachLimit.prototype);
-            OmitByLimit.prototype.constructor = OmitByLimit;
-
-            return OmitByLimit;
-          })(EachLimit);
-
-          module.exports = { omitByLimit: omitByLimit, OmitByLimit: OmitByLimit };
-
-          function set(collection) {
-            setLimit.call(this, collection);
-            this._callResolve = this._keys === undefined ? callResolveArray : callResolveObject;
-            return this;
-          }
-
-          function callResolveArray(value, index) {
-            if (!value) {
-              this._result[index] = this._coll[index];
-            }
-            if (--this._rest === 0) {
-              this._promise._resolve(this._result);
-            } else if (this._callRest-- > 0) {
-              this._iterate();
-            }
-          }
-
-          function callResolveObject(value, index) {
-            if (!value) {
-              var key = this._keys[index];
-              this._result[key] = this._coll[key];
-            }
-            if (--this._rest === 0) {
-              this._promise._resolve(this._result);
-            } else if (this._callRest-- > 0) {
-              this._iterate();
-            }
-          }
-
-          /**
-           * `Aigle.omitByLimit` is almost the as [`Aigle.omitBy`](https://suguru03.github.io/aigle/docs/Aigle.html#omitBy) and
-           * [`Aigle.omitBySeries`](https://suguru03.github.io/aigle/docs/Aigle.html#omitBySeries), but it will work with concurrency.
-           * @param {Array|Object} collection
-           * @param {integer} [limit=8]
-           * @param {Function} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 5, 3, 4, 2];
-           * const iterator = (num, index) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2;
-           *     });
-           * };
-           * Aigle.omitByLimit(collection, 2, iterator)
-           *   .then(object => {
-           *     console.log(object); // { '3': 4, '4': 2 }
-           *     console.log(order); // [1, 3, 5, 2, 4]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = { a: 1, b: 5, c: 3, d: 4, e: 2 };
-           * const iterator = (num, key) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2;
-           *     });
-           * };
-           * Aigle.omitByLimit(collection, 2, iterator)
-           *   .then(object => {
-           *     console.log(object); // { d: 4, e: 2 }
-           *     console.log(order); // [1, 3, 5, 2, 4]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [1, 5, 3, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2;
-           *     });
-           * };
-           * Aigle.omitByLimit(collection, iterator)
-           *   .then(object => {
-           *     console.log(object); // { '3': 4, '4': 2 }
-           *     console.log(order); // [1, 2, 3, 4, 5]
-           *   });
-           */
-          function omitByLimit(collection, limit, iterator) {
-            return new OmitByLimit(collection, limit, iterator)._execute();
-          }
-        },
-        { './eachLimit': 13, './internal/collection': 36 }
-      ],
-      50: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./eachSeries');
-          var EachSeries = ref.EachSeries;
-          var ref$1 = require('./internal/util');
-          var PENDING = ref$1.PENDING;
-          var ref$2 = require('./internal/collection');
-          var setSeries = ref$2.setSeries;
-
-          var OmitBySeries = /*@__PURE__*/ (function(EachSeries) {
-            function OmitBySeries(collection, iterator) {
-              EachSeries.call(this, collection, iterator);
-              this._result = {};
-              if (collection === PENDING) {
-                this._set = set;
-              } else {
-                this._callResolve = this._keys === undefined ? callResolveArray : callResolveObject;
-              }
-            }
-
-            if (EachSeries) OmitBySeries.__proto__ = EachSeries;
-            OmitBySeries.prototype = Object.create(EachSeries && EachSeries.prototype);
-            OmitBySeries.prototype.constructor = OmitBySeries;
-
-            return OmitBySeries;
-          })(EachSeries);
-
-          module.exports = { omitBySeries: omitBySeries, OmitBySeries: OmitBySeries };
-
-          function set(collection) {
-            setSeries.call(this, collection);
-            this._callResolve = this._keys === undefined ? callResolveArray : callResolveObject;
-            return this;
-          }
-
-          function callResolveArray(value, index) {
-            if (!value) {
-              this._result[index] = this._coll[index];
-            }
-            if (--this._rest === 0) {
-              this._promise._resolve(this._result);
-            } else {
-              this._iterate();
-            }
-          }
-
-          function callResolveObject(value, index) {
-            if (!value) {
-              var key = this._keys[index];
-              this._result[key] = this._coll[key];
-            }
-            if (--this._rest === 0) {
-              this._promise._resolve(this._result);
-            } else {
-              this._iterate();
-            }
-          }
-
-          /**
-           * `Aigle.omitBySeries` is almost the as [`Aigle.omitBy`](https://suguru03.github.io/aigle/docs/Aigle.html#omitBy), but it will work in series.
-           * @param {Array|Object} collection
-           * @param {Function} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2;
-           *     });
-           * };
-           * Aigle.omitBySeriesSeries(collection, iterator)
-           *   .then(object => {
-           *     console.log(object); // { '1': 4, '2': 2 }
-           *     console.log(order); // [1, 4, 2]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = { a: 1, b: 4, c: 2 };
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2;
-           *     });
-           * };
-           * Aigle.omitBySeriesSeries(collection, iterator)
-           *   .then(object => {
-           *     console.log(object); // { b: 4, c: 2 }
-           *     console.log(order); // [1, 4, 2]
-           *   });
-           */
-          function omitBySeries(collection, iterator) {
-            return new OmitBySeries(collection, iterator)._execute();
-          }
-        },
-        { './eachSeries': 14, './internal/collection': 36, './internal/util': 39 }
-      ],
-      51: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('aigle-core');
-          var AigleProxy = ref.AigleProxy;
-
-          var Aigle = require('./aigle');
-          var ref$1 = require('./internal/util');
-          var INTERNAL = ref$1.INTERNAL;
-          var PENDING = ref$1.PENDING;
-          var promiseArrayEachWithFunc = ref$1.promiseArrayEachWithFunc;
-          var promiseObjectEachWithFunc = ref$1.promiseObjectEachWithFunc;
-          var promiseMapEachWithFunc = ref$1.promiseMapEachWithFunc;
-          var promiseSetEachWithFunc = ref$1.promiseSetEachWithFunc;
-          var iteratorSymbol = ref$1.iteratorSymbol;
-          var ref$2 = require('./props');
-          var callResolve = ref$2.callResolve;
-          var callResolveMap = ref$2.callResolveMap;
-
-          var Parallel = /*@__PURE__*/ (function(AigleProxy) {
-            function Parallel(coll) {
-              AigleProxy.call(this);
-              this._promise = new Aigle(INTERNAL);
-              this._rest = undefined;
-              this._result = undefined;
-              if (coll === PENDING) {
-                this._callResolve = this._set;
-              } else {
-                this._callResolve = undefined;
-                this._set(coll);
-              }
-            }
-
-            if (AigleProxy) Parallel.__proto__ = AigleProxy;
-            Parallel.prototype = Object.create(AigleProxy && AigleProxy.prototype);
-            Parallel.prototype.constructor = Parallel;
-
-            Parallel.prototype._set = function _set(coll) {
-              if (Array.isArray(coll)) {
-                var size = coll.length;
-                this._rest = size;
-                this._result = Array(size);
-                this._callResolve = callResolve;
-                promiseArrayEachWithFunc(this, size, coll);
-              } else if (!coll || typeof coll !== 'object') {
-                this._rest = 0;
-                this._result = undefined;
-              } else if (coll[iteratorSymbol]) {
-                var size$1 = coll.size;
-                this._rest = size$1;
-                if (coll instanceof Map) {
-                  var result = new Map();
-                  this._result = result;
-                  this._callResolve = callResolveMap;
-                  promiseMapEachWithFunc(this, Infinity, coll, result);
-                } else {
-                  this._result = Array(this._rest);
-                  this._callResolve = callResolve;
-                  promiseSetEachWithFunc(this, Infinity, coll);
-                }
-              } else {
-                var result$1 = {};
-                var keys = Object.keys(coll);
-                var size$2 = keys.length;
-                this._rest = size$2;
-                this._result = result$1;
-                this._callResolve = callResolve;
-                promiseObjectEachWithFunc(this, size$2, coll, result$1, keys);
-              }
-              if (this._rest === 0) {
-                this._promise._resolve(this._result);
-              }
-              return this;
-            };
-
-            Parallel.prototype._execute = function _execute() {
-              return this._promise;
-            };
-
-            Parallel.prototype._callReject = function _callReject(reason) {
-              this._promise._reject(reason);
-            };
-
-            return Parallel;
-          })(AigleProxy);
-
-          module.exports = { parallel: parallel, Parallel: Parallel };
-
-          /**
-           * `Aigle.parallel` functionality is similar to [`Aigle.all`](https://suguru03.github.io/aigle/docs/global.html#all)
-           * and [`Aigle.props`](https://suguru03.github.io/aigle/docs/global.html#props), and the function allows function collection.
-           * @param {Array|Object} collection - it should be an array/object of functions or Promise instances
-           * @example
-           *   Aigle.parallel([
-           *     () => Aigle.delay(30, 1),
-           *     Aigle.delay(20, 2),
-           *     3
-           *   ]).then(array => {
-           *     console.log(array); // [1, 2, 3]
-           *   });
-           *
-           * @example
-           *   Aigle.parallel({
-           *     a: () => Aigle.delay(30, 1),
-           *     b: Aigle.delay(20, 2),
-           *     c: 3
-           *   }).then(obj => {
-           *     console.log(obj); // { a: 1, b: 2, c: 3 }
-           *   });
-           */
-          function parallel(collection) {
-            return new Parallel(collection)._promise;
-          }
-        },
-        { './aigle': 2, './internal/util': 39, './props': 59, 'aigle-core': 85 }
-      ],
-      52: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./series');
-          var Series = ref.Series;
-          var ref$1 = require('./internal/util');
-          var DEFAULT_LIMIT = ref$1.DEFAULT_LIMIT;
-
-          var ParallelLimit = /*@__PURE__*/ (function(Series) {
-            function ParallelLimit(coll, limit) {
-              if (limit === void 0) limit = DEFAULT_LIMIT;
-
-              Series.call(this, coll);
-              this._size = this._rest;
-              this._limit = limit;
-            }
-
-            if (Series) ParallelLimit.__proto__ = Series;
-            ParallelLimit.prototype = Object.create(Series && Series.prototype);
-            ParallelLimit.prototype.constructor = ParallelLimit;
-
-            ParallelLimit.prototype._execute = function _execute() {
-              var ref = this;
-              var _limit = ref._limit;
-              var _rest = ref._rest;
-              if (_rest === 0) {
-                this._promise._resolve(this._result);
-                return this._promise;
-              }
-              this._size = _rest;
-              this._iterate = iterate;
-              var limit = _limit < _rest ? _limit : _rest;
-              while (limit--) {
-                this._iterate();
-              }
-              return this._promise;
-            };
-
-            ParallelLimit.prototype._callResolve = function _callResolve(value, key) {
-              this._result[key] = value;
-              if (--this._rest === 0) {
-                this._promise._resolve(this._result);
-              } else {
-                this._iterate();
-              }
-            };
-
-            ParallelLimit.prototype._callResolveMap = function _callResolveMap(value, key) {
-              this._result.set(key, value);
-              if (--this._rest === 0) {
-                this._promise._resolve(this._result);
-              } else {
-                this._iterate();
-              }
-            };
-
-            ParallelLimit.prototype._callReject = function _callReject(reason) {
-              this._promise._reject(reason);
-            };
-
-            return ParallelLimit;
-          })(Series);
-
-          module.exports = { parallelLimit: parallelLimit, ParallelLimit: ParallelLimit };
-
-          function iterate() {
-            ++this._index < this._size &&
-              this._iterator(this, this._coll, this._index, this._result, this._keys);
-          }
-
-          /**
-           * `Aigle.parallel` functionality has the same functionality as [`Aigle.parallel`](https://suguru03.github.io/aigle/docs/global.html#parallel)
-           * and it works with concurrency.
-           * @param {Array|Object} collection - it should be an array/object of functions or Promise instances
-           * @param {integer} [limit=8] - It is concurrncy, default is 8
-           * @example
-           *   Aigle.parallelLimit([
-           *     () => Aigle.delay(30, 1),
-           *     Aigle.delay(20, 2),
-           *     3
-           *   ]).then(array => {
-           *     console.log(array); // [1, 2, 3]
-           *   });
-           *
-           * @example
-           *   Aigle.parallelLimit({
-           *     a: () => Aigle.delay(30, 1),
-           *     b: Aigle.delay(20, 2),
-           *     c: 3
-           *   }, 2).then(obj => {
-           *     console.log(obj); // { a: 1, b: 2, c: 3 }
-           *   });
-           */
-          function parallelLimit(collection, limit) {
-            return new ParallelLimit(collection, limit)._execute();
-          }
-        },
-        { './internal/util': 39, './series': 66 }
-      ],
-      53: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./each');
-          var Each = ref.Each;
-          var ref$1 = require('./internal/collection');
-          var setPickShorthand = ref$1.setPickShorthand;
-
-          var Pick = /*@__PURE__*/ (function(Each) {
-            function Pick(collection, iterator, args) {
-              if (typeof iterator !== 'function') {
-                iterator = [iterator].concat(args);
-              }
-              Each.call(this, collection, iterator, set);
-              this._result = {};
-            }
-
-            if (Each) Pick.__proto__ = Each;
-            Pick.prototype = Object.create(Each && Each.prototype);
-            Pick.prototype.constructor = Pick;
-
-            return Pick;
-          })(Each);
-
-          module.exports = { pick: pick, Pick: Pick };
-
-          function set(collection) {
-            setPickShorthand.call(this, collection);
-            this._callResolve = this._keys === undefined ? callResolveArray : callResolveObject;
-            return this;
-          }
-
-          function callResolveArray(value, index) {
-            if (value) {
-              this._result[index] = this._coll[index];
-            }
-            if (--this._rest === 0) {
-              this._promise._resolve(this._result);
-            }
-          }
-
-          function callResolveObject(value, index) {
-            if (value) {
-              var key = this._keys[index];
-              this._result[key] = this._coll[key];
-            }
-            if (--this._rest === 0) {
-              this._promise._resolve(this._result);
-            }
-          }
-
-          /**
-           * `Aigle.pick` has almost the same functionality as [`Aigle.filter`](https://suguru03.github.io/aigle/docs/global.html#filter).
-           * It will return an object as a result.
-           * @param {Array|Object} collection
-           * @param {Function|Array|Object|string} iterator
-           * @param {*} [args]
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2;
-           *     });
-           * };
-           * Aigle.pick(collection, iterator)
-           *   .then(object => {
-           *     console.log(object); // { '0': 1 }
-           *     console.log(order); // [1, 2, 4]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = { a: 1, b: 4, c: 2 };
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num * 2;
-           *     });
-           * };
-           * Aigle.pick(collection, iterator)
-           *   .then(object => {
-           *     console.log(object); // { a: 1 }
-           *     console.log(order); // [1, 2, 4]
-           *   });
-           *
-           */
-          function pick(collection, iterator) {
-            var args = [],
-              len = arguments.length - 2;
-            while (len-- > 0) args[len] = arguments[len + 2];
-
-            return new Pick(collection, iterator, args)._execute();
-          }
-        },
-        { './each': 12, './internal/collection': 36 }
-      ],
-      54: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./each');
-          var Each = ref.Each;
-          var ref$1 = require('./internal/collection');
-          var setShorthand = ref$1.setShorthand;
-
-          var PickBy = /*@__PURE__*/ (function(Each) {
-            function PickBy(collection, iterator) {
-              Each.call(this, collection, iterator, set);
-              this._result = {};
-            }
-
-            if (Each) PickBy.__proto__ = Each;
-            PickBy.prototype = Object.create(Each && Each.prototype);
-            PickBy.prototype.constructor = PickBy;
-
-            return PickBy;
-          })(Each);
-
-          module.exports = { pickBy: pickBy, PickBy: PickBy };
-
-          function set(collection) {
-            setShorthand.call(this, collection);
-            this._callResolve = this._keys === undefined ? callResolveArray : callResolveObject;
-            return this;
-          }
-
-          function callResolveArray(value, index) {
-            if (value) {
-              this._result[index] = this._coll[index];
-            }
-            if (--this._rest === 0) {
-              this._promise._resolve(this._result);
-            }
-          }
-
-          function callResolveObject(value, index) {
-            if (value) {
-              var key = this._keys[index];
-              this._result[key] = this._coll[key];
-            }
-            if (--this._rest === 0) {
-              this._promise._resolve(this._result);
-            }
-          }
-
-          /**
-           * `Aigle.pickBy` has almost the same functionality as [`Aigle.filter`](https://suguru03.github.io/aigle/docs/global.html#filter).
-           * It will return an object as a result.
-           * @param {Array|Object} collection
-           * @param {Function|Array|Object|string} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2;
-           *     });
-           * };
-           * Aigle.pickBy(collection, iterator)
-           *   .then(object => {
-           *     console.log(object); // { '0': 1 }
-           *     console.log(order); // [1, 2, 4]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = { a: 1, b: 4, c: 2 };
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num * 2;
-           *     });
-           * };
-           * Aigle.pickBy(collection, iterator)
-           *   .then(object => {
-           *     console.log(object); // { a: 1 }
-           *     console.log(order); // [1, 2, 4]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [{
-           *   name: 'bargey', active: false
-           * }, {
-           *   name: 'fread', active: true
-           * }];
-           * Aigle.pickBy(collection, 'active')
-           *   .then(object => {
-           *     console.log(object); // { '1': { name: 'fread', active: true } }
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [{
-           *   name: 'bargey', active: false
-           * }, {
-           *   name: 'fread', active: true
-           * }];
-           * Aigle.pickBy(collection, ['name', 'fread'])
-           *   .then(object => {
-           *     console.log(object); // { '1': { name: 'fread', active: true } }
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [{
-           *   name: 'bargey', active: false
-           * }, {
-           *   name: 'fread', active: true
-           * }];
-           * Aigle.pickBy(collection, { name: 'fread', active: true })
-           *   .then(object => {
-           *     console.log(object); // { '1': { name: 'fread', active: true } }
-           *   });
-           */
-          function pickBy(collection, iterator) {
-            return new PickBy(collection, iterator)._execute();
-          }
-        },
-        { './each': 12, './internal/collection': 36 }
-      ],
-      55: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./eachLimit');
-          var EachLimit = ref.EachLimit;
-          var ref$1 = require('./internal/collection');
-          var setLimit = ref$1.setLimit;
-
-          var PickByLimit = /*@__PURE__*/ (function(EachLimit) {
-            function PickByLimit(collection, limit, iterator) {
-              EachLimit.call(this, collection, limit, iterator, set);
-              this._result = {};
-            }
-
-            if (EachLimit) PickByLimit.__proto__ = EachLimit;
-            PickByLimit.prototype = Object.create(EachLimit && EachLimit.prototype);
-            PickByLimit.prototype.constructor = PickByLimit;
-
-            return PickByLimit;
-          })(EachLimit);
-
-          module.exports = { pickByLimit: pickByLimit, PickByLimit: PickByLimit };
-
-          function set(collection) {
-            setLimit.call(this, collection);
-            this._callResolve = this._keys === undefined ? callResolveArray : callResolveObject;
-            return this;
-          }
-
-          function callResolveArray(value, index) {
-            if (value) {
-              this._result[index] = this._coll[index];
-            }
-            if (--this._rest === 0) {
-              this._promise._resolve(this._result);
-            } else if (this._callRest-- > 0) {
-              this._iterate();
-            }
-          }
-
-          function callResolveObject(value, index) {
-            if (value) {
-              var key = this._keys[index];
-              this._result[key] = this._coll[key];
-            }
-            if (--this._rest === 0) {
-              this._promise._resolve(this._result);
-            } else if (this._callRest-- > 0) {
-              this._iterate();
-            }
-          }
-
-          /**
-           * `Aigle.pickByLimit` is almost the as [`Aigle.pickBy`](https://suguru03.github.io/aigle/docs/Aigle.html#pickBy) and
-           * [`Aigle.pickBySeries`](https://suguru03.github.io/aigle/docs/Aigle.html#pickBySeries), but it will work with concurrency.
-           * @param {Array|Object} collection
-           * @param {integer} [limit=8]
-           * @param {Function} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 5, 3, 4, 2];
-           * const iterator = (num, index) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2;
-           *     });
-           * };
-           * Aigle.pickByLimit(collection, 2, iterator)
-           *   .then(object => {
-           *     console.log(object); // { '0': 1, '1': 5, '2': 3 }
-           *     console.log(order); // [1, 3, 5, 2, 4]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = { a: 1, b: 5, c: 3, d: 4, e: 2 };
-           * const iterator = (num, key) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2;
-           *     });
-           * };
-           * Aigle.pickByLimit(collection, 2, iterator)
-           *   .then(object => {
-           *     console.log(object); // { a: 1, b: 5, c: 3 }
-           *     console.log(order); // [1, 3, 5, 2, 4]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [1, 5, 3, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2;
-           *     });
-           * };
-           * Aigle.pickByLimit(collection, iterator)
-           *   .then(object => {
-           *     console.log(object); // { '0': 1, '1': 5, '2': 3 }
-           *     console.log(order); // [1, 2, 3, 4, 5]
-           *   });
-           */
-          function pickByLimit(collection, limit, iterator) {
-            return new PickByLimit(collection, limit, iterator)._execute();
-          }
-        },
-        { './eachLimit': 13, './internal/collection': 36 }
-      ],
-      56: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./eachSeries');
-          var EachSeries = ref.EachSeries;
-          var ref$1 = require('./internal/collection');
-          var setSeries = ref$1.setSeries;
-
-          var PickBySeries = /*@__PURE__*/ (function(EachSeries) {
-            function PickBySeries(collection, iterator) {
-              EachSeries.call(this, collection, iterator, set);
-              this._result = {};
-            }
-
-            if (EachSeries) PickBySeries.__proto__ = EachSeries;
-            PickBySeries.prototype = Object.create(EachSeries && EachSeries.prototype);
-            PickBySeries.prototype.constructor = PickBySeries;
-
-            return PickBySeries;
-          })(EachSeries);
-
-          module.exports = { pickBySeries: pickBySeries, PickBySeries: PickBySeries };
-
-          function set(collection) {
-            setSeries.call(this, collection);
-            this._callResolve = this._keys === undefined ? callResolveArray : callResolveObject;
-            return this;
-          }
-
-          function callResolveArray(value, index) {
-            if (value) {
-              this._result[index] = this._coll[index];
-            }
-            if (--this._rest === 0) {
-              this._promise._resolve(this._result);
-            } else {
-              this._iterate();
-            }
-          }
-
-          function callResolveObject(value, index) {
-            if (value) {
-              var key = this._keys[index];
-              this._result[key] = this._coll[key];
-            }
-            if (--this._rest === 0) {
-              this._promise._resolve(this._result);
-            } else {
-              this._iterate();
-            }
-          }
-
-          /**
-           * `Aigle.pickBySeries` is almost the as [`Aigle.pickBy`](https://suguru03.github.io/aigle/docs/Aigle.html#pickBy), but it will work in series.
-           * @param {Array|Object} collection
-           * @param {Function} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2;
-           *     });
-           * };
-           * Aigle.pickBySeries(collection, iterator)
-           *   .then(object => {
-           *     console.log(object); // { '0': 1 }
-           *     console.log(order); // [1, 4, 2]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = { a: 1, b: 4, c: 2 };
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num * 2;
-           *     });
-           * };
-           * Aigle.pickBySeries(collection, iterator)
-           *   .then(object => {
-           *     console.log(object); // { a: 1 }
-           *     console.log(order); // [1, 4, 2]
-           *   });
-           */
-          function pickBySeries(collection, iterator) {
-            return new PickBySeries(collection, iterator)._execute();
-          }
-        },
-        { './eachSeries': 14, './internal/collection': 36 }
-      ],
-      57: [
-        function(require, module, exports) {
-          'use strict';
-
-          var Aigle = require('./aigle');
-          var ref = require('./internal/util');
-          var INTERNAL = ref.INTERNAL;
-          var callThen = ref.callThen;
-
-          var globalSetImmediate = typeof setImmediate === 'function' ? setImmediate : {};
-          var custom =
-            (function() {
-              try {
-                return require('util').promisify.custom;
-              } catch (e) {
-                return;
-              }
-            })() || {};
-
-          module.exports = promisify;
-
-          /**
-           * @param {Object|Function} fn
-           * @param {string|number|Object} [fn]
-           * @param {Object} [fn.context]
-           * @example
-           * const func = (a, b, c, callback) => callback(null, a + b + c);
-           * Aigle.promisify(func)(1, 2, 3)
-           *   .then(value => console.log(value)); // 6
-           *
-           * @example
-           * const obj = {
-           *   val: 1,
-           *   get(callback) {
-           *     callback(null, this.val);
-           *   }
-           * };
-           *
-           * // using bind
-           * Aigle.promisify(obj.get.bind(obj))().then(console.log);
-           *
-           * // using context
-           * Aigle.promisify(obj.get, { context: obj })().then(console.log);
-           *
-           * // using shorthand
-           * Aigle.promisify(obj, 'get')().then(console.log);
-           */
-          function promisify(fn, opts) {
-            switch (typeof fn) {
-              case 'object':
-                switch (typeof opts) {
-                  case 'string':
-                  case 'number':
-                    if (typeof fn[opts] !== 'function') {
-                      throw new TypeError('Function not found key: ' + opts);
-                    }
-                    if (fn[opts].__isPromisified__) {
-                      return fn[opts];
-                    }
-                    return makeFunctionByKey(fn, opts);
-                  default:
-                    throw new TypeError('Second argument is invalid');
-                }
-              case 'function':
-                if (fn.__isPromisified__) {
-                  return fn;
-                }
-                var ctx = opts && opts.context !== undefined ? opts.context : undefined;
-                return makeFunction(fn, ctx);
-              default:
-                throw new TypeError('Type of first argument is not function');
-            }
-          }
-
-          /**
-           * @private
-           * @param {Aigle} promise
-           */
-          function makeCallback(promise) {
-            return function(err, res) {
-              return err ? promise._reject(err) : promise._resolve(res);
-            };
-          }
-
-          /**
-           * @private
-           * @param {Object} obj
-           * @param {string} key
-           */
-          function makeFunctionByKey(obj, key) {
-            promisified.__isPromisified__ = true;
-            return promisified;
-
-            function promisified(arg) {
-              var arguments$1 = arguments;
-
-              var promise = new Aigle(INTERNAL);
-              var callback = makeCallback(promise);
-              var l = arguments.length;
-              switch (l) {
-                case 0:
-                  obj[key](callback);
-                  break;
-                case 1:
-                  obj[key](arg, callback);
-                  break;
-                default:
-                  var args = Array(l);
-                  while (l--) {
-                    args[l] = arguments$1[l];
-                  }
-                  args[args.length] = callback;
-                  obj[key].apply(obj, args);
-                  break;
-              }
-              return promise;
-            }
-          }
-
-          /**
-           * @private
-           * @param {function} fn
-           * @param {*} [ctx]
-           */
-          function makeFunction(fn, ctx) {
-            var func = fn[custom];
-            if (func) {
-              nativePromisified.__isPromisified__ = true;
-              return nativePromisified;
-            }
-            switch (fn) {
-              case setTimeout:
-                return Aigle.delay;
-              case globalSetImmediate:
-                return Aigle.resolve;
-            }
-            promisified.__isPromisified__ = true;
-            return promisified;
-
-            function nativePromisified(arg) {
-              var arguments$1 = arguments;
-
-              var promise = new Aigle(INTERNAL);
-              var l = arguments.length;
-              var p;
-              switch (l) {
-                case 0:
-                  p = func.call(ctx || this);
-                  break;
-                case 1:
-                  p = func.call(ctx || this, arg);
-                  break;
-                default:
-                  var args = Array(l);
-                  while (l--) {
-                    args[l] = arguments$1[l];
-                  }
-                  p = func.apply(ctx || this, args);
-                  break;
-              }
-              callThen(p, promise);
-              return promise;
-            }
-
-            function promisified(arg) {
-              var arguments$1 = arguments;
-
-              var promise = new Aigle(INTERNAL);
-              var callback = makeCallback(promise);
-              var l = arguments.length;
-              switch (l) {
-                case 0:
-                  fn.call(ctx || this, callback);
-                  break;
-                case 1:
-                  fn.call(ctx || this, arg, callback);
-                  break;
-                default:
-                  var args = Array(l);
-                  while (l--) {
-                    args[l] = arguments$1[l];
-                  }
-                  args[args.length] = callback;
-                  fn.apply(ctx || this, args);
-                  break;
-              }
-              return promise;
-            }
-          }
-        },
-        { './aigle': 2, './internal/util': 39, util: 90 }
-      ],
-      58: [
-        function(require, module, exports) {
-          'use strict';
-
-          var promisify = require('./promisify');
-          var skipMap = {
-            constructor: true,
-            arity: true,
-            length: true,
-            name: true,
-            arguments: true,
-            caller: true,
-            callee: true,
-            prototype: true,
-            __isPromisified__: true
-          };
-
-          module.exports = promisifyAll;
-
-          /**
-           * @param {Object} target
-           * @param {Object} [opts]
-           * @param {String} [opts.suffix=Async]
-           * @param {Function} [opts.filter]
-           * @param {Integer} [opts.depth=2]
-           * @example
-           * const redis = require('redis');
-           * Aigle.promisifyAll(redis);
-           * const client = redis.createClient();
-           *
-           * const key = 'test';
-           * redis.hsetAsync(key, 1)
-           *   .then(() => redis.hgetAsync(key))
-           *   .then(value => console.log(value)); // 1
-           */
-          function promisifyAll(target, opts) {
-            var ref = opts || {};
-            var suffix = ref.suffix;
-            if (suffix === void 0) suffix = 'Async';
-            var filter = ref.filter;
-            if (filter === void 0) filter = defaultFilter;
-            var depth = ref.depth;
-            if (depth === void 0) depth = 2;
-            _promisifyAll(suffix, filter, target, undefined, undefined, depth);
-            return target;
-          }
-
-          function defaultFilter(name) {
-            return /^(?!_).*/.test(name);
-          }
-
-          function _promisifyAll(suffix, filter, obj, key, target, depth) {
-            var memo = {};
-            switch (typeof obj) {
-              case 'function':
-                if (target) {
-                  if (obj.__isPromisified__) {
-                    return;
-                  }
-                  var _key = '' + key + suffix;
-                  if (target[_key]) {
-                    if (!target[_key].__isPromisified__) {
-                      throw new TypeError(
-                        "Cannot promisify an API that has normal methods with '" +
-                          suffix +
-                          "'-suffix"
-                      );
-                    }
-                  } else {
-                    target[_key] = promisify(obj);
-                  }
-                }
-                iterate(suffix, filter, obj, obj, depth, memo);
-                iterate(suffix, filter, obj.prototype, obj.prototype, depth, memo);
-                break;
-              case 'object':
-                if (!obj) {
-                  break;
-                }
-                iterate(suffix, filter, obj, obj, depth, memo);
-                iterate(suffix, filter, Object.getPrototypeOf(obj), obj, depth, memo);
-            }
-          }
-
-          var fp = Function.prototype;
-          var op = Object.prototype;
-          var ap = Array.prototype;
-
-          function iterate(suffix, filter, obj, target, depth, memo) {
-            if (
-              depth-- === 0 ||
-              !obj ||
-              fp === obj ||
-              op === obj ||
-              ap === obj ||
-              Object.isFrozen(obj)
-            ) {
-              return;
-            }
-            var keys = Object.getOwnPropertyNames(obj);
-            var l = keys.length;
-            while (l--) {
-              var key = keys[l];
-              if (skipMap[key] === true || memo[key] === true || !filter(key)) {
-                continue;
-              }
-              var desc = Object.getOwnPropertyDescriptor(obj, key);
-              if (!desc || desc.set || desc.get) {
-                continue;
-              }
-              memo[key] = true;
-              _promisifyAll(suffix, filter, obj[key], key, target, depth);
-            }
-          }
-        },
-        { './promisify': 57 }
-      ],
-      59: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('aigle-core');
-          var AigleProxy = ref.AigleProxy;
-
-          var Aigle = require('./aigle');
-          var ref$1 = require('./internal/util');
-          var INTERNAL = ref$1.INTERNAL;
-          var PENDING = ref$1.PENDING;
-          var promiseObjectEach = ref$1.promiseObjectEach;
-          var promiseMapEach = ref$1.promiseMapEach;
-
-          var Props = /*@__PURE__*/ (function(AigleProxy) {
-            function Props(coll) {
-              AigleProxy.call(this);
-              this._promise = new Aigle(INTERNAL);
-              this._rest = 0;
-              this._result = undefined;
-              if (coll === PENDING) {
-                this._callResolve = this._set;
-              } else {
-                this._callResolve = undefined;
-                this._set(coll);
-              }
-            }
-
-            if (AigleProxy) Props.__proto__ = AigleProxy;
-            Props.prototype = Object.create(AigleProxy && AigleProxy.prototype);
-            Props.prototype.constructor = Props;
-
-            Props.prototype._set = function _set(coll) {
-              if (typeof coll !== 'object' || coll === null) {
-                this._result = {};
-              } else if (coll instanceof Map) {
-                var result = new Map();
-                this._result = result;
-                this._rest = coll.size;
-                this._callResolve = callResolveMap;
-                promiseMapEach(this, Infinity, coll, result);
-              } else {
-                var keys = Object.keys(coll);
-                var size = keys.length;
-                var result$1 = {};
-                this._result = result$1;
-                this._rest = size;
-                this._callResolve = callResolve;
-                promiseObjectEach(this, size, coll, result$1, keys);
-              }
-              if (this._rest === 0) {
-                this._promise._resolve(this._result);
-              }
-              return this;
-            };
-
-            Props.prototype._execute = function _execute() {
-              return this._promise;
-            };
-
-            Props.prototype._callReject = function _callReject(reason) {
-              this._promise._reject(reason);
-            };
-
-            return Props;
-          })(AigleProxy);
-
-          module.exports = {
-            props: props,
-            Props: Props,
-            callResolve: callResolve,
-            callResolveMap: callResolveMap
-          };
-
-          function callResolve(value, key) {
-            this._result[key] = value;
-            if (--this._rest === 0) {
-              this._promise._resolve(this._result);
-            }
-          }
-
-          function callResolveMap(value, key) {
-            this._result.set(key, value);
-            if (--this._rest === 0) {
-              this._promise._resolve(this._result);
-            }
-          }
-
-          /**
-           * `Aigle.props` is almost the same functionality as [`Aigle.all`](https://suguru03.github.io/aigle/docs/global.html#all)
-           * But the function allows an object as the first argument instead of an array.
-           * @param {Object} object
-           * @example
-           * const order = [];
-           * const makeDelay = (num, delay) => {
-           *   return Aigle.delay(delay)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num;
-           *     });
-           * };
-           * Aigle.props({
-           *   a: makeDelay(1, 30),
-           *   b: makeDelay(2, 20),
-           *   c: makeDelay(3, 10)
-           * })
-           * .then(object => {
-           *   console.log(object); // { a: 1, b: 2, c: 3 }
-           *   console.log(order); // [3, 2, 1]
-           * });
-           */
-          function props(object) {
-            return new Props(object)._promise;
-          }
-        },
-        { './aigle': 2, './internal/util': 39, 'aigle-core': 85 }
-      ],
-      60: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('aigle-core');
-          var AigleProxy = ref.AigleProxy;
-
-          var Aigle = require('./aigle');
-          var ref$1 = require('./internal/util');
-          var INTERNAL = ref$1.INTERNAL;
-          var PENDING = ref$1.PENDING;
-          var promiseArrayEach = ref$1.promiseArrayEach;
-          var promiseObjectEach = ref$1.promiseObjectEach;
-          var promiseMapEach = ref$1.promiseMapEach;
-          var promiseSetEach = ref$1.promiseSetEach;
-          var iteratorSymbol = ref$1.iteratorSymbol;
-
-          var Race = /*@__PURE__*/ (function(AigleProxy) {
-            function Race(coll) {
-              AigleProxy.call(this);
-              this._promise = new Aigle(INTERNAL);
-              this._keys = undefined;
-              if (coll === PENDING) {
-                this._callResolve = this._set;
-              } else {
-                this._callResolve = undefined;
-                this._set(coll);
-              }
-            }
-
-            if (AigleProxy) Race.__proto__ = AigleProxy;
-            Race.prototype = Object.create(AigleProxy && AigleProxy.prototype);
-            Race.prototype.constructor = Race;
-
-            Race.prototype._set = function _set(coll) {
-              this._callResolve = callResolve;
-              if (Array.isArray(coll)) {
-                promiseArrayEach(this, coll.length, coll);
-              } else if (!coll || typeof coll !== 'object') {
-              } else if (coll[iteratorSymbol]) {
-                coll instanceof Map
-                  ? promiseMapEach(this, Infinity, coll, new Map())
-                  : promiseSetEach(this, Infinity, coll);
-              } else {
-                var keys = Object.keys(coll);
-                promiseObjectEach(this, keys.length, coll, {}, keys);
-              }
-              return this;
-            };
-
-            Race.prototype._execute = function _execute() {
-              return this._promise;
-            };
-
-            Race.prototype._callReject = function _callReject(reason) {
-              this._promise._reject(reason);
-            };
-
-            return Race;
-          })(AigleProxy);
-
-          module.exports = { race: race, Race: Race };
-
-          function callResolve(value) {
-            this._promise._resolve(value);
-          }
-
-          /**
-           * @param {Object|Array} collection
-           * @example
-           * Aigle.race([
-           *   new Aigle(resolve => setTimeout(() => resolve(1), 30)),
-           *   new Aigle(resolve => setTimeout(() => resolve(2), 20)),
-           *   new Aigle(resolve => setTimeout(() => resolve(3), 10))
-           * ])
-           * .then(value => console.log(value)); // 3
-           *
-           * @example
-           * Aigle.race({
-           *   a: new Aigle(resolve => setTimeout(() => resolve(1), 30)),
-           *   b: new Aigle(resolve => setTimeout(() => resolve(2), 20)),
-           *   c: new Aigle(resolve => setTimeout(() => resolve(3), 10))
-           * })
-           * .then(value => console.log(value)); // 3
-           */
-          function race(collection) {
-            return new Race(collection)._promise;
-          }
-        },
-        { './aigle': 2, './internal/util': 39, 'aigle-core': 85 }
-      ],
-      61: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('aigle-core');
-          var AigleProxy = ref.AigleProxy;
-
-          var Aigle = require('./aigle');
-          var ref$1 = require('./internal/collection');
-          var execute = ref$1.execute;
-          var setSeries = ref$1.setSeries;
-          var ref$2 = require('./internal/util');
-          var INTERNAL = ref$2.INTERNAL;
-          var PENDING = ref$2.PENDING;
-          var call3 = ref$2.call3;
-          var callProxyReciever = ref$2.callProxyReciever;
-
-          var Reduce = /*@__PURE__*/ (function(AigleProxy) {
-            function Reduce(collection, iterator, result) {
-              AigleProxy.call(this);
-              this._result = result;
-              this._iterator = iterator;
-              this._promise = new Aigle(INTERNAL);
-              this._coll = undefined;
-              this._rest = undefined;
-              this._size = undefined;
-              this._keys = undefined;
-              this._iterate = undefined;
-              if (collection === PENDING) {
-                this._set = set;
-                this._iterate = this._callResolve;
-                this._callResolve = execute;
-              } else {
-                set.call(this, collection);
-              }
-            }
-
-            if (AigleProxy) Reduce.__proto__ = AigleProxy;
-            Reduce.prototype = Object.create(AigleProxy && AigleProxy.prototype);
-            Reduce.prototype.constructor = Reduce;
-
-            Reduce.prototype._callResolve = function _callResolve(result, index) {
-              if (--this._rest === 0) {
-                this._promise._resolve(result);
-              } else {
-                this._iterate(++index, result);
-              }
-            };
-
-            Reduce.prototype._callReject = function _callReject(reason) {
-              this._promise._reject(reason);
-            };
-
-            return Reduce;
-          })(AigleProxy);
-
-          module.exports = { reduce: reduce, Reduce: Reduce };
-
-          function set(collection) {
-            setSeries.call(this, collection);
-            if (this._keys === undefined) {
-              this._iterate = iterateArray;
-              this._execute = executeArray;
-            } else {
-              this._iterate = iterateObject;
-              this._execute = executeObject;
-            }
-            return this;
-          }
-
-          function iterateArray(index, result) {
-            callProxyReciever(call3(this._iterator, result, this._coll[index], index), this, index);
-          }
-
-          function iterateObject(index, result) {
-            var key = this._keys[index];
-            callProxyReciever(call3(this._iterator, result, this._coll[key], key), this, index);
-          }
-
-          function executeArray() {
-            if (this._rest === 0) {
-              this._promise._resolve(this._result);
-            } else if (this._result === undefined) {
-              this._callResolve(this._coll[0], 0);
-            } else {
-              this._iterate(0, this._result);
-            }
-            return this._promise;
-          }
-
-          function executeObject() {
-            if (this._rest === 0) {
-              this._promise._resolve(this._result);
-            } else if (this._result === undefined) {
-              this._callResolve(this._coll[this._keys[0]], 0);
-            } else {
-              this._iterate(0, this._result);
-            }
-            return this._promise;
-          }
-
-          /**
-           * @param {Array|Object} collection
-           * @param {Function} iterator
-           * @param {*} [result]
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const collection = [1, 4, 2];
-           * const iterator = (result, num, index) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => result + num);
-           * };
-           * return Aigle.reduce(collection, iterator, 1)
-           *   .then(value => console.log(value)); // 8
-           *
-           * @example
-           * const collection = { a: 1, b: 4, c: 2 };
-           * const iterator = (result, num, key) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => result + num);
-           * };
-           * return Aigle.reduce(collection, iterator, '')
-           *   .then(value => console.log(value)); // '142'
-           */
-          function reduce(collection, iterator, result) {
-            return new Reduce(collection, iterator, result)._execute();
-          }
-        },
-        { './aigle': 2, './internal/collection': 36, './internal/util': 39, 'aigle-core': 85 }
-      ],
-      62: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./each');
-          var Each = ref.Each;
-          var ref$1 = require('./internal/collection');
-          var setShorthand = ref$1.setShorthand;
-          var ref$2 = require('./internal/util');
-          var INTERNAL = ref$2.INTERNAL;
-          var compactArray = ref$2.compactArray;
-
-          var Reject = /*@__PURE__*/ (function(Each) {
-            function Reject(collection, iterator) {
-              Each.call(this, collection, iterator, set);
-            }
-
-            if (Each) Reject.__proto__ = Each;
-            Reject.prototype = Object.create(Each && Each.prototype);
-            Reject.prototype.constructor = Reject;
-
-            return Reject;
-          })(Each);
-
-          module.exports = { reject: reject, Reject: Reject };
-
-          function set(collection) {
-            setShorthand.call(this, collection);
-            this._result = Array(this._rest);
-            this._callResolve = this._keys === undefined ? callResolveArray : callResolveObject;
-            return this;
-          }
-
-          function callResolveArray(value, index) {
-            this._result[index] = value ? INTERNAL : this._coll[index];
-            if (--this._rest === 0) {
-              this._promise._resolve(compactArray(this._result));
-            }
-          }
-
-          function callResolveObject(value, index) {
-            this._result[index] = value ? INTERNAL : this._coll[this._keys[index]];
-            if (--this._rest === 0) {
-              this._promise._resolve(compactArray(this._result));
-            }
-          }
-
-          /**
-           * Aigle reject has two features.
-           * One of them is basic [`Promise.reject`](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Promise/reject) function, it returns a rejected Aigle instance.
-           * The other is a collection function, it requires an iterator function. It is the opposite of [`filter`](https://suguru03.github.io/aigle/docs/Aigle.html#filter).
-           * If the iterator function is not defined, the function works as a first one.
-           *
-           * @param {Function|Array|Object} collection
-           * @param {Function|Array|Object|string} [iterator]
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const error = new Error('error');
-           * Aigle.reject(error)
-           *   .catch(error => {
-           *     console.log(error); // error
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = (num, index) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2;
-           *     });
-           * };
-           * Aigle.reject(collection, iterator)
-           *   .then(array => {
-           *     console.log(array); // [4, 2];
-           *     console.log(order); // [1, 2, 4];
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = { a: 1, b: 4, c: 2 };
-           * const iterator = (num, key) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2;
-           *     });
-           * };
-           * Aigle.reject(collection, iterator)
-           *   .then(array => {
-           *     console.log(array); // [4, 2];
-           *     console.log(order); // [1, 2, 4];
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [{
-           *   name: 'bargey', active: false
-           * }, {
-           *   name: 'fread', active: true
-           * }];
-           * Aigle.reject(collection, 'active')
-           *   .then(array => {
-           *     console.log(array); // [{ name: 'fread', active: false }]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [{
-           *   name: 'bargey', active: false
-           * }, {
-           *   name: 'fread', active: true
-           * }];
-           * Aigle.reject(collection, ['name', 'bargey'])
-           *   .then(array => {
-           *     console.log(array); // [{ name: 'fread', active: false }]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [{
-           *   name: 'bargey', active: false
-           * }, {
-           *   name: 'fread', active: true
-           * }];
-           * Aigle.reject(collection, { name: 'bargey', active: false })
-           *   .then(array => {
-           *     console.log(array); // [{ name: 'fread', active: false }]
-           *   });
-           */
-          function reject(collection, iterator) {
-            return new Reject(collection, iterator)._execute();
-          }
-        },
-        { './each': 12, './internal/collection': 36, './internal/util': 39 }
-      ],
-      63: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./eachLimit');
-          var EachLimit = ref.EachLimit;
-          var ref$1 = require('./internal/collection');
-          var setLimit = ref$1.setLimit;
-          var ref$2 = require('./internal/util');
-          var INTERNAL = ref$2.INTERNAL;
-          var compactArray = ref$2.compactArray;
-
-          var RejectLimit = /*@__PURE__*/ (function(EachLimit) {
-            function RejectLimit(collection, limit, iterator) {
-              EachLimit.call(this, collection, limit, iterator, set);
-            }
-
-            if (EachLimit) RejectLimit.__proto__ = EachLimit;
-            RejectLimit.prototype = Object.create(EachLimit && EachLimit.prototype);
-            RejectLimit.prototype.constructor = RejectLimit;
-
-            return RejectLimit;
-          })(EachLimit);
-
-          module.exports = { rejectLimit: rejectLimit, RejectLimit: RejectLimit };
-
-          function set(collection) {
-            setLimit.call(this, collection);
-            this._result = Array(this._rest);
-            this._callResolve = this._keys === undefined ? callResolveArray : callResolveObject;
-            return this;
-          }
-
-          function callResolveArray(value, index) {
-            this._result[index] = value ? INTERNAL : this._coll[index];
-            if (--this._rest === 0) {
-              this._promise._resolve(compactArray(this._result));
-            } else if (this._callRest-- > 0) {
-              this._iterate();
-            }
-          }
-
-          function callResolveObject(value, index) {
-            this._result[index] = value ? INTERNAL : this._coll[this._keys[index]];
-            if (--this._rest === 0) {
-              this._promise._resolve(compactArray(this._result));
-            } else if (this._callRest-- > 0) {
-              this._iterate();
-            }
-          }
-
-          /**
-           * @param {Array|Object} collection
-           * @param {integer} [limit=8]
-           * @param {Function} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 5, 3, 4, 2];
-           * const iterator = (num, index) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2;
-           *     });
-           * };
-           * Aigle.rejectLimit(collection, 2, iterator)
-           *   .then(array => {
-           *     console.log(array); // [4, 2]
-           *     console.log(order); // [1, 3, 5, 2, 4]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = { a: 1, b: 5, c: 3, d: 4, e: 2 };
-           * const iterator = (num, key) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2;
-           *     });
-           * };
-           * Aigle.rejectLimit(collection, 2, iterator)
-           *   .then(array => {
-           *     console.log(array); // [4, 2]
-           *     console.log(order); // [1, 3, 5, 2, 4]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [1, 5, 3, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2;
-           *     });
-           * };
-           * Aigle.rejectLimit(collection, iterator)
-           *   .then(array => {
-           *     console.log(array); // [4, 2]
-           *     console.log(order); // [1, 2, 3, 4, 5]
-           *   });
-           */
-          function rejectLimit(collection, limit, iterator) {
-            return new RejectLimit(collection, limit, iterator)._execute();
-          }
-        },
-        { './eachLimit': 13, './internal/collection': 36, './internal/util': 39 }
-      ],
-      64: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./eachSeries');
-          var EachSeries = ref.EachSeries;
-          var ref$1 = require('./internal/collection');
-          var setSeries = ref$1.setSeries;
-          var ref$2 = require('./internal/util');
-          var INTERNAL = ref$2.INTERNAL;
-          var compactArray = ref$2.compactArray;
-
-          var RejectSeries = /*@__PURE__*/ (function(EachSeries) {
-            function RejectSeries(collection, iterator) {
-              EachSeries.call(this, collection, iterator, set);
-            }
-
-            if (EachSeries) RejectSeries.__proto__ = EachSeries;
-            RejectSeries.prototype = Object.create(EachSeries && EachSeries.prototype);
-            RejectSeries.prototype.constructor = RejectSeries;
-
-            return RejectSeries;
-          })(EachSeries);
-
-          module.exports = { rejectSeries: rejectSeries, RejectSeries: RejectSeries };
-
-          function set(collection) {
-            setSeries.call(this, collection);
-            this._result = Array(this._rest);
-            this._callResolve = this._keys === undefined ? callResolveArray : callResolveObject;
-            return this;
-          }
-
-          function callResolveArray(value, index) {
-            this._result[index] = value ? INTERNAL : this._coll[index];
-            if (--this._rest === 0) {
-              this._promise._resolve(compactArray(this._result));
-            } else {
-              this._iterate();
-            }
-          }
-
-          function callResolveObject(value, index) {
-            this._result[index] = value ? INTERNAL : this._coll[this._keys[index]];
-            if (--this._rest === 0) {
-              this._promise._resolve(compactArray(this._result));
-            } else {
-              this._iterate();
-            }
-          }
-
-          /**
-           * @param {Array|Object} collection
-           * @param {Function} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = (num, index) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2;
-           *     });
-           * };
-           * Aigle.rejectSeries(collection, iterator)
-           *   .then(array => {
-           *     console.log(array); // [4, 2];
-           *     console.log(order); // [1, 4, 2];
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = { a: 1, b: 4, c: 2 };
-           * const iterator = (num, key) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2;
-           *     });
-           * };
-           * Aigle.rejectSeries(collection, iterator)
-           *   .then(array => {
-           *     console.log(array); // [4, 2];
-           *     console.log(order); // [1, 4, 2];
-           *   });
-           */
-          function rejectSeries(collection, iterator) {
-            return new RejectSeries(collection, iterator)._execute();
-          }
-        },
-        { './eachSeries': 14, './internal/collection': 36, './internal/util': 39 }
-      ],
-      65: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('aigle-core');
-          var AigleProxy = ref.AigleProxy;
-
-          var Aigle = require('./aigle');
-          var ref$1 = require('./internal/util');
-          var INTERNAL = ref$1.INTERNAL;
-          var call0 = ref$1.call0;
-          var callProxyReciever = ref$1.callProxyReciever;
-          var DEFAULT_RETRY = 5;
-
-          var Retry = /*@__PURE__*/ (function(AigleProxy) {
-            function Retry(opts, handler) {
-              AigleProxy.call(this);
-              this._promise = new Aigle(INTERNAL);
-              this._handler = handler;
-              this._count = 0;
-              this._times = DEFAULT_RETRY;
-              this._interval = undefined;
-              switch (opts && typeof opts) {
-                case 'function':
-                  this._handler = opts;
-                  break;
-                case 'object':
-                  var interval = opts.interval;
-                  var times = opts.times;
-                  this._times = times || DEFAULT_RETRY;
-                  this._interval =
-                    typeof interval === 'function'
-                      ? interval
-                      : interval
-                        ? function() {
-                            return interval;
-                          }
-                        : undefined;
-                  this._iterate = this._iterate.bind(this);
-                  break;
-                default:
-                  this._times = opts;
-                  break;
-              }
-              this._iterate();
-            }
-
-            if (AigleProxy) Retry.__proto__ = AigleProxy;
-            Retry.prototype = Object.create(AigleProxy && AigleProxy.prototype);
-            Retry.prototype.constructor = Retry;
-
-            Retry.prototype._iterate = function _iterate() {
-              callProxyReciever(call0(this._handler), this, undefined);
-            };
-
-            Retry.prototype._callResolve = function _callResolve(value) {
-              this._promise._resolve(value);
-            };
-
-            Retry.prototype._callReject = function _callReject(reason) {
-              if (++this._count === this._times) {
-                this._promise._reject(reason);
-              } else if (this._interval !== undefined) {
-                setTimeout(this._iterate, this._interval(this._count));
-              } else {
-                this._iterate();
-              }
-            };
-
-            return Retry;
-          })(AigleProxy);
-
-          module.exports = retry;
-
-          /**
-           * @param {Integer|Object} [times=5]
-           * @param {Function} handler
-           * @example
-           * let called = 0;
-           * Aigle.retry(3, () => {
-           *   return new Aigle((resolve, reject) => {
-           *     setTimeout(() => reject(++called), 10);
-           *   });
-           * })
-           * .catch(error => {
-           *   console.log(error); // 3
-           *   console.log(called); // 3
-           * });
-           *
-           * @example
-           * let called = 0;
-           * Aigle.retry(() => {
-           *   return new Aigle((resolve, reject) => {
-           *     setTimeout(() => reject(++called), 10);
-           *   });
-           * })
-           * .catch(error => {
-           *   console.log(error); // 5
-           *   console.log(called); // 5
-           * });
-           *
-           * @example
-           * let called = 0;
-           * const opts = {
-           *   times: 5,
-           *   interval: 10
-           * };
-           * Aigle.retry(opts, () => {
-           *   return new Aigle((resolve, reject) => {
-           *     setTimeout(() => reject(++called), 10);
-           *   });
-           * })
-           * .catch(error => {
-           *   console.log(error); // 5
-           *   console.log(called); // 5
-           * });
-           *
-           * @example
-           * let called = 0;
-           * const opts = {
-           *   times: 5,
-           *   interval: c => c * 2;
-           * };
-           * Aigle.retry(opts, () => {
-           *   return new Aigle((resolve, reject) => {
-           *     setTimeout(() => reject(++called), 10);
-           *   });
-           * })
-           * .catch(error => {
-           *   console.log(error); // 5
-           *   console.log(called); // 5
-           * });
-           */
-          function retry(opts, handler) {
-            return new Retry(opts, handler)._promise;
-          }
-        },
-        { './aigle': 2, './internal/util': 39, 'aigle-core': 85 }
-      ],
-      66: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('aigle-core');
-          var AigleProxy = ref.AigleProxy;
-
-          var Aigle = require('./aigle');
-          var ref$1 = require('./internal/util');
-          var INTERNAL = ref$1.INTERNAL;
-          var PENDING = ref$1.PENDING;
-          var promiseArrayIterator = ref$1.promiseArrayIterator;
-          var promiseObjectIterator = ref$1.promiseObjectIterator;
-          var promiseSetIterator = ref$1.promiseSetIterator;
-          var promiseMapIterator = ref$1.promiseMapIterator;
-          var iteratorSymbol = ref$1.iteratorSymbol;
-          var ref$2 = require('./internal/collection');
-          var execute = ref$2.execute;
-
-          var Series = /*@__PURE__*/ (function(AigleProxy) {
-            function Series(coll) {
-              AigleProxy.call(this);
-              this._promise = new Aigle(INTERNAL);
-              this._index = -1;
-              this._coll = undefined;
-              this._keys = undefined;
-              this._rest = undefined;
-              this._result = undefined;
-              this._iterate = undefined;
-              if (coll === PENDING) {
-                this._set = set;
-                this._iterate = this._callResolve;
-                this._callResolve = execute;
-              } else {
-                set.call(this, coll);
-              }
-            }
-
-            if (AigleProxy) Series.__proto__ = AigleProxy;
-            Series.prototype = Object.create(AigleProxy && AigleProxy.prototype);
-            Series.prototype.constructor = Series;
-
-            Series.prototype._execute = function _execute() {
-              this._iterate();
-              return this._promise;
-            };
-
-            Series.prototype._callResolve = function _callResolve(value, key) {
-              this._result[key] = value;
-              this._iterate();
-            };
-
-            Series.prototype._callResolveMap = function _callResolveMap(value, key) {
-              this._result.set(key, value);
-              this._iterate();
-            };
-
-            Series.prototype._callReject = function _callReject(reason) {
-              this._promise._reject(reason);
-            };
-
-            return Series;
-          })(AigleProxy);
-
-          module.exports = { series: series, Series: Series };
-
-          function set(coll) {
-            this._coll = coll;
-            this._iterate = iterate;
-            if (Array.isArray(coll)) {
-              var size = coll.length;
-              this._rest = size;
-              this._result = Array(size);
-              this._iterator = promiseArrayIterator;
-            } else if (typeof coll !== 'object' || coll === null) {
-              this._rest = 0;
-              this._result = undefined;
-            } else if (coll[iteratorSymbol]) {
-              this._coll = coll[iteratorSymbol]();
-              var size$1 = coll.size;
-              this._rest = size$1;
-              if (coll instanceof Map) {
-                var result = new Map();
-                this._result = result;
-                this._callResolve = this._callResolveMap;
-                this._iterator = promiseMapIterator;
-              } else {
-                this._result = [];
-                this._iterator = promiseSetIterator;
-              }
-            } else {
-              var result$1 = {};
-              var keys = Object.keys(coll);
-              this._rest = keys.length;
-              this._keys = keys;
-              this._result = result$1;
-              this._iterator = promiseObjectIterator;
-            }
-            return this;
-          }
-
-          function iterate() {
-            if (++this._index === this._rest) {
-              this._promise._resolve(this._result);
-            } else {
-              this._iterator(this, this._coll, this._index, this._result, this._keys);
-            }
-          }
-
-          /**
-           * `Aigle.series` functionality has the same functionality as [`Aigle.parallel`](https://suguru03.github.io/aigle/docs/global.html#parallel)
-           * and it works in series.
-           * @param {Array|Object} collection - it should be an array/object of functions or Promise instances
-           * @example
-           *   Aigle.series([
-           *     () => Aigle.delay(30, 1),
-           *     Aigle.delay(20, 2),
-           *     3
-           *   ]).then(array => {
-           *     console.log(array); // [1, 2, 3]
-           *   });
-           *
-           * @example
-           *   Aigle.series({
-           *     a: () => Aigle.delay(30, 1),
-           *     b: Aigle.delay(20, 2),
-           *     c: 3
-           *   }).then(obj => {
-           *     console.log(obj); // { a: 1, b: 2, c: 3 }
-           *   });
-           */
-          function series(collection) {
-            return new Series(collection)._execute();
-          }
-        },
-        { './aigle': 2, './internal/collection': 36, './internal/util': 39, 'aigle-core': 85 }
-      ],
-      67: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./each');
-          var Each = ref.Each;
-          var ref$1 = require('./internal/collection');
-          var setShorthand = ref$1.setShorthand;
-
-          var Some = /*@__PURE__*/ (function(Each) {
-            function Some(collection, iterator) {
-              Each.call(this, collection, iterator, setShorthand);
-              this._result = false;
-            }
-
-            if (Each) Some.__proto__ = Each;
-            Some.prototype = Object.create(Each && Each.prototype);
-            Some.prototype.constructor = Some;
-
-            Some.prototype._callResolve = function _callResolve(value) {
-              if (value) {
-                this._promise._resolve(true);
-              } else if (--this._rest === 0) {
-                this._promise._resolve(false);
-              }
-            };
-
-            return Some;
-          })(Each);
-
-          module.exports = { some: some, Some: Some };
-
-          /**
-           * `Aigle.some` has almost the same functionality as `Array#some`.
-           * It iterates all elements of `collection` and executes `iterator` using each element on parallel.
-           * The `iterator` needs to return a promise or something..
-           * If a promise is returned, the function will wait until the promise is fulfilled.
-           * If the result is truthy, the function will return true otherwise false.
-           * @param {Array|Object} collection
-           * @param {Function|Array|Object|string} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2 === 0;
-           *     });
-           * };
-           * Aigle.some(collection, iterator)
-           *   .then(bool => {
-           *     console.log(bool); // true
-           *     console.log(order); // [1, 2]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = { a: 1, b: 4, c: 2 };
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2 === 0;
-           *     });
-           * };
-           * Aigle.some(collection, iterator)
-           *   .then(bool => {
-           *     console.log(bool); // true
-           *     console.log(order); // [1, 2]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return false;
-           *     });
-           * };
-           * Aigle.some(collection, iterator)
-           *   .then(bool => {
-           *     console.log(bool); // false
-           *     console.log(order); // [1, 2, 4]
-           *   });
-           *
-           * @example
-           * const collection = [{
-           *  uid: 1, active: false
-           * }, {
-           *  uid: 4, active: true
-           * }, {
-           *  uid: 2, active: true
-           * }];
-           * Aigle.some(collection, 'active')
-           *   .then(value => console.log(value)); // true
-           *
-           * @example
-           * const collection = [{
-           *  uid: 1, active: false
-           * }, {
-           *  uid: 4, active: true
-           * }, {
-           *  uid: 2, active: true
-           * }];
-           * Aigle.some(collection, ['uid', 4])
-           *   .then(value => console.log(value)); // true
-           *
-           * @example
-           * const collection = [{
-           *  uid: 1, active: false
-           * }, {
-           *  uid: 4, active: true
-           * }, {
-           *  uid: 2, active: true
-           * }];
-           * Aigle.some(collection, { uid: 4 })
-           *   .then(value => console.log(value)); // true
-           */
-          function some(collection, iterator) {
-            return new Some(collection, iterator)._execute();
-          }
-        },
-        { './each': 12, './internal/collection': 36 }
-      ],
-      68: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./eachLimit');
-          var EachLimit = ref.EachLimit;
-
-          var SomeLimit = /*@__PURE__*/ (function(EachLimit) {
-            function SomeLimit(collection, limit, iterator) {
-              EachLimit.call(this, collection, limit, iterator);
-              this._result = false;
-            }
-
-            if (EachLimit) SomeLimit.__proto__ = EachLimit;
-            SomeLimit.prototype = Object.create(EachLimit && EachLimit.prototype);
-            SomeLimit.prototype.constructor = SomeLimit;
-
-            SomeLimit.prototype._callResolve = function _callResolve(value) {
-              if (value) {
-                this._promise._resolve(true);
-              } else if (--this._rest === 0) {
-                this._promise._resolve(false);
-              } else if (this._callRest-- > 0) {
-                this._iterate();
-              }
-            };
-
-            return SomeLimit;
-          })(EachLimit);
-
-          module.exports = { someLimit: someLimit, SomeLimit: SomeLimit };
-
-          /**
-           * `Aigle.someLimit` is almost the as [`Aigle.some`](https://suguru03.github.io/aigle/docs/Aigle.html#some) and
-           * [`Aigle.someSeries`](https://suguru03.github.io/aigle/docs/Aigle.html#someSeries), but it will work with concurrency.
-           * @param {Array|Object} collection
-           * @param {integer} [limit=8]
-           * @param {Function} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 5, 3, 4, 2];
-           * const iterator = (num, index) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2 === 0;
-           *     });
-           * };
-           * Aigle.someLimit(collection, 2, iterator)
-           *   .then(bool => {
-           *     console.log(bool); // true
-           *     console.log(order); // [1, 3, 5, 2]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = { a: 1, b: 5, c: 3, d: 4, e: 2 };
-           * const iterator = (num, key) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2 === 0;
-           *     });
-           * };
-           * Aigle.someLimit(collection, 2, iterator)
-           *   .then(bool => {
-           *     console.log(bool); // true
-           *     console.log(order); // [1, 3, 5, 2]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [1, 5, 3, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2 === 0;
-           *     });
-           * };
-           * Aigle.someLimit(collection, iterator)
-           *   .then(bool => {
-           *     console.log(bool); // true
-           *     console.log(order); // [1, 2]
-           *   });
-           */
-          function someLimit(collection, limit, iterator) {
-            return new SomeLimit(collection, limit, iterator)._execute();
-          }
-        },
-        { './eachLimit': 13 }
-      ],
-      69: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./eachSeries.js');
-          var EachSeries = ref.EachSeries;
-
-          var SomeSeries = /*@__PURE__*/ (function(EachSeries) {
-            function SomeSeries(collection, iterator) {
-              EachSeries.call(this, collection, iterator);
-              this._result = false;
-            }
-
-            if (EachSeries) SomeSeries.__proto__ = EachSeries;
-            SomeSeries.prototype = Object.create(EachSeries && EachSeries.prototype);
-            SomeSeries.prototype.constructor = SomeSeries;
-
-            SomeSeries.prototype._callResolve = function _callResolve(value) {
-              if (value) {
-                this._promise._resolve(true);
-              } else if (--this._rest === 0) {
-                this._promise._resolve(false);
-              } else {
-                this._iterate();
-              }
-            };
-
-            return SomeSeries;
-          })(EachSeries);
-
-          module.exports = { someSeries: someSeries, SomeSeries: SomeSeries };
-
-          /**
-           * `Aigle.someSeries` is almost the as [`Aigle.some`](https://suguru03.github.io/aigle/docs/Aigle.html#some), but it will work in series.
-           * @param {Array|Object} collection
-           * @param {Function} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2 === 0;
-           *     });
-           * };
-           * Aigle.someSeries(collection, iterator)
-           *   .then(bool => {
-           *     console.log(bool); // true
-           *     console.log(order); // [1, 4]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = { a: 1, b: 4, c: 2 };
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num % 2 === 0;
-           *     });
-           * };
-           * Aigle.someSeries(collection, iterator)
-           *   .then(bool => {
-           *     console.log(bool); // true
-           *     console.log(order); // [1, 4]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return false;
-           *     });
-           * };
-           * Aigle.someSeries(collection, iterator)
-           *   .then(bool => {
-           *     console.log(bool); // false
-           *     console.log(order); // [1, 4, 2]
-           *   });
-           */
-          function someSeries(collection, iterator) {
-            return new SomeSeries(collection, iterator)._execute();
-          }
-        },
-        { './eachSeries.js': 14 }
-      ],
-      70: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./each');
-          var Each = ref.Each;
-          var ref$1 = require('./internal/collection');
-          var setShorthand = ref$1.setShorthand;
-          var ref$2 = require('./internal/util');
-          var sortArray = ref$2.sortArray;
-          var sortObject = ref$2.sortObject;
-
-          var SortBy = /*@__PURE__*/ (function(Each) {
-            function SortBy(collection, iterator) {
-              Each.call(this, collection, iterator, set);
-            }
-
-            if (Each) SortBy.__proto__ = Each;
-            SortBy.prototype = Object.create(Each && Each.prototype);
-            SortBy.prototype.constructor = SortBy;
-
-            return SortBy;
-          })(Each);
-
-          module.exports = { sortBy: sortBy, SortBy: SortBy };
-
-          function set(collection) {
-            setShorthand.call(this, collection);
-            this._result = Array(this._rest);
-            this._callResolve = this._keys === undefined ? callResolveArray : callResolveObject;
-            return this;
-          }
-
-          function callResolveArray(criterion, index) {
-            this._result[index] = criterion;
-            if (--this._rest === 0) {
-              this._promise._resolve(sortArray(this._coll, this._result));
-            }
-          }
-
-          function callResolveObject(criterion, index) {
-            this._result[index] = criterion;
-            if (--this._rest === 0) {
-              this._promise._resolve(sortObject(this._coll, this._keys, this._result));
-            }
-          }
-
-          /**
-           * It iterates all elements of `collection` and executes `iterator` using each element on parallel.
-           * It creates a sorted array which is ordered by results of iterator.
-           * @param {Array|Object} collection
-           * @param {Function|string} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num;
-           *     });
-           * };
-           * Aigle.sortBy(collection, iterator)
-           *   .then(array => {
-           *     console.log(array); // [1, 2, 4]
-           *     console.log(order); // [1, 2, 4]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = { a: 1, b: 4, c: 2 };
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num;
-           *     });
-           * };
-           * Aigle.sortBy(collection, iterator)
-           *   .then(array => {
-           *     console.log(array); // [1, 2, 4]
-           *     console.log(order); // [1, 2, 4]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [{
-           *   uid: 2, name: 'bargey', uid: 2
-           * }, {
-           *   uid: 1, name: 'fread'
-           * }];
-           * Aigle.sortBy(collection, 'uid')
-           *   .then(array => {
-           *     console.log(array); // [{ uid: 1, name: 'fread' }, { uid: 2, name: 'bargey' ]
-           *   });
-           */
-          function sortBy(collection, iterator) {
-            return new SortBy(collection, iterator)._execute();
-          }
-        },
-        { './each': 12, './internal/collection': 36, './internal/util': 39 }
-      ],
-      71: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./eachLimit');
-          var EachLimit = ref.EachLimit;
-          var ref$1 = require('./internal/collection');
-          var setLimit = ref$1.setLimit;
-          var ref$2 = require('./internal/util');
-          var sortArray = ref$2.sortArray;
-          var sortObject = ref$2.sortObject;
-
-          var SortByLimit = /*@__PURE__*/ (function(EachLimit) {
-            function SortByLimit(collection, limit, iterator) {
-              EachLimit.call(this, collection, limit, iterator, set);
-            }
-
-            if (EachLimit) SortByLimit.__proto__ = EachLimit;
-            SortByLimit.prototype = Object.create(EachLimit && EachLimit.prototype);
-            SortByLimit.prototype.constructor = SortByLimit;
-
-            return SortByLimit;
-          })(EachLimit);
-
-          module.exports = { sortByLimit: sortByLimit, SortByLimit: SortByLimit };
-
-          function set(collection) {
-            setLimit.call(this, collection);
-            this._result = Array(this._rest);
-            this._callResolve = this._keys === undefined ? callResolveArray : callResolveObject;
-            return this;
-          }
-
-          function callResolveArray(criterion, index) {
-            this._result[index] = criterion;
-            if (--this._rest === 0) {
-              this._promise._resolve(sortArray(this._coll, this._result));
-            } else if (this._callRest-- > 0) {
-              this._iterate();
-            }
-          }
-
-          function callResolveObject(criterion, index) {
-            this._result[index] = criterion;
-            if (--this._rest === 0) {
-              this._promise._resolve(sortObject(this._coll, this._keys, this._result));
-            } else if (this._callRest-- > 0) {
-              this._iterate();
-            }
-          }
-
-          /**
-           * `Aigle.sortByLimit` is almost the smae as [`Aigle.sortBy`](https://suguru03.github.io/aigle/docs/Aigle.html#sortBy) and
-           * [`Aigle.sortBySeries`](https://suguru03.github.io/aigle/docs/Aigle.html#sortBySeries), but it will work with concurrency.
-           * @param {Array|Object} collection
-           * @param {integer} [limit=8]
-           * @param {Function} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 5, 3, 4, 2];
-           * const iterator = (num, index) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num;
-           *     });
-           * };
-           * Aigle.sortByLimit(collection, 2, iterator)
-           *   .then(array => {
-           *     console.log(array); // [1, 2, 3, 4, 5]
-           *     console.log(order); // [1, 3, 5, 2, 4]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = { a: 1, b: 5, c: 3, d: 4, e: 2 };
-           * const iterator = (num, key) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num;
-           *     });
-           * };
-           * Aigle.sortByLimit(collection, 2, iterator)
-           *   .then(array => {
-           *     console.log(array); // [1, 2, 3, 4, 5]
-           *     console.log(order); // [1, 3, 5, 2, 4]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [1, 5, 3, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num;
-           *     });
-           * };
-           * Aigle.sortByLimit(collection, iterator)
-           *   .then(array => {
-           *     console.log(array); // [1, 2, 3, 4, 5]
-           *     console.log(order); // [1, 2, 3, 4, 5]
-           *   });
-           */
-          function sortByLimit(collection, limit, iterator) {
-            return new SortByLimit(collection, limit, iterator)._execute();
-          }
-        },
-        { './eachLimit': 13, './internal/collection': 36, './internal/util': 39 }
-      ],
-      72: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./eachSeries');
-          var EachSeries = ref.EachSeries;
-          var ref$1 = require('./internal/collection');
-          var setSeries = ref$1.setSeries;
-          var ref$2 = require('./internal/util');
-          var sortArray = ref$2.sortArray;
-          var sortObject = ref$2.sortObject;
-
-          var SortBySeries = /*@__PURE__*/ (function(EachSeries) {
-            function SortBySeries(collection, iterator) {
-              EachSeries.call(this, collection, iterator, set);
-            }
-
-            if (EachSeries) SortBySeries.__proto__ = EachSeries;
-            SortBySeries.prototype = Object.create(EachSeries && EachSeries.prototype);
-            SortBySeries.prototype.constructor = SortBySeries;
-
-            return SortBySeries;
-          })(EachSeries);
-
-          module.exports = { sortBySeries: sortBySeries, SortBySeries: SortBySeries };
-
-          function set(collection) {
-            setSeries.call(this, collection);
-            this._result = Array(this._rest);
-            this._callResolve = this._keys === undefined ? callResolveArray : callResolveObject;
-            return this;
-          }
-
-          function callResolveArray(criterion, index) {
-            this._result[index] = criterion;
-            if (--this._rest === 0) {
-              this._promise._resolve(sortArray(this._coll, this._result));
-            } else {
-              this._iterate();
-            }
-          }
-
-          function callResolveObject(criterion, index) {
-            this._result[index] = criterion;
-            if (--this._rest === 0) {
-              this._promise._resolve(sortObject(this._coll, this._keys, this._result));
-            } else {
-              this._iterate();
-            }
-          }
-
-          /**
-           * `Aigle.sortBySeries` is almost the smae as [`Aigle.sortBy`](https://suguru03.github.io/aigle/docs/Aigle.html#sortBy), but it will work in series.
-           *
-           * @param {Array|Object} collection
-           * @param {Function} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num;
-           *     });
-           * };
-           * Aigle.sortBySeries(collection, iterator)
-           *   .then(array => {
-           *     console.log(array); // [1, 2, 4]
-           *     console.log(order); // [1, 4, 2]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = { a: 1, b: 4, c: 2 };
-           * const iterator = num => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       return num;
-           *     });
-           * };
-           * Aigle.sortBySeries(collection, iterator)
-           *   .then(array => {
-           *     console.log(array); // [1, 2, 4]
-           *     console.log(order); // [1, 4, 2]
-           *   });
-           */
-          function sortBySeries(collection, iterator) {
-            return new SortBySeries(collection, iterator)._execute();
-          }
-        },
-        { './eachSeries': 14, './internal/collection': 36, './internal/util': 39 }
-      ],
-      73: [
-        function(require, module, exports) {
-          'use strict';
-
-          var Aigle = require('./aigle');
-          var ref = require('./internal/util');
-          var INTERNAL = ref.INTERNAL;
-          var callResolve = ref.callResolve;
-
-          // TODO refactor
-          function tap(value, onFulfilled) {
-            var promise = new Aigle(INTERNAL);
-            callResolve(promise, onFulfilled, value);
-            return promise.then(function() {
-              return value;
-            });
-          }
-
-          module.exports = tap;
-        },
-        { './aigle': 2, './internal/util': 39 }
-      ],
-      74: [
-        function(require, module, exports) {
-          'use strict';
-
-          var Aigle = require('./aigle');
-          var ref = require('./internal/util');
-          var INTERNAL = ref.INTERNAL;
-          var callResolve = ref.callResolve;
-
-          function thru(value, onFulfilled) {
-            var promise = new Aigle(INTERNAL);
-            callResolve(promise, onFulfilled, value);
-            return promise;
-          }
-
-          module.exports = thru;
-        },
-        { './aigle': 2, './internal/util': 39 }
-      ],
-      75: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('aigle-core');
-          var AigleProxy = ref.AigleProxy;
-
-          var Aigle = require('./aigle');
-          var ref$1 = require('./error');
-          var TimeoutError = ref$1.TimeoutError;
-          var ref$2 = require('./internal/util');
-          var INTERNAL = ref$2.INTERNAL;
-
-          var Timeout = /*@__PURE__*/ (function(AigleProxy) {
-            function Timeout(ms, message) {
-              var this$1 = this;
-              if (message === void 0) message = 'operation timed out';
-
-              AigleProxy.call(this);
-              this._promise = new Aigle(INTERNAL);
-              this._timer = setTimeout(function() {
-                return this$1._callReject(
-                  message instanceof Error ? message : new TimeoutError(message)
-                );
-              }, ms);
-            }
-
-            if (AigleProxy) Timeout.__proto__ = AigleProxy;
-            Timeout.prototype = Object.create(AigleProxy && AigleProxy.prototype);
-            Timeout.prototype.constructor = Timeout;
-
-            Timeout.prototype._callResolve = function _callResolve(value) {
-              clearTimeout(this._timer);
-              this._promise._resolve(value);
-            };
-
-            Timeout.prototype._callReject = function _callReject(reason) {
-              clearTimeout(this._timer);
-              this._promise._reject(reason);
-            };
-
-            return Timeout;
-          })(AigleProxy);
-
-          module.exports = Timeout;
-        },
-        { './aigle': 2, './error': 15, './internal/util': 39, 'aigle-core': 85 }
-      ],
-      76: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('aigle-core');
-          var AigleProxy = ref.AigleProxy;
-
-          var Aigle = require('./aigle');
-          var ref$1 = require('./internal/util');
-          var INTERNAL = ref$1.INTERNAL;
-          var PENDING = ref$1.PENDING;
-          var defaultIterator = ref$1.defaultIterator;
-          var call1 = ref$1.call1;
-          var callProxyReciever = ref$1.callProxyReciever;
-
-          var Times = /*@__PURE__*/ (function(AigleProxy) {
-            function Times(times, iterator) {
-              AigleProxy.call(this);
-              this._promise = new Aigle(INTERNAL);
-              this._iterator = typeof iterator === 'function' ? iterator : defaultIterator;
-              this._rest = undefined;
-              this._result = undefined;
-              if (times === PENDING) {
-                this._rest = this._callResolve;
-                this._callResolve = execute;
-              } else {
-                set.call(this, times);
-              }
-            }
-
-            if (AigleProxy) Times.__proto__ = AigleProxy;
-            Times.prototype = Object.create(AigleProxy && AigleProxy.prototype);
-            Times.prototype.constructor = Times;
-
-            Times.prototype._execute = function _execute() {
-              if (this._rest >= 1) {
-                var ref = this;
-                var _rest = ref._rest;
-                var _iterator = ref._iterator;
-                var i = -1;
-                while (++i < _rest && callProxyReciever(call1(_iterator, i), this, i)) {}
-              } else {
-                this._promise._resolve(this._result);
-              }
-              return this._promise;
-            };
-
-            Times.prototype._callResolve = function _callResolve(value, index) {
-              this._result[index] = value;
-              if (--this._rest === 0) {
-                this._promise._resolve(this._result);
-              }
-            };
-
-            Times.prototype._callReject = function _callReject(reason) {
-              this._promise._reject(reason);
-            };
-
-            return Times;
-          })(AigleProxy);
-
-          module.exports = { times: times, Times: Times, set: set, execute: execute };
-
-          function set(times) {
-            times = +times | 0;
-            if (times >= 1) {
-              this._rest = times;
-              this._result = Array(times);
-            } else {
-              this._rest = 0;
-              this._result = [];
-            }
-          }
-
-          function execute(times) {
-            this._callResolve = this._rest;
-            set.call(this, times);
-            this._execute();
-          }
-
-          /**
-           * @param {integer} times
-           * @param {Function} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const timer = [30, 20, 10];
-           * const iterator = n => {
-           *   return Aigle.delay(timer[n])
-           *     .then(() => {
-           *       order.push(n);
-           *       return n;
-           *     });
-           * };
-           * Aigle.times(3, iterator)
-           *   .then(array => {
-           *     console.log(array); // [0, 1, 2]
-           *     console.log(order); // [2, 1, 0]
-           *   });
-           */
-          function times(times, iterator) {
-            return new Times(times, iterator)._execute();
-          }
-        },
-        { './aigle': 2, './internal/util': 39, 'aigle-core': 85 }
-      ],
-      77: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('aigle-core');
-          var AigleProxy = ref.AigleProxy;
-
-          var Aigle = require('./aigle');
-          var ref$1 = require('./internal/util');
-          var INTERNAL = ref$1.INTERNAL;
-          var PENDING = ref$1.PENDING;
-          var DEFAULT_LIMIT = ref$1.DEFAULT_LIMIT;
-          var defaultIterator = ref$1.defaultIterator;
-          var call1 = ref$1.call1;
-          var callProxyReciever = ref$1.callProxyReciever;
-
-          var TimesLimit = /*@__PURE__*/ (function(AigleProxy) {
-            function TimesLimit(times, limit, iterator) {
-              AigleProxy.call(this);
-              if (typeof limit === 'function') {
-                iterator = limit;
-                limit = DEFAULT_LIMIT;
-              }
-              this._promise = new Aigle(INTERNAL);
-              this._index = 0;
-              this._limit = limit;
-              this._iterator = typeof iterator === 'function' ? iterator : defaultIterator;
-              this._rest = undefined;
-              this._result = undefined;
-              this._callRest = undefined;
-              if (times === PENDING) {
-                this._rest = this._callResolve;
-                this._callResolve = execute;
-              } else {
-                set.call(this, times);
-              }
-            }
-
-            if (AigleProxy) TimesLimit.__proto__ = AigleProxy;
-            TimesLimit.prototype = Object.create(AigleProxy && AigleProxy.prototype);
-            TimesLimit.prototype.constructor = TimesLimit;
-
-            TimesLimit.prototype._execute = function _execute() {
-              if (this._rest === 0) {
-                this._promise._resolve(this._result);
-              } else {
-                while (this._limit--) {
-                  this._iterate();
-                }
-              }
-              return this._promise;
-            };
-
-            TimesLimit.prototype._iterate = function _iterate() {
-              var i = this._index++;
-              callProxyReciever(call1(this._iterator, i), this, i);
-            };
-
-            TimesLimit.prototype._callResolve = function _callResolve(value, index) {
-              this._result[index] = value;
-              if (--this._rest === 0) {
-                this._promise._resolve(this._result);
-              } else if (this._callRest-- > 0) {
-                this._iterate();
-              }
-            };
-
-            TimesLimit.prototype._callReject = function _callReject(reason) {
-              this._callRest = 0;
-              this._promise._reject(reason);
-            };
-
-            return TimesLimit;
-          })(AigleProxy);
-
-          module.exports = { timesLimit: timesLimit, TimesLimit: TimesLimit };
-
-          function set(times) {
-            times = +times | 0;
-            if (times >= 1) {
-              this._rest = times;
-              this._result = Array(times);
-              var ref = this;
-              var _limit = ref._limit;
-              this._limit = _limit < times ? _limit : times;
-              this._callRest = times - this._limit;
-            } else {
-              this._rest = 0;
-              this._result = [];
-            }
-          }
-
-          function execute(times) {
-            this._callResolve = this._rest;
-            set.call(this, times);
-            this._execute();
-          }
-
-          /**
-           * @param {integer} times
-           * @param {integer} [limit=8]
-           * @param {Function} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const timer = [30, 20, 10];
-           * const iterator = n => {
-           *   return Aigle.delay(timer[n])
-           *     .then(() => {
-           *       order.push(n);
-           *       return n;
-           *     });
-           * };
-           * Aigle.timesLimit(3, 2, iterator)
-           *   .then(array => {
-           *     console.log(array); // [0, 1, 2]
-           *     console.log(order); // [1, 0, 2]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const timer = [30, 20, 10];
-           * const iterator = n => {
-           *   return Aigle.delay(timer[n])
-           *     .then(() => {
-           *       order.push(n);
-           *       return n;
-           *     });
-           * };
-           * Aigle.timesLimit(3, iterator)
-           *   .then(array => {
-           *     console.log(array); // [0, 1, 2]
-           *     console.log(order); // [2, 1, 0]
-           *   });
-           */
-          function timesLimit(times, limit, iterator) {
-            return new TimesLimit(times, limit, iterator)._execute();
-          }
-        },
-        { './aigle': 2, './internal/util': 39, 'aigle-core': 85 }
-      ],
-      78: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('aigle-core');
-          var AigleProxy = ref.AigleProxy;
-
-          var Aigle = require('./aigle');
-          var ref$1 = require('./times');
-          var set = ref$1.set;
-          var execute = ref$1.execute;
-          var ref$2 = require('./internal/util');
-          var INTERNAL = ref$2.INTERNAL;
-          var PENDING = ref$2.PENDING;
-          var defaultIterator = ref$2.defaultIterator;
-          var call1 = ref$2.call1;
-          var callProxyReciever = ref$2.callProxyReciever;
-
-          var TimesSeries = /*@__PURE__*/ (function(AigleProxy) {
-            function TimesSeries(times, iterator) {
-              AigleProxy.call(this);
-              this._promise = new Aigle(INTERNAL);
-              this._iterator = typeof iterator === 'function' ? iterator : defaultIterator;
-              this._index = 0;
-              this._rest = undefined;
-              this._result = undefined;
-              if (times === PENDING) {
-                this._rest = this._callResolve;
-                this._callResolve = execute;
-              } else {
-                set.call(this, times);
-              }
-            }
-
-            if (AigleProxy) TimesSeries.__proto__ = AigleProxy;
-            TimesSeries.prototype = Object.create(AigleProxy && AigleProxy.prototype);
-            TimesSeries.prototype.constructor = TimesSeries;
-
-            TimesSeries.prototype._execute = function _execute() {
-              if (this._rest >= 1) {
-                this._iterate();
-              } else {
-                this._promise._resolve(this._result);
-              }
-              return this._promise;
-            };
-
-            TimesSeries.prototype._iterate = function _iterate() {
-              var i = this._index++;
-              callProxyReciever(call1(this._iterator, i), this, i);
-            };
-
-            TimesSeries.prototype._callResolve = function _callResolve(value, index) {
-              this._result[index] = value;
-              if (--this._rest === 0) {
-                this._promise._resolve(this._result);
-              } else {
-                this._iterate();
-              }
-            };
-
-            TimesSeries.prototype._callReject = function _callReject(reason) {
-              this._promise._reject(reason);
-            };
-
-            return TimesSeries;
-          })(AigleProxy);
-
-          module.exports = { timesSeries: timesSeries, TimesSeries: TimesSeries };
-
-          /**
-           * @param {integer} times
-           * @param {Function} iterator
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const timer = [30, 20, 10];
-           * const iterator = n => {
-           *   return Aigle.delay(timer[n])
-           *     .then(() => {
-           *       order.push(n);
-           *       return n;
-           *     });
-           * };
-           * Aigle.timesSeries(3, iterator)
-           *   .then(array => {
-           *     console.log(array); // [0, 1, 2]
-           *     console.log(order); // [0, 1, 2]
-           *   });
-           */
-          function timesSeries(times, iterator) {
-            return new TimesSeries(times, iterator)._execute();
-          }
-        },
-        { './aigle': 2, './internal/util': 39, './times': 76, 'aigle-core': 85 }
-      ],
-      79: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./each');
-          var Each = ref.Each;
-          var ref$1 = require('./internal/collection');
-          var setParallel = ref$1.setParallel;
-          var ref$2 = require('./internal/util');
-          var call3 = ref$2.call3;
-          var callProxyReciever = ref$2.callProxyReciever;
-          var clone = ref$2.clone;
-
-          var Transform = /*@__PURE__*/ (function(Each) {
-            function Transform(collection, iterator, accumulator) {
-              Each.call(this, collection, iterator, set);
-              if (accumulator !== undefined) {
-                this._result = accumulator;
-              }
-            }
-
-            if (Each) Transform.__proto__ = Each;
-            Transform.prototype = Object.create(Each && Each.prototype);
-            Transform.prototype.constructor = Transform;
-
-            Transform.prototype._callResolve = function _callResolve(bool) {
-              if (bool === false) {
-                this._promise._resolve(clone(this._result));
-              } else if (--this._rest === 0) {
-                this._promise._resolve(this._result);
-              }
-            };
-
-            return Transform;
-          })(Each);
-
-          module.exports = { transform: transform, Transform: Transform };
-
-          function set(collection) {
-            setParallel.call(this, collection);
-            if (this._keys !== undefined || this._coll === undefined) {
-              if (this._result === undefined) {
-                this._result = {};
-              }
-              this._iterate = iterateObject;
-            } else {
-              if (this._result === undefined) {
-                this._result = [];
-              }
-              this._iterate = iterateArray;
-            }
-            return this;
-          }
-
-          function iterateArray() {
-            var ref = this;
-            var _rest = ref._rest;
-            var _result = ref._result;
-            var _iterator = ref._iterator;
-            var _coll = ref._coll;
-            var i = -1;
-            while (
-              ++i < _rest &&
-              callProxyReciever(call3(_iterator, _result, _coll[i], i), this, i)
-            ) {}
-          }
-
-          function iterateObject() {
-            var ref = this;
-            var _rest = ref._rest;
-            var _result = ref._result;
-            var _iterator = ref._iterator;
-            var _coll = ref._coll;
-            var _keys = ref._keys;
-            var i = -1;
-            while (++i < _rest) {
-              var key = _keys[i];
-              if (
-                callProxyReciever(call3(_iterator, _result, _coll[key], key), this, i) === false
-              ) {
-                break;
-              }
-            }
-          }
-
-          /**
-           * @param {Array|Object} collection
-           * @param {Function} iterator
-           * @param {Array|Object} [accumulator]
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = (result, num, index) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       result[index] = num;
-           *     });
-           * };
-           * Aigle.transform(collection, iterator, {})
-           *   .then(object => {
-           *     console.log(object); // { '0': 1, '1': 4, '2': 2 }
-           *     console.log(order); // [1, 2, 4]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = (result, num, index) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       result.push(num);
-           *     });
-           * };
-           * Aigle.transform(collection, iterator, {})
-           *   .then(array => {
-           *     console.log(array); // [1, 2, 4]
-           *     console.log(order); // [1, 2, 4]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = { a: 1, b: 4, c: 2 };
-           * const iterator = (result, num, key) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       result.push(num);
-           *       return num !== 2;
-           *     });
-           * };
-           * Aigle.transform(collection, iterator, [])
-           *   .then(array => {
-           *     console.log(array); // [1, 2]
-           *     console.log(order); // [1, 2]
-           *   });
-           */
-          function transform(collection, iterator, accumulator) {
-            return new Transform(collection, iterator, accumulator)._execute();
-          }
-        },
-        { './each': 12, './internal/collection': 36, './internal/util': 39 }
-      ],
-      80: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./eachLimit');
-          var EachLimit = ref.EachLimit;
-          var ref$1 = require('./internal/collection');
-          var setLimit = ref$1.setLimit;
-          var ref$2 = require('./internal/util');
-          var DEFAULT_LIMIT = ref$2.DEFAULT_LIMIT;
-          var call3 = ref$2.call3;
-          var callProxyReciever = ref$2.callProxyReciever;
-          var clone = ref$2.clone;
-
-          var TransformLimit = /*@__PURE__*/ (function(EachLimit) {
-            function TransformLimit(collection, limit, iterator, accumulator) {
-              if (typeof limit === 'function') {
-                accumulator = iterator;
-                iterator = limit;
-                limit = DEFAULT_LIMIT;
-              }
-              EachLimit.call(this, collection, limit, iterator, set);
-              if (accumulator !== undefined) {
-                this._result = accumulator;
-              }
-            }
-
-            if (EachLimit) TransformLimit.__proto__ = EachLimit;
-            TransformLimit.prototype = Object.create(EachLimit && EachLimit.prototype);
-            TransformLimit.prototype.constructor = TransformLimit;
-
-            TransformLimit.prototype._callResolve = function _callResolve(bool) {
-              if (bool === false) {
-                this._promise._resolve(clone(this._result));
-              } else if (--this._rest === 0) {
-                this._promise._resolve(this._result);
-              } else if (this._callRest-- > 0) {
-                this._iterate();
-              }
-            };
-
-            return TransformLimit;
-          })(EachLimit);
-
-          module.exports = { transformLimit: transformLimit, TransformLimit: TransformLimit };
-
-          function set(collection) {
-            setLimit.call(this, collection);
-            if (this._keys !== undefined || this._coll === undefined) {
-              if (this._result === undefined) {
-                this._result = {};
-              }
-              this._iterate = iterateObject;
-            } else {
-              if (this._result === undefined) {
-                this._result = [];
-              }
-              this._iterate = iterateArray;
-            }
-            return this;
-          }
-
-          function iterateArray() {
-            var index = this._index++;
-            callProxyReciever(
-              call3(this._iterator, this._result, this._coll[index], index),
-              this,
-              index
-            );
-          }
-
-          function iterateObject() {
-            var index = this._index++;
-            var key = this._keys[index];
-            callProxyReciever(
-              call3(this._iterator, this._result, this._coll[key], key),
-              this,
-              index
-            );
-          }
-
-          /**
-           * @param {Array|Object} collection
-           * @param {integer} [limit]
-           * @param {Function} iterator
-           * @param {Array|Object} [accumulator]
-           * @example
-           * const order = [];
-           * const collection = [1, 5, 3, 4, 2];
-           * const iterator = (result, num, index) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       result[index] = num;
-           *     });
-           * };
-           * Aigle.transformLimit(collection, 2, iterator, {})
-           *   .then(object => {
-           *     console.log(object); // { '0': 1, '1': 5, '2': 3, '3': 4, '4': 2 }
-           *     console.log(order); // [1, 5, 3, 4, 2]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [1, 5, 3, 4, 2];
-           * const iterator = (result, num, index) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       result.push(num);
-           *     });
-           * };
-           * Aigle.transformLimit(collection, 2, iterator, {})
-           *   .then(array => {
-           *     console.log(array); // [1, 5, 3, 4, 2]
-           *     console.log(order); // [1, 5, 3, 4, 2]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = { a: 1, b: 5, c: 3, d: 4, e: 2 };
-           * const iterator = (result, num, key) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       result.push(num);
-           *       return num !== 4;
-           *     });
-           * };
-           * Aigle.transformLimit(collection, 2, iterator, [])
-           *   .then(array => {
-           *     console.log(array); // [1, 5, 3, 4]
-           *     console.log(order); // [1, 5, 3, 4]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = { a: 1, b: 5, c: 3, d: 4, e: 2 };
-           * const iterator = (result, num, key) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       result.push(num);
-           *       return num !== 4;
-           *     });
-           * };
-           * Aigle.transformLimit(collection, iterator, [])
-           *   .then(array => {
-           *     console.log(array); // [1, 2, 3, 4]
-           *     console.log(order); // [1, 2, 3, 4]
-           *   });
-           */
-          function transformLimit(collection, limit, iterator, accumulator) {
-            return new TransformLimit(collection, limit, iterator, accumulator)._execute();
-          }
-        },
-        { './eachLimit': 13, './internal/collection': 36, './internal/util': 39 }
-      ],
-      81: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./eachSeries');
-          var EachSeries = ref.EachSeries;
-          var ref$1 = require('./internal/collection');
-          var setSeries = ref$1.setSeries;
-          var ref$2 = require('./internal/util');
-          var call3 = ref$2.call3;
-          var callProxyReciever = ref$2.callProxyReciever;
-          var clone = ref$2.clone;
-
-          var TransformSeries = /*@__PURE__*/ (function(EachSeries) {
-            function TransformSeries(collection, iterator, accumulator) {
-              EachSeries.call(this, collection, iterator, set);
-              if (accumulator !== undefined) {
-                this._result = accumulator;
-              }
-            }
-
-            if (EachSeries) TransformSeries.__proto__ = EachSeries;
-            TransformSeries.prototype = Object.create(EachSeries && EachSeries.prototype);
-            TransformSeries.prototype.constructor = TransformSeries;
-
-            TransformSeries.prototype._callResolve = function _callResolve(bool) {
-              if (bool === false) {
-                this._promise._resolve(clone(this._result));
-              } else if (--this._rest === 0) {
-                this._promise._resolve(this._result);
-              } else {
-                this._iterate();
-              }
-            };
-
-            return TransformSeries;
-          })(EachSeries);
-
-          module.exports = { transformSeries: transformSeries, TransformSeries: TransformSeries };
-
-          function set(collection) {
-            setSeries.call(this, collection);
-            if (this._keys !== undefined || this._coll === undefined) {
-              if (this._result === undefined) {
-                this._result = {};
-              }
-              this._iterate = iterateObject;
-            } else {
-              if (this._result === undefined) {
-                this._result = [];
-              }
-              this._iterate = iterateArray;
-            }
-            return this;
-          }
-
-          function iterateArray() {
-            var index = this._index++;
-            callProxyReciever(
-              call3(this._iterator, this._result, this._coll[index], index),
-              this,
-              index
-            );
-          }
-
-          function iterateObject() {
-            var index = this._index++;
-            var key = this._keys[index];
-            callProxyReciever(
-              call3(this._iterator, this._result, this._coll[key], key),
-              this,
-              index
-            );
-          }
-
-          /**
-           * @param {Array|Object} collection
-           * @param {Function} iterator
-           * @param {Array|Object} [accumulator]
-           * @return {Aigle} Returns an Aigle instance
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = (result, num, index) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       result[index] = num;
-           *     });
-           * };
-           * Aigle.transformSeries(collection, iterator, {})
-           *   .then(object => {
-           *     console.log(object); // { '0': 1, '1': 4, '2': 2 }
-           *     console.log(order); // [1, 4, 2]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = [1, 4, 2];
-           * const iterator = (result, num, index) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       result.push(num);
-           *     });
-           * };
-           * Aigle.transformSeries(collection, iterator, {})
-           *   .then(array => {
-           *     console.log(array); // [1, 4, 2]
-           *     console.log(order); // [1, 4, 2]
-           *   });
-           *
-           * @example
-           * const order = [];
-           * const collection = { a: 1, b: 4, c: 2 };
-           * const iterator = (result, num, key) => {
-           *   return Aigle.delay(num * 10)
-           *     .then(() => {
-           *       order.push(num);
-           *       result.push(num);
-           *       return num !== 4;
-           *     });
-           * };
-           * Aigle.transformSeries(collection, iterator, [])
-           *   .then(array => {
-           *     console.log(array); // [1, 4]
-           *     console.log(order); // [1, 4]
-           *   });
-           */
-          function transformSeries(collection, iterator, accumulator) {
-            return new TransformSeries(collection, iterator, accumulator)._execute();
-          }
-        },
-        { './eachSeries': 14, './internal/collection': 36, './internal/util': 39 }
-      ],
-      82: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('./whilst');
-          var AigleWhilst = ref.AigleWhilst;
-          var WhilstTester = ref.WhilstTester;
-
-          var UntilTester = /*@__PURE__*/ (function(WhilstTester) {
-            function UntilTester(tester) {
-              WhilstTester.call(this, tester);
-            }
-
-            if (WhilstTester) UntilTester.__proto__ = WhilstTester;
-            UntilTester.prototype = Object.create(WhilstTester && WhilstTester.prototype);
-            UntilTester.prototype.constructor = UntilTester;
-
-            UntilTester.prototype._callResolve = function _callResolve(value) {
-              if (value) {
-                this._proxy._promise._resolve(this._value);
-              } else {
-                this._proxy._next(this._value);
-              }
-            };
-
-            return UntilTester;
-          })(WhilstTester);
-
-          module.exports = { until: until, UntilTester: UntilTester };
-
-          /**
-           * @param {*} [value]
-           * @param {Function} tester
-           * @param {Function} iterator
-           */
-          function until(value, tester, iterator) {
-            if (typeof iterator !== 'function') {
-              iterator = tester;
-              tester = value;
-              value = undefined;
-            }
-            return new AigleWhilst(new UntilTester(tester), iterator)._iterate(value);
-          }
-        },
-        { './whilst': 84 }
-      ],
-      83: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('aigle-core');
-          var AigleProxy = ref.AigleProxy;
-
-          var Aigle = require('./aigle');
-          var ref$1 = require('./internal/util');
-          var INTERNAL = ref$1.INTERNAL;
-          var apply = ref$1.apply;
-          var call1 = ref$1.call1;
-          var callProxyReciever = ref$1.callProxyReciever;
-
-          var DISPOSER = {};
-
-          var Disposer = function Disposer(promise, handler) {
-            this._promise = promise;
-            this._handler = handler;
-          };
-
-          Disposer.prototype._dispose = function _dispose() {
-            var this$1 = this;
-
-            var ref = this;
-            var _promise = ref._promise;
-            switch (_promise._resolved) {
-              case 0:
-                return _promise.then(function() {
-                  return this$1._dispose();
-                });
-              case 1:
-                return call1(this._handler, this._promise._value);
-            }
-          };
-
-          var Using = /*@__PURE__*/ (function(AigleProxy) {
-            function Using(array, handler) {
-              AigleProxy.call(this);
-              var size = array.length;
-              this._promise = new Aigle(INTERNAL);
-              this._rest = size;
-              this._disposed = size;
-              this._array = array;
-              this._error = undefined;
-              this._result = Array(size);
-              this._handler = handler;
-              var i = -1;
-              while (++i < size) {
-                var disposer = array[i];
-                if (disposer instanceof Disposer === false) {
-                  callProxyReciever(disposer, this, i);
-                } else {
-                  callProxyReciever(disposer._promise, this, i);
-                }
-              }
-            }
-
-            if (AigleProxy) Using.__proto__ = AigleProxy;
-            Using.prototype = Object.create(AigleProxy && AigleProxy.prototype);
-            Using.prototype.constructor = Using;
-
-            Using.prototype._spread = function _spread() {
-              var ref = this;
-              var _handler = ref._handler;
-              var _result = ref._result;
-              if (typeof _handler !== 'function') {
-                return this._callResolve(undefined, INTERNAL);
-              }
-              callProxyReciever(apply(_handler, _result), this, INTERNAL);
-            };
-
-            Using.prototype._release = function _release() {
-              var ref = this;
-              var _array = ref._array;
-              var l = _array.length;
-              while (l--) {
-                var disposer = _array[l];
-                if (disposer instanceof Disposer === false) {
-                  this._callResolve(disposer, DISPOSER);
-                } else {
-                  callProxyReciever(disposer._dispose(), this, DISPOSER);
-                }
-              }
-            };
-
-            Using.prototype._callResolve = function _callResolve(value, index) {
-              if (index === INTERNAL) {
-                this._result = value;
-                return this._release();
-              }
-              if (index === DISPOSER) {
-                if (--this._disposed === 0) {
-                  if (this._error) {
-                    this._promise._reject(this._error);
-                  } else {
-                    this._promise._resolve(this._result);
-                  }
-                }
-                return;
-              }
-              this._result[index] = value;
-              if (--this._rest === 0) {
-                this._spread();
-              }
-            };
-
-            Using.prototype._callReject = function _callReject(reason) {
-              if (this._error) {
-                return this._promise._reject(reason);
-              }
-              this._error = reason;
-              this._release();
-            };
-
-            return Using;
-          })(AigleProxy);
-
-          module.exports = { using: using, Disposer: Disposer };
-
-          function using() {
-            var arguments$1 = arguments;
-
-            var l = arguments.length;
-            var handler = arguments[--l];
-            var array = Array(l);
-            while (l--) {
-              array[l] = arguments$1[l];
-            }
-            return new Using(array, handler)._promise;
-          }
-        },
-        { './aigle': 2, './internal/util': 39, 'aigle-core': 85 }
-      ],
-      84: [
-        function(require, module, exports) {
-          'use strict';
-
-          var ref = require('aigle-core');
-          var AigleProxy = ref.AigleProxy;
-
-          var Aigle = require('./aigle');
-          var ref$1 = require('./internal/util');
-          var INTERNAL = ref$1.INTERNAL;
-          var callProxyReciever = ref$1.callProxyReciever;
-          var call1 = ref$1.call1;
-
-          var WhilstTester = /*@__PURE__*/ (function(AigleProxy) {
-            function WhilstTester(tester) {
-              AigleProxy.call(this);
-              this._tester = tester;
-              this._proxy = undefined;
-              this._value = undefined;
-            }
-
-            if (AigleProxy) WhilstTester.__proto__ = AigleProxy;
-            WhilstTester.prototype = Object.create(AigleProxy && AigleProxy.prototype);
-            WhilstTester.prototype.constructor = WhilstTester;
-
-            WhilstTester.prototype._test = function _test(value) {
-              this._value = value;
-              callProxyReciever(call1(this._tester, value), this, undefined);
-            };
-
-            WhilstTester.prototype._callResolve = function _callResolve(value) {
-              if (value) {
-                this._proxy._next(this._value);
-              } else {
-                this._proxy._promise._resolve(this._value);
-              }
-            };
-
-            WhilstTester.prototype._callReject = function _callReject(reason) {
-              this._proxy._callReject(reason);
-            };
-
-            return WhilstTester;
-          })(AigleProxy);
-
-          var AigleWhilst = /*@__PURE__*/ (function(AigleProxy) {
-            function AigleWhilst(tester, iterator) {
-              AigleProxy.call(this);
-              this._promise = new Aigle(INTERNAL);
-              this._tester = tester;
-              this._iterator = iterator;
-              tester._proxy = this;
-            }
-
-            if (AigleProxy) AigleWhilst.__proto__ = AigleProxy;
-            AigleWhilst.prototype = Object.create(AigleProxy && AigleProxy.prototype);
-            AigleWhilst.prototype.constructor = AigleWhilst;
-
-            AigleWhilst.prototype._iterate = function _iterate(value) {
-              this._callResolve(value);
-              return this._promise;
-            };
-
-            AigleWhilst.prototype._next = function _next(value) {
-              callProxyReciever(call1(this._iterator, value), this, undefined);
-            };
-
-            AigleWhilst.prototype._callResolve = function _callResolve(value) {
-              this._tester._test(value);
-            };
-
-            AigleWhilst.prototype._callReject = function _callReject(reason) {
-              this._promise._reject(reason);
-            };
-
-            return AigleWhilst;
-          })(AigleProxy);
-
-          module.exports = { whilst: whilst, AigleWhilst: AigleWhilst, WhilstTester: WhilstTester };
-
-          /**
-           * @param {*} [value]
-           * @param {Function} tester
-           * @param {Function} iterator
-           */
-          function whilst(value, tester, iterator) {
-            if (typeof iterator !== 'function') {
-              iterator = tester;
-              tester = value;
-              value = undefined;
-            }
-            return new AigleWhilst(new WhilstTester(tester), iterator)._iterate(value);
-          }
-        },
-        { './aigle': 2, './internal/util': 39, 'aigle-core': 85 }
-      ],
-      85: [
-        function(require, module, exports) {
-          'use strict';
-
-          var AigleCore = function AigleCore() {};
-
-          var AigleProxy = function AigleProxy() {};
-
-          module.exports = { AigleCore: AigleCore, AigleProxy: AigleProxy };
-        },
-        {}
-      ],
-      86: [
-        function(require, module, exports) {
-          // shim for using process in browser
-          var process = (module.exports = {});
-
-          // cached from whatever global is present so that test runners that stub it
-          // don't break things.  But we need to wrap it in a try catch in case it is
-          // wrapped in strict mode code which doesn't define any globals.  It's inside a
-          // function because try/catches deoptimize in certain engines.
-
-          var cachedSetTimeout;
-          var cachedClearTimeout;
-
-          function defaultSetTimout() {
-            throw new Error('setTimeout has not been defined');
-          }
-          function defaultClearTimeout() {
-            throw new Error('clearTimeout has not been defined');
-          }
-          (function() {
-            try {
-              if (typeof setTimeout === 'function') {
-                cachedSetTimeout = setTimeout;
-              } else {
-                cachedSetTimeout = defaultSetTimout;
-              }
-            } catch (e) {
-              cachedSetTimeout = defaultSetTimout;
-            }
-            try {
-              if (typeof clearTimeout === 'function') {
-                cachedClearTimeout = clearTimeout;
-              } else {
-                cachedClearTimeout = defaultClearTimeout;
-              }
-            } catch (e) {
-              cachedClearTimeout = defaultClearTimeout;
-            }
-          })();
-          function runTimeout(fun) {
-            if (cachedSetTimeout === setTimeout) {
-              //normal enviroments in sane situations
-              return setTimeout(fun, 0);
-            }
-            // if setTimeout wasn't available but was latter defined
-            if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
-              cachedSetTimeout = setTimeout;
-              return setTimeout(fun, 0);
-            }
-            try {
-              // when when somebody has screwed with setTimeout but no I.E. maddness
-              return cachedSetTimeout(fun, 0);
-            } catch (e) {
-              try {
-                // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
-                return cachedSetTimeout.call(null, fun, 0);
-              } catch (e) {
-                // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
-                return cachedSetTimeout.call(this, fun, 0);
-              }
-            }
-          }
-          function runClearTimeout(marker) {
-            if (cachedClearTimeout === clearTimeout) {
-              //normal enviroments in sane situations
-              return clearTimeout(marker);
-            }
-            // if clearTimeout wasn't available but was latter defined
-            if (
-              (cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) &&
-              clearTimeout
-            ) {
-              cachedClearTimeout = clearTimeout;
-              return clearTimeout(marker);
-            }
-            try {
-              // when when somebody has screwed with setTimeout but no I.E. maddness
-              return cachedClearTimeout(marker);
-            } catch (e) {
-              try {
-                // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
-                return cachedClearTimeout.call(null, marker);
-              } catch (e) {
-                // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
-                // Some versions of I.E. have different rules for clearTimeout vs setTimeout
-                return cachedClearTimeout.call(this, marker);
-              }
-            }
-          }
-          var queue = [];
-          var draining = false;
-          var currentQueue;
-          var queueIndex = -1;
-
-          function cleanUpNextTick() {
-            if (!draining || !currentQueue) {
-              return;
-            }
-            draining = false;
-            if (currentQueue.length) {
-              queue = currentQueue.concat(queue);
-            } else {
-              queueIndex = -1;
-            }
-            if (queue.length) {
-              drainQueue();
-            }
-          }
-
-          function drainQueue() {
-            if (draining) {
-              return;
-            }
-            var timeout = runTimeout(cleanUpNextTick);
-            draining = true;
-
-            var len = queue.length;
-            while (len) {
-              currentQueue = queue;
-              queue = [];
-              while (++queueIndex < len) {
-                if (currentQueue) {
-                  currentQueue[queueIndex].run();
-                }
-              }
-              queueIndex = -1;
-              len = queue.length;
-            }
-            currentQueue = null;
-            draining = false;
-            runClearTimeout(timeout);
-          }
-
-          process.nextTick = function(fun) {
-            var arguments$1 = arguments;
-
-            var args = new Array(arguments.length - 1);
-            if (arguments.length > 1) {
-              for (var i = 1; i < arguments.length; i++) {
-                args[i - 1] = arguments$1[i];
-              }
-            }
-            queue.push(new Item(fun, args));
-            if (queue.length === 1 && !draining) {
-              runTimeout(drainQueue);
-            }
-          };
-
-          // v8 likes predictible objects
-          function Item(fun, array) {
-            this.fun = fun;
-            this.array = array;
-          }
-          Item.prototype.run = function() {
-            this.fun.apply(null, this.array);
-          };
-          process.title = 'browser';
-          process.browser = true;
-          process.env = {};
-          process.argv = [];
-          process.version = ''; // empty string to avoid regexp issues
-          process.versions = {};
-
-          function noop() {}
-
-          process.on = noop;
-          process.addListener = noop;
-          process.once = noop;
-          process.off = noop;
-          process.removeListener = noop;
-          process.removeAllListeners = noop;
-          process.emit = noop;
-          process.prependListener = noop;
-          process.prependOnceListener = noop;
-
-          process.listeners = function(name) {
-            return [];
-          };
-
-          process.binding = function(name) {
-            throw new Error('process.binding is not supported');
-          };
-
-          process.cwd = function() {
-            return '/';
-          };
-          process.chdir = function(dir) {
-            throw new Error('process.chdir is not supported');
-          };
-          process.umask = function() {
-            return 0;
-          };
-        },
-        {}
-      ],
-      87: [
-        function(require, module, exports) {
-          (function(process, global) {
-            (function(global, undefined) {
-              'use strict';
-
-              if (global.setImmediate) {
-                return;
-              }
-
-              var nextHandle = 1; // Spec says greater than zero
-              var tasksByHandle = {};
-              var currentlyRunningATask = false;
-              var doc = global.document;
-              var registerImmediate;
-
-              function setImmediate(callback) {
-                var arguments$1 = arguments;
-
-                // Callback can either be a function or a string
-                if (typeof callback !== 'function') {
-                  callback = new Function('' + callback);
-                }
-                // Copy function arguments
-                var args = new Array(arguments.length - 1);
-                for (var i = 0; i < args.length; i++) {
-                  args[i] = arguments$1[i + 1];
-                }
-                // Store and register the task
-                var task = { callback: callback, args: args };
-                tasksByHandle[nextHandle] = task;
-                registerImmediate(nextHandle);
-                return nextHandle++;
-              }
-
-              function clearImmediate(handle) {
-                delete tasksByHandle[handle];
-              }
-
-              function run(task) {
-                var callback = task.callback;
-                var args = task.args;
-                switch (args.length) {
-                  case 0:
-                    callback();
-                    break;
-                  case 1:
-                    callback(args[0]);
-                    break;
-                  case 2:
-                    callback(args[0], args[1]);
-                    break;
-                  case 3:
-                    callback(args[0], args[1], args[2]);
-                    break;
-                  default:
-                    callback.apply(undefined, args);
-                    break;
-                }
-              }
-
-              function runIfPresent(handle) {
-                // From the spec: "Wait until any invocations of this algorithm started before this one have completed."
-                // So if we're currently running a task, we'll need to delay this invocation.
-                if (currentlyRunningATask) {
-                  // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a
-                  // "too much recursion" error.
-                  setTimeout(runIfPresent, 0, handle);
-                } else {
-                  var task = tasksByHandle[handle];
-                  if (task) {
-                    currentlyRunningATask = true;
-                    try {
-                      run(task);
-                    } finally {
-                      clearImmediate(handle);
-                      currentlyRunningATask = false;
-                    }
-                  }
-                }
-              }
-
-              function installNextTickImplementation() {
-                registerImmediate = function(handle) {
-                  process.nextTick(function() {
-                    runIfPresent(handle);
-                  });
-                };
-              }
-
-              function canUsePostMessage() {
-                // The test against `importScripts` prevents this implementation from being installed inside a web worker,
-                // where `global.postMessage` means something completely different and can't be used for this purpose.
-                if (global.postMessage && !global.importScripts) {
-                  var postMessageIsAsynchronous = true;
-                  var oldOnMessage = global.onmessage;
-                  global.onmessage = function() {
-                    postMessageIsAsynchronous = false;
-                  };
-                  global.postMessage('', '*');
-                  global.onmessage = oldOnMessage;
-                  return postMessageIsAsynchronous;
-                }
-              }
-
-              function installPostMessageImplementation() {
-                // Installs an event handler on `global` for the `message` event: see
-                // * https://developer.mozilla.org/en/DOM/window.postMessage
-                // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages
-
-                var messagePrefix = 'setImmediate$' + Math.random() + '$';
-                var onGlobalMessage = function(event) {
-                  if (
-                    event.source === global &&
-                    typeof event.data === 'string' &&
-                    event.data.indexOf(messagePrefix) === 0
-                  ) {
-                    runIfPresent(+event.data.slice(messagePrefix.length));
-                  }
-                };
-
-                if (global.addEventListener) {
-                  global.addEventListener('message', onGlobalMessage, false);
-                } else {
-                  global.attachEvent('onmessage', onGlobalMessage);
-                }
-
-                registerImmediate = function(handle) {
-                  global.postMessage(messagePrefix + handle, '*');
-                };
-              }
-
-              function installMessageChannelImplementation() {
-                var channel = new MessageChannel();
-                channel.port1.onmessage = function(event) {
-                  var handle = event.data;
-                  runIfPresent(handle);
-                };
-
-                registerImmediate = function(handle) {
-                  channel.port2.postMessage(handle);
-                };
-              }
-
-              function installReadyStateChangeImplementation() {
-                var html = doc.documentElement;
-                registerImmediate = function(handle) {
-                  // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted
-                  // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.
-                  var script = doc.createElement('script');
-                  script.onreadystatechange = function() {
-                    runIfPresent(handle);
-                    script.onreadystatechange = null;
-                    html.removeChild(script);
-                    script = null;
-                  };
-                  html.appendChild(script);
-                };
-              }
-
-              function installSetTimeoutImplementation() {
-                registerImmediate = function(handle) {
-                  setTimeout(runIfPresent, 0, handle);
-                };
-              }
-
-              // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.
-              var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);
-              attachTo = attachTo && attachTo.setTimeout ? attachTo : global;
-
-              // Don't get fooled by e.g. browserify environments.
-              if ({}.toString.call(global.process) === '[object process]') {
-                // For Node.js before 0.9
-                installNextTickImplementation();
-              } else if (canUsePostMessage()) {
-                // For non-IE10 modern browsers
-                installPostMessageImplementation();
-              } else if (global.MessageChannel) {
-                // For web workers, where supported
-                installMessageChannelImplementation();
-              } else if (doc && 'onreadystatechange' in doc.createElement('script')) {
-                // For IE 6–8
-                installReadyStateChangeImplementation();
-              } else {
-                // For older browsers
-                installSetTimeoutImplementation();
-              }
-
-              attachTo.setImmediate = setImmediate;
-              attachTo.clearImmediate = clearImmediate;
-            })(
-              typeof self === 'undefined' ? (typeof global === 'undefined' ? this : global) : self
-            );
-          }.call(
-            this,
-            require('_process'),
-            typeof global !== 'undefined'
-              ? global
-              : typeof self !== 'undefined'
-                ? self
-                : typeof window !== 'undefined'
-                  ? window
-                  : {}
-          ));
-        },
-        { _process: 86 }
-      ],
-      88: [
-        function(require, module, exports) {
-          if (typeof Object.create === 'function') {
-            // implementation from standard node.js 'util' module
-            module.exports = function inherits(ctor, superCtor) {
-              ctor.super_ = superCtor;
-              ctor.prototype = Object.create(superCtor.prototype, {
-                constructor: {
-                  value: ctor,
-                  enumerable: false,
-                  writable: true,
-                  configurable: true
-                }
-              });
-            };
-          } else {
-            // old school shim for old browsers
-            module.exports = function inherits(ctor, superCtor) {
-              ctor.super_ = superCtor;
-              var TempCtor = function() {};
-              TempCtor.prototype = superCtor.prototype;
-              ctor.prototype = new TempCtor();
-              ctor.prototype.constructor = ctor;
-            };
-          }
-        },
-        {}
-      ],
-      89: [
-        function(require, module, exports) {
-          module.exports = function isBuffer(arg) {
-            return (
-              arg &&
-              typeof arg === 'object' &&
-              typeof arg.copy === 'function' &&
-              typeof arg.fill === 'function' &&
-              typeof arg.readUInt8 === 'function'
-            );
-          };
-        },
-        {}
-      ],
-      90: [
-        function(require, module, exports) {
-          (function(process, global) {
-            // Copyright Joyent, Inc. and other Node contributors.
-            //
-            // Permission is hereby granted, free of charge, to any person obtaining a
-            // copy of this software and associated documentation files (the
-            // "Software"), to deal in the Software without restriction, including
-            // without limitation the rights to use, copy, modify, merge, publish,
-            // distribute, sublicense, and/or sell copies of the Software, and to permit
-            // persons to whom the Software is furnished to do so, subject to the
-            // following conditions:
-            //
-            // The above copyright notice and this permission notice shall be included
-            // in all copies or substantial portions of the Software.
-            //
-            // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-            // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-            // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-            // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-            // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-            // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-            // USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-            var formatRegExp = /%[sdj%]/g;
-            exports.format = function(f) {
-              var arguments$1 = arguments;
-
-              if (!isString(f)) {
-                var objects = [];
-                for (var i = 0; i < arguments.length; i++) {
-                  objects.push(inspect(arguments$1[i]));
-                }
-                return objects.join(' ');
-              }
-
-              var i = 1;
-              var args = arguments;
-              var len = args.length;
-              var str = String(f).replace(formatRegExp, function(x) {
-                if (x === '%%') {
-                  return '%';
-                }
-                if (i >= len) {
-                  return x;
-                }
-                switch (x) {
-                  case '%s':
-                    return String(args[i++]);
-                  case '%d':
-                    return Number(args[i++]);
-                  case '%j':
-                    try {
-                      return JSON.stringify(args[i++]);
-                    } catch (_) {
-                      return '[Circular]';
-                    }
-                  default:
-                    return x;
-                }
-              });
-              for (var x = args[i]; i < len; x = args[++i]) {
-                if (isNull(x) || !isObject(x)) {
-                  str += ' ' + x;
-                } else {
-                  str += ' ' + inspect(x);
-                }
-              }
-              return str;
-            };
-
-            // Mark that a method should not be used.
-            // Returns a modified function which warns once by default.
-            // If --no-deprecation is set, then it is a no-op.
-            exports.deprecate = function(fn, msg) {
-              // Allow for deprecating things in the process of starting up.
-              if (isUndefined(global.process)) {
-                return function() {
-                  return exports.deprecate(fn, msg).apply(this, arguments);
-                };
-              }
-
-              if (process.noDeprecation === true) {
-                return fn;
-              }
-
-              var warned = false;
-              function deprecated() {
-                if (!warned) {
-                  if (process.throwDeprecation) {
-                    throw new Error(msg);
-                  } else if (process.traceDeprecation) {
-                    console.trace(msg);
-                  } else {
-                    console.error(msg);
-                  }
-                  warned = true;
-                }
-                return fn.apply(this, arguments);
-              }
-
-              return deprecated;
-            };
-
-            var debugs = {};
-            var debugEnviron;
-            exports.debuglog = function(set) {
-              if (isUndefined(debugEnviron)) {
-                debugEnviron = process.env.NODE_DEBUG || '';
-              }
-              set = set.toUpperCase();
-              if (!debugs[set]) {
-                if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
-                  var pid = process.pid;
-                  debugs[set] = function() {
-                    var msg = exports.format.apply(exports, arguments);
-                    console.error('%s %d: %s', set, pid, msg);
-                  };
-                } else {
-                  debugs[set] = function() {};
-                }
-              }
-              return debugs[set];
-            };
-
-            /**
-             * Echos the value of a value. Trys to print the value out
-             * in the best way possible given the different types.
-             *
-             * @param {Object} obj The object to print out.
-             * @param {Object} opts Optional options object that alters the output.
-             */
-            /* legacy: obj, showHidden, depth, colors*/
-            function inspect(obj, opts) {
-              // default options
-              var ctx = {
-                seen: [],
-                stylize: stylizeNoColor
-              };
-              // legacy...
-              if (arguments.length >= 3) {
-                ctx.depth = arguments[2];
-              }
-              if (arguments.length >= 4) {
-                ctx.colors = arguments[3];
-              }
-              if (isBoolean(opts)) {
-                // legacy...
-                ctx.showHidden = opts;
-              } else if (opts) {
-                // got an "options" object
-                exports._extend(ctx, opts);
-              }
-              // set default options
-              if (isUndefined(ctx.showHidden)) {
-                ctx.showHidden = false;
-              }
-              if (isUndefined(ctx.depth)) {
-                ctx.depth = 2;
-              }
-              if (isUndefined(ctx.colors)) {
-                ctx.colors = false;
-              }
-              if (isUndefined(ctx.customInspect)) {
-                ctx.customInspect = true;
-              }
-              if (ctx.colors) {
-                ctx.stylize = stylizeWithColor;
-              }
-              return formatValue(ctx, obj, ctx.depth);
-            }
-            exports.inspect = inspect;
-
-            // http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
-            inspect.colors = {
-              bold: [1, 22],
-              italic: [3, 23],
-              underline: [4, 24],
-              inverse: [7, 27],
-              white: [37, 39],
-              grey: [90, 39],
-              black: [30, 39],
-              blue: [34, 39],
-              cyan: [36, 39],
-              green: [32, 39],
-              magenta: [35, 39],
-              red: [31, 39],
-              yellow: [33, 39]
-            };
-
-            // Don't use 'blue' not visible on cmd.exe
-            inspect.styles = {
-              special: 'cyan',
-              number: 'yellow',
-              boolean: 'yellow',
-              undefined: 'grey',
-              null: 'bold',
-              string: 'green',
-              date: 'magenta',
-              // "name": intentionally not styling
-              regexp: 'red'
-            };
-
-            function stylizeWithColor(str, styleType) {
-              var style = inspect.styles[styleType];
-
-              if (style) {
-                return (
-                  '\u001b[' +
-                  inspect.colors[style][0] +
-                  'm' +
-                  str +
-                  '\u001b[' +
-                  inspect.colors[style][1] +
-                  'm'
-                );
-              } else {
-                return str;
-              }
-            }
-
-            function stylizeNoColor(str, styleType) {
-              return str;
-            }
-
-            function arrayToHash(array) {
-              var hash = {};
-
-              array.forEach(function(val, idx) {
-                hash[val] = true;
-              });
-
-              return hash;
-            }
-
-            function formatValue(ctx, value, recurseTimes) {
-              // Provide a hook for user-specified inspect functions.
-              // Check that value is an object with an inspect function on it
-              if (
-                ctx.customInspect &&
-                value &&
-                isFunction(value.inspect) &&
-                // Filter out the util module, it's inspect function is special
-                value.inspect !== exports.inspect &&
-                // Also filter out any prototype objects using the circular check.
-                !(value.constructor && value.constructor.prototype === value)
-              ) {
-                var ret = value.inspect(recurseTimes, ctx);
-                if (!isString(ret)) {
-                  ret = formatValue(ctx, ret, recurseTimes);
-                }
-                return ret;
-              }
-
-              // Primitive types cannot have properties
-              var primitive = formatPrimitive(ctx, value);
-              if (primitive) {
-                return primitive;
-              }
-
-              // Look up the keys of the object.
-              var keys = Object.keys(value);
-              var visibleKeys = arrayToHash(keys);
-
-              if (ctx.showHidden) {
-                keys = Object.getOwnPropertyNames(value);
-              }
-
-              // IE doesn't make error fields non-enumerable
-              // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
-              if (
-                isError(value) &&
-                (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)
-              ) {
-                return formatError(value);
-              }
-
-              // Some type of object without properties can be shortcutted.
-              if (keys.length === 0) {
-                if (isFunction(value)) {
-                  var name = value.name ? ': ' + value.name : '';
-                  return ctx.stylize('[Function' + name + ']', 'special');
-                }
-                if (isRegExp(value)) {
-                  return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
-                }
-                if (isDate(value)) {
-                  return ctx.stylize(Date.prototype.toString.call(value), 'date');
-                }
-                if (isError(value)) {
-                  return formatError(value);
-                }
-              }
-
-              var base = '',
-                array = false,
-                braces = ['{', '}'];
-
-              // Make Array say that they are Array
-              if (isArray(value)) {
-                array = true;
-                braces = ['[', ']'];
-              }
-
-              // Make functions say that they are functions
-              if (isFunction(value)) {
-                var n = value.name ? ': ' + value.name : '';
-                base = ' [Function' + n + ']';
-              }
-
-              // Make RegExps say that they are RegExps
-              if (isRegExp(value)) {
-                base = ' ' + RegExp.prototype.toString.call(value);
-              }
-
-              // Make dates with properties first say the date
-              if (isDate(value)) {
-                base = ' ' + Date.prototype.toUTCString.call(value);
-              }
-
-              // Make error with message first say the error
-              if (isError(value)) {
-                base = ' ' + formatError(value);
-              }
-
-              if (keys.length === 0 && (!array || value.length == 0)) {
-                return braces[0] + base + braces[1];
-              }
-
-              if (recurseTimes < 0) {
-                if (isRegExp(value)) {
-                  return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
-                } else {
-                  return ctx.stylize('[Object]', 'special');
-                }
-              }
-
-              ctx.seen.push(value);
-
-              var output;
-              if (array) {
-                output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
-              } else {
-                output = keys.map(function(key) {
-                  return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
-                });
-              }
-
-              ctx.seen.pop();
-
-              return reduceToSingleString(output, base, braces);
-            }
-
-            function formatPrimitive(ctx, value) {
-              if (isUndefined(value)) {
-                return ctx.stylize('undefined', 'undefined');
-              }
-              if (isString(value)) {
-                var simple =
-                  "'" +
-                  JSON.stringify(value)
-                    .replace(/^"|"$/g, '')
-                    .replace(/'/g, "\\'")
-                    .replace(/\\"/g, '"') +
-                  "'";
-                return ctx.stylize(simple, 'string');
-              }
-              if (isNumber(value)) {
-                return ctx.stylize('' + value, 'number');
-              }
-              if (isBoolean(value)) {
-                return ctx.stylize('' + value, 'boolean');
-              }
-              // For some reason typeof null is "object", so special case here.
-              if (isNull(value)) {
-                return ctx.stylize('null', 'null');
-              }
-            }
-
-            function formatError(value) {
-              return '[' + Error.prototype.toString.call(value) + ']';
-            }
-
-            function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
-              var output = [];
-              for (var i = 0, l = value.length; i < l; ++i) {
-                if (hasOwnProperty(value, String(i))) {
-                  output.push(
-                    formatProperty(ctx, value, recurseTimes, visibleKeys, String(i), true)
-                  );
-                } else {
-                  output.push('');
-                }
-              }
-              keys.forEach(function(key) {
-                if (!key.match(/^\d+$/)) {
-                  output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, key, true));
-                }
-              });
-              return output;
-            }
-
-            function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
-              var name, str, desc;
-              desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
-              if (desc.get) {
-                if (desc.set) {
-                  str = ctx.stylize('[Getter/Setter]', 'special');
-                } else {
-                  str = ctx.stylize('[Getter]', 'special');
-                }
-              } else {
-                if (desc.set) {
-                  str = ctx.stylize('[Setter]', 'special');
-                }
-              }
-              if (!hasOwnProperty(visibleKeys, key)) {
-                name = '[' + key + ']';
-              }
-              if (!str) {
-                if (ctx.seen.indexOf(desc.value) < 0) {
-                  if (isNull(recurseTimes)) {
-                    str = formatValue(ctx, desc.value, null);
-                  } else {
-                    str = formatValue(ctx, desc.value, recurseTimes - 1);
-                  }
-                  if (str.indexOf('\n') > -1) {
-                    if (array) {
-                      str = str
-                        .split('\n')
-                        .map(function(line) {
-                          return '  ' + line;
-                        })
-                        .join('\n')
-                        .substr(2);
-                    } else {
-                      str =
-                        '\n' +
-                        str
-                          .split('\n')
-                          .map(function(line) {
-                            return '   ' + line;
-                          })
-                          .join('\n');
-                    }
-                  }
-                } else {
-                  str = ctx.stylize('[Circular]', 'special');
-                }
-              }
-              if (isUndefined(name)) {
-                if (array && key.match(/^\d+$/)) {
-                  return str;
-                }
-                name = JSON.stringify('' + key);
-                if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
-                  name = name.substr(1, name.length - 2);
-                  name = ctx.stylize(name, 'name');
-                } else {
-                  name = name
-                    .replace(/'/g, "\\'")
-                    .replace(/\\"/g, '"')
-                    .replace(/(^"|"$)/g, "'");
-                  name = ctx.stylize(name, 'string');
-                }
-              }
-
-              return name + ': ' + str;
-            }
-
-            function reduceToSingleString(output, base, braces) {
-              var numLinesEst = 0;
-              var length = output.reduce(function(prev, cur) {
-                numLinesEst++;
-                if (cur.indexOf('\n') >= 0) {
-                  numLinesEst++;
-                }
-                return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
-              }, 0);
-
-              if (length > 60) {
-                return (
-                  braces[0] +
-                  (base === '' ? '' : base + '\n ') +
-                  ' ' +
-                  output.join(',\n  ') +
-                  ' ' +
-                  braces[1]
-                );
-              }
-
-              return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
-            }
-
-            // NOTE: These type checking functions intentionally don't use `instanceof`
-            // because it is fragile and can be easily faked with `Object.create()`.
-            function isArray(ar) {
-              return Array.isArray(ar);
-            }
-            exports.isArray = isArray;
-
-            function isBoolean(arg) {
-              return typeof arg === 'boolean';
-            }
-            exports.isBoolean = isBoolean;
-
-            function isNull(arg) {
-              return arg === null;
-            }
-            exports.isNull = isNull;
-
-            function isNullOrUndefined(arg) {
-              return arg == null;
-            }
-            exports.isNullOrUndefined = isNullOrUndefined;
-
-            function isNumber(arg) {
-              return typeof arg === 'number';
-            }
-            exports.isNumber = isNumber;
-
-            function isString(arg) {
-              return typeof arg === 'string';
-            }
-            exports.isString = isString;
-
-            function isSymbol(arg) {
-              return typeof arg === 'symbol';
-            }
-            exports.isSymbol = isSymbol;
-
-            function isUndefined(arg) {
-              return arg === void 0;
-            }
-            exports.isUndefined = isUndefined;
-
-            function isRegExp(re) {
-              return isObject(re) && objectToString(re) === '[object RegExp]';
-            }
-            exports.isRegExp = isRegExp;
-
-            function isObject(arg) {
-              return typeof arg === 'object' && arg !== null;
-            }
-            exports.isObject = isObject;
-
-            function isDate(d) {
-              return isObject(d) && objectToString(d) === '[object Date]';
-            }
-            exports.isDate = isDate;
-
-            function isError(e) {
-              return isObject(e) && (objectToString(e) === '[object Error]' || e instanceof Error);
-            }
-            exports.isError = isError;
-
-            function isFunction(arg) {
-              return typeof arg === 'function';
-            }
-            exports.isFunction = isFunction;
-
-            function isPrimitive(arg) {
-              return (
-                arg === null ||
-                typeof arg === 'boolean' ||
-                typeof arg === 'number' ||
-                typeof arg === 'string' ||
-                typeof arg === 'symbol' || // ES6 symbol
-                typeof arg === 'undefined'
-              );
-            }
-            exports.isPrimitive = isPrimitive;
-
-            exports.isBuffer = require('./support/isBuffer');
-
-            function objectToString(o) {
-              return Object.prototype.toString.call(o);
-            }
-
-            function pad(n) {
-              return n < 10 ? '0' + n.toString(10) : n.toString(10);
-            }
-
-            var months = [
-              'Jan',
-              'Feb',
-              'Mar',
-              'Apr',
-              'May',
-              'Jun',
-              'Jul',
-              'Aug',
-              'Sep',
-              'Oct',
-              'Nov',
-              'Dec'
-            ];
-
-            // 26 Feb 16:19:34
-            function timestamp() {
-              var d = new Date();
-              var time = [pad(d.getHours()), pad(d.getMinutes()), pad(d.getSeconds())].join(':');
-              return [d.getDate(), months[d.getMonth()], time].join(' ');
-            }
-
-            // log is just a thin wrapper to console.log that prepends a timestamp
-            exports.log = function() {
-              console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
-            };
-
-            /**
-             * Inherit the prototype methods from one constructor into another.
-             *
-             * The Function.prototype.inherits from lang.js rewritten as a standalone
-             * function (not on Function.prototype). NOTE: If this file is to be loaded
-             * during bootstrapping this function needs to be rewritten using some native
-             * functions as prototype setup using normal JavaScript does not work as
-             * expected during bootstrapping (see mirror.js in r114903).
-             *
-             * @param {function} ctor Constructor function which needs to inherit the
-             *     prototype.
-             * @param {function} superCtor Constructor function to inherit prototype from.
-             */
-            exports.inherits = require('inherits');
-
-            exports._extend = function(origin, add) {
-              // Don't do anything if add isn't an object
-              if (!add || !isObject(add)) {
-                return origin;
-              }
-
-              var keys = Object.keys(add);
-              var i = keys.length;
-              while (i--) {
-                origin[keys[i]] = add[keys[i]];
-              }
-              return origin;
-            };
-
-            function hasOwnProperty(obj, prop) {
-              return Object.prototype.hasOwnProperty.call(obj, prop);
-            }
-          }.call(
-            this,
-            require('_process'),
-            typeof global !== 'undefined'
-              ? global
-              : typeof self !== 'undefined'
-                ? self
-                : typeof window !== 'undefined'
-                  ? window
-                  : {}
-          ));
-        },
-        { './support/isBuffer': 89, _process: 86, inherits: 88 }
-      ],
-      91: [
-        function(require, module, exports) {
-          module.exports = {
-            name: 'aigle',
-            version: '1.13.1',
-            description:
-              'Aigle is an ideal Promise library, faster and more functional than other Promise libraries',
-            main: 'index.js',
-            typings: 'aigle.d.ts',
-            private: true,
-            browser: 'browser.js',
-            scripts: {
-              'start:doc': 'cd website && npm start',
-              build: 'npm-run-all build:*',
-              'build:lib': 'gulp build',
-              'build:type': 'typeg typings/aigle-base.d.ts --out typings/aigle.d.ts',
-              bench: 'node --expose_gc ./benchmark -d',
-              eslint: 'eslint . --ext .js',
-              test: 'DELAY=50 npm-run-all -p eslint test:type test:cov',
-              'test:mocha': 'mocha test/**/*.js',
-              'test:cov': 'nyc npm run test:mocha',
-              'test:type': 'cd typings && tsc',
-              codecov: 'nyc report --reporter=lcovonly && codecov',
-              'lint-staged': 'lint-staged',
-              prettier:
-                "prettier --write './benchmark/**/*.js' './gulp/**/*.js' './lib/**/*.js' './test/**/*.js' './typings/**/*.ts'"
-            },
-            homepage: 'https://github.com/suguru03/aigle',
-            keywords: ['aigle', 'promise', 'async'],
-            files: ['README.md', 'index.js', 'lib/', 'browser.js', 'dist/'],
-            author: 'Suguru Motegi',
-            license: 'MIT',
-            devDependencies: {
-              babili: '0.1.4',
-              benchmark: '^2.1.1',
-              bluebird: '^3.5.3',
-              browserify: '^16.2.3',
-              buble: '^0.19.6',
-              codecov: '^3.2.0',
-              docdash: '^1.0.0',
-              eslint: '^5.0.0',
-              'fs-extra': '^8.0.0',
-              gulp: '^4.0.0',
-              'gulp-bump': '^3.0.0',
-              'gulp-git': '^2.8.1',
-              'gulp-tag-version': '^1.3.0',
-              husky: '^2.0.0',
-              jsdoc: '^3.5.5',
-              'lint-staged': '^8.0.5',
-              lodash: '^4.15.0',
-              minimist: '^1.2.0',
-              mocha: '^6.0.2',
-              'mocha.parallel': '0.15.6',
-              'neo-async': '^2.6.0',
-              'npm-run-all': '^4.1.5',
-              nyc: '^14.0.0',
-              prettier: '^1.14.3',
-              'require-dir': '^1.0.0',
-              semver: '^6.0.0',
-              setimmediate: '^1.0.5',
-              tslint: '^5.11.0',
-              typeg: '^0.1.3',
-              typescript: '^3.1.6',
-              'uglify-js': '^3.5.1'
-            },
-            dependencies: {
-              'aigle-core': '^1.0.0'
-            },
-            husky: {
-              hooks: {
-                'pre-commit': 'npm-run-all -p build:type lint-staged'
-              }
-            },
-            'lint-staged': {
-              '*.{js,ts}': ['prettier --write', 'git add']
-            },
-            prettier: {
-              printWidth: 100,
-              singleQuote: true
-            }
-          };
-        },
-        {}
-      ]
-    },
-    {},
-    [1]
-  )(1);
-});
diff --git a/dist/aigle-es5.min.js b/dist/aigle-es5.min.js
index 3678ecc8..e69de29b 100644
--- a/dist/aigle-es5.min.js
+++ b/dist/aigle-es5.min.js
@@ -1,5918 +0,0 @@
-!(function(t) {
-  if ('object' == typeof exports && 'undefined' != typeof module) module.exports = t();
-  else if ('function' == typeof define && define.amd) define([], t);
-  else {
-    ('undefined' != typeof window
-      ? window
-      : 'undefined' != typeof global
-        ? global
-        : 'undefined' != typeof self
-          ? self
-          : this
-    ).Promise = t();
-  }
-})(function() {
-  return (function o(n, c, l) {
-    function u(e, t) {
-      if (!c[e]) {
-        if (!n[e]) {
-          var i = 'function' == typeof require && require;
-          if (!t && i) return i(e, !0);
-          if (a) return a(e, !0);
-          var r = new Error("Cannot find module '" + e + "'");
-          throw ((r.code = 'MODULE_NOT_FOUND'), r);
-        }
-        var s = (c[e] = { exports: {} });
-        n[e][0].call(
-          s.exports,
-          function(t) {
-            return u(n[e][1][t] || t);
-          },
-          s,
-          s.exports,
-          o,
-          n,
-          c,
-          l
-        );
-      }
-      return c[e].exports;
-    }
-    for (var a = 'function' == typeof require && require, t = 0; t < l.length; t++) u(l[t]);
-    return u;
-  })(
-    {
-      1: [
-        function(t, e, i) {
-          'use strict';
-          t('setimmediate'), (e.exports = t('./lib/aigle'));
-        },
-        { './lib/aigle': 2, setimmediate: 87 }
-      ],
-      2: [
-        function(mr, dr, t) {
-          (function(l) {
-            'use strict';
-            var t = mr('aigle-core'),
-              n = t.AigleCore,
-              u = t.AigleProxy,
-              c = mr('./internal/queue'),
-              o = mr('./internal/async'),
-              e = mr('./internal/util'),
-              i = e.VERSION,
-              a = e.INTERNAL,
-              h = e.PENDING,
-              _ = e.UNHANDLED,
-              p = e.errorObj,
-              f = e.call0,
-              y = e.callResolve,
-              v = e.callReject,
-              r = e.callReceiver,
-              m = e.printWarning,
-              d = !1,
-              g = (function(e) {
-                function s(t) {
-                  e.call(this),
-                    (this._resolved = 0),
-                    (this._value = void 0),
-                    (this._key = void 0),
-                    (this._receiver = void 0),
-                    (this._onFulfilled = void 0),
-                    (this._onRejected = void 0),
-                    (this._receivers = void 0),
-                    t !== a && this._execute(t);
-                }
-                return (
-                  e && (s.__proto__ = e),
-                  (((s.prototype = Object.create(
-                    e && e.prototype
-                  )).constructor = s).prototype.then = function(t, e) {
-                    return fr(this, new s(a), t, e);
-                  }),
-                  (s.prototype.catch = function(t) {
-                    var e = arguments;
-                    if (1 < arguments.length) {
-                      var i = arguments.length;
-                      if ('function' == typeof (t = arguments[--i])) {
-                        for (var r = Array(i); i--; ) r[i] = e[i];
-                        t = (function(r, s) {
-                          return function(t) {
-                            for (var e = r.length; e--; ) {
-                              var i = r[e];
-                              if (i === Error || i.prototype instanceof Error) {
-                                if (t instanceof i) return s(t);
-                              } else if (i(t)) return s(t);
-                            }
-                            return (p.e = t), p;
-                          };
-                        })(r, t);
-                      }
-                    }
-                    return fr(this, new s(a), void 0, t);
-                  }),
-                  (s.prototype.finally = function(t) {
-                    return (
-                      (t =
-                        'function' != typeof t
-                          ? t
-                          : (function(s, o) {
-                              return function() {
-                                var t = s._resolved,
-                                  e = s._value,
-                                  i = f(o);
-                                if (i === p) return i;
-                                if (i instanceof n)
-                                  switch (i._resolved) {
-                                    case 1:
-                                      return (i._value = e), i;
-                                    case 2:
-                                      return i;
-                                  }
-                                var r = new g(a);
-                                return (
-                                  i && i.then
-                                    ? 1 === t
-                                      ? i.then(
-                                          function() {
-                                            return r._resolve(e);
-                                          },
-                                          function(t) {
-                                            return r._reject(t);
-                                          }
-                                        )
-                                      : i.then(
-                                          function() {
-                                            return r._reject(e);
-                                          },
-                                          function(t) {
-                                            return r._reject(t);
-                                          }
-                                        )
-                                    : ((r._resolved = t), (r._value = e)),
-                                  r
-                                );
-                              };
-                            })(this, t)),
-                      fr(this, new s(a), t, t)
-                    );
-                  }),
-                  (s.prototype.toString = function() {
-                    return '[object Promise]';
-                  }),
-                  (s.prototype.isPending = function() {
-                    return 0 === this._resolved;
-                  }),
-                  (s.prototype.isFulfilled = function() {
-                    return 1 === this._resolved;
-                  }),
-                  (s.prototype.isRejected = function() {
-                    return 2 === this._resolved;
-                  }),
-                  (s.prototype.isCancelled = function() {
-                    return this._value instanceof ur;
-                  }),
-                  (s.prototype.value = function() {
-                    return 1 === this._resolved ? this._value : void 0;
-                  }),
-                  (s.prototype.reason = function() {
-                    return 2 === this._resolved ? this._value : void 0;
-                  }),
-                  (s.prototype.cancel = function() {
-                    if (this._execute !== _r && 0 === this._resolved) {
-                      var t = this._onCancelQueue;
-                      if (t) {
-                        var e = -1,
-                          i = t.array;
-                        for (this._onCancelQueue = void 0; ++e < t.length; ) i[e]();
-                      }
-                      (this._resolved = 2),
-                        (this._value = new ur('late cancellation observer')),
-                        this._parent && this._parent.cancel();
-                    }
-                  }),
-                  (s.prototype.suppressUnhandledRejections = function() {
-                    this._receiver = a;
-                  }),
-                  (s.prototype.spread = function(t) {
-                    return yr(this, new Ni(t));
-                  }),
-                  (s.prototype.all = function() {
-                    return vr(this, R);
-                  }),
-                  (s.prototype.race = function() {
-                    return vr(this, b);
-                  }),
-                  (s.prototype.props = function() {
-                    return vr(this, E);
-                  }),
-                  (s.prototype.parallel = function() {
-                    return vr(this, N);
-                  }),
-                  (s.prototype.series = function() {
-                    return vr(this, T);
-                  }),
-                  (s.prototype.parallelLimit = function(t) {
-                    return vr(this, z, t);
-                  }),
-                  (s.prototype.each = function(t) {
-                    return vr(this, W, t);
-                  }),
-                  (s.prototype.forEach = function(t) {
-                    return vr(this, W, t);
-                  }),
-                  (s.prototype.eachSeries = function(t) {
-                    return vr(this, G, t);
-                  }),
-                  (s.prototype.forEachSeries = function(t) {
-                    return vr(this, G, t);
-                  }),
-                  (s.prototype.eachLimit = function(t, e) {
-                    return vr(this, q, t, e);
-                  }),
-                  (s.prototype.forEachLimit = function(t, e) {
-                    return vr(this, q, t, e);
-                  }),
-                  (s.prototype.map = function(t) {
-                    return vr(this, J, t);
-                  }),
-                  (s.prototype.mapSeries = function(t) {
-                    return vr(this, Y, t);
-                  }),
-                  (s.prototype.mapLimit = function(t, e) {
-                    return vr(this, et, t, e);
-                  }),
-                  (s.prototype.mapValues = function(t) {
-                    return vr(this, st, t);
-                  }),
-                  (s.prototype.mapValuesSeries = function(t) {
-                    return vr(this, ct, t);
-                  }),
-                  (s.prototype.mapValuesLimit = function(t, e) {
-                    return vr(this, at, t, e);
-                  }),
-                  (s.prototype.filter = function(t) {
-                    return vr(this, pt, t);
-                  }),
-                  (s.prototype.filterSeries = function(t) {
-                    return vr(this, vt, t);
-                  }),
-                  (s.prototype.filterLimit = function(t, e) {
-                    return vr(this, gt, t, e);
-                  }),
-                  (s.prototype.reject = function(t) {
-                    return vr(this, St, t);
-                  }),
-                  (s.prototype.rejectSeries = function(t) {
-                    return vr(this, bt, t);
-                  }),
-                  (s.prototype.rejectLimit = function(t, e) {
-                    return vr(this, Et, t, e);
-                  }),
-                  (s.prototype.find = function(t) {
-                    return vr(this, Nt, t);
-                  }),
-                  (s.prototype.findSeries = function(t) {
-                    return vr(this, Tt, t);
-                  }),
-                  (s.prototype.findLimit = function(t, e) {
-                    return vr(this, zt, t, e);
-                  }),
-                  (s.prototype.findIndex = function(t) {
-                    return vr(this, Wt, t);
-                  }),
-                  (s.prototype.findIndexSeries = function(t) {
-                    return vr(this, Gt, t);
-                  }),
-                  (s.prototype.findIndexLimit = function(t, e) {
-                    return vr(this, qt, t, e);
-                  }),
-                  (s.prototype.findKey = function(t) {
-                    return vr(this, Jt, t);
-                  }),
-                  (s.prototype.findKeySeries = function(t) {
-                    return vr(this, Yt, t);
-                  }),
-                  (s.prototype.findKeyLimit = function(t, e) {
-                    return vr(this, ee, t, e);
-                  }),
-                  (s.prototype.pick = function(t) {
-                    for (var e = [], i = arguments.length - 1; 0 < i--; ) e[i] = arguments[i + 1];
-                    return vr(this, se, t, e);
-                  }),
-                  (s.prototype.pickSeries = function(t) {
-                    return this.pickBySeries(t);
-                  }),
-                  (s.prototype.pickLimit = function(t, e) {
-                    return this.pickByLimit(t, e);
-                  }),
-                  (s.prototype.pickBy = function(t) {
-                    return vr(this, ce, t);
-                  }),
-                  (s.prototype.pickBySeries = function(t) {
-                    return vr(this, ae, t);
-                  }),
-                  (s.prototype.pickByLimit = function(t, e) {
-                    return vr(this, pe, t, e);
-                  }),
-                  (s.prototype.omit = function(t) {
-                    for (var e = [], i = arguments.length - 1; 0 < i--; ) e[i] = arguments[i + 1];
-                    return vr(this, ve, t, e);
-                  }),
-                  (s.prototype.omitSeries = function(t) {
-                    return this.omitBySeries(t);
-                  }),
-                  (s.prototype.omitLimit = function(t, e) {
-                    return this.omitByLimit(t, e);
-                  }),
-                  (s.prototype.omitBy = function(t) {
-                    return vr(this, ge, t);
-                  }),
-                  (s.prototype.omitBySeries = function(t) {
-                    return vr(this, Se, t);
-                  }),
-                  (s.prototype.omitByLimit = function(t, e) {
-                    return vr(this, be, t, e);
-                  }),
-                  (s.prototype.reduce = function(t, e) {
-                    return vr(this, Ee, t, e);
-                  }),
-                  (s.prototype.transform = function(t, e) {
-                    return vr(this, Ne, t, e);
-                  }),
-                  (s.prototype.transformSeries = function(t, e) {
-                    return vr(this, Te, t, e);
-                  }),
-                  (s.prototype.transformLimit = function(t, e, i) {
-                    return vr(this, ze, t, e, i);
-                  }),
-                  (s.prototype.sortBy = function(t) {
-                    return vr(this, We, t);
-                  }),
-                  (s.prototype.sortBySeries = function(t) {
-                    return vr(this, Ge, t);
-                  }),
-                  (s.prototype.sortByLimit = function(t, e) {
-                    return vr(this, qe, t, e);
-                  }),
-                  (s.prototype.some = function(t) {
-                    return vr(this, Je, t);
-                  }),
-                  (s.prototype.someSeries = function(t) {
-                    return vr(this, Ye, t);
-                  }),
-                  (s.prototype.someLimit = function(t, e) {
-                    return vr(this, ei, t, e);
-                  }),
-                  (s.prototype.every = function(t) {
-                    return vr(this, si, t);
-                  }),
-                  (s.prototype.everySeries = function(t) {
-                    return vr(this, ci, t);
-                  }),
-                  (s.prototype.everyLimit = function(t, e) {
-                    return vr(this, ai, t, e);
-                  }),
-                  (s.prototype.concat = function(t) {
-                    return vr(this, pi, t);
-                  }),
-                  (s.prototype.concatSeries = function(t) {
-                    return vr(this, vi, t);
-                  }),
-                  (s.prototype.concatLimit = function(t, e) {
-                    return vr(this, gi, t, e);
-                  }),
-                  (s.prototype.groupBy = function(t) {
-                    return vr(this, Si, t);
-                  }),
-                  (s.prototype.groupBySeries = function(t) {
-                    return vr(this, bi, t);
-                  }),
-                  (s.prototype.groupByLimit = function(t, e) {
-                    return vr(this, Ei, t, e);
-                  }),
-                  (s.prototype.delay = function(t) {
-                    return fr(this, new Fi(t));
-                  }),
-                  (s.prototype.timeout = function(t, e) {
-                    return yr(this, new zi(t, e));
-                  }),
-                  (s.prototype.whilst = function(e, i) {
-                    return this.then(function(t) {
-                      return Mi(t, e, i);
-                    });
-                  }),
-                  (s.prototype.doWhilst = function(e, i) {
-                    return this.then(function(t) {
-                      return Di(t, e, i);
-                    });
-                  }),
-                  (s.prototype.until = function(e, i) {
-                    return this.then(function(t) {
-                      return Wi(t, e, i);
-                    });
-                  }),
-                  (s.prototype.doUntil = function(e, i) {
-                    return this.then(function(t) {
-                      return Vi(t, e, i);
-                    });
-                  }),
-                  (s.prototype.thru = function(e) {
-                    return this.then(function(t) {
-                      return Gi(t, e);
-                    });
-                  }),
-                  (s.prototype.tap = function(e) {
-                    return this.then(function(t) {
-                      return Ki(t, e);
-                    });
-                  }),
-                  (s.prototype.times = function(t) {
-                    return vr(this, $i, t);
-                  }),
-                  (s.prototype.timesSeries = function(t) {
-                    return vr(this, Zi, t);
-                  }),
-                  (s.prototype.timesLimit = function(t, e) {
-                    return vr(this, tr, t, e);
-                  }),
-                  (s.prototype.disposer = function(t) {
-                    return new rr(this, t);
-                  }),
-                  (s.prototype._resolve = function(t) {
-                    0 === this._resolved &&
-                      ((this._resolved = 1),
-                      (this._value = t),
-                      void 0 !== this._receiver && this._callResolve());
-                  }),
-                  (s.prototype._callResolve = function() {
-                    var t = this._receiver;
-                    if (
-                      ((this._receiver = void 0),
-                      t instanceof u
-                        ? t._callResolve(this._value, this._key)
-                        : this._key === a
-                          ? t._resolve(this._value)
-                          : y(t, this._onFulfilled, this._value),
-                      this._receivers)
-                    ) {
-                      var e = this._value,
-                        i = this._key,
-                        r = this._receivers;
-                      this._receivers = void 0;
-                      for (var s = -1, o = r.array; ++s < r.length; ) {
-                        var n = o[s],
-                          c = n.receiver,
-                          l = n.onFulfilled;
-                        c instanceof u ? c._callResolve(e, i) : y(c, l, e);
-                      }
-                    }
-                  }),
-                  (s.prototype._reject = function(t) {
-                    if (0 === this._resolved) {
-                      if (((this._resolved = 2), (this._value = t), void 0 === this._receiver))
-                        return (this._receiver = _), void o(this);
-                      d && nr(this), this._callReject();
-                    }
-                  }),
-                  (s.prototype._callReject = function() {
-                    var t = this._receiver;
-                    if ((this._receiver = void 0) === t || t === _)
-                      return m(this._value), void l.emit('unhandledRejection', this._value);
-                    if (
-                      t !== a &&
-                      (t instanceof u
-                        ? t._callReject(this._value)
-                        : this._key === a
-                          ? t._reject(this._value)
-                          : v(t, this._onRejected, this._value),
-                      this._receivers)
-                    ) {
-                      var e = this._value,
-                        i = this._receivers;
-                      this._receivers = void 0;
-                      for (var r = -1, s = i.array; ++r < i.length; ) {
-                        var o = s[r],
-                          n = o.receiver,
-                          c = o.onRejected;
-                        n instanceof u ? n._callReject(e) : v(n, c, e);
-                      }
-                    }
-                  }),
-                  (s.prototype._addReceiver = function(t, e) {
-                    (this._key = e), (this._receiver = t);
-                  }),
-                  s
-                );
-              })(n);
-            (g.prototype._execute = _r), (dr.exports = g), (dr.exports.default = g);
-            var s = mr('./all'),
-              x = s.all,
-              R = s.All,
-              S = mr('./attempt'),
-              j = mr('./race'),
-              L = j.race,
-              b = j.Race,
-              w = mr('./props'),
-              k = w.props,
-              E = w.Props,
-              A = mr('./parallel'),
-              O = A.parallel,
-              N = A.Parallel,
-              I = mr('./series'),
-              B = I.series,
-              T = I.Series,
-              P = mr('./parallelLimit'),
-              F = P.parallelLimit,
-              z = P.ParallelLimit,
-              M = mr('./each'),
-              D = M.each,
-              W = M.Each,
-              V = mr('./eachSeries'),
-              C = V.eachSeries,
-              G = V.EachSeries,
-              K = mr('./eachLimit'),
-              U = K.eachLimit,
-              q = K.EachLimit,
-              H = mr('./map'),
-              $ = H.map,
-              J = H.Map,
-              Q = mr('./mapSeries'),
-              Z = Q.mapSeries,
-              Y = Q.MapSeries,
-              X = mr('./mapLimit'),
-              tt = X.mapLimit,
-              et = X.MapLimit,
-              it = mr('./mapValues'),
-              rt = it.mapValues,
-              st = it.MapValues,
-              ot = mr('./mapValuesSeries'),
-              nt = ot.mapValuesSeries,
-              ct = ot.MapValuesSeries,
-              lt = mr('./mapValuesLimit'),
-              ut = lt.mapValuesLimit,
-              at = lt.MapValuesLimit,
-              ht = mr('./filter'),
-              _t = ht.filter,
-              pt = ht.Filter,
-              ft = mr('./filterSeries'),
-              yt = ft.filterSeries,
-              vt = ft.FilterSeries,
-              mt = mr('./filterLimit'),
-              dt = mt.filterLimit,
-              gt = mt.FilterLimit,
-              xt = mr('./reject'),
-              Rt = xt.reject,
-              St = xt.Reject,
-              jt = mr('./rejectSeries'),
-              Lt = jt.rejectSeries,
-              bt = jt.RejectSeries,
-              wt = mr('./rejectLimit'),
-              kt = wt.rejectLimit,
-              Et = wt.RejectLimit,
-              At = mr('./find'),
-              Ot = At.find,
-              Nt = At.Find,
-              It = mr('./findSeries'),
-              Bt = It.findSeries,
-              Tt = It.FindSeries,
-              Pt = mr('./findLimit'),
-              Ft = Pt.findLimit,
-              zt = Pt.FindLimit,
-              Mt = mr('./findIndex'),
-              Dt = Mt.findIndex,
-              Wt = Mt.FindIndex,
-              Vt = mr('./findIndexSeries'),
-              Ct = Vt.findIndexSeries,
-              Gt = Vt.FindIndexSeries,
-              Kt = mr('./findIndexLimit'),
-              Ut = Kt.findIndexLimit,
-              qt = Kt.FindIndexLimit,
-              Ht = mr('./findKey'),
-              $t = Ht.findKey,
-              Jt = Ht.FindKey,
-              Qt = mr('./findKeySeries'),
-              Zt = Qt.findKeySeries,
-              Yt = Qt.FindKeySeries,
-              Xt = mr('./findKeyLimit'),
-              te = Xt.findKeyLimit,
-              ee = Xt.FindKeyLimit,
-              ie = mr('./pick'),
-              re = ie.pick,
-              se = ie.Pick,
-              oe = mr('./pickBy'),
-              ne = oe.pickBy,
-              ce = oe.PickBy,
-              le = mr('./pickBySeries'),
-              ue = le.pickBySeries,
-              ae = le.PickBySeries,
-              he = mr('./pickByLimit'),
-              _e = he.pickByLimit,
-              pe = he.PickByLimit,
-              fe = mr('./omit'),
-              ye = fe.omit,
-              ve = fe.Omit,
-              me = mr('./omitBy'),
-              de = me.omitBy,
-              ge = me.OmitBy,
-              xe = mr('./omitBySeries'),
-              Re = xe.omitBySeries,
-              Se = xe.OmitBySeries,
-              je = mr('./omitByLimit'),
-              Le = je.omitByLimit,
-              be = je.OmitByLimit,
-              we = mr('./reduce'),
-              ke = we.reduce,
-              Ee = we.Reduce,
-              Ae = mr('./transform'),
-              Oe = Ae.transform,
-              Ne = Ae.Transform,
-              Ie = mr('./transformSeries'),
-              Be = Ie.transformSeries,
-              Te = Ie.TransformSeries,
-              Pe = mr('./transformLimit'),
-              Fe = Pe.transformLimit,
-              ze = Pe.TransformLimit,
-              Me = mr('./sortBy'),
-              De = Me.sortBy,
-              We = Me.SortBy,
-              Ve = mr('./sortBySeries'),
-              Ce = Ve.sortBySeries,
-              Ge = Ve.SortBySeries,
-              Ke = mr('./sortByLimit'),
-              Ue = Ke.sortByLimit,
-              qe = Ke.SortByLimit,
-              He = mr('./some'),
-              $e = He.some,
-              Je = He.Some,
-              Qe = mr('./someSeries'),
-              Ze = Qe.someSeries,
-              Ye = Qe.SomeSeries,
-              Xe = mr('./someLimit'),
-              ti = Xe.someLimit,
-              ei = Xe.SomeLimit,
-              ii = mr('./every'),
-              ri = ii.every,
-              si = ii.Every,
-              oi = mr('./everySeries'),
-              ni = oi.everySeries,
-              ci = oi.EverySeries,
-              li = mr('./everyLimit'),
-              ui = li.everyLimit,
-              ai = li.EveryLimit,
-              hi = mr('./concat'),
-              _i = hi.concat,
-              pi = hi.Concat,
-              fi = mr('./concatSeries'),
-              yi = fi.concatSeries,
-              vi = fi.ConcatSeries,
-              mi = mr('./concatLimit'),
-              di = mi.concatLimit,
-              gi = mi.ConcatLimit,
-              xi = mr('./groupBy'),
-              Ri = xi.groupBy,
-              Si = xi.GroupBy,
-              ji = mr('./groupBySeries'),
-              Li = ji.groupBySeries,
-              bi = ji.GroupBySeries,
-              wi = mr('./groupByLimit'),
-              ki = wi.groupByLimit,
-              Ei = wi.GroupByLimit,
-              Ai = mr('./join'),
-              Oi = Ai.join,
-              Ni = Ai.Spread,
-              Ii = mr('./promisify'),
-              Bi = mr('./promisifyAll'),
-              Ti = mr('./delay'),
-              Pi = Ti.delay,
-              Fi = Ti.Delay,
-              zi = mr('./timeout'),
-              Mi = mr('./whilst').whilst,
-              Di = mr('./doWhilst').doWhilst,
-              Wi = mr('./until').until,
-              Vi = mr('./doUntil'),
-              Ci = mr('./retry'),
-              Gi = mr('./thru'),
-              Ki = mr('./tap'),
-              Ui = mr('./flow'),
-              qi = mr('./times'),
-              Hi = qi.times,
-              $i = qi.Times,
-              Ji = mr('./timesSeries'),
-              Qi = Ji.timesSeries,
-              Zi = Ji.TimesSeries,
-              Yi = mr('./timesLimit'),
-              Xi = Yi.timesLimit,
-              tr = Yi.TimesLimit,
-              er = mr('./using'),
-              ir = er.using,
-              rr = er.Disposer,
-              sr = mr('./debug'),
-              or = sr.resolveStack,
-              nr = sr.reconstructStack,
-              cr = mr('./internal/mixin').createProxy;
-            (g.VERSION = i),
-              ((g.Aigle = g).resolve = hr),
-              (g.reject = function(t, e) {
-                if (2 === arguments.length && 'function' == typeof e) return Rt(t, e);
-                var i = new g(a);
-                return i._reject(t), i;
-              }),
-              (g.all = x),
-              (g.race = L),
-              (g.props = k),
-              (g.series = B),
-              (g.parallel = O),
-              (g.parallelLimit = F),
-              (g.each = D),
-              (g.eachSeries = C),
-              (g.eachLimit = U),
-              (g.forEach = D),
-              (g.forEachSeries = C),
-              (g.forEachLimit = U),
-              (g.map = $),
-              (g.mapSeries = Z),
-              (g.mapLimit = tt),
-              (g.mapValues = rt),
-              (g.mapValuesSeries = nt),
-              (g.mapValuesLimit = ut),
-              (g.filter = _t),
-              (g.filterSeries = yt),
-              (g.filterLimit = dt),
-              (g.rejectSeries = Lt),
-              (g.rejectLimit = kt),
-              (g.find = Ot),
-              (g.findSeries = Bt),
-              (g.findLimit = Ft),
-              (g.findIndex = Dt),
-              (g.findIndexSeries = Ct),
-              (g.findIndexLimit = Ut),
-              (g.findKey = $t),
-              (g.findKeySeries = Zt),
-              (g.findKeyLimit = te),
-              (g.detect = Ot),
-              (g.detectSeries = Bt),
-              (g.detectLimit = Ft),
-              (g.pick = re),
-              (g.pickSeries = ue),
-              (g.pickLimit = _e),
-              (g.pickBy = ne),
-              (g.pickBySeries = ue),
-              (g.pickByLimit = _e),
-              (g.omit = ye),
-              (g.omitSeries = Re),
-              (g.omitLimit = Le),
-              (g.omitBy = de),
-              (g.omitBySeries = Re),
-              (g.omitByLimit = Le),
-              (g.reduce = ke),
-              (g.transform = Oe),
-              (g.transformSeries = Be),
-              (g.transformLimit = Fe),
-              (g.sortBy = De),
-              (g.sortBySeries = Ce),
-              (g.sortByLimit = Ue),
-              (g.some = $e),
-              (g.someSeries = Ze),
-              (g.someLimit = ti),
-              (g.every = ri),
-              (g.everySeries = ni),
-              (g.everyLimit = ui),
-              (g.concat = _i),
-              (g.concatSeries = yi),
-              (g.concatLimit = di),
-              (g.groupBy = Ri),
-              (g.groupBySeries = Li),
-              (g.groupByLimit = ki),
-              (g.attempt = S),
-              (g.try = S),
-              (g.join = Oi),
-              (g.promisify = Ii),
-              (g.promisifyAll = Bi),
-              (g.delay = Pi),
-              (g.whilst = Mi),
-              (g.doWhilst = Di),
-              (g.until = Wi),
-              (g.doUntil = Vi),
-              (g.retry = Ci),
-              (g.thru = Gi),
-              (g.tap = Ki),
-              (g.flow = Ui),
-              (g.times = Hi),
-              (g.timesSeries = Qi),
-              (g.timesLimit = Xi),
-              (g.using = ir),
-              (g.mixin = function(r, t) {
-                void 0 === t && (t = {});
-                var o = t.override,
-                  n = t.promisify;
-                void 0 === n && (n = !0);
-                return (
-                  Object.getOwnPropertyNames(r).forEach(function(t) {
-                    var e = r[t];
-                    if ('function' == typeof e && (!g[t] || o)) {
-                      if ('chain' === t) {
-                        var i = e();
-                        if (i && i.__chain__)
-                          return (
-                            (g.chain = hr),
-                            void (g.prototype.value = function() {
-                              return this;
-                            })
-                          );
-                      }
-                      var s = cr(e, n);
-                      (g[t] = function(t, e, i, r) {
-                        return new s(t, e, i, r)._execute();
-                      }),
-                        (g.prototype[t] = function(t, e, i) {
-                          return vr(this, s, t, e, i);
-                        });
-                    }
-                  }),
-                  g
-                );
-              }),
-              (g.config = function(t) {
-                void 0 !== (t = t || {}).longStackTraces && (d = !!t.longStackTraces);
-                void 0 !== t.cancellation && (g.prototype._execute = t.cancellation ? pr : _r);
-              }),
-              (g.longStackTraces = function() {
-                d = !0;
-              });
-            var lr = mr('./error'),
-              ur = lr.CancellationError,
-              ar = lr.TimeoutError;
-            function hr(t) {
-              if (t instanceof n) return t;
-              var e = new g(a);
-              return r(e, t), e;
-            }
-            function _r(e) {
-              var i = this;
-              d && or(this);
-              try {
-                e(
-                  function(t) {
-                    void 0 !== e && ((e = void 0), r(i, t));
-                  },
-                  function(t) {
-                    void 0 !== e && ((e = void 0), i._reject(t));
-                  }
-                );
-              } catch (t) {
-                if (void 0 === e) return;
-                (e = void 0), this._reject(t);
-              }
-            }
-            function pr(e) {
-              var i = this;
-              d && or(this);
-              try {
-                e(
-                  function(t) {
-                    void 0 !== e &&
-                      (t instanceof g && 0 === t._resolved && (i._parent = t),
-                      (e = void 0),
-                      r(i, t));
-                  },
-                  function(t) {
-                    void 0 !== e && ((e = void 0), i._reject(t));
-                  },
-                  function(t) {
-                    if ('function' != typeof t) throw new TypeError('onCancel must be function');
-                    0 === i._resolved &&
-                      (void 0 === i._onCancelQueue && (i._onCancelQueue = new c()),
-                      i._onCancelQueue.push(t));
-                  }
-                );
-              } catch (t) {
-                if (void 0 === e) return;
-                (e = void 0), this._reject(t);
-              }
-            }
-            function fr(t, e, i, r) {
-              return (
-                d && or(e),
-                void 0 === t._receiver || t._receiver === a
-                  ? (0 !== t._resolved && o(t),
-                    (t._receiver = e),
-                    (t._onFulfilled = i),
-                    (t._onRejected = r))
-                  : t._receiver === _
-                    ? ((t._receiver = e), (t._onFulfilled = i), (t._onRejected = r))
-                    : (t._receivers || (t._receivers = new c()),
-                      t._receivers.push({ receiver: e, onFulfilled: i, onRejected: r })),
-                e
-              );
-            }
-            function yr(t, e) {
-              return d && or(e), 0 !== t._resolved && o(t), (t._receiver = e)._promise;
-            }
-            function vr(t, e, i, r, s) {
-              if (d) {
-                d = !1;
-                var o = vr(t, e, i, r, s);
-                return (d = !0), or(o), o;
-              }
-              switch (t._resolved) {
-                case 0:
-                  var n = new e(h, i, r, s);
-                  return (
-                    void 0 === t._receiver
-                      ? (t._receiver = n)
-                      : (t._receivers || (t._receivers = new c()),
-                        t._receivers.push({ receiver: n })),
-                    n._promise
-                  );
-                case 1:
-                  return new e(t._value, i, r, s)._execute();
-                case 2:
-                  return g.reject(t._value);
-              }
-            }
-            (g.CancellationError = ur), (g.TimeoutError = ar);
-          }.call(this, mr('_process')));
-        },
-        {
-          './all': 3,
-          './attempt': 4,
-          './concat': 5,
-          './concatLimit': 6,
-          './concatSeries': 7,
-          './debug': 8,
-          './delay': 9,
-          './doUntil': 10,
-          './doWhilst': 11,
-          './each': 12,
-          './eachLimit': 13,
-          './eachSeries': 14,
-          './error': 15,
-          './every': 16,
-          './everyLimit': 17,
-          './everySeries': 18,
-          './filter': 19,
-          './filterLimit': 20,
-          './filterSeries': 21,
-          './find': 22,
-          './findIndex': 23,
-          './findIndexLimit': 24,
-          './findIndexSeries': 25,
-          './findKey': 26,
-          './findKeyLimit': 27,
-          './findKeySeries': 28,
-          './findLimit': 29,
-          './findSeries': 30,
-          './flow': 31,
-          './groupBy': 32,
-          './groupByLimit': 33,
-          './groupBySeries': 34,
-          './internal/async': 35,
-          './internal/mixin': 37,
-          './internal/queue': 38,
-          './internal/util': 39,
-          './join': 40,
-          './map': 41,
-          './mapLimit': 42,
-          './mapSeries': 43,
-          './mapValues': 44,
-          './mapValuesLimit': 45,
-          './mapValuesSeries': 46,
-          './omit': 47,
-          './omitBy': 48,
-          './omitByLimit': 49,
-          './omitBySeries': 50,
-          './parallel': 51,
-          './parallelLimit': 52,
-          './pick': 53,
-          './pickBy': 54,
-          './pickByLimit': 55,
-          './pickBySeries': 56,
-          './promisify': 57,
-          './promisifyAll': 58,
-          './props': 59,
-          './race': 60,
-          './reduce': 61,
-          './reject': 62,
-          './rejectLimit': 63,
-          './rejectSeries': 64,
-          './retry': 65,
-          './series': 66,
-          './some': 67,
-          './someLimit': 68,
-          './someSeries': 69,
-          './sortBy': 70,
-          './sortByLimit': 71,
-          './sortBySeries': 72,
-          './tap': 73,
-          './thru': 74,
-          './timeout': 75,
-          './times': 76,
-          './timesLimit': 77,
-          './timesSeries': 78,
-          './transform': 79,
-          './transformLimit': 80,
-          './transformSeries': 81,
-          './until': 82,
-          './using': 83,
-          './whilst': 84,
-          _process: 86,
-          'aigle-core': 85
-        }
-      ],
-      3: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('aigle-core').AigleProxy,
-            s = t('./aigle'),
-            o = t('./internal/util'),
-            n = o.INTERNAL,
-            c = o.PENDING,
-            l = o.iteratorSymbol,
-            u = o.promiseArrayEach,
-            a = o.promiseSetEach,
-            h = t('./props').callResolve,
-            _ = (function(e) {
-              function t(t) {
-                e.call(this),
-                  (this._promise = new s(n)),
-                  (this._rest = void 0),
-                  (this._result = void 0),
-                  t === c
-                    ? (this._callResolve = this._set)
-                    : ((this._callResolve = void 0), this._set(t));
-              }
-              return (
-                e && (t.__proto__ = e),
-                (((t.prototype = Object.create(
-                  e && e.prototype
-                )).constructor = t).prototype._set = function(t) {
-                  if (Array.isArray(t)) {
-                    var e = t.length;
-                    (this._rest = e),
-                      (this._result = Array(e)),
-                      (this._callResolve = h),
-                      u(this, e, t);
-                  } else if (t[l]) {
-                    var i = t.size;
-                    (this._rest = i),
-                      (this._result = Array(i)),
-                      (this._callResolve = h),
-                      a(this, 1 / 0, t);
-                  } else (this._rest = 0), (this._result = []);
-                  return 0 === this._rest && this._promise._resolve(this._result), this;
-                }),
-                (t.prototype._execute = function() {
-                  return this._promise;
-                }),
-                (t.prototype._callReject = function(t) {
-                  this._promise._reject(t);
-                }),
-                t
-              );
-            })(r);
-          e.exports = {
-            all: function(t) {
-              return new _(t)._promise;
-            },
-            All: _
-          };
-        },
-        { './aigle': 2, './internal/util': 39, './props': 59, 'aigle-core': 85 }
-      ],
-      4: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./aigle'),
-            s = t('./internal/util'),
-            o = s.INTERNAL,
-            n = s.callResolve;
-          e.exports = function(t) {
-            var e = new r(o);
-            return n(e, t), e;
-          };
-        },
-        { './aigle': 2, './internal/util': 39 }
-      ],
-      5: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./each').Each,
-            s = t('./internal/util').concatArray,
-            o = t('./internal/collection').setParallel,
-            n = (function(i) {
-              function t(t, e) {
-                i.call(this, t, e, c);
-              }
-              return (
-                i && (t.__proto__ = i),
-                (((t.prototype = Object.create(
-                  i && i.prototype
-                )).constructor = t).prototype._callResolve = function(t, e) {
-                  (this._result[e] = t),
-                    0 == --this._rest && this._promise._resolve(s(this._result));
-                }),
-                t
-              );
-            })(r);
-          function c(t) {
-            return o.call(this, t), (this._result = Array(this._rest)), this;
-          }
-          e.exports = {
-            concat: function(t, e) {
-              return new n(t, e)._execute();
-            },
-            Concat: n
-          };
-        },
-        { './each': 12, './internal/collection': 36, './internal/util': 39 }
-      ],
-      6: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./eachLimit').EachLimit,
-            s = t('./internal/util').concatArray,
-            o = t('./internal/collection').setLimit,
-            n = (function(r) {
-              function t(t, e, i) {
-                r.call(this, t, e, i, c);
-              }
-              return (
-                r && (t.__proto__ = r),
-                (((t.prototype = Object.create(
-                  r && r.prototype
-                )).constructor = t).prototype._callResolve = function(t, e) {
-                  (this._result[e] = t),
-                    0 == --this._rest
-                      ? this._promise._resolve(s(this._result))
-                      : 0 < this._callRest-- && this._iterate();
-                }),
-                t
-              );
-            })(r);
-          function c(t) {
-            return o.call(this, t), (this._result = Array(this._rest)), this;
-          }
-          e.exports = {
-            concatLimit: function(t, e, i) {
-              return new n(t, e, i)._execute();
-            },
-            ConcatLimit: n
-          };
-        },
-        { './eachLimit': 13, './internal/collection': 36, './internal/util': 39 }
-      ],
-      7: [
-        function(t, e, i) {
-          'use strict';
-          var r = (function(i) {
-            function t(t, e) {
-              i.call(this, t, e), (this._result = []);
-            }
-            return (
-              i && (t.__proto__ = i),
-              (((t.prototype = Object.create(
-                i && i.prototype
-              )).constructor = t).prototype._callResolve = function(t) {
-                var e;
-                Array.isArray(t)
-                  ? (e = this._result).push.apply(e, t)
-                  : void 0 !== t && this._result.push(t),
-                  0 == --this._rest ? this._promise._resolve(this._result) : this._iterate();
-              }),
-              t
-            );
-          })(t('./eachSeries').EachSeries);
-          e.exports = {
-            concatSeries: function(t, e) {
-              return new r(t, e)._execute();
-            },
-            ConcatSeries: r
-          };
-        },
-        { './eachSeries': 14 }
-      ],
-      8: [
-        function(t, e, i) {
-          'use strict';
-          function s(t) {
-            for (var e = [], i = t.split('\n'), r = 0; r < i.length; r++) {
-              var s = i[r];
-              /node_modules/.test(s) || e.push(s);
-            }
-            return e;
-          }
-          e.exports = {
-            resolveStack: function(t) {
-              Error.captureStackTrace(t);
-            },
-            reconstructStack: function(t) {
-              var e = t.stack,
-                i = t._value;
-              if (i instanceof Error == !1 || !e) return;
-              i._reconstruct || ((i.stack = s(i.stack).join('\n')), (i._reconstruct = !0));
-              var r = s(e);
-              (r[0] = '\nFrom previous event:'), (i.stack += r.join('\n'));
-            }
-          };
-        },
-        {}
-      ],
-      9: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./aigle'),
-            s = t('./internal/util').INTERNAL,
-            o = (function(i) {
-              function t(t) {
-                i.call(this, s), (this._ms = t), (this._timer = void 0);
-              }
-              return (
-                i && (t.__proto__ = i),
-                (((t.prototype = Object.create(
-                  i && i.prototype
-                )).constructor = t).prototype._resolve = function(t) {
-                  var e = this;
-                  return (
-                    (this._timer = setTimeout(function() {
-                      return i.prototype._resolve.call(e, t);
-                    }, this._ms)),
-                    this
-                  );
-                }),
-                (t.prototype._reject = function(t) {
-                  clearTimeout(this._timer), i.prototype._reject.call(this, t);
-                }),
-                t
-              );
-            })(r);
-          e.exports = {
-            delay: function(t, e) {
-              return new o(t)._resolve(e);
-            },
-            Delay: o
-          };
-        },
-        { './aigle': 2, './internal/util': 39 }
-      ],
-      10: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./doWhilst').DoWhilst,
-            s = t('./until').UntilTester;
-          e.exports = function(t, e, i) {
-            'function' != typeof i && ((i = e), (e = t), (t = void 0));
-            return new r(new s(i), e)._iterate(t);
-          };
-        },
-        { './doWhilst': 11, './until': 82 }
-      ],
-      11: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./whilst'),
-            s = r.AigleWhilst,
-            o = r.WhilstTester,
-            n = (function(i) {
-              function t(t, e) {
-                i.call(this, t, e);
-              }
-              return (
-                i && (t.__proto__ = i),
-                (((t.prototype = Object.create(
-                  i && i.prototype
-                )).constructor = t).prototype._iterate = function(t) {
-                  return this._next(t), this._promise;
-                }),
-                t
-              );
-            })(s);
-          e.exports = {
-            doWhilst: function(t, e, i) {
-              'function' != typeof i && ((i = e), (e = t), (t = void 0));
-              return new n(new o(i), e)._iterate(t);
-            },
-            DoWhilst: n
-          };
-        },
-        { './whilst': 84 }
-      ],
-      12: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('aigle-core').AigleProxy,
-            s = t('./aigle'),
-            o = t('./internal/util'),
-            n = o.INTERNAL,
-            c = o.PENDING,
-            l = t('./internal/collection'),
-            u = l.execute,
-            a = l.setParallel,
-            h = (function(r) {
-              function t(t, e, i) {
-                void 0 === i && (i = _),
-                  r.call(this),
-                  (this._iterator = e),
-                  (this._promise = new s(n)),
-                  (this._coll = void 0),
-                  (this._size = void 0),
-                  (this._rest = void 0),
-                  (this._keys = void 0),
-                  (this._result = void 0),
-                  (this._iterate = void 0),
-                  t === c
-                    ? ((this._set = i),
-                      (this._iterate = this._callResolve),
-                      (this._callResolve = u))
-                    : i.call(this, t);
-              }
-              return (
-                r && (t.__proto__ = r),
-                (((t.prototype = Object.create(
-                  r && r.prototype
-                )).constructor = t).prototype._execute = function() {
-                  return (
-                    0 === this._rest ? this._promise._resolve(this._result) : this._iterate(),
-                    this._promise
-                  );
-                }),
-                (t.prototype._callResolve = function(t) {
-                  (0 != --this._rest && !1 !== t) || this._promise._resolve(this._result);
-                }),
-                (t.prototype._callReject = function(t) {
-                  this._promise._reject(t);
-                }),
-                t
-              );
-            })(r);
-          function _(t) {
-            return a.call(this, t), (this._result = t), this;
-          }
-          e.exports = {
-            each: function(t, e) {
-              return new h(t, e)._execute();
-            },
-            Each: h
-          };
-        },
-        { './aigle': 2, './internal/collection': 36, './internal/util': 39, 'aigle-core': 85 }
-      ],
-      13: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('aigle-core').AigleProxy,
-            o = t('./aigle'),
-            s = t('./internal/util'),
-            n = s.DEFAULT_LIMIT,
-            c = s.INTERNAL,
-            l = s.PENDING,
-            u = t('./internal/collection'),
-            a = u.execute,
-            h = u.setLimit,
-            _ = (function(s) {
-              function t(t, e, i, r) {
-                void 0 === r && (r = p),
-                  s.call(this),
-                  'function' == typeof e && ((i = e), (e = n)),
-                  (this._iterator = i),
-                  (this._promise = new o(c)),
-                  (this._index = 0),
-                  (this._limit = e),
-                  (this._coll = void 0),
-                  (this._rest = void 0),
-                  (this._size = void 0),
-                  (this._keys = void 0),
-                  (this._result = void 0),
-                  (this._iterate = void 0),
-                  (this._callRest = void 0),
-                  t === l
-                    ? ((this._set = r),
-                      (this._iterate = this._callResolve),
-                      (this._callResolve = a))
-                    : r.call(this, t);
-              }
-              return (
-                s && (t.__proto__ = s),
-                (((t.prototype = Object.create(
-                  s && s.prototype
-                )).constructor = t).prototype._execute = function() {
-                  if (0 === this._rest) this._promise._resolve(this._result);
-                  else for (; this._limit--; ) this._iterate();
-                  return this._promise;
-                }),
-                (t.prototype._callResolve = function(t) {
-                  !1 === t
-                    ? ((this._callRest = 0), this._promise._resolve(this._result))
-                    : 0 == --this._rest
-                      ? this._promise._resolve(this._result)
-                      : 0 < this._callRest-- && this._iterate();
-                }),
-                (t.prototype._callReject = function(t) {
-                  (this._callRest = 0), this._promise._reject(t);
-                }),
-                t
-              );
-            })(r);
-          function p(t) {
-            return h.call(this, t), (this._result = t), this;
-          }
-          e.exports = {
-            eachLimit: function(t, e, i) {
-              return new _(t, e, i)._execute();
-            },
-            EachLimit: _
-          };
-        },
-        { './aigle': 2, './internal/collection': 36, './internal/util': 39, 'aigle-core': 85 }
-      ],
-      14: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('aigle-core').AigleProxy,
-            s = t('./aigle'),
-            o = t('./internal/util'),
-            n = o.INTERNAL,
-            c = o.PENDING,
-            l = t('./internal/collection'),
-            u = l.execute,
-            a = l.setSeries,
-            h = (function(r) {
-              function t(t, e, i) {
-                void 0 === i && (i = _),
-                  r.call(this),
-                  (this._iterator = e),
-                  (this._promise = new s(n)),
-                  (this._index = 0),
-                  (this._coll = void 0),
-                  (this._rest = void 0),
-                  (this._size = void 0),
-                  (this._keys = void 0),
-                  (this._result = void 0),
-                  (this._iterate = void 0),
-                  t === c
-                    ? ((this._set = i),
-                      (this._iterate = this._callResolve),
-                      (this._callResolve = u))
-                    : i.call(this, t);
-              }
-              return (
-                r && (t.__proto__ = r),
-                (((t.prototype = Object.create(
-                  r && r.prototype
-                )).constructor = t).prototype._execute = function() {
-                  return (
-                    0 === this._rest ? this._promise._resolve(this._result) : this._iterate(),
-                    this._promise
-                  );
-                }),
-                (t.prototype._callResolve = function(t) {
-                  0 == --this._rest || !1 === t
-                    ? this._promise._resolve(this._result)
-                    : this._iterate();
-                }),
-                (t.prototype._callReject = function(t) {
-                  this._promise._reject(t);
-                }),
-                t
-              );
-            })(r);
-          function _(t) {
-            return a.call(this, t), (this._result = t), this;
-          }
-          e.exports = {
-            eachSeries: function(t, e) {
-              return new h(t, e)._execute();
-            },
-            EachSeries: h
-          };
-        },
-        { './aigle': 2, './internal/collection': 36, './internal/util': 39, 'aigle-core': 85 }
-      ],
-      15: [
-        function(t, e, i) {
-          'use strict';
-          for (var r = ['CancellationError', 'TimeoutError'], s = r.length; s--; ) {
-            var o = r[s],
-              n = (function(t) {
-                function e() {
-                  t.apply(this, arguments);
-                }
-                return (
-                  t && (e.__proto__ = t),
-                  ((e.prototype = Object.create(t && t.prototype)).constructor = e)
-                );
-              })(Error);
-            i[(n.prototype.name = o)] = n;
-          }
-        },
-        {}
-      ],
-      16: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./each').Each,
-            s = t('./internal/util').PENDING,
-            o = t('./internal/collection').setShorthand,
-            n = (function(i) {
-              function t(t, e) {
-                i.call(this, t, e),
-                  (this._result = !0),
-                  t === s ? (this._set = o) : o.call(this, t);
-              }
-              return (
-                i && (t.__proto__ = i),
-                (((t.prototype = Object.create(
-                  i && i.prototype
-                )).constructor = t).prototype._callResolve = function(t) {
-                  t ? 0 == --this._rest && this._promise._resolve(!0) : this._promise._resolve(!1);
-                }),
-                t
-              );
-            })(r);
-          e.exports = {
-            every: function(t, e) {
-              return new n(t, e)._execute();
-            },
-            Every: n
-          };
-        },
-        { './each': 12, './internal/collection': 36, './internal/util': 39 }
-      ],
-      17: [
-        function(t, e, i) {
-          'use strict';
-          var r = (function(r) {
-            function t(t, e, i) {
-              r.call(this, t, e, i), (this._result = !0);
-            }
-            return (
-              r && (t.__proto__ = r),
-              (((t.prototype = Object.create(
-                r && r.prototype
-              )).constructor = t).prototype._callResolve = function(t) {
-                t
-                  ? 0 == --this._rest
-                    ? this._promise._resolve(!0)
-                    : 0 < this._callRest-- && this._iterate()
-                  : this._promise._resolve(!1);
-              }),
-              t
-            );
-          })(t('./eachLimit').EachLimit);
-          e.exports = {
-            everyLimit: function(t, e, i) {
-              return new r(t, e, i)._execute();
-            },
-            EveryLimit: r
-          };
-        },
-        { './eachLimit': 13 }
-      ],
-      18: [
-        function(t, e, i) {
-          'use strict';
-          var r = (function(i) {
-            function t(t, e) {
-              i.call(this, t, e), (this._result = !0);
-            }
-            return (
-              i && (t.__proto__ = i),
-              (((t.prototype = Object.create(
-                i && i.prototype
-              )).constructor = t).prototype._callResolve = function(t) {
-                t
-                  ? 0 == --this._rest
-                    ? this._promise._resolve(!0)
-                    : this._iterate()
-                  : this._promise._resolve(!1);
-              }),
-              t
-            );
-          })(t('./eachSeries.js').EachSeries);
-          e.exports = {
-            everySeries: function(t, e) {
-              return new r(t, e)._execute();
-            },
-            EverySeries: r
-          };
-        },
-        { './eachSeries.js': 14 }
-      ],
-      19: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./each').Each,
-            s = t('./internal/collection').setShorthand,
-            o = t('./internal/util'),
-            n = o.INTERNAL,
-            c = o.compactArray,
-            l = (function(i) {
-              function t(t, e) {
-                i.call(this, t, e, u);
-              }
-              return (
-                i && (t.__proto__ = i),
-                ((t.prototype = Object.create(i && i.prototype)).constructor = t)
-              );
-            })(r);
-          function u(t) {
-            return (
-              s.call(this, t),
-              (this._result = Array(this._rest)),
-              (this._callResolve = void 0 === this._keys ? a : h),
-              this
-            );
-          }
-          function a(t, e) {
-            (this._result[e] = t ? this._coll[e] : n),
-              0 == --this._rest && this._promise._resolve(c(this._result));
-          }
-          function h(t, e) {
-            (this._result[e] = t ? this._coll[this._keys[e]] : n),
-              0 == --this._rest && this._promise._resolve(c(this._result));
-          }
-          (l.prototype._set = u),
-            (e.exports = {
-              filter: function(t, e) {
-                return new l(t, e)._execute();
-              },
-              Filter: l
-            });
-        },
-        { './each': 12, './internal/collection': 36, './internal/util': 39 }
-      ],
-      20: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./eachLimit').EachLimit,
-            s = t('./internal/collection').setLimit,
-            o = t('./internal/util'),
-            n = o.INTERNAL,
-            c = o.compactArray,
-            l = (function(r) {
-              function t(t, e, i) {
-                r.call(this, t, e, i, u);
-              }
-              return (
-                r && (t.__proto__ = r),
-                ((t.prototype = Object.create(r && r.prototype)).constructor = t)
-              );
-            })(r);
-          function u(t) {
-            return (
-              s.call(this, t),
-              (this._result = Array(this._rest)),
-              (this._callResolve = void 0 === this._keys ? a : h),
-              this
-            );
-          }
-          function a(t, e) {
-            (this._result[e] = t ? this._coll[e] : n),
-              0 == --this._rest
-                ? this._promise._resolve(c(this._result))
-                : 0 < this._callRest-- && this._iterate();
-          }
-          function h(t, e) {
-            (this._result[e] = t ? this._coll[this._keys[e]] : n),
-              0 == --this._rest
-                ? this._promise._resolve(c(this._result))
-                : 0 < this._callRest-- && this._iterate();
-          }
-          e.exports = {
-            filterLimit: function(t, e, i) {
-              return new l(t, e, i)._execute();
-            },
-            FilterLimit: l
-          };
-        },
-        { './eachLimit': 13, './internal/collection': 36, './internal/util': 39 }
-      ],
-      21: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./eachSeries').EachSeries,
-            s = t('./internal/collection').setSeries,
-            o = t('./internal/util'),
-            n = o.INTERNAL,
-            c = o.compactArray,
-            l = (function(i) {
-              function t(t, e) {
-                i.call(this, t, e, u);
-              }
-              return (
-                i && (t.__proto__ = i),
-                ((t.prototype = Object.create(i && i.prototype)).constructor = t)
-              );
-            })(r);
-          function u(t) {
-            return (
-              s.call(this, t),
-              (this._result = Array(this._rest)),
-              (this._callResolve = void 0 === this._keys ? a : h),
-              this
-            );
-          }
-          function a(t, e) {
-            (this._result[e] = t ? this._coll[e] : n),
-              0 == --this._rest ? this._promise._resolve(c(this._result)) : this._iterate();
-          }
-          function h(t, e) {
-            (this._result[e] = t ? this._coll[this._keys[e]] : n),
-              0 == --this._rest ? this._promise._resolve(c(this._result)) : this._iterate();
-          }
-          e.exports = {
-            filterSeries: function(t, e) {
-              return new l(t, e)._execute();
-            },
-            FilterSeries: l
-          };
-        },
-        { './eachSeries': 14, './internal/collection': 36, './internal/util': 39 }
-      ],
-      22: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./each').Each,
-            s = t('./internal/collection').setShorthand,
-            o = (function(i) {
-              function t(t, e) {
-                i.call(this, t, e, n);
-              }
-              return (
-                i && (t.__proto__ = i),
-                ((t.prototype = Object.create(i && i.prototype)).constructor = t)
-              );
-            })(r);
-          function n(t) {
-            return s.call(this, t), (this._callResolve = void 0 === this._keys ? c : l), this;
-          }
-          function c(t, e) {
-            t
-              ? ((this._size = 0), this._promise._resolve(this._coll[e]))
-              : 0 == --this._rest && this._promise._resolve();
-          }
-          function l(t, e) {
-            t
-              ? ((this._size = 0), this._promise._resolve(this._coll[this._keys[e]]))
-              : 0 == --this._rest && this._promise._resolve();
-          }
-          e.exports = {
-            find: function(t, e) {
-              return new o(t, e)._execute();
-            },
-            Find: o
-          };
-        },
-        { './each': 12, './internal/collection': 36 }
-      ],
-      23: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./each').Each,
-            s = t('./internal/collection').setShorthand,
-            o = (function(i) {
-              function t(t, e) {
-                i.call(this, t, e, n), (this._result = -1);
-              }
-              return (
-                i && (t.__proto__ = i),
-                (((t.prototype = Object.create(
-                  i && i.prototype
-                )).constructor = t).prototype._callResolve = function(t, e) {
-                  t
-                    ? ((this._size = 0), this._promise._resolve(e))
-                    : 0 == --this._rest && this._promise._resolve(-1);
-                }),
-                t
-              );
-            })(r);
-          function n(t) {
-            return s.call(this, t), void 0 !== this._keys && (this._rest = 0), this;
-          }
-          e.exports = {
-            findIndex: function(t, e) {
-              return new o(t, e)._execute();
-            },
-            FindIndex: o
-          };
-        },
-        { './each': 12, './internal/collection': 36 }
-      ],
-      24: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./eachLimit').EachLimit,
-            s = t('./internal/collection').setLimit,
-            o = (function(r) {
-              function t(t, e, i) {
-                r.call(this, t, e, i, n), (this._result = -1);
-              }
-              return (
-                r && (t.__proto__ = r),
-                (((t.prototype = Object.create(
-                  r && r.prototype
-                )).constructor = t).prototype._callResolve = function(t, e) {
-                  t
-                    ? ((this._callRest = 0), this._promise._resolve(e))
-                    : 0 == --this._rest
-                      ? this._promise._resolve(-1)
-                      : 0 < this._callRest-- && this._iterate();
-                }),
-                t
-              );
-            })(r);
-          function n(t) {
-            return s.call(this, t), void 0 !== this._keys && (this._rest = 0), this;
-          }
-          e.exports = {
-            findIndexLimit: function(t, e, i) {
-              return new o(t, e, i)._execute();
-            },
-            FindIndexLimit: o
-          };
-        },
-        { './eachLimit': 13, './internal/collection': 36 }
-      ],
-      25: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./eachSeries').EachSeries,
-            s = t('./internal/collection').setSeries,
-            o = (function(i) {
-              function t(t, e) {
-                i.call(this, t, e, n), (this._result = -1);
-              }
-              return (
-                i && (t.__proto__ = i),
-                (((t.prototype = Object.create(
-                  i && i.prototype
-                )).constructor = t).prototype._callResolve = function(t, e) {
-                  t
-                    ? this._promise._resolve(e)
-                    : 0 == --this._rest
-                      ? this._promise._resolve(-1)
-                      : this._iterate();
-                }),
-                t
-              );
-            })(r);
-          function n(t) {
-            return s.call(this, t), void 0 !== this._keys && (this._rest = 0), this;
-          }
-          e.exports = {
-            findIndexSeries: function(t, e) {
-              return new o(t, e)._execute();
-            },
-            FindIndexSeries: o
-          };
-        },
-        { './eachSeries': 14, './internal/collection': 36 }
-      ],
-      26: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./each').Each,
-            s = t('./internal/collection').setShorthand,
-            o = (function(i) {
-              function t(t, e) {
-                i.call(this, t, e, n);
-              }
-              return (
-                i && (t.__proto__ = i),
-                ((t.prototype = Object.create(i && i.prototype)).constructor = t)
-              );
-            })(r);
-          function n(t) {
-            return s.call(this, t), (this._callResolve = void 0 === this._keys ? c : l), this;
-          }
-          function c(t, e) {
-            t
-              ? ((this._size = 0), this._promise._resolve('' + e))
-              : 0 == --this._rest && this._promise._resolve();
-          }
-          function l(t, e) {
-            t
-              ? ((this._size = 0), this._promise._resolve(this._keys[e]))
-              : 0 == --this._rest && this._promise._resolve();
-          }
-          e.exports = {
-            findKey: function(t, e) {
-              return new o(t, e)._execute();
-            },
-            FindKey: o
-          };
-        },
-        { './each': 12, './internal/collection': 36 }
-      ],
-      27: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./eachLimit').EachLimit,
-            s = t('./internal/collection').setLimit,
-            o = (function(r) {
-              function t(t, e, i) {
-                r.call(this, t, e, i, n);
-              }
-              return (
-                r && (t.__proto__ = r),
-                ((t.prototype = Object.create(r && r.prototype)).constructor = t)
-              );
-            })(r);
-          function n(t) {
-            return s.call(this, t), (this._callResolve = void 0 === this._keys ? c : l), this;
-          }
-          function c(t, e) {
-            t
-              ? ((this._callRest = 0), this._promise._resolve('' + e))
-              : 0 == --this._rest
-                ? this._promise._resolve()
-                : 0 < this._callRest-- && this._iterate();
-          }
-          function l(t, e) {
-            t
-              ? ((this._callRest = 0), this._promise._resolve(this._keys[e]))
-              : 0 == --this._rest
-                ? this._promise._resolve()
-                : 0 < this._callRest-- && this._iterate();
-          }
-          e.exports = {
-            findKeyLimit: function(t, e, i) {
-              return new o(t, e, i)._execute();
-            },
-            FindKeyLimit: o
-          };
-        },
-        { './eachLimit': 13, './internal/collection': 36 }
-      ],
-      28: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./eachSeries').EachSeries,
-            s = t('./internal/collection').setSeries,
-            o = (function(i) {
-              function t(t, e) {
-                i.call(this, t, e, n);
-              }
-              return (
-                i && (t.__proto__ = i),
-                ((t.prototype = Object.create(i && i.prototype)).constructor = t)
-              );
-            })(r);
-          function n(t) {
-            return s.call(this, t), (this._callResolve = void 0 === this._keys ? c : l), this;
-          }
-          function c(t, e) {
-            t
-              ? this._promise._resolve('' + e)
-              : 0 == --this._rest
-                ? this._promise._resolve()
-                : this._iterate();
-          }
-          function l(t, e) {
-            t
-              ? this._promise._resolve(this._keys[e])
-              : 0 == --this._rest
-                ? this._promise._resolve()
-                : this._iterate();
-          }
-          e.exports = {
-            findKeySeries: function(t, e) {
-              return new o(t, e)._execute();
-            },
-            FindKeySeries: o
-          };
-        },
-        { './eachSeries': 14, './internal/collection': 36 }
-      ],
-      29: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./eachLimit').EachLimit,
-            s = t('./internal/collection').setLimit,
-            o = (function(r) {
-              function t(t, e, i) {
-                r.call(this, t, e, i, n);
-              }
-              return (
-                r && (t.__proto__ = r),
-                ((t.prototype = Object.create(r && r.prototype)).constructor = t)
-              );
-            })(r);
-          function n(t) {
-            return s.call(this, t), (this._callResolve = void 0 === this._keys ? c : l), this;
-          }
-          function c(t, e) {
-            t
-              ? ((this._callRest = 0), this._promise._resolve(this._coll[e]))
-              : 0 == --this._rest
-                ? this._promise._resolve()
-                : 0 < this._callRest-- && this._iterate();
-          }
-          function l(t, e) {
-            t
-              ? ((this._callRest = 0), this._promise._resolve(this._coll[this._keys[e]]))
-              : 0 == --this._rest
-                ? this._promise._resolve()
-                : 0 < this._callRest-- && this._iterate();
-          }
-          e.exports = {
-            findLimit: function(t, e, i) {
-              return new o(t, e, i)._execute();
-            },
-            FindLimit: o
-          };
-        },
-        { './eachLimit': 13, './internal/collection': 36 }
-      ],
-      30: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./eachSeries').EachSeries,
-            s = t('./internal/collection').setSeries,
-            o = (function(i) {
-              function t(t, e) {
-                i.call(this, t, e, n);
-              }
-              return (
-                i && (t.__proto__ = i),
-                ((t.prototype = Object.create(i && i.prototype)).constructor = t)
-              );
-            })(r);
-          function n(t) {
-            return s.call(this, t), (this._callResolve = void 0 === this._keys ? c : l), this;
-          }
-          function c(t, e) {
-            t
-              ? this._promise._resolve(this._coll[e])
-              : 0 == --this._rest
-                ? this._promise._resolve()
-                : this._iterate();
-          }
-          function l(t, e) {
-            t
-              ? this._promise._resolve(this._coll[this._keys[e]])
-              : 0 == --this._rest
-                ? this._promise._resolve()
-                : this._iterate();
-          }
-          e.exports = {
-            findSeries: function(t, e) {
-              return new o(t, e)._execute();
-            },
-            FindSeries: o
-          };
-        },
-        { './eachSeries': 14, './internal/collection': 36 }
-      ],
-      31: [
-        function(t, e, i) {
-          'use strict';
-          var o = t('./aigle');
-          function n(t) {
-            return t;
-          }
-          e.exports = function() {
-            var t = [],
-              e = arguments.length;
-            for (; e--; ) t[e] = arguments[e];
-            var i = (function(t) {
-                var e = t.length,
-                  i = [],
-                  r = -1;
-                for (; ++r < e; ) {
-                  var s = t[r];
-                  Array.isArray(s) ? i.push.apply(i, s) : i.push(s);
-                }
-                return i;
-              })(t),
-              r = i[0];
-            void 0 === r && (r = n);
-            var s = i.slice(1);
-            return function() {
-              for (var t = [], e = arguments.length; e--; ) t[e] = arguments[e];
-              return o.resolve(r.apply(void 0, t)).then(function(t) {
-                return o.reduce(
-                  s,
-                  function(t, e) {
-                    return e(t);
-                  },
-                  t
-                );
-              });
-            };
-          };
-        },
-        { './aigle': 2 }
-      ],
-      32: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./each').Each,
-            s = t('./internal/collection').setShorthand,
-            o = (function(i) {
-              function t(t, e) {
-                i.call(this, t, e, n), (this._result = {});
-              }
-              return (
-                i && (t.__proto__ = i),
-                ((t.prototype = Object.create(i && i.prototype)).constructor = t)
-              );
-            })(r);
-          function n(t) {
-            return s.call(this, t), (this._callResolve = void 0 === this._keys ? c : l), this;
-          }
-          function c(t, e) {
-            this._result[t]
-              ? this._result[t].push(this._coll[e])
-              : (this._result[t] = [this._coll[e]]),
-              0 == --this._rest && this._promise._resolve(this._result);
-          }
-          function l(t, e) {
-            this._result[t]
-              ? this._result[t].push(this._coll[this._keys[e]])
-              : (this._result[t] = [this._coll[this._keys[e]]]),
-              0 == --this._rest && this._promise._resolve(this._result);
-          }
-          e.exports = {
-            groupBy: function(t, e) {
-              return new o(t, e)._execute();
-            },
-            GroupBy: o
-          };
-        },
-        { './each': 12, './internal/collection': 36 }
-      ],
-      33: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./eachLimit').EachLimit,
-            s = t('./internal/collection').setLimit,
-            o = (function(r) {
-              function t(t, e, i) {
-                r.call(this, t, e, i, n), (this._result = {});
-              }
-              return (
-                r && (t.__proto__ = r),
-                ((t.prototype = Object.create(r && r.prototype)).constructor = t)
-              );
-            })(r);
-          function n(t) {
-            return s.call(this, t), (this._callResolve = void 0 === this._keys ? c : l), this;
-          }
-          function c(t, e) {
-            this._result[t]
-              ? this._result[t].push(this._coll[e])
-              : (this._result[t] = [this._coll[e]]),
-              0 == --this._rest
-                ? this._promise._resolve(this._result)
-                : 0 < this._callRest-- && this._iterate();
-          }
-          function l(t, e) {
-            this._result[t]
-              ? this._result[t].push(this._coll[this._keys[e]])
-              : (this._result[t] = [this._coll[this._keys[e]]]),
-              0 == --this._rest
-                ? this._promise._resolve(this._result)
-                : 0 < this._callRest-- && this._iterate();
-          }
-          e.exports = {
-            groupByLimit: function(t, e, i) {
-              return new o(t, e, i)._execute();
-            },
-            GroupByLimit: o
-          };
-        },
-        { './eachLimit': 13, './internal/collection': 36 }
-      ],
-      34: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./eachSeries').EachSeries,
-            s = t('./internal/collection').setSeries,
-            o = (function(i) {
-              function t(t, e) {
-                i.call(this, t, e, n), (this._result = {});
-              }
-              return (
-                i && (t.__proto__ = i),
-                ((t.prototype = Object.create(i && i.prototype)).constructor = t)
-              );
-            })(r);
-          function n(t) {
-            return s.call(this, t), (this._callResolve = void 0 === this._keys ? c : l), this;
-          }
-          function c(t, e) {
-            this._result[t]
-              ? this._result[t].push(this._coll[e])
-              : (this._result[t] = [this._coll[e]]),
-              0 == --this._rest ? this._promise._resolve(this._result) : this._iterate();
-          }
-          function l(t, e) {
-            this._result[t]
-              ? this._result[t].push(this._coll[this._keys[e]])
-              : (this._result[t] = [this._coll[this._keys[e]]]),
-              0 == --this._rest ? this._promise._resolve(this._result) : this._iterate();
-          }
-          e.exports = {
-            groupBySeries: function(t, e) {
-              return new o(t, e)._execute();
-            },
-            GroupBySeries: o
-          };
-        },
-        { './eachSeries': 14, './internal/collection': 36 }
-      ],
-      35: [
-        function(t, e, i) {
-          'use strict';
-          var r = Array(8),
-            s = 0,
-            o = !1;
-          function n() {
-            for (var t = -1; ++t < s; ) {
-              var e = r[t];
-              switch (((r[t] = void 0), e._resolved)) {
-                case 1:
-                  e._callResolve();
-                  break;
-                case 2:
-                  e._callReject();
-              }
-            }
-            (s = 0), (o = !1);
-          }
-          e.exports = function(t) {
-            !1 === o && (setImmediate(n), (o = !0)), (r[s++] = t);
-          };
-        },
-        {}
-      ],
-      36: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./util'),
-            l = r.call3,
-            u = r.callProxyReciever,
-            s = [
-              [d, g],
-              [d, x],
-              [
-                function() {
-                  var t = this._coll,
-                    e = this._index++;
-                  u(l(this._iterator, t[e], e, t), this, e);
-                },
-                function() {
-                  var t = this._coll,
-                    e = this._index++,
-                    i = this._keys[e];
-                  u(l(this._iterator, t[i], i, t), this, e);
-                }
-              ]
-            ].map(function(t) {
-              var i = t[0],
-                r = t[1];
-              return function(t) {
-                if (Array.isArray(t))
-                  (this._coll = t), (this._size = t.length), (this._iterate = i);
-                else if (t && 'object' == typeof t) {
-                  var e = Object.keys(t);
-                  (this._coll = t), (this._size = e.length), (this._keys = e), (this._iterate = r);
-                } else this._size = 0;
-                return (this._rest = this._size), this;
-              };
-            }),
-            o = s[0],
-            n = s[1],
-            c = s[2],
-            a = [
-              d,
-              function() {
-                var t = this._iterator,
-                  e = this._coll,
-                  i = -1;
-                for (; ++i < this._size; ) {
-                  var r = e[i];
-                  r ? this._callResolve(r[t], i) : this._callResolve(void 0, i);
-                }
-              },
-              function() {
-                var t = this._iterator,
-                  e = this._coll,
-                  i = Object.keys(t),
-                  r = -1;
-                t: for (; ++r < this._size; ) {
-                  var s = e[r];
-                  if (s) {
-                    for (var o = i.length; o--; ) {
-                      var n = i[o];
-                      if (s[n] !== t[n]) {
-                        this._callResolve(!1, r);
-                        continue t;
-                      }
-                    }
-                    this._callResolve(!0, r);
-                  } else this._callResolve(void 0, r);
-                }
-              },
-              function() {
-                var t = this._coll,
-                  e = this._iterator,
-                  i = e[0],
-                  r = e[1],
-                  s = -1;
-                for (; ++s < this._size; ) {
-                  var o = t[s];
-                  o ? this._callResolve(o[i] === r, s) : this._callResolve(void 0, s);
-                }
-              }
-            ],
-            h = [
-              g,
-              function() {
-                var t = this._iterator,
-                  e = this._coll,
-                  i = this._keys,
-                  r = -1;
-                for (; ++r < this._size; ) {
-                  var s = e[i[r]];
-                  s ? this._callResolve(s[t], r) : this._callResolve(void 0, r);
-                }
-              },
-              function() {
-                var t = this._iterator,
-                  e = this._coll,
-                  i = this._keys,
-                  r = Object.keys(t),
-                  s = -1;
-                t: for (; ++s < this._size; ) {
-                  var o = e[i[s]];
-                  if (o) {
-                    for (var n = r.length; n--; ) {
-                      var c = r[n];
-                      if (o[c] !== t[c]) {
-                        this._callResolve(!1, s);
-                        continue t;
-                      }
-                    }
-                    this._callResolve(!0, s);
-                  } else this._callResolve(void 0, s);
-                }
-              },
-              function() {
-                var t = this._coll,
-                  e = this._keys,
-                  i = this._iterator,
-                  r = i[0],
-                  s = i[1],
-                  o = -1;
-                for (; ++o < this._size; ) {
-                  var n = t[e[o]];
-                  n ? this._callResolve(n[r] === s, o) : this._callResolve(void 0, o);
-                }
-              }
-            ],
-            _ = [
-              [a, h],
-              [a, [x].concat(h.slice(1))],
-              [a.slice(0, 3).concat([R]), h.slice(0, 3).concat([R])],
-              [a.slice(0, 3).concat([S]), h.slice(0, 3).concat([S])]
-            ].map(function(t) {
-              var e = t.map(m),
-                i = e[0],
-                r = e[1];
-              return function(t) {
-                if (Array.isArray(t))
-                  (this._coll = t), (this._size = t.length), (this._iterate = i(this._iterator));
-                else if (t && 'object' == typeof t) {
-                  var e = Object.keys(t);
-                  (this._coll = t),
-                    (this._size = e.length),
-                    (this._keys = e),
-                    (this._iterate = r(this._iterator));
-                } else this._size = 0;
-                return (this._rest = this._size), this;
-              };
-            }),
-            p = _[0],
-            f = _[1],
-            y = _[2],
-            v = _[3];
-          function m(t) {
-            var e = t[0],
-              i = t[1],
-              r = t[2],
-              s = t[3];
-            return function(t) {
-              switch (typeof t) {
-                case 'function':
-                  return e;
-                case 'string':
-                  return i;
-                case 'object':
-                  return Array.isArray(t) ? s : r;
-              }
-            };
-          }
-          function d() {
-            for (
-              var t = this._rest, e = this._iterator, i = this._coll, r = -1;
-              ++r < t && u(l(e, i[r], r, i), this, r);
-
-            );
-          }
-          function g() {
-            for (
-              var t = this._rest, e = this._iterator, i = this._coll, r = this._keys, s = -1;
-              ++s < t;
-
-            ) {
-              var o = r[s];
-              if (!1 === u(l(e, i[o], o, i), this, s)) break;
-            }
-          }
-          function x() {
-            for (
-              var t = this,
-                e = t._rest,
-                i = t._iterator,
-                r = t._coll,
-                s = t._keys,
-                o = t._result,
-                n = -1;
-              ++n < e;
-
-            ) {
-              var c = s[n];
-              if (((o[c] = void 0), !1 === u(l(i, r[c], c, r), this, n))) break;
-            }
-          }
-          function R() {
-            var s = this._coll,
-              o = this._result;
-            !(function t(e) {
-              var i = -1;
-              for (; ++i < e.length; ) {
-                var r = e[i];
-                Array.isArray(r) ? t(r) : s.hasOwnProperty(r) && (o[r] = s[r]);
-              }
-            })(this._iterator),
-              this._promise._resolve(o);
-          }
-          function S() {
-            var e = this._coll,
-              i = this._result,
-              s = {};
-            !(function t(e) {
-              var i = -1;
-              for (; ++i < e.length; ) {
-                var r = e[i];
-                Array.isArray(r) ? t(r) : (s[r] = !0);
-              }
-            })(this._iterator),
-              Object.keys(e).forEach(function(t) {
-                !1 === s.hasOwnProperty(t) && (i[t] = e[t]);
-              }),
-              this._promise._resolve(i);
-          }
-          e.exports = {
-            execute: function(t) {
-              (this._callResolve = this._iterate), this._set(t), this._execute();
-            },
-            setParallel: o,
-            setParallelWithOrder: n,
-            setShorthand: p,
-            setShorthandWithOrder: f,
-            setPickShorthand: y,
-            setOmitShorthand: v,
-            setSeries: c,
-            setLimit: function(t) {
-              c.call(this, t);
-              var e = this._limit,
-                i = this._size;
-              return (this._limit = e < i ? e : i), (this._callRest = i - this._limit), this;
-            }
-          };
-        },
-        { './util': 39 }
-      ],
-      37: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('aigle-core').AigleProxy,
-            s = t('../aigle'),
-            o = t('../map').map,
-            n = t('../mapValues').mapValues,
-            c = t('./util'),
-            l = c.INTERNAL,
-            u = c.PENDING,
-            a = c.apply,
-            h = c.callProxyReciever;
-          e.exports = {
-            createProxy: function(r, t) {
-              var s = t ? f : p;
-              return (function(i) {
-                function t() {
-                  for (var t = [], e = arguments.length; e--; ) t[e] = arguments[e];
-                  i.call(this, r, s, t);
-                }
-                return (
-                  i && (t.__proto__ = i),
-                  ((t.prototype = Object.create(i && i.prototype)).constructor = t)
-                );
-              })(_);
-            }
-          };
-          var _ = (function(r) {
-            function t(t, e, i) {
-              r.call(this),
-                (this._promise = new s(l)),
-                (this._func = t),
-                (this._args = i),
-                (this._execute = e),
-                i[0] === u && ((this._set = this._callResolve), (this._callResolve = e));
-            }
-            return (
-              r && (t.__proto__ = r),
-              (((t.prototype = Object.create(
-                r && r.prototype
-              )).constructor = t).prototype._callResolve = function(t) {
-                this._promise._resolve(t);
-              }),
-              (t.prototype._callReject = function(t) {
-                this._promise._reject(t);
-              }),
-              t
-            );
-          })(r);
-          function p(t) {
-            var e = this._args;
-            return (
-              e[0] === u && ((e[0] = t), (this._callResolve = this._set)),
-              h(a(this._func, e), this),
-              this._promise
-            );
-          }
-          function f(t) {
-            var r = this,
-              s = this._args;
-            s[0] === u ? ((s[0] = t), (this._callResolve = this._set)) : (t = s[0]);
-            var e = 'function' == typeof s[1];
-            return (
-              e && Array.isArray(t)
-                ? y(this, o, function(t) {
-                    var e = 0;
-                    (s[1] = function() {
-                      return t[e++];
-                    }),
-                      h(a(r._func, s), r);
-                  })
-                : e && t && 'object' == typeof t
-                  ? y(this, n, function(t) {
-                      var e = 0,
-                        i = Object.keys(t);
-                      (s[1] = function() {
-                        return t[i[e++]];
-                      }),
-                        h(a(r._func, s), r);
-                    })
-                  : h(a(this._func, s), this),
-              this._promise
-            );
-          }
-          function y(e, t, i) {
-            var r = e._args,
-              s = r[0],
-              o = r[1],
-              n = t(s, function(t, e) {
-                return o(t, e, s);
-              });
-            return 1 === n._resolved
-              ? i(n._value)
-              : n.then(i, function(t) {
-                  return e._callReject(t);
-                });
-          }
-        },
-        { '../aigle': 2, '../map': 41, '../mapValues': 44, './util': 39, 'aigle-core': 85 }
-      ],
-      38: [
-        function(t, e, i) {
-          'use strict';
-          var r = function(t) {
-            void 0 === t && (t = 8), (this.array = Array(t)), (this.length = 0);
-          };
-          (r.prototype.push = function(t) {
-            this.array[this.length++] = t;
-          }),
-            (e.exports = r);
-        },
-        {}
-      ],
-      39: [
-        function(I, B, t) {
-          (function(t) {
-            'use strict';
-            var r = I('aigle-core').AigleCore,
-              e = I('../../package.json').version,
-              s = { e: void 0 },
-              c = 'function' == typeof Symbol ? Symbol.iterator : function() {},
-              i = 'object' == typeof t && '[object process]' === Object.prototype.toString.call(t),
-              o = [
-                function(r) {
-                  return function(t, e, i) {
-                    return r(e[i], t, i);
-                  };
-                },
-                function(n) {
-                  return function(t, e, i, r, s) {
-                    var o = s[i];
-                    return (r[o] = void 0), n(e[o], t, o);
-                  };
-                },
-                function(s) {
-                  return function(t, e, i) {
-                    var r = e.next();
-                    return !1 === r.done && s(r.value, t, i);
-                  };
-                },
-                function(l) {
-                  return function(t, e, i, r) {
-                    var s = e.next();
-                    if (s.done) return !1;
-                    var o = s.value,
-                      n = o[0],
-                      c = o[1];
-                    return r.set(n, void 0), l(c, t, n);
-                  };
-                }
-              ].map(function(t) {
-                return [E, A].map(t);
-              }),
-              n = o[0][1],
-              l = o[1][1],
-              u = o[2][1],
-              a = o[3][1],
-              h = [
-                function(s) {
-                  return function(t, e, i) {
-                    for (var r = -1; ++r < e && s(t, i, r); );
-                  };
-                },
-                function(n) {
-                  return function(t, e, i, r, s) {
-                    for (var o = -1; ++o < e && n(t, i, o, r, s); );
-                  };
-                },
-                function(o) {
-                  return function(t, e, i) {
-                    for (var r = i[c](), s = -1; ++s < e && o(t, r, s); );
-                  };
-                },
-                function(n) {
-                  return function(t, e, i, r) {
-                    for (var s = i[c](), o = -1; ++o < e && n(t, s, o, r); );
-                  };
-                }
-              ].map(function(t, e) {
-                return o[e].map(t);
-              }),
-              _ = h[0],
-              p = _[0],
-              f = _[1],
-              y = h[1],
-              v = y[0],
-              m = y[1],
-              d = h[2],
-              g = d[0],
-              x = d[1],
-              R = h[3],
-              S = R[0],
-              j = R[1];
-            function L() {}
-            function b(t, e) {
-              try {
-                return t(e);
-              } catch (t) {
-                return (s.e = t), s;
-              }
-            }
-            function w(t, e) {
-              if (e !== s)
-                if (e && e.then) {
-                  if (e instanceof r)
-                    switch (e._resolved) {
-                      case 0:
-                        return void e._addReceiver(t, L);
-                      case 1:
-                        return void t._resolve(e._value);
-                      case 2:
-                        return e.suppressUnhandledRejections(), void t._reject(e._value);
-                    }
-                  k(e, t);
-                } else t._resolve(e);
-              else t._reject(s.e);
-            }
-            function k(t, e) {
-              t.then(
-                function(t) {
-                  e._resolve(t);
-                },
-                function(t) {
-                  e._reject(t);
-                }
-              );
-            }
-            function E(t, e, i) {
-              if (t instanceof r)
-                switch (t._resolved) {
-                  case 0:
-                    return t._addReceiver(e, i), !0;
-                  case 1:
-                    return e._callResolve(t._value, i), !0;
-                  case 2:
-                    return t.suppressUnhandledRejections(), e._callReject(t._value), !1;
-                }
-              return t === s
-                ? (e._callReject(s.e), !1)
-                : (t && t.then
-                    ? (function(t, e, i) {
-                        t.then(
-                          function(t) {
-                            e._callResolve(t, i);
-                          },
-                          function(t) {
-                            e._callReject(t);
-                          }
-                        );
-                      })(t, e, i)
-                    : e._callResolve(t, i),
-                  !0);
-            }
-            function A(t, e, i) {
-              return 'function' == typeof t && (t = t()), E(t, e, i);
-            }
-            function O(t, e, i, r) {
-              var s = t[i];
-              (t[i] = t[r]), (t[r] = s);
-              var o = e[i];
-              (e[i] = e[r]), (e[r] = o);
-            }
-            function N(t, e, i, r) {
-              if (e !== i) {
-                for (var s = e; ++s <= i && t[e] === t[s]; ) {
-                  var o = s - 1;
-                  if (r[o] > r[s]) {
-                    var n = r[o];
-                    (r[o] = r[s]), (r[s] = n);
-                  }
-                }
-                if (!(i < s))
-                  N(
-                    t,
-                    e,
-                    (s = (function(t, e, i, r, s) {
-                      for (var o = e, n = i; o <= n; ) {
-                        for (e = o; o < n && t[o] < r; ) o++;
-                        for (; e <= n && t[n] >= r; ) n--;
-                        if (n < o) break;
-                        O(t, s, o++, n--);
-                      }
-                      return o;
-                    })(t, e, i, t[t[e] > t[s] ? e : s], r)) - 1,
-                    r
-                  ),
-                    N(t, s, i, r);
-              }
-            }
-            B.exports = {
-              VERSION: e,
-              DEFAULT_LIMIT: 8,
-              INTERNAL: L,
-              PENDING: function() {},
-              UNHANDLED: function() {},
-              defaultIterator: function(t) {
-                return t;
-              },
-              errorObj: s,
-              iteratorSymbol: c,
-              call0: function(t) {
-                try {
-                  return t();
-                } catch (t) {
-                  return (s.e = t), s;
-                }
-              },
-              call1: b,
-              call3: function(t, e, i, r) {
-                try {
-                  return t(e, i, r);
-                } catch (t) {
-                  return (s.e = t), s;
-                }
-              },
-              apply: function(t, e) {
-                try {
-                  switch (e.length) {
-                    case 0:
-                      return t();
-                    case 1:
-                      return t(e[0]);
-                    case 2:
-                      return t(e[0], e[1]);
-                    case 3:
-                      return t(e[0], e[1], e[2]);
-                    default:
-                      return t.apply(null, e);
-                  }
-                } catch (t) {
-                  return (s.e = t), s;
-                }
-              },
-              callResolve: function(t, e, i) {
-                'function' == typeof e ? w(t, b(e, i)) : t._resolve(i);
-              },
-              callReject: function(t, e, i) {
-                'function' == typeof e ? w(t, b(e, i)) : t._reject(i);
-              },
-              callReceiver: w,
-              callThen: k,
-              callProxyReciever: E,
-              callProxyRecieverWithFunc: A,
-              promiseArrayIterator: n,
-              promiseArrayEach: p,
-              promiseArrayEachWithFunc: f,
-              promiseObjectIterator: l,
-              promiseObjectEach: v,
-              promiseObjectEachWithFunc: m,
-              promiseSetIterator: u,
-              promiseSetEach: g,
-              promiseSetEachWithFunc: x,
-              promiseMapIterator: a,
-              promiseMapEach: S,
-              promiseMapEachWithFunc: j,
-              compactArray: function(t) {
-                var e = -1,
-                  i = t.length,
-                  r = [];
-                for (; ++e < i; ) {
-                  var s = t[e];
-                  s !== L && r.push(s);
-                }
-                return r;
-              },
-              concatArray: function(t) {
-                var e = -1,
-                  i = t.length,
-                  r = [];
-                for (; ++e < i; ) {
-                  var s = t[e];
-                  Array.isArray(s) ? r.push.apply(r, s) : void 0 !== s && r.push(s);
-                }
-                return r;
-              },
-              clone: function(t) {
-                return Array.isArray(t)
-                  ? (function(t) {
-                      var e = t.length,
-                        i = Array(e);
-                      for (; e--; ) i[e] = t[e];
-                      return i;
-                    })(t)
-                  : (function(t) {
-                      var e = Object.keys(t),
-                        i = e.length,
-                        r = {};
-                      for (; i--; ) {
-                        var s = e[i];
-                        r[s] = t[s];
-                      }
-                      return r;
-                    })(t);
-              },
-              createEmptyObject: function(t, e) {
-                var i = -1,
-                  r = e.length,
-                  s = {};
-                for (; ++i < r; ) s[e[i]] = void 0;
-                return s;
-              },
-              sortArray: function(t, e) {
-                for (var i = t.length, r = Array(i), s = 0; s < i; s++) r[s] = s;
-                N(e, 0, i - 1, r);
-                for (var o = Array(i), n = 0; n < i; n++) {
-                  var c = r[n];
-                  o[n] = void 0 === c ? t[n] : t[c];
-                }
-                return o;
-              },
-              sortObject: function(t, e, i) {
-                for (var r = e.length, s = Array(r), o = 0; o < r; o++) s[o] = o;
-                N(i, 0, r - 1, s);
-                for (var n = Array(r), c = 0; c < r; c++) {
-                  var l = s[c];
-                  n[c] = t[e[void 0 === l ? c : l]];
-                }
-                return n;
-              },
-              printWarning: function(t) {
-                i ? console.warn('' + t + '\n') : console.warn('%c' + t, 'color: red');
-              }
-            };
-          }.call(this, I('_process')));
-        },
-        { '../../package.json': 91, _process: 86, 'aigle-core': 85 }
-      ],
-      40: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('aigle-core').AigleProxy,
-            s = t('./aigle'),
-            o = t('./internal/util'),
-            n = o.INTERNAL,
-            c = o.call1,
-            l = o.apply,
-            u = o.callProxyReciever,
-            a = (function(i) {
-              function t(t, e) {
-                i.call(this),
-                  (this._promise = new s(n)),
-                  (this._rest = e),
-                  (this._result = Array(e)),
-                  (this._handler = t);
-              }
-              return (
-                i && (t.__proto__ = i),
-                (((t.prototype = Object.create(
-                  i && i.prototype
-                )).constructor = t).prototype._callResolve = function(t, e) {
-                  if (e === n) return this._promise._resolve(t);
-                  if (((this._result[e] = t), 0 == --this._rest)) {
-                    var i = this._handler,
-                      r = this._result;
-                    void 0 === i ? this._promise._resolve(r) : u(l(i, r), this, n);
-                  }
-                }),
-                (t.prototype._callReject = function(t) {
-                  this._promise._reject(t);
-                }),
-                t
-              );
-            })(r),
-            h = (function(e) {
-              function t(t) {
-                e.call(this), (this._promise = new s(n)), (this._handler = t);
-              }
-              return (
-                e && (t.__proto__ = e),
-                (((t.prototype = Object.create(
-                  e && e.prototype
-                )).constructor = t).prototype._callResolve = function(t, e) {
-                  if (e === n) return this._promise._resolve(t);
-                  !(function(t, e) {
-                    var i = t._handler;
-                    if (void 0 === i) return t._promise._resolve(e);
-                    switch (typeof e) {
-                      case 'string':
-                        e = e.split('');
-                        break;
-                      case 'object':
-                        if (Array.isArray(e)) break;
-                        if (e) {
-                          for (var r = Object.keys(e), s = r.length, o = Array(s); s--; )
-                            o[s] = e[r[s]];
-                          e = o;
-                          break;
-                        }
-                      default:
-                        return u(c(i, e), t, n);
-                    }
-                    u(l(i, e), t, n);
-                  })(this, t);
-                }),
-                (t.prototype._callReject = function(t) {
-                  this._promise._reject(t);
-                }),
-                t
-              );
-            })(r);
-          e.exports = {
-            join: function() {
-              var t = arguments,
-                e = arguments.length,
-                i = 'function' == typeof arguments[e - 1] ? arguments[--e] : void 0,
-                r = new a(i, e);
-              for (; e--; ) u(t[e], r, e);
-              return r._promise;
-            },
-            Spread: h
-          };
-        },
-        { './aigle': 2, './internal/util': 39, 'aigle-core': 85 }
-      ],
-      41: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./each').Each,
-            s = t('./internal/collection').setShorthand,
-            o = (function(i) {
-              function t(t, e) {
-                i.call(this, t, e, n);
-              }
-              return (
-                i && (t.__proto__ = i),
-                (((t.prototype = Object.create(
-                  i && i.prototype
-                )).constructor = t).prototype._callResolve = function(t, e) {
-                  (this._result[e] = t), 0 == --this._rest && this._promise._resolve(this._result);
-                }),
-                t
-              );
-            })(r);
-          function n(t) {
-            return s.call(this, t), (this._result = Array(this._rest)), this;
-          }
-          e.exports = {
-            map: function(t, e) {
-              return new o(t, e)._execute();
-            },
-            Map: o
-          };
-        },
-        { './each': 12, './internal/collection': 36 }
-      ],
-      42: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./eachLimit').EachLimit,
-            s = t('./internal/collection').setLimit,
-            o = (function(r) {
-              function t(t, e, i) {
-                r.call(this, t, e, i, n);
-              }
-              return (
-                r && (t.__proto__ = r),
-                (((t.prototype = Object.create(
-                  r && r.prototype
-                )).constructor = t).prototype._callResolve = function(t, e) {
-                  (this._result[e] = t),
-                    0 == --this._rest
-                      ? this._promise._resolve(this._result)
-                      : 0 < this._callRest-- && this._iterate();
-                }),
-                t
-              );
-            })(r);
-          function n(t) {
-            return s.call(this, t), (this._result = Array(this._rest)), this;
-          }
-          e.exports = {
-            mapLimit: function(t, e, i) {
-              return new o(t, e, i)._execute();
-            },
-            MapLimit: o
-          };
-        },
-        { './eachLimit': 13, './internal/collection': 36 }
-      ],
-      43: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./eachSeries').EachSeries,
-            s = t('./internal/collection').setSeries,
-            o = (function(i) {
-              function t(t, e) {
-                i.call(this, t, e, n);
-              }
-              return (
-                i && (t.__proto__ = i),
-                (((t.prototype = Object.create(
-                  i && i.prototype
-                )).constructor = t).prototype._callResolve = function(t, e) {
-                  (this._result[e] = t),
-                    0 == --this._rest ? this._promise._resolve(this._result) : this._iterate();
-                }),
-                t
-              );
-            })(r);
-          function n(t) {
-            return s.call(this, t), (this._result = Array(this._rest)), this;
-          }
-          e.exports = {
-            mapSeries: function(t, e) {
-              return new o(t, e)._execute();
-            },
-            MapSeries: o
-          };
-        },
-        { './eachSeries': 14, './internal/collection': 36 }
-      ],
-      44: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./each').Each,
-            s = t('./internal/collection').setShorthandWithOrder,
-            o = (function(i) {
-              function t(t, e) {
-                i.call(this, t, e, n), (this._result = {});
-              }
-              return (
-                i && (t.__proto__ = i),
-                ((t.prototype = Object.create(i && i.prototype)).constructor = t)
-              );
-            })(r);
-          function n(t) {
-            return s.call(this, t), (this._callResolve = void 0 === this._keys ? c : l), this;
-          }
-          function c(t, e) {
-            (this._result[e] = t), 0 == --this._rest && this._promise._resolve(this._result);
-          }
-          function l(t, e) {
-            (this._result[this._keys[e]] = t),
-              0 == --this._rest && this._promise._resolve(this._result);
-          }
-          e.exports = {
-            mapValues: function(t, e) {
-              return new o(t, e)._execute();
-            },
-            MapValues: o
-          };
-        },
-        { './each': 12, './internal/collection': 36 }
-      ],
-      45: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./eachLimit').EachLimit,
-            s = t('./internal/collection').setLimit,
-            o = t('./internal/util').createEmptyObject,
-            n = (function(r) {
-              function t(t, e, i) {
-                r.call(this, t, e, i, c);
-              }
-              return (
-                r && (t.__proto__ = r),
-                ((t.prototype = Object.create(r && r.prototype)).constructor = t)
-              );
-            })(r);
-          function c(t) {
-            return (
-              s.call(this, t),
-              void 0 === this._keys
-                ? ((this._result = {}), (this._callResolve = l))
-                : ((this._result = o(t, this._keys)), (this._callResolve = u)),
-              this
-            );
-          }
-          function l(t, e) {
-            (this._result[e] = t),
-              0 == --this._rest
-                ? this._promise._resolve(this._result)
-                : 0 < this._callRest-- && this._iterate();
-          }
-          function u(t, e) {
-            (this._result[this._keys[e]] = t),
-              0 == --this._rest
-                ? this._promise._resolve(this._result)
-                : 0 < this._callRest-- && this._iterate();
-          }
-          e.exports = {
-            mapValuesLimit: function(t, e, i) {
-              return new n(t, e, i)._execute();
-            },
-            MapValuesLimit: n
-          };
-        },
-        { './eachLimit': 13, './internal/collection': 36, './internal/util': 39 }
-      ],
-      46: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./eachSeries').EachSeries,
-            s = t('./internal/collection').setSeries,
-            o = (function(i) {
-              function t(t, e) {
-                i.call(this, t, e, n), (this._result = {});
-              }
-              return (
-                i && (t.__proto__ = i),
-                ((t.prototype = Object.create(i && i.prototype)).constructor = t)
-              );
-            })(r);
-          function n(t) {
-            return s.call(this, t), (this._callResolve = void 0 === this._keys ? c : l), this;
-          }
-          function c(t, e) {
-            (this._result[e] = t),
-              0 == --this._rest ? this._promise._resolve(this._result) : this._iterate();
-          }
-          function l(t, e) {
-            (this._result[this._keys[e]] = t),
-              0 == --this._rest ? this._promise._resolve(this._result) : this._iterate();
-          }
-          e.exports = {
-            mapValuesSeries: function(t, e) {
-              return new o(t, e)._execute();
-            },
-            MapValuesSeries: o
-          };
-        },
-        { './eachSeries': 14, './internal/collection': 36 }
-      ],
-      47: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./each').Each,
-            s = t('./internal/collection').setOmitShorthand,
-            o = (function(r) {
-              function t(t, e, i) {
-                'function' != typeof e && (e = [e].concat(i)),
-                  r.call(this, t, e, n),
-                  (this._result = {});
-              }
-              return (
-                r && (t.__proto__ = r),
-                ((t.prototype = Object.create(r && r.prototype)).constructor = t)
-              );
-            })(r);
-          function n(t) {
-            return s.call(this, t), (this._callResolve = void 0 === this._keys ? c : l), this;
-          }
-          function c(t, e) {
-            t || (this._result[e] = this._coll[e]),
-              0 == --this._rest && this._promise._resolve(this._result);
-          }
-          function l(t, e) {
-            if (!t) {
-              var i = this._keys[e];
-              this._result[i] = this._coll[i];
-            }
-            0 == --this._rest && this._promise._resolve(this._result);
-          }
-          e.exports = {
-            omit: function(t, e) {
-              var i = [],
-                r = arguments.length - 2;
-              for (; 0 < r--; ) i[r] = arguments[r + 2];
-              return new o(t, e, i)._execute();
-            },
-            Omit: o
-          };
-        },
-        { './each': 12, './internal/collection': 36 }
-      ],
-      48: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./each').Each,
-            s = t('./internal/collection').setShorthand,
-            o = (function(i) {
-              function t(t, e) {
-                i.call(this, t, e, n), (this._result = {});
-              }
-              return (
-                i && (t.__proto__ = i),
-                ((t.prototype = Object.create(i && i.prototype)).constructor = t)
-              );
-            })(r);
-          function n(t) {
-            return s.call(this, t), (this._callResolve = void 0 === this._keys ? c : l), this;
-          }
-          function c(t, e) {
-            t || (this._result[e] = this._coll[e]),
-              0 == --this._rest && this._promise._resolve(this._result);
-          }
-          function l(t, e) {
-            if (!t) {
-              var i = this._keys[e];
-              this._result[i] = this._coll[i];
-            }
-            0 == --this._rest && this._promise._resolve(this._result);
-          }
-          e.exports = {
-            omitBy: function(t, e) {
-              return new o(t, e)._execute();
-            },
-            OmitBy: o
-          };
-        },
-        { './each': 12, './internal/collection': 36 }
-      ],
-      49: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./eachLimit').EachLimit,
-            s = t('./internal/collection').setLimit,
-            o = (function(r) {
-              function t(t, e, i) {
-                r.call(this, t, e, i, n), (this._result = {});
-              }
-              return (
-                r && (t.__proto__ = r),
-                ((t.prototype = Object.create(r && r.prototype)).constructor = t)
-              );
-            })(r);
-          function n(t) {
-            return s.call(this, t), (this._callResolve = void 0 === this._keys ? c : l), this;
-          }
-          function c(t, e) {
-            t || (this._result[e] = this._coll[e]),
-              0 == --this._rest
-                ? this._promise._resolve(this._result)
-                : 0 < this._callRest-- && this._iterate();
-          }
-          function l(t, e) {
-            if (!t) {
-              var i = this._keys[e];
-              this._result[i] = this._coll[i];
-            }
-            0 == --this._rest
-              ? this._promise._resolve(this._result)
-              : 0 < this._callRest-- && this._iterate();
-          }
-          e.exports = {
-            omitByLimit: function(t, e, i) {
-              return new o(t, e, i)._execute();
-            },
-            OmitByLimit: o
-          };
-        },
-        { './eachLimit': 13, './internal/collection': 36 }
-      ],
-      50: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./eachSeries').EachSeries,
-            s = t('./internal/util').PENDING,
-            o = t('./internal/collection').setSeries,
-            n = (function(i) {
-              function t(t, e) {
-                i.call(this, t, e),
-                  (this._result = {}),
-                  t === s ? (this._set = c) : (this._callResolve = void 0 === this._keys ? l : u);
-              }
-              return (
-                i && (t.__proto__ = i),
-                ((t.prototype = Object.create(i && i.prototype)).constructor = t)
-              );
-            })(r);
-          function c(t) {
-            return o.call(this, t), (this._callResolve = void 0 === this._keys ? l : u), this;
-          }
-          function l(t, e) {
-            t || (this._result[e] = this._coll[e]),
-              0 == --this._rest ? this._promise._resolve(this._result) : this._iterate();
-          }
-          function u(t, e) {
-            if (!t) {
-              var i = this._keys[e];
-              this._result[i] = this._coll[i];
-            }
-            0 == --this._rest ? this._promise._resolve(this._result) : this._iterate();
-          }
-          e.exports = {
-            omitBySeries: function(t, e) {
-              return new n(t, e)._execute();
-            },
-            OmitBySeries: n
-          };
-        },
-        { './eachSeries': 14, './internal/collection': 36, './internal/util': 39 }
-      ],
-      51: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('aigle-core').AigleProxy,
-            s = t('./aigle'),
-            o = t('./internal/util'),
-            n = o.INTERNAL,
-            c = o.PENDING,
-            l = o.promiseArrayEachWithFunc,
-            u = o.promiseObjectEachWithFunc,
-            a = o.promiseMapEachWithFunc,
-            h = o.promiseSetEachWithFunc,
-            _ = o.iteratorSymbol,
-            p = t('./props'),
-            f = p.callResolve,
-            y = p.callResolveMap,
-            v = (function(e) {
-              function t(t) {
-                e.call(this),
-                  (this._promise = new s(n)),
-                  (this._rest = void 0),
-                  (this._result = void 0),
-                  t === c
-                    ? (this._callResolve = this._set)
-                    : ((this._callResolve = void 0), this._set(t));
-              }
-              return (
-                e && (t.__proto__ = e),
-                (((t.prototype = Object.create(
-                  e && e.prototype
-                )).constructor = t).prototype._set = function(t) {
-                  if (Array.isArray(t)) {
-                    var e = t.length;
-                    (this._rest = e),
-                      (this._result = Array(e)),
-                      (this._callResolve = f),
-                      l(this, e, t);
-                  } else if (t && 'object' == typeof t)
-                    if (t[_]) {
-                      var i = t.size;
-                      if (((this._rest = i), t instanceof Map)) {
-                        var r = new Map();
-                        (this._result = r), (this._callResolve = y), a(this, 1 / 0, t, r);
-                      } else
-                        (this._result = Array(this._rest)),
-                          (this._callResolve = f),
-                          h(this, 1 / 0, t);
-                    } else {
-                      var s = {},
-                        o = Object.keys(t),
-                        n = o.length;
-                      (this._rest = n),
-                        (this._result = s),
-                        (this._callResolve = f),
-                        u(this, n, t, s, o);
-                    }
-                  else (this._rest = 0), (this._result = void 0);
-                  return 0 === this._rest && this._promise._resolve(this._result), this;
-                }),
-                (t.prototype._execute = function() {
-                  return this._promise;
-                }),
-                (t.prototype._callReject = function(t) {
-                  this._promise._reject(t);
-                }),
-                t
-              );
-            })(r);
-          e.exports = {
-            parallel: function(t) {
-              return new v(t)._promise;
-            },
-            Parallel: v
-          };
-        },
-        { './aigle': 2, './internal/util': 39, './props': 59, 'aigle-core': 85 }
-      ],
-      52: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./series').Series,
-            s = t('./internal/util').DEFAULT_LIMIT,
-            o = (function(i) {
-              function t(t, e) {
-                void 0 === e && (e = s),
-                  i.call(this, t),
-                  (this._size = this._rest),
-                  (this._limit = e);
-              }
-              return (
-                i && (t.__proto__ = i),
-                (((t.prototype = Object.create(
-                  i && i.prototype
-                )).constructor = t).prototype._execute = function() {
-                  var t = this._limit,
-                    e = this._rest;
-                  if (0 === e) return this._promise._resolve(this._result), this._promise;
-                  (this._size = e), (this._iterate = n);
-                  for (var i = t < e ? t : e; i--; ) this._iterate();
-                  return this._promise;
-                }),
-                (t.prototype._callResolve = function(t, e) {
-                  (this._result[e] = t),
-                    0 == --this._rest ? this._promise._resolve(this._result) : this._iterate();
-                }),
-                (t.prototype._callResolveMap = function(t, e) {
-                  this._result.set(e, t),
-                    0 == --this._rest ? this._promise._resolve(this._result) : this._iterate();
-                }),
-                (t.prototype._callReject = function(t) {
-                  this._promise._reject(t);
-                }),
-                t
-              );
-            })(r);
-          function n() {
-            ++this._index < this._size &&
-              this._iterator(this, this._coll, this._index, this._result, this._keys);
-          }
-          e.exports = {
-            parallelLimit: function(t, e) {
-              return new o(t, e)._execute();
-            },
-            ParallelLimit: o
-          };
-        },
-        { './internal/util': 39, './series': 66 }
-      ],
-      53: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./each').Each,
-            s = t('./internal/collection').setPickShorthand,
-            o = (function(r) {
-              function t(t, e, i) {
-                'function' != typeof e && (e = [e].concat(i)),
-                  r.call(this, t, e, n),
-                  (this._result = {});
-              }
-              return (
-                r && (t.__proto__ = r),
-                ((t.prototype = Object.create(r && r.prototype)).constructor = t)
-              );
-            })(r);
-          function n(t) {
-            return s.call(this, t), (this._callResolve = void 0 === this._keys ? c : l), this;
-          }
-          function c(t, e) {
-            t && (this._result[e] = this._coll[e]),
-              0 == --this._rest && this._promise._resolve(this._result);
-          }
-          function l(t, e) {
-            if (t) {
-              var i = this._keys[e];
-              this._result[i] = this._coll[i];
-            }
-            0 == --this._rest && this._promise._resolve(this._result);
-          }
-          e.exports = {
-            pick: function(t, e) {
-              var i = [],
-                r = arguments.length - 2;
-              for (; 0 < r--; ) i[r] = arguments[r + 2];
-              return new o(t, e, i)._execute();
-            },
-            Pick: o
-          };
-        },
-        { './each': 12, './internal/collection': 36 }
-      ],
-      54: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./each').Each,
-            s = t('./internal/collection').setShorthand,
-            o = (function(i) {
-              function t(t, e) {
-                i.call(this, t, e, n), (this._result = {});
-              }
-              return (
-                i && (t.__proto__ = i),
-                ((t.prototype = Object.create(i && i.prototype)).constructor = t)
-              );
-            })(r);
-          function n(t) {
-            return s.call(this, t), (this._callResolve = void 0 === this._keys ? c : l), this;
-          }
-          function c(t, e) {
-            t && (this._result[e] = this._coll[e]),
-              0 == --this._rest && this._promise._resolve(this._result);
-          }
-          function l(t, e) {
-            if (t) {
-              var i = this._keys[e];
-              this._result[i] = this._coll[i];
-            }
-            0 == --this._rest && this._promise._resolve(this._result);
-          }
-          e.exports = {
-            pickBy: function(t, e) {
-              return new o(t, e)._execute();
-            },
-            PickBy: o
-          };
-        },
-        { './each': 12, './internal/collection': 36 }
-      ],
-      55: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./eachLimit').EachLimit,
-            s = t('./internal/collection').setLimit,
-            o = (function(r) {
-              function t(t, e, i) {
-                r.call(this, t, e, i, n), (this._result = {});
-              }
-              return (
-                r && (t.__proto__ = r),
-                ((t.prototype = Object.create(r && r.prototype)).constructor = t)
-              );
-            })(r);
-          function n(t) {
-            return s.call(this, t), (this._callResolve = void 0 === this._keys ? c : l), this;
-          }
-          function c(t, e) {
-            t && (this._result[e] = this._coll[e]),
-              0 == --this._rest
-                ? this._promise._resolve(this._result)
-                : 0 < this._callRest-- && this._iterate();
-          }
-          function l(t, e) {
-            if (t) {
-              var i = this._keys[e];
-              this._result[i] = this._coll[i];
-            }
-            0 == --this._rest
-              ? this._promise._resolve(this._result)
-              : 0 < this._callRest-- && this._iterate();
-          }
-          e.exports = {
-            pickByLimit: function(t, e, i) {
-              return new o(t, e, i)._execute();
-            },
-            PickByLimit: o
-          };
-        },
-        { './eachLimit': 13, './internal/collection': 36 }
-      ],
-      56: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./eachSeries').EachSeries,
-            s = t('./internal/collection').setSeries,
-            o = (function(i) {
-              function t(t, e) {
-                i.call(this, t, e, n), (this._result = {});
-              }
-              return (
-                i && (t.__proto__ = i),
-                ((t.prototype = Object.create(i && i.prototype)).constructor = t)
-              );
-            })(r);
-          function n(t) {
-            return s.call(this, t), (this._callResolve = void 0 === this._keys ? c : l), this;
-          }
-          function c(t, e) {
-            t && (this._result[e] = this._coll[e]),
-              0 == --this._rest ? this._promise._resolve(this._result) : this._iterate();
-          }
-          function l(t, e) {
-            if (t) {
-              var i = this._keys[e];
-              this._result[i] = this._coll[i];
-            }
-            0 == --this._rest ? this._promise._resolve(this._result) : this._iterate();
-          }
-          e.exports = {
-            pickBySeries: function(t, e) {
-              return new o(t, e)._execute();
-            },
-            PickBySeries: o
-          };
-        },
-        { './eachSeries': 14, './internal/collection': 36 }
-      ],
-      57: [
-        function(t, e, i) {
-          'use strict';
-          var u = t('./aigle'),
-            r = t('./internal/util'),
-            a = r.INTERNAL,
-            h = r.callThen,
-            s = 'function' == typeof setImmediate ? setImmediate : {},
-            o =
-              (function() {
-                try {
-                  return t('util').promisify.custom;
-                } catch (t) {
-                  return;
-                }
-              })() || {};
-          function _(i) {
-            return function(t, e) {
-              return t ? i._reject(t) : i._resolve(e);
-            };
-          }
-          e.exports = function(t, e) {
-            switch (typeof t) {
-              case 'object':
-                switch (typeof e) {
-                  case 'string':
-                  case 'number':
-                    if ('function' != typeof t[e])
-                      throw new TypeError('Function not found key: ' + e);
-                    return t[e].__isPromisified__
-                      ? t[e]
-                      : (function(n, c) {
-                          return (t.__isPromisified__ = !0), t;
-                          function t(t) {
-                            var e = arguments,
-                              i = new u(a),
-                              r = _(i),
-                              s = arguments.length;
-                            switch (s) {
-                              case 0:
-                                n[c](r);
-                                break;
-                              case 1:
-                                n[c](t, r);
-                                break;
-                              default:
-                                for (var o = Array(s); s--; ) o[s] = e[s];
-                                (o[o.length] = r), n[c].apply(n, o);
-                            }
-                            return i;
-                          }
-                        })(t, e);
-                  default:
-                    throw new TypeError('Second argument is invalid');
-                }
-              case 'function':
-                if (t.__isPromisified__) return t;
-                var i = e && void 0 !== e.context ? e.context : void 0;
-                return (function(n, c) {
-                  var l = n[o];
-                  if (l) return (t.__isPromisified__ = !0), t;
-                  switch (n) {
-                    case setTimeout:
-                      return u.delay;
-                    case s:
-                      return u.resolve;
-                  }
-                  return (e.__isPromisified__ = !0), e;
-                  function t(t) {
-                    var e,
-                      i = arguments,
-                      r = new u(a),
-                      s = arguments.length;
-                    switch (s) {
-                      case 0:
-                        e = l.call(c || this);
-                        break;
-                      case 1:
-                        e = l.call(c || this, t);
-                        break;
-                      default:
-                        for (var o = Array(s); s--; ) o[s] = i[s];
-                        e = l.apply(c || this, o);
-                    }
-                    return h(e, r), r;
-                  }
-                  function e(t) {
-                    var e = arguments,
-                      i = new u(a),
-                      r = _(i),
-                      s = arguments.length;
-                    switch (s) {
-                      case 0:
-                        n.call(c || this, r);
-                        break;
-                      case 1:
-                        n.call(c || this, t, r);
-                        break;
-                      default:
-                        for (var o = Array(s); s--; ) o[s] = e[s];
-                        (o[o.length] = r), n.apply(c || this, o);
-                    }
-                    return i;
-                  }
-                })(t, i);
-              default:
-                throw new TypeError('Type of first argument is not function');
-            }
-          };
-        },
-        { './aigle': 2, './internal/util': 39, util: 90 }
-      ],
-      58: [
-        function(t, e, i) {
-          'use strict';
-          var l = t('./promisify'),
-            a = {
-              constructor: !0,
-              arity: !0,
-              length: !0,
-              name: !0,
-              arguments: !0,
-              caller: !0,
-              callee: !0,
-              prototype: !0,
-              __isPromisified__: !0
-            };
-          function n(t) {
-            return /^(?!_).*/.test(t);
-          }
-          function h(t, e, i, r, s, o) {
-            var n = {};
-            switch (typeof i) {
-              case 'function':
-                if (s) {
-                  if (i.__isPromisified__) return;
-                  var c = '' + r + t;
-                  if (s[c]) {
-                    if (!s[c].__isPromisified__)
-                      throw new TypeError(
-                        "Cannot promisify an API that has normal methods with '" + t + "'-suffix"
-                      );
-                  } else s[c] = l(i);
-                }
-                u(t, e, i, i, o, n), u(t, e, i.prototype, i.prototype, o, n);
-                break;
-              case 'object':
-                if (!i) break;
-                u(t, e, i, i, o, n), u(t, e, Object.getPrototypeOf(i), i, o, n);
-            }
-          }
-          e.exports = function(t, e) {
-            var i = e || {},
-              r = i.suffix;
-            void 0 === r && (r = 'Async');
-            var s = i.filter;
-            void 0 === s && (s = n);
-            var o = i.depth;
-            void 0 === o && (o = 2);
-            return h(r, s, t, void 0, void 0, o), t;
-          };
-          var _ = Function.prototype,
-            p = Object.prototype,
-            f = Array.prototype;
-          function u(t, e, i, r, s, o) {
-            if (0 != s-- && i && _ !== i && p !== i && f !== i && !Object.isFrozen(i))
-              for (var n = Object.getOwnPropertyNames(i), c = n.length; c--; ) {
-                var l = n[c];
-                if (!0 !== a[l] && !0 !== o[l] && e(l)) {
-                  var u = Object.getOwnPropertyDescriptor(i, l);
-                  !u || u.set || u.get || ((o[l] = !0), h(t, e, i[l], l, r, s));
-                }
-              }
-          }
-        },
-        { './promisify': 57 }
-      ],
-      59: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('aigle-core').AigleProxy,
-            s = t('./aigle'),
-            o = t('./internal/util'),
-            n = o.INTERNAL,
-            c = o.PENDING,
-            l = o.promiseObjectEach,
-            u = o.promiseMapEach,
-            a = (function(e) {
-              function t(t) {
-                e.call(this),
-                  (this._promise = new s(n)),
-                  (this._rest = 0),
-                  (this._result = void 0),
-                  t === c
-                    ? (this._callResolve = this._set)
-                    : ((this._callResolve = void 0), this._set(t));
-              }
-              return (
-                e && (t.__proto__ = e),
-                (((t.prototype = Object.create(
-                  e && e.prototype
-                )).constructor = t).prototype._set = function(t) {
-                  if ('object' != typeof t || null === t) this._result = {};
-                  else if (t instanceof Map) {
-                    var e = new Map();
-                    (this._result = e),
-                      (this._rest = t.size),
-                      (this._callResolve = _),
-                      u(this, 1 / 0, t, e);
-                  } else {
-                    var i = Object.keys(t),
-                      r = i.length,
-                      s = {};
-                    (this._result = s),
-                      (this._rest = r),
-                      (this._callResolve = h),
-                      l(this, r, t, s, i);
-                  }
-                  return 0 === this._rest && this._promise._resolve(this._result), this;
-                }),
-                (t.prototype._execute = function() {
-                  return this._promise;
-                }),
-                (t.prototype._callReject = function(t) {
-                  this._promise._reject(t);
-                }),
-                t
-              );
-            })(r);
-          function h(t, e) {
-            (this._result[e] = t), 0 == --this._rest && this._promise._resolve(this._result);
-          }
-          function _(t, e) {
-            this._result.set(e, t), 0 == --this._rest && this._promise._resolve(this._result);
-          }
-          e.exports = {
-            props: function(t) {
-              return new a(t)._promise;
-            },
-            Props: a,
-            callResolve: h,
-            callResolveMap: _
-          };
-        },
-        { './aigle': 2, './internal/util': 39, 'aigle-core': 85 }
-      ],
-      60: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('aigle-core').AigleProxy,
-            s = t('./aigle'),
-            o = t('./internal/util'),
-            n = o.INTERNAL,
-            c = o.PENDING,
-            l = o.promiseArrayEach,
-            u = o.promiseObjectEach,
-            a = o.promiseMapEach,
-            h = o.promiseSetEach,
-            _ = o.iteratorSymbol,
-            p = (function(e) {
-              function t(t) {
-                e.call(this),
-                  (this._promise = new s(n)),
-                  (this._keys = void 0),
-                  t === c
-                    ? (this._callResolve = this._set)
-                    : ((this._callResolve = void 0), this._set(t));
-              }
-              return (
-                e && (t.__proto__ = e),
-                (((t.prototype = Object.create(
-                  e && e.prototype
-                )).constructor = t).prototype._set = function(t) {
-                  if (((this._callResolve = f), Array.isArray(t))) l(this, t.length, t);
-                  else if (t && 'object' == typeof t)
-                    if (t[_]) t instanceof Map ? a(this, 1 / 0, t, new Map()) : h(this, 1 / 0, t);
-                    else {
-                      var e = Object.keys(t);
-                      u(this, e.length, t, {}, e);
-                    }
-                  else;
-                  return this;
-                }),
-                (t.prototype._execute = function() {
-                  return this._promise;
-                }),
-                (t.prototype._callReject = function(t) {
-                  this._promise._reject(t);
-                }),
-                t
-              );
-            })(r);
-          function f(t) {
-            this._promise._resolve(t);
-          }
-          e.exports = {
-            race: function(t) {
-              return new p(t)._promise;
-            },
-            Race: p
-          };
-        },
-        { './aigle': 2, './internal/util': 39, 'aigle-core': 85 }
-      ],
-      61: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('aigle-core').AigleProxy,
-            s = t('./aigle'),
-            o = t('./internal/collection'),
-            n = o.execute,
-            c = o.setSeries,
-            l = t('./internal/util'),
-            u = l.INTERNAL,
-            a = l.PENDING,
-            h = l.call3,
-            _ = l.callProxyReciever,
-            p = (function(r) {
-              function t(t, e, i) {
-                r.call(this),
-                  (this._result = i),
-                  (this._iterator = e),
-                  (this._promise = new s(u)),
-                  (this._coll = void 0),
-                  (this._rest = void 0),
-                  (this._size = void 0),
-                  (this._keys = void 0),
-                  (this._iterate = void 0),
-                  t === a
-                    ? ((this._set = f),
-                      (this._iterate = this._callResolve),
-                      (this._callResolve = n))
-                    : f.call(this, t);
-              }
-              return (
-                r && (t.__proto__ = r),
-                (((t.prototype = Object.create(
-                  r && r.prototype
-                )).constructor = t).prototype._callResolve = function(t, e) {
-                  0 == --this._rest ? this._promise._resolve(t) : this._iterate(++e, t);
-                }),
-                (t.prototype._callReject = function(t) {
-                  this._promise._reject(t);
-                }),
-                t
-              );
-            })(r);
-          function f(t) {
-            return (
-              c.call(this, t),
-              void 0 === this._keys
-                ? ((this._iterate = y), (this._execute = m))
-                : ((this._iterate = v), (this._execute = d)),
-              this
-            );
-          }
-          function y(t, e) {
-            _(h(this._iterator, e, this._coll[t], t), this, t);
-          }
-          function v(t, e) {
-            var i = this._keys[t];
-            _(h(this._iterator, e, this._coll[i], i), this, t);
-          }
-          function m() {
-            return (
-              0 === this._rest
-                ? this._promise._resolve(this._result)
-                : void 0 === this._result
-                  ? this._callResolve(this._coll[0], 0)
-                  : this._iterate(0, this._result),
-              this._promise
-            );
-          }
-          function d() {
-            return (
-              0 === this._rest
-                ? this._promise._resolve(this._result)
-                : void 0 === this._result
-                  ? this._callResolve(this._coll[this._keys[0]], 0)
-                  : this._iterate(0, this._result),
-              this._promise
-            );
-          }
-          e.exports = {
-            reduce: function(t, e, i) {
-              return new p(t, e, i)._execute();
-            },
-            Reduce: p
-          };
-        },
-        { './aigle': 2, './internal/collection': 36, './internal/util': 39, 'aigle-core': 85 }
-      ],
-      62: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./each').Each,
-            s = t('./internal/collection').setShorthand,
-            o = t('./internal/util'),
-            n = o.INTERNAL,
-            c = o.compactArray,
-            l = (function(i) {
-              function t(t, e) {
-                i.call(this, t, e, u);
-              }
-              return (
-                i && (t.__proto__ = i),
-                ((t.prototype = Object.create(i && i.prototype)).constructor = t)
-              );
-            })(r);
-          function u(t) {
-            return (
-              s.call(this, t),
-              (this._result = Array(this._rest)),
-              (this._callResolve = void 0 === this._keys ? a : h),
-              this
-            );
-          }
-          function a(t, e) {
-            (this._result[e] = t ? n : this._coll[e]),
-              0 == --this._rest && this._promise._resolve(c(this._result));
-          }
-          function h(t, e) {
-            (this._result[e] = t ? n : this._coll[this._keys[e]]),
-              0 == --this._rest && this._promise._resolve(c(this._result));
-          }
-          e.exports = {
-            reject: function(t, e) {
-              return new l(t, e)._execute();
-            },
-            Reject: l
-          };
-        },
-        { './each': 12, './internal/collection': 36, './internal/util': 39 }
-      ],
-      63: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./eachLimit').EachLimit,
-            s = t('./internal/collection').setLimit,
-            o = t('./internal/util'),
-            n = o.INTERNAL,
-            c = o.compactArray,
-            l = (function(r) {
-              function t(t, e, i) {
-                r.call(this, t, e, i, u);
-              }
-              return (
-                r && (t.__proto__ = r),
-                ((t.prototype = Object.create(r && r.prototype)).constructor = t)
-              );
-            })(r);
-          function u(t) {
-            return (
-              s.call(this, t),
-              (this._result = Array(this._rest)),
-              (this._callResolve = void 0 === this._keys ? a : h),
-              this
-            );
-          }
-          function a(t, e) {
-            (this._result[e] = t ? n : this._coll[e]),
-              0 == --this._rest
-                ? this._promise._resolve(c(this._result))
-                : 0 < this._callRest-- && this._iterate();
-          }
-          function h(t, e) {
-            (this._result[e] = t ? n : this._coll[this._keys[e]]),
-              0 == --this._rest
-                ? this._promise._resolve(c(this._result))
-                : 0 < this._callRest-- && this._iterate();
-          }
-          e.exports = {
-            rejectLimit: function(t, e, i) {
-              return new l(t, e, i)._execute();
-            },
-            RejectLimit: l
-          };
-        },
-        { './eachLimit': 13, './internal/collection': 36, './internal/util': 39 }
-      ],
-      64: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./eachSeries').EachSeries,
-            s = t('./internal/collection').setSeries,
-            o = t('./internal/util'),
-            n = o.INTERNAL,
-            c = o.compactArray,
-            l = (function(i) {
-              function t(t, e) {
-                i.call(this, t, e, u);
-              }
-              return (
-                i && (t.__proto__ = i),
-                ((t.prototype = Object.create(i && i.prototype)).constructor = t)
-              );
-            })(r);
-          function u(t) {
-            return (
-              s.call(this, t),
-              (this._result = Array(this._rest)),
-              (this._callResolve = void 0 === this._keys ? a : h),
-              this
-            );
-          }
-          function a(t, e) {
-            (this._result[e] = t ? n : this._coll[e]),
-              0 == --this._rest ? this._promise._resolve(c(this._result)) : this._iterate();
-          }
-          function h(t, e) {
-            (this._result[e] = t ? n : this._coll[this._keys[e]]),
-              0 == --this._rest ? this._promise._resolve(c(this._result)) : this._iterate();
-          }
-          e.exports = {
-            rejectSeries: function(t, e) {
-              return new l(t, e)._execute();
-            },
-            RejectSeries: l
-          };
-        },
-        { './eachSeries': 14, './internal/collection': 36, './internal/util': 39 }
-      ],
-      65: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('aigle-core').AigleProxy,
-            o = t('./aigle'),
-            s = t('./internal/util'),
-            n = s.INTERNAL,
-            c = s.call0,
-            l = s.callProxyReciever,
-            u = (function(s) {
-              function t(t, e) {
-                switch (
-                  (s.call(this),
-                  (this._promise = new o(n)),
-                  (this._handler = e),
-                  (this._count = 0),
-                  (this._times = 5),
-                  (this._interval = void 0),
-                  t && typeof t)
-                ) {
-                  case 'function':
-                    this._handler = t;
-                    break;
-                  case 'object':
-                    var i = t.interval,
-                      r = t.times;
-                    (this._times = r || 5),
-                      (this._interval =
-                        'function' == typeof i
-                          ? i
-                          : i
-                            ? function() {
-                                return i;
-                              }
-                            : void 0),
-                      (this._iterate = this._iterate.bind(this));
-                    break;
-                  default:
-                    this._times = t;
-                }
-                this._iterate();
-              }
-              return (
-                s && (t.__proto__ = s),
-                (((t.prototype = Object.create(
-                  s && s.prototype
-                )).constructor = t).prototype._iterate = function() {
-                  l(c(this._handler), this, void 0);
-                }),
-                (t.prototype._callResolve = function(t) {
-                  this._promise._resolve(t);
-                }),
-                (t.prototype._callReject = function(t) {
-                  ++this._count === this._times
-                    ? this._promise._reject(t)
-                    : void 0 !== this._interval
-                      ? setTimeout(this._iterate, this._interval(this._count))
-                      : this._iterate();
-                }),
-                t
-              );
-            })(r);
-          e.exports = function(t, e) {
-            return new u(t, e)._promise;
-          };
-        },
-        { './aigle': 2, './internal/util': 39, 'aigle-core': 85 }
-      ],
-      66: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('aigle-core').AigleProxy,
-            s = t('./aigle'),
-            o = t('./internal/util'),
-            n = o.INTERNAL,
-            c = o.PENDING,
-            l = o.promiseArrayIterator,
-            u = o.promiseObjectIterator,
-            a = o.promiseSetIterator,
-            h = o.promiseMapIterator,
-            _ = o.iteratorSymbol,
-            p = t('./internal/collection').execute,
-            f = (function(e) {
-              function t(t) {
-                e.call(this),
-                  (this._promise = new s(n)),
-                  (this._index = -1),
-                  (this._coll = void 0),
-                  (this._keys = void 0),
-                  (this._rest = void 0),
-                  (this._result = void 0),
-                  (this._iterate = void 0),
-                  t === c
-                    ? ((this._set = y),
-                      (this._iterate = this._callResolve),
-                      (this._callResolve = p))
-                    : y.call(this, t);
-              }
-              return (
-                e && (t.__proto__ = e),
-                (((t.prototype = Object.create(
-                  e && e.prototype
-                )).constructor = t).prototype._execute = function() {
-                  return this._iterate(), this._promise;
-                }),
-                (t.prototype._callResolve = function(t, e) {
-                  (this._result[e] = t), this._iterate();
-                }),
-                (t.prototype._callResolveMap = function(t, e) {
-                  this._result.set(e, t), this._iterate();
-                }),
-                (t.prototype._callReject = function(t) {
-                  this._promise._reject(t);
-                }),
-                t
-              );
-            })(r);
-          function y(t) {
-            if (((this._coll = t), (this._iterate = v), Array.isArray(t))) {
-              var e = t.length;
-              (this._rest = e), (this._result = Array(e)), (this._iterator = l);
-            } else if ('object' != typeof t || null === t)
-              (this._rest = 0), (this._result = void 0);
-            else if (t[_]) {
-              this._coll = t[_]();
-              var i = t.size;
-              if (((this._rest = i), t instanceof Map)) {
-                var r = new Map();
-                (this._result = r),
-                  (this._callResolve = this._callResolveMap),
-                  (this._iterator = h);
-              } else (this._result = []), (this._iterator = a);
-            } else {
-              var s = Object.keys(t);
-              (this._rest = s.length), (this._keys = s), (this._result = {}), (this._iterator = u);
-            }
-            return this;
-          }
-          function v() {
-            ++this._index === this._rest
-              ? this._promise._resolve(this._result)
-              : this._iterator(this, this._coll, this._index, this._result, this._keys);
-          }
-          e.exports = {
-            series: function(t) {
-              return new f(t)._execute();
-            },
-            Series: f
-          };
-        },
-        { './aigle': 2, './internal/collection': 36, './internal/util': 39, 'aigle-core': 85 }
-      ],
-      67: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./each').Each,
-            s = t('./internal/collection').setShorthand,
-            o = (function(i) {
-              function t(t, e) {
-                i.call(this, t, e, s), (this._result = !1);
-              }
-              return (
-                i && (t.__proto__ = i),
-                (((t.prototype = Object.create(
-                  i && i.prototype
-                )).constructor = t).prototype._callResolve = function(t) {
-                  t ? this._promise._resolve(!0) : 0 == --this._rest && this._promise._resolve(!1);
-                }),
-                t
-              );
-            })(r);
-          e.exports = {
-            some: function(t, e) {
-              return new o(t, e)._execute();
-            },
-            Some: o
-          };
-        },
-        { './each': 12, './internal/collection': 36 }
-      ],
-      68: [
-        function(t, e, i) {
-          'use strict';
-          var r = (function(r) {
-            function t(t, e, i) {
-              r.call(this, t, e, i), (this._result = !1);
-            }
-            return (
-              r && (t.__proto__ = r),
-              (((t.prototype = Object.create(
-                r && r.prototype
-              )).constructor = t).prototype._callResolve = function(t) {
-                t
-                  ? this._promise._resolve(!0)
-                  : 0 == --this._rest
-                    ? this._promise._resolve(!1)
-                    : 0 < this._callRest-- && this._iterate();
-              }),
-              t
-            );
-          })(t('./eachLimit').EachLimit);
-          e.exports = {
-            someLimit: function(t, e, i) {
-              return new r(t, e, i)._execute();
-            },
-            SomeLimit: r
-          };
-        },
-        { './eachLimit': 13 }
-      ],
-      69: [
-        function(t, e, i) {
-          'use strict';
-          var r = (function(i) {
-            function t(t, e) {
-              i.call(this, t, e), (this._result = !1);
-            }
-            return (
-              i && (t.__proto__ = i),
-              (((t.prototype = Object.create(
-                i && i.prototype
-              )).constructor = t).prototype._callResolve = function(t) {
-                t
-                  ? this._promise._resolve(!0)
-                  : 0 == --this._rest
-                    ? this._promise._resolve(!1)
-                    : this._iterate();
-              }),
-              t
-            );
-          })(t('./eachSeries.js').EachSeries);
-          e.exports = {
-            someSeries: function(t, e) {
-              return new r(t, e)._execute();
-            },
-            SomeSeries: r
-          };
-        },
-        { './eachSeries.js': 14 }
-      ],
-      70: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./each').Each,
-            s = t('./internal/collection').setShorthand,
-            o = t('./internal/util'),
-            n = o.sortArray,
-            c = o.sortObject,
-            l = (function(i) {
-              function t(t, e) {
-                i.call(this, t, e, u);
-              }
-              return (
-                i && (t.__proto__ = i),
-                ((t.prototype = Object.create(i && i.prototype)).constructor = t)
-              );
-            })(r);
-          function u(t) {
-            return (
-              s.call(this, t),
-              (this._result = Array(this._rest)),
-              (this._callResolve = void 0 === this._keys ? a : h),
-              this
-            );
-          }
-          function a(t, e) {
-            (this._result[e] = t),
-              0 == --this._rest && this._promise._resolve(n(this._coll, this._result));
-          }
-          function h(t, e) {
-            (this._result[e] = t),
-              0 == --this._rest && this._promise._resolve(c(this._coll, this._keys, this._result));
-          }
-          e.exports = {
-            sortBy: function(t, e) {
-              return new l(t, e)._execute();
-            },
-            SortBy: l
-          };
-        },
-        { './each': 12, './internal/collection': 36, './internal/util': 39 }
-      ],
-      71: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./eachLimit').EachLimit,
-            s = t('./internal/collection').setLimit,
-            o = t('./internal/util'),
-            n = o.sortArray,
-            c = o.sortObject,
-            l = (function(r) {
-              function t(t, e, i) {
-                r.call(this, t, e, i, u);
-              }
-              return (
-                r && (t.__proto__ = r),
-                ((t.prototype = Object.create(r && r.prototype)).constructor = t)
-              );
-            })(r);
-          function u(t) {
-            return (
-              s.call(this, t),
-              (this._result = Array(this._rest)),
-              (this._callResolve = void 0 === this._keys ? a : h),
-              this
-            );
-          }
-          function a(t, e) {
-            (this._result[e] = t),
-              0 == --this._rest
-                ? this._promise._resolve(n(this._coll, this._result))
-                : 0 < this._callRest-- && this._iterate();
-          }
-          function h(t, e) {
-            (this._result[e] = t),
-              0 == --this._rest
-                ? this._promise._resolve(c(this._coll, this._keys, this._result))
-                : 0 < this._callRest-- && this._iterate();
-          }
-          e.exports = {
-            sortByLimit: function(t, e, i) {
-              return new l(t, e, i)._execute();
-            },
-            SortByLimit: l
-          };
-        },
-        { './eachLimit': 13, './internal/collection': 36, './internal/util': 39 }
-      ],
-      72: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./eachSeries').EachSeries,
-            s = t('./internal/collection').setSeries,
-            o = t('./internal/util'),
-            n = o.sortArray,
-            c = o.sortObject,
-            l = (function(i) {
-              function t(t, e) {
-                i.call(this, t, e, u);
-              }
-              return (
-                i && (t.__proto__ = i),
-                ((t.prototype = Object.create(i && i.prototype)).constructor = t)
-              );
-            })(r);
-          function u(t) {
-            return (
-              s.call(this, t),
-              (this._result = Array(this._rest)),
-              (this._callResolve = void 0 === this._keys ? a : h),
-              this
-            );
-          }
-          function a(t, e) {
-            (this._result[e] = t),
-              0 == --this._rest
-                ? this._promise._resolve(n(this._coll, this._result))
-                : this._iterate();
-          }
-          function h(t, e) {
-            (this._result[e] = t),
-              0 == --this._rest
-                ? this._promise._resolve(c(this._coll, this._keys, this._result))
-                : this._iterate();
-          }
-          e.exports = {
-            sortBySeries: function(t, e) {
-              return new l(t, e)._execute();
-            },
-            SortBySeries: l
-          };
-        },
-        { './eachSeries': 14, './internal/collection': 36, './internal/util': 39 }
-      ],
-      73: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./aigle'),
-            s = t('./internal/util'),
-            o = s.INTERNAL,
-            n = s.callResolve;
-          e.exports = function(t, e) {
-            var i = new r(o);
-            return (
-              n(i, e, t),
-              i.then(function() {
-                return t;
-              })
-            );
-          };
-        },
-        { './aigle': 2, './internal/util': 39 }
-      ],
-      74: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./aigle'),
-            s = t('./internal/util'),
-            o = s.INTERNAL,
-            n = s.callResolve;
-          e.exports = function(t, e) {
-            var i = new r(o);
-            return n(i, e, t), i;
-          };
-        },
-        { './aigle': 2, './internal/util': 39 }
-      ],
-      75: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('aigle-core').AigleProxy,
-            s = t('./aigle'),
-            o = t('./error').TimeoutError,
-            n = t('./internal/util').INTERNAL,
-            c = (function(r) {
-              function t(t, e) {
-                var i = this;
-                void 0 === e && (e = 'operation timed out'),
-                  r.call(this),
-                  (this._promise = new s(n)),
-                  (this._timer = setTimeout(function() {
-                    return i._callReject(e instanceof Error ? e : new o(e));
-                  }, t));
-              }
-              return (
-                r && (t.__proto__ = r),
-                (((t.prototype = Object.create(
-                  r && r.prototype
-                )).constructor = t).prototype._callResolve = function(t) {
-                  clearTimeout(this._timer), this._promise._resolve(t);
-                }),
-                (t.prototype._callReject = function(t) {
-                  clearTimeout(this._timer), this._promise._reject(t);
-                }),
-                t
-              );
-            })(r);
-          e.exports = c;
-        },
-        { './aigle': 2, './error': 15, './internal/util': 39, 'aigle-core': 85 }
-      ],
-      76: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('aigle-core').AigleProxy,
-            s = t('./aigle'),
-            o = t('./internal/util'),
-            n = o.INTERNAL,
-            c = o.PENDING,
-            l = o.defaultIterator,
-            u = o.call1,
-            a = o.callProxyReciever,
-            h = (function(i) {
-              function t(t, e) {
-                i.call(this),
-                  (this._promise = new s(n)),
-                  (this._iterator = 'function' == typeof e ? e : l),
-                  (this._rest = void 0),
-                  (this._result = void 0),
-                  t === c
-                    ? ((this._rest = this._callResolve), (this._callResolve = p))
-                    : _.call(this, t);
-              }
-              return (
-                i && (t.__proto__ = i),
-                (((t.prototype = Object.create(
-                  i && i.prototype
-                )).constructor = t).prototype._execute = function() {
-                  if (1 <= this._rest)
-                    for (
-                      var t = this._rest, e = this._iterator, i = -1;
-                      ++i < t && a(u(e, i), this, i);
-
-                    );
-                  else this._promise._resolve(this._result);
-                  return this._promise;
-                }),
-                (t.prototype._callResolve = function(t, e) {
-                  (this._result[e] = t), 0 == --this._rest && this._promise._resolve(this._result);
-                }),
-                (t.prototype._callReject = function(t) {
-                  this._promise._reject(t);
-                }),
-                t
-              );
-            })(r);
-          function _(t) {
-            1 <= (t = 0 | +t)
-              ? ((this._rest = t), (this._result = Array(t)))
-              : ((this._rest = 0), (this._result = []));
-          }
-          function p(t) {
-            (this._callResolve = this._rest), _.call(this, t), this._execute();
-          }
-          e.exports = {
-            times: function(t, e) {
-              return new h(t, e)._execute();
-            },
-            Times: h,
-            set: _,
-            execute: p
-          };
-        },
-        { './aigle': 2, './internal/util': 39, 'aigle-core': 85 }
-      ],
-      77: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('aigle-core').AigleProxy,
-            s = t('./aigle'),
-            o = t('./internal/util'),
-            n = o.INTERNAL,
-            c = o.PENDING,
-            l = o.DEFAULT_LIMIT,
-            u = o.defaultIterator,
-            a = o.call1,
-            h = o.callProxyReciever,
-            _ = (function(r) {
-              function t(t, e, i) {
-                r.call(this),
-                  'function' == typeof e && ((i = e), (e = l)),
-                  (this._promise = new s(n)),
-                  (this._index = 0),
-                  (this._limit = e),
-                  (this._iterator = 'function' == typeof i ? i : u),
-                  (this._rest = void 0),
-                  (this._result = void 0),
-                  (this._callRest = void 0),
-                  t === c
-                    ? ((this._rest = this._callResolve), (this._callResolve = f))
-                    : p.call(this, t);
-              }
-              return (
-                r && (t.__proto__ = r),
-                (((t.prototype = Object.create(
-                  r && r.prototype
-                )).constructor = t).prototype._execute = function() {
-                  if (0 === this._rest) this._promise._resolve(this._result);
-                  else for (; this._limit--; ) this._iterate();
-                  return this._promise;
-                }),
-                (t.prototype._iterate = function() {
-                  var t = this._index++;
-                  h(a(this._iterator, t), this, t);
-                }),
-                (t.prototype._callResolve = function(t, e) {
-                  (this._result[e] = t),
-                    0 == --this._rest
-                      ? this._promise._resolve(this._result)
-                      : 0 < this._callRest-- && this._iterate();
-                }),
-                (t.prototype._callReject = function(t) {
-                  (this._callRest = 0), this._promise._reject(t);
-                }),
-                t
-              );
-            })(r);
-          function p(t) {
-            if (1 <= (t = 0 | +t)) {
-              (this._rest = t), (this._result = Array(t));
-              var e = this._limit;
-              (this._limit = e < t ? e : t), (this._callRest = t - this._limit);
-            } else (this._rest = 0), (this._result = []);
-          }
-          function f(t) {
-            (this._callResolve = this._rest), p.call(this, t), this._execute();
-          }
-          e.exports = {
-            timesLimit: function(t, e, i) {
-              return new _(t, e, i)._execute();
-            },
-            TimesLimit: _
-          };
-        },
-        { './aigle': 2, './internal/util': 39, 'aigle-core': 85 }
-      ],
-      78: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('aigle-core').AigleProxy,
-            s = t('./aigle'),
-            o = t('./times'),
-            n = o.set,
-            c = o.execute,
-            l = t('./internal/util'),
-            u = l.INTERNAL,
-            a = l.PENDING,
-            h = l.defaultIterator,
-            _ = l.call1,
-            p = l.callProxyReciever,
-            f = (function(i) {
-              function t(t, e) {
-                i.call(this),
-                  (this._promise = new s(u)),
-                  (this._iterator = 'function' == typeof e ? e : h),
-                  (this._index = 0),
-                  (this._rest = void 0),
-                  (this._result = void 0),
-                  t === a
-                    ? ((this._rest = this._callResolve), (this._callResolve = c))
-                    : n.call(this, t);
-              }
-              return (
-                i && (t.__proto__ = i),
-                (((t.prototype = Object.create(
-                  i && i.prototype
-                )).constructor = t).prototype._execute = function() {
-                  return (
-                    1 <= this._rest ? this._iterate() : this._promise._resolve(this._result),
-                    this._promise
-                  );
-                }),
-                (t.prototype._iterate = function() {
-                  var t = this._index++;
-                  p(_(this._iterator, t), this, t);
-                }),
-                (t.prototype._callResolve = function(t, e) {
-                  (this._result[e] = t),
-                    0 == --this._rest ? this._promise._resolve(this._result) : this._iterate();
-                }),
-                (t.prototype._callReject = function(t) {
-                  this._promise._reject(t);
-                }),
-                t
-              );
-            })(r);
-          e.exports = {
-            timesSeries: function(t, e) {
-              return new f(t, e)._execute();
-            },
-            TimesSeries: f
-          };
-        },
-        { './aigle': 2, './internal/util': 39, './times': 76, 'aigle-core': 85 }
-      ],
-      79: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./each').Each,
-            s = t('./internal/collection').setParallel,
-            o = t('./internal/util'),
-            l = o.call3,
-            u = o.callProxyReciever,
-            n = o.clone,
-            c = (function(r) {
-              function t(t, e, i) {
-                r.call(this, t, e, a), void 0 !== i && (this._result = i);
-              }
-              return (
-                r && (t.__proto__ = r),
-                (((t.prototype = Object.create(
-                  r && r.prototype
-                )).constructor = t).prototype._callResolve = function(t) {
-                  !1 === t
-                    ? this._promise._resolve(n(this._result))
-                    : 0 == --this._rest && this._promise._resolve(this._result);
-                }),
-                t
-              );
-            })(r);
-          function a(t) {
-            return (
-              s.call(this, t),
-              void 0 !== this._keys || void 0 === this._coll
-                ? (void 0 === this._result && (this._result = {}), (this._iterate = _))
-                : (void 0 === this._result && (this._result = []), (this._iterate = h)),
-              this
-            );
-          }
-          function h() {
-            for (
-              var t = this._rest, e = this._result, i = this._iterator, r = this._coll, s = -1;
-              ++s < t && u(l(i, e, r[s], s), this, s);
-
-            );
-          }
-          function _() {
-            for (
-              var t = this,
-                e = t._rest,
-                i = t._result,
-                r = t._iterator,
-                s = t._coll,
-                o = t._keys,
-                n = -1;
-              ++n < e;
-
-            ) {
-              var c = o[n];
-              if (!1 === u(l(r, i, s[c], c), this, n)) break;
-            }
-          }
-          e.exports = {
-            transform: function(t, e, i) {
-              return new c(t, e, i)._execute();
-            },
-            Transform: c
-          };
-        },
-        { './each': 12, './internal/collection': 36, './internal/util': 39 }
-      ],
-      80: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./eachLimit').EachLimit,
-            s = t('./internal/collection').setLimit,
-            o = t('./internal/util'),
-            n = o.DEFAULT_LIMIT,
-            c = o.call3,
-            l = o.callProxyReciever,
-            u = o.clone,
-            a = (function(s) {
-              function t(t, e, i, r) {
-                'function' == typeof e && ((r = i), (i = e), (e = n)),
-                  s.call(this, t, e, i, h),
-                  void 0 !== r && (this._result = r);
-              }
-              return (
-                s && (t.__proto__ = s),
-                (((t.prototype = Object.create(
-                  s && s.prototype
-                )).constructor = t).prototype._callResolve = function(t) {
-                  !1 === t
-                    ? this._promise._resolve(u(this._result))
-                    : 0 == --this._rest
-                      ? this._promise._resolve(this._result)
-                      : 0 < this._callRest-- && this._iterate();
-                }),
-                t
-              );
-            })(r);
-          function h(t) {
-            return (
-              s.call(this, t),
-              void 0 !== this._keys || void 0 === this._coll
-                ? (void 0 === this._result && (this._result = {}), (this._iterate = p))
-                : (void 0 === this._result && (this._result = []), (this._iterate = _)),
-              this
-            );
-          }
-          function _() {
-            var t = this._index++;
-            l(c(this._iterator, this._result, this._coll[t], t), this, t);
-          }
-          function p() {
-            var t = this._index++,
-              e = this._keys[t];
-            l(c(this._iterator, this._result, this._coll[e], e), this, t);
-          }
-          e.exports = {
-            transformLimit: function(t, e, i, r) {
-              return new a(t, e, i, r)._execute();
-            },
-            TransformLimit: a
-          };
-        },
-        { './eachLimit': 13, './internal/collection': 36, './internal/util': 39 }
-      ],
-      81: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./eachSeries').EachSeries,
-            s = t('./internal/collection').setSeries,
-            o = t('./internal/util'),
-            n = o.call3,
-            c = o.callProxyReciever,
-            l = o.clone,
-            u = (function(r) {
-              function t(t, e, i) {
-                r.call(this, t, e, a), void 0 !== i && (this._result = i);
-              }
-              return (
-                r && (t.__proto__ = r),
-                (((t.prototype = Object.create(
-                  r && r.prototype
-                )).constructor = t).prototype._callResolve = function(t) {
-                  !1 === t
-                    ? this._promise._resolve(l(this._result))
-                    : 0 == --this._rest
-                      ? this._promise._resolve(this._result)
-                      : this._iterate();
-                }),
-                t
-              );
-            })(r);
-          function a(t) {
-            return (
-              s.call(this, t),
-              void 0 !== this._keys || void 0 === this._coll
-                ? (void 0 === this._result && (this._result = {}), (this._iterate = _))
-                : (void 0 === this._result && (this._result = []), (this._iterate = h)),
-              this
-            );
-          }
-          function h() {
-            var t = this._index++;
-            c(n(this._iterator, this._result, this._coll[t], t), this, t);
-          }
-          function _() {
-            var t = this._index++,
-              e = this._keys[t];
-            c(n(this._iterator, this._result, this._coll[e], e), this, t);
-          }
-          e.exports = {
-            transformSeries: function(t, e, i) {
-              return new u(t, e, i)._execute();
-            },
-            TransformSeries: u
-          };
-        },
-        { './eachSeries': 14, './internal/collection': 36, './internal/util': 39 }
-      ],
-      82: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('./whilst'),
-            s = r.AigleWhilst,
-            o = (function(e) {
-              function t(t) {
-                e.call(this, t);
-              }
-              return (
-                e && (t.__proto__ = e),
-                (((t.prototype = Object.create(
-                  e && e.prototype
-                )).constructor = t).prototype._callResolve = function(t) {
-                  t ? this._proxy._promise._resolve(this._value) : this._proxy._next(this._value);
-                }),
-                t
-              );
-            })(r.WhilstTester);
-          e.exports = {
-            until: function(t, e, i) {
-              'function' != typeof i && ((i = e), (e = t), (t = void 0));
-              return new s(new o(e), i)._iterate(t);
-            },
-            UntilTester: o
-          };
-        },
-        { './whilst': 84 }
-      ],
-      83: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('aigle-core').AigleProxy,
-            n = t('./aigle'),
-            s = t('./internal/util'),
-            c = s.INTERNAL,
-            l = s.apply,
-            o = s.call1,
-            u = s.callProxyReciever,
-            a = {},
-            h = function(t, e) {
-              (this._promise = t), (this._handler = e);
-            };
-          h.prototype._dispose = function() {
-            var t = this,
-              e = this._promise;
-            switch (e._resolved) {
-              case 0:
-                return e.then(function() {
-                  return t._dispose();
-                });
-              case 1:
-                return o(this._handler, this._promise._value);
-            }
-          };
-          var _ = (function(o) {
-            function t(t, e) {
-              o.call(this);
-              var i = t.length;
-              (this._promise = new n(c)),
-                (this._rest = i),
-                (this._disposed = i),
-                (this._array = t),
-                (this._error = void 0),
-                (this._result = Array(i)),
-                (this._handler = e);
-              for (var r = -1; ++r < i; ) {
-                var s = t[r];
-                u(s instanceof h == !1 ? s : s._promise, this, r);
-              }
-            }
-            return (
-              o && (t.__proto__ = o),
-              (((t.prototype = Object.create(
-                o && o.prototype
-              )).constructor = t).prototype._spread = function() {
-                var t = this._handler,
-                  e = this._result;
-                if ('function' != typeof t) return this._callResolve(void 0, c);
-                u(l(t, e), this, c);
-              }),
-              (t.prototype._release = function() {
-                for (var t = this._array, e = t.length; e--; ) {
-                  var i = t[e];
-                  i instanceof h == !1 ? this._callResolve(i, a) : u(i._dispose(), this, a);
-                }
-              }),
-              (t.prototype._callResolve = function(t, e) {
-                if (e === c) return (this._result = t), this._release();
-                e !== a
-                  ? ((this._result[e] = t), 0 == --this._rest && this._spread())
-                  : 0 == --this._disposed &&
-                    (this._error
-                      ? this._promise._reject(this._error)
-                      : this._promise._resolve(this._result));
-              }),
-              (t.prototype._callReject = function(t) {
-                if (this._error) return this._promise._reject(t);
-                (this._error = t), this._release();
-              }),
-              t
-            );
-          })(r);
-          e.exports = {
-            using: function() {
-              var t = arguments,
-                e = arguments.length,
-                i = arguments[--e],
-                r = Array(e);
-              for (; e--; ) r[e] = t[e];
-              return new _(r, i)._promise;
-            },
-            Disposer: h
-          };
-        },
-        { './aigle': 2, './internal/util': 39, 'aigle-core': 85 }
-      ],
-      84: [
-        function(t, e, i) {
-          'use strict';
-          var r = t('aigle-core').AigleProxy,
-            s = t('./aigle'),
-            o = t('./internal/util'),
-            n = o.INTERNAL,
-            c = o.callProxyReciever,
-            l = o.call1,
-            u = (function(e) {
-              function t(t) {
-                e.call(this), (this._tester = t), (this._proxy = void 0), (this._value = void 0);
-              }
-              return (
-                e && (t.__proto__ = e),
-                (((t.prototype = Object.create(
-                  e && e.prototype
-                )).constructor = t).prototype._test = function(t) {
-                  (this._value = t), c(l(this._tester, t), this, void 0);
-                }),
-                (t.prototype._callResolve = function(t) {
-                  t ? this._proxy._next(this._value) : this._proxy._promise._resolve(this._value);
-                }),
-                (t.prototype._callReject = function(t) {
-                  this._proxy._callReject(t);
-                }),
-                t
-              );
-            })(r),
-            a = (function(i) {
-              function t(t, e) {
-                i.call(this),
-                  (this._promise = new s(n)),
-                  (this._tester = t),
-                  (this._iterator = e),
-                  (t._proxy = this);
-              }
-              return (
-                i && (t.__proto__ = i),
-                (((t.prototype = Object.create(
-                  i && i.prototype
-                )).constructor = t).prototype._iterate = function(t) {
-                  return this._callResolve(t), this._promise;
-                }),
-                (t.prototype._next = function(t) {
-                  c(l(this._iterator, t), this, void 0);
-                }),
-                (t.prototype._callResolve = function(t) {
-                  this._tester._test(t);
-                }),
-                (t.prototype._callReject = function(t) {
-                  this._promise._reject(t);
-                }),
-                t
-              );
-            })(r);
-          e.exports = {
-            whilst: function(t, e, i) {
-              'function' != typeof i && ((i = e), (e = t), (t = void 0));
-              return new a(new u(e), i)._iterate(t);
-            },
-            AigleWhilst: a,
-            WhilstTester: u
-          };
-        },
-        { './aigle': 2, './internal/util': 39, 'aigle-core': 85 }
-      ],
-      85: [
-        function(t, e, i) {
-          'use strict';
-          e.exports = { AigleCore: function() {}, AigleProxy: function() {} };
-        },
-        {}
-      ],
-      86: [
-        function(t, e, i) {
-          var r,
-            s,
-            o = (e.exports = {});
-          function n() {
-            throw new Error('setTimeout has not been defined');
-          }
-          function c() {
-            throw new Error('clearTimeout has not been defined');
-          }
-          function l(e) {
-            if (r === setTimeout) return setTimeout(e, 0);
-            if ((r === n || !r) && setTimeout) return (r = setTimeout), setTimeout(e, 0);
-            try {
-              return r(e, 0);
-            } catch (t) {
-              try {
-                return r.call(null, e, 0);
-              } catch (t) {
-                return r.call(this, e, 0);
-              }
-            }
-          }
-          !(function() {
-            try {
-              r = 'function' == typeof setTimeout ? setTimeout : n;
-            } catch (t) {
-              r = n;
-            }
-            try {
-              s = 'function' == typeof clearTimeout ? clearTimeout : c;
-            } catch (t) {
-              s = c;
-            }
-          })();
-          var u,
-            a = [],
-            h = !1,
-            _ = -1;
-          function p() {
-            h && u && ((h = !1), u.length ? (a = u.concat(a)) : (_ = -1), a.length && f());
-          }
-          function f() {
-            if (!h) {
-              var t = l(p);
-              h = !0;
-              for (var e = a.length; e; ) {
-                for (u = a, a = []; ++_ < e; ) u && u[_].run();
-                (_ = -1), (e = a.length);
-              }
-              (u = null),
-                (h = !1),
-                (function(e) {
-                  if (s === clearTimeout) return clearTimeout(e);
-                  if ((s === c || !s) && clearTimeout) return (s = clearTimeout), clearTimeout(e);
-                  try {
-                    s(e);
-                  } catch (t) {
-                    try {
-                      return s.call(null, e);
-                    } catch (t) {
-                      return s.call(this, e);
-                    }
-                  }
-                })(t);
-            }
-          }
-          function y(t, e) {
-            (this.fun = t), (this.array = e);
-          }
-          function v() {}
-          (o.nextTick = function(t) {
-            var e = arguments,
-              i = new Array(arguments.length - 1);
-            if (1 < arguments.length) for (var r = 1; r < arguments.length; r++) i[r - 1] = e[r];
-            a.push(new y(t, i)), 1 !== a.length || h || l(f);
-          }),
-            (y.prototype.run = function() {
-              this.fun.apply(null, this.array);
-            }),
-            (o.title = 'browser'),
-            (o.browser = !0),
-            (o.env = {}),
-            (o.argv = []),
-            (o.version = ''),
-            (o.versions = {}),
-            (o.on = v),
-            (o.addListener = v),
-            (o.once = v),
-            (o.off = v),
-            (o.removeListener = v),
-            (o.removeAllListeners = v),
-            (o.emit = v),
-            (o.prependListener = v),
-            (o.prependOnceListener = v),
-            (o.listeners = function(t) {
-              return [];
-            }),
-            (o.binding = function(t) {
-              throw new Error('process.binding is not supported');
-            }),
-            (o.cwd = function() {
-              return '/';
-            }),
-            (o.chdir = function(t) {
-              throw new Error('process.chdir is not supported');
-            }),
-            (o.umask = function() {
-              return 0;
-            });
-        },
-        {}
-      ],
-      87: [
-        function(t, e, i) {
-          (function(f, t) {
-            !(function(i, r) {
-              'use strict';
-              if (!i.setImmediate) {
-                var o,
-                  s,
-                  e,
-                  n,
-                  t,
-                  c = 1,
-                  l = {},
-                  u = !1,
-                  a = i.document,
-                  h = Object.getPrototypeOf && Object.getPrototypeOf(i);
-                (h = h && h.setTimeout ? h : i),
-                  (o =
-                    '[object process]' === {}.toString.call(i.process)
-                      ? function(t) {
-                          f.nextTick(function() {
-                            p(t);
-                          });
-                        }
-                      : (function() {
-                          if (i.postMessage && !i.importScripts) {
-                            var t = !0,
-                              e = i.onmessage;
-                            return (
-                              (i.onmessage = function() {
-                                t = !1;
-                              }),
-                              i.postMessage('', '*'),
-                              (i.onmessage = e),
-                              t
-                            );
-                          }
-                        })()
-                        ? ((n = 'setImmediate$' + Math.random() + '$'),
-                          (t = function(t) {
-                            t.source === i &&
-                              'string' == typeof t.data &&
-                              0 === t.data.indexOf(n) &&
-                              p(+t.data.slice(n.length));
-                          }),
-                          i.addEventListener
-                            ? i.addEventListener('message', t, !1)
-                            : i.attachEvent('onmessage', t),
-                          function(t) {
-                            i.postMessage(n + t, '*');
-                          })
-                        : i.MessageChannel
-                          ? (((e = new MessageChannel()).port1.onmessage = function(t) {
-                              p(t.data);
-                            }),
-                            function(t) {
-                              e.port2.postMessage(t);
-                            })
-                          : a && 'onreadystatechange' in a.createElement('script')
-                            ? ((s = a.documentElement),
-                              function(t) {
-                                var e = a.createElement('script');
-                                (e.onreadystatechange = function() {
-                                  p(t), (e.onreadystatechange = null), s.removeChild(e), (e = null);
-                                }),
-                                  s.appendChild(e);
-                              })
-                            : function(t) {
-                                setTimeout(p, 0, t);
-                              }),
-                  (h.setImmediate = function(t) {
-                    var e = arguments;
-                    'function' != typeof t && (t = new Function('' + t));
-                    for (var i = new Array(arguments.length - 1), r = 0; r < i.length; r++)
-                      i[r] = e[r + 1];
-                    var s = { callback: t, args: i };
-                    return (l[c] = s), o(c), c++;
-                  }),
-                  (h.clearImmediate = _);
-              }
-              function _(t) {
-                delete l[t];
-              }
-              function p(t) {
-                if (u) setTimeout(p, 0, t);
-                else {
-                  var e = l[t];
-                  if (e) {
-                    u = !0;
-                    try {
-                      !(function(t) {
-                        var e = t.callback,
-                          i = t.args;
-                        switch (i.length) {
-                          case 0:
-                            e();
-                            break;
-                          case 1:
-                            e(i[0]);
-                            break;
-                          case 2:
-                            e(i[0], i[1]);
-                            break;
-                          case 3:
-                            e(i[0], i[1], i[2]);
-                            break;
-                          default:
-                            e.apply(r, i);
-                        }
-                      })(e);
-                    } finally {
-                      _(t), (u = !1);
-                    }
-                  }
-                }
-              }
-            })('undefined' == typeof self ? (void 0 === t ? this : t) : self);
-          }.call(
-            this,
-            t('_process'),
-            'undefined' != typeof global
-              ? global
-              : 'undefined' != typeof self
-                ? self
-                : 'undefined' != typeof window
-                  ? window
-                  : {}
-          ));
-        },
-        { _process: 86 }
-      ],
-      88: [
-        function(t, e, i) {
-          'function' == typeof Object.create
-            ? (e.exports = function(t, e) {
-                (t.super_ = e),
-                  (t.prototype = Object.create(e.prototype, {
-                    constructor: { value: t, enumerable: !1, writable: !0, configurable: !0 }
-                  }));
-              })
-            : (e.exports = function(t, e) {
-                t.super_ = e;
-                var i = function() {};
-                (i.prototype = e.prototype), (t.prototype = new i()), (t.prototype.constructor = t);
-              });
-        },
-        {}
-      ],
-      89: [
-        function(t, e, i) {
-          e.exports = function(t) {
-            return (
-              t &&
-              'object' == typeof t &&
-              'function' == typeof t.copy &&
-              'function' == typeof t.fill &&
-              'function' == typeof t.readUInt8
-            );
-          };
-        },
-        {}
-      ],
-      90: [
-        function(w, t, k) {
-          (function(r, s) {
-            var l = /%[sdj%]/g;
-            (k.format = function(t) {
-              var e = arguments;
-              if (!g(t)) {
-                for (var i = [], r = 0; r < arguments.length; r++) i.push(u(e[r]));
-                return i.join(' ');
-              }
-              r = 1;
-              for (
-                var s = arguments,
-                  o = s.length,
-                  n = String(t).replace(l, function(t) {
-                    if ('%%' === t) return '%';
-                    if (o <= r) return t;
-                    switch (t) {
-                      case '%s':
-                        return String(s[r++]);
-                      case '%d':
-                        return Number(s[r++]);
-                      case '%j':
-                        try {
-                          return JSON.stringify(s[r++]);
-                        } catch (t) {
-                          return '[Circular]';
-                        }
-                      default:
-                        return t;
-                    }
-                  }),
-                  c = s[r];
-                r < o;
-                c = s[++r]
-              )
-                m(c) || !a(c) ? (n += ' ' + c) : (n += ' ' + u(c));
-              return n;
-            }),
-              (k.deprecate = function(t, e) {
-                if (x(s.process))
-                  return function() {
-                    return k.deprecate(t, e).apply(this, arguments);
-                  };
-                if (!0 === r.noDeprecation) return t;
-                var i = !1;
-                return function() {
-                  if (!i) {
-                    if (r.throwDeprecation) throw new Error(e);
-                    r.traceDeprecation ? console.trace(e) : console.error(e), (i = !0);
-                  }
-                  return t.apply(this, arguments);
-                };
-              });
-            var t,
-              o = {};
-            function u(t, e) {
-              var i = { seen: [], stylize: c };
-              return (
-                3 <= arguments.length && (i.depth = arguments[2]),
-                4 <= arguments.length && (i.colors = arguments[3]),
-                v(e) ? (i.showHidden = e) : e && k._extend(i, e),
-                x(i.showHidden) && (i.showHidden = !1),
-                x(i.depth) && (i.depth = 2),
-                x(i.colors) && (i.colors = !1),
-                x(i.customInspect) && (i.customInspect = !0),
-                i.colors && (i.stylize = n),
-                _(i, t, i.depth)
-              );
-            }
-            function n(t, e) {
-              var i = u.styles[e];
-              return i ? '[' + u.colors[i][0] + 'm' + t + '[' + u.colors[i][1] + 'm' : t;
-            }
-            function c(t, e) {
-              return t;
-            }
-            function _(e, i, r) {
-              if (
-                e.customInspect &&
-                i &&
-                L(i.inspect) &&
-                i.inspect !== k.inspect &&
-                (!i.constructor || i.constructor.prototype !== i)
-              ) {
-                var t = i.inspect(r, e);
-                return g(t) || (t = _(e, t, r)), t;
-              }
-              var s = (function(t, e) {
-                if (x(e)) return t.stylize('undefined', 'undefined');
-                if (g(e)) {
-                  var i =
-                    "'" +
-                    JSON.stringify(e)
-                      .replace(/^"|"$/g, '')
-                      .replace(/'/g, "\\'")
-                      .replace(/\\"/g, '"') +
-                    "'";
-                  return t.stylize(i, 'string');
-                }
-                if (d(e)) return t.stylize('' + e, 'number');
-                if (v(e)) return t.stylize('' + e, 'boolean');
-                if (m(e)) return t.stylize('null', 'null');
-              })(e, i);
-              if (s) return s;
-              var o = Object.keys(i),
-                n = (function(t) {
-                  var i = {};
-                  return (
-                    t.forEach(function(t, e) {
-                      i[t] = !0;
-                    }),
-                    i
-                  );
-                })(o);
-              if (
-                (e.showHidden && (o = Object.getOwnPropertyNames(i)),
-                j(i) && (0 <= o.indexOf('message') || 0 <= o.indexOf('description')))
-              )
-                return p(i);
-              if (0 === o.length) {
-                if (L(i)) {
-                  var c = i.name ? ': ' + i.name : '';
-                  return e.stylize('[Function' + c + ']', 'special');
-                }
-                if (R(i)) return e.stylize(RegExp.prototype.toString.call(i), 'regexp');
-                if (S(i)) return e.stylize(Date.prototype.toString.call(i), 'date');
-                if (j(i)) return p(i);
-              }
-              var l,
-                u = '',
-                a = !1,
-                h = ['{', '}'];
-              (y(i) && ((a = !0), (h = ['[', ']'])), L(i)) &&
-                (u = ' [Function' + (i.name ? ': ' + i.name : '') + ']');
-              return (
-                R(i) && (u = ' ' + RegExp.prototype.toString.call(i)),
-                S(i) && (u = ' ' + Date.prototype.toUTCString.call(i)),
-                j(i) && (u = ' ' + p(i)),
-                0 !== o.length || (a && 0 != i.length)
-                  ? r < 0
-                    ? R(i)
-                      ? e.stylize(RegExp.prototype.toString.call(i), 'regexp')
-                      : e.stylize('[Object]', 'special')
-                    : (e.seen.push(i),
-                      (l = a
-                        ? (function(e, i, r, s, t) {
-                            for (var o = [], n = 0, c = i.length; n < c; ++n)
-                              b(i, String(n)) ? o.push(f(e, i, r, s, String(n), !0)) : o.push('');
-                            return (
-                              t.forEach(function(t) {
-                                t.match(/^\d+$/) || o.push(f(e, i, r, s, t, !0));
-                              }),
-                              o
-                            );
-                          })(e, i, r, n, o)
-                        : o.map(function(t) {
-                            return f(e, i, r, n, t, a);
-                          })),
-                      e.seen.pop(),
-                      (function(t, e, i) {
-                        if (
-                          60 <
-                          t.reduce(function(t, e) {
-                            return (
-                              0,
-                              0 <= e.indexOf('\n') && 0,
-                              t + e.replace(/\u001b\[\d\d?m/g, '').length + 1
-                            );
-                          }, 0)
-                        )
-                          return (
-                            i[0] + ('' === e ? '' : e + '\n ') + ' ' + t.join(',\n  ') + ' ' + i[1]
-                          );
-                        return i[0] + e + ' ' + t.join(', ') + ' ' + i[1];
-                      })(l, u, h))
-                  : h[0] + u + h[1]
-              );
-            }
-            function p(t) {
-              return '[' + Error.prototype.toString.call(t) + ']';
-            }
-            function f(t, e, i, r, s, o) {
-              var n, c, l;
-              if (
-                ((l = Object.getOwnPropertyDescriptor(e, s) || { value: e[s] }).get
-                  ? (c = l.set
-                      ? t.stylize('[Getter/Setter]', 'special')
-                      : t.stylize('[Getter]', 'special'))
-                  : l.set && (c = t.stylize('[Setter]', 'special')),
-                b(r, s) || (n = '[' + s + ']'),
-                c ||
-                  (t.seen.indexOf(l.value) < 0
-                    ? -1 < (c = m(i) ? _(t, l.value, null) : _(t, l.value, i - 1)).indexOf('\n') &&
-                      (c = o
-                        ? c
-                            .split('\n')
-                            .map(function(t) {
-                              return '  ' + t;
-                            })
-                            .join('\n')
-                            .substr(2)
-                        : '\n' +
-                          c
-                            .split('\n')
-                            .map(function(t) {
-                              return '   ' + t;
-                            })
-                            .join('\n'))
-                    : (c = t.stylize('[Circular]', 'special'))),
-                x(n))
-              ) {
-                if (o && s.match(/^\d+$/)) return c;
-                n = (n = JSON.stringify('' + s)).match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)
-                  ? ((n = n.substr(1, n.length - 2)), t.stylize(n, 'name'))
-                  : ((n = n
-                      .replace(/'/g, "\\'")
-                      .replace(/\\"/g, '"')
-                      .replace(/(^"|"$)/g, "'")),
-                    t.stylize(n, 'string'));
-              }
-              return n + ': ' + c;
-            }
-            function y(t) {
-              return Array.isArray(t);
-            }
-            function v(t) {
-              return 'boolean' == typeof t;
-            }
-            function m(t) {
-              return null === t;
-            }
-            function d(t) {
-              return 'number' == typeof t;
-            }
-            function g(t) {
-              return 'string' == typeof t;
-            }
-            function x(t) {
-              return void 0 === t;
-            }
-            function R(t) {
-              return a(t) && '[object RegExp]' === e(t);
-            }
-            function a(t) {
-              return 'object' == typeof t && null !== t;
-            }
-            function S(t) {
-              return a(t) && '[object Date]' === e(t);
-            }
-            function j(t) {
-              return a(t) && ('[object Error]' === e(t) || t instanceof Error);
-            }
-            function L(t) {
-              return 'function' == typeof t;
-            }
-            function e(t) {
-              return Object.prototype.toString.call(t);
-            }
-            function i(t) {
-              return t < 10 ? '0' + t.toString(10) : t.toString(10);
-            }
-            (k.debuglog = function(e) {
-              if ((x(t) && (t = r.env.NODE_DEBUG || ''), (e = e.toUpperCase()), !o[e]))
-                if (new RegExp('\\b' + e + '\\b', 'i').test(t)) {
-                  var i = r.pid;
-                  o[e] = function() {
-                    var t = k.format.apply(k, arguments);
-                    console.error('%s %d: %s', e, i, t);
-                  };
-                } else o[e] = function() {};
-              return o[e];
-            }),
-              ((k.inspect = u).colors = {
-                bold: [1, 22],
-                italic: [3, 23],
-                underline: [4, 24],
-                inverse: [7, 27],
-                white: [37, 39],
-                grey: [90, 39],
-                black: [30, 39],
-                blue: [34, 39],
-                cyan: [36, 39],
-                green: [32, 39],
-                magenta: [35, 39],
-                red: [31, 39],
-                yellow: [33, 39]
-              }),
-              (u.styles = {
-                special: 'cyan',
-                number: 'yellow',
-                boolean: 'yellow',
-                undefined: 'grey',
-                null: 'bold',
-                string: 'green',
-                date: 'magenta',
-                regexp: 'red'
-              }),
-              (k.isArray = y),
-              (k.isBoolean = v),
-              (k.isNull = m),
-              (k.isNullOrUndefined = function(t) {
-                return null == t;
-              }),
-              (k.isNumber = d),
-              (k.isString = g),
-              (k.isSymbol = function(t) {
-                return 'symbol' == typeof t;
-              }),
-              (k.isUndefined = x),
-              (k.isRegExp = R),
-              (k.isObject = a),
-              (k.isDate = S),
-              (k.isError = j),
-              (k.isFunction = L),
-              (k.isPrimitive = function(t) {
-                return (
-                  null === t ||
-                  'boolean' == typeof t ||
-                  'number' == typeof t ||
-                  'string' == typeof t ||
-                  'symbol' == typeof t ||
-                  void 0 === t
-                );
-              }),
-              (k.isBuffer = w('./support/isBuffer'));
-            var h = [
-              'Jan',
-              'Feb',
-              'Mar',
-              'Apr',
-              'May',
-              'Jun',
-              'Jul',
-              'Aug',
-              'Sep',
-              'Oct',
-              'Nov',
-              'Dec'
-            ];
-            function b(t, e) {
-              return Object.prototype.hasOwnProperty.call(t, e);
-            }
-            (k.log = function() {
-              console.log(
-                '%s - %s',
-                (function() {
-                  var t = new Date(),
-                    e = [i(t.getHours()), i(t.getMinutes()), i(t.getSeconds())].join(':');
-                  return [t.getDate(), h[t.getMonth()], e].join(' ');
-                })(),
-                k.format.apply(k, arguments)
-              );
-            }),
-              (k.inherits = w('inherits')),
-              (k._extend = function(t, e) {
-                if (!e || !a(e)) return t;
-                for (var i = Object.keys(e), r = i.length; r--; ) t[i[r]] = e[i[r]];
-                return t;
-              });
-          }.call(
-            this,
-            w('_process'),
-            'undefined' != typeof global
-              ? global
-              : 'undefined' != typeof self
-                ? self
-                : 'undefined' != typeof window
-                  ? window
-                  : {}
-          ));
-        },
-        { './support/isBuffer': 89, _process: 86, inherits: 88 }
-      ],
-      91: [
-        function(t, e, i) {
-          e.exports = {
-            name: 'aigle',
-            version: '1.13.1',
-            description:
-              'Aigle is an ideal Promise library, faster and more functional than other Promise libraries',
-            main: 'index.js',
-            typings: 'aigle.d.ts',
-            private: !0,
-            browser: 'browser.js',
-            scripts: {
-              'start:doc': 'cd website && npm start',
-              build: 'npm-run-all build:*',
-              'build:lib': 'gulp build',
-              'build:type': 'typeg typings/aigle-base.d.ts --out typings/aigle.d.ts',
-              bench: 'node --expose_gc ./benchmark -d',
-              eslint: 'eslint . --ext .js',
-              test: 'DELAY=50 npm-run-all -p eslint test:type test:cov',
-              'test:mocha': 'mocha test/**/*.js',
-              'test:cov': 'nyc npm run test:mocha',
-              'test:type': 'cd typings && tsc',
-              codecov: 'nyc report --reporter=lcovonly && codecov',
-              'lint-staged': 'lint-staged',
-              prettier:
-                "prettier --write './benchmark/**/*.js' './gulp/**/*.js' './lib/**/*.js' './test/**/*.js' './typings/**/*.ts'"
-            },
-            homepage: 'https://github.com/suguru03/aigle',
-            keywords: ['aigle', 'promise', 'async'],
-            files: ['README.md', 'index.js', 'lib/', 'browser.js', 'dist/'],
-            author: 'Suguru Motegi',
-            license: 'MIT',
-            devDependencies: {
-              babili: '0.1.4',
-              benchmark: '^2.1.1',
-              bluebird: '^3.5.3',
-              browserify: '^16.2.3',
-              buble: '^0.19.6',
-              codecov: '^3.2.0',
-              docdash: '^1.0.0',
-              eslint: '^5.0.0',
-              'fs-extra': '^8.0.0',
-              gulp: '^4.0.0',
-              'gulp-bump': '^3.0.0',
-              'gulp-git': '^2.8.1',
-              'gulp-tag-version': '^1.3.0',
-              husky: '^2.0.0',
-              jsdoc: '^3.5.5',
-              'lint-staged': '^8.0.5',
-              lodash: '^4.15.0',
-              minimist: '^1.2.0',
-              mocha: '^6.0.2',
-              'mocha.parallel': '0.15.6',
-              'neo-async': '^2.6.0',
-              'npm-run-all': '^4.1.5',
-              nyc: '^14.0.0',
-              prettier: '^1.14.3',
-              'require-dir': '^1.0.0',
-              semver: '^6.0.0',
-              setimmediate: '^1.0.5',
-              tslint: '^5.11.0',
-              typeg: '^0.1.3',
-              typescript: '^3.1.6',
-              'uglify-js': '^3.5.1'
-            },
-            dependencies: { 'aigle-core': '^1.0.0' },
-            husky: { hooks: { 'pre-commit': 'npm-run-all -p build:type lint-staged' } },
-            'lint-staged': { '*.{js,ts}': ['prettier --write', 'git add'] },
-            prettier: { printWidth: 100, singleQuote: !0 }
-          };
-        },
-        {}
-      ]
-    },
-    {},
-    [1]
-  )(1);
-});
diff --git a/dist/aigle.js b/dist/aigle.js
index f53b7c26..d6d07617 100644
--- a/dist/aigle.js
+++ b/dist/aigle.js
@@ -59,7 +59,7 @@
           require('setimmediate');
           module.exports = require('./lib/aigle');
         },
-        { './lib/aigle': 2, setimmediate: 87 }
+        { './lib/aigle': 2, setimmediate: 88 }
       ],
       2: [
         function(require, module, exports) {
@@ -296,6 +296,10 @@
                 return addProxy(this, All);
               }
 
+              allSettled() {
+                return addProxy(this, AllSettled);
+              }
+
               /**
                * @return {Aigle} Returns an Aigle instance
                * @example
@@ -3618,6 +3622,7 @@
 
             /* functions, classes */
             const { all, All } = require('./all');
+            const { allSettled, AllSettled } = require('./allSettled');
             const attempt = require('./attempt');
             const { race, Race } = require('./race');
             const { props, Props } = require('./props');
@@ -3704,6 +3709,7 @@
 
             /* collections */
             Aigle.all = all;
+            Aigle.allSettled = allSettled;
             Aigle.race = race;
             Aigle.props = props;
             Aigle.series = series;
@@ -4067,88 +4073,89 @@
         },
         {
           './all': 3,
-          './attempt': 4,
-          './concat': 5,
-          './concatLimit': 6,
-          './concatSeries': 7,
-          './debug': 8,
-          './delay': 9,
-          './doUntil': 10,
-          './doWhilst': 11,
-          './each': 12,
-          './eachLimit': 13,
-          './eachSeries': 14,
-          './error': 15,
-          './every': 16,
-          './everyLimit': 17,
-          './everySeries': 18,
-          './filter': 19,
-          './filterLimit': 20,
-          './filterSeries': 21,
-          './find': 22,
-          './findIndex': 23,
-          './findIndexLimit': 24,
-          './findIndexSeries': 25,
-          './findKey': 26,
-          './findKeyLimit': 27,
-          './findKeySeries': 28,
-          './findLimit': 29,
-          './findSeries': 30,
-          './flow': 31,
-          './groupBy': 32,
-          './groupByLimit': 33,
-          './groupBySeries': 34,
-          './internal/async': 35,
-          './internal/mixin': 37,
-          './internal/queue': 38,
-          './internal/util': 39,
-          './join': 40,
-          './map': 41,
-          './mapLimit': 42,
-          './mapSeries': 43,
-          './mapValues': 44,
-          './mapValuesLimit': 45,
-          './mapValuesSeries': 46,
-          './omit': 47,
-          './omitBy': 48,
-          './omitByLimit': 49,
-          './omitBySeries': 50,
-          './parallel': 51,
-          './parallelLimit': 52,
-          './pick': 53,
-          './pickBy': 54,
-          './pickByLimit': 55,
-          './pickBySeries': 56,
-          './promisify': 57,
-          './promisifyAll': 58,
-          './props': 59,
-          './race': 60,
-          './reduce': 61,
-          './reject': 62,
-          './rejectLimit': 63,
-          './rejectSeries': 64,
-          './retry': 65,
-          './series': 66,
-          './some': 67,
-          './someLimit': 68,
-          './someSeries': 69,
-          './sortBy': 70,
-          './sortByLimit': 71,
-          './sortBySeries': 72,
-          './tap': 73,
-          './thru': 74,
-          './timeout': 75,
-          './times': 76,
-          './timesLimit': 77,
-          './timesSeries': 78,
-          './transform': 79,
-          './transformLimit': 80,
-          './transformSeries': 81,
-          './until': 82,
-          './using': 83,
-          './whilst': 84,
-          _process: 86,
-          'aigle-core': 85
+          './allSettled': 4,
+          './attempt': 5,
+          './concat': 6,
+          './concatLimit': 7,
+          './concatSeries': 8,
+          './debug': 9,
+          './delay': 10,
+          './doUntil': 11,
+          './doWhilst': 12,
+          './each': 13,
+          './eachLimit': 14,
+          './eachSeries': 15,
+          './error': 16,
+          './every': 17,
+          './everyLimit': 18,
+          './everySeries': 19,
+          './filter': 20,
+          './filterLimit': 21,
+          './filterSeries': 22,
+          './find': 23,
+          './findIndex': 24,
+          './findIndexLimit': 25,
+          './findIndexSeries': 26,
+          './findKey': 27,
+          './findKeyLimit': 28,
+          './findKeySeries': 29,
+          './findLimit': 30,
+          './findSeries': 31,
+          './flow': 32,
+          './groupBy': 33,
+          './groupByLimit': 34,
+          './groupBySeries': 35,
+          './internal/async': 36,
+          './internal/mixin': 38,
+          './internal/queue': 39,
+          './internal/util': 40,
+          './join': 41,
+          './map': 42,
+          './mapLimit': 43,
+          './mapSeries': 44,
+          './mapValues': 45,
+          './mapValuesLimit': 46,
+          './mapValuesSeries': 47,
+          './omit': 48,
+          './omitBy': 49,
+          './omitByLimit': 50,
+          './omitBySeries': 51,
+          './parallel': 52,
+          './parallelLimit': 53,
+          './pick': 54,
+          './pickBy': 55,
+          './pickByLimit': 56,
+          './pickBySeries': 57,
+          './promisify': 58,
+          './promisifyAll': 59,
+          './props': 60,
+          './race': 61,
+          './reduce': 62,
+          './reject': 63,
+          './rejectLimit': 64,
+          './rejectSeries': 65,
+          './retry': 66,
+          './series': 67,
+          './some': 68,
+          './someLimit': 69,
+          './someSeries': 70,
+          './sortBy': 71,
+          './sortByLimit': 72,
+          './sortBySeries': 73,
+          './tap': 74,
+          './thru': 75,
+          './timeout': 76,
+          './times': 77,
+          './timesLimit': 78,
+          './timesSeries': 79,
+          './transform': 80,
+          './transformLimit': 81,
+          './transformSeries': 82,
+          './until': 83,
+          './using': 84,
+          './whilst': 85,
+          _process: 87,
+          'aigle-core': 86
         }
       ],
       3: [
@@ -4243,9 +4250,74 @@
             return new All(array)._promise;
           }
         },
-        { './aigle': 2, './internal/util': 39, './props': 59, 'aigle-core': 85 }
+        { './aigle': 2, './internal/util': 40, './props': 60, 'aigle-core': 86 }
       ],
       4: [
+        function(require, module, exports) {
+          'use strict';
+
+          const { Parallel } = require('./parallel');
+
+          class AllSettled extends Parallel {
+            _set(coll) {
+              this._errorSet = new Set();
+              this._promise._resolve = createResolve(this);
+              super._set(coll);
+            }
+
+            _callReject(reason, key) {
+              this._errorSet.add(key);
+              this._callResolve(reason, key);
+              return true;
+            }
+          }
+
+          function createResolve(proxy) {
+            const { _errorSet, _promise } = proxy;
+            const { _resolve } = _promise;
+            return result => {
+              if (Array.isArray(result)) {
+                result = result.map(iterator);
+              } else if (result instanceof Map) {
+                for (const [key, val] of result) {
+                  result.set(key, iterator(val, key));
+                }
+              } else {
+                for (const [key, val] of Object.entries(result)) {
+                  result[key] = iterator(val, key);
+                }
+              }
+              _resolve.call(_promise, result);
+            };
+            function iterator(res, key) {
+              return _errorSet.has(key)
+                ? { state: 'rejected', reason: res }
+                : { state: 'fulfilled', value: res };
+            }
+          }
+
+          module.exports = { allSettled, AllSettled };
+
+          /**
+           * Return an Aigle instance
+           * @param {Array|Object} collection - it should be an array/object of functions or Promise instances
+           * @example
+           * Aigle.allSettled([
+           *   Aigle.resolve(1),
+           *   Aigle.reject(2),
+           *   Aigle.reject(3)
+           * ])
+           * .then(array => {
+           *   console.log(array); // [{ state: 'fulfilled', value: 1 }, { state: 'rejected', reason: 2 }, { state: 'rejected', reason: 3 }]
+           * });
+           */
+          function allSettled(collection) {
+            return new AllSettled(collection)._promise;
+          }
+        },
+        { './parallel': 52 }
+      ],
+      5: [
         function(require, module, exports) {
           'use strict';
 
@@ -4269,9 +4341,9 @@
             return receiver;
           }
         },
-        { './aigle': 2, './internal/util': 39 }
+        { './aigle': 2, './internal/util': 40 }
       ],
-      5: [
+      6: [
         function(require, module, exports) {
           'use strict';
 
@@ -4346,9 +4418,9 @@
             return new Concat(collection, iterator)._execute();
           }
         },
-        { './each': 12, './internal/collection': 36, './internal/util': 39 }
+        { './each': 13, './internal/collection': 37, './internal/util': 40 }
       ],
-      6: [
+      7: [
         function(require, module, exports) {
           'use strict';
 
@@ -4444,9 +4516,9 @@
             return new ConcatLimit(collection, limit, iterator)._execute();
           }
         },
-        { './eachLimit': 13, './internal/collection': 36, './internal/util': 39 }
+        { './eachLimit': 14, './internal/collection': 37, './internal/util': 40 }
       ],
-      7: [
+      8: [
         function(require, module, exports) {
           'use strict';
 
@@ -4515,9 +4587,9 @@
             return new ConcatSeries(collection, iterator)._execute();
           }
         },
-        { './eachSeries': 14 }
+        { './eachSeries': 15 }
       ],
-      8: [
+      9: [
         function(require, module, exports) {
           'use strict';
 
@@ -4559,7 +4631,7 @@
         },
         {}
       ],
-      9: [
+      10: [
         function(require, module, exports) {
           'use strict';
 
@@ -4603,9 +4675,9 @@
             return new Delay(ms)._resolve(value);
           }
         },
-        { './aigle': 2, './internal/util': 39 }
+        { './aigle': 2, './internal/util': 40 }
       ],
-      10: [
+      11: [
         function(require, module, exports) {
           'use strict';
 
@@ -4668,9 +4740,9 @@
             return new DoWhilst(new UntilTester(tester), iterator)._iterate(value);
           }
         },
-        { './doWhilst': 11, './until': 82 }
+        { './doWhilst': 12, './until': 83 }
       ],
-      11: [
+      12: [
         function(require, module, exports) {
           'use strict';
 
@@ -4743,9 +4815,9 @@
             return new DoWhilst(new WhilstTester(tester), iterator)._iterate(value);
           }
         },
-        { './whilst': 84 }
+        { './whilst': 85 }
       ],
-      12: [
+      13: [
         function(require, module, exports) {
           'use strict';
 
@@ -4857,9 +4929,9 @@
             return new Each(collection, iterator)._execute();
           }
         },
-        { './aigle': 2, './internal/collection': 36, './internal/util': 39, 'aigle-core': 85 }
+        { './aigle': 2, './internal/collection': 37, './internal/util': 40, 'aigle-core': 86 }
       ],
-      13: [
+      14: [
         function(require, module, exports) {
           'use strict';
 
@@ -5015,9 +5087,9 @@
             return new EachLimit(collection, limit, iterator)._execute();
           }
         },
-        { './aigle': 2, './internal/collection': 36, './internal/util': 39, 'aigle-core': 85 }
+        { './aigle': 2, './internal/collection': 37, './internal/util': 40, 'aigle-core': 86 }
       ],
-      14: [
+      15: [
         function(require, module, exports) {
           'use strict';
 
@@ -5129,9 +5201,9 @@
             return new EachSeries(collection, iterator)._execute();
           }
         },
-        { './aigle': 2, './internal/collection': 36, './internal/util': 39, 'aigle-core': 85 }
+        { './aigle': 2, './internal/collection': 37, './internal/util': 40, 'aigle-core': 86 }
       ],
-      15: [
+      16: [
         function(require, module, exports) {
           'use strict';
 
@@ -5146,7 +5218,7 @@
         },
         {}
       ],
-      16: [
+      17: [
         function(require, module, exports) {
           'use strict';
 
@@ -5268,9 +5340,9 @@
             return new Every(collection, iterator)._execute();
           }
         },
-        { './each': 12, './internal/collection': 36, './internal/util': 39 }
+        { './each': 13, './internal/collection': 37, './internal/util': 40 }
       ],
-      17: [
+      18: [
         function(require, module, exports) {
           'use strict';
 
@@ -5358,9 +5430,9 @@
             return new EveryLimit(collection, limit, iterator)._execute();
           }
         },
-        { './eachLimit': 13 }
+        { './eachLimit': 14 }
       ],
-      18: [
+      19: [
         function(require, module, exports) {
           'use strict';
 
@@ -5442,9 +5514,9 @@
             return new EverySeries(collection, iterator)._execute();
           }
         },
-        { './eachSeries.js': 14 }
+        { './eachSeries.js': 15 }
       ],
-      19: [
+      20: [
         function(require, module, exports) {
           'use strict';
 
@@ -5565,9 +5637,9 @@
             return new Filter(collection, iterator)._execute();
           }
         },
-        { './each': 12, './internal/collection': 36, './internal/util': 39 }
+        { './each': 13, './internal/collection': 37, './internal/util': 40 }
       ],
-      20: [
+      21: [
         function(require, module, exports) {
           'use strict';
 
@@ -5673,9 +5745,9 @@
             return new FilterLimit(collection, limit, iterator)._execute();
           }
         },
-        { './eachLimit': 13, './internal/collection': 36, './internal/util': 39 }
+        { './eachLimit': 14, './internal/collection': 37, './internal/util': 40 }
       ],
-      21: [
+      22: [
         function(require, module, exports) {
           'use strict';
 
@@ -5757,9 +5829,9 @@
             return new FilterSeries(collection, iterator)._execute();
           }
         },
-        { './eachSeries': 14, './internal/collection': 36, './internal/util': 39 }
+        { './eachSeries': 15, './internal/collection': 37, './internal/util': 40 }
       ],
-      22: [
+      23: [
         function(require, module, exports) {
           'use strict';
 
@@ -5892,9 +5964,9 @@
             return new Find(collection, iterator)._execute();
           }
         },
-        { './each': 12, './internal/collection': 36 }
+        { './each': 13, './internal/collection': 37 }
       ],
-      23: [
+      24: [
         function(require, module, exports) {
           'use strict';
 
@@ -6001,9 +6073,9 @@
             return new FindIndex(collection, iterator)._execute();
           }
         },
-        { './each': 12, './internal/collection': 36 }
+        { './each': 13, './internal/collection': 37 }
       ],
-      24: [
+      25: [
         function(require, module, exports) {
           'use strict';
 
@@ -6081,9 +6153,9 @@
             return new FindIndexLimit(collection, limit, iterator)._execute();
           }
         },
-        { './eachLimit': 13, './internal/collection': 36 }
+        { './eachLimit': 14, './internal/collection': 37 }
       ],
-      25: [
+      26: [
         function(require, module, exports) {
           'use strict';
 
@@ -6157,9 +6229,9 @@
             return new FindIndexSeries(collection, iterator)._execute();
           }
         },
-        { './eachSeries': 14, './internal/collection': 36 }
+        { './eachSeries': 15, './internal/collection': 37 }
       ],
-      26: [
+      27: [
         function(require, module, exports) {
           'use strict';
 
@@ -6207,9 +6279,9 @@
             return new FindKey(collection, iterator)._execute();
           }
         },
-        { './each': 12, './internal/collection': 36 }
+        { './each': 13, './internal/collection': 37 }
       ],
-      27: [
+      28: [
         function(require, module, exports) {
           'use strict';
 
@@ -6262,9 +6334,9 @@
             return new FindKeyLimit(collection, limit, iterator)._execute();
           }
         },
-        { './eachLimit': 13, './internal/collection': 36 }
+        { './eachLimit': 14, './internal/collection': 37 }
       ],
-      28: [
+      29: [
         function(require, module, exports) {
           'use strict';
 
@@ -6314,9 +6386,9 @@
             return new FindKeySeries(collection, iterator)._execute();
           }
         },
-        { './eachSeries': 14, './internal/collection': 36 }
+        { './eachSeries': 15, './internal/collection': 37 }
       ],
-      29: [
+      30: [
         function(require, module, exports) {
           'use strict';
 
@@ -6418,9 +6490,9 @@
             return new FindLimit(collection, limit, iterator)._execute();
           }
         },
-        { './eachLimit': 13, './internal/collection': 36 }
+        { './eachLimit': 14, './internal/collection': 37 }
       ],
-      30: [
+      31: [
         function(require, module, exports) {
           'use strict';
 
@@ -6518,9 +6590,9 @@
             return new FindSeries(collection, iterator)._execute();
           }
         },
-        { './eachSeries': 14, './internal/collection': 36 }
+        { './eachSeries': 15, './internal/collection': 37 }
       ],
-      31: [
+      32: [
         function(require, module, exports) {
           'use strict';
 
@@ -6564,7 +6636,7 @@
         },
         { './aigle': 2 }
       ],
-      32: [
+      33: [
         function(require, module, exports) {
           'use strict';
 
@@ -6680,9 +6752,9 @@
             return new GroupBy(collection, iterator)._execute();
           }
         },
-        { './each': 12, './internal/collection': 36 }
+        { './each': 13, './internal/collection': 37 }
       ],
-      33: [
+      34: [
         function(require, module, exports) {
           'use strict';
 
@@ -6793,9 +6865,9 @@
             return new GroupByLimit(collection, limit, iterator)._execute();
           }
         },
-        { './eachLimit': 13, './internal/collection': 36 }
+        { './eachLimit': 14, './internal/collection': 37 }
       ],
-      34: [
+      35: [
         function(require, module, exports) {
           'use strict';
 
@@ -6883,9 +6955,9 @@
             return new GroupBySeries(collection, iterator)._execute();
           }
         },
-        { './eachSeries': 14, './internal/collection': 36 }
+        { './eachSeries': 15, './internal/collection': 37 }
       ],
-      35: [
+      36: [
         function(require, module, exports) {
           'use strict';
 
@@ -6923,7 +6995,7 @@
         },
         {}
       ],
-      36: [
+      37: [
         function(require, module, exports) {
           'use strict';
 
@@ -7231,9 +7303,9 @@
             }
           }
         },
-        { './util': 39 }
+        { './util': 40 }
       ],
-      37: [
+      38: [
         function(require, module, exports) {
           'use strict';
 
@@ -7329,9 +7401,9 @@
             };
           }
         },
-        { '../aigle': 2, '../map': 41, '../mapValues': 44, './util': 39, 'aigle-core': 85 }
+        { '../aigle': 2, '../map': 42, '../mapValues': 45, './util': 40, 'aigle-core': 86 }
       ],
-      38: [
+      39: [
         function(require, module, exports) {
           'use strict';
 
@@ -7350,7 +7422,7 @@
         },
         {}
       ],
-      39: [
+      40: [
         function(require, module, exports) {
           (function(process) {
             'use strict';
@@ -7544,7 +7616,7 @@
               }
 
               function reject(reason) {
-                receiver._callReject(reason);
+                receiver._callReject(reason, key);
               }
             }
 
@@ -7559,13 +7631,11 @@
                     return true;
                   case 2:
                     promise.suppressUnhandledRejections();
-                    receiver._callReject(promise._value);
-                    return false;
+                    return receiver._callReject(promise._value, key) === true;
                 }
               }
               if (promise === errorObj) {
-                receiver._callReject(errorObj.e);
-                return false;
+                return receiver._callReject(errorObj.e, key) === true;
               }
               if (promise && promise.then) {
                 callProxyThen(promise, receiver, key);
@@ -7803,9 +7873,9 @@
             }
           }.call(this, require('_process')));
         },
-        { '../../package.json': 91, _process: 86, 'aigle-core': 85 }
+        { '../../package.json': 92, _process: 87, 'aigle-core': 86 }
       ],
-      40: [
+      41: [
         function(require, module, exports) {
           'use strict';
 
@@ -7919,9 +7989,9 @@
             callProxyReciever(apply(_handler, array), proxy, INTERNAL);
           }
         },
-        { './aigle': 2, './internal/util': 39, 'aigle-core': 85 }
+        { './aigle': 2, './internal/util': 40, 'aigle-core': 86 }
       ],
-      41: [
+      42: [
         function(require, module, exports) {
           'use strict';
 
@@ -8005,9 +8075,9 @@
             return new Map(collection, iterator)._execute();
           }
         },
-        { './each': 12, './internal/collection': 36 }
+        { './each': 13, './internal/collection': 37 }
       ],
-      42: [
+      43: [
         function(require, module, exports) {
           'use strict';
 
@@ -8096,9 +8166,9 @@
             return new MapLimit(collection, limit, iterator)._execute();
           }
         },
-        { './eachLimit': 13, './internal/collection': 36 }
+        { './eachLimit': 14, './internal/collection': 37 }
       ],
-      43: [
+      44: [
         function(require, module, exports) {
           'use strict';
 
@@ -8169,9 +8239,9 @@
             return new MapSeries(collection, iterator)._execute();
           }
         },
-        { './eachSeries': 14, './internal/collection': 36 }
+        { './eachSeries': 15, './internal/collection': 37 }
       ],
-      44: [
+      45: [
         function(require, module, exports) {
           'use strict';
 
@@ -8258,9 +8328,9 @@
             return new MapValues(collection, iterator)._execute();
           }
         },
-        { './each': 12, './internal/collection': 36 }
+        { './each': 13, './internal/collection': 37 }
       ],
-      45: [
+      46: [
         function(require, module, exports) {
           'use strict';
 
@@ -8365,9 +8435,9 @@
             return new MapValuesLimit(collection, limit, iterator)._execute();
           }
         },
-        { './eachLimit': 13, './internal/collection': 36, './internal/util': 39 }
+        { './eachLimit': 14, './internal/collection': 37, './internal/util': 40 }
       ],
-      46: [
+      47: [
         function(require, module, exports) {
           'use strict';
 
@@ -8448,9 +8518,9 @@
             return new MapValuesSeries(collection, iterator)._execute();
           }
         },
-        { './eachSeries': 14, './internal/collection': 36 }
+        { './eachSeries': 15, './internal/collection': 37 }
       ],
-      47: [
+      48: [
         function(require, module, exports) {
           'use strict';
 
@@ -8538,9 +8608,9 @@
             return new Omit(collection, iterator, args)._execute();
           }
         },
-        { './each': 12, './internal/collection': 36 }
+        { './each': 13, './internal/collection': 37 }
       ],
-      48: [
+      49: [
         function(require, module, exports) {
           'use strict';
 
@@ -8659,9 +8729,9 @@
             return new OmitBy(collection, iterator)._execute();
           }
         },
-        { './each': 12, './internal/collection': 36 }
+        { './each': 13, './internal/collection': 37 }
       ],
-      49: [
+      50: [
         function(require, module, exports) {
           'use strict';
 
@@ -8765,9 +8835,9 @@
             return new OmitByLimit(collection, limit, iterator)._execute();
           }
         },
-        { './eachLimit': 13, './internal/collection': 36 }
+        { './eachLimit': 14, './internal/collection': 37 }
       ],
-      50: [
+      51: [
         function(require, module, exports) {
           'use strict';
 
@@ -8859,9 +8929,9 @@
             return new OmitBySeries(collection, iterator)._execute();
           }
         },
-        { './eachSeries': 14, './internal/collection': 36, './internal/util': 39 }
+        { './eachSeries': 15, './internal/collection': 37, './internal/util': 40 }
       ],
-      51: [
+      52: [
         function(require, module, exports) {
           'use strict';
 
@@ -8902,7 +8972,7 @@
                 promiseArrayEachWithFunc(this, size, coll);
               } else if (!coll || typeof coll !== 'object') {
                 this._rest = 0;
-                this._result = undefined;
+                this._result = {};
               } else if (coll[iteratorSymbol]) {
                 const size = coll.size;
                 this._rest = size;
@@ -8968,9 +9038,9 @@
             return new Parallel(collection)._promise;
           }
         },
-        { './aigle': 2, './internal/util': 39, './props': 59, 'aigle-core': 85 }
+        { './aigle': 2, './internal/util': 40, './props': 60, 'aigle-core': 86 }
       ],
-      52: [
+      53: [
         function(require, module, exports) {
           'use strict';
 
@@ -9056,9 +9126,9 @@
             return new ParallelLimit(collection, limit)._execute();
           }
         },
-        { './internal/util': 39, './series': 66 }
+        { './internal/util': 40, './series': 67 }
       ],
-      53: [
+      54: [
         function(require, module, exports) {
           'use strict';
 
@@ -9146,9 +9216,9 @@
             return new Pick(collection, iterator, args)._execute();
           }
         },
-        { './each': 12, './internal/collection': 36 }
+        { './each': 13, './internal/collection': 37 }
       ],
-      54: [
+      55: [
         function(require, module, exports) {
           'use strict';
 
@@ -9267,9 +9337,9 @@
             return new PickBy(collection, iterator)._execute();
           }
         },
-        { './each': 12, './internal/collection': 36 }
+        { './each': 13, './internal/collection': 37 }
       ],
-      55: [
+      56: [
         function(require, module, exports) {
           'use strict';
 
@@ -9373,9 +9443,9 @@
             return new PickByLimit(collection, limit, iterator)._execute();
           }
         },
-        { './eachLimit': 13, './internal/collection': 36 }
+        { './eachLimit': 14, './internal/collection': 37 }
       ],
-      56: [
+      57: [
         function(require, module, exports) {
           'use strict';
 
@@ -9461,9 +9531,9 @@
             return new PickBySeries(collection, iterator)._execute();
           }
         },
-        { './eachSeries': 14, './internal/collection': 36 }
+        { './eachSeries': 15, './internal/collection': 37 }
       ],
-      57: [
+      58: [
         function(require, module, exports) {
           'use strict';
 
@@ -9643,9 +9713,9 @@
             }
           }
         },
-        { './aigle': 2, './internal/util': 39, util: 90 }
+        { './aigle': 2, './internal/util': 40, util: 91 }
       ],
-      58: [
+      59: [
         function(require, module, exports) {
           'use strict';
 
@@ -9752,9 +9822,9 @@
             }
           }
         },
-        { './promisify': 57 }
+        { './promisify': 58 }
       ],
-      59: [
+      60: [
         function(require, module, exports) {
           'use strict';
 
@@ -9858,9 +9928,9 @@
             return new Props(object)._promise;
           }
         },
-        { './aigle': 2, './internal/util': 39, 'aigle-core': 85 }
+        { './aigle': 2, './internal/util': 40, 'aigle-core': 86 }
       ],
-      60: [
+      61: [
         function(require, module, exports) {
           'use strict';
 
@@ -9943,9 +10013,9 @@
             return new Race(collection)._promise;
           }
         },
-        { './aigle': 2, './internal/util': 39, 'aigle-core': 85 }
+        { './aigle': 2, './internal/util': 40, 'aigle-core': 86 }
       ],
-      61: [
+      62: [
         function(require, module, exports) {
           'use strict';
 
@@ -10060,9 +10130,9 @@
             return new Reduce(collection, iterator, result)._execute();
           }
         },
-        { './aigle': 2, './internal/collection': 36, './internal/util': 39, 'aigle-core': 85 }
+        { './aigle': 2, './internal/collection': 37, './internal/util': 40, 'aigle-core': 86 }
       ],
-      62: [
+      63: [
         function(require, module, exports) {
           'use strict';
 
@@ -10187,9 +10257,9 @@
             return new Reject(collection, iterator)._execute();
           }
         },
-        { './each': 12, './internal/collection': 36, './internal/util': 39 }
+        { './each': 13, './internal/collection': 37, './internal/util': 40 }
       ],
-      63: [
+      64: [
         function(require, module, exports) {
           'use strict';
 
@@ -10287,9 +10357,9 @@
             return new RejectLimit(collection, limit, iterator)._execute();
           }
         },
-        { './eachLimit': 13, './internal/collection': 36, './internal/util': 39 }
+        { './eachLimit': 14, './internal/collection': 37, './internal/util': 40 }
       ],
-      64: [
+      65: [
         function(require, module, exports) {
           'use strict';
 
@@ -10370,9 +10440,9 @@
             return new RejectSeries(collection, iterator)._execute();
           }
         },
-        { './eachSeries': 14, './internal/collection': 36, './internal/util': 39 }
+        { './eachSeries': 15, './internal/collection': 37, './internal/util': 40 }
       ],
-      65: [
+      66: [
         function(require, module, exports) {
           'use strict';
 
@@ -10496,9 +10566,9 @@
             return new Retry(opts, handler)._promise;
           }
         },
-        { './aigle': 2, './internal/util': 39, 'aigle-core': 85 }
+        { './aigle': 2, './internal/util': 40, 'aigle-core': 86 }
       ],
-      66: [
+      67: [
         function(require, module, exports) {
           'use strict';
 
@@ -10567,7 +10637,7 @@
               this._iterator = promiseArrayIterator;
             } else if (typeof coll !== 'object' || coll === null) {
               this._rest = 0;
-              this._result = undefined;
+              this._result = {};
             } else if (coll[iteratorSymbol]) {
               this._coll = coll[iteratorSymbol]();
               const size = coll.size;
@@ -10626,9 +10696,9 @@
             return new Series(collection)._execute();
           }
         },
-        { './aigle': 2, './internal/collection': 36, './internal/util': 39, 'aigle-core': 85 }
+        { './aigle': 2, './internal/collection': 37, './internal/util': 40, 'aigle-core': 86 }
       ],
-      67: [
+      68: [
         function(require, module, exports) {
           'use strict';
 
@@ -10746,9 +10816,9 @@
             return new Some(collection, iterator)._execute();
           }
         },
-        { './each': 12, './internal/collection': 36 }
+        { './each': 13, './internal/collection': 37 }
       ],
-      68: [
+      69: [
         function(require, module, exports) {
           'use strict';
 
@@ -10832,9 +10902,9 @@
             return new SomeLimit(collection, limit, iterator)._execute();
           }
         },
-        { './eachLimit': 13 }
+        { './eachLimit': 14 }
       ],
-      69: [
+      70: [
         function(require, module, exports) {
           'use strict';
 
@@ -10916,9 +10986,9 @@
             return new SomeSeries(collection, iterator)._execute();
           }
         },
-        { './eachSeries.js': 14 }
+        { './eachSeries.js': 15 }
       ],
-      70: [
+      71: [
         function(require, module, exports) {
           'use strict';
 
@@ -11009,9 +11079,9 @@
             return new SortBy(collection, iterator)._execute();
           }
         },
-        { './each': 12, './internal/collection': 36, './internal/util': 39 }
+        { './each': 13, './internal/collection': 37, './internal/util': 40 }
       ],
-      71: [
+      72: [
         function(require, module, exports) {
           'use strict';
 
@@ -11111,9 +11181,9 @@
             return new SortByLimit(collection, limit, iterator)._execute();
           }
         },
-        { './eachLimit': 13, './internal/collection': 36, './internal/util': 39 }
+        { './eachLimit': 14, './internal/collection': 37, './internal/util': 40 }
       ],
-      72: [
+      73: [
         function(require, module, exports) {
           'use strict';
 
@@ -11196,9 +11266,9 @@
             return new SortBySeries(collection, iterator)._execute();
           }
         },
-        { './eachSeries': 14, './internal/collection': 36, './internal/util': 39 }
+        { './eachSeries': 15, './internal/collection': 37, './internal/util': 40 }
       ],
-      73: [
+      74: [
         function(require, module, exports) {
           'use strict';
 
@@ -11214,9 +11284,9 @@
 
           module.exports = tap;
         },
-        { './aigle': 2, './internal/util': 39 }
+        { './aigle': 2, './internal/util': 40 }
       ],
-      74: [
+      75: [
         function(require, module, exports) {
           'use strict';
 
@@ -11231,9 +11301,9 @@
 
           module.exports = thru;
         },
-        { './aigle': 2, './internal/util': 39 }
+        { './aigle': 2, './internal/util': 40 }
       ],
-      75: [
+      76: [
         function(require, module, exports) {
           'use strict';
 
@@ -11267,9 +11337,9 @@
 
           module.exports = Timeout;
         },
-        { './aigle': 2, './error': 15, './internal/util': 39, 'aigle-core': 85 }
+        { './aigle': 2, './error': 16, './internal/util': 40, 'aigle-core': 86 }
       ],
-      76: [
+      77: [
         function(require, module, exports) {
           'use strict';
 
@@ -11365,9 +11435,9 @@
             return new Times(times, iterator)._execute();
           }
         },
-        { './aigle': 2, './internal/util': 39, 'aigle-core': 85 }
+        { './aigle': 2, './internal/util': 40, 'aigle-core': 86 }
       ],
-      77: [
+      78: [
         function(require, module, exports) {
           'use strict';
 
@@ -11499,9 +11569,9 @@
             return new TimesLimit(times, limit, iterator)._execute();
           }
         },
-        { './aigle': 2, './internal/util': 39, 'aigle-core': 85 }
+        { './aigle': 2, './internal/util': 40, 'aigle-core': 86 }
       ],
-      78: [
+      79: [
         function(require, module, exports) {
           'use strict';
 
@@ -11587,9 +11657,9 @@
             return new TimesSeries(times, iterator)._execute();
           }
         },
-        { './aigle': 2, './internal/util': 39, './times': 76, 'aigle-core': 85 }
+        { './aigle': 2, './internal/util': 40, './times': 77, 'aigle-core': 86 }
       ],
-      79: [
+      80: [
         function(require, module, exports) {
           'use strict';
 
@@ -11712,9 +11782,9 @@
             return new Transform(collection, iterator, accumulator)._execute();
           }
         },
-        { './each': 12, './internal/collection': 36, './internal/util': 39 }
+        { './each': 13, './internal/collection': 37, './internal/util': 40 }
       ],
-      80: [
+      81: [
         function(require, module, exports) {
           'use strict';
 
@@ -11858,9 +11928,9 @@
             return new TransformLimit(collection, limit, iterator, accumulator)._execute();
           }
         },
-        { './eachLimit': 13, './internal/collection': 36, './internal/util': 39 }
+        { './eachLimit': 14, './internal/collection': 37, './internal/util': 40 }
       ],
-      81: [
+      82: [
         function(require, module, exports) {
           'use strict';
 
@@ -11982,9 +12052,9 @@
             return new TransformSeries(collection, iterator, accumulator)._execute();
           }
         },
-        { './eachSeries': 14, './internal/collection': 36, './internal/util': 39 }
+        { './eachSeries': 15, './internal/collection': 37, './internal/util': 40 }
       ],
-      82: [
+      83: [
         function(require, module, exports) {
           'use strict';
 
@@ -12020,9 +12090,9 @@
             return new AigleWhilst(new UntilTester(tester), iterator)._iterate(value);
           }
         },
-        { './whilst': 84 }
+        { './whilst': 85 }
       ],
-      83: [
+      84: [
         function(require, module, exports) {
           'use strict';
 
@@ -12135,9 +12205,9 @@
             return new Using(array, handler)._promise;
           }
         },
-        { './aigle': 2, './internal/util': 39, 'aigle-core': 85 }
+        { './aigle': 2, './internal/util': 40, 'aigle-core': 86 }
       ],
-      84: [
+      85: [
         function(require, module, exports) {
           'use strict';
 
@@ -12215,9 +12285,9 @@
             return new AigleWhilst(new WhilstTester(tester), iterator)._iterate(value);
           }
         },
-        { './aigle': 2, './internal/util': 39, 'aigle-core': 85 }
+        { './aigle': 2, './internal/util': 40, 'aigle-core': 86 }
       ],
-      85: [
+      86: [
         function(require, module, exports) {
           'use strict';
 
@@ -12233,7 +12303,7 @@
         },
         {}
       ],
-      86: [
+      87: [
         function(require, module, exports) {
           // shim for using process in browser
           var process = (module.exports = {});
@@ -12426,7 +12496,7 @@
         },
         {}
       ],
-      87: [
+      88: [
         function(require, module, exports) {
           (function(process, global) {
             (function(global, undefined) {
@@ -12629,9 +12699,9 @@
                   : {}
           ));
         },
-        { _process: 86 }
+        { _process: 87 }
       ],
-      88: [
+      89: [
         function(require, module, exports) {
           if (typeof Object.create === 'function') {
             // implementation from standard node.js 'util' module
@@ -12659,7 +12729,7 @@
         },
         {}
       ],
-      89: [
+      90: [
         function(require, module, exports) {
           module.exports = function isBuffer(arg) {
             return (
@@ -12673,7 +12743,7 @@
         },
         {}
       ],
-      90: [
+      91: [
         function(require, module, exports) {
           (function(process, global) {
             // Copyright Joyent, Inc. and other Node contributors.
@@ -13293,13 +13363,13 @@
                   : {}
           ));
         },
-        { './support/isBuffer': 89, _process: 86, inherits: 88 }
+        { './support/isBuffer': 90, _process: 87, inherits: 89 }
       ],
-      91: [
+      92: [
         function(require, module, exports) {
           module.exports = {
             name: 'aigle',
-            version: '1.13.1',
+            version: '1.14.0',
             description:
               'Aigle is an ideal Promise library, faster and more functional than other Promise libraries',
             main: 'index.js',
@@ -13346,7 +13416,7 @@
               'lint-staged': '^8.0.5',
               lodash: '^4.15.0',
               minimist: '^1.2.0',
-              mocha: '^6.0.2',
+              mocha: '^6.1.4',
               'mocha.parallel': '0.15.6',
               'neo-async': '^2.6.0',
               'npm-run-all': '^4.1.5',
@@ -13358,7 +13428,7 @@
               tslint: '^5.11.0',
               typeg: '^0.1.3',
               typescript: '^3.1.6',
-              'uglify-js': '^3.5.1'
+              'uglify-js': '^3.5.14'
             },
             dependencies: {
               'aigle-core': '^1.0.0'
diff --git a/dist/aigle.min.js b/dist/aigle.min.js
index 1a5a8dd3..5c229d92 100644
--- a/dist/aigle.min.js
+++ b/dist/aigle.min.js
@@ -53,7 +53,7 @@
           'use strict';
           e('setimmediate'), (t.exports = e('./lib/aigle'));
         },
-        { './lib/aigle': 2, setimmediate: 87 }
+        { './lib/aigle': 2, setimmediate: 88 }
       ],
       2: [
         function(e, t) {
@@ -65,7 +65,7 @@
               return L(t, e), t;
             }
             function i(t) {
-              E && lr(this);
+              E && sr(this);
               try {
                 t(
                   e => {
@@ -81,7 +81,7 @@
               }
             }
             function s(t) {
-              E && lr(this);
+              E && sr(this);
               try {
                 t(
                   e => {
@@ -141,9 +141,9 @@
             }
             function a(e, t, r, l) {
               return (
-                E && lr(t),
+                E && sr(t),
                 void 0 === e._receiver || e._receiver === h
-                  ? (0 !== e._resolved && y(e),
+                  ? (0 !== e._resolved && d(e),
                     (e._receiver = t),
                     (e._onFulfilled = r),
                     (e._onRejected = l))
@@ -155,13 +155,13 @@
               );
             }
             function c(e, t) {
-              return E && lr(t), 0 !== e._resolved && y(e), (e._receiver = t), t._promise;
+              return E && sr(t), 0 !== e._resolved && d(e), (e._receiver = t), t._promise;
             }
             function n(e, t, r, l, i) {
               if (E) {
                 E = !1;
                 const s = n(e, t, r, l, i);
-                return (E = !0), lr(s), s;
+                return (E = !0), sr(s), s;
               }
               switch (e._resolved) {
                 case 0:
@@ -181,9 +181,9 @@
             }
             const { AigleCore: u, AigleProxy: p } = e('aigle-core'),
               m = e('./internal/queue'),
-              y = e('./internal/async'),
+              d = e('./internal/async'),
               {
-                VERSION: d,
+                VERSION: y,
                 INTERNAL: h,
                 PENDING: v,
                 UNHANDLED: x,
@@ -237,7 +237,7 @@
                 return 2 === this._resolved;
               }
               isCancelled() {
-                return this._value instanceof or;
+                return this._value instanceof ar;
               }
               value() {
                 return 1 === this._resolved ? this._value : void 0;
@@ -254,7 +254,7 @@
                     for (this._onCancelQueue = void 0; ++t < e.length; ) r[t]();
                   }
                   (this._resolved = 2),
-                    (this._value = new or('late cancellation observer')),
+                    (this._value = new ar('late cancellation observer')),
                     this._parent && this._parent.cancel();
                 }
               }
@@ -262,109 +262,112 @@
                 this._receiver = h;
               }
               spread(e) {
-                return c(this, new Ft(e));
+                return c(this, new Dt(e));
               }
               all() {
                 return n(this, A);
               }
+              allSettled() {
+                return n(this, I);
+              }
               race() {
-                return n(this, P);
+                return n(this, T);
               }
               props() {
-                return n(this, T);
+                return n(this, F);
               }
               parallel() {
-                return n(this, F);
+                return n(this, D);
               }
               series() {
-                return n(this, D);
+                return n(this, M);
               }
               parallelLimit(e) {
-                return n(this, M, e);
+                return n(this, V, e);
               }
               each(e) {
-                return n(this, V, e);
+                return n(this, G, e);
               }
               forEach(e) {
-                return n(this, V, e);
+                return n(this, G, e);
               }
               eachSeries(e) {
-                return n(this, G, e);
+                return n(this, K, e);
               }
               forEachSeries(e) {
-                return n(this, G, e);
+                return n(this, K, e);
               }
               eachLimit(e, t) {
-                return n(this, K, e, t);
+                return n(this, Q, e, t);
               }
               forEachLimit(e, t) {
-                return n(this, K, e, t);
+                return n(this, Q, e, t);
               }
               map(e) {
-                return n(this, Q, e);
+                return n(this, J, e);
               }
               mapSeries(e) {
-                return n(this, J, e);
+                return n(this, Y, e);
               }
               mapLimit(e, t) {
-                return n(this, Y, e, t);
+                return n(this, Z, e, t);
               }
               mapValues(e) {
-                return n(this, Z, e);
+                return n(this, te, e);
               }
               mapValuesSeries(e) {
-                return n(this, te, e);
+                return n(this, le, e);
               }
               mapValuesLimit(e, t) {
-                return n(this, le, e, t);
+                return n(this, se, e, t);
               }
               filter(e) {
-                return n(this, se, e);
+                return n(this, _e, e);
               }
               filterSeries(e) {
-                return n(this, _e, e);
+                return n(this, ce, e);
               }
               filterLimit(e, t) {
-                return n(this, ce, e, t);
+                return n(this, ue, e, t);
               }
               reject(e) {
-                return n(this, ue, e);
+                return n(this, me, e);
               }
               rejectSeries(e) {
-                return n(this, me, e);
+                return n(this, ye, e);
               }
               rejectLimit(e, t) {
-                return n(this, de, e, t);
+                return n(this, ve, e, t);
               }
               find(e) {
-                return n(this, ve, e);
+                return n(this, ge, e);
               }
               findSeries(e) {
-                return n(this, ge, e);
+                return n(this, fe, e);
               }
               findLimit(e, t) {
-                return n(this, fe, e, t);
+                return n(this, Le, e, t);
               }
               findIndex(e) {
-                return n(this, Le, e);
+                return n(this, Ee, e);
               }
               findIndexSeries(e) {
-                return n(this, Ee, e);
+                return n(this, be, e);
               }
               findIndexLimit(e, t) {
-                return n(this, be, e, t);
+                return n(this, Ne, e, t);
               }
               findKey(e) {
-                return n(this, Ne, e);
+                return n(this, Pe, e);
               }
               findKeySeries(e) {
-                return n(this, Pe, e);
+                return n(this, Te, e);
               }
               findKeyLimit(e, t) {
-                return n(this, Te, e, t);
+                return n(this, Fe, e, t);
               }
               pick(e, ...t) {
-                return n(this, Fe, e, t);
+                return n(this, De, e, t);
               }
               pickSeries(e) {
                 return this.pickBySeries(e);
@@ -373,16 +376,16 @@
                 return this.pickByLimit(e, t);
               }
               pickBy(e) {
-                return n(this, De, e);
+                return n(this, Me, e);
               }
               pickBySeries(e) {
-                return n(this, Me, e);
+                return n(this, Ve, e);
               }
               pickByLimit(e, t) {
-                return n(this, Ve, e, t);
+                return n(this, Ge, e, t);
               }
               omit(e, ...t) {
-                return n(this, Ge, e, t);
+                return n(this, Ke, e, t);
               }
               omitSeries(e) {
                 return this.omitBySeries(e);
@@ -391,106 +394,106 @@
                 return this.omitByLimit(e, t);
               }
               omitBy(e) {
-                return n(this, Ke, e);
+                return n(this, Qe, e);
               }
               omitBySeries(e) {
-                return n(this, Qe, e);
+                return n(this, Je, e);
               }
               omitByLimit(e, t) {
-                return n(this, Je, e, t);
+                return n(this, Ye, e, t);
               }
               reduce(e, t) {
-                return n(this, Ye, e, t);
+                return n(this, Ze, e, t);
               }
               transform(e, t) {
-                return n(this, Ze, e, t);
+                return n(this, tt, e, t);
               }
               transformSeries(e, t) {
-                return n(this, tt, e, t);
+                return n(this, lt, e, t);
               }
               transformLimit(e, t, r) {
-                return n(this, lt, e, t, r);
+                return n(this, st, e, t, r);
               }
               sortBy(e) {
-                return n(this, st, e);
+                return n(this, _t, e);
               }
               sortBySeries(e) {
-                return n(this, _t, e);
+                return n(this, ct, e);
               }
               sortByLimit(e, t) {
-                return n(this, ct, e, t);
+                return n(this, ut, e, t);
               }
               some(e) {
-                return n(this, ut, e);
+                return n(this, mt, e);
               }
               someSeries(e) {
-                return n(this, mt, e);
+                return n(this, yt, e);
               }
               someLimit(e, t) {
-                return n(this, dt, e, t);
+                return n(this, vt, e, t);
               }
               every(e) {
-                return n(this, vt, e);
+                return n(this, gt, e);
               }
               everySeries(e) {
-                return n(this, gt, e);
+                return n(this, ft, e);
               }
               everyLimit(e, t) {
-                return n(this, ft, e, t);
+                return n(this, Lt, e, t);
               }
               concat(e) {
-                return n(this, Lt, e);
+                return n(this, Et, e);
               }
               concatSeries(e) {
-                return n(this, Et, e);
+                return n(this, bt, e);
               }
               concatLimit(e, t) {
-                return n(this, bt, e, t);
+                return n(this, Nt, e, t);
               }
               groupBy(e) {
-                return n(this, Nt, e);
+                return n(this, Pt, e);
               }
               groupBySeries(e) {
-                return n(this, Pt, e);
+                return n(this, Tt, e);
               }
               groupByLimit(e, t) {
-                return n(this, Tt, e, t);
+                return n(this, Ft, e, t);
               }
               delay(e) {
-                return a(this, new Mt(e));
+                return a(this, new Vt(e));
               }
               timeout(e, t) {
-                return c(this, new Wt(e, t));
+                return c(this, new Ct(e, t));
               }
               whilst(e, t) {
-                return this.then(r => Vt(r, e, t));
+                return this.then(r => Gt(r, e, t));
               }
               doWhilst(e, t) {
-                return this.then(r => Ct(r, e, t));
+                return this.then(r => Ut(r, e, t));
               }
               until(e, t) {
-                return this.then(r => Gt(r, e, t));
+                return this.then(r => Kt(r, e, t));
               }
               doUntil(e, t) {
-                return this.then(r => Ut(r, e, t));
+                return this.then(r => Ht(r, e, t));
               }
               thru(e) {
-                return this.then(t => Ht(t, e));
+                return this.then(t => qt(t, e));
               }
               tap(e) {
-                return this.then(t => Qt(t, e));
+                return this.then(t => Jt(t, e));
               }
               times(e) {
-                return n(this, $t, e);
+                return n(this, Xt, e);
               }
               timesSeries(e) {
-                return n(this, Xt, e);
+                return n(this, er, e);
               }
               timesLimit(e, t) {
-                return n(this, er, e, t);
+                return n(this, rr, e, t);
               }
               disposer(e) {
-                return new rr(this, e);
+                return new ir(this, e);
               }
               _resolve(e) {
                 0 === this._resolved &&
@@ -525,8 +528,8 @@
                     (this._resolved = 2),
                     (this._value = e),
                     void 0 === this._receiver
-                      ? ((this._receiver = x), void y(this))
-                      : void (E && ir(this), this._callReject())
+                      ? ((this._receiver = x), void d(this))
+                      : void (E && or(this), this._callReject())
                   );
               }
               _callReject() {
@@ -558,174 +561,176 @@
             }
             (j.prototype._execute = i), (t.exports = j), (t.exports.default = j);
             const { all: b, All: A } = e('./all'),
-              N = e('./attempt'),
-              { race: I, Race: P } = e('./race'),
-              { props: B, Props: T } = e('./props'),
-              { parallel: O, Parallel: F } = e('./parallel'),
-              { series: z, Series: D } = e('./series'),
-              { parallelLimit: w, ParallelLimit: M } = e('./parallelLimit'),
-              { each: W, Each: V } = e('./each'),
-              { eachSeries: C, EachSeries: G } = e('./eachSeries'),
-              { eachLimit: U, EachLimit: K } = e('./eachLimit'),
-              { map: H, Map: Q } = e('./map'),
-              { mapSeries: q, MapSeries: J } = e('./mapSeries'),
-              { mapLimit: $, MapLimit: Y } = e('./mapLimit'),
-              { mapValues: X, MapValues: Z } = e('./mapValues'),
-              { mapValuesSeries: ee, MapValuesSeries: te } = e('./mapValuesSeries'),
-              { mapValuesLimit: re, MapValuesLimit: le } = e('./mapValuesLimit'),
-              { filter: ie, Filter: se } = e('./filter'),
-              { filterSeries: oe, FilterSeries: _e } = e('./filterSeries'),
-              { filterLimit: ae, FilterLimit: ce } = e('./filterLimit'),
-              { reject: ne, Reject: ue } = e('./reject'),
-              { rejectSeries: pe, RejectSeries: me } = e('./rejectSeries'),
-              { rejectLimit: ye, RejectLimit: de } = e('./rejectLimit'),
-              { find: he, Find: ve } = e('./find'),
-              { findSeries: xe, FindSeries: ge } = e('./findSeries'),
-              { findLimit: Se, FindLimit: fe } = e('./findLimit'),
-              { findIndex: ke, FindIndex: Le } = e('./findIndex'),
-              { findIndexSeries: Re, FindIndexSeries: Ee } = e('./findIndexSeries'),
-              { findIndexLimit: je, FindIndexLimit: be } = e('./findIndexLimit'),
-              { findKey: Ae, FindKey: Ne } = e('./findKey'),
-              { findKeySeries: Ie, FindKeySeries: Pe } = e('./findKeySeries'),
-              { findKeyLimit: Be, FindKeyLimit: Te } = e('./findKeyLimit'),
-              { pick: Oe, Pick: Fe } = e('./pick'),
-              { pickBy: ze, PickBy: De } = e('./pickBy'),
-              { pickBySeries: we, PickBySeries: Me } = e('./pickBySeries'),
-              { pickByLimit: We, PickByLimit: Ve } = e('./pickByLimit'),
-              { omit: Ce, Omit: Ge } = e('./omit'),
-              { omitBy: Ue, OmitBy: Ke } = e('./omitBy'),
-              { omitBySeries: He, OmitBySeries: Qe } = e('./omitBySeries'),
-              { omitByLimit: qe, OmitByLimit: Je } = e('./omitByLimit'),
-              { reduce: $e, Reduce: Ye } = e('./reduce'),
-              { transform: Xe, Transform: Ze } = e('./transform'),
-              { transformSeries: et, TransformSeries: tt } = e('./transformSeries'),
-              { transformLimit: rt, TransformLimit: lt } = e('./transformLimit'),
-              { sortBy: it, SortBy: st } = e('./sortBy'),
-              { sortBySeries: ot, SortBySeries: _t } = e('./sortBySeries'),
-              { sortByLimit: at, SortByLimit: ct } = e('./sortByLimit'),
-              { some: nt, Some: ut } = e('./some'),
-              { someSeries: pt, SomeSeries: mt } = e('./someSeries'),
-              { someLimit: yt, SomeLimit: dt } = e('./someLimit'),
-              { every: ht, Every: vt } = e('./every'),
-              { everySeries: xt, EverySeries: gt } = e('./everySeries'),
-              { everyLimit: St, EveryLimit: ft } = e('./everyLimit'),
-              { concat: kt, Concat: Lt } = e('./concat'),
-              { concatSeries: Rt, ConcatSeries: Et } = e('./concatSeries'),
-              { concatLimit: jt, ConcatLimit: bt } = e('./concatLimit'),
-              { groupBy: At, GroupBy: Nt } = e('./groupBy'),
-              { groupBySeries: It, GroupBySeries: Pt } = e('./groupBySeries'),
-              { groupByLimit: Bt, GroupByLimit: Tt } = e('./groupByLimit'),
-              { join: Ot, Spread: Ft } = e('./join'),
-              zt = e('./promisify'),
-              Dt = e('./promisifyAll'),
-              { delay: wt, Delay: Mt } = e('./delay'),
-              Wt = e('./timeout'),
-              { whilst: Vt } = e('./whilst'),
-              { doWhilst: Ct } = e('./doWhilst'),
-              { until: Gt } = e('./until'),
-              Ut = e('./doUntil'),
-              Kt = e('./retry'),
-              Ht = e('./thru'),
-              Qt = e('./tap'),
-              qt = e('./flow'),
-              { times: Jt, Times: $t } = e('./times'),
-              { timesSeries: Yt, TimesSeries: Xt } = e('./timesSeries'),
-              { timesLimit: Zt, TimesLimit: er } = e('./timesLimit'),
-              { using: tr, Disposer: rr } = e('./using'),
-              { resolveStack: lr, reconstructStack: ir } = e('./debug'),
-              { createProxy: sr } = e('./internal/mixin');
-            (j.VERSION = d),
+              { allSettled: N, AllSettled: I } = e('./allSettled'),
+              P = e('./attempt'),
+              { race: B, Race: T } = e('./race'),
+              { props: O, Props: F } = e('./props'),
+              { parallel: z, Parallel: D } = e('./parallel'),
+              { series: w, Series: M } = e('./series'),
+              { parallelLimit: W, ParallelLimit: V } = e('./parallelLimit'),
+              { each: C, Each: G } = e('./each'),
+              { eachSeries: U, EachSeries: K } = e('./eachSeries'),
+              { eachLimit: H, EachLimit: Q } = e('./eachLimit'),
+              { map: q, Map: J } = e('./map'),
+              { mapSeries: $, MapSeries: Y } = e('./mapSeries'),
+              { mapLimit: X, MapLimit: Z } = e('./mapLimit'),
+              { mapValues: ee, MapValues: te } = e('./mapValues'),
+              { mapValuesSeries: re, MapValuesSeries: le } = e('./mapValuesSeries'),
+              { mapValuesLimit: ie, MapValuesLimit: se } = e('./mapValuesLimit'),
+              { filter: oe, Filter: _e } = e('./filter'),
+              { filterSeries: ae, FilterSeries: ce } = e('./filterSeries'),
+              { filterLimit: ne, FilterLimit: ue } = e('./filterLimit'),
+              { reject: pe, Reject: me } = e('./reject'),
+              { rejectSeries: de, RejectSeries: ye } = e('./rejectSeries'),
+              { rejectLimit: he, RejectLimit: ve } = e('./rejectLimit'),
+              { find: xe, Find: ge } = e('./find'),
+              { findSeries: Se, FindSeries: fe } = e('./findSeries'),
+              { findLimit: ke, FindLimit: Le } = e('./findLimit'),
+              { findIndex: Re, FindIndex: Ee } = e('./findIndex'),
+              { findIndexSeries: je, FindIndexSeries: be } = e('./findIndexSeries'),
+              { findIndexLimit: Ae, FindIndexLimit: Ne } = e('./findIndexLimit'),
+              { findKey: Ie, FindKey: Pe } = e('./findKey'),
+              { findKeySeries: Be, FindKeySeries: Te } = e('./findKeySeries'),
+              { findKeyLimit: Oe, FindKeyLimit: Fe } = e('./findKeyLimit'),
+              { pick: ze, Pick: De } = e('./pick'),
+              { pickBy: we, PickBy: Me } = e('./pickBy'),
+              { pickBySeries: We, PickBySeries: Ve } = e('./pickBySeries'),
+              { pickByLimit: Ce, PickByLimit: Ge } = e('./pickByLimit'),
+              { omit: Ue, Omit: Ke } = e('./omit'),
+              { omitBy: He, OmitBy: Qe } = e('./omitBy'),
+              { omitBySeries: qe, OmitBySeries: Je } = e('./omitBySeries'),
+              { omitByLimit: $e, OmitByLimit: Ye } = e('./omitByLimit'),
+              { reduce: Xe, Reduce: Ze } = e('./reduce'),
+              { transform: et, Transform: tt } = e('./transform'),
+              { transformSeries: rt, TransformSeries: lt } = e('./transformSeries'),
+              { transformLimit: it, TransformLimit: st } = e('./transformLimit'),
+              { sortBy: ot, SortBy: _t } = e('./sortBy'),
+              { sortBySeries: at, SortBySeries: ct } = e('./sortBySeries'),
+              { sortByLimit: nt, SortByLimit: ut } = e('./sortByLimit'),
+              { some: pt, Some: mt } = e('./some'),
+              { someSeries: dt, SomeSeries: yt } = e('./someSeries'),
+              { someLimit: ht, SomeLimit: vt } = e('./someLimit'),
+              { every: xt, Every: gt } = e('./every'),
+              { everySeries: St, EverySeries: ft } = e('./everySeries'),
+              { everyLimit: kt, EveryLimit: Lt } = e('./everyLimit'),
+              { concat: Rt, Concat: Et } = e('./concat'),
+              { concatSeries: jt, ConcatSeries: bt } = e('./concatSeries'),
+              { concatLimit: At, ConcatLimit: Nt } = e('./concatLimit'),
+              { groupBy: It, GroupBy: Pt } = e('./groupBy'),
+              { groupBySeries: Bt, GroupBySeries: Tt } = e('./groupBySeries'),
+              { groupByLimit: Ot, GroupByLimit: Ft } = e('./groupByLimit'),
+              { join: zt, Spread: Dt } = e('./join'),
+              wt = e('./promisify'),
+              Mt = e('./promisifyAll'),
+              { delay: Wt, Delay: Vt } = e('./delay'),
+              Ct = e('./timeout'),
+              { whilst: Gt } = e('./whilst'),
+              { doWhilst: Ut } = e('./doWhilst'),
+              { until: Kt } = e('./until'),
+              Ht = e('./doUntil'),
+              Qt = e('./retry'),
+              qt = e('./thru'),
+              Jt = e('./tap'),
+              $t = e('./flow'),
+              { times: Yt, Times: Xt } = e('./times'),
+              { timesSeries: Zt, TimesSeries: er } = e('./timesSeries'),
+              { timesLimit: tr, TimesLimit: rr } = e('./timesLimit'),
+              { using: lr, Disposer: ir } = e('./using'),
+              { resolveStack: sr, reconstructStack: or } = e('./debug'),
+              { createProxy: _r } = e('./internal/mixin');
+            (j.VERSION = y),
               (j.Aigle = j),
               (j.resolve = l),
               (j.reject = function(e, t) {
-                if (2 === arguments.length && 'function' == typeof t) return ne(e, t);
+                if (2 === arguments.length && 'function' == typeof t) return pe(e, t);
                 const r = new j(h);
                 return r._reject(e), r;
               }),
               (j.all = b),
-              (j.race = I),
-              (j.props = B),
-              (j.series = z),
-              (j.parallel = O),
-              (j.parallelLimit = w),
-              (j.each = W),
-              (j.eachSeries = C),
-              (j.eachLimit = U),
-              (j.forEach = W),
-              (j.forEachSeries = C),
-              (j.forEachLimit = U),
-              (j.map = H),
-              (j.mapSeries = q),
-              (j.mapLimit = $),
-              (j.mapValues = X),
-              (j.mapValuesSeries = ee),
-              (j.mapValuesLimit = re),
-              (j.filter = ie),
-              (j.filterSeries = oe),
-              (j.filterLimit = ae),
-              (j.rejectSeries = pe),
-              (j.rejectLimit = ye),
-              (j.find = he),
-              (j.findSeries = xe),
-              (j.findLimit = Se),
-              (j.findIndex = ke),
-              (j.findIndexSeries = Re),
-              (j.findIndexLimit = je),
-              (j.findKey = Ae),
-              (j.findKeySeries = Ie),
-              (j.findKeyLimit = Be),
-              (j.detect = he),
-              (j.detectSeries = xe),
-              (j.detectLimit = Se),
-              (j.pick = Oe),
-              (j.pickSeries = we),
-              (j.pickLimit = We),
-              (j.pickBy = ze),
-              (j.pickBySeries = we),
-              (j.pickByLimit = We),
-              (j.omit = Ce),
-              (j.omitSeries = He),
-              (j.omitLimit = qe),
-              (j.omitBy = Ue),
-              (j.omitBySeries = He),
-              (j.omitByLimit = qe),
-              (j.reduce = $e),
-              (j.transform = Xe),
-              (j.transformSeries = et),
-              (j.transformLimit = rt),
-              (j.sortBy = it),
-              (j.sortBySeries = ot),
-              (j.sortByLimit = at),
-              (j.some = nt),
-              (j.someSeries = pt),
-              (j.someLimit = yt),
-              (j.every = ht),
-              (j.everySeries = xt),
-              (j.everyLimit = St),
-              (j.concat = kt),
-              (j.concatSeries = Rt),
-              (j.concatLimit = jt),
-              (j.groupBy = At),
-              (j.groupBySeries = It),
-              (j.groupByLimit = Bt),
-              (j.attempt = N),
-              (j.try = N),
-              (j.join = Ot),
-              (j.promisify = zt),
-              (j.promisifyAll = Dt),
-              (j.delay = wt),
-              (j.whilst = Vt),
-              (j.doWhilst = Ct),
-              (j.until = Gt),
-              (j.doUntil = Ut),
-              (j.retry = Kt),
-              (j.thru = Ht),
-              (j.tap = Qt),
-              (j.flow = qt),
-              (j.times = Jt),
-              (j.timesSeries = Yt),
-              (j.timesLimit = Zt),
-              (j.using = tr),
+              (j.allSettled = N),
+              (j.race = B),
+              (j.props = O),
+              (j.series = w),
+              (j.parallel = z),
+              (j.parallelLimit = W),
+              (j.each = C),
+              (j.eachSeries = U),
+              (j.eachLimit = H),
+              (j.forEach = C),
+              (j.forEachSeries = U),
+              (j.forEachLimit = H),
+              (j.map = q),
+              (j.mapSeries = $),
+              (j.mapLimit = X),
+              (j.mapValues = ee),
+              (j.mapValuesSeries = re),
+              (j.mapValuesLimit = ie),
+              (j.filter = oe),
+              (j.filterSeries = ae),
+              (j.filterLimit = ne),
+              (j.rejectSeries = de),
+              (j.rejectLimit = he),
+              (j.find = xe),
+              (j.findSeries = Se),
+              (j.findLimit = ke),
+              (j.findIndex = Re),
+              (j.findIndexSeries = je),
+              (j.findIndexLimit = Ae),
+              (j.findKey = Ie),
+              (j.findKeySeries = Be),
+              (j.findKeyLimit = Oe),
+              (j.detect = xe),
+              (j.detectSeries = Se),
+              (j.detectLimit = ke),
+              (j.pick = ze),
+              (j.pickSeries = We),
+              (j.pickLimit = Ce),
+              (j.pickBy = we),
+              (j.pickBySeries = We),
+              (j.pickByLimit = Ce),
+              (j.omit = Ue),
+              (j.omitSeries = qe),
+              (j.omitLimit = $e),
+              (j.omitBy = He),
+              (j.omitBySeries = qe),
+              (j.omitByLimit = $e),
+              (j.reduce = Xe),
+              (j.transform = et),
+              (j.transformSeries = rt),
+              (j.transformLimit = it),
+              (j.sortBy = ot),
+              (j.sortBySeries = at),
+              (j.sortByLimit = nt),
+              (j.some = pt),
+              (j.someSeries = dt),
+              (j.someLimit = ht),
+              (j.every = xt),
+              (j.everySeries = St),
+              (j.everyLimit = kt),
+              (j.concat = Rt),
+              (j.concatSeries = jt),
+              (j.concatLimit = At),
+              (j.groupBy = It),
+              (j.groupBySeries = Bt),
+              (j.groupByLimit = Ot),
+              (j.attempt = P),
+              (j.try = P),
+              (j.join = zt),
+              (j.promisify = wt),
+              (j.promisifyAll = Mt),
+              (j.delay = Wt),
+              (j.whilst = Gt),
+              (j.doWhilst = Ut),
+              (j.until = Kt),
+              (j.doUntil = Ht),
+              (j.retry = Qt),
+              (j.thru = qt),
+              (j.tap = Jt),
+              (j.flow = $t),
+              (j.times = Yt),
+              (j.timesSeries = Zt),
+              (j.timesLimit = tr),
+              (j.using = lr),
               (j.mixin = function(e, t = {}) {
                 const { override: r, promisify: i = !0 } = t;
                 return (
@@ -742,7 +747,7 @@
                           })
                         );
                     }
-                    const o = sr(s, i);
+                    const o = _r(s, i);
                     (j[t] = function(e, t, r, l) {
                       return new o(e, t, r, l)._execute();
                     }),
@@ -761,94 +766,95 @@
               (j.longStackTraces = function() {
                 E = !0;
               });
-            const { CancellationError: or, TimeoutError: _r } = e('./error');
-            (j.CancellationError = or), (j.TimeoutError = _r);
+            const { CancellationError: ar, TimeoutError: cr } = e('./error');
+            (j.CancellationError = ar), (j.TimeoutError = cr);
           }.call(this, e('_process')));
         },
         {
           './all': 3,
-          './attempt': 4,
-          './concat': 5,
-          './concatLimit': 6,
-          './concatSeries': 7,
-          './debug': 8,
-          './delay': 9,
-          './doUntil': 10,
-          './doWhilst': 11,
-          './each': 12,
-          './eachLimit': 13,
-          './eachSeries': 14,
-          './error': 15,
-          './every': 16,
-          './everyLimit': 17,
-          './everySeries': 18,
-          './filter': 19,
-          './filterLimit': 20,
-          './filterSeries': 21,
-          './find': 22,
-          './findIndex': 23,
-          './findIndexLimit': 24,
-          './findIndexSeries': 25,
-          './findKey': 26,
-          './findKeyLimit': 27,
-          './findKeySeries': 28,
-          './findLimit': 29,
-          './findSeries': 30,
-          './flow': 31,
-          './groupBy': 32,
-          './groupByLimit': 33,
-          './groupBySeries': 34,
-          './internal/async': 35,
-          './internal/mixin': 37,
-          './internal/queue': 38,
-          './internal/util': 39,
-          './join': 40,
-          './map': 41,
-          './mapLimit': 42,
-          './mapSeries': 43,
-          './mapValues': 44,
-          './mapValuesLimit': 45,
-          './mapValuesSeries': 46,
-          './omit': 47,
-          './omitBy': 48,
-          './omitByLimit': 49,
-          './omitBySeries': 50,
-          './parallel': 51,
-          './parallelLimit': 52,
-          './pick': 53,
-          './pickBy': 54,
-          './pickByLimit': 55,
-          './pickBySeries': 56,
-          './promisify': 57,
-          './promisifyAll': 58,
-          './props': 59,
-          './race': 60,
-          './reduce': 61,
-          './reject': 62,
-          './rejectLimit': 63,
-          './rejectSeries': 64,
-          './retry': 65,
-          './series': 66,
-          './some': 67,
-          './someLimit': 68,
-          './someSeries': 69,
-          './sortBy': 70,
-          './sortByLimit': 71,
-          './sortBySeries': 72,
-          './tap': 73,
-          './thru': 74,
-          './timeout': 75,
-          './times': 76,
-          './timesLimit': 77,
-          './timesSeries': 78,
-          './transform': 79,
-          './transformLimit': 80,
-          './transformSeries': 81,
-          './until': 82,
-          './using': 83,
-          './whilst': 84,
-          _process: 86,
-          'aigle-core': 85
+          './allSettled': 4,
+          './attempt': 5,
+          './concat': 6,
+          './concatLimit': 7,
+          './concatSeries': 8,
+          './debug': 9,
+          './delay': 10,
+          './doUntil': 11,
+          './doWhilst': 12,
+          './each': 13,
+          './eachLimit': 14,
+          './eachSeries': 15,
+          './error': 16,
+          './every': 17,
+          './everyLimit': 18,
+          './everySeries': 19,
+          './filter': 20,
+          './filterLimit': 21,
+          './filterSeries': 22,
+          './find': 23,
+          './findIndex': 24,
+          './findIndexLimit': 25,
+          './findIndexSeries': 26,
+          './findKey': 27,
+          './findKeyLimit': 28,
+          './findKeySeries': 29,
+          './findLimit': 30,
+          './findSeries': 31,
+          './flow': 32,
+          './groupBy': 33,
+          './groupByLimit': 34,
+          './groupBySeries': 35,
+          './internal/async': 36,
+          './internal/mixin': 38,
+          './internal/queue': 39,
+          './internal/util': 40,
+          './join': 41,
+          './map': 42,
+          './mapLimit': 43,
+          './mapSeries': 44,
+          './mapValues': 45,
+          './mapValuesLimit': 46,
+          './mapValuesSeries': 47,
+          './omit': 48,
+          './omitBy': 49,
+          './omitByLimit': 50,
+          './omitBySeries': 51,
+          './parallel': 52,
+          './parallelLimit': 53,
+          './pick': 54,
+          './pickBy': 55,
+          './pickByLimit': 56,
+          './pickBySeries': 57,
+          './promisify': 58,
+          './promisifyAll': 59,
+          './props': 60,
+          './race': 61,
+          './reduce': 62,
+          './reject': 63,
+          './rejectLimit': 64,
+          './rejectSeries': 65,
+          './retry': 66,
+          './series': 67,
+          './some': 68,
+          './someLimit': 69,
+          './someSeries': 70,
+          './sortBy': 71,
+          './sortByLimit': 72,
+          './sortBySeries': 73,
+          './tap': 74,
+          './thru': 75,
+          './timeout': 76,
+          './times': 77,
+          './timesLimit': 78,
+          './timesSeries': 79,
+          './transform': 80,
+          './transformLimit': 81,
+          './transformSeries': 82,
+          './until': 83,
+          './using': 84,
+          './whilst': 85,
+          _process: 87,
+          'aigle-core': 86
         }
       ],
       3: [
@@ -901,9 +907,43 @@
             All: n
           };
         },
-        { './aigle': 2, './internal/util': 39, './props': 59, 'aigle-core': 85 }
+        { './aigle': 2, './internal/util': 40, './props': 60, 'aigle-core': 86 }
       ],
       4: [
+        function(e, t) {
+          'use strict';
+          function r(e) {
+            function t(e, t) {
+              return r.has(t) ? { state: 'rejected', reason: e } : { state: 'fulfilled', value: e };
+            }
+            const { _errorSet: r, _promise: l } = e,
+              { _resolve: i } = l;
+            return e => {
+              if (Array.isArray(e)) e = e.map(t);
+              else if (e instanceof Map) for (const [r, l] of e) e.set(r, t(l, r));
+              else for (const [r, l] of Object.entries(e)) e[r] = t(l, r);
+              i.call(l, e);
+            };
+          }
+          const { Parallel: l } = e('./parallel');
+          class i extends l {
+            _set(e) {
+              (this._errorSet = new Set()), (this._promise._resolve = r(this)), super._set(e);
+            }
+            _callReject(e, t) {
+              return this._errorSet.add(t), this._callResolve(e, t), !0;
+            }
+          }
+          t.exports = {
+            allSettled: function(e) {
+              return new i(e)._promise;
+            },
+            AllSettled: i
+          };
+        },
+        { './parallel': 52 }
+      ],
+      5: [
         function(e, t) {
           'use strict';
           const r = e('./aigle'),
@@ -913,9 +953,9 @@
             return i(t, e), t;
           };
         },
-        { './aigle': 2, './internal/util': 39 }
+        { './aigle': 2, './internal/util': 40 }
       ],
-      5: [
+      6: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -939,9 +979,9 @@
             Concat: o
           };
         },
-        { './each': 12, './internal/collection': 36, './internal/util': 39 }
+        { './each': 13, './internal/collection': 37, './internal/util': 40 }
       ],
-      6: [
+      7: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -968,9 +1008,9 @@
             ConcatLimit: o
           };
         },
-        { './eachLimit': 13, './internal/collection': 36, './internal/util': 39 }
+        { './eachLimit': 14, './internal/collection': 37, './internal/util': 40 }
       ],
-      7: [
+      8: [
         function(e, t) {
           'use strict';
           const { EachSeries: r } = e('./eachSeries');
@@ -990,9 +1030,9 @@
             ConcatSeries: l
           };
         },
-        { './eachSeries': 14 }
+        { './eachSeries': 15 }
       ],
-      8: [
+      9: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -1020,7 +1060,7 @@
         },
         {}
       ],
-      9: [
+      10: [
         function(e, t) {
           'use strict';
           const r = e('./aigle'),
@@ -1045,9 +1085,9 @@
             Delay: i
           };
         },
-        { './aigle': 2, './internal/util': 39 }
+        { './aigle': 2, './internal/util': 40 }
       ],
-      10: [
+      11: [
         function(e, t) {
           'use strict';
           const { DoWhilst: r } = e('./doWhilst'),
@@ -1059,9 +1099,9 @@
             );
           };
         },
-        { './doWhilst': 11, './until': 82 }
+        { './doWhilst': 12, './until': 83 }
       ],
-      11: [
+      12: [
         function(e, t) {
           'use strict';
           const { AigleWhilst: r, WhilstTester: l } = e('./whilst');
@@ -1083,9 +1123,9 @@
             DoWhilst: i
           };
         },
-        { './whilst': 84 }
+        { './whilst': 85 }
       ],
-      12: [
+      13: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -1130,9 +1170,9 @@
             Each: c
           };
         },
-        { './aigle': 2, './internal/collection': 36, './internal/util': 39, 'aigle-core': 85 }
+        { './aigle': 2, './internal/collection': 37, './internal/util': 40, 'aigle-core': 86 }
       ],
-      13: [
+      14: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -1184,9 +1224,9 @@
             EachLimit: n
           };
         },
-        { './aigle': 2, './internal/collection': 36, './internal/util': 39, 'aigle-core': 85 }
+        { './aigle': 2, './internal/collection': 37, './internal/util': 40, 'aigle-core': 86 }
       ],
-      14: [
+      15: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -1234,9 +1274,9 @@
             EachSeries: c
           };
         },
-        { './aigle': 2, './internal/collection': 36, './internal/util': 39, 'aigle-core': 85 }
+        { './aigle': 2, './internal/collection': 37, './internal/util': 40, 'aigle-core': 86 }
       ],
-      15: [
+      16: [
         function(e, t, r) {
           'use strict';
           const i = ['CancellationError', 'TimeoutError'];
@@ -1248,7 +1288,7 @@
         },
         {}
       ],
-      16: [
+      17: [
         function(e, t) {
           'use strict';
           const { Each: r } = e('./each'),
@@ -1269,9 +1309,9 @@
             Every: s
           };
         },
-        { './each': 12, './internal/collection': 36, './internal/util': 39 }
+        { './each': 13, './internal/collection': 37, './internal/util': 40 }
       ],
-      17: [
+      18: [
         function(e, t) {
           'use strict';
           const { EachLimit: r } = e('./eachLimit');
@@ -1294,9 +1334,9 @@
             EveryLimit: l
           };
         },
-        { './eachLimit': 13 }
+        { './eachLimit': 14 }
       ],
-      18: [
+      19: [
         function(e, t) {
           'use strict';
           const { EachSeries: r } = e('./eachSeries.js');
@@ -1319,9 +1359,9 @@
             EverySeries: l
           };
         },
-        { './eachSeries.js': 14 }
+        { './eachSeries.js': 15 }
       ],
-      19: [
+      20: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -1356,9 +1396,9 @@
               Filter: c
             });
         },
-        { './each': 12, './internal/collection': 36, './internal/util': 39 }
+        { './each': 13, './internal/collection': 37, './internal/util': 40 }
       ],
-      20: [
+      21: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -1396,9 +1436,9 @@
             FilterLimit: c
           };
         },
-        { './eachLimit': 13, './internal/collection': 36, './internal/util': 39 }
+        { './eachLimit': 14, './internal/collection': 37, './internal/util': 40 }
       ],
-      21: [
+      22: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -1432,9 +1472,9 @@
             FilterSeries: c
           };
         },
-        { './eachSeries': 14, './internal/collection': 36, './internal/util': 39 }
+        { './eachSeries': 15, './internal/collection': 37, './internal/util': 40 }
       ],
-      22: [
+      23: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -1464,9 +1504,9 @@
             Find: _
           };
         },
-        { './each': 12, './internal/collection': 36 }
+        { './each': 13, './internal/collection': 37 }
       ],
-      23: [
+      24: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -1491,9 +1531,9 @@
             FindIndex: s
           };
         },
-        { './each': 12, './internal/collection': 36 }
+        { './each': 13, './internal/collection': 37 }
       ],
-      24: [
+      25: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -1520,9 +1560,9 @@
             FindIndexLimit: s
           };
         },
-        { './eachLimit': 13, './internal/collection': 36 }
+        { './eachLimit': 14, './internal/collection': 37 }
       ],
-      25: [
+      26: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -1549,9 +1589,9 @@
             FindIndexSeries: s
           };
         },
-        { './eachSeries': 14, './internal/collection': 36 }
+        { './eachSeries': 15, './internal/collection': 37 }
       ],
-      26: [
+      27: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -1581,9 +1621,9 @@
             FindKey: _
           };
         },
-        { './each': 12, './internal/collection': 36 }
+        { './each': 13, './internal/collection': 37 }
       ],
-      27: [
+      28: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -1617,9 +1657,9 @@
             FindKeyLimit: _
           };
         },
-        { './eachLimit': 13, './internal/collection': 36 }
+        { './eachLimit': 14, './internal/collection': 37 }
       ],
-      28: [
+      29: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -1653,9 +1693,9 @@
             FindKeySeries: _
           };
         },
-        { './eachSeries': 14, './internal/collection': 36 }
+        { './eachSeries': 15, './internal/collection': 37 }
       ],
-      29: [
+      30: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -1689,9 +1729,9 @@
             FindLimit: _
           };
         },
-        { './eachLimit': 13, './internal/collection': 36 }
+        { './eachLimit': 14, './internal/collection': 37 }
       ],
-      30: [
+      31: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -1725,9 +1765,9 @@
             FindSeries: _
           };
         },
-        { './eachSeries': 14, './internal/collection': 36 }
+        { './eachSeries': 15, './internal/collection': 37 }
       ],
-      31: [
+      32: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -1750,7 +1790,7 @@
         },
         { './aigle': 2 }
       ],
-      32: [
+      33: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -1782,9 +1822,9 @@
             GroupBy: _
           };
         },
-        { './each': 12, './internal/collection': 36 }
+        { './each': 13, './internal/collection': 37 }
       ],
-      33: [
+      34: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -1820,9 +1860,9 @@
             GroupByLimit: _
           };
         },
-        { './eachLimit': 13, './internal/collection': 36 }
+        { './eachLimit': 14, './internal/collection': 37 }
       ],
-      34: [
+      35: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -1854,9 +1894,9 @@
             GroupBySeries: _
           };
         },
-        { './eachSeries': 14, './internal/collection': 36 }
+        { './eachSeries': 15, './internal/collection': 37 }
       ],
-      35: [
+      36: [
         function(e, t) {
           'use strict';
           function r() {
@@ -1881,7 +1921,7 @@
         },
         {}
       ],
-      36: [
+      37: [
         function(e, t) {
           'use strict';
           function r([e, t, r, l]) {
@@ -2013,7 +2053,7 @@
                 }
               }
             ],
-            y = [
+            d = [
               i,
               function() {
                 const { _iterator: e, _coll: t, _keys: r } = this;
@@ -2051,11 +2091,11 @@
                 }
               }
             ],
-            [d, h, v, x] = [
-              [m, y],
-              [m, [s, ...y.slice(1)]],
-              [[...m.slice(0, 3), o], [...y.slice(0, 3), o]],
-              [[...m.slice(0, 3), _], [...y.slice(0, 3), _]]
+            [y, h, v, x] = [
+              [m, d],
+              [m, [s, ...d.slice(1)]],
+              [[...m.slice(0, 3), o], [...d.slice(0, 3), o]],
+              [[...m.slice(0, 3), _], [...d.slice(0, 3), _]]
             ].map(function(e) {
               const [t, l] = e.map(r);
               return function(e) {
@@ -2077,7 +2117,7 @@
             },
             setParallel: n,
             setParallelWithOrder: u,
-            setShorthand: d,
+            setShorthand: y,
             setShorthandWithOrder: h,
             setPickShorthand: v,
             setOmitShorthand: x,
@@ -2089,9 +2129,9 @@
             }
           };
         },
-        { './util': 39 }
+        { './util': 40 }
       ],
-      37: [
+      38: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -2160,9 +2200,9 @@
             }
           }
         },
-        { '../aigle': 2, '../map': 41, '../mapValues': 44, './util': 39, 'aigle-core': 85 }
+        { '../aigle': 2, '../map': 42, '../mapValues': 45, './util': 40, 'aigle-core': 86 }
       ],
-      38: [
+      39: [
         function(e, t) {
           'use strict';
           t.exports = class {
@@ -2176,7 +2216,7 @@
         },
         {}
       ],
-      39: [
+      40: [
         function(e, t) {
           (function(r) {
             'use strict';
@@ -2191,7 +2231,7 @@
             function s(e, t) {
               if (t === v) return void e._reject(v.e);
               if (!t || !t.then) return void e._resolve(t);
-              if (t instanceof d)
+              if (t instanceof y)
                 switch (t._resolved) {
                   case 0:
                     return void t._addReceiver(e, l);
@@ -2218,22 +2258,22 @@
                   t._callResolve(e, r);
                 },
                 function(e) {
-                  t._callReject(e);
+                  t._callReject(e, r);
                 }
               );
             }
             function a(e, t, r) {
-              if (e instanceof d)
+              if (e instanceof y)
                 switch (e._resolved) {
                   case 0:
                     return e._addReceiver(t, r), !0;
                   case 1:
                     return t._callResolve(e._value, r), !0;
                   case 2:
-                    return e.suppressUnhandledRejections(), t._callReject(e._value), !1;
+                    return e.suppressUnhandledRejections(), !0 === t._callReject(e._value, r);
                 }
               return e === v
-                ? (t._callReject(v.e), !1)
+                ? !0 === t._callReject(v.e, r)
                 : (e && e.then ? _(e, t, r) : t._callResolve(e, r), !0);
             }
             function c(e, t, r) {
@@ -2272,7 +2312,7 @@
               const o = t[s];
               (t[s] = t[l]), (t[l] = o);
             }
-            function y(e, t, r, s) {
+            function d(e, t, r, s) {
               if (t === r) return;
               let o = t;
               for (; ++o <= r && e[t] === e[o]; ) {
@@ -2284,10 +2324,10 @@
               }
               if (!(o > r)) {
                 const l = e[t] > e[o] ? t : o;
-                (o = m(e, t, r, e[l], s)), y(e, t, o - 1, s), y(e, o, r, s);
+                (o = m(e, t, r, e[l], s)), d(e, t, o - 1, s), d(e, o, r, s);
               }
             }
-            const { AigleCore: d } = e('aigle-core'),
+            const { AigleCore: y } = e('aigle-core'),
               { version: h } = e('../../package.json'),
               v = { e: void 0 },
               x = 'function' == typeof Symbol ? Symbol.iterator : function() {},
@@ -2442,7 +2482,7 @@
                 const r = e.length,
                   l = Array(r);
                 for (let s = 0; s < r; s++) l[s] = s;
-                y(t, 0, r - 1, l);
+                d(t, 0, r - 1, l);
                 const s = Array(r);
                 for (let o = 0; o < r; o++) {
                   const t = l[o];
@@ -2454,7 +2494,7 @@
                 const s = t.length,
                   l = Array(s);
                 for (let o = 0; o < s; o++) l[o] = o;
-                y(r, 0, s - 1, l);
+                d(r, 0, s - 1, l);
                 const o = Array(s);
                 for (let _ = 0; _ < s; _++) {
                   const r = l[_];
@@ -2470,9 +2510,9 @@
             };
           }.call(this, e('_process')));
         },
-        { '../../package.json': 91, _process: 86, 'aigle-core': 85 }
+        { '../../package.json': 92, _process: 87, 'aigle-core': 86 }
       ],
-      40: [
+      41: [
         function(e, t) {
           'use strict';
           function r(e, t) {
@@ -2540,9 +2580,9 @@
             }
           };
         },
-        { './aigle': 2, './internal/util': 39, 'aigle-core': 85 }
+        { './aigle': 2, './internal/util': 40, 'aigle-core': 86 }
       ],
-      41: [
+      42: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -2565,9 +2605,9 @@
             Map: s
           };
         },
-        { './each': 12, './internal/collection': 36 }
+        { './each': 13, './internal/collection': 37 }
       ],
-      42: [
+      43: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -2593,9 +2633,9 @@
             MapLimit: s
           };
         },
-        { './eachLimit': 13, './internal/collection': 36 }
+        { './eachLimit': 14, './internal/collection': 37 }
       ],
-      43: [
+      44: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -2619,9 +2659,9 @@
             MapSeries: s
           };
         },
-        { './eachSeries': 14, './internal/collection': 36 }
+        { './eachSeries': 15, './internal/collection': 37 }
       ],
-      44: [
+      45: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -2648,9 +2688,9 @@
             MapValues: _
           };
         },
-        { './each': 12, './internal/collection': 36 }
+        { './each': 13, './internal/collection': 37 }
       ],
-      45: [
+      46: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -2689,9 +2729,9 @@
             MapValuesLimit: a
           };
         },
-        { './eachLimit': 13, './internal/collection': 36, './internal/util': 39 }
+        { './eachLimit': 14, './internal/collection': 37, './internal/util': 40 }
       ],
-      46: [
+      47: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -2719,9 +2759,9 @@
             MapValuesSeries: _
           };
         },
-        { './eachSeries': 14, './internal/collection': 36 }
+        { './eachSeries': 15, './internal/collection': 37 }
       ],
-      47: [
+      48: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -2752,9 +2792,9 @@
             Omit: _
           };
         },
-        { './each': 12, './internal/collection': 36 }
+        { './each': 13, './internal/collection': 37 }
       ],
-      48: [
+      49: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -2785,9 +2825,9 @@
             OmitBy: _
           };
         },
-        { './each': 12, './internal/collection': 36 }
+        { './each': 13, './internal/collection': 37 }
       ],
-      49: [
+      50: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -2822,9 +2862,9 @@
             OmitByLimit: _
           };
         },
-        { './eachLimit': 13, './internal/collection': 36 }
+        { './eachLimit': 14, './internal/collection': 37 }
       ],
-      50: [
+      51: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -2858,9 +2898,9 @@
             OmitBySeries: a
           };
         },
-        { './eachSeries': 14, './internal/collection': 36, './internal/util': 39 }
+        { './eachSeries': 15, './internal/collection': 37, './internal/util': 40 }
       ],
-      51: [
+      52: [
         function(e, t) {
           'use strict';
           const { AigleProxy: r } = e('aigle-core'),
@@ -2889,7 +2929,7 @@
               if (Array.isArray(e)) {
                 const t = e.length;
                 (this._rest = t), (this._result = Array(t)), (this._callResolve = u), o(this, t, e);
-              } else if (!e || 'object' != typeof e) (this._rest = 0), (this._result = void 0);
+              } else if (!e || 'object' != typeof e) (this._rest = 0), (this._result = {});
               else if (e[n]) {
                 const t = e.size;
                 if (((this._rest = t), e instanceof Map)) {
@@ -2919,9 +2959,9 @@
             Parallel: m
           };
         },
-        { './aigle': 2, './internal/util': 39, './props': 59, 'aigle-core': 85 }
+        { './aigle': 2, './internal/util': 40, './props': 60, 'aigle-core': 86 }
       ],
-      52: [
+      53: [
         function(e, t) {
           'use strict';
           function r() {
@@ -2960,9 +3000,9 @@
             ParallelLimit: s
           };
         },
-        { './internal/util': 39, './series': 66 }
+        { './internal/util': 40, './series': 67 }
       ],
-      53: [
+      54: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -2993,9 +3033,9 @@
             Pick: _
           };
         },
-        { './each': 12, './internal/collection': 36 }
+        { './each': 13, './internal/collection': 37 }
       ],
-      54: [
+      55: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -3026,9 +3066,9 @@
             PickBy: _
           };
         },
-        { './each': 12, './internal/collection': 36 }
+        { './each': 13, './internal/collection': 37 }
       ],
-      55: [
+      56: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -3063,9 +3103,9 @@
             PickByLimit: _
           };
         },
-        { './eachLimit': 13, './internal/collection': 36 }
+        { './eachLimit': 14, './internal/collection': 37 }
       ],
-      56: [
+      57: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -3096,9 +3136,9 @@
             PickBySeries: _
           };
         },
-        { './eachSeries': 14, './internal/collection': 36 }
+        { './eachSeries': 15, './internal/collection': 37 }
       ],
-      57: [
+      58: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -3200,9 +3240,9 @@
             }
           };
         },
-        { './aigle': 2, './internal/util': 39, util: 90 }
+        { './aigle': 2, './internal/util': 40, util: 91 }
       ],
-      58: [
+      59: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -3259,9 +3299,9 @@
             a = Object.prototype,
             c = Array.prototype;
         },
-        { './promisify': 57 }
+        { './promisify': 58 }
       ],
-      59: [
+      60: [
         function(e, t) {
           'use strict';
           function r(e, t) {
@@ -3317,9 +3357,9 @@
             callResolveMap: l
           };
         },
-        { './aigle': 2, './internal/util': 39, 'aigle-core': 85 }
+        { './aigle': 2, './internal/util': 40, 'aigle-core': 86 }
       ],
-      60: [
+      61: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -3370,9 +3410,9 @@
             Race: p
           };
         },
-        { './aigle': 2, './internal/util': 39, 'aigle-core': 85 }
+        { './aigle': 2, './internal/util': 40, 'aigle-core': 86 }
       ],
-      61: [
+      62: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -3385,11 +3425,11 @@
             );
           }
           function l(e, t) {
-            y(m(this._iterator, t, this._coll[e], e), this, e);
+            d(m(this._iterator, t, this._coll[e], e), this, e);
           }
           function i(e, t) {
             const r = this._keys[e];
-            y(m(this._iterator, t, this._coll[r], r), this, e);
+            d(m(this._iterator, t, this._coll[r], r), this, e);
           }
           function s() {
             return (
@@ -3414,8 +3454,8 @@
           const { AigleProxy: _ } = e('aigle-core'),
             a = e('./aigle'),
             { execute: c, setSeries: n } = e('./internal/collection'),
-            { INTERNAL: u, PENDING: p, call3: m, callProxyReciever: y } = e('./internal/util');
-          class d extends _ {
+            { INTERNAL: u, PENDING: p, call3: m, callProxyReciever: d } = e('./internal/util');
+          class y extends _ {
             constructor(e, t, l) {
               super(),
                 (this._result = l),
@@ -3439,14 +3479,14 @@
           }
           t.exports = {
             reduce: function(e, t, r) {
-              return new d(e, t, r)._execute();
+              return new y(e, t, r)._execute();
             },
-            Reduce: d
+            Reduce: y
           };
         },
-        { './aigle': 2, './internal/collection': 36, './internal/util': 39, 'aigle-core': 85 }
+        { './aigle': 2, './internal/collection': 37, './internal/util': 40, 'aigle-core': 86 }
       ],
-      62: [
+      63: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -3480,9 +3520,9 @@
             Reject: c
           };
         },
-        { './each': 12, './internal/collection': 36, './internal/util': 39 }
+        { './each': 13, './internal/collection': 37, './internal/util': 40 }
       ],
-      63: [
+      64: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -3520,9 +3560,9 @@
             RejectLimit: c
           };
         },
-        { './eachLimit': 13, './internal/collection': 36, './internal/util': 39 }
+        { './eachLimit': 14, './internal/collection': 37, './internal/util': 40 }
       ],
-      64: [
+      65: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -3556,9 +3596,9 @@
             RejectSeries: c
           };
         },
-        { './eachSeries': 14, './internal/collection': 36, './internal/util': 39 }
+        { './eachSeries': 15, './internal/collection': 37, './internal/util': 40 }
       ],
-      65: [
+      66: [
         function(e, t) {
           'use strict';
           const { AigleProxy: r } = e('aigle-core'),
@@ -3608,17 +3648,16 @@
             return new a(e, t)._promise;
           };
         },
-        { './aigle': 2, './internal/util': 39, 'aigle-core': 85 }
+        { './aigle': 2, './internal/util': 40, 'aigle-core': 86 }
       ],
-      66: [
+      67: [
         function(e, t) {
           'use strict';
           function r(e) {
             if (((this._coll = e), (this._iterate = l), Array.isArray(e))) {
               const t = e.length;
               (this._rest = t), (this._result = Array(t)), (this._iterator = a);
-            } else if ('object' != typeof e || null === e)
-              (this._rest = 0), (this._result = void 0);
+            } else if ('object' != typeof e || null === e) (this._rest = 0), (this._result = {});
             else if (e[p]) {
               this._coll = e[p]();
               const t = e.size;
@@ -3651,7 +3690,7 @@
               iteratorSymbol: p
             } = e('./internal/util'),
             { execute: m } = e('./internal/collection');
-          class y extends i {
+          class d extends i {
             constructor(e) {
               super(),
                 (this._promise = new s(o)),
@@ -3680,14 +3719,14 @@
           }
           t.exports = {
             series: function(e) {
-              return new y(e)._execute();
+              return new d(e)._execute();
             },
-            Series: y
+            Series: d
           };
         },
-        { './aigle': 2, './internal/collection': 36, './internal/util': 39, 'aigle-core': 85 }
+        { './aigle': 2, './internal/collection': 37, './internal/util': 40, 'aigle-core': 86 }
       ],
-      67: [
+      68: [
         function(e, t) {
           'use strict';
           const { Each: r } = e('./each'),
@@ -3707,9 +3746,9 @@
             Some: i
           };
         },
-        { './each': 12, './internal/collection': 36 }
+        { './each': 13, './internal/collection': 37 }
       ],
-      68: [
+      69: [
         function(e, t) {
           'use strict';
           const { EachLimit: r } = e('./eachLimit');
@@ -3732,9 +3771,9 @@
             SomeLimit: l
           };
         },
-        { './eachLimit': 13 }
+        { './eachLimit': 14 }
       ],
-      69: [
+      70: [
         function(e, t) {
           'use strict';
           const { EachSeries: r } = e('./eachSeries.js');
@@ -3757,9 +3796,9 @@
             SomeSeries: l
           };
         },
-        { './eachSeries.js': 14 }
+        { './eachSeries.js': 15 }
       ],
-      70: [
+      71: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -3793,9 +3832,9 @@
             SortBy: c
           };
         },
-        { './each': 12, './internal/collection': 36, './internal/util': 39 }
+        { './each': 13, './internal/collection': 37, './internal/util': 40 }
       ],
-      71: [
+      72: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -3833,9 +3872,9 @@
             SortByLimit: c
           };
         },
-        { './eachLimit': 13, './internal/collection': 36, './internal/util': 39 }
+        { './eachLimit': 14, './internal/collection': 37, './internal/util': 40 }
       ],
-      72: [
+      73: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -3873,9 +3912,9 @@
             SortBySeries: c
           };
         },
-        { './eachSeries': 14, './internal/collection': 36, './internal/util': 39 }
+        { './eachSeries': 15, './internal/collection': 37, './internal/util': 40 }
       ],
-      73: [
+      74: [
         function(e, t) {
           'use strict';
           const r = e('./aigle'),
@@ -3885,9 +3924,9 @@
             return i(s, t, e), s.then(() => e);
           };
         },
-        { './aigle': 2, './internal/util': 39 }
+        { './aigle': 2, './internal/util': 40 }
       ],
-      74: [
+      75: [
         function(e, t) {
           'use strict';
           const r = e('./aigle'),
@@ -3897,9 +3936,9 @@
             return i(s, t, e), s;
           };
         },
-        { './aigle': 2, './internal/util': 39 }
+        { './aigle': 2, './internal/util': 40 }
       ],
-      75: [
+      76: [
         function(e, t) {
           'use strict';
           const { AigleProxy: r } = e('aigle-core'),
@@ -3923,9 +3962,9 @@
             }
           };
         },
-        { './aigle': 2, './error': 15, './internal/util': 39, 'aigle-core': 85 }
+        { './aigle': 2, './error': 16, './internal/util': 40, 'aigle-core': 86 }
       ],
-      76: [
+      77: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -3976,9 +4015,9 @@
             execute: l
           };
         },
-        { './aigle': 2, './internal/util': 39, 'aigle-core': 85 }
+        { './aigle': 2, './internal/util': 40, 'aigle-core': 86 }
       ],
-      77: [
+      78: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -4042,9 +4081,9 @@
             TimesLimit: p
           };
         },
-        { './aigle': 2, './internal/util': 39, 'aigle-core': 85 }
+        { './aigle': 2, './internal/util': 40, 'aigle-core': 86 }
       ],
-      78: [
+      79: [
         function(e, t) {
           'use strict';
           const { AigleProxy: r } = e('aigle-core'),
@@ -4090,9 +4129,9 @@
             TimesSeries: u
           };
         },
-        { './aigle': 2, './internal/util': 39, './times': 76, 'aigle-core': 85 }
+        { './aigle': 2, './internal/util': 40, './times': 77, 'aigle-core': 86 }
       ],
-      79: [
+      80: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -4135,9 +4174,9 @@
             Transform: n
           };
         },
-        { './each': 12, './internal/collection': 36, './internal/util': 39 }
+        { './each': 13, './internal/collection': 37, './internal/util': 40 }
       ],
-      80: [
+      81: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -4182,9 +4221,9 @@
             TransformLimit: u
           };
         },
-        { './eachLimit': 13, './internal/collection': 36, './internal/util': 39 }
+        { './eachLimit': 14, './internal/collection': 37, './internal/util': 40 }
       ],
-      81: [
+      82: [
         function(e, t) {
           'use strict';
           function r(e) {
@@ -4227,9 +4266,9 @@
             TransformSeries: n
           };
         },
-        { './eachSeries': 14, './internal/collection': 36, './internal/util': 39 }
+        { './eachSeries': 15, './internal/collection': 37, './internal/util': 40 }
       ],
-      82: [
+      83: [
         function(e, t) {
           'use strict';
           const { AigleWhilst: r, WhilstTester: l } = e('./whilst');
@@ -4251,9 +4290,9 @@
             UntilTester: i
           };
         },
-        { './whilst': 84 }
+        { './whilst': 85 }
       ],
-      83: [
+      84: [
         function(e, t) {
           'use strict';
           const { AigleProxy: r } = e('aigle-core'),
@@ -4332,9 +4371,9 @@
             Disposer: c
           };
         },
-        { './aigle': 2, './internal/util': 39, 'aigle-core': 85 }
+        { './aigle': 2, './internal/util': 40, 'aigle-core': 86 }
       ],
-      84: [
+      85: [
         function(e, t) {
           'use strict';
           const { AigleProxy: r } = e('aigle-core'),
@@ -4386,9 +4425,9 @@
             WhilstTester: _
           };
         },
-        { './aigle': 2, './internal/util': 39, 'aigle-core': 85 }
+        { './aigle': 2, './internal/util': 40, 'aigle-core': 86 }
       ],
-      85: [
+      86: [
         function(e, t) {
           'use strict';
           t.exports = {
@@ -4402,7 +4441,7 @@
         },
         {}
       ],
-      86: [
+      87: [
         function(e, t) {
           function r() {
             throw new Error('setTimeout has not been defined');
@@ -4437,17 +4476,17 @@
             }
           }
           function o() {
-            y && h && ((y = !1), h.length ? (m = h.concat(m)) : (d = -1), m.length && _());
+            d && h && ((d = !1), h.length ? (m = h.concat(m)) : (y = -1), m.length && _());
           }
           function _() {
-            if (!y) {
+            if (!d) {
               var e = s(o);
-              y = !0;
+              d = !0;
               for (var t = m.length; t; ) {
-                for (h = m, m = []; ++d < t; ) h && h[d].run();
-                (d = -1), (t = m.length);
+                for (h = m, m = []; ++y < t; ) h && h[y].run();
+                (y = -1), (t = m.length);
               }
-              (h = null), (y = !1), i(e);
+              (h = null), (d = !1), i(e);
             }
           }
           function a(e, t) {
@@ -4470,14 +4509,14 @@
             }
           })();
           var m = [],
-            y = !1,
-            d = -1,
+            d = !1,
+            y = -1,
             h;
           (n.nextTick = function(e) {
             var t = Array(arguments.length - 1);
             if (1 < arguments.length)
               for (var r = 1; r < arguments.length; r++) t[r - 1] = arguments[r];
-            m.push(new a(e, t)), 1 !== m.length || y || s(_);
+            m.push(new a(e, t)), 1 !== m.length || d || s(_);
           }),
             (a.prototype.run = function() {
               this.fun.apply(null, this.array);
@@ -4515,7 +4554,7 @@
         },
         {}
       ],
-      87: [
+      88: [
         function(e) {
           (function(e, t) {
             (function(t) {
@@ -4551,15 +4590,15 @@
                 }
               }
               function s(e) {
-                if (y) setTimeout(s, 0, e);
+                if (d) setTimeout(s, 0, e);
                 else {
                   var t = m[e];
                   if (t) {
-                    y = !0;
+                    d = !0;
                     try {
                       i(t);
                     } finally {
-                      l(e), (y = !1);
+                      l(e), (d = !1);
                     }
                   }
                 }
@@ -4611,9 +4650,9 @@
                   });
               }
               function n() {
-                var e = d.documentElement;
+                var e = y.documentElement;
                 v = function(t) {
-                  var r = d.createElement('script');
+                  var r = y.createElement('script');
                   (r.onreadystatechange = function() {
                     s(t), (r.onreadystatechange = null), e.removeChild(r), (r = null);
                   }),
@@ -4628,8 +4667,8 @@
               if (!t.setImmediate) {
                 var p = 1,
                   m = {},
-                  y = !1,
-                  d = t.document,
+                  d = !1,
+                  y = t.document,
                   h = Object.getPrototypeOf && Object.getPrototypeOf(t),
                   v;
                 (h = h && h.setTimeout ? h : t),
@@ -4639,7 +4678,7 @@
                       ? a()
                       : t.MessageChannel
                         ? c()
-                        : d && 'onreadystatechange' in d.createElement('script')
+                        : y && 'onreadystatechange' in y.createElement('script')
                           ? n()
                           : u(),
                   (h.setImmediate = r),
@@ -4658,9 +4697,9 @@
               : global
           ));
         },
-        { _process: 86 }
+        { _process: 87 }
       ],
-      88: [
+      89: [
         function(e, t) {
           t.exports =
             'function' == typeof Object.create
@@ -4680,7 +4719,7 @@
         },
         {}
       ],
-      89: [
+      90: [
         function(e, t) {
           t.exports = function(e) {
             return (
@@ -4694,7 +4733,7 @@
         },
         {}
       ],
-      90: [
+      91: [
         function(e, t, r) {
           (function(t, l) {
             function s(e, t) {
@@ -4702,7 +4741,7 @@
               return (
                 3 <= arguments.length && (l.depth = arguments[2]),
                 4 <= arguments.length && (l.colors = arguments[3]),
-                d(t) ? (l.showHidden = t) : t && r._extend(l, t),
+                y(t) ? (l.showHidden = t) : t && r._extend(l, t),
                 x(l.showHidden) && (l.showHidden = !1),
                 x(l.depth) && (l.depth = 2),
                 x(l.colors) && (l.colors = !1),
@@ -4741,7 +4780,7 @@
               var s = c(e, t);
               if (s) return s;
               var o = Object.keys(t),
-                d = _(o);
+                y = _(o);
               if (
                 (e.showHidden && (o = Object.getOwnPropertyNames(t)),
                 L(t) && (0 <= o.indexOf('message') || 0 <= o.indexOf('description')))
@@ -4759,7 +4798,7 @@
               var v = '',
                 x = !1,
                 k = ['{', '}'];
-              if ((y(t) && ((x = !0), (k = ['[', ']'])), R(t))) {
+              if ((d(t) && ((x = !0), (k = ['[', ']'])), R(t))) {
                 var E = t.name ? ': ' + t.name : '';
                 v = ' [Function' + E + ']';
               }
@@ -4778,9 +4817,9 @@
               var j;
               return (
                 (j = x
-                  ? p(e, t, l, d, o)
+                  ? p(e, t, l, y, o)
                   : o.map(function(r) {
-                      return n(e, t, l, d, r, x);
+                      return n(e, t, l, y, r, x);
                     })),
                 e.seen.pop(),
                 m(j, v, k)
@@ -4800,7 +4839,7 @@
               }
               return v(t)
                 ? e.stylize('' + t, 'number')
-                : d(t)
+                : y(t)
                   ? e.stylize('' + t, 'boolean')
                   : h(t)
                     ? e.stylize('null', 'null')
@@ -4875,10 +4914,10 @@
                 ? r[0] + ('' === t ? '' : t + '\n ') + ' ' + e.join(',\n  ') + ' ' + r[1]
                 : r[0] + t + ' ' + e.join(', ') + ' ' + r[1];
             }
-            function y(e) {
+            function d(e) {
               return Array.isArray(e);
             }
-            function d(e) {
+            function y(e) {
               return 'boolean' == typeof e;
             }
             function h(e) {
@@ -5012,8 +5051,8 @@
                 date: 'magenta',
                 regexp: 'red'
               }),
-              (r.isArray = y),
-              (r.isBoolean = d),
+              (r.isArray = d),
+              (r.isBoolean = y),
               (r.isNull = h),
               (r.isNullOrUndefined = function(e) {
                 return null == e;
@@ -5075,13 +5114,13 @@
               : global
           ));
         },
-        { './support/isBuffer': 89, _process: 86, inherits: 88 }
+        { './support/isBuffer': 90, _process: 87, inherits: 89 }
       ],
-      91: [
+      92: [
         function(e, t) {
           t.exports = {
             name: 'aigle',
-            version: '1.13.1',
+            version: '1.14.0',
             description:
               'Aigle is an ideal Promise library, faster and more functional than other Promise libraries',
             main: 'index.js',
@@ -5128,7 +5167,7 @@
               'lint-staged': '^8.0.5',
               lodash: '^4.15.0',
               minimist: '^1.2.0',
-              mocha: '^6.0.2',
+              mocha: '^6.1.4',
               'mocha.parallel': '0.15.6',
               'neo-async': '^2.6.0',
               'npm-run-all': '^4.1.5',
@@ -5140,7 +5179,7 @@
               tslint: '^5.11.0',
               typeg: '^0.1.3',
               typescript: '^3.1.6',
-              'uglify-js': '^3.5.1'
+              'uglify-js': '^3.5.14'
             },
             dependencies: { 'aigle-core': '^1.0.0' },
             husky: { hooks: { 'pre-commit': 'npm-run-all -p build:type lint-staged' } },
diff --git a/package.json b/package.json
index 9540206a..2cbe3b48 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "aigle",
-  "version": "1.13.1",
+  "version": "1.14.0",
   "description": "Aigle is an ideal Promise library, faster and more functional than other Promise libraries",
   "main": "index.js",
   "typings": "aigle.d.ts",