Set up async bundles

31 files changed, 301 insertions, 115 deletions

diff --git a/lib/apply.js b/lib/apply.js
index f185597..1d62d75 100644
--- a/lib/apply.js
+++ b/lib/apply.js
@@ -1,9 +1,9 @@
 'use strict';
 
-import restParam from 'lodash/function/restParam';
+import rest from 'lodash/function/rest';
 
-export default restParam(function(fn, args) {
-    return restParam(function(callArgs) {
+export default rest(function(fn, args) {
+    return rest(function(callArgs) {
         return fn.apply(null, args.concat(callArgs));
     });
 });
diff --git a/lib/asyncify.js b/lib/asyncify.js
index 6fdc62d..6f6cd57 100644
--- a/lib/asyncify.js
+++ b/lib/asyncify.js
@@ -1,10 +1,10 @@
 'use strict';
 
 import isObject from 'lodash/lang/isObject';
-import restParam from 'lodash/function/restParam';
+import rest from 'lodash/function/rest';
 
 export default function asyncify(func) {
-    return restParam(function (args) {
+    return rest(function (args) {
         var callback = args.pop();
         var result;
         try {
diff --git a/lib/auto.js b/lib/auto.js
index 82ad468..35fd012 100644
--- a/lib/auto.js
+++ b/lib/auto.js
@@ -8,7 +8,7 @@ import isArray from 'lodash/lang/isArray';
 import okeys from 'lodash/object/keys';
 import noop from 'lodash/utility/noop';
 import once from 'lodash/function/once';
-import restParam from 'lodash/function/restParam';
+import rest from 'lodash/function/rest';
 
 import setImmediate from './internal/setImmediate';
 
@@ -54,7 +54,7 @@ export default function (tasks, concurrency, callback) {
 
     arrayEach(keys, function (k) {
         var task = isArray(tasks[k]) ? tasks[k]: [tasks[k]];
-        var taskCallback = restParam(function(err, args) {
+        var taskCallback = rest(function(err, args) {
             runningTasks--;
             if (args.length <= 1) {
                 args = args[0];
diff --git a/lib/constant.js b/lib/constant.js
index 7d6a800..1eff0cf 100644
--- a/lib/constant.js
+++ b/lib/constant.js
@@ -1,8 +1,8 @@
 'use strict';
 
-import restParam from 'lodash/function/restParam';
+import rest from 'lodash/function/rest';
 
-export default restParam(function(values) {
+export default rest(function(values) {
     var args = [null].concat(values);
     return function (cb) {
         return cb.apply(this, args);
diff --git a/lib/during.js b/lib/during.js
index 074d0da..cc75e31 100644
--- a/lib/during.js
+++ b/lib/during.js
@@ -1,12 +1,12 @@
 'use strict';
 
 import noop from 'lodash/utility/noop';
-import restParam from 'lodash/function/restParam';
+import rest from 'lodash/function/rest';
 
 export default function during(test, iterator, cb) {
     cb = cb || noop;
 
-    var next = restParam(function(err, args) {
+    var next = rest(function(err, args) {
         if (err) {
             cb(err);
         } else {
diff --git a/lib/ensureAsync.js b/lib/ensureAsync.js
index 66de26b..8b7b208 100644
--- a/lib/ensureAsync.js
+++ b/lib/ensureAsync.js
@@ -1,11 +1,11 @@
 'use strict';
 
-import restParam from 'lodash/function/restParam';
+import rest from 'lodash/function/rest';
 
 import setImmediate from './internal/setImmediate';
 
 export default function ensureAsync(fn) {
-    return restParam(function (args) {
+    return rest(function (args) {
         var callback = args.pop();
         args.push(function () {
             var innerArgs = arguments;
diff --git a/lib/forever.js b/lib/forever.js
index 95f0d5d..0ec395a 100644
--- a/lib/forever.js
+++ b/lib/forever.js
@@ -1,3 +1,5 @@
+'use strict';
+
 import noop from 'lodash/utility/noop';
 
 import onlyOnce from './internal/onlyOnce';
diff --git a/lib/index.js b/lib/index.js
index 745090b..a165909 100644
--- a/lib/index.js
+++ b/lib/index.js
@@ -1,83 +1,228 @@
 'use strict';
 
-export {default as applyEach} from './applyEach';
-export {default as applyEachSeries} from './applyEachSeries';
-export {default as apply} from './apply';
-export {default as asyncify} from './asyncify';
-export {default as auto} from './auto';
-export {default as cargo} from './cargo';
-export {default as compose} from './compose';
-export {default as concat} from './concat';
-export {default as concatSeries} from './concatSeries';
-export {default as constant} from './constant';
-export {default as detect} from './detect';
-export {default as detectLimit} from './detectLimit';
-export {default as detectSeries} from './detectSeries';
-export {default as dir} from './dir';
-export {default as doDuring} from './doDuring';
-export {default as doUntil} from './doUntil';
-export {default as doWhilst} from './doWhilst';
-export {default as during} from './during';
-export {default as each} from './each';
-export {default as eachLimit} from './eachLimit';
-export {default as eachOf} from './eachOf';
-export {default as eachOfLimit} from './eachOfLimit';
-export {default as eachOfSeries} from './eachOfSeries';
-export {default as eachSeries} from './eachSeries';
-export {default as ensureAsync} from './ensureAsync';
-export {default as every} from './every';
-export {default as everyLimit} from './everyLimit';
-export {default as filter} from './filter';
-export {default as filterLimit} from './filterLimit';
-export {default as filterSeries} from './filterSeries';
-export {default as forever} from './forever';
-export {default as index} from './index';
-export {default as iterator} from './iterator';
-export {default as log} from './log';
-export {default as map} from './map';
-export {default as mapLimit} from './mapLimit';
-export {default as mapSeries} from './mapSeries';
-export {default as memoize} from './memoize';
-export {default as nextTick} from './nextTick';
-export {default as parallel} from './parallel';
-export {default as parallelLimit} from './parallelLimit';
-export {default as priorityQueue} from './priorityQueue';
-export {default as queue} from './queue';
-export {default as reduce} from './reduce';
-export {default as reduceRight} from './reduceRight';
-export {default as reject} from './reject';
-export {default as rejectLimit} from './rejectLimit';
-export {default as rejectSeries} from './rejectSeries';
-export {default as retry} from './retry';
-export {default as seq} from './seq';
-export {default as series} from './series';
-export {default as setImmediate} from './setImmediate';
-export {default as some} from './some';
-export {default as someLimit} from './someLimit';
-export {default as sortBy} from './sortBy';
-export {default as times} from './times';
-export {default as timesLimit} from './timesLimit';
-export {default as timesSeries} from './timesSeries';
-export {default as transform} from './transform';
-export {default as unmemoize} from './unmemoize';
-export {default as until} from './until';
-export {default as waterfall} from './waterfall';
-export {default as whilst} from './whilst';
+import applyEach from './applyEach';
+import applyEachSeries from './applyEachSeries';
+import apply from './apply';
+import asyncify from './asyncify';
+import auto from './auto';
+import cargo from './cargo';
+import compose from './compose';
+import concat from './concat';
+import concatSeries from './concatSeries';
+import constant from './constant';
+import detect from './detect';
+import detectLimit from './detectLimit';
+import detectSeries from './detectSeries';
+import dir from './dir';
+import doDuring from './doDuring';
+import doUntil from './doUntil';
+import doWhilst from './doWhilst';
+import during from './during';
+import each from './each';
+import eachLimit from './eachLimit';
+import eachOf from './eachOf';
+import eachOfLimit from './eachOfLimit';
+import eachOfSeries from './eachOfSeries';
+import eachSeries from './eachSeries';
+import ensureAsync from './ensureAsync';
+import every from './every';
+import everyLimit from './everyLimit';
+import filter from './filter';
+import filterLimit from './filterLimit';
+import filterSeries from './filterSeries';
+import forever from './forever';
+import iterator from './iterator';
+import log from './log';
+import map from './map';
+import mapLimit from './mapLimit';
+import mapSeries from './mapSeries';
+import memoize from './memoize';
+import nextTick from './nextTick';
+import parallel from './parallel';
+import parallelLimit from './parallelLimit';
+import priorityQueue from './priorityQueue';
+import queue from './queue';
+import reduce from './reduce';
+import reduceRight from './reduceRight';
+import reject from './reject';
+import rejectLimit from './rejectLimit';
+import rejectSeries from './rejectSeries';
+import retry from './retry';
+import seq from './seq';
+import series from './series';
+import setImmediate from './setImmediate';
+import some from './some';
+import someLimit from './someLimit';
+import sortBy from './sortBy';
+import times from './times';
+import timesLimit from './timesLimit';
+import timesSeries from './timesSeries';
+import transform from './transform';
+import unmemoize from './unmemoize';
+import until from './until';
+import waterfall from './waterfall';
+import whilst from './whilst';
 
-// Aliases
-export {default as all} from './every';
-export {default as any} from './some';
-export {default as forEach} from './each';
-export {default as forEachSeries} from './eachSeries';
-export {default as forEachLimit} from './eachLimit';
-export {default as forEachOf} from './eachOf';
-export {default as forEachOfSeries} from './eachOfSeries';
-export {default as forEachOfLimit} from './eachOfLimit';
-export {default as inject} from './reduce';
-export {default as foldl} from './reduce';
-export {default as foldr} from './reduceRight';
-export {default as select} from './filter';
-export {default as selectLimit} from './filterLimit';
-export {default as selectSeries} from './filterSeries';
-export {default as wrapSync} from './asyncify';
+export default {
+    applyEach: applyEach,
+    applyEachSeries: applyEachSeries,
+    apply: apply,
+    asyncify: asyncify,
+    auto: auto,
+    cargo: cargo,
+    compose: compose,
+    concat: concat,
+    concatSeries: concatSeries,
+    constant: constant,
+    detect: detect,
+    detectLimit: detectLimit,
+    detectSeries: detectSeries,
+    dir: dir,
+    doDuring: doDuring,
+    doUntil: doUntil,
+    doWhilst: doWhilst,
+    during: during,
+    each: each,
+    eachLimit: eachLimit,
+    eachOf: eachOf,
+    eachOfLimit: eachOfLimit,
+    eachOfSeries: eachOfSeries,
+    eachSeries: eachSeries,
+    ensureAsync: ensureAsync,
+    every: every,
+    everyLimit: everyLimit,
+    filter: filter,
+    filterLimit: filterLimit,
+    filterSeries: filterSeries,
+    forever: forever,
+    iterator: iterator,
+    log: log,
+    map: map,
+    mapLimit: mapLimit,
+    mapSeries: mapSeries,
+    memoize: memoize,
+    nextTick: nextTick,
+    parallel: parallel,
+    parallelLimit: parallelLimit,
+    priorityQueue: priorityQueue,
+    queue: queue,
+    reduce: reduce,
+    reduceRight: reduceRight,
+    reject: reject,
+    rejectLimit: rejectLimit,
+    rejectSeries: rejectSeries,
+    retry: retry,
+    seq: seq,
+    series: series,
+    setImmediate: setImmediate,
+    some: some,
+    someLimit: someLimit,
+    sortBy: sortBy,
+    times: times,
+    timesLimit: timesLimit,
+    timesSeries: timesSeries,
+    transform: transform,
+    unmemoize: unmemoize,
+    until: until,
+    waterfall: waterfall,
+    whilst: whilst,
 
+    // aliases
+    all: every,
+    any: some,
+    forEach: each,
+    forEachSeries: eachSeries,
+    forEachLimit: eachLimit,
+    forEachOf: eachOf,
+    forEachOfSeries: eachOfSeries,
+    forEachOfLimit: eachOfLimit,
+    inject: reduce,
+    foldl: reduce,
+    foldr: reduceRight,
+    select: filter,
+    selectLimit: filterLimit,
+    selectSeries: filterSeries,
+    wrapSync: asyncify
+};
+
+export {
+    applyEach as applyEach,
+    applyEachSeries as applyEachSeries,
+    apply as apply,
+    asyncify as asyncify,
+    auto as auto,
+    cargo as cargo,
+    compose as compose,
+    concat as concat,
+    concatSeries as concatSeries,
+    constant as constant,
+    detect as detect,
+    detectLimit as detectLimit,
+    detectSeries as detectSeries,
+    dir as dir,
+    doDuring as doDuring,
+    doUntil as doUntil,
+    doWhilst as doWhilst,
+    during as during,
+    each as each,
+    eachLimit as eachLimit,
+    eachOf as eachOf,
+    eachOfLimit as eachOfLimit,
+    eachOfSeries as eachOfSeries,
+    eachSeries as eachSeries,
+    ensureAsync as ensureAsync,
+    every as every,
+    everyLimit as everyLimit,
+    filter as filter,
+    filterLimit as filterLimit,
+    filterSeries as filterSeries,
+    forever as forever,
+    iterator as iterator,
+    log as log,
+    map as map,
+    mapLimit as mapLimit,
+    mapSeries as mapSeries,
+    memoize as memoize,
+    nextTick as nextTick,
+    parallel as parallel,
+    parallelLimit as parallelLimit,
+    priorityQueue as priorityQueue,
+    queue as queue,
+    reduce as reduce,
+    reduceRight as reduceRight,
+    reject as reject,
+    rejectLimit as rejectLimit,
+    rejectSeries as rejectSeries,
+    retry as retry,
+    seq as seq,
+    series as series,
+    setImmediate as setImmediate,
+    some as some,
+    someLimit as someLimit,
+    sortBy as sortBy,
+    times as times,
+    timesLimit as timesLimit,
+    timesSeries as timesSeries,
+    transform as transform,
+    unmemoize as unmemoize,
+    until as until,
+    waterfall as waterfall,
+    whilst as whilst,
+
+    // Aliases
+    every as all,
+    some as any,
+    each as forEach,
+    eachSeries as forEachSeries,
+    eachLimit as forEachLimit,
+    eachOf as forEachOf,
+    eachOfSeries as forEachOfSeries,
+    eachOfLimit as forEachOfLimit,
+    reduce as inject,
+    reduce as foldl,
+    reduceRight as foldr,
+    filter as select,
+    filterLimit as selectLimit,
+    filterSeries as selectSeries,
+    asyncify as wrapSync
+};
diff --git a/lib/internal/applyEach.js b/lib/internal/applyEach.js
index 62eadfd..aa13cc2 100644
--- a/lib/internal/applyEach.js
+++ b/lib/internal/applyEach.js
@@ -1,8 +1,10 @@
-import restParam from 'lodash/function/restParam';
+'use strict';
+
+import rest from 'lodash/function/rest';
 
 export default function _applyEach(eachfn) {
-    return restParam(function(fns, args) {
-        var go = restParam(function(args) {
+    return rest(function(fns, args) {
+        var go = rest(function(args) {
             var that = this;
             var callback = args.pop();
             return eachfn(fns, function (fn, _, cb) {
diff --git a/lib/internal/concat.js b/lib/internal/concat.js
index a55de2e..482ad3a 100644
--- a/lib/internal/concat.js
+++ b/lib/internal/concat.js
@@ -1,3 +1,5 @@
+'use strict';
+
 export default function concat(eachfn, arr, fn, callback) {
     var result = [];
     eachfn(arr, function (x, index, cb) {
diff --git a/lib/internal/consoleFunc.js b/lib/internal/consoleFunc.js
index d2baebd..ea262ed 100644
--- a/lib/internal/consoleFunc.js
+++ b/lib/internal/consoleFunc.js
@@ -1,9 +1,11 @@
+'use strict';
+
 import arrayEach from 'lodash/internal/arrayEach';
-import restParam from 'lodash/function/restParam';
+import rest from 'lodash/function/rest';
 
 export default function consoleFunc(name) {
-    return restParam(function (fn, args) {
-        fn.apply(null, args.concat([restParam(function (err, args) {
+    return rest(function (fn, args) {
+        fn.apply(null, args.concat([rest(function (err, args) {
             if (typeof console === 'object') {
                 if (err) {
                     if (console.error) {
diff --git a/lib/internal/createTester.js b/lib/internal/createTester.js
index 3dbf78d..1bf2e89 100644
--- a/lib/internal/createTester.js
+++ b/lib/internal/createTester.js
@@ -1,3 +1,5 @@
+'use strict';
+
 export default function _createTester(eachfn, check, getResult) {
     return function(arr, limit, iterator, cb) {
         function done() {
diff --git a/lib/internal/doParallel.js b/lib/internal/doParallel.js
index fdb1264..19c90fc 100644
--- a/lib/internal/doParallel.js
+++ b/lib/internal/doParallel.js
@@ -1,3 +1,5 @@
+'use strict';
+
 import eachOf from '../eachOf';
 
 export default function doParallel(fn) {
diff --git a/lib/internal/doParallelLimit.js b/lib/internal/doParallelLimit.js
index e5d04f4..0c3bcf7 100644
--- a/lib/internal/doParallelLimit.js
+++ b/lib/internal/doParallelLimit.js
@@ -1,3 +1,5 @@
+'use strict';
+
 import eachOfLimit from './eachOfLimit';
 
 export default function doParallelLimit(fn) {
diff --git a/lib/internal/doSeries.js b/lib/internal/doSeries.js
index 1724798..c7f1d99 100644
--- a/lib/internal/doSeries.js
+++ b/lib/internal/doSeries.js
@@ -1,3 +1,5 @@
+'use strict';
+
 import eachOfSeries from '../eachOfSeries';
 
 export default function doSeries(fn) {
diff --git a/lib/internal/eachOfLimit.js b/lib/internal/eachOfLimit.js
index 2ef8f88..0ad6a7e 100644
--- a/lib/internal/eachOfLimit.js
+++ b/lib/internal/eachOfLimit.js
@@ -1,3 +1,5 @@
+'use strict';
+
 import noop from 'lodash/utility/noop';
 import once from 'lodash/function/once';
 
diff --git a/lib/internal/filter.js b/lib/internal/filter.js
index 3355bee..83242fa 100644
--- a/lib/internal/filter.js
+++ b/lib/internal/filter.js
@@ -1,3 +1,5 @@
+'use strict';
+
 import arrayMap from 'lodash/internal/arrayMap';
 import property from 'lodash/utility/property';
 
diff --git a/lib/internal/findGetResult.js b/lib/internal/findGetResult.js
index 7345df6..3aeb07d 100644
--- a/lib/internal/findGetResult.js
+++ b/lib/internal/findGetResult.js
@@ -1,3 +1,5 @@
+'use strict';
+
 export default function _findGetResult(v, x) {
     return x;
 }
diff --git a/lib/internal/keyIterator.js b/lib/internal/keyIterator.js
index 801b43b..4040c19 100644
--- a/lib/internal/keyIterator.js
+++ b/lib/internal/keyIterator.js
@@ -1,4 +1,6 @@
-import isArrayLike from 'lodash/internal/isArrayLike';
+'use strict';
+
+import isArrayLike from 'lodash/lang/isArrayLike';
 import keys from 'lodash/object/keys';
 
 export default function keyIterator(coll) {
diff --git a/lib/internal/map.js b/lib/internal/map.js
index aa4fdc1..3ae9d6c 100644
--- a/lib/internal/map.js
+++ b/lib/internal/map.js
@@ -1,4 +1,6 @@
-import isArrayLike from 'lodash/internal/isArrayLike';
+'use strict';
+
+import isArrayLike from 'lodash/lang/isArrayLike';
 import noop from 'lodash/utility/noop';
 import once from 'lodash/function/once';
 
diff --git a/lib/internal/notId.js b/lib/internal/notId.js
index 65a676e..d936aab 100644
--- a/lib/internal/notId.js
+++ b/lib/internal/notId.js
@@ -1,3 +1,5 @@
+'use strict';
+
 export default function notId(v) {
     return !v;
 }
diff --git a/lib/internal/onlyOnce.js b/lib/internal/onlyOnce.js
index 0a0f278..f4241c8 100644
--- a/lib/internal/onlyOnce.js
+++ b/lib/internal/onlyOnce.js
@@ -1,3 +1,5 @@
+'use strict';
+
 export default function onlyOnce(fn) {
     return function() {
         if (fn === null) throw new Error("Callback was already called.");
diff --git a/lib/internal/parallel.js b/lib/internal/parallel.js
index 5d959ba..d6c9258 100644
--- a/lib/internal/parallel.js
+++ b/lib/internal/parallel.js
@@ -1,14 +1,15 @@
-import noop from 'lodash/utility/noop';
-import isArrayLike from 'lodash/internal/isArrayLike';
-import restParam from 'lodash/function/restParam';
+'use strict';
 
+import noop from 'lodash/utility/noop';
+import isArrayLike from 'lodash/lang/isArrayLike';
+import rest from 'lodash/function/rest';
 
 export default function _parallel(eachfn, tasks, callback) {
     callback = callback || noop;
     var results = isArrayLike(tasks) ? [] : {};
 
     eachfn(tasks, function (task, key, callback) {
-        task(restParam(function (err, args) {
+        task(rest(function (err, args) {
             if (args.length <= 1) {
                 args = args[0];
             }
diff --git a/lib/internal/queue.js b/lib/internal/queue.js
index 71c6c64..8d5c081 100644
--- a/lib/internal/queue.js
+++ b/lib/internal/queue.js
@@ -1,3 +1,5 @@
+'use strict';
+
 import arrayEach from 'lodash/internal/arrayEach';
 import arrayMap from 'lodash/internal/arrayMap';
 import isArray from 'lodash/lang/isArray';
diff --git a/lib/internal/reject.js b/lib/internal/reject.js
index b15fab1..8b1bf0d 100644
--- a/lib/internal/reject.js
+++ b/lib/internal/reject.js
@@ -1,3 +1,5 @@
+'use strict';
+
 import filter from './filter';
 
 export default function reject(eachfn, arr, iterator, callback) {
diff --git a/lib/internal/setImmediate.js b/lib/internal/setImmediate.js
index d44c66e..c02ad71 100644
--- a/lib/internal/setImmediate.js
+++ b/lib/internal/setImmediate.js
@@ -1,3 +1,5 @@
+'use strict';
+
 var _setImmediate = typeof setImmediate === 'function' && setImmediate;
 
 var _delay;
@@ -5,7 +7,7 @@ if (_setImmediate) {
     _delay = function(fn) {
         // not a direct alias for IE10 compatibility
         _setImmediate(fn);
-    }
+    };
 } else if (typeof process === 'object' && typeof process.nextTick === 'function') {
     _delay = process.nextTick;
 } else {
diff --git a/lib/internal/withoutIndex.js b/lib/internal/withoutIndex.js
index 706c27a..f163ff3 100644
--- a/lib/internal/withoutIndex.js
+++ b/lib/internal/withoutIndex.js
@@ -1,3 +1,5 @@
+'use strict';
+
 export default function _withoutIndex(iterator) {
     return function (value, index, callback) {
         return iterator(value, callback);
diff --git a/lib/memoize.js b/lib/memoize.js
index 7a87af0..2dc8808 100644
--- a/lib/memoize.js
+++ b/lib/memoize.js
@@ -1,7 +1,7 @@
 'use strict';
 
 import identity from 'lodash/utility/identity';
-import restParam from 'lodash/function/restParam';
+import rest from 'lodash/function/rest';
 
 import setImmediate from './internal/setImmediate';
 
@@ -9,7 +9,7 @@ export default function memoize(fn, hasher) {
     var memo = {};
     var queues = {};
     hasher = hasher || identity;
-    var memoized = restParam(function memoized(args) {
+    var memoized = rest(function memoized(args) {
         var callback = args.pop();
         var key = hasher.apply(null, args);
         if (key in memo) {
@@ -20,7 +20,7 @@ export default function memoize(fn, hasher) {
             queues[key].push(callback);
         } else {
             queues[key] = [callback];
-            fn.apply(null, args.concat([restParam(function(args) {
+            fn.apply(null, args.concat([rest(function(args) {
                 memo[key] = args;
                 var q = queues[key];
                 delete queues[key];
diff --git a/lib/seq.js b/lib/seq.js
index 184dc4b..52475b3 100644
--- a/lib/seq.js
+++ b/lib/seq.js
@@ -1,10 +1,12 @@
+'use strict';
+
 import noop from 'lodash/utility/noop';
 import reduce from './reduce';
-import restParam from 'lodash/function/restParam';
+import rest from 'lodash/function/rest';
 
 export default function seq( /* functions... */ ) {
     var fns = arguments;
-    return restParam(function(args) {
+    return rest(function(args) {
         var that = this;
 
         var cb = args[args.length - 1];
@@ -15,7 +17,7 @@ export default function seq( /* functions... */ ) {
         }
 
         reduce(fns, args, function(newargs, fn, cb) {
-                fn.apply(that, newargs.concat([restParam(function(err, nextargs) {
+                fn.apply(that, newargs.concat([rest(function(err, nextargs) {
                     cb(err, nextargs);
                 })]));
             },
diff --git a/lib/waterfall.js b/lib/waterfall.js
index d82d344..601c569 100644
--- a/lib/waterfall.js
+++ b/lib/waterfall.js
@@ -3,7 +3,7 @@
 import isArray from 'lodash/lang/isArray';
 import noop from 'lodash/utility/noop';
 import once from 'lodash/function/once';
-import restParam from 'lodash/function/restParam';
+import rest from 'lodash/function/rest';
 
 import ensureAsync from './ensureAsync';
 import iterator from './iterator';
@@ -14,7 +14,7 @@ export default  function(tasks, cb) {
     if (!tasks.length) return cb();
 
     function wrapIterator(iterator) {
-        return restParam(function(err, args) {
+        return rest(function(err, args) {
             if (err) {
                 cb.apply(null, [err].concat(args));
             } else {
diff --git a/lib/whilst.js b/lib/whilst.js
index b0825c6..eea3a67 100644
--- a/lib/whilst.js
+++ b/lib/whilst.js
@@ -1,12 +1,12 @@
 'use strict';
 
 import noop from 'lodash/utility/noop';
-import restParam from 'lodash/function/restParam';
+import rest from 'lodash/function/rest';
 
 export default function whilst(test, iterator, cb) {
     cb = cb || noop;
     if (!test()) return cb(null);
-    var next = restParam(function(err, args) {
+    var next = rest(function(err, args) {
         if (err) return cb(err);
         if (test.apply(this, args)) return iterator(next);
         cb.apply(null, [null].concat(args));