third_party/devtools/node_modules/neo-async/async.js - cobalt - Git at Google

 (function(global, factory) {
   /*jshint -W030 */
   'use strict';
   typeof exports === 'object' && typeof module !== 'undefined'
     ? factory(exports)
     : typeof define === 'function' && define.amd
     ? define(['exports'], factory)
     : global.async
     ? factory((global.neo_async = global.neo_async || {}))
     : factory((global.async = global.async || {}));
 })(this, function(exports) {
   'use strict';

   var noop = function noop() {};
   var throwError = function throwError() {
     throw new Error('Callback was already called.');
   };

   var DEFAULT_TIMES = 5;
   var DEFAULT_INTERVAL = 0;

   var obj = 'object';
   var func = 'function';
   var isArray = Array.isArray;
   var nativeKeys = Object.keys;
   var nativePush = Array.prototype.push;
   var iteratorSymbol = typeof Symbol === func && Symbol.iterator;

   var nextTick, asyncNextTick, asyncSetImmediate;
   createImmediate();

   /**
    * @memberof async
    * @namespace each
    * @param {Array|Object} collection
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done();
    *   }, num * 10);
    * };
    * async.each(array, iterator, function(err, res) {
    *   console.log(res); // undefined
    *   console.log(order); // [1, 2, 3]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done();
    *   }, num * 10);
    * };
    * async.each(array, iterator, function(err, res) {
    *   console.log(res); // undefined
    *   console.log(order); // [[1, 0], [2, 2], [3, 1]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done();
    *   }, num * 10);
    * };
    * async.each(object, iterator, function(err, res) {
    *   console.log(res); // undefined
    *   console.log(order); // [1, 2, 3]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done();
    *   }, num * 10);
    * };
    * async.each(object, iterator, function(err, res) {
    *   console.log(res); // undefined
    *   console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b']]
    * });
    *
    * @example
    *
    * // break
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num !== 2);
    *   }, num * 10);
    * };
    * async.each(array, iterator, function(err, res) {
    *   console.log(res); // undefined
    *   console.log(order); // [1, 2]
    * });
    *
    */
   var each = createEach(arrayEach, baseEach, symbolEach);

   /**
    * @memberof async
    * @namespace map
    * @param {Array|Object} collection
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num);
    *   }, num * 10);
    * };
    * async.map(array, iterator, function(err, res) {
    *   console.log(res); // [1, 3, 2];
    *   console.log(order); // [1, 2, 3]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done(null, num);
    *   }, num * 10);
    * };
    * async.map(array, iterator, function(err, res) {
    *   console.log(res); // [1, 3, 2]
    *   console.log(order); // [[1, 0], [2, 2], [3, 1]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num);
    *   }, num * 10);
    * };
    * async.map(object, iterator, function(err, res) {
    *   console.log(res); // [1, 3, 2]
    *   console.log(order); // [1, 2, 3]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done(null, num);
    *   }, num * 10);
    * };
    * async.map(object, iterator, function(err, res) {
    *   console.log(res); // [1, 3, 2]
    *   console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b']]
    * });
    *
    */
   var map = createMap(arrayEachIndex, baseEachIndex, symbolEachIndex, true);

   /**
    * @memberof async
    * @namespace mapValues
    * @param {Array|Object} collection
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num);
    *   }, num * 10);
    * };
    * async.mapValues(array, iterator, function(err, res) {
    *   console.log(res); // { '0': 1, '1': 3, '2': 2 }
    *   console.log(order); // [1, 2, 3]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done(null, num);
    *   }, num * 10);
    * };
    * async.mapValues(array, iterator, function(err, res) {
    *   console.log(res); // { '0': 1, '1': 3, '2': 2 }
    *   console.log(order); // [[1, 0], [2, 2], [3, 1]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num);
    *   }, num * 10);
    * };
    * async.mapValues(object, iterator, function(err, res) {
    *   console.log(res); // { a: 1, b: 3, c: 2 }
    *   console.log(order); // [1, 2, 3]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done(null, num);
    *   }, num * 10);
    * };
    * async.mapValues(object, iterator, function(err, res) {
    *   console.log(res); // { a: 1, b: 3, c: 2 }
    *   console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b']]
    * });
    *
    */
   var mapValues = createMap(arrayEachIndex, baseEachKey, symbolEachKey, false);

   /**
    * @memberof async
    * @namespace filter
    * @param {Array|Object} collection
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.filter(array, iterator, function(err, res) {
    *   console.log(res); // [1, 3];
    *   console.log(order); // [1, 2, 3]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.filter(array, iterator, function(err, res) {
    *   console.log(res); // [1, 3];
    *   console.log(order); // [[1, 0], [2, 2], [3, 1]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.filter(object, iterator, function(err, res) {
    *   console.log(res); // [1, 3];
    *   console.log(order); // [1, 2, 3]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.filter(object, iterator, function(err, res) {
    *   console.log(res); // [1, 3];
    *   console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b']]
    * });
    *
    */
   var filter = createFilter(arrayEachIndexValue, baseEachIndexValue, symbolEachIndexValue, true);

   /**
    * @memberof async
    * @namespace filterSeries
    * @param {Array|Object} collection
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.filterSeries(array, iterator, function(err, res) {
    *   console.log(res); // [1, 3];
    *   console.log(order); // [1, 3, 2]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.filterSeries(array, iterator, function(err, res) {
    *   console.log(res); // [1, 3]
    *   console.log(order); // [[1, 0], [3, 1], [2, 2]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.filterSeries(object, iterator, function(err, res) {
    *   console.log(res); // [1, 3]
    *   console.log(order); // [1, 3, 2]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.filterSeries(object, iterator, function(err, res) {
    *   console.log(res); // [1, 3]
    *   console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c']]
    * });
    *
    */
   var filterSeries = createFilterSeries(true);

   /**
    * @memberof async
    * @namespace filterLimit
    * @param {Array|Object} collection
    * @param {number} limit - limit >= 1
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var array = [1, 5, 3, 4, 2];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.filterLimit(array, 2, iterator, function(err, res) {
    *   console.log(res); // [1, 5, 3]
    *   console.log(order); // [1, 3, 5, 2, 4]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var array = [1, 5, 3, 4, 2];
    * var iterator = function(num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.filterLimit(array, 2, iterator, function(err, res) {
    *   console.log(res); // [1, 5, 3]
    *   console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.filterLimit(object, 2, iterator, function(err, res) {
    *   console.log(res); // [1, 5, 3]
    *   console.log(order); // [1, 3, 5, 2, 4]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
    * var iterator = function(num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.filterLimit(object, 2, iterator, function(err, res) {
    *   console.log(res); // [1, 5, 3]
    *   console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
    * });
    *
    */
   var filterLimit = createFilterLimit(true);

   /**
    * @memberof async
    * @namespace reject
    * @param {Array|Object} collection
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.reject(array, iterator, function(err, res) {
    *   console.log(res); // [2];
    *   console.log(order); // [1, 2, 3]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.reject(array, iterator, function(err, res) {
    *   console.log(res); // [2];
    *   console.log(order); // [[1, 0], [2, 2], [3, 1]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.reject(object, iterator, function(err, res) {
    *   console.log(res); // [2];
    *   console.log(order); // [1, 2, 3]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.reject(object, iterator, function(err, res) {
    *   console.log(res); // [2];
    *   console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b']]
    * });
    *
    */
   var reject = createFilter(arrayEachIndexValue, baseEachIndexValue, symbolEachIndexValue, false);

   /**
    * @memberof async
    * @namespace rejectSeries
    * @param {Array|Object} collection
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.rejectSeries(array, iterator, function(err, res) {
    *   console.log(res); // [2];
    *   console.log(order); // [1, 3, 2]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.rejectSeries(object, iterator, function(err, res) {
    *   console.log(res); // [2];
    *   console.log(order); // [1, 3, 2]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.rejectSeries(object, iterator, function(err, res) {
    *   console.log(res); // [2];
    *   console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c']]
    * });
    *
    */
   var rejectSeries = createFilterSeries(false);

   /**
    * @memberof async
    * @namespace rejectLimit
    * @param {Array|Object} collection
    * @param {number} limit - limit >= 1
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var array = [1, 5, 3, 4, 2];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.rejectLimit(array, 2, iterator, function(err, res) {
    *   console.log(res); // [4, 2]
    *   console.log(order); // [1, 3, 5, 2, 4]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var array = [1, 5, 3, 4, 2];
    * var iterator = function(num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.rejectLimit(array, 2, iterator, function(err, res) {
    *   console.log(res); // [4, 2]
    *   console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.rejectLimit(object, 2, iterator, function(err, res) {
    *   console.log(res); // [4, 2]
    *   console.log(order); // [1, 3, 5, 2, 4]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
    * var iterator = function(num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.rejectLimit(object, 2, iterator, function(err, res) {
    *   console.log(res); // [4, 2]
    *   console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
    * });
    *
    */
   var rejectLimit = createFilterLimit(false);

   /**
    * @memberof async
    * @namespace detect
    * @param {Array|Object} collection
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.detect(array, iterator, function(err, res) {
    *   console.log(res); // 1
    *   console.log(order); // [1]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.detect(array, iterator, function(err, res) {
    *   console.log(res); // 1
    *   console.log(order); // [[1, 0]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.detect(object, iterator, function(err, res) {
    *   console.log(res); // 1
    *   console.log(order); // [1]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.detect(object, iterator, function(err, res) {
    *   console.log(res); // 1
    *   console.log(order); // [[1, 'a']]
    * });
    *
    */
   var detect = createDetect(arrayEachValue, baseEachValue, symbolEachValue, true);

   /**
    * @memberof async
    * @namespace detectSeries
    * @param {Array|Object} collection
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.detectSeries(array, iterator, function(err, res) {
    *   console.log(res); // 1
    *   console.log(order); // [1]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.detectSeries(array, iterator, function(err, res) {
    *   console.log(res); // 1
    *   console.log(order); // [[1, 0]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.detectSeries(object, iterator, function(err, res) {
    *   console.log(res); // 1
    *   console.log(order); // [1]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.detectSeries(object, iterator, function(err, res) {
    *   console.log(res); // 1
    *   console.log(order); // [[1, 'a']]
    * });
    *
    */
   var detectSeries = createDetectSeries(true);

   /**
    * @memberof async
    * @namespace detectLimit
    * @param {Array|Object} collection
    * @param {number} limit - limit >= 1
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var array = [1, 5, 3, 4, 2];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.detectLimit(array, 2, iterator, function(err, res) {
    *   console.log(res); // 1
    *   console.log(order); // [1]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var array = [1, 5, 3, 4, 2];
    * var iterator = function(num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.detectLimit(array, 2, iterator, function(err, res) {
    *   console.log(res); // 1
    *   console.log(order); // [[1, 0]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.detectLimit(object, 2, iterator, function(err, res) {
    *   console.log(res); // 1
    *   console.log(order); // [1]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
    * var iterator = function(num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.detectLimit(object, 2, iterator, function(err, res) {
    *   console.log(res); // 1
    *   console.log(order); // [[1, 'a']]
    * });
    *
    */
   var detectLimit = createDetectLimit(true);

   /**
    * @memberof async
    * @namespace every
    * @param {Array|Object} collection
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.every(array, iterator, function(err, res) {
    *   console.log(res); // false
    *   console.log(order); // [1, 2]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.every(array, iterator, function(err, res) {
    *   console.log(res); // false
    *   console.log(order); // [[1, 0], [2, 2]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.every(object, iterator, function(err, res) {
    *   console.log(res); // false
    *   console.log(order); // [1, 2]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.every(object, iterator, function(err, res) {
    *   console.log(res); // false
    *   console.log(order); // [[1, 'a'], [2, 'c']]
    * });
    *
    */
   var every = createEvery(arrayEachValue, baseEachValue, symbolEachValue);

   /**
    * @memberof async
    * @namespace everySeries
    * @param {Array|Object} collection
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.everySeries(array, iterator, function(err, res) {
    *   console.log(res); // false
    *   console.log(order); // [1, 3, 2]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.everySeries(array, iterator, function(err, res) {
    *   console.log(res); // false
    *   console.log(order); // [[1, 0], [3, 1], [2, 2]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.everySeries(object, iterator, function(err, res) {
    *   console.log(res); // false
    *   console.log(order); // [1, 3, 2]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.everySeries(object, iterator, function(err, res) {
    *   console.log(res); // false
    *   console.log(order); // [[1, 'a'], [3, 'b'] [2, 'c']]
    * });
    *
    */
   var everySeries = createEverySeries();

   /**
    * @memberof async
    * @namespace everyLimit
    * @param {Array|Object} collection
    * @param {number} limit - limit >= 1
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var array = [1, 5, 3, 4, 2];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.everyLimit(array, 2, iterator, function(err, res) {
    *   console.log(res); // false
    *   console.log(order); // [1, 3, 5, 2]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var array = [1, 5, 3, 4, 2];
    * var iterator = function(num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.everyLimit(array, 2, iterator, function(err, res) {
    *   console.log(res); // false
    *   console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.everyLimit(object, 2, iterator, function(err, res) {
    *   console.log(res); // false
    *   console.log(order); // [1, 3, 5, 2]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
    * var iterator = function(num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.everyLimit(object, 2, iterator, function(err, res) {
    *   console.log(res); // false
    *   console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e']]
    * });
    *
    */
   var everyLimit = createEveryLimit();

   /**
    * @memberof async
    * @namespace pick
    * @param {Array|Object} collection
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var array = [1, 3, 2, 4];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.pick(array, iterator, function(err, res) {
    *   console.log(res); // { '0': 1, '1': 3 }
    *   console.log(order); // [1, 2, 3, 4]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var array = [1, 3, 2, 4];
    * var iterator = function(num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.pick(array, iterator, function(err, res) {
    *   console.log(res); // { '0': 1, '1': 3 }
    *   console.log(order); // [[0, 1], [2, 2], [3, 1], [4, 3]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 1, b: 3, c: 2, d: 4 };
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.pick(object, iterator, function(err, res) {
    *   console.log(res); // { a: 1, b: 3 }
    *   console.log(order); // [1, 2, 3, 4]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 3, c: 2, d: 4 };
    * var iterator = function(num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.pick(object, iterator, function(err, res) {
    *   console.log(res); // { a: 1, b: 3 }
    *   console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b'], [4, 'd']]
    * });
    *
    */
   var pick = createPick(arrayEachIndexValue, baseEachKeyValue, symbolEachKeyValue, true);

   /**
    * @memberof async
    * @namespace pickSeries
    * @param {Array|Object} collection
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var array = [1, 3, 2, 4];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.pickSeries(array, iterator, function(err, res) {
    *   console.log(res); // { '0': 1, '1': 3 }
    *   console.log(order); // [1, 3, 2, 4]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var array = [1, 3, 2, 4];
    * var iterator = function(num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.pickSeries(array, iterator, function(err, res) {
    *   console.log(res); // { '0': 1, '1': 3 }
    *   console.log(order); // [[0, 1], [3, 1], [2, 2], [4, 3]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 1, b: 3, c: 2, d: 4 };
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.pickSeries(object, iterator, function(err, res) {
    *   console.log(res); // { a: 1, b: 3 }
    *   console.log(order); // [1, 3, 2, 4]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 3, c: 2, d: 4 };
    * var iterator = function(num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.pickSeries(object, iterator, function(err, res) {
    *   console.log(res); // { a: 1, b: 3 }
    *   console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c'], [4, 'd']]
    * });
    *
    */
   var pickSeries = createPickSeries(true);

   /**
    * @memberof async
    * @namespace pickLimit
    * @param {Array|Object} collection
    * @param {number} limit - limit >= 1
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var array = [1, 5, 3, 4, 2];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.pickLimit(array, 2, iterator, function(err, res) {
    *   console.log(res); // { '0': 1, '1': 5, '2': 3 }
    *   console.log(order); // [1, 3, 5, 2, 4]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var array = [1, 5, 3, 4, 2];
    * var iterator = function(num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.pickLimit(array, 2, iterator, function(err, res) {
    *   console.log(res); // { '0': 1, '1': 5, '2': 3 }
    *   console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.pickLimit(object, 2, iterator, function(err, res) {
    *   console.log(res); // { a: 1, b: 5, c: 3 }
    *   console.log(order); // [1, 3, 5, 2, 4]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
    * var iterator = function(num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.pickLimit(object, 2, iterator, function(err, res) {
    *   console.log(res); // { a: 1, b: 5, c: 3 }
    *   console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
    * });
    *
    */
   var pickLimit = createPickLimit(true);

   /**
    * @memberof async
    * @namespace omit
    * @param {Array|Object} collection
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var array = [1, 3, 2, 4];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.omit(array, iterator, function(err, res) {
    *   console.log(res); // { '2': 2, '3': 4 }
    *   console.log(order); // [1, 2, 3, 4]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var array = [1, 3, 2, 4];
    * var iterator = function(num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.omit(array, iterator, function(err, res) {
    *   console.log(res); // { '2': 2, '3': 4 }
    *   console.log(order); // [[0, 1], [2, 2], [3, 1], [4, 3]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 1, b: 3, c: 2, d: 4 };
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.omit(object, iterator, function(err, res) {
    *   console.log(res); // { c: 2, d: 4 }
    *   console.log(order); // [1, 2, 3, 4]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 3, c: 2, d: 4 };
    * var iterator = function(num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.omit(object, iterator, function(err, res) {
    *   console.log(res); // { c: 2, d: 4 }
    *   console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b'], [4, 'd']]
    * });
    *
    */
   var omit = createPick(arrayEachIndexValue, baseEachKeyValue, symbolEachKeyValue, false);

   /**
    * @memberof async
    * @namespace omitSeries
    * @param {Array|Object} collection
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var array = [1, 3, 2, 4];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.omitSeries(array, iterator, function(err, res) {
    *   console.log(res); // { '2': 2, '3': 4 }
    *   console.log(order); // [1, 3, 2, 4]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var array = [1, 3, 2, 4];
    * var iterator = function(num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.omitSeries(array, iterator, function(err, res) {
    *   console.log(res); // { '2': 2, '3': 4 }
    *   console.log(order); // [[0, 1], [3, 1], [2, 2], [4, 3]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 1, b: 3, c: 2, d: 4 };
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.omitSeries(object, iterator, function(err, res) {
    *   console.log(res); // { c: 2, d: 4 }
    *   console.log(order); // [1, 3, 2, 4]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 3, c: 2, d: 4 };
    * var iterator = function(num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.omitSeries(object, iterator, function(err, res) {
    *   console.log(res); // { c: 2, d: 4 }
    *   console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c'], [4, 'd']]
    * });
    *
    */
   var omitSeries = createPickSeries(false);

   /**
    * @memberof async
    * @namespace omitLimit
    * @param {Array|Object} collection
    * @param {number} limit - limit >= 1
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var array = [1, 5, 3, 4, 2];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.omitLimit(array, 2, iterator, function(err, res) {
    *   console.log(res); // { '3': 4, '4': 2 }
    *   console.log(order); // [1, 3, 5, 2, 4]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var array = [1, 5, 3, 4, 2];
    * var iterator = function(num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.omitLimit(array, 2, iterator, function(err, res) {
    *   console.log(res); // { '3': 4, '4': 2 }
    *   console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.omitLimit(object, 2, iterator, function(err, res) {
    *   console.log(res); // { d: 4, e: 2 }
    *   console.log(order); // [1, 3, 5, 2, 4]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
    * var iterator = function(num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.omitLimit(object, 2, iterator, function(err, res) {
    *   console.log(res); // { d: 4, e: 2 }
    *   console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
    * });
    *
    */
   var omitLimit = createPickLimit(false);

   /**
    * @memberof async
    * @namespace transform
    * @param {Array|Object} collection
    * @param {Array|Object|Function} [accumulator]
    * @param {Function} [iterator]
    * @param {Function} [callback]
    * @example
    *
    * // array
    * var order = [];
    * var collection = [1, 3, 2, 4];
    * var iterator = function(result, num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     result.push(num)
    *     done();
    *   }, num * 10);
    * };
    * async.transform(collection, iterator, function(err, res) {
    *   console.log(res); // [1, 2, 3, 4]
    *   console.log(order); // [1, 2, 3, 4]
    * });
    *
    * @example
    *
    * // array with index and accumulator
    * var order = [];
    * var collection = [1, 3, 2, 4];
    * var iterator = function(result, num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     result[index] = num;
    *     done();
    *   }, num * 10);
    * };
    * async.transform(collection, {}, iterator, function(err, res) {
    *   console.log(res); // { '0': 1, '1': 3, '2': 2, '3': 4 }
    *   console.log(order); // [[1, 0], [2, 2], [3, 1], [4, 3]]
    * });
    *
    * @example
    *
    * // object with accumulator
    * var order = [];
    * var object = { a: 1, b: 3, c: 2, d: 4 };
    * var iterator = function(result, num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     result.push(num);
    *     done();
    *   }, num * 10);
    * };
    * async.transform(collection, [], iterator, function(err, res) {
    *   console.log(res); // [1, 2, 3, 4]
    *   console.log(order); // [1, 2, 3, 4]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 3, c: 2, d: 4 };
    * var iterator = function(result, num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     result[key] = num;
    *     done();
    *   }, num * 10);
    * };
    * async.transform(collection, iterator, function(err, res) {
    *   console.log(res); //  { a: 1, b: 3, c: 2, d: 4 }
    *   console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b'], [4, 'd']]
    * });
    *
    */
   var transform = createTransform(arrayEachResult, baseEachResult, symbolEachResult);

   /**
    * @memberof async
    * @namespace sortBy
    * @param {Array|Object} collection
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num);
    *   }, num * 10);
    * };
    * async.sortBy(array, iterator, function(err, res) {
    *   console.log(res); // [1, 2, 3];
    *   console.log(order); // [1, 2, 3]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done(null, num);
    *   }, num * 10);
    * };
    * async.sortBy(array, iterator, function(err, res) {
    *   console.log(res); // [1, 2, 3]
    *   console.log(order); // [[1, 0], [2, 2], [3, 1]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num);
    *   }, num * 10);
    * };
    * async.sortBy(object, iterator, function(err, res) {
    *   console.log(res); // [1, 2, 3]
    *   console.log(order); // [1, 2, 3]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done(null, num);
    *   }, num * 10);
    * };
    * async.sortBy(object, iterator, function(err, res) {
    *   console.log(res); // [1, 2, 3]
    *   console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b']]
    * });
    *
    */
   var sortBy = createSortBy(arrayEachIndexValue, baseEachIndexValue, symbolEachIndexValue);

   /**
    * @memberof async
    * @namespace concat
    * @param {Array|Object} collection
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, [num]);
    *   }, num * 10);
    * };
    * async.concat(array, iterator, function(err, res) {
    *   console.log(res); // [1, 2, 3];
    *   console.log(order); // [1, 2, 3]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done(null, [num]);
    *   }, num * 10);
    * };
    * async.concat(array, iterator, function(err, res) {
    *   console.log(res); // [1, 2, 3]
    *   console.log(order); // [[1, 0], [2, 2], [3, 1]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, [num]);
    *   }, num * 10);
    * };
    * async.concat(object, iterator, function(err, res) {
    *   console.log(res); // [1, 2, 3]
    *   console.log(order); // [1, 2, 3]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done(null, [num]);
    *   }, num * 10);
    * };
    * async.concat(object, iterator, function(err, res) {
    *   console.log(res); // [1, 2, 3]
    *   console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b']]
    * });
    *
    */
   var concat = createConcat(arrayEachIndex, baseEachIndex, symbolEachIndex);

   /**
    * @memberof async
    * @namespace groupBy
    * @param {Array|Object} collection
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var array = [4.2, 6.4, 6.1];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, Math.floor(num));
    *   }, num * 10);
    * };
    * async.groupBy(array, iterator, function(err, res) {
    *   console.log(res); // { '4': [4.2], '6': [6.1, 6.4] }
    *   console.log(order); // [4.2, 6.1, 6.4]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var array = [4.2, 6.4, 6.1];
    * var iterator = function(num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done(null, Math.floor(num));
    *   }, num * 10);
    * };
    * async.groupBy(array, iterator, function(err, res) {
    *   console.log(res); // { '4': [4.2], '6': [6.1, 6.4] }
    *   console.log(order); // [[4.2, 0], [6.1, 2], [6.4, 1]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 4.2, b: 6.4, c: 6.1 };
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, Math.floor(num));
    *   }, num * 10);
    * };
    * async.groupBy(object, iterator, function(err, res) {
    *   console.log(res); // { '4': [4.2], '6': [6.1, 6.4] }
    *   console.log(order); // [4.2, 6.1, 6.4]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 4.2, b: 6.4, c: 6.1 };
    * var iterator = function(num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done(null, Math.floor(num));
    *   }, num * 10);
    * };
    * async.groupBy(object, iterator, function(err, res) {
    *   console.log(res); // { '4': [4.2], '6': [6.1, 6.4] }
    *   console.log(order); // [[4.2, 'a'], [6.1, 'c'], [6.4, 'b']]
    * });
    *
    */
   var groupBy = createGroupBy(arrayEachValue, baseEachValue, symbolEachValue);

   /**
    * @memberof async
    * @namespace parallel
    * @param {Array|Object} tasks - functions
    * @param {Function} callback
    * @example
    *
    * var order = [];
    * var tasks = [
    *  function(done) {
    *    setTimeout(function() {
    *      order.push(1);
    *      done(null, 1);
    *    }, 10);
    *  },
    *  function(done) {
    *    setTimeout(function() {
    *      order.push(2);
    *      done(null, 2);
    *    }, 30);
    *  },
    *  function(done) {
    *    setTimeout(function() {
    *      order.push(3);
    *      done(null, 3);
    *    }, 40);
    *  },
    *  function(done) {
    *    setTimeout(function() {
    *      order.push(4);
    *      done(null, 4);
    *    }, 20);
    *  }
    * ];
    * async.parallel(tasks, function(err, res) {
    *   console.log(res); // [1, 2, 3, 4];
    *   console.log(order); // [1, 4, 2, 3]
    * });
    *
    * @example
    *
    * var order = [];
    * var tasks = {
    *   'a': function(done) {
    *     setTimeout(function() {
    *       order.push(1);
    *       done(null, 1);
    *     }, 10);
    *   },
    *   'b': function(done) {
    *     setTimeout(function() {
    *       order.push(2);
    *       done(null, 2);
    *     }, 30);
    *   },
    *   'c': function(done) {
    *     setTimeout(function() {
    *       order.push(3);
    *       done(null, 3);
    *     }, 40);
    *   },
    *   'd': function(done) {
    *     setTimeout(function() {
    *       order.push(4);
    *       done(null, 4);
    *     }, 20);
    *   }
    * };
    * async.parallel(tasks, function(err, res) {
    *   console.log(res); // { a: 1, b: 2, c: 3, d:4 }
    *   console.log(order); // [1, 4, 2, 3]
    * });
    *
    */
   var parallel = createParallel(arrayEachFunc, baseEachFunc);

   /**
    * @memberof async
    * @namespace applyEach
    */
   var applyEach = createApplyEach(map);

   /**
    * @memberof async
    * @namespace applyEachSeries
    */
   var applyEachSeries = createApplyEach(mapSeries);

   /**
    * @memberof async
    * @namespace log
    */
   var log = createLogger('log');

   /**
    * @memberof async
    * @namespace dir
    */
   var dir = createLogger('dir');

   /**
    * @version 2.6.1
    * @namespace async
    */
   var index = {
     VERSION: '2.6.1',

     // Collections
     each: each,
     eachSeries: eachSeries,
     eachLimit: eachLimit,
     forEach: each,
     forEachSeries: eachSeries,
     forEachLimit: eachLimit,
     eachOf: each,
     eachOfSeries: eachSeries,
     eachOfLimit: eachLimit,
     forEachOf: each,
     forEachOfSeries: eachSeries,
     forEachOfLimit: eachLimit,
     map: map,
     mapSeries: mapSeries,
     mapLimit: mapLimit,
     mapValues: mapValues,
     mapValuesSeries: mapValuesSeries,
     mapValuesLimit: mapValuesLimit,
     filter: filter,
     filterSeries: filterSeries,
     filterLimit: filterLimit,
     select: filter,
     selectSeries: filterSeries,
     selectLimit: filterLimit,
     reject: reject,
     rejectSeries: rejectSeries,
     rejectLimit: rejectLimit,
     detect: detect,
     detectSeries: detectSeries,
     detectLimit: detectLimit,
     find: detect,
     findSeries: detectSeries,
     findLimit: detectLimit,
     pick: pick,
     pickSeries: pickSeries,
     pickLimit: pickLimit,
     omit: omit,
     omitSeries: omitSeries,
     omitLimit: omitLimit,
     reduce: reduce,
     inject: reduce,
     foldl: reduce,
     reduceRight: reduceRight,
     foldr: reduceRight,
     transform: transform,
     transformSeries: transformSeries,
     transformLimit: transformLimit,
     sortBy: sortBy,
     sortBySeries: sortBySeries,
     sortByLimit: sortByLimit,
     some: some,
     someSeries: someSeries,
     someLimit: someLimit,
     any: some,
     anySeries: someSeries,
     anyLimit: someLimit,
     every: every,
     everySeries: everySeries,
     everyLimit: everyLimit,
     all: every,
     allSeries: everySeries,
     allLimit: everyLimit,
     concat: concat,
     concatSeries: concatSeries,
     concatLimit: concatLimit,
     groupBy: groupBy,
     groupBySeries: groupBySeries,
     groupByLimit: groupByLimit,

     // Control Flow
     parallel: parallel,
     series: series,
     parallelLimit: parallelLimit,
     tryEach: tryEach,
     waterfall: waterfall,
     angelFall: angelFall,
     angelfall: angelFall,
     whilst: whilst,
     doWhilst: doWhilst,
     until: until,
     doUntil: doUntil,
     during: during,
     doDuring: doDuring,
     forever: forever,
     compose: compose,
     seq: seq,
     applyEach: applyEach,
     applyEachSeries: applyEachSeries,
     queue: queue,
     priorityQueue: priorityQueue,
     cargo: cargo,
     auto: auto,
     autoInject: autoInject,
     retry: retry,
     retryable: retryable,
     iterator: iterator,
     times: times,
     timesSeries: timesSeries,
     timesLimit: timesLimit,
     race: race,

     // Utils
     apply: apply,
     nextTick: asyncNextTick,
     setImmediate: asyncSetImmediate,
     memoize: memoize,
     unmemoize: unmemoize,
     ensureAsync: ensureAsync,
     constant: constant,
     asyncify: asyncify,
     wrapSync: asyncify,
     log: log,
     dir: dir,
     reflect: reflect,
     reflectAll: reflectAll,
     timeout: timeout,
     createLogger: createLogger,

     // Mode
     safe: safe,
     fast: fast
   };

   exports['default'] = index;
   baseEachSync(
     index,
     function(func, key) {
       exports[key] = func;
     },
     nativeKeys(index)
   );

   /**
    * @private
    */
   function createImmediate(safeMode) {
     var delay = function delay(fn) {
       var args = slice(arguments, 1);
       setTimeout(function() {
         fn.apply(null, args);
       });
     };
     asyncSetImmediate = typeof setImmediate === func ? setImmediate : delay;
     if (typeof process === obj && typeof process.nextTick === func) {
       nextTick = /^v0.10/.test(process.version) ? asyncSetImmediate : process.nextTick;
       asyncNextTick = /^v0/.test(process.version) ? asyncSetImmediate : process.nextTick;
     } else {
       asyncNextTick = nextTick = asyncSetImmediate;
     }
     if (safeMode === false) {
       nextTick = function(cb) {
         cb();
       };
     }
   }

   /* sync functions based on lodash */

   /**
    * Converts `arguments` to an array.
    *
    * @private
    * @param {Array} array = The array to slice.
    */
   function createArray(array) {
     var index = -1;
     var size = array.length;
     var result = Array(size);

     while (++index < size) {
       result[index] = array[index];
     }
     return result;
   }

   /**
    * Create an array from `start`
    *
    * @private
    * @param {Array} array - The array to slice.
    * @param {number} start - The start position.
    */
   function slice(array, start) {
     var end = array.length;
     var index = -1;
     var size = end - start;
     if (size <= 0) {
       return [];
     }
     var result = Array(size);

     while (++index < size) {
       result[index] = array[index + start];
     }
     return result;
   }

   /**
    * @private
    * @param {Object} object
    */
   function objectClone(object) {
     var keys = nativeKeys(object);
     var size = keys.length;
     var index = -1;
     var result = {};

     while (++index < size) {
       var key = keys[index];
       result[key] = object[key];
     }
     return result;
   }

   /**
    * Create an array with all falsey values removed.
    *
    * @private
    * @param {Array} array - The array to compact.
    */
   function compact(array) {
     var index = -1;
     var size = array.length;
     var result = [];

     while (++index < size) {
       var value = array[index];
       if (value) {
         result[result.length] = value;
       }
     }
     return result;
   }

   /**
    * Create an array of reverse sequence.
    *
    * @private
    * @param {Array} array - The array to reverse.
    */
   function reverse(array) {
     var index = -1;
     var size = array.length;
     var result = Array(size);
     var resIndex = size;

     while (++index < size) {
       result[--resIndex] = array[index];
     }
     return result;
   }

   /**
    * Checks if key exists in object property.
    *
    * @private
    * @param {Object} object - The object to inspect.
    * @param {string} key - The key to check.
    */
   function has(object, key) {
     return object.hasOwnProperty(key);
   }

   /**
    * Check if target exists in array.
    * @private
    * @param {Array} array
    * @param {*} target
    */
   function notInclude(array, target) {
     var index = -1;
     var size = array.length;

     while (++index < size) {
       if (array[index] === target) {
         return false;
       }
     }
     return true;
   }

   /**
    * @private
    * @param {Array} array - The array to iterate over.
    * @param {Function} iterator - The function invoked per iteration.
    */
   function arrayEachSync(array, iterator) {
     var index = -1;
     var size = array.length;

     while (++index < size) {
       iterator(array[index], index);
     }
     return array;
   }

   /**
    * @private
    * @param {Object} object - The object to iterate over.
    * @param {Function} iterator - The function invoked per iteration.
    * @param {Array} keys
    */
   function baseEachSync(object, iterator, keys) {
     var index = -1;
     var size = keys.length;

     while (++index < size) {
       var key = keys[index];
       iterator(object[key], key);
     }
     return object;
   }

   /**
    * @private
    * @param {number} n
    * @param {Function} iterator
    */
   function timesSync(n, iterator) {
     var index = -1;
     while (++index < n) {
       iterator(index);
     }
   }

   /**
    * @private
    * @param {Array} array
    * @param {number[]} criteria
    */
   function sortByCriteria(array, criteria) {
     var l = array.length;
     var indices = Array(l);
     var i;
     for (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++) {
       i = indices[n];
       result[n] = i === undefined ? array[n] : array[i];
     }
     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 index = indices[l];
         indices[l] = indices[k];
         indices[k] = index;
       }
     }
     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);
   }

   /**
    * @Private
    */
   function makeConcatResult(array) {
     var result = [];
     arrayEachSync(array, function(value) {
       if (value === noop) {
         return;
       }
       if (isArray(value)) {
         nativePush.apply(result, value);
       } else {
         result.push(value);
       }
     });
     return result;
   }

   /* async functions */

   /**
    * @private
    */
   function arrayEach(array, iterator, callback) {
     var index = -1;
     var size = array.length;

     if (iterator.length === 3) {
       while (++index < size) {
         iterator(array[index], index, onlyOnce(callback));
       }
     } else {
       while (++index < size) {
         iterator(array[index], onlyOnce(callback));
       }
     }
   }

   /**
    * @private
    */
   function baseEach(object, iterator, callback, keys) {
     var key;
     var index = -1;
     var size = keys.length;

     if (iterator.length === 3) {
       while (++index < size) {
         key = keys[index];
         iterator(object[key], key, onlyOnce(callback));
       }
     } else {
       while (++index < size) {
         iterator(object[keys[index]], onlyOnce(callback));
       }
     }
   }

   /**
    * @private
    */
   function symbolEach(collection, iterator, callback) {
     var iter = collection[iteratorSymbol]();
     var index = 0;
     var item;
     if (iterator.length === 3) {
       while ((item = iter.next()).done === false) {
         iterator(item.value, index++, onlyOnce(callback));
       }
     } else {
       while ((item = iter.next()).done === false) {
         index++;
         iterator(item.value, onlyOnce(callback));
       }
     }
     return index;
   }

   /**
    * @private
    */
   function arrayEachResult(array, result, iterator, callback) {
     var index = -1;
     var size = array.length;

     if (iterator.length === 4) {
       while (++index < size) {
         iterator(result, array[index], index, onlyOnce(callback));
       }
     } else {
       while (++index < size) {
         iterator(result, array[index], onlyOnce(callback));
       }
     }
   }

   /**
    * @private
    */
   function baseEachResult(object, result, iterator, callback, keys) {
     var key;
     var index = -1;
     var size = keys.length;

     if (iterator.length === 4) {
       while (++index < size) {
         key = keys[index];
         iterator(result, object[key], key, onlyOnce(callback));
       }
     } else {
       while (++index < size) {
         iterator(result, object[keys[index]], onlyOnce(callback));
       }
     }
   }

   /**
    * @private
    */
   function symbolEachResult(collection, result, iterator, callback) {
     var item;
     var index = 0;
     var iter = collection[iteratorSymbol]();

     if (iterator.length === 4) {
       while ((item = iter.next()).done === false) {
         iterator(result, item.value, index++, onlyOnce(callback));
       }
     } else {
       while ((item = iter.next()).done === false) {
         index++;
         iterator(result, item.value, onlyOnce(callback));
       }
     }
     return index;
   }

   /**
    * @private
    */
   function arrayEachFunc(array, createCallback) {
     var index = -1;
     var size = array.length;

     while (++index < size) {
       array[index](createCallback(index));
     }
   }

   /**
    * @private
    */
   function baseEachFunc(object, createCallback, keys) {
     var key;
     var index = -1;
     var size = keys.length;

     while (++index < size) {
       key = keys[index];
       object[key](createCallback(key));
     }
   }

   /**
    * @private
    */
   function arrayEachIndex(array, iterator, createCallback) {
     var index = -1;
     var size = array.length;

     if (iterator.length === 3) {
       while (++index < size) {
         iterator(array[index], index, createCallback(index));
       }
     } else {
       while (++index < size) {
         iterator(array[index], createCallback(index));
       }
     }
   }

   /**
    * @private
    */
   function baseEachIndex(object, iterator, createCallback, keys) {
     var key;
     var index = -1;
     var size = keys.length;

     if (iterator.length === 3) {
       while (++index < size) {
         key = keys[index];
         iterator(object[key], key, createCallback(index));
       }
     } else {
       while (++index < size) {
         iterator(object[keys[index]], createCallback(index));
       }
     }
   }

   /**
    * @private
    */
   function symbolEachIndex(collection, iterator, createCallback) {
     var item;
     var index = 0;
     var iter = collection[iteratorSymbol]();

     if (iterator.length === 3) {
       while ((item = iter.next()).done === false) {
         iterator(item.value, index, createCallback(index++));
       }
     } else {
       while ((item = iter.next()).done === false) {
         iterator(item.value, createCallback(index++));
       }
     }
     return index;
   }

   /**
    * @private
    */
   function baseEachKey(object, iterator, createCallback, keys) {
     var key;
     var index = -1;
     var size = keys.length;

     if (iterator.length === 3) {
       while (++index < size) {
         key = keys[index];
         iterator(object[key], key, createCallback(key));
       }
     } else {
       while (++index < size) {
         key = keys[index];
         iterator(object[key], createCallback(key));
       }
     }
   }

   /**
    * @private
    */
   function symbolEachKey(collection, iterator, createCallback) {
     var item;
     var index = 0;
     var iter = collection[iteratorSymbol]();

     if (iterator.length === 3) {
       while ((item = iter.next()).done === false) {
         iterator(item.value, index, createCallback(index++));
       }
     } else {
       while ((item = iter.next()).done === false) {
         iterator(item.value, createCallback(index++));
       }
     }
     return index;
   }

   /**
    * @private
    */
   function arrayEachValue(array, iterator, createCallback) {
     var value;
     var index = -1;
     var size = array.length;

     if (iterator.length === 3) {
       while (++index < size) {
         value = array[index];
         iterator(value, index, createCallback(value));
       }
     } else {
       while (++index < size) {
         value = array[index];
         iterator(value, createCallback(value));
       }
     }
   }

   /**
    * @private
    */
   function baseEachValue(object, iterator, createCallback, keys) {
     var key, value;
     var index = -1;
     var size = keys.length;

     if (iterator.length === 3) {
       while (++index < size) {
         key = keys[index];
         value = object[key];
         iterator(value, key, createCallback(value));
       }
     } else {
       while (++index < size) {
         value = object[keys[index]];
         iterator(value, createCallback(value));
       }
     }
   }

   /**
    * @private
    */
   function symbolEachValue(collection, iterator, createCallback) {
     var value, item;
     var index = 0;
     var iter = collection[iteratorSymbol]();

     if (iterator.length === 3) {
       while ((item = iter.next()).done === false) {
         value = item.value;
         iterator(value, index++, createCallback(value));
       }
     } else {
       while ((item = iter.next()).done === false) {
         index++;
         value = item.value;
         iterator(value, createCallback(value));
       }
     }
     return index;
   }

   /**
    * @private
    */
   function arrayEachIndexValue(array, iterator, createCallback) {
     var value;
     var index = -1;
     var size = array.length;

     if (iterator.length === 3) {
       while (++index < size) {
         value = array[index];
         iterator(value, index, createCallback(index, value));
       }
     } else {
       while (++index < size) {
         value = array[index];
         iterator(value, createCallback(index, value));
       }
     }
   }

   /**
    * @private
    */
   function baseEachIndexValue(object, iterator, createCallback, keys) {
     var key, value;
     var index = -1;
     var size = keys.length;

     if (iterator.length === 3) {
       while (++index < size) {
         key = keys[index];
         value = object[key];
         iterator(value, key, createCallback(index, value));
       }
     } else {
       while (++index < size) {
         value = object[keys[index]];
         iterator(value, createCallback(index, value));
       }
     }
   }

   /**
    * @private
    */
   function symbolEachIndexValue(collection, iterator, createCallback) {
     var value, item;
     var index = 0;
     var iter = collection[iteratorSymbol]();

     if (iterator.length === 3) {
       while ((item = iter.next()).done === false) {
         value = item.value;
         iterator(value, index, createCallback(index++, value));
       }
     } else {
       while ((item = iter.next()).done === false) {
         value = item.value;
         iterator(value, createCallback(index++, value));
       }
     }
     return index;
   }

   /**
    * @private
    */
   function baseEachKeyValue(object, iterator, createCallback, keys) {
     var key, value;
     var index = -1;
     var size = keys.length;

     if (iterator.length === 3) {
       while (++index < size) {
         key = keys[index];
         value = object[key];
         iterator(value, key, createCallback(key, value));
       }
     } else {
       while (++index < size) {
         key = keys[index];
         value = object[key];
         iterator(value, createCallback(key, value));
       }
     }
   }

   /**
    * @private
    */
   function symbolEachKeyValue(collection, iterator, createCallback) {
     var value, item;
     var index = 0;
     var iter = collection[iteratorSymbol]();

     if (iterator.length === 3) {
       while ((item = iter.next()).done === false) {
         value = item.value;
         iterator(value, index, createCallback(index++, value));
       }
     } else {
       while ((item = iter.next()).done === false) {
         value = item.value;
         iterator(value, createCallback(index++, value));
       }
     }
     return index;
   }

   /**
    * @private
    * @param {Function} func
    */
   function onlyOnce(func) {
     return function(err, res) {
       var fn = func;
       func = throwError;
       fn(err, res);
     };
   }

   /**
    * @private
    * @param {Function} func
    */
   function once(func) {
     return function(err, res) {
       var fn = func;
       func = noop;
       fn(err, res);
     };
   }

   /**
    * @private
    * @param {Function} arrayEach
    * @param {Function} baseEach
    */
   function createEach(arrayEach, baseEach, symbolEach) {
     return function each(collection, iterator, callback) {
       callback = once(callback || noop);
       var size, keys;
       var completed = 0;
       if (isArray(collection)) {
         size = collection.length;
         arrayEach(collection, iterator, done);
       } else if (!collection) {
       } else if (iteratorSymbol && collection[iteratorSymbol]) {
         size = symbolEach(collection, iterator, done);
         size && size === completed && callback(null);
       } else if (typeof collection === obj) {
         keys = nativeKeys(collection);
         size = keys.length;
         baseEach(collection, iterator, done, keys);
       }
       if (!size) {
         callback(null);
       }

       function done(err, bool) {
         if (err) {
           callback = once(callback);
           callback(err);
         } else if (++completed === size) {
           callback(null);
         } else if (bool === false) {
           callback = once(callback);
           callback(null);
         }
       }
     };
   }

   /**
    * @private
    * @param {Function} arrayEach
    * @param {Function} baseEach
    * @param {Function} symbolEach
    */
   function createMap(arrayEach, baseEach, symbolEach, useArray) {
     var init, clone;
     if (useArray) {
       init = Array;
       clone = createArray;
     } else {
       init = function() {
         return {};
       };
       clone = objectClone;
     }

     return function(collection, iterator, callback) {
       callback = callback || noop;
       var size, keys, result;
       var completed = 0;

       if (isArray(collection)) {
         size = collection.length;
         result = init(size);
         arrayEach(collection, iterator, createCallback);
       } else if (!collection) {
       } else if (iteratorSymbol && collection[iteratorSymbol]) {
         // TODO: size could be changed
         result = init(0);
         size = symbolEach(collection, iterator, createCallback);
         size && size === completed && callback(null, result);
       } else if (typeof collection === obj) {
         keys = nativeKeys(collection);
         size = keys.length;
         result = init(size);
         baseEach(collection, iterator, createCallback, keys);
       }
       if (!size) {
         callback(null, init());
       }

       function createCallback(key) {
         return function done(err, res) {
           if (key === null) {
             throwError();
           }
           if (err) {
             key = null;
             callback = once(callback);
             callback(err, clone(result));
             return;
           }
           result[key] = res;
           key = null;
           if (++completed === size) {
             callback(null, result);
           }
         };
       }
     };
   }

   /**
    * @private
    * @param {Function} arrayEach
    * @param {Function} baseEach
    * @param {Function} symbolEach
    * @param {boolean} bool
    */
   function createFilter(arrayEach, baseEach, symbolEach, bool) {
     return function(collection, iterator, callback) {
       callback = callback || noop;
       var size, keys, result;
       var completed = 0;

       if (isArray(collection)) {
         size = collection.length;
         result = Array(size);
         arrayEach(collection, iterator, createCallback);
       } else if (!collection) {
       } else if (iteratorSymbol && collection[iteratorSymbol]) {
         result = [];
         size = symbolEach(collection, iterator, createCallback);
         size && size === completed && callback(null, compact(result));
       } else if (typeof collection === obj) {
         keys = nativeKeys(collection);
         size = keys.length;
         result = Array(size);
         baseEach(collection, iterator, createCallback, keys);
       }
       if (!size) {
         return callback(null, []);
       }

       function createCallback(index, value) {
         return function done(err, res) {
           if (index === null) {
             throwError();
           }
           if (err) {
             index = null;
             callback = once(callback);
             callback(err);
             return;
           }
           if (!!res === bool) {
             result[index] = value;
           }
           index = null;
           if (++completed === size) {
             callback(null, compact(result));
           }
         };
       }
     };
   }

   /**
    * @private
    * @param {boolean} bool
    */
   function createFilterSeries(bool) {
     return function(collection, iterator, callback) {
       callback = onlyOnce(callback || noop);
       var size, key, value, keys, iter, item, iterate;
       var sync = false;
       var completed = 0;
       var result = [];

       if (isArray(collection)) {
         size = collection.length;
         iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
       } else if (!collection) {
       } else if (iteratorSymbol && collection[iteratorSymbol]) {
         size = Infinity;
         iter = collection[iteratorSymbol]();
         iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
       } else if (typeof collection === obj) {
         keys = nativeKeys(collection);
         size = keys.length;
         iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
       }
       if (!size) {
         return callback(null, []);
       }
       iterate();

       function arrayIterator() {
         value = collection[completed];
         iterator(value, done);
       }

       function arrayIteratorWithIndex() {
         value = collection[completed];
         iterator(value, completed, done);
       }

       function symbolIterator() {
         item = iter.next();
         value = item.value;
         item.done ? callback(null, result) : iterator(value, done);
       }

       function symbolIteratorWithKey() {
         item = iter.next();
         value = item.value;
         item.done ? callback(null, result) : iterator(value, completed, done);
       }

       function objectIterator() {
         key = keys[completed];
         value = collection[key];
         iterator(value, done);
       }

       function objectIteratorWithKey() {
         key = keys[completed];
         value = collection[key];
         iterator(value, key, done);
       }

       function done(err, res) {
         if (err) {
           callback(err);
           return;
         }
         if (!!res === bool) {
           result[result.length] = value;
         }
         if (++completed === size) {
           iterate = throwError;
           callback(null, result);
         } else if (sync) {
           nextTick(iterate);
         } else {
           sync = true;
           iterate();
         }
         sync = false;
       }
     };
   }

   /**
    * @private
    * @param {boolean} bool
    */
   function createFilterLimit(bool) {
     return function(collection, limit, iterator, callback) {
       callback = callback || noop;
       var size, index, key, value, keys, iter, item, iterate, result;
       var sync = false;
       var started = 0;
       var completed = 0;

       if (isArray(collection)) {
         size = collection.length;
         iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
       } else if (!collection) {
       } else if (iteratorSymbol && collection[iteratorSymbol]) {
         size = Infinity;
         result = [];
         iter = collection[iteratorSymbol]();
         iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
       } else if (typeof collection === obj) {
         keys = nativeKeys(collection);
         size = keys.length;
         iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
       }
       if (!size || isNaN(limit) || limit < 1) {
         return callback(null, []);
       }
       result = result || Array(size);
       timesSync(limit > size ? size : limit, iterate);

       function arrayIterator() {
         index = started++;
         if (index < size) {
           value = collection[index];
           iterator(value, createCallback(value, index));
         }
       }

       function arrayIteratorWithIndex() {
         index = started++;
         if (index < size) {
           value = collection[index];
           iterator(value, index, createCallback(value, index));
         }
       }

       function symbolIterator() {
         item = iter.next();
         if (item.done === false) {
           value = item.value;
           iterator(value, createCallback(value, started++));
         } else if (completed === started && iterator !== noop) {
           iterator = noop;
           callback(null, compact(result));
         }
       }

       function symbolIteratorWithKey() {
         item = iter.next();
         if (item.done === false) {
           value = item.value;
           iterator(value, started, createCallback(value, started++));
         } else if (completed === started && iterator !== noop) {
           iterator = noop;
           callback(null, compact(result));
         }
       }

       function objectIterator() {
         index = started++;
         if (index < size) {
           value = collection[keys[index]];
           iterator(value, createCallback(value, index));
         }
       }

       function objectIteratorWithKey() {
         index = started++;
         if (index < size) {
           key = keys[index];
           value = collection[key];
           iterator(value, key, createCallback(value, index));
         }
       }

       function createCallback(value, index) {
         return function(err, res) {
           if (index === null) {
             throwError();
           }
           if (err) {
             index = null;
             iterate = noop;
             callback = once(callback);
             callback(err);
             return;
           }
           if (!!res === bool) {
             result[index] = value;
           }
           index = null;
           if (++completed === size) {
             callback = onlyOnce(callback);
             callback(null, compact(result));
           } else if (sync) {
             nextTick(iterate);
           } else {
             sync = true;
             iterate();
           }
           sync = false;
         };
       }
     };
   }

   /**
    * @memberof async
    * @namespace eachSeries
    * @param {Array|Object} collection
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done();
    *   }, num * 10);
    * };
    * async.eachSeries(array, iterator, function(err, res) {
    *   console.log(res); // undefined
    *   console.log(order); // [1, 3, 2]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done();
    *   }, num * 10);
    * };
    * async.eachSeries(array, iterator, function(err, res) {
    *   console.log(res); // undefined
    *   console.log(order); // [[1, 0], [3, 1], [2, 2]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done();
    *   }, num * 10);
    * };
    * async.eachSeries(object, iterator, function(err, res) {
    *   console.log(res); // undefined
    *   console.log(order); // [1, 3, 2]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done();
    *   }, num * 10);
    * };
    * async.eachSeries(object, iterator, function(err, res) {
    *   console.log(res); // undefined
    *   console.log(order); // [[1, 'a'], [3, 'b'], [2, 'b']]
    * });
    *
    * @example
    *
    * // break
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num !== 3);
    *   }, num * 10);
    * };
    * async.eachSeries(array, iterator, function(err, res) {
    *   console.log(res); // undefined
    *   console.log(order); // [1, 3]
    * });
    */
   function eachSeries(collection, iterator, callback) {
     callback = onlyOnce(callback || noop);
     var size, key, keys, iter, item, iterate;
     var sync = false;
     var completed = 0;

     if (isArray(collection)) {
       size = collection.length;
       iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
     } else if (!collection) {
     } else if (iteratorSymbol && collection[iteratorSymbol]) {
       size = Infinity;
       iter = collection[iteratorSymbol]();
       iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
     } else if (typeof collection === obj) {
       keys = nativeKeys(collection);
       size = keys.length;
       iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
     }
     if (!size) {
       return callback(null);
     }
     iterate();

     function arrayIterator() {
       iterator(collection[completed], done);
     }

     function arrayIteratorWithIndex() {
       iterator(collection[completed], completed, done);
     }

     function symbolIterator() {
       item = iter.next();
       item.done ? callback(null) : iterator(item.value, done);
     }

     function symbolIteratorWithKey() {
       item = iter.next();
       item.done ? callback(null) : iterator(item.value, completed, done);
     }

     function objectIterator() {
       iterator(collection[keys[completed]], done);
     }

     function objectIteratorWithKey() {
       key = keys[completed];
       iterator(collection[key], key, done);
     }

     function done(err, bool) {
       if (err) {
         callback(err);
       } else if (++completed === size || bool === false) {
         iterate = throwError;
         callback(null);
       } else if (sync) {
         nextTick(iterate);
       } else {
         sync = true;
         iterate();
       }
       sync = false;
     }
   }

   /**
    * @memberof async
    * @namespace eachLimit
    * @param {Array|Object} collection
    * @param {number} limit - limit >= 1
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var array = [1, 5, 3, 4, 2];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done();
    *   }, num * 10);
    * };
    * async.eachLimit(array, 2, iterator, function(err, res) {
    *   console.log(res); // undefined
    *   console.log(order); // [1, 3, 5, 2, 4]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var array = [1, 5, 3, 4, 2];
    * var iterator = function(num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done();
    *   }, num * 10);
    * };
    * async.eachLimit(array, 2, iterator, function(err, res) {
    *   console.log(res); // undefined
    *   console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done();
    *   }, num * 10);
    * };
    * async.eachLimit(object, 2, iterator, function(err, res) {
    *   console.log(res); // undefined
    *   console.log(order); // [1, 3, 5, 2, 4]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
    * var iterator = function(num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done();
    *   }, num * 10);
    * };
    * async.eachLimit(object, 2, iterator, function(err, res) {
    *   console.log(res); // undefined
    *   console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
    * });
    *
    * @example
    *
    * // break
    * var order = [];
    * var array = [1, 5, 3, 4, 2];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num !== 5);
    *   }, num * 10);
    * };
    * async.eachLimit(array, 2, iterator, function(err, res) {
    *   console.log(res); // undefined
    *   console.log(order); // [1, 3, 5]
    * });
    *
    */
   function eachLimit(collection, limit, iterator, callback) {
     callback = callback || noop;
     var size, index, key, keys, iter, item, iterate;
     var sync = false;
     var started = 0;
     var completed = 0;

     if (isArray(collection)) {
       size = collection.length;
       iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
     } else if (!collection) {
     } else if (iteratorSymbol && collection[iteratorSymbol]) {
       size = Infinity;
       iter = collection[iteratorSymbol]();
       iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
     } else if (typeof collection === obj) {
       keys = nativeKeys(collection);
       size = keys.length;
       iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
     } else {
       return callback(null);
     }
     if (!size || isNaN(limit) || limit < 1) {
       return callback(null);
     }
     timesSync(limit > size ? size : limit, iterate);

     function arrayIterator() {
       if (started < size) {
         iterator(collection[started++], done);
       }
     }

     function arrayIteratorWithIndex() {
       index = started++;
       if (index < size) {
         iterator(collection[index], index, done);
       }
     }

     function symbolIterator() {
       item = iter.next();
       if (item.done === false) {
         started++;
         iterator(item.value, done);
       } else if (completed === started && iterator !== noop) {
         iterator = noop;
         callback(null);
       }
     }

     function symbolIteratorWithKey() {
       item = iter.next();
       if (item.done === false) {
         iterator(item.value, started++, done);
       } else if (completed === started && iterator !== noop) {
         iterator = noop;
         callback(null);
       }
     }

     function objectIterator() {
       if (started < size) {
         iterator(collection[keys[started++]], done);
       }
     }

     function objectIteratorWithKey() {
       index = started++;
       if (index < size) {
         key = keys[index];
         iterator(collection[key], key, done);
       }
     }

     function done(err, bool) {
       if (err || bool === false) {
         iterate = noop;
         callback = once(callback);
         callback(err);
       } else if (++completed === size) {
         iterator = noop;
         iterate = throwError;
         callback = onlyOnce(callback);
         callback(null);
       } else if (sync) {
         nextTick(iterate);
       } else {
         sync = true;
         iterate();
       }
       sync = false;
     }
   }

   /**
    * @memberof async
    * @namespace mapSeries
    * @param {Array|Object} collection
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num);
    *   }, num * 10);
    * };
    * async.mapSeries(array, iterator, function(err, res) {
    *   console.log(res); // [1, 3, 2];
    *   console.log(order); // [1, 3, 2]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done(null, num);
    *   }, num * 10);
    * };
    * async.mapSeries(array, iterator, function(err, res) {
    *   console.log(res); // [1, 3, 2]
    *   console.log(order); // [[1, 0], [3, 1], [2, 2]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num);
    *   }, num * 10);
    * };
    * async.mapSeries(object, iterator, function(err, res) {
    *   console.log(res); // [1, 3, 2]
    *   console.log(order); // [1, 3, 2]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done(null, num);
    *   }, num * 10);
    * };
    * async.mapSeries(object, iterator, function(err, res) {
    *   console.log(res); // [1, 3, 2]
    *   console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c']]
    * });
    *
    */
   function mapSeries(collection, iterator, callback) {
     callback = callback || noop;
     var size, key, keys, iter, item, result, iterate;
     var sync = false;
     var completed = 0;

     if (isArray(collection)) {
       size = collection.length;
       iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
     } else if (!collection) {
     } else if (iteratorSymbol && collection[iteratorSymbol]) {
       size = Infinity;
       result = [];
       iter = collection[iteratorSymbol]();
       iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
     } else if (typeof collection === obj) {
       keys = nativeKeys(collection);
       size = keys.length;
       iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
     }
     if (!size) {
       return callback(null, []);
     }
     result = result || Array(size);
     iterate();

     function arrayIterator() {
       iterator(collection[completed], done);
     }

     function arrayIteratorWithIndex() {
       iterator(collection[completed], completed, done);
     }

     function symbolIterator() {
       item = iter.next();
       item.done ? callback(null, result) : iterator(item.value, done);
     }

     function symbolIteratorWithKey() {
       item = iter.next();
       item.done ? callback(null, result) : iterator(item.value, completed, done);
     }

     function objectIterator() {
       iterator(collection[keys[completed]], done);
     }

     function objectIteratorWithKey() {
       key = keys[completed];
       iterator(collection[key], key, done);
     }

     function done(err, res) {
       if (err) {
         iterate = throwError;
         callback = onlyOnce(callback);
         callback(err, createArray(result));
         return;
       }
       result[completed] = res;
       if (++completed === size) {
         iterate = throwError;
         callback(null, result);
         callback = throwError;
       } else if (sync) {
         nextTick(iterate);
       } else {
         sync = true;
         iterate();
       }
       sync = false;
     }
   }

   /**
    * @memberof async
    * @namespace mapLimit
    * @param {Array|Object} collection
    * @param {number} limit - limit >= 1
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var array = [1, 5, 3, 4, 2];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num);
    *   }, num * 10);
    * };
    * async.mapLimit(array, 2, iterator, function(err, res) {
    *   console.log(res); // [1, 5, 3, 4, 2]
    *   console.log(order); // [1, 3, 5, 2, 4]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var array = [1, 5, 3, 4, 2];
    * var iterator = function(num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done(null, num);
    *   }, num * 10);
    * };
    * async.mapLimit(array, 2, iterator, function(err, res) {
    *   console.log(res); // [1, 5, 3, 4, 2]
    *   console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num);
    *   }, num * 10);
    * };
    * async.mapLimit(object, 2, iterator, function(err, res) {
    *   console.log(res); // [1, 5, 3, 4, 2]
    *   console.log(order); // [1, 3, 5, 2, 4]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
    * var iterator = function(num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done(null, num);
    *   }, num * 10);
    * };
    * async.mapLimit(object, 2, iterator, function(err, res) {
    *   console.log(res); // [1, 5, 3, 4, 2]
    *   console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
    * });
    *
    */
   function mapLimit(collection, limit, iterator, callback) {
     callback = callback || noop;
     var size, index, key, keys, iter, item, result, iterate;
     var sync = false;
     var started = 0;
     var completed = 0;

     if (isArray(collection)) {
       size = collection.length;
       iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
     } else if (!collection) {
     } else if (iteratorSymbol && collection[iteratorSymbol]) {
       size = Infinity;
       result = [];
       iter = collection[iteratorSymbol]();
       iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
     } else if (typeof collection === obj) {
       keys = nativeKeys(collection);
       size = keys.length;
       iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
     }
     if (!size || isNaN(limit) || limit < 1) {
       return callback(null, []);
     }
     result = result || Array(size);
     timesSync(limit > size ? size : limit, iterate);

     function arrayIterator() {
       index = started++;
       if (index < size) {
         iterator(collection[index], createCallback(index));
       }
     }

     function arrayIteratorWithIndex() {
       index = started++;
       if (index < size) {
         iterator(collection[index], index, createCallback(index));
       }
     }

     function symbolIterator() {
       item = iter.next();
       if (item.done === false) {
         iterator(item.value, createCallback(started++));
       } else if (completed === started && iterator !== noop) {
         iterator = noop;
         callback(null, result);
       }
     }

     function symbolIteratorWithKey() {
       item = iter.next();
       if (item.done === false) {
         iterator(item.value, started, createCallback(started++));
       } else if (completed === started && iterator !== noop) {
         iterator = noop;
         callback(null, result);
       }
     }

     function objectIterator() {
       index = started++;
       if (index < size) {
         iterator(collection[keys[index]], createCallback(index));
       }
     }

     function objectIteratorWithKey() {
       index = started++;
       if (index < size) {
         key = keys[index];
         iterator(collection[key], key, createCallback(index));
       }
     }

     function createCallback(index) {
       return function(err, res) {
         if (index === null) {
           throwError();
         }
         if (err) {
           index = null;
           iterate = noop;
           callback = once(callback);
           callback(err, createArray(result));
           return;
         }
         result[index] = res;
         index = null;
         if (++completed === size) {
           iterate = throwError;
           callback(null, result);
           callback = throwError;
         } else if (sync) {
           nextTick(iterate);
         } else {
           sync = true;
           iterate();
         }
         sync = false;
       };
     }
   }

   /**
    * @memberof async
    * @namespace mapValuesSeries
    * @param {Array|Object} collection
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num);
    *   }, num * 10);
    * };
    * async.mapValuesSeries(array, iterator, function(err, res) {
    *   console.log(res); // { '0': 1, '1': 3, '2': 2 }
    *   console.log(order); // [1, 3, 2]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done(null, num);
    *   }, num * 10);
    * };
    * async.mapValuesSeries(array, iterator, function(err, res) {
    *   console.log(res); // { '0': 1, '1': 3, '2': 2 }
    *   console.log(order); // [[1, 0], [3, 1], [2, 2]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num);
    *   }, num * 10);
    * };
    * async.mapValuesSeries(object, iterator, function(err, res) {
    *   console.log(res); // { a: 1, b: 3, c: 2 }
    *   console.log(order); // [1, 3, 2]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done(null, num);
    *   }, num * 10);
    * };
    * async.mapValuesSeries(object, iterator, function(err, res) {
    *   console.log(res); // { a: 1, b: 3, c: 2 }
    *   console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c']]
    * });
    *
    */
   function mapValuesSeries(collection, iterator, callback) {
     callback = callback || noop;
     var size, key, keys, iter, item, iterate;
     var sync = false;
     var result = {};
     var completed = 0;

     if (isArray(collection)) {
       size = collection.length;
       iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
     } else if (!collection) {
     } else if (iteratorSymbol && collection[iteratorSymbol]) {
       size = Infinity;
       iter = collection[iteratorSymbol]();
       iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
     } else if (typeof collection === obj) {
       keys = nativeKeys(collection);
       size = keys.length;
       iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
     }
     if (!size) {
       return callback(null, result);
     }
     iterate();

     function arrayIterator() {
       key = completed;
       iterator(collection[completed], done);
     }

     function arrayIteratorWithIndex() {
       key = completed;
       iterator(collection[completed], completed, done);
     }

     function symbolIterator() {
       key = completed;
       item = iter.next();
       item.done ? callback(null, result) : iterator(item.value, done);
     }

     function symbolIteratorWithKey() {
       key = completed;
       item = iter.next();
       item.done ? callback(null, result) : iterator(item.value, completed, done);
     }

     function objectIterator() {
       key = keys[completed];
       iterator(collection[key], done);
     }

     function objectIteratorWithKey() {
       key = keys[completed];
       iterator(collection[key], key, done);
     }

     function done(err, res) {
       if (err) {
         iterate = throwError;
         callback = onlyOnce(callback);
         callback(err, objectClone(result));
         return;
       }
       result[key] = res;
       if (++completed === size) {
         iterate = throwError;
         callback(null, result);
         callback = throwError;
       } else if (sync) {
         nextTick(iterate);
       } else {
         sync = true;
         iterate();
       }
       sync = false;
     }
   }

   /**
    * @memberof async
    * @namespace mapValuesLimit
    * @param {Array|Object} collection
    * @param {number} limit - limit >= 1
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var array = [1, 5, 3, 4, 2];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num);
    *   }, num * 10);
    * };
    * async.mapValuesLimit(array, 2, iterator, function(err, res) {
    *   console.log(res); // { '0': 1, '1': 5, '2': 3, '3': 4, '4': 2 }
    *   console.log(order); // [1, 3, 5, 2, 4]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var array = [1, 5, 3, 4, 2];
    * var iterator = function(num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done(null, num);
    *   }, num * 10);
    * };
    * async.mapValuesLimit(array, 2, iterator, function(err, res) {
    *   console.log(res); // { '0': 1, '1': 5, '2': 3, '3': 4, '4': 2 }
    *   console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num);
    *   }, num * 10);
    * };
    * async.mapValuesLimit(object, 2, iterator, function(err, res) {
    *   console.log(res); // { a: 1, b: 5, c: 3, d: 4, e: 2 }
    *   console.log(order); // [1, 3, 5, 2, 4]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
    * var iterator = function(num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done(null, num);
    *   }, num * 10);
    * };
    * async.mapValuesLimit(object, 2, iterator, function(err, res) {
    *   console.log(res); // { a: 1, b: 5, c: 3, d: 4, e: 2 }
    *   console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
    * });
    *
    */
   function mapValuesLimit(collection, limit, iterator, callback) {
     callback = callback || noop;
     var size, index, key, keys, iter, item, iterate;
     var sync = false;
     var result = {};
     var started = 0;
     var completed = 0;

     if (isArray(collection)) {
       size = collection.length;
       iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
     } else if (!collection) {
     } else if (iteratorSymbol && collection[iteratorSymbol]) {
       size = Infinity;
       iter = collection[iteratorSymbol]();
       iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
     } else if (typeof collection === obj) {
       keys = nativeKeys(collection);
       size = keys.length;
       iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
     }
     if (!size || isNaN(limit) || limit < 1) {
       return callback(null, result);
     }
     timesSync(limit > size ? size : limit, iterate);

     function arrayIterator() {
       index = started++;
       if (index < size) {
         iterator(collection[index], createCallback(index));
       }
     }

     function arrayIteratorWithIndex() {
       index = started++;
       if (index < size) {
         iterator(collection[index], index, createCallback(index));
       }
     }

     function symbolIterator() {
       item = iter.next();
       if (item.done === false) {
         iterator(item.value, createCallback(started++));
       } else if (completed === started && iterator !== noop) {
         iterator = noop;
         callback(null, result);
       }
     }

     function symbolIteratorWithKey() {
       item = iter.next();
       if (item.done === false) {
         iterator(item.value, started, createCallback(started++));
       } else if (completed === started && iterator !== noop) {
         iterator = noop;
         callback(null, result);
       }
     }

     function objectIterator() {
       index = started++;
       if (index < size) {
         key = keys[index];
         iterator(collection[key], createCallback(key));
       }
     }

     function objectIteratorWithKey() {
       index = started++;
       if (index < size) {
         key = keys[index];
         iterator(collection[key], key, createCallback(key));
       }
     }

     function createCallback(key) {
       return function(err, res) {
         if (key === null) {
           throwError();
         }
         if (err) {
           key = null;
           iterate = noop;
           callback = once(callback);
           callback(err, objectClone(result));
           return;
         }
         result[key] = res;
         key = null;
         if (++completed === size) {
           callback(null, result);
         } else if (sync) {
           nextTick(iterate);
         } else {
           sync = true;
           iterate();
         }
         sync = false;
       };
     }
   }

   /**
    * @private
    * @param {Function} arrayEach
    * @param {Function} baseEach
    * @param {Function} symbolEach
    * @param {boolean} bool
    */
   function createDetect(arrayEach, baseEach, symbolEach, bool) {
     return function(collection, iterator, callback) {
       callback = callback || noop;
       var size, keys;
       var completed = 0;

       if (isArray(collection)) {
         size = collection.length;
         arrayEach(collection, iterator, createCallback);
       } else if (!collection) {
       } else if (iteratorSymbol && collection[iteratorSymbol]) {
         size = symbolEach(collection, iterator, createCallback);
         size && size === completed && callback(null);
       } else if (typeof collection === obj) {
         keys = nativeKeys(collection);
         size = keys.length;
         baseEach(collection, iterator, createCallback, keys);
       }
       if (!size) {
         callback(null);
       }

       function createCallback(value) {
         var called = false;
         return function done(err, res) {
           if (called) {
             throwError();
           }
           called = true;
           if (err) {
             callback = once(callback);
             callback(err);
           } else if (!!res === bool) {
             callback = once(callback);
             callback(null, value);
           } else if (++completed === size) {
             callback(null);
           }
         };
       }
     };
   }

   /**
    * @private
    * @param {boolean} bool
    */
   function createDetectSeries(bool) {
     return function(collection, iterator, callback) {
       callback = onlyOnce(callback || noop);
       var size, key, value, keys, iter, item, iterate;
       var sync = false;
       var completed = 0;

       if (isArray(collection)) {
         size = collection.length;
         iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
       } else if (!collection) {
       } else if (iteratorSymbol && collection[iteratorSymbol]) {
         size = Infinity;
         iter = collection[iteratorSymbol]();
         iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
       } else if (typeof collection === obj) {
         keys = nativeKeys(collection);
         size = keys.length;
         iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
       }
       if (!size) {
         return callback(null);
       }
       iterate();

       function arrayIterator() {
         value = collection[completed];
         iterator(value, done);
       }

       function arrayIteratorWithIndex() {
         value = collection[completed];
         iterator(value, completed, done);
       }

       function symbolIterator() {
         item = iter.next();
         value = item.value;
         item.done ? callback(null) : iterator(value, done);
       }

       function symbolIteratorWithKey() {
         item = iter.next();
         value = item.value;
         item.done ? callback(null) : iterator(value, completed, done);
       }

       function objectIterator() {
         value = collection[keys[completed]];
         iterator(value, done);
       }

       function objectIteratorWithKey() {
         key = keys[completed];
         value = collection[key];
         iterator(value, key, done);
       }

       function done(err, res) {
         if (err) {
           callback(err);
         } else if (!!res === bool) {
           iterate = throwError;
           callback(null, value);
         } else if (++completed === size) {
           iterate = throwError;
           callback(null);
         } else if (sync) {
           nextTick(iterate);
         } else {
           sync = true;
           iterate();
         }
         sync = false;
       }
     };
   }

   /**
    * @private
    * @param {boolean} bool
    */
   function createDetectLimit(bool) {
     return function(collection, limit, iterator, callback) {
       callback = callback || noop;
       var size, index, key, value, keys, iter, item, iterate;
       var sync = false;
       var started = 0;
       var completed = 0;

       if (isArray(collection)) {
         size = collection.length;
         iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
       } else if (!collection) {
       } else if (iteratorSymbol && collection[iteratorSymbol]) {
         size = Infinity;
         iter = collection[iteratorSymbol]();
         iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
       } else if (typeof collection === obj) {
         keys = nativeKeys(collection);
         size = keys.length;
         iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
       }
       if (!size || isNaN(limit) || limit < 1) {
         return callback(null);
       }
       timesSync(limit > size ? size : limit, iterate);

       function arrayIterator() {
         index = started++;
         if (index < size) {
           value = collection[index];
           iterator(value, createCallback(value));
         }
       }

       function arrayIteratorWithIndex() {
         index = started++;
         if (index < size) {
           value = collection[index];
           iterator(value, index, createCallback(value));
         }
       }

       function symbolIterator() {
         item = iter.next();
         if (item.done === false) {
           started++;
           value = item.value;
           iterator(value, createCallback(value));
         } else if (completed === started && iterator !== noop) {
           iterator = noop;
           callback(null);
         }
       }

       function symbolIteratorWithKey() {
         item = iter.next();
         if (item.done === false) {
           value = item.value;
           iterator(value, started++, createCallback(value));
         } else if (completed === started && iterator !== noop) {
           iterator = noop;
           callback(null);
         }
       }

       function objectIterator() {
         index = started++;
         if (index < size) {
           value = collection[keys[index]];
           iterator(value, createCallback(value));
         }
       }

       function objectIteratorWithKey() {
         if (started < size) {
           key = keys[started++];
           value = collection[key];
           iterator(value, key, createCallback(value));
         }
       }

       function createCallback(value) {
         var called = false;
         return function(err, res) {
           if (called) {
             throwError();
           }
           called = true;
           if (err) {
             iterate = noop;
             callback = once(callback);
             callback(err);
           } else if (!!res === bool) {
             iterate = noop;
             callback = once(callback);
             callback(null, value);
           } else if (++completed === size) {
             callback(null);
           } else if (sync) {
             nextTick(iterate);
           } else {
             sync = true;
             iterate();
           }
           sync = false;
         };
       }
     };
   }

   /**
    * @private
    * @param {Function} arrayEach
    * @param {Function} baseEach
    * @param {Function} symbolEach
    * @param {boolean} bool
    */
   function createPick(arrayEach, baseEach, symbolEach, bool) {
     return function(collection, iterator, callback) {
       callback = callback || noop;
       var size, keys;
       var completed = 0;
       var result = {};

       if (isArray(collection)) {
         size = collection.length;
         arrayEach(collection, iterator, createCallback);
       } else if (!collection) {
       } else if (iteratorSymbol && collection[iteratorSymbol]) {
         size = symbolEach(collection, iterator, createCallback);
         size && size === completed && callback(null, result);
       } else if (typeof collection === obj) {
         keys = nativeKeys(collection);
         size = keys.length;
         baseEach(collection, iterator, createCallback, keys);
       }
       if (!size) {
         return callback(null, {});
       }

       function createCallback(key, value) {
         return function done(err, res) {
           if (key === null) {
             throwError();
           }
           if (err) {
             key = null;
             callback = once(callback);
             callback(err, objectClone(result));
             return;
           }
           if (!!res === bool) {
             result[key] = value;
           }
           key = null;
           if (++completed === size) {
             callback(null, result);
           }
         };
       }
     };
   }

   /**
    * @private
    * @param {boolean} bool
    */
   function createPickSeries(bool) {
     return function(collection, iterator, callback) {
       callback = onlyOnce(callback || noop);
       var size, key, value, keys, iter, item, iterate;
       var sync = false;
       var result = {};
       var completed = 0;

       if (isArray(collection)) {
         size = collection.length;
         iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
       } else if (!collection) {
       } else if (iteratorSymbol && collection[iteratorSymbol]) {
         size = Infinity;
         iter = collection[iteratorSymbol]();
         iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
       } else if (typeof collection === obj) {
         keys = nativeKeys(collection);
         size = keys.length;
         iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
       }
       if (!size) {
         return callback(null, {});
       }
       iterate();

       function arrayIterator() {
         key = completed;
         value = collection[completed];
         iterator(value, done);
       }

       function arrayIteratorWithIndex() {
         key = completed;
         value = collection[completed];
         iterator(value, completed, done);
       }

       function symbolIterator() {
         key = completed;
         item = iter.next();
         value = item.value;
         item.done ? callback(null, result) : iterator(value, done);
       }

       function symbolIteratorWithKey() {
         key = completed;
         item = iter.next();
         value = item.value;
         item.done ? callback(null, result) : iterator(value, key, done);
       }

       function objectIterator() {
         key = keys[completed];
         value = collection[key];
         iterator(value, done);
       }

       function objectIteratorWithKey() {
         key = keys[completed];
         value = collection[key];
         iterator(value, key, done);
       }

       function done(err, res) {
         if (err) {
           callback(err, result);
           return;
         }
         if (!!res === bool) {
           result[key] = value;
         }
         if (++completed === size) {
           iterate = throwError;
           callback(null, result);
         } else if (sync) {
           nextTick(iterate);
         } else {
           sync = true;
           iterate();
         }
         sync = false;
       }
     };
   }

   /**
    * @private
    * @param {boolean} bool
    */
   function createPickLimit(bool) {
     return function(collection, limit, iterator, callback) {
       callback = callback || noop;
       var size, index, key, value, keys, iter, item, iterate;
       var sync = false;
       var result = {};
       var started = 0;
       var completed = 0;

       if (isArray(collection)) {
         size = collection.length;
         iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
       } else if (!collection) {
       } else if (iteratorSymbol && collection[iteratorSymbol]) {
         size = Infinity;
         iter = collection[iteratorSymbol]();
         iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
       } else if (typeof collection === obj) {
         keys = nativeKeys(collection);
         size = keys.length;
         iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
       }
       if (!size || isNaN(limit) || limit < 1) {
         return callback(null, {});
       }
       timesSync(limit > size ? size : limit, iterate);

       function arrayIterator() {
         index = started++;
         if (index < size) {
           value = collection[index];
           iterator(value, createCallback(value, index));
         }
       }

       function arrayIteratorWithIndex() {
         index = started++;
         if (index < size) {
           value = collection[index];
           iterator(value, index, createCallback(value, index));
         }
       }

       function symbolIterator() {
         item = iter.next();
         if (item.done === false) {
           value = item.value;
           iterator(value, createCallback(value, started++));
         } else if (completed === started && iterator !== noop) {
           iterator = noop;
           callback(null, result);
         }
       }

       function symbolIteratorWithKey() {
         item = iter.next();
         if (item.done === false) {
           value = item.value;
           iterator(value, started, createCallback(value, started++));
         } else if (completed === started && iterator !== noop) {
           iterator = noop;
           callback(null, result);
         }
       }

       function objectIterator() {
         if (started < size) {
           key = keys[started++];
           value = collection[key];
           iterator(value, createCallback(value, key));
         }
       }

       function objectIteratorWithKey() {
         if (started < size) {
           key = keys[started++];
           value = collection[key];
           iterator(value, key, createCallback(value, key));
         }
       }

       function createCallback(value, key) {
         return function(err, res) {
           if (key === null) {
             throwError();
           }
           if (err) {
             key = null;
             iterate = noop;
             callback = once(callback);
             callback(err, objectClone(result));
             return;
           }
           if (!!res === bool) {
             result[key] = value;
           }
           key = null;
           if (++completed === size) {
             iterate = throwError;
             callback = onlyOnce(callback);
             callback(null, result);
           } else if (sync) {
             nextTick(iterate);
           } else {
             sync = true;
             iterate();
           }
           sync = false;
         };
       }
     };
   }

   /**
    * @memberof async
    * @namespace reduce
    * @param {Array|Object} collection
    * @param {*} result
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var collection = [1, 3, 2, 4];
    * var iterator = function(result, num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, result + num);
    *   }, num * 10);
    * };
    * async.reduce(collection, 0, iterator, function(err, res) {
    *   console.log(res); // 10
    *   console.log(order); // [1, 3, 2, 4]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var collection = [1, 3, 2, 4];
    * var iterator = function(result, num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done(null, result + num);
    *   }, num * 10);
    * };
    * async.reduce(collection, '', iterator, function(err, res) {
    *   console.log(res); // '1324'
    *   console.log(order); // [[1, 0], [3, 1], [2, 2], [4, 3]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 1, b: 3, c: 2, d: 4 };
    * var iterator = function(result, num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, result + num);
    *   }, num * 10);
    * };
    * async.reduce(collection, '', iterator, function(err, res) {
    *   console.log(res); // '1324'
    *   console.log(order); // [1, 3, 2, 4]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 3, c: 2, d: 4 };
    * var iterator = function(result, num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done(null, result + num);
    *   }, num * 10);
    * };
    * async.reduce(collection, 0, iterator, function(err, res) {
    *   console.log(res); // 10
    *   console.log(order); // [[1, 'a'], [3, 'b'], [2, 'b'], [4, 'd']]
    * });
    *
    */
   function reduce(collection, result, iterator, callback) {
     callback = onlyOnce(callback || noop);
     var size, key, keys, iter, item, iterate;
     var sync = false;
     var completed = 0;

     if (isArray(collection)) {
       size = collection.length;
       iterate = iterator.length === 4 ? arrayIteratorWithIndex : arrayIterator;
     } else if (!collection) {
     } else if (iteratorSymbol && collection[iteratorSymbol]) {
       size = Infinity;
       iter = collection[iteratorSymbol]();
       iterate = iterator.length === 4 ? symbolIteratorWithKey : symbolIterator;
     } else if (typeof collection === obj) {
       keys = nativeKeys(collection);
       size = keys.length;
       iterate = iterator.length === 4 ? objectIteratorWithKey : objectIterator;
     }
     if (!size) {
       return callback(null, result);
     }
     iterate(result);

     function arrayIterator(result) {
       iterator(result, collection[completed], done);
     }

     function arrayIteratorWithIndex(result) {
       iterator(result, collection[completed], completed, done);
     }

     function symbolIterator(result) {
       item = iter.next();
       item.done ? callback(null, result) : iterator(result, item.value, done);
     }

     function symbolIteratorWithKey(result) {
       item = iter.next();
       item.done ? callback(null, result) : iterator(result, item.value, completed, done);
     }

     function objectIterator(result) {
       iterator(result, collection[keys[completed]], done);
     }

     function objectIteratorWithKey(result) {
       key = keys[completed];
       iterator(result, collection[key], key, done);
     }

     function done(err, result) {
       if (err) {
         callback(err, result);
       } else if (++completed === size) {
         iterator = throwError;
         callback(null, result);
       } else if (sync) {
         nextTick(function() {
           iterate(result);
         });
       } else {
         sync = true;
         iterate(result);
       }
       sync = false;
     }
   }

   /**
    * @memberof async
    * @namespace reduceRight
    * @param {Array|Object} collection
    * @param {*} result
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var collection = [1, 3, 2, 4];
    * var iterator = function(result, num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, result + num);
    *   }, num * 10);
    * };
    * async.reduceRight(collection, 0, iterator, function(err, res) {
    *   console.log(res); // 10
    *   console.log(order); // [4, 2, 3, 1]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var collection = [1, 3, 2, 4];
    * var iterator = function(result, num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done(null, result + num);
    *   }, num * 10);
    * };
    * async.reduceRight(collection, '', iterator, function(err, res) {
    *   console.log(res); // '4231'
    *   console.log(order); // [[4, 3], [2, 2], [3, 1], [1, 0]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 1, b: 3, c: 2, d: 4 };
    * var iterator = function(result, num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, result + num);
    *   }, num * 10);
    * };
    * async.reduceRight(collection, '', iterator, function(err, res) {
    *   console.log(res); // '4231'
    *   console.log(order); // [4, 2, 3, 1]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 3, c: 2, d: 4 };
    * var iterator = function(result, num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done(null, result + num);
    *   }, num * 10);
    * };
    * async.reduceRight(collection, 0, iterator, function(err, res) {
    *   console.log(res); // 10
    *   console.log(order); // [[4, 3], [2, 2], [3, 1], [1, 0]]
    * });
    *
    */
   function reduceRight(collection, result, iterator, callback) {
     callback = onlyOnce(callback || noop);
     var resIndex, index, key, keys, iter, item, col, iterate;
     var sync = false;

     if (isArray(collection)) {
       resIndex = collection.length;
       iterate = iterator.length === 4 ? arrayIteratorWithIndex : arrayIterator;
     } else if (!collection) {
     } else if (iteratorSymbol && collection[iteratorSymbol]) {
       col = [];
       iter = collection[iteratorSymbol]();
       index = -1;
       while ((item = iter.next()).done === false) {
         col[++index] = item.value;
       }
       collection = col;
       resIndex = col.length;
       iterate = iterator.length === 4 ? arrayIteratorWithIndex : arrayIterator;
     } else if (typeof collection === obj) {
       keys = nativeKeys(collection);
       resIndex = keys.length;
       iterate = iterator.length === 4 ? objectIteratorWithKey : objectIterator;
     }
     if (!resIndex) {
       return callback(null, result);
     }
     iterate(result);

     function arrayIterator(result) {
       iterator(result, collection[--resIndex], done);
     }

     function arrayIteratorWithIndex(result) {
       iterator(result, collection[--resIndex], resIndex, done);
     }

     function objectIterator(result) {
       iterator(result, collection[keys[--resIndex]], done);
     }

     function objectIteratorWithKey(result) {
       key = keys[--resIndex];
       iterator(result, collection[key], key, done);
     }

     function done(err, result) {
       if (err) {
         callback(err, result);
       } else if (resIndex === 0) {
         iterate = throwError;
         callback(null, result);
       } else if (sync) {
         nextTick(function() {
           iterate(result);
         });
       } else {
         sync = true;
         iterate(result);
       }
       sync = false;
     }
   }

   /**
    * @private
    * @param {Function} arrayEach
    * @param {Function} baseEach
    * @param {Function} symbolEach
    */
   function createTransform(arrayEach, baseEach, symbolEach) {
     return function transform(collection, accumulator, iterator, callback) {
       if (arguments.length === 3) {
         callback = iterator;
         iterator = accumulator;
         accumulator = undefined;
       }
       callback = callback || noop;
       var size, keys, result;
       var completed = 0;

       if (isArray(collection)) {
         size = collection.length;
         result = accumulator !== undefined ? accumulator : [];
         arrayEach(collection, result, iterator, done);
       } else if (!collection) {
       } else if (iteratorSymbol && collection[iteratorSymbol]) {
         result = accumulator !== undefined ? accumulator : {};
         size = symbolEach(collection, result, iterator, done);
         size && size === completed && callback(null, result);
       } else if (typeof collection === obj) {
         keys = nativeKeys(collection);
         size = keys.length;
         result = accumulator !== undefined ? accumulator : {};
         baseEach(collection, result, iterator, done, keys);
       }
       if (!size) {
         callback(null, accumulator !== undefined ? accumulator : result || {});
       }

       function done(err, bool) {
         if (err) {
           callback = once(callback);
           callback(err, isArray(result) ? createArray(result) : objectClone(result));
         } else if (++completed === size) {
           callback(null, result);
         } else if (bool === false) {
           callback = once(callback);
           callback(null, isArray(result) ? createArray(result) : objectClone(result));
         }
       }
     };
   }

   /**
    * @memberof async
    * @namespace transformSeries
    * @param {Array|Object} collection
    * @param {Array|Object|Function} [accumulator]
    * @param {Function} [iterator]
    * @param {Function} [callback]
    * @example
    *
    * // array
    * var order = [];
    * var collection = [1, 3, 2, 4];
    * var iterator = function(result, num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     result.push(num)
    *     done();
    *   }, num * 10);
    * };
    * async.transformSeries(collection, iterator, function(err, res) {
    *   console.log(res); // [1, 3, 2, 4]
    *   console.log(order); // [1, 3, 2, 4]
    * });
    *
    * @example
    *
    * // array with index and accumulator
    * var order = [];
    * var collection = [1, 3, 2, 4];
    * var iterator = function(result, num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     result[index] = num;
    *     done();
    *   }, num * 10);
    * };
    * async.transformSeries(collection, {}, iterator, function(err, res) {
    *   console.log(res); // { '0': 1, '1': 3, '2': 2, '3': 4 }
    *   console.log(order); // [[1, 0], [3, 1], [2, 2], [4, 3]]
    * });
    *
    * @example
    *
    * // object with accumulator
    * var order = [];
    * var object = { a: 1, b: 3, c: 2, d: 4 };
    * var iterator = function(result, num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     result.push(num);
    *     done();
    *   }, num * 10);
    * };
    * async.transformSeries(collection, [], iterator, function(err, res) {
    *   console.log(res); // [1, 3, 2, 4]
    *   console.log(order); // [1, 3, 2, 4]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 3, c: 2, d: 4 };
    * var iterator = function(result, num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     result[key] = num;
    *     done();
    *   }, num * 10);
    * };
    * async.transformSeries(collection, iterator, function(err, res) {
    *   console.log(res); //  { a: 1, b: 3, c: 2, d: 4 }
    *   console.log(order); // [[1, 'a'], [3, 'b'], [2, 'b'], [4, 'd']]
    * });
    *
    */
   function transformSeries(collection, accumulator, iterator, callback) {
     if (arguments.length === 3) {
       callback = iterator;
       iterator = accumulator;
       accumulator = undefined;
     }
     callback = onlyOnce(callback || noop);
     var size, key, keys, iter, item, iterate, result;
     var sync = false;
     var completed = 0;

     if (isArray(collection)) {
       size = collection.length;
       result = accumulator !== undefined ? accumulator : [];
       iterate = iterator.length === 4 ? arrayIteratorWithIndex : arrayIterator;
     } else if (!collection) {
     } else if (iteratorSymbol && collection[iteratorSymbol]) {
       size = Infinity;
       iter = collection[iteratorSymbol]();
       result = accumulator !== undefined ? accumulator : {};
       iterate = iterator.length === 4 ? symbolIteratorWithKey : symbolIterator;
     } else if (typeof collection === obj) {
       keys = nativeKeys(collection);
       size = keys.length;
       result = accumulator !== undefined ? accumulator : {};
       iterate = iterator.length === 4 ? objectIteratorWithKey : objectIterator;
     }
     if (!size) {
       return callback(null, accumulator !== undefined ? accumulator : result || {});
     }
     iterate();

     function arrayIterator() {
       iterator(result, collection[completed], done);
     }

     function arrayIteratorWithIndex() {
       iterator(result, collection[completed], completed, done);
     }

     function symbolIterator() {
       item = iter.next();
       item.done ? callback(null, result) : iterator(result, item.value, done);
     }

     function symbolIteratorWithKey() {
       item = iter.next();
       item.done ? callback(null, result) : iterator(result, item.value, completed, done);
     }

     function objectIterator() {
       iterator(result, collection[keys[completed]], done);
     }

     function objectIteratorWithKey() {
       key = keys[completed];
       iterator(result, collection[key], key, done);
     }

     function done(err, bool) {
       if (err) {
         callback(err, result);
       } else if (++completed === size || bool === false) {
         iterate = throwError;
         callback(null, result);
       } else if (sync) {
         nextTick(iterate);
       } else {
         sync = true;
         iterate();
       }
       sync = false;
     }
   }

   /**
    * @memberof async
    * @namespace transformLimit
    * @param {Array|Object} collection
    * @param {number} limit - limit >= 1
    * @param {Array|Object|Function} [accumulator]
    * @param {Function} [iterator]
    * @param {Function} [callback]
    * @example
    *
    * // array
    * var order = [];
    * var array = [1, 5, 3, 4, 2];
    * var iterator = function(result, num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     result.push(num);
    *     done();
    *   }, num * 10);
    * };
    * async.transformLimit(array, 2, iterator, function(err, res) {
    *   console.log(res); // [1, 3, 5, 2, 4]
    *   console.log(order); // [1, 3, 5, 2, 4]
    * });
    *
    * @example
    *
    * // array with index and accumulator
    * var order = [];
    * var array = [1, 5, 3, 4, 2];
    * var iterator = function(result, num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     result[index] = key;
    *     done();
    *   }, num * 10);
    * };
    * async.transformLimit(array, 2, {}, iterator, function(err, res) {
    *   console.log(res); // { '0': 1, '1': 5, '2': 3, '3': 4, '4': 2 }
    *   console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
    * });
    *
    * @example
    *
    * // object with accumulator
    * var order = [];
    * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
    * var iterator = function(result, num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     result.push(num);
    *     done();
    *   }, num * 10);
    * };
    * async.transformLimit(object, 2, [], iterator, function(err, res) {
    *   console.log(res); // [1, 3, 5, 2, 4]
    *   console.log(order); // [1, 3, 5, 2, 4]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
    * var iterator = function(result, num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     result[key] = num;
    *     done();
    *   }, num * 10);
    * };
    * async.transformLimit(object, 2, iterator, function(err, res) {
    *   console.log(res); // { a: 1, b: 5, c: 3, d: 4, e: 2 };
    *   console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
    * });
    *
    */
   function transformLimit(collection, limit, accumulator, iterator, callback) {
     if (arguments.length === 4) {
       callback = iterator;
       iterator = accumulator;
       accumulator = undefined;
     }
     callback = callback || noop;
     var size, index, key, keys, iter, item, iterate, result;
     var sync = false;
     var started = 0;
     var completed = 0;

     if (isArray(collection)) {
       size = collection.length;
       result = accumulator !== undefined ? accumulator : [];
       iterate = iterator.length === 4 ? arrayIteratorWithIndex : arrayIterator;
     } else if (!collection) {
     } else if (iteratorSymbol && collection[iteratorSymbol]) {
       size = Infinity;
       iter = collection[iteratorSymbol]();
       result = accumulator !== undefined ? accumulator : {};
       iterate = iterator.length === 4 ? symbolIteratorWithKey : symbolIterator;
     } else if (typeof collection === obj) {
       keys = nativeKeys(collection);
       size = keys.length;
       result = accumulator !== undefined ? accumulator : {};
       iterate = iterator.length === 4 ? objectIteratorWithKey : objectIterator;
     }
     if (!size || isNaN(limit) || limit < 1) {
       return callback(null, accumulator !== undefined ? accumulator : result || {});
     }
     timesSync(limit > size ? size : limit, iterate);

     function arrayIterator() {
       index = started++;
       if (index < size) {
         iterator(result, collection[index], onlyOnce(done));
       }
     }

     function arrayIteratorWithIndex() {
       index = started++;
       if (index < size) {
         iterator(result, collection[index], index, onlyOnce(done));
       }
     }

     function symbolIterator() {
       item = iter.next();
       if (item.done === false) {
         started++;
         iterator(result, item.value, onlyOnce(done));
       } else if (completed === started && iterator !== noop) {
         iterator = noop;
         callback(null, result);
       }
     }

     function symbolIteratorWithKey() {
       item = iter.next();
       if (item.done === false) {
         iterator(result, item.value, started++, onlyOnce(done));
       } else if (completed === started && iterator !== noop) {
         iterator = noop;
         callback(null, result);
       }
     }

     function objectIterator() {
       index = started++;
       if (index < size) {
         iterator(result, collection[keys[index]], onlyOnce(done));
       }
     }

     function objectIteratorWithKey() {
       index = started++;
       if (index < size) {
         key = keys[index];
         iterator(result, collection[key], key, onlyOnce(done));
       }
     }

     function done(err, bool) {
       if (err || bool === false) {
         iterate = noop;
         callback(err || null, isArray(result) ? createArray(result) : objectClone(result));
         callback = noop;
       } else if (++completed === size) {
         iterator = noop;
         callback(null, result);
       } else if (sync) {
         nextTick(iterate);
       } else {
         sync = true;
         iterate();
       }
       sync = false;
     }
   }

   /**
    * @private
    * @param {function} arrayEach
    * @param {function} baseEach
    * @param {function} symbolEach
    */
   function createSortBy(arrayEach, baseEach, symbolEach) {
     return function sortBy(collection, iterator, callback) {
       callback = callback || noop;
       var size, array, criteria;
       var completed = 0;

       if (isArray(collection)) {
         size = collection.length;
         array = Array(size);
         criteria = Array(size);
         arrayEach(collection, iterator, createCallback);
       } else if (!collection) {
       } else if (iteratorSymbol && collection[iteratorSymbol]) {
         array = [];
         criteria = [];
         size = symbolEach(collection, iterator, createCallback);
         size && size === completed && callback(null, sortByCriteria(array, criteria));
       } else if (typeof collection === obj) {
         var keys = nativeKeys(collection);
         size = keys.length;
         array = Array(size);
         criteria = Array(size);
         baseEach(collection, iterator, createCallback, keys);
       }
       if (!size) {
         callback(null, []);
       }

       function createCallback(index, value) {
         var called = false;
         array[index] = value;
         return function done(err, criterion) {
           if (called) {
             throwError();
           }
           called = true;
           criteria[index] = criterion;
           if (err) {
             callback = once(callback);
             callback(err);
           } else if (++completed === size) {
             callback(null, sortByCriteria(array, criteria));
           }
         };
       }
     };
   }

   /**
    * @memberof async
    * @namespace sortBySeries
    * @param {Array|Object} collection
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num);
    *   }, num * 10);
    * };
    * async.sortBySeries(array, iterator, function(err, res) {
    *   console.log(res); // [1, 2, 3];
    *   console.log(order); // [1, 3, 2]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done(null, num);
    *   }, num * 10);
    * };
    * async.sortBySeries(array, iterator, function(err, res) {
    *   console.log(res); // [1, 2, 3]
    *   console.log(order); // [[1, 0], [3, 1], [2, 2]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num);
    *   }, num * 10);
    * };
    * async.sortBySeries(object, iterator, function(err, res) {
    *   console.log(res); // [1, 2, 3]
    *   console.log(order); // [1, 3, 2]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done(null, num);
    *   }, num * 10);
    * };
    * async.sortBySeries(object, iterator, function(err, res) {
    *   console.log(res); // [1, 2, 3]
    *   console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c']]
    * });
    *
    */
   function sortBySeries(collection, iterator, callback) {
     callback = onlyOnce(callback || noop);
     var size, key, value, keys, iter, item, array, criteria, iterate;
     var sync = false;
     var completed = 0;

     if (isArray(collection)) {
       size = collection.length;
       array = collection;
       criteria = Array(size);
       iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
     } else if (!collection) {
     } else if (iteratorSymbol && collection[iteratorSymbol]) {
       size = Infinity;
       array = [];
       criteria = [];
       iter = collection[iteratorSymbol]();
       iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
     } else if (typeof collection === obj) {
       keys = nativeKeys(collection);
       size = keys.length;
       array = Array(size);
       criteria = Array(size);
       iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
     }
     if (!size) {
       return callback(null, []);
     }
     iterate();

     function arrayIterator() {
       value = collection[completed];
       iterator(value, done);
     }

     function arrayIteratorWithIndex() {
       value = collection[completed];
       iterator(value, completed, done);
     }

     function symbolIterator() {
       item = iter.next();
       if (item.done) {
         return callback(null, sortByCriteria(array, criteria));
       }
       value = item.value;
       array[completed] = value;
       iterator(value, done);
     }

     function symbolIteratorWithKey() {
       item = iter.next();
       if (item.done) {
         return callback(null, sortByCriteria(array, criteria));
       }
       value = item.value;
       array[completed] = value;
       iterator(value, completed, done);
     }

     function objectIterator() {
       value = collection[keys[completed]];
       array[completed] = value;
       iterator(value, done);
     }

     function objectIteratorWithKey() {
       key = keys[completed];
       value = collection[key];
       array[completed] = value;
       iterator(value, key, done);
     }

     function done(err, criterion) {
       criteria[completed] = criterion;
       if (err) {
         callback(err);
       } else if (++completed === size) {
         iterate = throwError;
         callback(null, sortByCriteria(array, criteria));
       } else if (sync) {
         nextTick(iterate);
       } else {
         sync = true;
         iterate();
       }
       sync = false;
     }
   }

   /**
    * @memberof async
    * @namespace sortByLimit
    * @param {Array|Object} collection
    * @param {number} limit - limit >= 1
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var array = [1, 5, 3, 4, 2];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num);
    *   }, num * 10);
    * };
    * async.sortByLimit(array, 2, iterator, function(err, res) {
    *   console.log(res); // [1, 2, 3, 4, 5]
    *   console.log(order); // [1, 3, 5, 2, 4]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var array = [1, 5, 3, 4, 2];
    * var iterator = function(num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done(null, num);
    *   }, num * 10);
    * };
    * async.sortByLimit(array, 2, iterator, function(err, res) {
    *   console.log(res); // [1, 2, 3, 4, 5]
    *   console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num);
    *   }, num * 10);
    * };
    * async.sortByLimit(object, 2, iterator, function(err, res) {
    *   console.log(res); // [1, 2, 3, 4, 5]
    *   console.log(order); // [1, 3, 5, 2, 4]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
    * var iterator = function(num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done(null, num);
    *   }, num * 10);
    * };
    * async.sortByLimit(object, 2, iterator, function(err, res) {
    *   console.log(res); // [1, 2, 3, 4, 5]
    *   console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
    * });
    *
    */
   function sortByLimit(collection, limit, iterator, callback) {
     callback = callback || noop;
     var size, index, key, value, array, keys, iter, item, criteria, iterate;
     var sync = false;
     var started = 0;
     var completed = 0;

     if (isArray(collection)) {
       size = collection.length;
       array = collection;
       iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
     } else if (!collection) {
     } else if (iteratorSymbol && collection[iteratorSymbol]) {
       size = Infinity;
       iter = collection[iteratorSymbol]();
       array = [];
       criteria = [];
       iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
     } else if (typeof collection === obj) {
       keys = nativeKeys(collection);
       size = keys.length;
       array = Array(size);
       iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
     }
     if (!size || isNaN(limit) || limit < 1) {
       return callback(null, []);
     }
     criteria = criteria || Array(size);
     timesSync(limit > size ? size : limit, iterate);

     function arrayIterator() {
       if (started < size) {
         value = collection[started];
         iterator(value, createCallback(value, started++));
       }
     }

     function arrayIteratorWithIndex() {
       index = started++;
       if (index < size) {
         value = collection[index];
         iterator(value, index, createCallback(value, index));
       }
     }

     function symbolIterator() {
       item = iter.next();
       if (item.done === false) {
         value = item.value;
         array[started] = value;
         iterator(value, createCallback(value, started++));
       } else if (completed === started && iterator !== noop) {
         iterator = noop;
         callback(null, sortByCriteria(array, criteria));
       }
     }

     function symbolIteratorWithKey() {
       item = iter.next();
       if (item.done === false) {
         value = item.value;
         array[started] = value;
         iterator(value, started, createCallback(value, started++));
       } else if (completed === started && iterator !== noop) {
         iterator = noop;
         callback(null, sortByCriteria(array, criteria));
       }
     }

     function objectIterator() {
       if (started < size) {
         value = collection[keys[started]];
         array[started] = value;
         iterator(value, createCallback(value, started++));
       }
     }

     function objectIteratorWithKey() {
       if (started < size) {
         key = keys[started];
         value = collection[key];
         array[started] = value;
         iterator(value, key, createCallback(value, started++));
       }
     }

     function createCallback(value, index) {
       var called = false;
       return function(err, criterion) {
         if (called) {
           throwError();
         }
         called = true;
         criteria[index] = criterion;
         if (err) {
           iterate = noop;
           callback(err);
           callback = noop;
         } else if (++completed === size) {
           callback(null, sortByCriteria(array, criteria));
         } else if (sync) {
           nextTick(iterate);
         } else {
           sync = true;
           iterate();
         }
         sync = false;
       };
     }
   }

   /**
    * @memberof async
    * @namespace some
    * @param {Array|Object} collection
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.some(array, iterator, function(err, res) {
    *   console.log(res); // true
    *   console.log(order); // [1]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.some(array, iterator, function(err, res) {
    *   console.log(res); // true
    *   console.log(order); // [[1, 0]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.some(object, iterator, function(err, res) {
    *   console.log(res); // true
    *   console.log(order); // [1]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.some(object, iterator, function(err, res) {
    *   console.log(res); // true
    *   console.log(order); // [[1, 'a']]
    * });
    *
    */
   function some(collection, iterator, callback) {
     callback = callback || noop;
     detect(collection, iterator, done);

     function done(err, res) {
       if (err) {
         return callback(err);
       }
       callback(null, !!res);
     }
   }

   /**
    * @memberof async
    * @namespace someSeries
    * @param {Array|Object} collection
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.someSeries(array, iterator, function(err, res) {
    *   console.log(res); // true
    *   console.log(order); // [1]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.someSeries(array, iterator, function(err, res) {
    *   console.log(res); // true
    *   console.log(order); // [[1, 0]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.someSeries(object, iterator, function(err, res) {
    *   console.log(res); // true
    *   console.log(order); // [1]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.someSeries(object, iterator, function(err, res) {
    *   console.log(res); // true
    *   console.log(order); // [[1, 'a']]
    * });
    *
    */
   function someSeries(collection, iterator, callback) {
     callback = callback || noop;
     detectSeries(collection, iterator, done);

     function done(err, res) {
       if (err) {
         return callback(err);
       }
       callback(null, !!res);
     }
   }

   /**
    * @memberof async
    * @namespace someLimit
    * @param {Array|Object} collection
    * @param {number} limit - limit >= 1
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var array = [1, 5, 3, 4, 2];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.someLimit(array, 2, iterator, function(err, res) {
    *   console.log(res); // true
    *   console.log(order); // [1]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var array = [1, 5, 3, 4, 2];
    * var iterator = function(num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.someLimit(array, 2, iterator, function(err, res) {
    *   console.log(res); // true
    *   console.log(order); // [[1, 0]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.someLimit(object, 2, iterator, function(err, res) {
    *   console.log(res); // true
    *   console.log(order); // [1]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
    * var iterator = function(num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done(null, num % 2);
    *   }, num * 10);
    * };
    * async.someLimit(object, 2, iterator, function(err, res) {
    *   console.log(res); // true
    *   console.log(order); // [[1, 'a']]
    * });
    *
    */
   function someLimit(collection, limit, iterator, callback) {
     callback = callback || noop;
     detectLimit(collection, limit, iterator, done);

     function done(err, res) {
       if (err) {
         return callback(err);
       }
       callback(null, !!res);
     }
   }

   /**
    * @private
    * @param {Function} arrayEach
    * @param {Function} baseEach
    * @param {Function} symbolEach
    */
   function createEvery(arrayEach, baseEach, symbolEach) {
     var deny = createDetect(arrayEach, baseEach, symbolEach, false);

     return function every(collection, iterator, callback) {
       callback = callback || noop;
       deny(collection, iterator, done);

       function done(err, res) {
         if (err) {
           return callback(err);
         }
         callback(null, !res);
       }
     };
   }

   /**
    * @private
    */
   function createEverySeries() {
     var denySeries = createDetectSeries(false);

     return function everySeries(collection, iterator, callback) {
       callback = callback || noop;
       denySeries(collection, iterator, done);

       function done(err, res) {
         if (err) {
           return callback(err);
         }
         callback(null, !res);
       }
     };
   }

   /**
    * @private
    */
   function createEveryLimit() {
     var denyLimit = createDetectLimit(false);

     return function everyLimit(collection, limit, iterator, callback) {
       callback = callback || noop;
       denyLimit(collection, limit, iterator, done);

       function done(err, res) {
         if (err) {
           return callback(err);
         }
         callback(null, !res);
       }
     };
   }

   /**
    * @private
    * @param {Function} arrayEach
    * @param {Function} baseEach
    * @param {Function} symbolEach
    */
   function createConcat(arrayEach, baseEach, symbolEach) {
     return function concat(collection, iterator, callback) {
       callback = callback || noop;
       var size, result;
       var completed = 0;

       if (isArray(collection)) {
         size = collection.length;
         result = Array(size);
         arrayEach(collection, iterator, createCallback);
       } else if (!collection) {
       } else if (iteratorSymbol && collection[iteratorSymbol]) {
         result = [];
         size = symbolEach(collection, iterator, createCallback);
         size && size === completed && callback(null, result);
       } else if (typeof collection === obj) {
         var keys = nativeKeys(collection);
         size = keys.length;
         result = Array(size);
         baseEach(collection, iterator, createCallback, keys);
       }
       if (!size) {
         callback(null, []);
       }

       function createCallback(index) {
         return function done(err, res) {
           if (index === null) {
             throwError();
           }
           if (err) {
             index = null;
             callback = once(callback);
             arrayEachSync(result, function(array, index) {
               if (array === undefined) {
                 result[index] = noop;
               }
             });
             callback(err, makeConcatResult(result));
             return;
           }
           switch (arguments.length) {
             case 0:
             case 1:
               result[index] = noop;
               break;
             case 2:
               result[index] = res;
               break;
             default:
               result[index] = slice(arguments, 1);
               break;
           }
           index = null;
           if (++completed === size) {
             callback(null, makeConcatResult(result));
           }
         };
       }
     };
   }

   /**
    * @memberof async
    * @namespace concatSeries
    * @param {Array|Object} collection
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, [num]);
    *   }, num * 10);
    * };
    * async.concatSeries(array, iterator, function(err, res) {
    *   console.log(res); // [1, 3, 2];
    *   console.log(order); // [1, 3, 2]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var array = [1, 3, 2];
    * var iterator = function(num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done(null, [num]);
    *   }, num * 10);
    * };
    * async.concatSeries(array, iterator, function(err, res) {
    *   console.log(res); // [1, 3, 2]
    *   console.log(order); // [[1, 0], [3, 1], [2, 2]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, [num]);
    *   }, num * 10);
    * };
    * async.concatSeries(object, iterator, function(err, res) {
    *   console.log(res); // [1, 3, 2]
    *   console.log(order); // [1, 3, 2]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 3, c: 2 };
    * var iterator = function(num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done(null, [num]);
    *   }, num * 10);
    * };
    * async.concatSeries(object, iterator, function(err, res) {
    *   console.log(res); // [1, 3, 2]
    *   console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c']]
    * });
    *
    */
   function concatSeries(collection, iterator, callback) {
     callback = onlyOnce(callback || noop);
     var size, key, keys, iter, item, iterate;
     var sync = false;
     var result = [];
     var completed = 0;

     if (isArray(collection)) {
       size = collection.length;
       iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
     } else if (!collection) {
     } else if (iteratorSymbol && collection[iteratorSymbol]) {
       size = Infinity;
       iter = collection[iteratorSymbol]();
       iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
     } else if (typeof collection === obj) {
       keys = nativeKeys(collection);
       size = keys.length;
       iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
     }
     if (!size) {
       return callback(null, result);
     }
     iterate();

     function arrayIterator() {
       iterator(collection[completed], done);
     }

     function arrayIteratorWithIndex() {
       iterator(collection[completed], completed, done);
     }

     function symbolIterator() {
       item = iter.next();
       item.done ? callback(null, result) : iterator(item.value, done);
     }

     function symbolIteratorWithKey() {
       item = iter.next();
       item.done ? callback(null, result) : iterator(item.value, completed, done);
     }

     function objectIterator() {
       iterator(collection[keys[completed]], done);
     }

     function objectIteratorWithKey() {
       key = keys[completed];
       iterator(collection[key], key, done);
     }

     function done(err, array) {
       if (isArray(array)) {
         nativePush.apply(result, array);
       } else if (arguments.length >= 2) {
         nativePush.apply(result, slice(arguments, 1));
       }
       if (err) {
         callback(err, result);
       } else if (++completed === size) {
         iterate = throwError;
         callback(null, result);
       } else if (sync) {
         nextTick(iterate);
       } else {
         sync = true;
         iterate();
       }
       sync = false;
     }
   }

   /**
    * @memberof async
    * @namespace concatLimit
    * @param {Array|Object} collection
    * @param {number} limit - limit >= 1
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var array = [1, 5, 3, 4, 2];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, [num]);
    *   }, num * 10);
    * };
    * async.concatLimit(array, 2, iterator, function(err, res) {
    *   console.log(res); // [1, 3, 5, 2, 4]
    *   console.log(order); // [1, 3, 5, 2, 4]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var array = [1, 5, 3, 4, 2];
    * var iterator = function(num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done(null, [num]);
    *   }, num * 10);
    * };
    * async.cocnatLimit(array, 2, iterator, function(err, res) {
    *   console.log(res); // [1, 3, 5, 2, 4]
    *   console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, [num]);
    *   }, num * 10);
    * };
    * async.concatLimit(object, 2, iterator, function(err, res) {
    *   console.log(res); // [1, 3, 5, 2, 4]
    *   console.log(order); // [1, 3, 5, 2, 4]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
    * var iterator = function(num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done(null, num);
    *   }, num * 10);
    * };
    * async.cocnatLimit(object, 2, iterator, function(err, res) {
    *   console.log(res); // [1, 3, 5, 2, 4]
    *   console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
    * });
    *
    */
   function concatLimit(collection, limit, iterator, callback) {
     callback = callback || noop;
     var size, key, iter, item, iterate, result;
     var sync = false;
     var started = 0;
     var completed = 0;

     if (isArray(collection)) {
       size = collection.length;
       iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
     } else if (!collection) {
     } else if (iteratorSymbol && collection[iteratorSymbol]) {
       size = Infinity;
       result = [];
       iter = collection[iteratorSymbol]();
       iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
     } else if (typeof collection === obj) {
       var keys = nativeKeys(collection);
       size = keys.length;
       iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
     }
     if (!size || isNaN(limit) || limit < 1) {
       return callback(null, []);
     }
     result = result || Array(size);
     timesSync(limit > size ? size : limit, iterate);

     function arrayIterator() {
       if (started < size) {
         iterator(collection[started], createCallback(started++));
       }
     }

     function arrayIteratorWithIndex() {
       if (started < size) {
         iterator(collection[started], started, createCallback(started++));
       }
     }

     function symbolIterator() {
       item = iter.next();
       if (item.done === false) {
         iterator(item.value, createCallback(started++));
       } else if (completed === started && iterator !== noop) {
         iterator = noop;
         callback(null, makeConcatResult(result));
       }
     }

     function symbolIteratorWithKey() {
       item = iter.next();
       if (item.done === false) {
         iterator(item.value, started, createCallback(started++));
       } else if (completed === started && iterator !== noop) {
         iterator = noop;
         callback(null, makeConcatResult(result));
       }
     }

     function objectIterator() {
       if (started < size) {
         iterator(collection[keys[started]], createCallback(started++));
       }
     }

     function objectIteratorWithKey() {
       if (started < size) {
         key = keys[started];
         iterator(collection[key], key, createCallback(started++));
       }
     }

     function createCallback(index) {
       return function(err, res) {
         if (index === null) {
           throwError();
         }
         if (err) {
           index = null;
           iterate = noop;
           callback = once(callback);
           arrayEachSync(result, function(array, index) {
             if (array === undefined) {
               result[index] = noop;
             }
           });
           callback(err, makeConcatResult(result));
           return;
         }
         switch (arguments.length) {
           case 0:
           case 1:
             result[index] = noop;
             break;
           case 2:
             result[index] = res;
             break;
           default:
             result[index] = slice(arguments, 1);
             break;
         }
         index = null;
         if (++completed === size) {
           iterate = throwError;
           callback(null, makeConcatResult(result));
           callback = throwError;
         } else if (sync) {
           nextTick(iterate);
         } else {
           sync = true;
           iterate();
         }
         sync = false;
       };
     }
   }

   /**
    * @private
    * @param {Function} arrayEach
    * @param {Function} baseEach
    * @param {Function} symbolEach
    */
   function createGroupBy(arrayEach, baseEach, symbolEach) {
     return function groupBy(collection, iterator, callback) {
       callback = callback || noop;
       var size;
       var completed = 0;
       var result = {};

       if (isArray(collection)) {
         size = collection.length;
         arrayEach(collection, iterator, createCallback);
       } else if (!collection) {
       } else if (iteratorSymbol && collection[iteratorSymbol]) {
         size = symbolEach(collection, iterator, createCallback);
         size && size === completed && callback(null, result);
       } else if (typeof collection === obj) {
         var keys = nativeKeys(collection);
         size = keys.length;
         baseEach(collection, iterator, createCallback, keys);
       }
       if (!size) {
         callback(null, {});
       }

       function createCallback(value) {
         var called = false;
         return function done(err, key) {
           if (called) {
             throwError();
           }
           called = true;
           if (err) {
             callback = once(callback);
             callback(err, objectClone(result));
             return;
           }
           var array = result[key];
           if (!array) {
             result[key] = [value];
           } else {
             array.push(value);
           }
           if (++completed === size) {
             callback(null, result);
           }
         };
       }
     };
   }

   /**
    * @memberof async
    * @namespace groupBySeries
    * @param {Array|Object} collection
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var array = [4.2, 6.4, 6.1];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, Math.floor(num));
    *   }, num * 10);
    * };
    * async.groupBySeries(array, iterator, function(err, res) {
    *   console.log(res); // { '4': [4.2], '6': [6.4, 6.1] }
    *   console.log(order); // [4.2, 6.4, 6.1]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var array = [4.2, 6.4, 6.1];
    * var iterator = function(num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done(null, Math.floor(num));
    *   }, num * 10);
    * };
    * async.groupBySeries(array, iterator, function(err, res) {
    *   console.log(res); // { '4': [4.2], '6': [6.4, 6.1] }
    *   console.log(order); // [[4.2, 0], [6.4, 1], [6.1, 2]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 4.2, b: 6.4, c: 6.1 };
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, Math.floor(num));
    *   }, num * 10);
    * };
    * async.groupBySeries(object, iterator, function(err, res) {
    *   console.log(res); // { '4': [4.2], '6': [6.4, 6.1] }
    *   console.log(order); // [4.2, 6.4, 6.1]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 4.2, b: 6.4, c: 6.1 };
    * var iterator = function(num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done(null, Math.floor(num));
    *   }, num * 10);
    * };
    * async.groupBySeries(object, iterator, function(err, res) {
    *   console.log(res); // { '4': [4.2], '6': [6.4, 6.1] }
    *   console.log(order); // [[4.2, 'a'], [6.4, 'b'], [6.1, 'c']]
    * });
    *
    */
   function groupBySeries(collection, iterator, callback) {
     callback = onlyOnce(callback || noop);
     var size, key, value, keys, iter, item, iterate;
     var sync = false;
     var completed = 0;
     var result = {};

     if (isArray(collection)) {
       size = collection.length;
       iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
     } else if (!collection) {
     } else if (iteratorSymbol && collection[iteratorSymbol]) {
       size = Infinity;
       iter = collection[iteratorSymbol]();
       iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
     } else if (typeof collection === obj) {
       keys = nativeKeys(collection);
       size = keys.length;
       iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
     }
     if (!size) {
       return callback(null, result);
     }
     iterate();

     function arrayIterator() {
       value = collection[completed];
       iterator(value, done);
     }

     function arrayIteratorWithIndex() {
       value = collection[completed];
       iterator(value, completed, done);
     }

     function symbolIterator() {
       item = iter.next();
       value = item.value;
       item.done ? callback(null, result) : iterator(value, done);
     }

     function symbolIteratorWithKey() {
       item = iter.next();
       value = item.value;
       item.done ? callback(null, result) : iterator(value, completed, done);
     }

     function objectIterator() {
       value = collection[keys[completed]];
       iterator(value, done);
     }

     function objectIteratorWithKey() {
       key = keys[completed];
       value = collection[key];
       iterator(value, key, done);
     }

     function done(err, key) {
       if (err) {
         iterate = throwError;
         callback = onlyOnce(callback);
         callback(err, objectClone(result));
         return;
       }
       var array = result[key];
       if (!array) {
         result[key] = [value];
       } else {
         array.push(value);
       }
       if (++completed === size) {
         iterate = throwError;
         callback(null, result);
       } else if (sync) {
         nextTick(iterate);
       } else {
         sync = true;
         iterate();
       }
       sync = false;
     }
   }

   /**
    * @memberof async
    * @namespace groupByLimit
    * @param {Array|Object} collection
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * // array
    * var order = [];
    * var array = [1.1, 5.9, 3.2, 3.9, 2.1];
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, Math.floor(num));
    *   }, num * 10);
    * };
    * async.groupByLimit(array, 2, iterator, function(err, res) {
    *   console.log(res); // { '1': [1.1], '3': [3.2, 3.9], '5': [5.9], '2': [2.1] }
    *   console.log(order); // [1.1, 3.2, 5.9, 2.1, 3.9]
    * });
    *
    * @example
    *
    * // array with index
    * var order = [];
    * var array = [1.1, 5.9, 3.2, 3.9, 2.1];
    * var iterator = function(num, index, done) {
    *   setTimeout(function() {
    *     order.push([num, index]);
    *     done(null, Math.floor(num));
    *   }, num * 10);
    * };
    * async.groupByLimit(array, 2, iterator, function(err, res) {
    *   console.log(res); // { '1': [1.1], '3': [3.2, 3.9], '5': [5.9], '2': [2.1] }
    *   console.log(order); // [[1.1, 0], [3.2, 2], [5.9, 1], [2.1, 4], [3.9, 3]]
    * });
    *
    * @example
    *
    * // object
    * var order = [];
    * var object = { a: 1.1, b: 5.9, c: 3.2, d: 3.9, e: 2.1 }
    * var iterator = function(num, done) {
    *   setTimeout(function() {
    *     order.push(num);
    *     done(null, Math.floor(num));
    *   }, num * 10);
    * };
    * async.groupByLimit(object, 2, iterator, function(err, res) {
    *   console.log(res); // { '1': [1.1], '3': [3.2, 3.9], '5': [5.9], '2': [2.1] }
    *   console.log(order); // [1.1, 3.2, 5.9, 2.1, 3.9]
    * });
    *
    * @example
    *
    * // object with key
    * var order = [];
    * var object = { a: 1.1, b: 5.9, c: 3.2, d: 3.9, e: 2.1 }
    * var iterator = function(num, key, done) {
    *   setTimeout(function() {
    *     order.push([num, key]);
    *     done(null, Math.floor(num));
    *   }, num * 10);
    * };
    * async.groupByLimit(object, 2, iterator, function(err, res) {
    *   console.log(res); // { '1': [1.1], '3': [3.2, 3.9], '5': [5.9], '2': [2.1] }
    *   console.log(order); // [[1.1, 'a'], [3.2, 'c'], [5.9, 'b'], [2.1, 'e'], [3.9, 'd']]
    * });
    *
    */
   function groupByLimit(collection, limit, iterator, callback) {
     callback = callback || noop;
     var size, index, key, value, keys, iter, item, iterate;
     var sync = false;
     var started = 0;
     var completed = 0;
     var result = {};

     if (isArray(collection)) {
       size = collection.length;
       iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
     } else if (!collection) {
     } else if (iteratorSymbol && collection[iteratorSymbol]) {
       size = Infinity;
       iter = collection[iteratorSymbol]();
       iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
     } else if (typeof collection === obj) {
       keys = nativeKeys(collection);
       size = keys.length;
       iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
     }
     if (!size || isNaN(limit) || limit < 1) {
       return callback(null, result);
     }
     timesSync(limit > size ? size : limit, iterate);

     function arrayIterator() {
       if (started < size) {
         value = collection[started++];
         iterator(value, createCallback(value));
       }
     }

     function arrayIteratorWithIndex() {
       index = started++;
       if (index < size) {
         value = collection[index];
         iterator(value, index, createCallback(value));
       }
     }

     function symbolIterator() {
       item = iter.next();
       if (item.done === false) {
         started++;
         value = item.value;
         iterator(value, createCallback(value));
       } else if (completed === started && iterator !== noop) {
         iterator = noop;
         callback(null, result);
       }
     }

     function symbolIteratorWithKey() {
       item = iter.next();
       if (item.done === false) {
         value = item.value;
         iterator(value, started++, createCallback(value));
       } else if (completed === started && iterator !== noop) {
         iterator = noop;
         callback(null, result);
       }
     }

     function objectIterator() {
       if (started < size) {
         value = collection[keys[started++]];
         iterator(value, createCallback(value));
       }
     }

     function objectIteratorWithKey() {
       if (started < size) {
         key = keys[started++];
         value = collection[key];
         iterator(value, key, createCallback(value));
       }
     }

     function createCallback(value) {
       var called = false;
       return function(err, key) {
         if (called) {
           throwError();
         }
         called = true;
         if (err) {
           iterate = noop;
           callback = once(callback);
           callback(err, objectClone(result));
           return;
         }
         var array = result[key];
         if (!array) {
           result[key] = [value];
         } else {
           array.push(value);
         }
         if (++completed === size) {
           callback(null, result);
         } else if (sync) {
           nextTick(iterate);
         } else {
           sync = true;
           iterate();
         }
         sync = false;
       };
     }
   }

   /**
    * @private
    * @param {Function} arrayEach
    * @param {Function} baseEach
    */
   function createParallel(arrayEach, baseEach) {
     return function parallel(tasks, callback) {
       callback = callback || noop;
       var size, keys, result;
       var completed = 0;

       if (isArray(tasks)) {
         size = tasks.length;
         result = Array(size);
         arrayEach(tasks, createCallback);
       } else if (tasks && typeof tasks === obj) {
         keys = nativeKeys(tasks);
         size = keys.length;
         result = {};
         baseEach(tasks, createCallback, keys);
       }
       if (!size) {
         callback(null, result);
       }

       function createCallback(key) {
         return function(err, res) {
           if (key === null) {
             throwError();
           }
           if (err) {
             key = null;
             callback = once(callback);
             callback(err, result);
             return;
           }
           result[key] = arguments.length <= 2 ? res : slice(arguments, 1);
           key = null;
           if (++completed === size) {
             callback(null, result);
           }
         };
       }
     };
   }

   /**
    * @memberof async
    * @namespace series
    * @param {Array|Object} tasks - functions
    * @param {Function} callback
    * @example
    *
    * var order = [];
    * var tasks = [
    *  function(done) {
    *    setTimeout(function() {
    *      order.push(1);
    *      done(null, 1);
    *    }, 10);
    *  },
    *  function(done) {
    *    setTimeout(function() {
    *      order.push(2);
    *      done(null, 2);
    *    }, 30);
    *  },
    *  function(done) {
    *    setTimeout(function() {
    *      order.push(3);
    *      done(null, 3);
    *    }, 40);
    *  },
    *  function(done) {
    *    setTimeout(function() {
    *      order.push(4);
    *      done(null, 4);
    *    }, 20);
    *  }
    * ];
    * async.series(tasks, function(err, res) {
    *   console.log(res); // [1, 2, 3, 4];
    *   console.log(order); // [1, 2, 3, 4]
    * });
    *
    * @example
    *
    * var order = [];
    * var tasks = {
    *   'a': function(done) {
    *     setTimeout(function() {
    *       order.push(1);
    *       done(null, 1);
    *     }, 10);
    *   },
    *   'b': function(done) {
    *     setTimeout(function() {
    *       order.push(2);
    *       done(null, 2);
    *     }, 30);
    *   },
    *   'c': function(done) {
    *     setTimeout(function() {
    *       order.push(3);
    *       done(null, 3);
    *     }, 40);
    *   },
    *   'd': function(done) {
    *     setTimeout(function() {
    *       order.push(4);
    *       done(null, 4);
    *     }, 20);
    *   }
    * };
    * async.series(tasks, function(err, res) {
    *   console.log(res); // { a: 1, b: 2, c: 3, d:4 }
    *   console.log(order); // [1, 4, 2, 3]
    * });
    *
    */
   function series(tasks, callback) {
     callback = callback || noop;
     var size, key, keys, result, iterate;
     var sync = false;
     var completed = 0;

     if (isArray(tasks)) {
       size = tasks.length;
       result = Array(size);
       iterate = arrayIterator;
     } else if (tasks && typeof tasks === obj) {
       keys = nativeKeys(tasks);
       size = keys.length;
       result = {};
       iterate = objectIterator;
     } else {
       return callback(null);
     }
     if (!size) {
       return callback(null, result);
     }
     iterate();

     function arrayIterator() {
       key = completed;
       tasks[completed](done);
     }

     function objectIterator() {
       key = keys[completed];
       tasks[key](done);
     }

     function done(err, res) {
       if (err) {
         iterate = throwError;
         callback = onlyOnce(callback);
         callback(err, result);
         return;
       }
       result[key] = arguments.length <= 2 ? res : slice(arguments, 1);
       if (++completed === size) {
         iterate = throwError;
         callback(null, result);
       } else if (sync) {
         nextTick(iterate);
       } else {
         sync = true;
         iterate();
       }
       sync = false;
     }
   }

   /**
    * @memberof async
    * @namespace parallelLimit
    * @param {Array|Object} tasks - functions
    * @param {number} limit - limit >= 1
    * @param {Function} callback
    * @example
    *
    * var order = [];
    * var tasks = [
    *  function(done) {
    *    setTimeout(function() {
    *      order.push(1);
    *      done(null, 1);
    *    }, 10);
    *  },
    *  function(done) {
    *    setTimeout(function() {
    *      order.push(2);
    *      done(null, 2);
    *    }, 50);
    *  },
    *  function(done) {
    *    setTimeout(function() {
    *      order.push(3);
    *      done(null, 3);
    *    }, 30);
    *  },
    *  function(done) {
    *    setTimeout(function() {
    *      order.push(4);
    *      done(null, 4);
    *    }, 40);
    *  }
    * ];
    * async.parallelLimit(tasks, 2, function(err, res) {
    *   console.log(res); // [1, 2, 3, 4];
    *   console.log(order); // [1, 3, 2, 4]
    * });
    *
    * @example
    *
    * var order = [];
    * var tasks = {
    *   'a': function(done) {
    *     setTimeout(function() {
    *       order.push(1);
    *       done(null, 1);
    *     }, 10);
    *   },
    *   'b': function(done) {
    *     setTimeout(function() {
    *       order.push(2);
    *       done(null, 2);
    *     }, 50);
    *   },
    *   'c': function(done) {
    *     setTimeout(function() {
    *       order.push(3);
    *       done(null, 3);
    *     }, 20);
    *   },
    *   'd': function(done) {
    *     setTimeout(function() {
    *       order.push(4);
    *       done(null, 4);
    *     }, 40);
    *   }
    * };
    * async.parallelLimit(tasks, 2, function(err, res) {
    *   console.log(res); // { a: 1, b: 2, c: 3, d:4 }
    *   console.log(order); // [1, 3, 2, 4]
    * });
    *
    */
   function parallelLimit(tasks, limit, callback) {
     callback = callback || noop;
     var size, index, key, keys, result, iterate;
     var sync = false;
     var started = 0;
     var completed = 0;

     if (isArray(tasks)) {
       size = tasks.length;
       result = Array(size);
       iterate = arrayIterator;
     } else if (tasks && typeof tasks === obj) {
       keys = nativeKeys(tasks);
       size = keys.length;
       result = {};
       iterate = objectIterator;
     }
     if (!size || isNaN(limit) || limit < 1) {
       return callback(null, result);
     }
     timesSync(limit > size ? size : limit, iterate);

     function arrayIterator() {
       index = started++;
       if (index < size) {
         tasks[index](createCallback(index));
       }
     }

     function objectIterator() {
       if (started < size) {
         key = keys[started++];
         tasks[key](createCallback(key));
       }
     }

     function createCallback(key) {
       return function(err, res) {
         if (key === null) {
           throwError();
         }
         if (err) {
           key = null;
           iterate = noop;
           callback = once(callback);
           callback(err, result);
           return;
         }
         result[key] = arguments.length <= 2 ? res : slice(arguments, 1);
         key = null;
         if (++completed === size) {
           callback(null, result);
         } else if (sync) {
           nextTick(iterate);
         } else {
           sync = true;
           iterate();
         }
         sync = false;
       };
     }
   }

   /**
    * @memberof async
    * @namespace tryEach
    * @param {Array|Object} tasks - functions
    * @param {Function} callback
    * @example
    *
    * var tasks = [
    *  function(done) {
    *    setTimeout(function() {
    *      done(new Error('error'));
    *    }, 10);
    *  },
    *  function(done) {
    *    setTimeout(function() {
    *      done(null, 2);
    *    }, 10);
    *  }
    * ];
    * async.tryEach(tasks, function(err, res) {
    *   console.log(res); // 2
    * });
    *
    * @example
    *
    * var tasks = [
    *  function(done) {
    *    setTimeout(function() {
    *      done(new Error('error1'));
    *    }, 10);
    *  },
    *  function(done) {
    *    setTimeout(function() {
    *      done(new Error('error2');
    *    }, 10);
    *  }
    * ];
    * async.tryEach(tasks, function(err, res) {
    *   console.log(err); // error2
    *   console.log(res); // undefined
    * });
    *
    */
   function tryEach(tasks, callback) {
     callback = callback || noop;
     var size, keys, iterate;
     var sync = false;
     var completed = 0;

     if (isArray(tasks)) {
       size = tasks.length;
       iterate = arrayIterator;
     } else if (tasks && typeof tasks === obj) {
       keys = nativeKeys(tasks);
       size = keys.length;
       iterate = objectIterator;
     }
     if (!size) {
       return callback(null);
     }
     iterate();

     function arrayIterator() {
       tasks[completed](done);
     }

     function objectIterator() {
       tasks[keys[completed]](done);
     }

     function done(err, res) {
       if (!err) {
         if (arguments.length <= 2) {
           callback(null, res);
         } else {
           callback(null, slice(arguments, 1));
         }
       } else if (++completed === size) {
         callback(err);
       } else {
         sync = true;
         iterate();
       }
       sync = false;
     }
   }

   /**
    * check for waterfall tasks
    * @private
    * @param {Array} tasks
    * @param {Function} callback
    * @return {boolean}
    */
   function checkWaterfallTasks(tasks, callback) {
     if (!isArray(tasks)) {
       callback(new Error('First argument to waterfall must be an array of functions'));
       return false;
     }
     if (tasks.length === 0) {
       callback(null);
       return false;
     }
     return true;
   }

   /**
    * check for waterfall tasks
    * @private
    * @param {function} func
    * @param {Array|Object} args - arguments
    * @return {function} next
    */
   function waterfallIterator(func, args, next) {
     switch (args.length) {
       case 0:
       case 1:
         return func(next);
       case 2:
         return func(args[1], next);
       case 3:
         return func(args[1], args[2], next);
       case 4:
         return func(args[1], args[2], args[3], next);
       case 5:
         return func(args[1], args[2], args[3], args[4], next);
       case 6:
         return func(args[1], args[2], args[3], args[4], args[5], next);
       default:
         args = slice(args, 1);
         args.push(next);
         return func.apply(null, args);
     }
   }

   /**
    * @memberof async
    * @namespace waterfall
    * @param {Array} tasks - functions
    * @param {Function} callback
    * @example
    *
    * var order = [];
    * var tasks = [
    *   function(next) {
    *     setTimeout(function() {
    *       order.push(1);
    *       next(null, 1);
    *     }, 10);
    *   },
    *   function(arg1, next) {
    *     setTimeout(function() {
    *       order.push(2);
    *       next(null, 1, 2);
    *     }, 30);
    *   },
    *   function(arg1, arg2, next) {
    *     setTimeout(function() {
    *       order.push(3);
    *       next(null, 3);
    *     }, 20);
    *   },
    *   function(arg1, next) {
    *     setTimeout(function() {
    *       order.push(4);
    *       next(null, 1, 2, 3, 4);
    *     }, 40);
    *   }
    * ];
    * async.waterfall(tasks, function(err, arg1, arg2, arg3, arg4) {
    *   console.log(arg1, arg2, arg3, arg4); // 1 2 3 4
    * });
    *
    */
   function waterfall(tasks, callback) {
     callback = callback || noop;
     if (!checkWaterfallTasks(tasks, callback)) {
       return;
     }
     var func, args, done, sync;
     var completed = 0;
     var size = tasks.length;
     waterfallIterator(tasks[0], [], createCallback(0));

     function iterate() {
       waterfallIterator(func, args, createCallback(func));
     }

     function createCallback(index) {
       return function next(err, res) {
         if (index === undefined) {
           callback = noop;
           throwError();
         }
         index = undefined;
         if (err) {
           done = callback;
           callback = throwError;
           done(err);
           return;
         }
         if (++completed === size) {
           done = callback;
           callback = throwError;
           if (arguments.length <= 2) {
             done(err, res);
           } else {
             done.apply(null, createArray(arguments));
           }
           return;
         }
         if (sync) {
           args = arguments;
           func = tasks[completed] || throwError;
           nextTick(iterate);
         } else {
           sync = true;
           waterfallIterator(tasks[completed] || throwError, arguments, createCallback(completed));
         }
         sync = false;
       };
     }
   }

   /**
    * `angelFall` is like `waterfall` and inject callback to last argument of next task.
    *
    * @memberof async
    * @namespace angelFall
    * @param {Array} tasks - functions
    * @param {Function} callback
    * @example
    *
    * var order = [];
    * var tasks = [
    *   function(next) {
    *     setTimeout(function() {
    *       order.push(1);
    *       next(null, 1);
    *     }, 10);
    *   },
    *   function(arg1, empty, next) {
    *     setTimeout(function() {
    *       order.push(2);
    *       next(null, 1, 2);
    *     }, 30);
    *   },
    *   function(next) {
    *     setTimeout(function() {
    *       order.push(3);
    *       next(null, 3);
    *     }, 20);
    *   },
    *   function(arg1, empty1, empty2, empty3, next) {
    *     setTimeout(function() {
    *       order.push(4);
    *       next(null, 1, 2, 3, 4);
    *     }, 40);
    *   }
    * ];
    * async.angelFall(tasks, function(err, arg1, arg2, arg3, arg4) {
    *   console.log(arg1, arg2, arg3, arg4); // 1 2 3 4
    * });
    *
    */
   function angelFall(tasks, callback) {
     callback = callback || noop;
     if (!checkWaterfallTasks(tasks, callback)) {
       return;
     }
     var completed = 0;
     var sync = false;
     var size = tasks.length;
     var func = tasks[completed];
     var args = [];
     var iterate = function() {
       switch (func.length) {
         case 0:
           try {
             next(null, func());
           } catch (e) {
             next(e);
           }
           return;
         case 1:
           return func(next);
         case 2:
           return func(args[1], next);
         case 3:
           return func(args[1], args[2], next);
         case 4:
           return func(args[1], args[2], args[3], next);
         case 5:
           return func(args[1], args[2], args[3], args[4], next);
         default:
           args = slice(args, 1);
           args[func.length - 1] = next;
           return func.apply(null, args);
       }
     };
     iterate();

     function next(err, res) {
       if (err) {
         iterate = throwError;
         callback = onlyOnce(callback);
         callback(err);
         return;
       }
       if (++completed === size) {
         iterate = throwError;
         var done = callback;
         callback = throwError;
         if (arguments.length === 2) {
           done(err, res);
         } else {
           done.apply(null, createArray(arguments));
         }
         return;
       }
       func = tasks[completed];
       args = arguments;
       if (sync) {
         nextTick(iterate);
       } else {
         sync = true;
         iterate();
       }
       sync = false;
     }
   }

   /**
    * @memberof async
    * @namespace whilst
    * @param {Function} test
    * @param {Function} iterator
    * @param {Function} callback
    */
   function whilst(test, iterator, callback) {
     callback = callback || noop;
     var sync = false;
     if (test()) {
       iterate();
     } else {
       callback(null);
     }

     function iterate() {
       if (sync) {
         nextTick(next);
       } else {
         sync = true;
         iterator(done);
       }
       sync = false;
     }

     function next() {
       iterator(done);
     }

     function done(err, arg) {
       if (err) {
         return callback(err);
       }
       if (arguments.length <= 2) {
         if (test(arg)) {
           iterate();
         } else {
           callback(null, arg);
         }
         return;
       }
       arg = slice(arguments, 1);
       if (test.apply(null, arg)) {
         iterate();
       } else {
         callback.apply(null, [null].concat(arg));
       }
     }
   }

   /**
    * @memberof async
    * @namespace doWhilst
    * @param {Function} iterator
    * @param {Function} test
    * @param {Function} callback
    */
   function doWhilst(iterator, test, callback) {
     callback = callback || noop;
     var sync = false;
     next();

     function iterate() {
       if (sync) {
         nextTick(next);
       } else {
         sync = true;
         iterator(done);
       }
       sync = false;
     }

     function next() {
       iterator(done);
     }

     function done(err, arg) {
       if (err) {
         return callback(err);
       }
       if (arguments.length <= 2) {
         if (test(arg)) {
           iterate();
         } else {
           callback(null, arg);
         }
         return;
       }
       arg = slice(arguments, 1);
       if (test.apply(null, arg)) {
         iterate();
       } else {
         callback.apply(null, [null].concat(arg));
       }
     }
   }

   /**
    * @memberof async
    * @namespace until
    * @param {Function} test
    * @param {Function} iterator
    * @param {Function} callback
    */
   function until(test, iterator, callback) {
     callback = callback || noop;
     var sync = false;
     if (!test()) {
       iterate();
     } else {
       callback(null);
     }

     function iterate() {
       if (sync) {
         nextTick(next);
       } else {
         sync = true;
         iterator(done);
       }
       sync = false;
     }

     function next() {
       iterator(done);
     }

     function done(err, arg) {
       if (err) {
         return callback(err);
       }
       if (arguments.length <= 2) {
         if (!test(arg)) {
           iterate();
         } else {
           callback(null, arg);
         }
         return;
       }
       arg = slice(arguments, 1);
       if (!test.apply(null, arg)) {
         iterate();
       } else {
         callback.apply(null, [null].concat(arg));
       }
     }
   }

   /**
    * @memberof async
    * @namespace doUntil
    * @param {Function} iterator
    * @param {Function} test
    * @param {Function} callback
    */
   function doUntil(iterator, test, callback) {
     callback = callback || noop;
     var sync = false;
     next();

     function iterate() {
       if (sync) {
         nextTick(next);
       } else {
         sync = true;
         iterator(done);
       }
       sync = false;
     }

     function next() {
       iterator(done);
     }

     function done(err, arg) {
       if (err) {
         return callback(err);
       }
       if (arguments.length <= 2) {
         if (!test(arg)) {
           iterate();
         } else {
           callback(null, arg);
         }
         return;
       }
       arg = slice(arguments, 1);
       if (!test.apply(null, arg)) {
         iterate();
       } else {
         callback.apply(null, [null].concat(arg));
       }
     }
   }

   /**
    * @memberof async
    * @namespace during
    * @param {Function} test
    * @param {Function} iterator
    * @param {Function} callback
    */
   function during(test, iterator, callback) {
     callback = callback || noop;
     _test();

     function _test() {
       test(iterate);
     }

     function iterate(err, truth) {
       if (err) {
         return callback(err);
       }
       if (truth) {
         iterator(done);
       } else {
         callback(null);
       }
     }

     function done(err) {
       if (err) {
         return callback(err);
       }
       _test();
     }
   }

   /**
    * @memberof async
    * @namespace doDuring
    * @param {Function} test
    * @param {Function} iterator
    * @param {Function} callback
    */
   function doDuring(iterator, test, callback) {
     callback = callback || noop;
     iterate(null, true);

     function iterate(err, truth) {
       if (err) {
         return callback(err);
       }
       if (truth) {
         iterator(done);
       } else {
         callback(null);
       }
     }

     function done(err, res) {
       if (err) {
         return callback(err);
       }
       switch (arguments.length) {
         case 0:
         case 1:
           test(iterate);
           break;
         case 2:
           test(res, iterate);
           break;
         default:
           var args = slice(arguments, 1);
           args.push(iterate);
           test.apply(null, args);
           break;
       }
     }
   }

   /**
    * @memberof async
    * @namespace forever
    */
   function forever(iterator, callback) {
     var sync = false;
     iterate();

     function iterate() {
       iterator(next);
     }

     function next(err) {
       if (err) {
         if (callback) {
           return callback(err);
         }
         throw err;
       }
       if (sync) {
         nextTick(iterate);
       } else {
         sync = true;
         iterate();
       }
       sync = false;
     }
   }

   /**
    * @memberof async
    * @namespace compose
    */
   function compose() {
     return seq.apply(null, reverse(arguments));
   }

   /**
    * @memberof async
    * @namespace seq
    */
   function seq(/* functions... */) {
     var fns = createArray(arguments);

     return function() {
       var self = this;
       var args = createArray(arguments);
       var callback = args[args.length - 1];
       if (typeof callback === func) {
         args.pop();
       } else {
         callback = noop;
       }
       reduce(fns, args, iterator, done);

       function iterator(newargs, fn, callback) {
         var func = function(err) {
           var nextargs = slice(arguments, 1);
           callback(err, nextargs);
         };
         newargs.push(func);
         fn.apply(self, newargs);
       }

       function done(err, res) {
         res = isArray(res) ? res : [res];
         res.unshift(err);
         callback.apply(self, res);
       }
     };
   }

   function createApplyEach(func) {
     return function applyEach(fns /* arguments */) {
       var go = function() {
         var self = this;
         var args = createArray(arguments);
         var callback = args.pop() || noop;
         return func(fns, iterator, callback);

         function iterator(fn, done) {
           fn.apply(self, args.concat([done]));
         }
       };
       if (arguments.length > 1) {
         var args = slice(arguments, 1);
         return go.apply(this, args);
       } else {
         return go;
       }
     };
   }

   /**
    * @see https://github.com/caolan/async/blob/master/lib/internal/DoublyLinkedList.js
    */
   function DLL() {
     this.head = null;
     this.tail = null;
     this.length = 0;
   }

   DLL.prototype._removeLink = function(node) {
     var prev = node.prev;
     var next = node.next;
     if (prev) {
       prev.next = next;
     } else {
       this.head = next;
     }
     if (next) {
       next.prev = prev;
     } else {
       this.tail = prev;
     }
     node.prev = null;
     node.next = null;
     this.length--;
     return node;
   };

   DLL.prototype.empty = DLL;

   DLL.prototype._setInitial = function(node) {
     this.length = 1;
     this.head = this.tail = node;
   };

   DLL.prototype.insertBefore = function(node, newNode) {
     newNode.prev = node.prev;
     newNode.next = node;
     if (node.prev) {
       node.prev.next = newNode;
     } else {
       this.head = newNode;
     }
     node.prev = newNode;
     this.length++;
   };

   DLL.prototype.unshift = function(node) {
     if (this.head) {
       this.insertBefore(this.head, node);
     } else {
       this._setInitial(node);
     }
   };

   DLL.prototype.push = function(node) {
     var tail = this.tail;
     if (tail) {
       node.prev = tail;
       node.next = tail.next;
       this.tail = node;
       tail.next = node;
       this.length++;
     } else {
       this._setInitial(node);
     }
   };

   DLL.prototype.shift = function() {
     return this.head && this._removeLink(this.head);
   };

   DLL.prototype.splice = function(end) {
     var task;
     var tasks = [];
     while (end-- && (task = this.shift())) {
       tasks.push(task);
     }
     return tasks;
   };

   DLL.prototype.remove = function(test) {
     var node = this.head;
     while (node) {
       if (test(node)) {
         this._removeLink(node);
       }
       node = node.next;
     }
     return this;
   };

   /**
    * @private
    */
   function baseQueue(isQueue, worker, concurrency, payload) {
     if (concurrency === undefined) {
       concurrency = 1;
     } else if (isNaN(concurrency) || concurrency < 1) {
       throw new Error('Concurrency must not be zero');
     }

     var workers = 0;
     var workersList = [];
     var _callback, _unshift;

     var q = {
       _tasks: new DLL(),
       concurrency: concurrency,
       payload: payload,
       saturated: noop,
       unsaturated: noop,
       buffer: concurrency / 4,
       empty: noop,
       drain: noop,
       error: noop,
       started: false,
       paused: false,
       push: push,
       kill: kill,
       unshift: unshift,
       remove: remove,
       process: isQueue ? runQueue : runCargo,
       length: getLength,
       running: running,
       workersList: getWorkersList,
       idle: idle,
       pause: pause,
       resume: resume,
       _worker: worker
     };
     return q;

     function push(tasks, callback) {
       _insert(tasks, callback);
     }

     function unshift(tasks, callback) {
       _insert(tasks, callback, true);
     }

     function _exec(task) {
       var item = {
         data: task,
         callback: _callback
       };
       if (_unshift) {
         q._tasks.unshift(item);
       } else {
         q._tasks.push(item);
       }
       nextTick(q.process);
     }

     function _insert(tasks, callback, unshift) {
       if (callback == null) {
         callback = noop;
       } else if (typeof callback !== 'function') {
         throw new Error('task callback must be a function');
       }
       q.started = true;
       var _tasks = isArray(tasks) ? tasks : [tasks];

       if (tasks === undefined || !_tasks.length) {
         if (q.idle()) {
           nextTick(q.drain);
         }
         return;
       }

       _unshift = unshift;
       _callback = callback;
       arrayEachSync(_tasks, _exec);
     }

     function kill() {
       q.drain = noop;
       q._tasks.empty();
     }

     function _next(q, tasks) {
       var called = false;
       return function done(err, res) {
         if (called) {
           throwError();
         }
         called = true;

         workers--;
         var task;
         var index = -1;
         var size = workersList.length;
         var taskIndex = -1;
         var taskSize = tasks.length;
         var useApply = arguments.length > 2;
         var args = useApply && createArray(arguments);
         while (++taskIndex < taskSize) {
           task = tasks[taskIndex];
           while (++index < size) {
             if (workersList[index] === task) {
               if (index === 0) {
                 workersList.shift();
               } else {
                 workersList.splice(index, 1);
               }
               index = size;
               size--;
             }
           }
           index = -1;
           if (useApply) {
             task.callback.apply(task, args);
           } else {
             task.callback(err, res);
           }
           if (err) {
             q.error(err, task.data);
           }
         }

         if (workers <= q.concurrency - q.buffer) {
           q.unsaturated();
         }

         if (q._tasks.length + workers === 0) {
           q.drain();
         }
         q.process();
       };
     }

     function runQueue() {
       while (!q.paused && workers < q.concurrency && q._tasks.length) {
         var task = q._tasks.shift();
         workers++;
         workersList.push(task);
         if (q._tasks.length === 0) {
           q.empty();
         }
         if (workers === q.concurrency) {
           q.saturated();
         }
         var done = _next(q, [task]);
         worker(task.data, done);
       }
     }

     function runCargo() {
       while (!q.paused && workers < q.concurrency && q._tasks.length) {
         var tasks = q._tasks.splice(q.payload || q._tasks.length);
         var index = -1;
         var size = tasks.length;
         var data = Array(size);
         while (++index < size) {
           data[index] = tasks[index].data;
         }
         workers++;
         nativePush.apply(workersList, tasks);
         if (q._tasks.length === 0) {
           q.empty();
         }
         if (workers === q.concurrency) {
           q.saturated();
         }
         var done = _next(q, tasks);
         worker(data, done);
       }
     }

     function getLength() {
       return q._tasks.length;
     }

     function running() {
       return workers;
     }

     function getWorkersList() {
       return workersList;
     }

     function idle() {
       return q.length() + workers === 0;
     }

     function pause() {
       q.paused = true;
     }

     function _resume() {
       nextTick(q.process);
     }

     function resume() {
       if (q.paused === false) {
         return;
       }
       q.paused = false;
       var count = q.concurrency < q._tasks.length ? q.concurrency : q._tasks.length;
       timesSync(count, _resume);
     }

     /**
      * @param {Function} test
      */
     function remove(test) {
       q._tasks.remove(test);
     }
   }

   /**
    * @memberof async
    * @namespace queue
    */
   function queue(worker, concurrency) {
     return baseQueue(true, worker, concurrency);
   }

   /**
    * @memberof async
    * @namespace priorityQueue
    */
   function priorityQueue(worker, concurrency) {
     var q = baseQueue(true, worker, concurrency);
     q.push = push;
     delete q.unshift;
     return q;

     function push(tasks, priority, callback) {
       q.started = true;
       priority = priority || 0;
       var _tasks = isArray(tasks) ? tasks : [tasks];
       var taskSize = _tasks.length;

       if (tasks === undefined || taskSize === 0) {
         if (q.idle()) {
           nextTick(q.drain);
         }
         return;
       }

       callback = typeof callback === func ? callback : noop;
       var nextNode = q._tasks.head;
       while (nextNode && priority >= nextNode.priority) {
         nextNode = nextNode.next;
       }
       while (taskSize--) {
         var item = {
           data: _tasks[taskSize],
           priority: priority,
           callback: callback
         };
         if (nextNode) {
           q._tasks.insertBefore(nextNode, item);
         } else {
           q._tasks.push(item);
         }
         nextTick(q.process);
       }
     }
   }

   /**
    * @memberof async
    * @namespace cargo
    */
   function cargo(worker, payload) {
     return baseQueue(false, worker, 1, payload);
   }

   /**
    * @memberof async
    * @namespace auto
    * @param {Object} tasks
    * @param {number} [concurrency]
    * @param {Function} [callback]
    */
   function auto(tasks, concurrency, callback) {
     if (typeof concurrency === func) {
       callback = concurrency;
       concurrency = null;
     }
     var keys = nativeKeys(tasks);
     var rest = keys.length;
     var results = {};
     if (rest === 0) {
       return callback(null, results);
     }
     var runningTasks = 0;
     var readyTasks = [];
     var listeners = Object.create(null);
     callback = onlyOnce(callback || noop);
     concurrency = concurrency || rest;

     baseEachSync(tasks, iterator, keys);
     proceedQueue();

     function iterator(task, key) {
       // no dependencies
       var _task, _taskSize;
       if (!isArray(task)) {
         _task = task;
         _taskSize = 0;
         readyTasks.push([_task, _taskSize, done]);
         return;
       }
       var dependencySize = task.length - 1;
       _task = task[dependencySize];
       _taskSize = dependencySize;
       if (dependencySize === 0) {
         readyTasks.push([_task, _taskSize, done]);
         return;
       }
       // dependencies
       var index = -1;
       while (++index < dependencySize) {
         var dependencyName = task[index];
         if (notInclude(keys, dependencyName)) {
           var msg =
             'async.auto task `' +
             key +
             '` has non-existent dependency `' +
             dependencyName +
             '` in ' +
             task.join(', ');
           throw new Error(msg);
         }
         var taskListeners = listeners[dependencyName];
         if (!taskListeners) {
           taskListeners = listeners[dependencyName] = [];
         }
         taskListeners.push(taskListener);
       }

       function done(err, arg) {
         if (key === null) {
           throwError();
         }
         arg = arguments.length <= 2 ? arg : slice(arguments, 1);
         if (err) {
           rest = 0;
           runningTasks = 0;
           readyTasks.length = 0;
           var safeResults = objectClone(results);
           safeResults[key] = arg;
           key = null;
           var _callback = callback;
           callback = noop;
           _callback(err, safeResults);
           return;
         }
         runningTasks--;
         rest--;
         results[key] = arg;
         taskComplete(key);
         key = null;
       }

       function taskListener() {
         if (--dependencySize === 0) {
           readyTasks.push([_task, _taskSize, done]);
         }
       }
     }

     function proceedQueue() {
       if (readyTasks.length === 0 && runningTasks === 0) {
         if (rest !== 0) {
           throw new Error('async.auto task has cyclic dependencies');
         }
         return callback(null, results);
       }
       while (readyTasks.length && runningTasks < concurrency && callback !== noop) {
         runningTasks++;
         var array = readyTasks.shift();
         if (array[1] === 0) {
           array[0](array[2]);
         } else {
           array[0](results, array[2]);
         }
       }
     }

     function taskComplete(key) {
       var taskListeners = listeners[key] || [];
       arrayEachSync(taskListeners, function(task) {
         task();
       });
       proceedQueue();
     }
   }

   var FN_ARGS = /^(function)?\s*[^\(]*\(\s*([^\)]*)\)/m;
   var FN_ARG_SPLIT = /,/;
   var FN_ARG = /(=.+)?(\s*)$/;
   var STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm;

   /**
    * parse function arguments for `autoInject`
    *
    * @private
    */
   function parseParams(func) {
     func = func.toString().replace(STRIP_COMMENTS, '');
     func = func.match(FN_ARGS)[2].replace(' ', '');
     func = func ? func.split(FN_ARG_SPLIT) : [];
     func = func.map(function(arg) {
       return arg.replace(FN_ARG, '').trim();
     });
     return func;
   }

   /**
    * @memberof async
    * @namespace autoInject
    * @param {Object} tasks
    * @param {number} [concurrency]
    * @param {Function} [callback]
    */
   function autoInject(tasks, concurrency, callback) {
     var newTasks = {};
     baseEachSync(tasks, iterator, nativeKeys(tasks));
     auto(newTasks, concurrency, callback);

     function iterator(task, key) {
       var params;
       var taskLength = task.length;

       if (isArray(task)) {
         if (taskLength === 0) {
           throw new Error('autoInject task functions require explicit parameters.');
         }
         params = createArray(task);
         taskLength = params.length - 1;
         task = params[taskLength];
         if (taskLength === 0) {
           newTasks[key] = task;
           return;
         }
       } else if (taskLength === 1) {
         newTasks[key] = task;
         return;
       } else {
         params = parseParams(task);
         if (taskLength === 0 && params.length === 0) {
           throw new Error('autoInject task functions require explicit parameters.');
         }
         taskLength = params.length - 1;
       }
       params[taskLength] = newTask;
       newTasks[key] = params;

       function newTask(results, done) {
         switch (taskLength) {
           case 1:
             task(results[params[0]], done);
             break;
           case 2:
             task(results[params[0]], results[params[1]], done);
             break;
           case 3:
             task(results[params[0]], results[params[1]], results[params[2]], done);
             break;
           default:
             var i = -1;
             while (++i < taskLength) {
               params[i] = results[params[i]];
             }
             params[i] = done;
             task.apply(null, params);
             break;
         }
       }
     }
   }

   /**
    * @memberof async
    * @namespace retry
    * @param {integer|Object|Function} opts
    * @param {Function} [task]
    * @param {Function} [callback]
    */
   function retry(opts, task, callback) {
     var times, intervalFunc, errorFilter;
     var count = 0;
     if (arguments.length < 3 && typeof opts === func) {
       callback = task || noop;
       task = opts;
       opts = null;
       times = DEFAULT_TIMES;
     } else {
       callback = callback || noop;
       switch (typeof opts) {
         case 'object':
           if (typeof opts.errorFilter === func) {
             errorFilter = opts.errorFilter;
           }
           var interval = opts.interval;
           switch (typeof interval) {
             case func:
               intervalFunc = interval;
               break;
             case 'string':
             case 'number':
               interval = +interval;
               intervalFunc = interval
                 ? function() {
                     return interval;
                   }
                 : function() {
                     return DEFAULT_INTERVAL;
                   };
               break;
           }
           times = +opts.times || DEFAULT_TIMES;
           break;
         case 'number':
           times = opts || DEFAULT_TIMES;
           break;
         case 'string':
           times = +opts || DEFAULT_TIMES;
           break;
         default:
           throw new Error('Invalid arguments for async.retry');
       }
     }
     if (typeof task !== 'function') {
       throw new Error('Invalid arguments for async.retry');
     }

     if (intervalFunc) {
       task(intervalCallback);
     } else {
       task(simpleCallback);
     }

     function simpleIterator() {
       task(simpleCallback);
     }

     function simpleCallback(err, res) {
       if (++count === times || !err || (errorFilter && !errorFilter(err))) {
         if (arguments.length <= 2) {
           return callback(err, res);
         }
         var args = createArray(arguments);
         return callback.apply(null, args);
       }
       simpleIterator();
     }

     function intervalIterator() {
       task(intervalCallback);
     }

     function intervalCallback(err, res) {
       if (++count === times || !err || (errorFilter && !errorFilter(err))) {
         if (arguments.length <= 2) {
           return callback(err, res);
         }
         var args = createArray(arguments);
         return callback.apply(null, args);
       }
       setTimeout(intervalIterator, intervalFunc(count));
     }
   }

   function retryable(opts, task) {
     if (!task) {
       task = opts;
       opts = null;
     }
     return done;

     function done() {
       var taskFn;
       var args = createArray(arguments);
       var lastIndex = args.length - 1;
       var callback = args[lastIndex];
       switch (task.length) {
         case 1:
           taskFn = task1;
           break;
         case 2:
           taskFn = task2;
           break;
         case 3:
           taskFn = task3;
           break;
         default:
           taskFn = task4;
       }
       if (opts) {
         retry(opts, taskFn, callback);
       } else {
         retry(taskFn, callback);
       }

       function task1(done) {
         task(done);
       }

       function task2(done) {
         task(args[0], done);
       }

       function task3(done) {
         task(args[0], args[1], done);
       }

       function task4(callback) {
         args[lastIndex] = callback;
         task.apply(null, args);
       }
     }
   }

   /**
    * @memberof async
    * @namespace iterator
    */
   function iterator(tasks) {
     var size = 0;
     var keys = [];
     if (isArray(tasks)) {
       size = tasks.length;
     } else {
       keys = nativeKeys(tasks);
       size = keys.length;
     }
     return makeCallback(0);

     function makeCallback(index) {
       var fn = function() {
         if (size) {
           var key = keys[index] || index;
           tasks[key].apply(null, createArray(arguments));
         }
         return fn.next();
       };
       fn.next = function() {
         return index < size - 1 ? makeCallback(index + 1) : null;
       };
       return fn;
     }
   }

   /**
    * @memberof async
    * @namespace apply
    */
   function apply(func) {
     switch (arguments.length) {
       case 0:
       case 1:
         return func;
       case 2:
         return func.bind(null, arguments[1]);
       case 3:
         return func.bind(null, arguments[1], arguments[2]);
       case 4:
         return func.bind(null, arguments[1], arguments[2], arguments[3]);
       case 5:
         return func.bind(null, arguments[1], arguments[2], arguments[3], arguments[4]);
       default:
         var size = arguments.length;
         var index = 0;
         var args = Array(size);
         args[index] = null;
         while (++index < size) {
           args[index] = arguments[index];
         }
         return func.bind.apply(func, args);
     }
   }

   /**
    * @memberof async
    * @namespace timeout
    * @param {Function} func
    * @param {number} millisec
    * @param {*} info
    */
   function timeout(func, millisec, info) {
     var callback, timer;
     return wrappedFunc;

     function wrappedFunc() {
       timer = setTimeout(timeoutCallback, millisec);
       var args = createArray(arguments);
       var lastIndex = args.length - 1;
       callback = args[lastIndex];
       args[lastIndex] = injectedCallback;
       simpleApply(func, args);
     }

     function timeoutCallback() {
       var name = func.name || 'anonymous';
       var err = new Error('Callback function "' + name + '" timed out.');
       err.code = 'ETIMEDOUT';
       if (info) {
         err.info = info;
       }
       timer = null;
       callback(err);
     }

     function injectedCallback() {
       if (timer !== null) {
         simpleApply(callback, createArray(arguments));
         clearTimeout(timer);
       }
     }

     function simpleApply(func, args) {
       switch (args.length) {
         case 0:
           func();
           break;
         case 1:
           func(args[0]);
           break;
         case 2:
           func(args[0], args[1]);
           break;
         default:
           func.apply(null, args);
           break;
       }
     }
   }

   /**
    * @memberof async
    * @namespace times
    * @param {number} n - n >= 1
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * var iterator = function(n, done) {
    *   done(null, n);
    * };
    * async.times(4, iterator, function(err, res) {
    *   console.log(res); // [0, 1, 2, 3];
    * });
    *
    */
   function times(n, iterator, callback) {
     callback = callback || noop;
     n = +n;
     if (isNaN(n) || n < 1) {
       return callback(null, []);
     }
     var result = Array(n);
     timesSync(n, iterate);

     function iterate(num) {
       iterator(num, createCallback(num));
     }

     function createCallback(index) {
       return function(err, res) {
         if (index === null) {
           throwError();
         }
         result[index] = res;
         index = null;
         if (err) {
           callback(err);
           callback = noop;
         } else if (--n === 0) {
           callback(null, result);
         }
       };
     }
   }

   /**
    * @memberof async
    * @namespace timesSeries
    * @param {number} n - n >= 1
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * var iterator = function(n, done) {
    *   done(null, n);
    * };
    * async.timesSeries(4, iterator, function(err, res) {
    *   console.log(res); // [0, 1, 2, 3];
    * });
    *
    */
   function timesSeries(n, iterator, callback) {
     callback = callback || noop;
     n = +n;
     if (isNaN(n) || n < 1) {
       return callback(null, []);
     }
     var result = Array(n);
     var sync = false;
     var completed = 0;
     iterate();

     function iterate() {
       iterator(completed, done);
     }

     function done(err, res) {
       result[completed] = res;
       if (err) {
         callback(err);
         callback = throwError;
       } else if (++completed >= n) {
         callback(null, result);
         callback = throwError;
       } else if (sync) {
         nextTick(iterate);
       } else {
         sync = true;
         iterate();
       }
       sync = false;
     }
   }

   /**
    * @memberof async
    * @namespace timesLimit
    * @param {number} n - n >= 1
    * @param {number} limit - n >= 1
    * @param {Function} iterator
    * @param {Function} callback
    * @example
    *
    * var iterator = function(n, done) {
    *   done(null, n);
    * };
    * async.timesLimit(4, 2, iterator, function(err, res) {
    *   console.log(res); // [0, 1, 2, 3];
    * });
    *
    */
   function timesLimit(n, limit, iterator, callback) {
     callback = callback || noop;
     n = +n;
     if (isNaN(n) || n < 1 || isNaN(limit) || limit < 1) {
       return callback(null, []);
     }
     var result = Array(n);
     var sync = false;
     var started = 0;
     var completed = 0;
     timesSync(limit > n ? n : limit, iterate);

     function iterate() {
       var index = started++;
       if (index < n) {
         iterator(index, createCallback(index));
       }
     }

     function createCallback(index) {
       return function(err, res) {
         if (index === null) {
           throwError();
         }
         result[index] = res;
         index = null;
         if (err) {
           callback(err);
           callback = noop;
         } else if (++completed >= n) {
           callback(null, result);
           callback = throwError;
         } else if (sync) {
           nextTick(iterate);
         } else {
           sync = true;
           iterate();
         }
         sync = false;
       };
     }
   }

   /**
    * @memberof async
    * @namespace race
    * @param {Array|Object} tasks - functions
    * @param {Function} callback
    * @example
    *
    * // array
    * var called = 0;
    * var tasks = [
    *   function(done) {
    *     setTimeout(function() {
    *       called++;
    *       done(null, '1');
    *     }, 30);
    *   },
    *   function(done) {
    *     setTimeout(function() {
    *       called++;
    *       done(null, '2');
    *     }, 20);
    *   },
    *   function(done) {
    *     setTimeout(function() {
    *       called++;
    *       done(null, '3');
    *     }, 10);
    *   }
    * ];
    * async.race(tasks, function(err, res) {
    *   console.log(res); // '3'
    *   console.log(called); // 1
    *   setTimeout(function() {
    *     console.log(called); // 3
    *   }, 50);
    * });
    *
    * @example
    *
    * // object
    * var called = 0;
    * var tasks = {
    *   'test1': function(done) {
    *     setTimeout(function() {
    *       called++;
    *       done(null, '1');
    *     }, 30);
    *   },
    *   'test2': function(done) {
    *     setTimeout(function() {
    *       called++;
    *       done(null, '2');
    *     }, 20);
    *   },
    *   'test3': function(done) {
    *     setTimeout(function() {
    *       called++;
    *       done(null, '3');
    *     }, 10);
    *   }
    * };
    * async.race(tasks, function(err, res) {
    *   console.log(res); // '3'
    *   console.log(called); // 1
    *   setTimeout(function() {
    *     console.log(called); // 3
    *     done();
    *   }, 50);
    * });
    *
    */
   function race(tasks, callback) {
     callback = once(callback || noop);
     var size, keys;
     var index = -1;
     if (isArray(tasks)) {
       size = tasks.length;
       while (++index < size) {
         tasks[index](callback);
       }
     } else if (tasks && typeof tasks === obj) {
       keys = nativeKeys(tasks);
       size = keys.length;
       while (++index < size) {
         tasks[keys[index]](callback);
       }
     } else {
       return callback(new TypeError('First argument to race must be a collection of functions'));
     }
     if (!size) {
       callback(null);
     }
   }

   /**
    * @memberof async
    * @namespace memoize
    */
   function memoize(fn, hasher) {
     hasher =
       hasher ||
       function(hash) {
         return hash;
       };

     var memo = {};
     var queues = {};
     var memoized = function() {
       var args = createArray(arguments);
       var callback = args.pop();
       var key = hasher.apply(null, args);
       if (has(memo, key)) {
         nextTick(function() {
           callback.apply(null, memo[key]);
         });
         return;
       }
       if (has(queues, key)) {
         return queues[key].push(callback);
       }

       queues[key] = [callback];
       args.push(done);
       fn.apply(null, args);

       function done(err) {
         var args = createArray(arguments);
         if (!err) {
           memo[key] = args;
         }
         var q = queues[key];
         delete queues[key];

         var i = -1;
         var size = q.length;
         while (++i < size) {
           q[i].apply(null, args);
         }
       }
     };
     memoized.memo = memo;
     memoized.unmemoized = fn;
     return memoized;
   }

   /**
    * @memberof async
    * @namespace unmemoize
    */
   function unmemoize(fn) {
     return function() {
       return (fn.unmemoized || fn).apply(null, arguments);
     };
   }

   /**
    * @memberof async
    * @namespace ensureAsync
    */
   function ensureAsync(fn) {
     return function(/* ...args, callback */) {
       var args = createArray(arguments);
       var lastIndex = args.length - 1;
       var callback = args[lastIndex];
       var sync = true;
       args[lastIndex] = done;
       fn.apply(this, args);
       sync = false;

       function done() {
         var innerArgs = createArray(arguments);
         if (sync) {
           nextTick(function() {
             callback.apply(null, innerArgs);
           });
         } else {
           callback.apply(null, innerArgs);
         }
       }
     };
   }

   /**
    * @memberof async
    * @namespace constant
    */
   function constant(/* values... */) {
     var args = [null].concat(createArray(arguments));
     return function(callback) {
       callback = arguments[arguments.length - 1];
       callback.apply(this, args);
     };
   }

   function asyncify(fn) {
     return function(/* args..., callback */) {
       var args = createArray(arguments);
       var callback = args.pop();
       var result;
       try {
         result = fn.apply(this, args);
       } catch (e) {
         return callback(e);
       }
       if (result && typeof result.then === func) {
         result.then(
           function(value) {
             invokeCallback(callback, null, value);
           },
           function(err) {
             invokeCallback(callback, err && err.message ? err : new Error(err));
           }
         );
       } else {
         callback(null, result);
       }
     };
   }

   function invokeCallback(callback, err, value) {
     try {
       callback(err, value);
     } catch (e) {
       nextTick(rethrow, e);
     }
   }

   function rethrow(error) {
     throw error;
   }

   /**
    * @memberof async
    * @namespace reflect
    * @param {Function} func
    * @return {Function}
    */
   function reflect(func) {
     return function(/* args..., callback */) {
       var callback;
       switch (arguments.length) {
         case 1:
           callback = arguments[0];
           return func(done);
         case 2:
           callback = arguments[1];
           return func(arguments[0], done);
         default:
           var args = createArray(arguments);
           var lastIndex = args.length - 1;
           callback = args[lastIndex];
           args[lastIndex] = done;
           func.apply(this, args);
       }

       function done(err, res) {
         if (err) {
           return callback(null, {
             error: err
           });
         }
         if (arguments.length > 2) {
           res = slice(arguments, 1);
         }
         callback(null, {
           value: res
         });
       }
     };
   }

   /**
    * @memberof async
    * @namespace reflectAll
    * @param {Array[]|Object} tasks
    * @return {Function}
    */
   function reflectAll(tasks) {
     var newTasks, keys;
     if (isArray(tasks)) {
       newTasks = Array(tasks.length);
       arrayEachSync(tasks, iterate);
     } else if (tasks && typeof tasks === obj) {
       keys = nativeKeys(tasks);
       newTasks = {};
       baseEachSync(tasks, iterate, keys);
     }
     return newTasks;

     function iterate(func, key) {
       newTasks[key] = reflect(func);
     }
   }

   /**
    * @memberof async
    * @namespace createLogger
    */
   function createLogger(name) {
     return function(fn) {
       var args = slice(arguments, 1);
       args.push(done);
       fn.apply(null, args);
     };

     function done(err) {
       if (typeof console === obj) {
         if (err) {
           if (console.error) {
             console.error(err);
           }
           return;
         }
         if (console[name]) {
           var args = slice(arguments, 1);
           arrayEachSync(args, function(arg) {
             console[name](arg);
           });
         }
       }
     }
   }

   /**
    * @memberof async
    * @namespace safe
    */
   function safe() {
     createImmediate();
     return exports;
   }

   /**
    * @memberof async
    * @namespace fast
    */
   function fast() {
     createImmediate(false);
     return exports;
   }
 });