update minified build

3 files changed, 1263 insertions, 0 deletions

diff --git a/dist/async.js b/dist/async.js
new file mode 100644
index 0000000..8889344
--- /dev/null
+++ b/dist/async.js
@@ -0,0 +1,1260 @@
+/*!
+ * async
+ * https://github.com/caolan/async
+ *
+ * Copyright 2010-2014 Caolan McMahon
+ * Released under the MIT license
+ */
+(function () {
+
+    var async = {};
+    function noop() {}
+    function identity(v) {
+        return v;
+    }
+    function toBool(v) {
+        return !!v;
+    }
+    function notId(v) {
+        return !v;
+    }
+
+    // global on the server, window in the browser
+    var previous_async;
+
+    // Establish the root object, `window` (`self`) in the browser, `global`
+    // on the server, or `this` in some virtual machines. We use `self`
+    // instead of `window` for `WebWorker` support.
+    var root = typeof self === 'object' && self.self === self && self ||
+            typeof global === 'object' && global.global === global && global ||
+            this;
+
+    if (root != null) {
+        previous_async = root.async;
+    }
+
+    async.noConflict = function () {
+        root.async = previous_async;
+        return async;
+    };
+
+    function only_once(fn) {
+        return function() {
+            if (fn === null) throw new Error("Callback was already called.");
+            fn.apply(this, arguments);
+            fn = null;
+        };
+    }
+
+    function _once(fn) {
+        return function() {
+            if (fn === null) return;
+            fn.apply(this, arguments);
+            fn = null;
+        };
+    }
+
+    //// cross-browser compatiblity functions ////
+
+    var _toString = Object.prototype.toString;
+
+    var _isArray = Array.isArray || function (obj) {
+        return _toString.call(obj) === '[object Array]';
+    };
+
+    // Ported from underscore.js isObject
+    var _isObject = function(obj) {
+        var type = typeof obj;
+        return type === 'function' || type === 'object' && !!obj;
+    };
+
+    function _isArrayLike(arr) {
+        return _isArray(arr) || (
+            // has a positive integer length property
+            typeof arr.length === "number" &&
+            arr.length >= 0 &&
+            arr.length % 1 === 0
+        );
+    }
+
+    function _arrayEach(arr, iterator) {
+        var index = -1,
+            length = arr.length;
+
+        while (++index < length) {
+            iterator(arr[index], index, arr);
+        }
+    }
+
+    function _map(arr, iterator) {
+        var index = -1,
+            length = arr.length,
+            result = Array(length);
+
+        while (++index < length) {
+            result[index] = iterator(arr[index], index, arr);
+        }
+        return result;
+    }
+
+    function _range(count) {
+        return _map(Array(count), function (v, i) { return i; });
+    }
+
+    function _reduce(arr, iterator, memo) {
+        _arrayEach(arr, function (x, i, a) {
+            memo = iterator(memo, x, i, a);
+        });
+        return memo;
+    }
+
+    function _forEachOf(object, iterator) {
+        _arrayEach(_keys(object), function (key) {
+            iterator(object[key], key);
+        });
+    }
+
+    function _indexOf(arr, item) {
+        for (var i = 0; i < arr.length; i++) {
+            if (arr[i] === item) return i;
+        }
+        return -1;
+    }
+
+    var _keys = Object.keys || function (obj) {
+        var keys = [];
+        for (var k in obj) {
+            if (obj.hasOwnProperty(k)) {
+                keys.push(k);
+            }
+        }
+        return keys;
+    };
+
+    function _keyIterator(coll) {
+        var i = -1;
+        var len;
+        var keys;
+        if (_isArrayLike(coll)) {
+            len = coll.length;
+            return function next() {
+                i++;
+                return i < len ? i : null;
+            };
+        } else {
+            keys = _keys(coll);
+            len = keys.length;
+            return function next() {
+                i++;
+                return i < len ? keys[i] : null;
+            };
+        }
+    }
+
+    // Similar to ES6's rest param (http://ariya.ofilabs.com/2013/03/es6-and-rest-parameter.html)
+    // This accumulates the arguments passed into an array, after a given index.
+    // From underscore.js (https://github.com/jashkenas/underscore/pull/2140).
+    function _restParam(func, startIndex) {
+        startIndex = startIndex == null ? func.length - 1 : +startIndex;
+        return function() {
+            var length = Math.max(arguments.length - startIndex, 0);
+            var rest = Array(length);
+            for (var index = 0; index < length; index++) {
+                rest[index] = arguments[index + startIndex];
+            }
+            switch (startIndex) {
+                case 0: return func.call(this, rest);
+                case 1: return func.call(this, arguments[0], rest);
+            }
+            // Currently unused but handle cases outside of the switch statement:
+            // var args = Array(startIndex + 1);
+            // for (index = 0; index < startIndex; index++) {
+            //     args[index] = arguments[index];
+            // }
+            // args[startIndex] = rest;
+            // return func.apply(this, args);
+        };
+    }
+
+    function _withoutIndex(iterator) {
+        return function (value, index, callback) {
+            return iterator(value, callback);
+        };
+    }
+
+    //// exported async module functions ////
+
+    //// nextTick implementation with browser-compatible fallback ////
+
+    // capture the global reference to guard against fakeTimer mocks
+    var _setImmediate = typeof setImmediate === 'function' && setImmediate;
+
+    var _delay = _setImmediate ? function(fn) {
+        // not a direct alias for IE10 compatibility
+        _setImmediate(fn);
+    } : function(fn) {
+        setTimeout(fn, 0);
+    };
+
+    if (typeof process === 'object' && typeof process.nextTick === 'function') {
+        async.nextTick = process.nextTick;
+    } else {
+        async.nextTick = _delay;
+    }
+    async.setImmediate = _setImmediate ? _delay : async.nextTick;
+
+
+    async.forEach =
+    async.each = function (arr, iterator, callback) {
+        return async.eachOf(arr, _withoutIndex(iterator), callback);
+    };
+
+    async.forEachSeries =
+    async.eachSeries = function (arr, iterator, callback) {
+        return async.eachOfSeries(arr, _withoutIndex(iterator), callback);
+    };
+
+
+    async.forEachLimit =
+    async.eachLimit = function (arr, limit, iterator, callback) {
+        return _eachOfLimit(limit)(arr, _withoutIndex(iterator), callback);
+    };
+
+    async.forEachOf =
+    async.eachOf = function (object, iterator, callback) {
+        callback = _once(callback || noop);
+        object = object || [];
+
+        var iter = _keyIterator(object);
+        var key, completed = 0;
+
+        while ((key = iter()) != null) {
+            completed += 1;
+            iterator(object[key], key, only_once(done));
+        }
+
+        if (completed === 0) callback(null);
+
+        function done(err) {
+            completed--;
+            if (err) {
+                callback(err);
+            }
+            // Check key is null in case iterator isn't exhausted
+            // and done resolved synchronously.
+            else if (key === null && completed <= 0) {
+                callback(null);
+            }
+        }
+    };
+
+    async.forEachOfSeries =
+    async.eachOfSeries = function (obj, iterator, callback) {
+        callback = _once(callback || noop);
+        obj = obj || [];
+        var nextKey = _keyIterator(obj);
+        var key = nextKey();
+        function iterate() {
+            var sync = true;
+            if (key === null) {
+                return callback(null);
+            }
+            iterator(obj[key], key, only_once(function (err) {
+                if (err) {
+                    callback(err);
+                }
+                else {
+                    key = nextKey();
+                    if (key === null) {
+                        return callback(null);
+                    } else {
+                        if (sync) {
+                            async.setImmediate(iterate);
+                        } else {
+                            iterate();
+                        }
+                    }
+                }
+            }));
+            sync = false;
+        }
+        iterate();
+    };
+
+
+
+    async.forEachOfLimit =
+    async.eachOfLimit = function (obj, limit, iterator, callback) {
+        _eachOfLimit(limit)(obj, iterator, callback);
+    };
+
+    function _eachOfLimit(limit) {
+
+        return function (obj, iterator, callback) {
+            callback = _once(callback || noop);
+            obj = obj || [];
+            var nextKey = _keyIterator(obj);
+            if (limit <= 0) {
+                return callback(null);
+            }
+            var done = false;
+            var running = 0;
+            var errored = false;
+
+            (function replenish () {
+                if (done && running <= 0) {
+                    return callback(null);
+                }
+
+                while (running < limit && !errored) {
+                    var key = nextKey();
+                    if (key === null) {
+                        done = true;
+                        if (running <= 0) {
+                            callback(null);
+                        }
+                        return;
+                    }
+                    running += 1;
+                    iterator(obj[key], key, only_once(function (err) {
+                        running -= 1;
+                        if (err) {
+                            callback(err);
+                            errored = true;
+                        }
+                        else {
+                            replenish();
+                        }
+                    }));
+                }
+            })();
+        };
+    }
+
+
+    function doParallel(fn) {
+        return function (obj, iterator, callback) {
+            return fn(async.eachOf, obj, iterator, callback);
+        };
+    }
+    function doParallelLimit(fn) {
+        return function (obj, limit, iterator, callback) {
+            return fn(_eachOfLimit(limit), obj, iterator, callback);
+        };
+    }
+    function doSeries(fn) {
+        return function (obj, iterator, callback) {
+            return fn(async.eachOfSeries, obj, iterator, callback);
+        };
+    }
+
+    function _asyncMap(eachfn, arr, iterator, callback) {
+        callback = _once(callback || noop);
+        arr = arr || [];
+        var results = _isArrayLike(arr) ? [] : {};
+        eachfn(arr, function (value, index, callback) {
+            iterator(value, function (err, v) {
+                results[index] = v;
+                callback(err);
+            });
+        }, function (err) {
+            callback(err, results);
+        });
+    }
+
+    async.map = doParallel(_asyncMap);
+    async.mapSeries = doSeries(_asyncMap);
+    async.mapLimit = doParallelLimit(_asyncMap);
+
+    // reduce only has a series version, as doing reduce in parallel won't
+    // work in many situations.
+    async.inject =
+    async.foldl =
+    async.reduce = function (arr, memo, iterator, callback) {
+        async.eachOfSeries(arr, function (x, i, callback) {
+            iterator(memo, x, function (err, v) {
+                memo = v;
+                callback(err);
+            });
+        }, function (err) {
+            callback(err, memo);
+        });
+    };
+
+    async.foldr =
+    async.reduceRight = function (arr, memo, iterator, callback) {
+        var reversed = _map(arr, identity).reverse();
+        async.reduce(reversed, memo, iterator, callback);
+    };
+
+    async.transform = function (arr, memo, iterator, callback) {
+        if (arguments.length === 3) {
+            callback = iterator;
+            iterator = memo;
+            memo = _isArray(arr) ? [] : {};
+        }
+
+        async.eachOf(arr, function(v, k, cb) {
+            iterator(memo, v, k, cb);
+        }, function(err) {
+            callback(err, memo);
+        });
+    };
+
+    function _filter(eachfn, arr, iterator, callback) {
+        var results = [];
+        eachfn(arr, function (x, index, callback) {
+            iterator(x, function (v) {
+                if (v) {
+                    results.push({index: index, value: x});
+                }
+                callback();
+            });
+        }, function () {
+            callback(_map(results.sort(function (a, b) {
+                return a.index - b.index;
+            }), function (x) {
+                return x.value;
+            }));
+        });
+    }
+
+    async.select =
+    async.filter = doParallel(_filter);
+
+    async.selectLimit =
+    async.filterLimit = doParallelLimit(_filter);
+
+    async.selectSeries =
+    async.filterSeries = doSeries(_filter);
+
+    function _reject(eachfn, arr, iterator, callback) {
+        _filter(eachfn, arr, function(value, cb) {
+            iterator(value, function(v) {
+                cb(!v);
+            });
+        }, callback);
+    }
+    async.reject = doParallel(_reject);
+    async.rejectLimit = doParallelLimit(_reject);
+    async.rejectSeries = doSeries(_reject);
+
+    function _createTester(eachfn, check, getResult) {
+        return function(arr, limit, iterator, cb) {
+            function done() {
+                if (cb) cb(getResult(false, void 0));
+            }
+            function iteratee(x, _, callback) {
+                if (!cb) return callback();
+                iterator(x, function (v) {
+                    if (cb && check(v)) {
+                        cb(getResult(true, x));
+                        cb = iterator = false;
+                    }
+                    callback();
+                });
+            }
+            if (arguments.length > 3) {
+                eachfn(arr, limit, iteratee, done);
+            } else {
+                cb = iterator;
+                iterator = limit;
+                eachfn(arr, iteratee, done);
+            }
+        };
+    }
+
+    async.any =
+    async.some = _createTester(async.eachOf, toBool, identity);
+
+    async.someLimit = _createTester(async.eachOfLimit, toBool, identity);
+
+    async.all =
+    async.every = _createTester(async.eachOf, notId, notId);
+
+    async.everyLimit = _createTester(async.eachOfLimit, notId, notId);
+
+    function _findGetResult(v, x) {
+        return x;
+    }
+    async.detect = _createTester(async.eachOf, identity, _findGetResult);
+    async.detectSeries = _createTester(async.eachOfSeries, identity, _findGetResult);
+    async.detectLimit = _createTester(async.eachOfLimit, identity, _findGetResult);
+
+    async.sortBy = function (arr, iterator, callback) {
+        async.map(arr, function (x, callback) {
+            iterator(x, function (err, criteria) {
+                if (err) {
+                    callback(err);
+                }
+                else {
+                    callback(null, {value: x, criteria: criteria});
+                }
+            });
+        }, function (err, results) {
+            if (err) {
+                return callback(err);
+            }
+            else {
+                callback(null, _map(results.sort(comparator), function (x) {
+                    return x.value;
+                }));
+            }
+
+        });
+
+        function comparator(left, right) {
+            var a = left.criteria, b = right.criteria;
+            return a < b ? -1 : a > b ? 1 : 0;
+        }
+    };
+
+    async.auto = function (tasks, concurrency, callback) {
+        if (!callback) {
+            // concurrency is optional, shift the args.
+            callback = concurrency;
+            concurrency = null;
+        }
+        callback = _once(callback || noop);
+        var keys = _keys(tasks);
+        var remainingTasks = keys.length;
+        if (!remainingTasks) {
+            return callback(null);
+        }
+        if (!concurrency) {
+            concurrency = remainingTasks;
+        }
+
+        var results = {};
+        var runningTasks = 0;
+
+        var listeners = [];
+        function addListener(fn) {
+            listeners.unshift(fn);
+        }
+        function removeListener(fn) {
+            var idx = _indexOf(listeners, fn);
+            if (idx >= 0) listeners.splice(idx, 1);
+        }
+        function taskComplete() {
+            remainingTasks--;
+            _arrayEach(listeners.slice(0), function (fn) {
+                fn();
+            });
+        }
+
+        addListener(function () {
+            if (!remainingTasks) {
+                callback(null, results);
+            }
+        });
+
+        _arrayEach(keys, function (k) {
+            var task = _isArray(tasks[k]) ? tasks[k]: [tasks[k]];
+            var taskCallback = _restParam(function(err, args) {
+                runningTasks--;
+                if (args.length <= 1) {
+                    args = args[0];
+                }
+                if (err) {
+                    var safeResults = {};
+                    _forEachOf(results, function(val, rkey) {
+                        safeResults[rkey] = val;
+                    });
+                    safeResults[k] = args;
+                    callback(err, safeResults);
+                }
+                else {
+                    results[k] = args;
+                    async.setImmediate(taskComplete);
+                }
+            });
+            var requires = task.slice(0, task.length - 1);
+            // prevent dead-locks
+            var len = requires.length;
+            var dep;
+            while (len--) {
+                if (!(dep = tasks[requires[len]])) {
+                    throw new Error('Has inexistant dependency');
+                }
+                if (_isArray(dep) && _indexOf(dep, k) >= 0) {
+                    throw new Error('Has cyclic dependencies');
+                }
+            }
+            function ready() {
+                return runningTasks < concurrency && _reduce(requires, function (a, x) {
+                    return (a && results.hasOwnProperty(x));
+                }, true) && !results.hasOwnProperty(k);
+            }
+            if (ready()) {
+                runningTasks++;
+                task[task.length - 1](taskCallback, results);
+            }
+            else {
+                addListener(listener);
+            }
+            function listener() {
+                if (ready()) {
+                    runningTasks++;
+                    removeListener(listener);
+                    task[task.length - 1](taskCallback, results);
+                }
+            }
+        });
+    };
+
+
+
+    async.retry = function(times, task, callback) {
+        var DEFAULT_TIMES = 5;
+        var DEFAULT_INTERVAL = 0;
+
+        var attempts = [];
+
+        var opts = {
+            times: DEFAULT_TIMES,
+            interval: DEFAULT_INTERVAL
+        };
+
+        function parseTimes(acc, t){
+            if(typeof t === 'number'){
+                acc.times = parseInt(t, 10) || DEFAULT_TIMES;
+            } else if(typeof t === 'object'){
+                acc.times = parseInt(t.times, 10) || DEFAULT_TIMES;
+                acc.interval = parseInt(t.interval, 10) || DEFAULT_INTERVAL;
+            } else {
+                throw new Error('Unsupported argument type for \'times\': ' + typeof t);
+            }
+        }
+
+        var length = arguments.length;
+        if (length < 1 || length > 3) {
+            throw new Error('Invalid arguments - must be either (task), (task, callback), (times, task) or (times, task, callback)');
+        } else if (length <= 2 && typeof times === 'function') {
+            callback = task;
+            task = times;
+        }
+        if (typeof times !== 'function') {
+            parseTimes(opts, times);
+        }
+        opts.callback = callback;
+        opts.task = task;
+
+        function wrappedTask(wrappedCallback, wrappedResults) {
+            function retryAttempt(task, finalAttempt) {
+                return function(seriesCallback) {
+                    task(function(err, result){
+                        seriesCallback(!err || finalAttempt, {err: err, result: result});
+                    }, wrappedResults);
+                };
+            }
+
+            function retryInterval(interval){
+                return function(seriesCallback){
+                    setTimeout(function(){
+                        seriesCallback(null);
+                    }, interval);
+                };
+            }
+
+            while (opts.times) {
+
+                var finalAttempt = !(opts.times-=1);
+                attempts.push(retryAttempt(opts.task, finalAttempt));
+                if(!finalAttempt && opts.interval > 0){
+                    attempts.push(retryInterval(opts.interval));
+                }
+            }
+
+            async.series(attempts, function(done, data){
+                data = data[data.length - 1];
+                (wrappedCallback || opts.callback)(data.err, data.result);
+            });
+        }
+
+        // If a callback is passed, run this as a controll flow
+        return opts.callback ? wrappedTask() : wrappedTask;
+    };
+
+    async.waterfall = function (tasks, callback) {
+        callback = _once(callback || noop);
+        if (!_isArray(tasks)) {
+            var err = new Error('First argument to waterfall must be an array of functions');
+            return callback(err);
+        }
+        if (!tasks.length) {
+            return callback();
+        }
+        function wrapIterator(iterator) {
+            return _restParam(function (err, args) {
+                if (err) {
+                    callback.apply(null, [err].concat(args));
+                }
+                else {
+                    var next = iterator.next();
+                    if (next) {
+                        args.push(wrapIterator(next));
+                    }
+                    else {
+                        args.push(callback);
+                    }
+                    ensureAsync(iterator).apply(null, args);
+                }
+            });
+        }
+        wrapIterator(async.iterator(tasks))();
+    };
+
+    function _parallel(eachfn, tasks, callback) {
+        callback = callback || noop;
+        var results = _isArrayLike(tasks) ? [] : {};
+
+        eachfn(tasks, function (task, key, callback) {
+            task(_restParam(function (err, args) {
+                if (args.length <= 1) {
+                    args = args[0];
+                }
+                results[key] = args;
+                callback(err);
+            }));
+        }, function (err) {
+            callback(err, results);
+        });
+    }
+
+    async.parallel = function (tasks, callback) {
+        _parallel(async.eachOf, tasks, callback);
+    };
+
+    async.parallelLimit = function(tasks, limit, callback) {
+        _parallel(_eachOfLimit(limit), tasks, callback);
+    };
+
+    async.series = function(tasks, callback) {
+        _parallel(async.eachOfSeries, tasks, callback);
+    };
+
+    async.iterator = function (tasks) {
+        function makeCallback(index) {
+            function fn() {
+                if (tasks.length) {
+                    tasks[index].apply(null, arguments);
+                }
+                return fn.next();
+            }
+            fn.next = function () {
+                return (index < tasks.length - 1) ? makeCallback(index + 1): null;
+            };
+            return fn;
+        }
+        return makeCallback(0);
+    };
+
+    async.apply = _restParam(function (fn, args) {
+        return _restParam(function (callArgs) {
+            return fn.apply(
+                null, args.concat(callArgs)
+            );
+        });
+    });
+
+    function _concat(eachfn, arr, fn, callback) {
+        var result = [];
+        eachfn(arr, function (x, index, cb) {
+            fn(x, function (err, y) {
+                result = result.concat(y || []);
+                cb(err);
+            });
+        }, function (err) {
+            callback(err, result);
+        });
+    }
+    async.concat = doParallel(_concat);
+    async.concatSeries = doSeries(_concat);
+
+    async.whilst = function (test, iterator, callback) {
+        callback = callback || noop;
+        if (test()) {
+            var next = _restParam(function(err, args) {
+                if (err) {
+                    callback(err);
+                } else if (test.apply(this, args)) {
+                    iterator(next);
+                } else {
+                    callback(null);
+                }
+            });
+            iterator(next);
+        } else {
+            callback(null);
+        }
+    };
+
+    async.doWhilst = function (iterator, test, callback) {
+        var calls = 0;
+        return async.whilst(function() {
+            return ++calls <= 1 || test.apply(this, arguments);
+        }, iterator, callback);
+    };
+
+    async.until = function (test, iterator, callback) {
+        return async.whilst(function() {
+            return !test.apply(this, arguments);
+        }, iterator, callback);
+    };
+
+    async.doUntil = function (iterator, test, callback) {
+        return async.doWhilst(iterator, function() {
+            return !test.apply(this, arguments);
+        }, callback);
+    };
+
+    async.during = function (test, iterator, callback) {
+        callback = callback || noop;
+
+        var next = _restParam(function(err, args) {
+            if (err) {
+                callback(err);
+            } else {
+                args.push(check);
+                test.apply(this, args);
+            }
+        });
+
+        var check = function(err, truth) {
+            if (err) {
+                callback(err);
+            } else if (truth) {
+                iterator(next);
+            } else {
+                callback(null);
+            }
+        };
+
+        test(check);
+    };
+
+    async.doDuring = function (iterator, test, callback) {
+        var calls = 0;
+        async.during(function(next) {
+            if (calls++ < 1) {
+                next(null, true);
+            } else {
+                test.apply(this, arguments);
+            }
+        }, iterator, callback);
+    };
+
+    function _queue(worker, concurrency, payload) {
+        if (concurrency == null) {
+            concurrency = 1;
+        }
+        else if(concurrency === 0) {
+            throw new Error('Concurrency must not be zero');
+        }
+        function _insert(q, data, pos, callback) {
+            if (callback != null && typeof callback !== "function") {
+                throw new Error("task callback must be a function");
+            }
+            q.started = true;
+            if (!_isArray(data)) {
+                data = [data];
+            }
+            if(data.length === 0 && q.idle()) {
+                // call drain immediately if there are no tasks
+                return async.setImmediate(function() {
+                    q.drain();
+                });
+            }
+            _arrayEach(data, function(task) {
+                var item = {
+                    data: task,
+                    callback: callback || noop
+                };
+
+                if (pos) {
+                    q.tasks.unshift(item);
+                } else {
+                    q.tasks.push(item);
+                }
+
+                if (q.tasks.length === q.concurrency) {
+                    q.saturated();
+                }
+            });
+            async.setImmediate(q.process);
+        }
+        function _next(q, tasks) {
+            return function(){
+                workers -= 1;
+
+                var removed = false;
+                var args = arguments;
+                _arrayEach(tasks, function (task) {
+                    _arrayEach(workersList, function (worker, index) {
+                        if (worker === task && !removed) {
+                            workersList.splice(index, 1);
+                            removed = true;
+                        }
+                    });
+
+                    task.callback.apply(task, args);
+                });
+                if (q.tasks.length + workers === 0) {
+                    q.drain();
+                }
+                q.process();
+            };
+        }
+
+        var workers = 0;
+        var workersList = [];
+        var q = {
+            tasks: [],
+            concurrency: concurrency,
+            payload: payload,
+            saturated: noop,
+            empty: noop,
+            drain: noop,
+            started: false,
+            paused: false,
+            push: function (data, callback) {
+                _insert(q, data, false, callback);
+            },
+            kill: function () {
+                q.drain = noop;
+                q.tasks = [];
+            },
+            unshift: function (data, callback) {
+                _insert(q, data, true, callback);
+            },
+            process: function () {
+                if (!q.paused && workers < q.concurrency && q.tasks.length) {
+                    while(workers < q.concurrency && q.tasks.length){
+                        var tasks = q.payload ?
+                            q.tasks.splice(0, q.payload) :
+                            q.tasks.splice(0, q.tasks.length);
+
+                        var data = _map(tasks, function (task) {
+                            return task.data;
+                        });
+
+                        if (q.tasks.length === 0) {
+                            q.empty();
+                        }
+                        workers += 1;
+                        workersList.push(tasks[0]);
+                        var cb = only_once(_next(q, tasks));
+                        worker(data, cb);
+                    }
+                }
+            },
+            length: function () {
+                return q.tasks.length;
+            },
+            running: function () {
+                return workers;
+            },
+            workersList: function () {
+                return workersList;
+            },
+            idle: function() {
+                return q.tasks.length + workers === 0;
+            },
+            pause: function () {
+                q.paused = true;
+            },
+            resume: function () {
+                if (q.paused === false) { return; }
+                q.paused = false;
+                var resumeCount = Math.min(q.concurrency, q.tasks.length);
+                // Need to call q.process once per concurrent
+                // worker to preserve full concurrency after pause
+                for (var w = 1; w <= resumeCount; w++) {
+                    async.setImmediate(q.process);
+                }
+            }
+        };
+        return q;
+    }
+
+    async.queue = function (worker, concurrency) {
+        var q = _queue(function (items, cb) {
+            worker(items[0], cb);
+        }, concurrency, 1);
+
+        return q;
+    };
+
+    async.priorityQueue = function (worker, concurrency) {
+
+        function _compareTasks(a, b){
+            return a.priority - b.priority;
+        }
+
+        function _binarySearch(sequence, item, compare) {
+            var beg = -1,
+                end = sequence.length - 1;
+            while (beg < end) {
+                var mid = beg + ((end - beg + 1) >>> 1);
+                if (compare(item, sequence[mid]) >= 0) {
+                    beg = mid;
+                } else {
+                    end = mid - 1;
+                }
+            }
+            return beg;
+        }
+
+        function _insert(q, data, priority, callback) {
+            if (callback != null && typeof callback !== "function") {
+                throw new Error("task callback must be a function");
+            }
+            q.started = true;
+            if (!_isArray(data)) {
+                data = [data];
+            }
+            if(data.length === 0) {
+                // call drain immediately if there are no tasks
+                return async.setImmediate(function() {
+                    q.drain();
+                });
+            }
+            _arrayEach(data, function(task) {
+                var item = {
+                    data: task,
+                    priority: priority,
+                    callback: typeof callback === 'function' ? callback : noop
+                };
+
+                q.tasks.splice(_binarySearch(q.tasks, item, _compareTasks) + 1, 0, item);
+
+                if (q.tasks.length === q.concurrency) {
+                    q.saturated();
+                }
+                async.setImmediate(q.process);
+            });
+        }
+
+        // Start with a normal queue
+        var q = async.queue(worker, concurrency);
+
+        // Override push to accept second parameter representing priority
+        q.push = function (data, priority, callback) {
+            _insert(q, data, priority, callback);
+        };
+
+        // Remove unshift function
+        delete q.unshift;
+
+        return q;
+    };
+
+    async.cargo = function (worker, payload) {
+        return _queue(worker, 1, payload);
+    };
+
+    function _console_fn(name) {
+        return _restParam(function (fn, args) {
+            fn.apply(null, args.concat([_restParam(function (err, args) {
+                if (typeof console === 'object') {
+                    if (err) {
+                        if (console.error) {
+                            console.error(err);
+                        }
+                    }
+                    else if (console[name]) {
+                        _arrayEach(args, function (x) {
+                            console[name](x);
+                        });
+                    }
+                }
+            })]));
+        });
+    }
+    async.log = _console_fn('log');
+    async.dir = _console_fn('dir');
+    /*async.info = _console_fn('info');
+    async.warn = _console_fn('warn');
+    async.error = _console_fn('error');*/
+
+    async.memoize = function (fn, hasher) {
+        var memo = {};
+        var queues = {};
+        hasher = hasher || identity;
+        var memoized = _restParam(function memoized(args) {
+            var callback = args.pop();
+            var key = hasher.apply(null, args);
+            if (key in memo) {
+                async.setImmediate(function () {
+                    callback.apply(null, memo[key]);
+                });
+            }
+            else if (key in queues) {
+                queues[key].push(callback);
+            }
+            else {
+                queues[key] = [callback];
+                fn.apply(null, args.concat([_restParam(function (args) {
+                    memo[key] = args;
+                    var q = queues[key];
+                    delete queues[key];
+                    for (var i = 0, l = q.length; i < l; i++) {
+                        q[i].apply(null, args);
+                    }
+                })]));
+            }
+        });
+        memoized.memo = memo;
+        memoized.unmemoized = fn;
+        return memoized;
+    };
+
+    async.unmemoize = function (fn) {
+        return function () {
+            return (fn.unmemoized || fn).apply(null, arguments);
+        };
+    };
+
+    function _times(mapper) {
+        return function (count, iterator, callback) {
+            mapper(_range(count), iterator, callback);
+        };
+    }
+
+    async.times = _times(async.map);
+    async.timesSeries = _times(async.mapSeries);
+    async.timesLimit = function (count, limit, iterator, callback) {
+        return async.mapLimit(_range(count), limit, iterator, callback);
+    };
+
+    async.seq = function (/* functions... */) {
+        var fns = arguments;
+        return _restParam(function (args) {
+            var that = this;
+
+            var callback = args[args.length - 1];
+            if (typeof callback == 'function') {
+                args.pop();
+            } else {
+                callback = noop;
+            }
+
+            async.reduce(fns, args, function (newargs, fn, cb) {
+                fn.apply(that, newargs.concat([_restParam(function (err, nextargs) {
+                    cb(err, nextargs);
+                })]));
+            },
+            function (err, results) {
+                callback.apply(that, [err].concat(results));
+            });
+        });
+    };
+
+    async.compose = function (/* functions... */) {
+        return async.seq.apply(null, Array.prototype.reverse.call(arguments));
+    };
+
+
+    function _applyEach(eachfn) {
+        return _restParam(function(fns, args) {
+            var go = _restParam(function(args) {
+                var that = this;
+                var callback = args.pop();
+                return eachfn(fns, function (fn, _, cb) {
+                    fn.apply(that, args.concat([cb]));
+                },
+                callback);
+            });
+            if (args.length) {
+                return go.apply(this, args);
+            }
+            else {
+                return go;
+            }
+        });
+    }
+
+    async.applyEach = _applyEach(async.eachOf);
+    async.applyEachSeries = _applyEach(async.eachOfSeries);
+
+
+    async.forever = function (fn, callback) {
+        var done = only_once(callback || noop);
+        var task = ensureAsync(fn);
+        function next(err) {
+            if (err) {
+                return done(err);
+            }
+            task(next);
+        }
+        next();
+    };
+
+    function ensureAsync(fn) {
+        return _restParam(function (args) {
+            var callback = args.pop();
+            args.push(function () {
+                var innerArgs = arguments;
+                if (sync) {
+                    async.setImmediate(function () {
+                        callback.apply(null, innerArgs);
+                    });
+                } else {
+                    callback.apply(null, innerArgs);
+                }
+            });
+            var sync = true;
+            fn.apply(this, args);
+            sync = false;
+        });
+    }
+
+    async.ensureAsync = ensureAsync;
+
+    async.constant = _restParam(function(values) {
+        var args = [null].concat(values);
+        return function (callback) {
+            return callback.apply(this, args);
+        };
+    });
+
+    async.wrapSync =
+    async.asyncify = function asyncify(func) {
+        return _restParam(function (args) {
+            var callback = args.pop();
+            var result;
+            try {
+                result = func.apply(this, args);
+            } catch (e) {
+                return callback(e);
+            }
+            // if result is Promise object
+            if (_isObject(result) && typeof result.then === "function") {
+                result.then(function(value) {
+                    callback(null, value);
+                })["catch"](function(err) {
+                    callback(err.message ? err : new Error(err));
+                });
+            } else {
+                callback(null, result);
+            }
+        });
+    };
+
+    // Node.js
+    if (typeof module === 'object' && module.exports) {
+        module.exports = async;
+    }
+    // AMD / RequireJS
+    else if (typeof define === 'function' && define.amd) {
+        define([], function () {
+            return async;
+        });
+    }
+    // included directly via <script> tag
+    else {
+        root.async = async;
+    }
+
+}());
diff --git a/dist/async.min.js b/dist/async.min.js
new file mode 100644
index 0000000..b947fc4
--- /dev/null
+++ b/dist/async.min.js
@@ -0,0 +1,2 @@
+!function(){function n(){}function t(n){return n}function e(n){return!!n}function r(n){return!n}function u(n){return function(){if(null===n)throw new Error("Callback was already called.");n.apply(this,arguments),n=null}}function i(n){return function(){null!==n&&(n.apply(this,arguments),n=null)}}function o(n){return M(n)||"number"==typeof n.length&&n.length>=0&&n.length%1===0}function c(n,t){for(var e=-1,r=n.length;++e<r;)t(n[e],e,n)}function a(n,t){for(var e=-1,r=n.length,u=Array(r);++e<r;)u[e]=t(n[e],e,n);return u}function f(n){return a(Array(n),function(n,t){return t})}function l(n,t,e){return c(n,function(n,r,u){e=t(e,n,r,u)}),e}function s(n,t){c(W(n),function(e){t(n[e],e)})}function p(n,t){for(var e=0;e<n.length;e++)if(n[e]===t)return e;return-1}function h(n){var t,e,r=-1;return o(n)?(t=n.length,function(){return r++,t>r?r:null}):(e=W(n),t=e.length,function(){return r++,t>r?e[r]:null})}function m(n,t){return t=null==t?n.length-1:+t,function(){for(var e=Math.max(arguments.length-t,0),r=Array(e),u=0;e>u;u++)r[u]=arguments[u+t];switch(t){case 0:return n.call(this,r);case 1:return n.call(this,arguments[0],r)}}}function y(n){return function(t,e,r){return n(t,r)}}function v(t){return function(e,r,o){o=i(o||n),e=e||[];var c=h(e);if(0>=t)return o(null);var a=!1,f=0,l=!1;!function s(){if(a&&0>=f)return o(null);for(;t>f&&!l;){var n=c();if(null===n)return a=!0,void(0>=f&&o(null));f+=1,r(e[n],n,u(function(n){f-=1,n?(o(n),l=!0):s()}))}}()}}function d(n){return function(t,e,r){return n(C.eachOf,t,e,r)}}function g(n){return function(t,e,r,u){return n(v(e),t,r,u)}}function k(n){return function(t,e,r){return n(C.eachOfSeries,t,e,r)}}function b(t,e,r,u){u=i(u||n),e=e||[];var c=o(e)?[]:{};t(e,function(n,t,e){r(n,function(n,r){c[t]=r,e(n)})},function(n){u(n,c)})}function w(n,t,e,r){var u=[];n(t,function(n,t,r){e(n,function(e){e&&u.push({index:t,value:n}),r()})},function(){r(a(u.sort(function(n,t){return n.index-t.index}),function(n){return n.value}))})}function O(n,t,e,r){w(n,t,function(n,t){e(n,function(n){t(!n)})},r)}function S(n,t,e){return function(r,u,i,o){function c(){o&&o(e(!1,void 0))}function a(n,r,u){return o?void i(n,function(r){o&&t(r)&&(o(e(!0,n)),o=i=!1),u()}):u()}arguments.length>3?n(r,u,a,c):(o=i,i=u,n(r,a,c))}}function E(n,t){return t}function L(t,e,r){r=r||n;var u=o(e)?[]:{};t(e,function(n,t,e){n(m(function(n,r){r.length<=1&&(r=r[0]),u[t]=r,e(n)}))},function(n){r(n,u)})}function I(n,t,e,r){var u=[];n(t,function(n,t,r){e(n,function(n,t){u=u.concat(t||[]),r(n)})},function(n){r(n,u)})}function x(t,e,r){function i(t,e,r,u){if(null!=u&&"function"!=typeof u)throw new Error("task callback must be a function");return t.started=!0,M(e)||(e=[e]),0===e.length&&t.idle()?C.setImmediate(function(){t.drain()}):(c(e,function(e){var i={data:e,callback:u||n};r?t.tasks.unshift(i):t.tasks.push(i),t.tasks.length===t.concurrency&&t.saturated()}),void C.setImmediate(t.process))}function o(n,t){return function(){f-=1;var e=!1,r=arguments;c(t,function(n){c(l,function(t,r){t!==n||e||(l.splice(r,1),e=!0)}),n.callback.apply(n,r)}),n.tasks.length+f===0&&n.drain(),n.process()}}if(null==e)e=1;else if(0===e)throw new Error("Concurrency must not be zero");var f=0,l=[],s={tasks:[],concurrency:e,payload:r,saturated:n,empty:n,drain:n,started:!1,paused:!1,push:function(n,t){i(s,n,!1,t)},kill:function(){s.drain=n,s.tasks=[]},unshift:function(n,t){i(s,n,!0,t)},process:function(){if(!s.paused&&f<s.concurrency&&s.tasks.length)for(;f<s.concurrency&&s.tasks.length;){var n=s.payload?s.tasks.splice(0,s.payload):s.tasks.splice(0,s.tasks.length),e=a(n,function(n){return n.data});0===s.tasks.length&&s.empty(),f+=1,l.push(n[0]);var r=u(o(s,n));t(e,r)}},length:function(){return s.tasks.length},running:function(){return f},workersList:function(){return l},idle:function(){return s.tasks.length+f===0},pause:function(){s.paused=!0},resume:function(){if(s.paused!==!1){s.paused=!1;for(var n=Math.min(s.concurrency,s.tasks.length),t=1;n>=t;t++)C.setImmediate(s.process)}}};return s}function j(n){return m(function(t,e){t.apply(null,e.concat([m(function(t,e){"object"==typeof console&&(t?console.error&&console.error(t):console[n]&&c(e,function(t){console[n](t)}))})]))})}function A(n){return function(t,e,r){n(f(t),e,r)}}function T(n){return m(function(t,e){var r=m(function(e){var r=this,u=e.pop();return n(t,function(n,t,u){n.apply(r,e.concat([u]))},u)});return e.length?r.apply(this,e):r})}function z(n){return m(function(t){var e=t.pop();t.push(function(){var n=arguments;r?C.setImmediate(function(){e.apply(null,n)}):e.apply(null,n)});var r=!0;n.apply(this,t),r=!1})}var q,C={},P="object"==typeof self&&self.self===self&&self||"object"==typeof global&&global.global===global&&global||this;null!=P&&(q=P.async),C.noConflict=function(){return P.async=q,C};var H=Object.prototype.toString,M=Array.isArray||function(n){return"[object Array]"===H.call(n)},U=function(n){var t=typeof n;return"function"===t||"object"===t&&!!n},W=Object.keys||function(n){var t=[];for(var e in n)n.hasOwnProperty(e)&&t.push(e);return t},B="function"==typeof setImmediate&&setImmediate,D=B?function(n){B(n)}:function(n){setTimeout(n,0)};"object"==typeof process&&"function"==typeof process.nextTick?C.nextTick=process.nextTick:C.nextTick=D,C.setImmediate=B?D:C.nextTick,C.forEach=C.each=function(n,t,e){return C.eachOf(n,y(t),e)},C.forEachSeries=C.eachSeries=function(n,t,e){return C.eachOfSeries(n,y(t),e)},C.forEachLimit=C.eachLimit=function(n,t,e,r){return v(t)(n,y(e),r)},C.forEachOf=C.eachOf=function(t,e,r){function o(n){f--,n?r(n):null===c&&0>=f&&r(null)}r=i(r||n),t=t||[];for(var c,a=h(t),f=0;null!=(c=a());)f+=1,e(t[c],c,u(o));0===f&&r(null)},C.forEachOfSeries=C.eachOfSeries=function(t,e,r){function o(){var n=!0;return null===a?r(null):(e(t[a],a,u(function(t){if(t)r(t);else{if(a=c(),null===a)return r(null);n?C.setImmediate(o):o()}})),void(n=!1))}r=i(r||n),t=t||[];var c=h(t),a=c();o()},C.forEachOfLimit=C.eachOfLimit=function(n,t,e,r){v(t)(n,e,r)},C.map=d(b),C.mapSeries=k(b),C.mapLimit=g(b),C.inject=C.foldl=C.reduce=function(n,t,e,r){C.eachOfSeries(n,function(n,r,u){e(t,n,function(n,e){t=e,u(n)})},function(n){r(n,t)})},C.foldr=C.reduceRight=function(n,e,r,u){var i=a(n,t).reverse();C.reduce(i,e,r,u)},C.transform=function(n,t,e,r){3===arguments.length&&(r=e,e=t,t=M(n)?[]:{}),C.eachOf(n,function(n,r,u){e(t,n,r,u)},function(n){r(n,t)})},C.select=C.filter=d(w),C.selectLimit=C.filterLimit=g(w),C.selectSeries=C.filterSeries=k(w),C.reject=d(O),C.rejectLimit=g(O),C.rejectSeries=k(O),C.any=C.some=S(C.eachOf,e,t),C.someLimit=S(C.eachOfLimit,e,t),C.all=C.every=S(C.eachOf,r,r),C.everyLimit=S(C.eachOfLimit,r,r),C.detect=S(C.eachOf,t,E),C.detectSeries=S(C.eachOfSeries,t,E),C.detectLimit=S(C.eachOfLimit,t,E),C.sortBy=function(n,t,e){function r(n,t){var e=n.criteria,r=t.criteria;return r>e?-1:e>r?1:0}C.map(n,function(n,e){t(n,function(t,r){t?e(t):e(null,{value:n,criteria:r})})},function(n,t){return n?e(n):void e(null,a(t.sort(r),function(n){return n.value}))})},C.auto=function(t,e,r){function u(n){d.unshift(n)}function o(n){var t=p(d,n);t>=0&&d.splice(t,1)}function a(){h--,c(d.slice(0),function(n){n()})}r||(r=e,e=null),r=i(r||n);var f=W(t),h=f.length;if(!h)return r(null);e||(e=h);var y={},v=0,d=[];u(function(){h||r(null,y)}),c(f,function(n){function i(){return e>v&&l(g,function(n,t){return n&&y.hasOwnProperty(t)},!0)&&!y.hasOwnProperty(n)}function c(){i()&&(v++,o(c),h[h.length-1](d,y))}for(var f,h=M(t[n])?t[n]:[t[n]],d=m(function(t,e){if(v--,e.length<=1&&(e=e[0]),t){var u={};s(y,function(n,t){u[t]=n}),u[n]=e,r(t,u)}else y[n]=e,C.setImmediate(a)}),g=h.slice(0,h.length-1),k=g.length;k--;){if(!(f=t[g[k]]))throw new Error("Has inexistant dependency");if(M(f)&&p(f,n)>=0)throw new Error("Has cyclic dependencies")}i()?(v++,h[h.length-1](d,y)):u(c)})},C.retry=function(n,t,e){function r(n,t){if("number"==typeof t)n.times=parseInt(t,10)||i;else{if("object"!=typeof t)throw new Error("Unsupported argument type for 'times': "+typeof t);n.times=parseInt(t.times,10)||i,n.interval=parseInt(t.interval,10)||o}}function u(n,t){function e(n,e){return function(r){n(function(n,t){r(!n||e,{err:n,result:t})},t)}}function r(n){return function(t){setTimeout(function(){t(null)},n)}}for(;a.times;){var u=!(a.times-=1);c.push(e(a.task,u)),!u&&a.interval>0&&c.push(r(a.interval))}C.series(c,function(t,e){e=e[e.length-1],(n||a.callback)(e.err,e.result)})}var i=5,o=0,c=[],a={times:i,interval:o},f=arguments.length;if(1>f||f>3)throw new Error("Invalid arguments - must be either (task), (task, callback), (times, task) or (times, task, callback)");return 2>=f&&"function"==typeof n&&(e=t,t=n),"function"!=typeof n&&r(a,n),a.callback=e,a.task=t,a.callback?u():u},C.waterfall=function(t,e){function r(n){return m(function(t,u){if(t)e.apply(null,[t].concat(u));else{var i=n.next();i?u.push(r(i)):u.push(e),z(n).apply(null,u)}})}if(e=i(e||n),!M(t)){var u=new Error("First argument to waterfall must be an array of functions");return e(u)}return t.length?void r(C.iterator(t))():e()},C.parallel=function(n,t){L(C.eachOf,n,t)},C.parallelLimit=function(n,t,e){L(v(t),n,e)},C.series=function(n,t){L(C.eachOfSeries,n,t)},C.iterator=function(n){function t(e){function r(){return n.length&&n[e].apply(null,arguments),r.next()}return r.next=function(){return e<n.length-1?t(e+1):null},r}return t(0)},C.apply=m(function(n,t){return m(function(e){return n.apply(null,t.concat(e))})}),C.concat=d(I),C.concatSeries=k(I),C.whilst=function(t,e,r){if(r=r||n,t()){var u=m(function(n,i){n?r(n):t.apply(this,i)?e(u):r(null)});e(u)}else r(null)},C.doWhilst=function(n,t,e){var r=0;return C.whilst(function(){return++r<=1||t.apply(this,arguments)},n,e)},C.until=function(n,t,e){return C.whilst(function(){return!n.apply(this,arguments)},t,e)},C.doUntil=function(n,t,e){return C.doWhilst(n,function(){return!t.apply(this,arguments)},e)},C.during=function(t,e,r){r=r||n;var u=m(function(n,e){n?r(n):(e.push(i),t.apply(this,e))}),i=function(n,t){n?r(n):t?e(u):r(null)};t(i)},C.doDuring=function(n,t,e){var r=0;C.during(function(n){r++<1?n(null,!0):t.apply(this,arguments)},n,e)},C.queue=function(n,t){var e=x(function(t,e){n(t[0],e)},t,1);return e},C.priorityQueue=function(t,e){function r(n,t){return n.priority-t.priority}function u(n,t,e){for(var r=-1,u=n.length-1;u>r;){var i=r+(u-r+1>>>1);e(t,n[i])>=0?r=i:u=i-1}return r}function i(t,e,i,o){if(null!=o&&"function"!=typeof o)throw new Error("task callback must be a function");return t.started=!0,M(e)||(e=[e]),0===e.length?C.setImmediate(function(){t.drain()}):void c(e,function(e){var c={data:e,priority:i,callback:"function"==typeof o?o:n};t.tasks.splice(u(t.tasks,c,r)+1,0,c),t.tasks.length===t.concurrency&&t.saturated(),C.setImmediate(t.process)})}var o=C.queue(t,e);return o.push=function(n,t,e){i(o,n,t,e)},delete o.unshift,o},C.cargo=function(n,t){return x(n,1,t)},C.log=j("log"),C.dir=j("dir"),C.memoize=function(n,e){var r={},u={};e=e||t;var i=m(function(t){var i=t.pop(),o=e.apply(null,t);o in r?C.setImmediate(function(){i.apply(null,r[o])}):o in u?u[o].push(i):(u[o]=[i],n.apply(null,t.concat([m(function(n){r[o]=n;var t=u[o];delete u[o];for(var e=0,i=t.length;i>e;e++)t[e].apply(null,n)})])))});return i.memo=r,i.unmemoized=n,i},C.unmemoize=function(n){return function(){return(n.unmemoized||n).apply(null,arguments)}},C.times=A(C.map),C.timesSeries=A(C.mapSeries),C.timesLimit=function(n,t,e,r){return C.mapLimit(f(n),t,e,r)},C.seq=function(){var t=arguments;return m(function(e){var r=this,u=e[e.length-1];"function"==typeof u?e.pop():u=n,C.reduce(t,e,function(n,t,e){t.apply(r,n.concat([m(function(n,t){e(n,t)})]))},function(n,t){u.apply(r,[n].concat(t))})})},C.compose=function(){return C.seq.apply(null,Array.prototype.reverse.call(arguments))},C.applyEach=T(C.eachOf),C.applyEachSeries=T(C.eachOfSeries),C.forever=function(t,e){function r(n){return n?i(n):void o(r)}var i=u(e||n),o=z(t);r()},C.ensureAsync=z,C.constant=m(function(n){var t=[null].concat(n);return function(n){return n.apply(this,t)}}),C.wrapSync=C.asyncify=function(n){return m(function(t){var e,r=t.pop();try{e=n.apply(this,t)}catch(u){return r(u)}U(e)&&"function"==typeof e.then?e.then(function(n){r(null,n)})["catch"](function(n){r(n.message?n:new Error(n))}):r(null,e)})},"object"==typeof module&&module.exports?module.exports=C:"function"==typeof define&&define.amd?define([],function(){return C}):P.async=C}();
+//# sourceMappingURL=dist/async.min.map
\ No newline at end of file
diff --git a/dist/async.min.map b/dist/async.min.map
new file mode 100644
index 0000000..6afbed0
--- /dev/null
+++ b/dist/async.min.map
@@ -0,0 +1 @@
+{"version":3,"file":"dist/async.min.js","sources":["dist/async.js"],"names":["noop","identity","v","toBool","notId","only_once","fn","Error","apply","this","arguments","_once","_isArrayLike","arr","_isArray","length","_arrayEach","iterator","index","_map","result","Array","_range","count","i","_reduce","memo","x","a","_forEachOf","object","_keys","key","_indexOf","item","_keyIterator","coll","len","keys","_restParam","func","startIndex","Math","max","rest","call","_withoutIndex","value","callback","_eachOfLimit","limit","obj","nextKey","done","running","errored","replenish","err","doParallel","async","eachOf","doParallelLimit","doSeries","eachOfSeries","_asyncMap","eachfn","results","_filter","push","sort","b","_reject","cb","_createTester","check","getResult","iteratee","_","_findGetResult","_parallel","tasks","task","args","_concat","y","concat","_queue","worker","concurrency","payload","_insert","q","data","pos","started","idle","setImmediate","drain","unshift","saturated","process","_next","workers","removed","workersList","splice","empty","paused","kill","pause","resume","resumeCount","min","w","_console_fn","name","console","error","_times","mapper","_applyEach","fns","go","that","pop","ensureAsync","innerArgs","sync","previous_async","root","self","global","noConflict","_toString","Object","prototype","toString","isArray","_isObject","type","k","hasOwnProperty","_setImmediate","_delay","setTimeout","nextTick","forEach","each","forEachSeries","eachSeries","forEachLimit","eachLimit","forEachOf","completed","iter","forEachOfSeries","iterate","forEachOfLimit","eachOfLimit","map","mapSeries","mapLimit","inject","foldl","reduce","foldr","reduceRight","reversed","reverse","transform","select","filter","selectLimit","filterLimit","selectSeries","filterSeries","reject","rejectLimit","rejectSeries","any","some","someLimit","all","every","everyLimit","detect","detectSeries","detectLimit","sortBy","comparator","left","right","criteria","auto","addListener","listeners","removeListener","idx","taskComplete","remainingTasks","slice","runningTasks","ready","requires","listener","taskCallback","dep","safeResults","val","rkey","retry","times","parseTimes","acc","t","parseInt","DEFAULT_TIMES","interval","DEFAULT_INTERVAL","wrappedTask","wrappedCallback","wrappedResults","retryAttempt","finalAttempt","seriesCallback","retryInterval","opts","attempts","series","waterfall","wrapIterator","next","parallel","parallelLimit","makeCallback","callArgs","concatSeries","whilst","test","doWhilst","calls","until","doUntil","during","truth","doDuring","queue","items","priorityQueue","_compareTasks","priority","_binarySearch","sequence","compare","beg","end","mid","cargo","log","dir","memoize","hasher","queues","memoized","l","unmemoized","unmemoize","timesSeries","timesLimit","seq","newargs","nextargs","compose","applyEach","applyEachSeries","forever","constant","values","wrapSync","asyncify","e","then","message","module","exports","define","amd"],"mappings":"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"}
\ No newline at end of file