5 years ago · f2a75643c8
--- a/message.model.js
+++ b/message.model.js
@@ -0,0 +1,11 @@
 const mongoose = require('mongoose');

 const MessageSchema = mongoose.Schema({
    _id: String,
    subject: { type: String, required: true },
    message: { type: String, required: true },
    user: { type: String, required: true },
    tag: {type: [String] },
 });

 module.exports = mongoose.model('Message', MessageSchema);
--- a/mongodb.config.js
+++ b/mongodb.config.js
@@ -0,0 +1,3 @@
 module.exports = {
    url: 'mongodb://localhost:27017/mydb'
 }
--- a/node_modules/async/CHANGELOG.md
+++ b/node_modules/async/CHANGELOG.md
@@ -0,0 +1,269 @@
 # v2.6.1
 - Updated lodash to prevent `npm audit` warnings. (#1532, #1533)
 - Made `async-es` more optimized for webpack users (#1517)
 - Fixed a stack overflow with large collections and a synchronous iterator (#1514)
 - Various small fixes/chores (#1505, #1511, #1527, #1530)

 # v2.6.0
 - Added missing aliases for many methods.  Previously, you could not (e.g.) `require('async/find')` or use `async.anyLimit`. (#1483)
 - Improved `queue` performance. (#1448, #1454)
 - Add missing sourcemap (#1452, #1453)
 - Various doc updates (#1448, #1471, #1483)

 # v2.5.0
 - Added `concatLimit`, the `Limit` equivalent of [`concat`](https://caolan.github.io/async/docs.html#concat) ([#1426](https://github.com/caolan/async/issues/1426), [#1430](https://github.com/caolan/async/pull/1430))
 - `concat` improvements: it now preserves order, handles falsy values and the `iteratee` callback takes a variable number of arguments ([#1437](https://github.com/caolan/async/issues/1437), [#1436](https://github.com/caolan/async/pull/1436))
 - Fixed an issue in `queue`  where there was a size discrepancy between `workersList().length` and `running()` ([#1428](https://github.com/caolan/async/issues/1428), [#1429](https://github.com/caolan/async/pull/1429))
 - Various doc fixes ([#1422](https://github.com/caolan/async/issues/1422), [#1424](https://github.com/caolan/async/pull/1424))

 # v2.4.1
 - Fixed a bug preventing functions wrapped  with `timeout()` from being re-used. ([#1418](https://github.com/caolan/async/issues/1418), [#1419](https://github.com/caolan/async/issues/1419))

 # v2.4.0
 - Added `tryEach`, for running async functions in parallel, where you only expect one to succeed. ([#1365](https://github.com/caolan/async/issues/1365), [#687](https://github.com/caolan/async/issues/687))
 - Improved performance, most notably in `parallel` and `waterfall` ([#1395](https://github.com/caolan/async/issues/1395))
 - Added `queue.remove()`, for removing items in a `queue` ([#1397](https://github.com/caolan/async/issues/1397), [#1391](https://github.com/caolan/async/issues/1391))
 - Fixed using `eval`, preventing Async from running in pages with Content Security Policy ([#1404](https://github.com/caolan/async/issues/1404), [#1403](https://github.com/caolan/async/issues/1403))
 - Fixed errors thrown in an `asyncify`ed function's callback being caught by the underlying Promise ([#1408](https://github.com/caolan/async/issues/1408))
 - Fixed timing of `queue.empty()` ([#1367](https://github.com/caolan/async/issues/1367))
 - Various doc fixes ([#1314](https://github.com/caolan/async/issues/1314), [#1394](https://github.com/caolan/async/issues/1394), [#1412](https://github.com/caolan/async/issues/1412))

 # v2.3.0
 - Added support for ES2017 `async` functions.  Wherever you can pass a Node-style/CPS function that uses a callback, you can also pass an `async` function.  Previously, you had to wrap `async` functions with `asyncify`.  The caveat is that it will only work if `async` functions are supported natively in your environment, transpiled implementations can't be detected.  ([#1386](https://github.com/caolan/async/issues/1386), [#1390](https://github.com/caolan/async/issues/1390))
 - Small doc fix ([#1392](https://github.com/caolan/async/issues/1392))

 # v2.2.0
 - Added `groupBy`, and the `Series`/`Limit` equivalents, analogous to [`_.groupBy`](http://lodash.com/docs#groupBy) ([#1364](https://github.com/caolan/async/issues/1364))
 - Fixed `transform` bug when `callback` was not passed ([#1381](https://github.com/caolan/async/issues/1381))
 - Added note about `reflect` to `parallel` docs ([#1385](https://github.com/caolan/async/issues/1385))

 # v2.1.5
 - Fix `auto` bug when function names collided with Array.prototype ([#1358](https://github.com/caolan/async/issues/1358))
 - Improve some error messages ([#1349](https://github.com/caolan/async/issues/1349))
 - Avoid stack overflow case in queue
 - Fixed an issue in `some`, `every` and `find` where processing would continue after the result was determined.
 - Cleanup implementations of `some`, `every` and `find`

 # v2.1.3
 - Make bundle size smaller
 - Create optimized hotpath for `filter` in array case.

 # v2.1.2
 - Fixed a stackoverflow bug with `detect`, `some`, `every` on large inputs ([#1293](https://github.com/caolan/async/issues/1293)).

 # v2.1.0

 - `retry` and `retryable` now support an optional `errorFilter` function that determines if the `task` should retry on the error ([#1256](https://github.com/caolan/async/issues/1256), [#1261](https://github.com/caolan/async/issues/1261))
 - Optimized array iteration in `race`, `cargo`, `queue`, and `priorityQueue` ([#1253](https://github.com/caolan/async/issues/1253))
 - Added alias documentation to doc site ([#1251](https://github.com/caolan/async/issues/1251), [#1254](https://github.com/caolan/async/issues/1254))
 - Added [BootStrap scrollspy](http://getbootstrap.com/javascript/#scrollspy) to docs to highlight in the sidebar the current method being viewed  ([#1289](https://github.com/caolan/async/issues/1289), [#1300](https://github.com/caolan/async/issues/1300))
 - Various minor doc fixes ([#1263](https://github.com/caolan/async/issues/1263), [#1264](https://github.com/caolan/async/issues/1264), [#1271](https://github.com/caolan/async/issues/1271), [#1278](https://github.com/caolan/async/issues/1278), [#1280](https://github.com/caolan/async/issues/1280), [#1282](https://github.com/caolan/async/issues/1282), [#1302](https://github.com/caolan/async/issues/1302))

 # v2.0.1

 - Significantly optimized all iteration based collection methods such as `each`, `map`, `filter`, etc ([#1245](https://github.com/caolan/async/issues/1245), [#1246](https://github.com/caolan/async/issues/1246), [#1247](https://github.com/caolan/async/issues/1247)).

 # v2.0.0

 Lots of changes here!

 First and foremost, we have a slick new [site for docs](https://caolan.github.io/async/). Special thanks to [**@hargasinski**](https://github.com/hargasinski) for his work converting our old docs to `jsdoc` format and implementing the new website. Also huge ups to [**@ivanseidel**](https://github.com/ivanseidel) for designing our new logo. It was a long process for both of these tasks, but I think these changes turned out extraordinary well.

 The biggest feature is modularization. You can now `require("async/series")` to only require the `series` function. Every Async library function is available this way. You still can `require("async")` to require the entire library, like you could do before.

 We also provide Async as a collection of ES2015 modules. You can now `import {each} from 'async-es'` or `import waterfall from 'async-es/waterfall'`. If you are using only a few Async functions, and are using a ES bundler such as Rollup, this can significantly lower your build size.

 Major thanks to [**@Kikobeats**](github.com/Kikobeats), [**@aearly**](github.com/aearly) and [**@megawac**](github.com/megawac) for doing the majority of the modularization work, as well as [**@jdalton**](github.com/jdalton) and [**@Rich-Harris**](github.com/Rich-Harris) for advisory work on the general modularization strategy.

 Another one of the general themes of the 2.0 release is standardization of what an "async" function is. We are now more strictly following the node-style continuation passing style. That is, an async function is a function that:

 1. Takes a variable number of arguments
 2. The last argument is always a callback
 3. The callback can accept any number of arguments
 4. The first argument passed to the callback will be treated as an error result, if the argument is truthy
 5. Any number of result arguments can be passed after the "error" argument
 6. The callback is called once and exactly once, either on the same tick or later tick of the JavaScript event loop.

 There were several cases where Async accepted some functions that did not strictly have these properties, most notably `auto`, `every`, `some`, `filter`, `reject` and `detect`.

 Another theme is performance. We have eliminated internal deferrals in all cases where they make sense. For example, in `waterfall` and `auto`, there was a `setImmediate` between each task -- these deferrals have been removed. A `setImmediate` call can add up to 1ms of delay. This might not seem like a lot, but it can add up if you are using many Async functions in the course of processing a HTTP request, for example. Nearly all asynchronous functions that do I/O already have some sort of deferral built in, so the extra deferral is unnecessary. The trade-off of this change is removing our built-in stack-overflow defense. Many synchronous callback calls in series can quickly overflow the JS call stack. If you do have a function that is sometimes synchronous (calling its callback on the same tick), and are running into stack overflows, wrap it with `async.ensureAsync()`.

 Another big performance win has been re-implementing `queue`, `cargo`, and `priorityQueue` with [doubly linked lists](https://en.wikipedia.org/wiki/Doubly_linked_list) instead of arrays. This has lead to queues being an order of [magnitude faster on large sets of tasks](https://github.com/caolan/async/pull/1205).

 ## New Features

 - Async is now modularized. Individual functions can be `require()`d from the main package. (`require('async/auto')`) ([#984](https://github.com/caolan/async/issues/984), [#996](https://github.com/caolan/async/issues/996))
 - Async is also available as a collection of ES2015 modules in the new `async-es` package. (`import {forEachSeries} from 'async-es'`) ([#984](https://github.com/caolan/async/issues/984), [#996](https://github.com/caolan/async/issues/996))
 - Added `race`, analogous to `Promise.race()`. It will run an array of async tasks in parallel and will call its callback with the result of the first task to respond. ([#568](https://github.com/caolan/async/issues/568), [#1038](https://github.com/caolan/async/issues/1038))
 - Collection methods now accept ES2015 iterators.  Maps, Sets, and anything that implements the iterator spec can now be passed directly to `each`, `map`, `parallel`, etc.. ([#579](https://github.com/caolan/async/issues/579), [#839](https://github.com/caolan/async/issues/839), [#1074](https://github.com/caolan/async/issues/1074))
 - Added `mapValues`, for mapping over the properties of an object and returning an object with the same keys. ([#1157](https://github.com/caolan/async/issues/1157), [#1177](https://github.com/caolan/async/issues/1177))
 - Added `timeout`, a wrapper for an async function that will make the task time-out after the specified time. ([#1007](https://github.com/caolan/async/issues/1007), [#1027](https://github.com/caolan/async/issues/1027))
 - Added `reflect` and `reflectAll`, analagous to [`Promise.reflect()`](http://bluebirdjs.com/docs/api/reflect.html), a wrapper for async tasks that always succeeds, by gathering results and errors into an object.  ([#942](https://github.com/caolan/async/issues/942), [#1012](https://github.com/caolan/async/issues/1012), [#1095](https://github.com/caolan/async/issues/1095))
 - `constant` supports dynamic arguments -- it will now always use its last argument as the callback. ([#1016](https://github.com/caolan/async/issues/1016), [#1052](https://github.com/caolan/async/issues/1052))
 - `setImmediate` and `nextTick` now support arguments to partially apply to the deferred function, like the node-native versions do. ([#940](https://github.com/caolan/async/issues/940), [#1053](https://github.com/caolan/async/issues/1053))
 - `auto` now supports resolving cyclic dependencies using [Kahn's algorithm](https://en.wikipedia.org/wiki/Topological_sorting#Kahn.27s_algorithm) ([#1140](https://github.com/caolan/async/issues/1140)).
 - Added `autoInject`, a relative of `auto` that automatically spreads a task's dependencies as arguments to the task function. ([#608](https://github.com/caolan/async/issues/608), [#1055](https://github.com/caolan/async/issues/1055), [#1099](https://github.com/caolan/async/issues/1099), [#1100](https://github.com/caolan/async/issues/1100))
 - You can now limit the concurrency of `auto` tasks. ([#635](https://github.com/caolan/async/issues/635), [#637](https://github.com/caolan/async/issues/637))
 - Added `retryable`, a relative of `retry` that wraps an async function, making it retry when called. ([#1058](https://github.com/caolan/async/issues/1058))
 - `retry` now supports specifying a function that determines the next time interval, useful for exponential backoff, logging and other retry strategies. ([#1161](https://github.com/caolan/async/issues/1161))
 - `retry` will now pass all of the arguments the task function was resolved with to the callback ([#1231](https://github.com/caolan/async/issues/1231)).
 - Added `q.unsaturated` -- callback called when a `queue`'s number of running workers falls below a threshold. ([#868](https://github.com/caolan/async/issues/868), [#1030](https://github.com/caolan/async/issues/1030), [#1033](https://github.com/caolan/async/issues/1033), [#1034](https://github.com/caolan/async/issues/1034))
 - Added `q.error` -- a callback called whenever a `queue` task calls its callback with an error. ([#1170](https://github.com/caolan/async/issues/1170))
 - `applyEach` and `applyEachSeries` now pass results to the final callback. ([#1088](https://github.com/caolan/async/issues/1088))

 ## Breaking changes

 - Calling a callback more than once is considered an error, and an error will be thrown. This had an explicit breaking change in `waterfall`. If you were relying on this behavior, you should more accurately represent your control flow as an event emitter or stream. ([#814](https://github.com/caolan/async/issues/814), [#815](https://github.com/caolan/async/issues/815), [#1048](https://github.com/caolan/async/issues/1048), [#1050](https://github.com/caolan/async/issues/1050))
 - `auto` task functions now always take the callback as the last argument. If a task has dependencies, the `results` object will be passed as the first argument. To migrate old task functions, wrap them with [`_.flip`](https://lodash.com/docs#flip) ([#1036](https://github.com/caolan/async/issues/1036), [#1042](https://github.com/caolan/async/issues/1042))
 - Internal `setImmediate` calls have been refactored away. This may make existing flows vulnerable to stack overflows if you use many synchronous functions in series. Use `ensureAsync` to work around this. ([#696](https://github.com/caolan/async/issues/696), [#704](https://github.com/caolan/async/issues/704), [#1049](https://github.com/caolan/async/issues/1049), [#1050](https://github.com/caolan/async/issues/1050))
 - `map` used to return an object when iterating over an object.  `map` now always returns an array, like in other libraries.  The previous object behavior has been split out into `mapValues`. ([#1157](https://github.com/caolan/async/issues/1157), [#1177](https://github.com/caolan/async/issues/1177))
 - `filter`, `reject`, `some`, `every`, `detect` and their families like `{METHOD}Series` and `{METHOD}Limit` now expect an error as the first callback argument, rather than just a simple boolean. Pass `null` as the first argument, or use `fs.access` instead of `fs.exists`. ([#118](https://github.com/caolan/async/issues/118), [#774](https://github.com/caolan/async/issues/774), [#1028](https://github.com/caolan/async/issues/1028), [#1041](https://github.com/caolan/async/issues/1041))
 - `{METHOD}` and `{METHOD}Series` are now implemented in terms of `{METHOD}Limit`. This is a major internal simplification, and is not expected to cause many problems, but it does subtly affect how functions execute internally. ([#778](https://github.com/caolan/async/issues/778), [#847](https://github.com/caolan/async/issues/847))
 - `retry`'s callback is now optional. Previously, omitting the callback would partially apply the function, meaning it could be passed directly as a task to `series` or `auto`. The partially applied "control-flow" behavior has been separated out into `retryable`. ([#1054](https://github.com/caolan/async/issues/1054), [#1058](https://github.com/caolan/async/issues/1058))
 - The test function for `whilst`, `until`, and `during` used to be passed non-error args from the iteratee function's callback, but this led to weirdness where the first call of the test function would be passed no args. We have made it so the test function is never passed extra arguments, and only the `doWhilst`, `doUntil`, and `doDuring` functions pass iteratee callback arguments to the test function ([#1217](https://github.com/caolan/async/issues/1217), [#1224](https://github.com/caolan/async/issues/1224))
 - The `q.tasks` array has been renamed `q._tasks` and is now implemented as a doubly linked list (DLL). Any code that used to interact with this array will need to be updated to either use the provided helpers or support DLLs ([#1205](https://github.com/caolan/async/issues/1205)).
 - The timing of the `q.saturated()` callback in a `queue` has been modified to better reflect when tasks pushed to the queue will start queueing. ([#724](https://github.com/caolan/async/issues/724), [#1078](https://github.com/caolan/async/issues/1078))
 - Removed `iterator` method in favour of [ES2015 iterator protocol](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Iterators_and_Generators ) which natively supports arrays ([#1237](https://github.com/caolan/async/issues/1237))
 - Dropped support for Component, Jam, SPM, and Volo ([#1175](https://github.com/caolan/async/issues/1175), #[#176](https://github.com/caolan/async/issues/176))

 ## Bug Fixes

 - Improved handling of no dependency cases in `auto` & `autoInject` ([#1147](https://github.com/caolan/async/issues/1147)).
 - Fixed a bug where the callback generated by `asyncify` with  `Promises` could resolve twice ([#1197](https://github.com/caolan/async/issues/1197)).
 - Fixed several documented optional callbacks not actually being optional ([#1223](https://github.com/caolan/async/issues/1223)).

 ## Other

 - Added `someSeries` and `everySeries` for symmetry, as well as a complete set of `any`/`anyLimit`/`anySeries` and `all`/`/allLmit`/`allSeries` aliases.
 - Added `find` as an alias for `detect. (as well as `findLimit` and `findSeries`).
 - Various doc fixes ([#1005](https://github.com/caolan/async/issues/1005), [#1008](https://github.com/caolan/async/issues/1008), [#1010](https://github.com/caolan/async/issues/1010), [#1015](https://github.com/caolan/async/issues/1015), [#1021](https://github.com/caolan/async/issues/1021), [#1037](https://github.com/caolan/async/issues/1037), [#1039](https://github.com/caolan/async/issues/1039), [#1051](https://github.com/caolan/async/issues/1051), [#1102](https://github.com/caolan/async/issues/1102), [#1107](https://github.com/caolan/async/issues/1107), [#1121](https://github.com/caolan/async/issues/1121), [#1123](https://github.com/caolan/async/issues/1123), [#1129](https://github.com/caolan/async/issues/1129), [#1135](https://github.com/caolan/async/issues/1135), [#1138](https://github.com/caolan/async/issues/1138), [#1141](https://github.com/caolan/async/issues/1141), [#1153](https://github.com/caolan/async/issues/1153), [#1216](https://github.com/caolan/async/issues/1216), [#1217](https://github.com/caolan/async/issues/1217), [#1232](https://github.com/caolan/async/issues/1232), [#1233](https://github.com/caolan/async/issues/1233), [#1236](https://github.com/caolan/async/issues/1236), [#1238](https://github.com/caolan/async/issues/1238))

 Thank you [**@aearly**](github.com/aearly) and [**@megawac**](github.com/megawac) for taking the lead on version 2 of async.

 ------------------------------------------

 # v1.5.2
 - Allow using `"constructor"` as an argument in `memoize` ([#998](https://github.com/caolan/async/issues/998))
 - Give a better error messsage when `auto` dependency checking fails ([#994](https://github.com/caolan/async/issues/994))
 - Various doc updates ([#936](https://github.com/caolan/async/issues/936), [#956](https://github.com/caolan/async/issues/956), [#979](https://github.com/caolan/async/issues/979), [#1002](https://github.com/caolan/async/issues/1002))

 # v1.5.1
 - Fix issue with `pause` in `queue` with concurrency enabled ([#946](https://github.com/caolan/async/issues/946))
 - `while` and `until` now pass the final result to callback ([#963](https://github.com/caolan/async/issues/963))
 - `auto` will properly handle concurrency when there is no callback ([#966](https://github.com/caolan/async/issues/966))
 - `auto` will no. properly stop execution when an error occurs ([#988](https://github.com/caolan/async/issues/988), [#993](https://github.com/caolan/async/issues/993))
 - Various doc fixes ([#971](https://github.com/caolan/async/issues/971), [#980](https://github.com/caolan/async/issues/980))

 # v1.5.0

 - Added `transform`, analogous to [`_.transform`](http://lodash.com/docs#transform) ([#892](https://github.com/caolan/async/issues/892))
 - `map` now returns an object when an object is passed in, rather than array with non-numeric keys. `map` will begin always returning an array with numeric indexes in the next major release. ([#873](https://github.com/caolan/async/issues/873))
 - `auto` now accepts an optional `concurrency` argument to limit the number o. running tasks ([#637](https://github.com/caolan/async/issues/637))
 - Added `queue#workersList()`, to retrieve the lis. of currently running tasks. ([#891](https://github.com/caolan/async/issues/891))
 - Various code simplifications ([#896](https://github.com/caolan/async/issues/896), [#904](https://github.com/caolan/async/issues/904))
 - Various doc fixes :scroll: ([#890](https://github.com/caolan/async/issues/890), [#894](https://github.com/caolan/async/issues/894), [#903](https://github.com/caolan/async/issues/903), [#905](https://github.com/caolan/async/issues/905), [#912](https://github.com/caolan/async/issues/912))

 # v1.4.2

 - Ensure coverage files don't get published on npm ([#879](https://github.com/caolan/async/issues/879))

 # v1.4.1

 - Add in overlooked `detectLimit` method ([#866](https://github.com/caolan/async/issues/866))
 - Removed unnecessary files from npm releases ([#861](https://github.com/caolan/async/issues/861))
 - Removed usage of a reserved word to prevent :boom: in older environments ([#870](https://github.com/caolan/async/issues/870))

 # v1.4.0

 - `asyncify` now supports promises ([#840](https://github.com/caolan/async/issues/840))
 - Added `Limit` versions of `filter` and `reject` ([#836](https://github.com/caolan/async/issues/836))
 - Add `Limit` versions of `detect`, `some` and `every` ([#828](https://github.com/caolan/async/issues/828), [#829](https://github.com/caolan/async/issues/829))
 - `some`, `every` and `detect` now short circuit early ([#828](https://github.com/caolan/async/issues/828), [#829](https://github.com/caolan/async/issues/829))
 - Improve detection of the global object ([#804](https://github.com/caolan/async/issues/804)), enabling use in WebWorkers
 - `whilst` now called with arguments from iterator ([#823](https://github.com/caolan/async/issues/823))
 - `during` now gets called with arguments from iterator ([#824](https://github.com/caolan/async/issues/824))
 - Code simplifications and optimizations aplenty ([diff](https://github.com/caolan/async/compare/v1.3.0...v1.4.0))


 # v1.3.0

 New Features:
 - Added `constant`
 - Added `asyncify`/`wrapSync` for making sync functions work with callbacks. ([#671](https://github.com/caolan/async/issues/671), [#806](https://github.com/caolan/async/issues/806))
 - Added `during` and `doDuring`, which are like `whilst` with an async truth test. ([#800](https://github.com/caolan/async/issues/800))
 - `retry` now accepts an `interval` parameter to specify a delay between retries. ([#793](https://github.com/caolan/async/issues/793))
 - `async` should work better in Web Workers due to better `root` detection ([#804](https://github.com/caolan/async/issues/804))
 - Callbacks are now optional in `whilst`, `doWhilst`, `until`, and `doUntil` ([#642](https://github.com/caolan/async/issues/642))
 - Various internal updates ([#786](https://github.com/caolan/async/issues/786), [#801](https://github.com/caolan/async/issues/801), [#802](https://github.com/caolan/async/issues/802), [#803](https://github.com/caolan/async/issues/803))
 - Various doc fixes ([#790](https://github.com/caolan/async/issues/790), [#794](https://github.com/caolan/async/issues/794))

 Bug Fixes:
 - `cargo` now exposes the `payload` size, and `cargo.payload` can be changed on the fly after the `cargo` is created. ([#740](https://github.com/caolan/async/issues/740), [#744](https://github.com/caolan/async/issues/744), [#783](https://github.com/caolan/async/issues/783))


 # v1.2.1

 Bug Fix:

 - Small regression with synchronous iterator behavior in `eachSeries` with a 1-element array. Before 1.1.0, `eachSeries`'s callback was called on the same tick, which this patch restores. In 2.0.0, it will be called on the next tick. ([#782](https://github.com/caolan/async/issues/782))


 # v1.2.0

 New Features:

 - Added `timesLimit` ([#743](https://github.com/caolan/async/issues/743))
 - `concurrency` can be changed after initialization in `queue` by setting `q.concurrency`. The new concurrency will be reflected the next time a task is processed. ([#747](https://github.com/caolan/async/issues/747), [#772](https://github.com/caolan/async/issues/772))

 Bug Fixes:

 - Fixed a regression in `each` and family with empty arrays that have additional properties. ([#775](https://github.com/caolan/async/issues/775), [#777](https://github.com/caolan/async/issues/777))


 # v1.1.1

 Bug Fix:

 - Small regression with synchronous iterator behavior in `eachSeries` with a 1-element array. Before 1.1.0, `eachSeries`'s callback was called on the same tick, which this patch restores. In 2.0.0, it will be called on the next tick. ([#782](https://github.com/caolan/async/issues/782))


 # v1.1.0

 New Features:

 - `cargo` now supports all of the same methods and event callbacks as `queue`.
 - Added `ensureAsync` - A wrapper that ensures an async function calls its callback on a later tick. ([#769](https://github.com/caolan/async/issues/769))
 - Optimized `map`, `eachOf`, and `waterfall` families of functions
 - Passing a `null` or `undefined` array to `map`, `each`, `parallel` and families will be treated as an empty array ([#667](https://github.com/caolan/async/issues/667)).
 - The callback is now optional for the composed results of `compose` and `seq`. ([#618](https://github.com/caolan/async/issues/618))
 - Reduced file size by 4kb, (minified version by 1kb)
 - Added code coverage through `nyc` and `coveralls` ([#768](https://github.com/caolan/async/issues/768))

 Bug Fixes:

 - `forever` will no longer stack overflow with a synchronous iterator ([#622](https://github.com/caolan/async/issues/622))
 - `eachLimit` and other limit functions will stop iterating once an error occurs ([#754](https://github.com/caolan/async/issues/754))
 - Always pass `null` in callbacks when there is no error ([#439](https://github.com/caolan/async/issues/439))
 - Ensure proper conditions when calling `drain()` after pushing an empty data set to a queue ([#668](https://github.com/caolan/async/issues/668))
 - `each` and family will properly handle an empty array ([#578](https://github.com/caolan/async/issues/578))
 - `eachSeries` and family will finish if the underlying array is modified during execution ([#557](https://github.com/caolan/async/issues/557))
 - `queue` will throw if a non-function is passed to `q.push()` ([#593](https://github.com/caolan/async/issues/593))
 - Doc fixes ([#629](https://github.com/caolan/async/issues/629), [#766](https://github.com/caolan/async/issues/766))


 # v1.0.0

 No known breaking changes, we are simply complying with semver from here on out.

 Changes:

 - Start using a changelog!
 - Add `forEachOf` for iterating over Objects (or to iterate Arrays with indexes available) ([#168](https://github.com/caolan/async/issues/168) [#704](https://github.com/caolan/async/issues/704) [#321](https://github.com/caolan/async/issues/321))
 - Detect deadlocks in `auto` ([#663](https://github.com/caolan/async/issues/663))
 - Better support for require.js ([#527](https://github.com/caolan/async/issues/527))
 - Throw if queue created with concurrency `0` ([#714](https://github.com/caolan/async/issues/714))
 - Fix unneeded iteration in `queue.resume()` ([#758](https://github.com/caolan/async/issues/758))
 - Guard against timer mocking overriding `setImmediate` ([#609](https://github.com/caolan/async/issues/609) [#611](https://github.com/caolan/async/issues/611))
 - Miscellaneous doc fixes ([#542](https://github.com/caolan/async/issues/542) [#596](https://github.com/caolan/async/issues/596) [#615](https://github.com/caolan/async/issues/615) [#628](https://github.com/caolan/async/issues/628) [#631](https://github.com/caolan/async/issues/631) [#690](https://github.com/caolan/async/issues/690) [#729](https://github.com/caolan/async/issues/729))
 - Use single noop function internally ([#546](https://github.com/caolan/async/issues/546))
 - Optimize internal `_each`, `_map` and `_keys` functions.
--- a/node_modules/async/LICENSE
+++ b/node_modules/async/LICENSE
@@ -0,0 +1,19 @@
 Copyright (c) 2010-2018 Caolan McMahon

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:

 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.

 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
--- a/node_modules/async/README.md
+++ b/node_modules/async/README.md
@@ -0,0 +1,56 @@
 ![Async Logo](https://raw.githubusercontent.com/caolan/async/master/logo/async-logo_readme.jpg)

 [![Build Status via Travis CI](https://travis-ci.org/caolan/async.svg?branch=master)](https://travis-ci.org/caolan/async)
 [![NPM version](https://img.shields.io/npm/v/async.svg)](https://www.npmjs.com/package/async)
 [![Coverage Status](https://coveralls.io/repos/caolan/async/badge.svg?branch=master)](https://coveralls.io/r/caolan/async?branch=master)
 [![Join the chat at https://gitter.im/caolan/async](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/caolan/async?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 [![libhive - Open source examples](https://www.libhive.com/providers/npm/packages/async/examples/badge.svg)](https://www.libhive.com/providers/npm/packages/async)
 [![jsDelivr Hits](https://data.jsdelivr.com/v1/package/npm/async/badge?style=rounded)](https://www.jsdelivr.com/package/npm/async)


 Async is a utility module which provides straight-forward, powerful functions for working with [asynchronous JavaScript](http://caolan.github.io/async/global.html). Although originally designed for use with [Node.js](https://nodejs.org/) and installable via `npm install --save async`, it can also be used directly in the browser.

 This version of the package is optimized for the Node.js environment. If you use Async with webpack, install [`async-es`](https://www.npmjs.com/package/async-es) instead.

 For Documentation, visit <https://caolan.github.io/async/>

 *For Async v1.5.x documentation, go [HERE](https://github.com/caolan/async/blob/v1.5.2/README.md)*


 ```javascript
 // for use with Node-style callbacks...
 var async = require("async");

 var obj = {dev: "/dev.json", test: "/test.json", prod: "/prod.json"};
 var configs = {};

 async.forEachOf(obj, (value, key, callback) => {
    fs.readFile(__dirname + value, "utf8", (err, data) => {
        if (err) return callback(err);
        try {
            configs[key] = JSON.parse(data);
        } catch (e) {
            return callback(e);
        }
        callback();
    });
 }, err => {
    if (err) console.error(err.message);
    // configs is now a map of JSON data
    doSomethingWith(configs);
 });
 ```

 ```javascript
 var async = require("async");

 // ...or ES2017 async functions
 async.mapLimit(urls, 5, async function(url) {
    const response = await fetch(url)
    return response.body
 }, (err, results) => {
    if (err) throw err
    // results is now an array of the response bodies
    console.log(results)
 })
 ```
--- a/node_modules/async/all.js
+++ b/node_modules/async/all.js
@@ -0,0 +1,50 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });

 var _createTester = require('./internal/createTester');

 var _createTester2 = _interopRequireDefault(_createTester);

 var _doParallel = require('./internal/doParallel');

 var _doParallel2 = _interopRequireDefault(_doParallel);

 var _notId = require('./internal/notId');

 var _notId2 = _interopRequireDefault(_notId);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * Returns `true` if every element in `coll` satisfies an async test. If any
 * iteratee call returns `false`, the main `callback` is immediately called.
 *
 * @name every
 * @static
 * @memberOf module:Collections
 * @method
 * @alias all
 * @category Collection
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {AsyncFunction} iteratee - An async truth test to apply to each item
 * in the collection in parallel.
 * The iteratee must complete with a boolean result value.
 * Invoked with (item, callback).
 * @param {Function} [callback] - A callback which is called after all the
 * `iteratee` functions have finished. Result will be either `true` or `false`
 * depending on the values of the async tests. Invoked with (err, result).
 * @example
 *
 * async.every(['file1','file2','file3'], function(filePath, callback) {
 *     fs.access(filePath, function(err) {
 *         callback(null, !err)
 *     });
 * }, function(err, result) {
 *     // if result is true then every file exists
 * });
 */
 exports.default = (0, _doParallel2.default)((0, _createTester2.default)(_notId2.default, _notId2.default));
 module.exports = exports['default'];
--- a/node_modules/async/allLimit.js
+++ b/node_modules/async/allLimit.js
@@ -0,0 +1,42 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });

 var _createTester = require('./internal/createTester');

 var _createTester2 = _interopRequireDefault(_createTester);

 var _doParallelLimit = require('./internal/doParallelLimit');

 var _doParallelLimit2 = _interopRequireDefault(_doParallelLimit);

 var _notId = require('./internal/notId');

 var _notId2 = _interopRequireDefault(_notId);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * The same as [`every`]{@link module:Collections.every} but runs a maximum of `limit` async operations at a time.
 *
 * @name everyLimit
 * @static
 * @memberOf module:Collections
 * @method
 * @see [async.every]{@link module:Collections.every}
 * @alias allLimit
 * @category Collection
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {number} limit - The maximum number of async operations at a time.
 * @param {AsyncFunction} iteratee - An async truth test to apply to each item
 * in the collection in parallel.
 * The iteratee must complete with a boolean result value.
 * Invoked with (item, callback).
 * @param {Function} [callback] - A callback which is called after all the
 * `iteratee` functions have finished. Result will be either `true` or `false`
 * depending on the values of the async tests. Invoked with (err, result).
 */
 exports.default = (0, _doParallelLimit2.default)((0, _createTester2.default)(_notId2.default, _notId2.default));
 module.exports = exports['default'];
--- a/node_modules/async/allSeries.js
+++ b/node_modules/async/allSeries.js
@@ -0,0 +1,37 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });

 var _everyLimit = require('./everyLimit');

 var _everyLimit2 = _interopRequireDefault(_everyLimit);

 var _doLimit = require('./internal/doLimit');

 var _doLimit2 = _interopRequireDefault(_doLimit);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * The same as [`every`]{@link module:Collections.every} but runs only a single async operation at a time.
 *
 * @name everySeries
 * @static
 * @memberOf module:Collections
 * @method
 * @see [async.every]{@link module:Collections.every}
 * @alias allSeries
 * @category Collection
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {AsyncFunction} iteratee - An async truth test to apply to each item
 * in the collection in series.
 * The iteratee must complete with a boolean result value.
 * Invoked with (item, callback).
 * @param {Function} [callback] - A callback which is called after all the
 * `iteratee` functions have finished. Result will be either `true` or `false`
 * depending on the values of the async tests. Invoked with (err, result).
 */
 exports.default = (0, _doLimit2.default)(_everyLimit2.default, 1);
 module.exports = exports['default'];
--- a/node_modules/async/any.js
+++ b/node_modules/async/any.js
@@ -0,0 +1,52 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });

 var _createTester = require('./internal/createTester');

 var _createTester2 = _interopRequireDefault(_createTester);

 var _doParallel = require('./internal/doParallel');

 var _doParallel2 = _interopRequireDefault(_doParallel);

 var _identity = require('lodash/identity');

 var _identity2 = _interopRequireDefault(_identity);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * Returns `true` if at least one element in the `coll` satisfies an async test.
 * If any iteratee call returns `true`, the main `callback` is immediately
 * called.
 *
 * @name some
 * @static
 * @memberOf module:Collections
 * @method
 * @alias any
 * @category Collection
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {AsyncFunction} iteratee - An async truth test to apply to each item
 * in the collections in parallel.
 * The iteratee should complete with a boolean `result` value.
 * Invoked with (item, callback).
 * @param {Function} [callback] - A callback which is called as soon as any
 * iteratee returns `true`, or after all the iteratee functions have finished.
 * Result will be either `true` or `false` depending on the values of the async
 * tests. Invoked with (err, result).
 * @example
 *
 * async.some(['file1','file2','file3'], function(filePath, callback) {
 *     fs.access(filePath, function(err) {
 *         callback(null, !err)
 *     });
 * }, function(err, result) {
 *     // if result is true then at least one of the files exists
 * });
 */
 exports.default = (0, _doParallel2.default)((0, _createTester2.default)(Boolean, _identity2.default));
 module.exports = exports['default'];
--- a/node_modules/async/anyLimit.js
+++ b/node_modules/async/anyLimit.js
@@ -0,0 +1,43 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });

 var _createTester = require('./internal/createTester');

 var _createTester2 = _interopRequireDefault(_createTester);

 var _doParallelLimit = require('./internal/doParallelLimit');

 var _doParallelLimit2 = _interopRequireDefault(_doParallelLimit);

 var _identity = require('lodash/identity');

 var _identity2 = _interopRequireDefault(_identity);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * The same as [`some`]{@link module:Collections.some} but runs a maximum of `limit` async operations at a time.
 *
 * @name someLimit
 * @static
 * @memberOf module:Collections
 * @method
 * @see [async.some]{@link module:Collections.some}
 * @alias anyLimit
 * @category Collection
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {number} limit - The maximum number of async operations at a time.
 * @param {AsyncFunction} iteratee - An async truth test to apply to each item
 * in the collections in parallel.
 * The iteratee should complete with a boolean `result` value.
 * Invoked with (item, callback).
 * @param {Function} [callback] - A callback which is called as soon as any
 * iteratee returns `true`, or after all the iteratee functions have finished.
 * Result will be either `true` or `false` depending on the values of the async
 * tests. Invoked with (err, result).
 */
 exports.default = (0, _doParallelLimit2.default)((0, _createTester2.default)(Boolean, _identity2.default));
 module.exports = exports['default'];
--- a/node_modules/async/anySeries.js
+++ b/node_modules/async/anySeries.js
@@ -0,0 +1,38 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });

 var _someLimit = require('./someLimit');

 var _someLimit2 = _interopRequireDefault(_someLimit);

 var _doLimit = require('./internal/doLimit');

 var _doLimit2 = _interopRequireDefault(_doLimit);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * The same as [`some`]{@link module:Collections.some} but runs only a single async operation at a time.
 *
 * @name someSeries
 * @static
 * @memberOf module:Collections
 * @method
 * @see [async.some]{@link module:Collections.some}
 * @alias anySeries
 * @category Collection
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {AsyncFunction} iteratee - An async truth test to apply to each item
 * in the collections in series.
 * The iteratee should complete with a boolean `result` value.
 * Invoked with (item, callback).
 * @param {Function} [callback] - A callback which is called as soon as any
 * iteratee returns `true`, or after all the iteratee functions have finished.
 * Result will be either `true` or `false` depending on the values of the async
 * tests. Invoked with (err, result).
 */
 exports.default = (0, _doLimit2.default)(_someLimit2.default, 1);
 module.exports = exports['default'];
--- a/node_modules/async/apply.js
+++ b/node_modules/async/apply.js
@@ -0,0 +1,68 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
    value: true
 });

 exports.default = function (fn /*, ...args*/) {
    var args = (0, _slice2.default)(arguments, 1);
    return function () /*callArgs*/{
        var callArgs = (0, _slice2.default)(arguments);
        return fn.apply(null, args.concat(callArgs));
    };
 };

 var _slice = require('./internal/slice');

 var _slice2 = _interopRequireDefault(_slice);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 ;

 /**
 * Creates a continuation function with some arguments already applied.
 *
 * Useful as a shorthand when combined with other control flow functions. Any
 * arguments passed to the returned function are added to the arguments
 * originally passed to apply.
 *
 * @name apply
 * @static
 * @memberOf module:Utils
 * @method
 * @category Util
 * @param {Function} fn - The function you want to eventually apply all
 * arguments to. Invokes with (arguments...).
 * @param {...*} arguments... - Any number of arguments to automatically apply
 * when the continuation is called.
 * @returns {Function} the partially-applied function
 * @example
 *
 * // using apply
 * async.parallel([
 *     async.apply(fs.writeFile, 'testfile1', 'test1'),
 *     async.apply(fs.writeFile, 'testfile2', 'test2')
 * ]);
 *
 *
 * // the same process without using apply
 * async.parallel([
 *     function(callback) {
 *         fs.writeFile('testfile1', 'test1', callback);
 *     },
 *     function(callback) {
 *         fs.writeFile('testfile2', 'test2', callback);
 *     }
 * ]);
 *
 * // It's possible to pass any number of additional arguments when calling the
 * // continuation:
 *
 * node> var fn = async.apply(sys.puts, 'one');
 * node> fn('two', 'three');
 * one
 * two
 * three
 */
 module.exports = exports['default'];
--- a/node_modules/async/applyEach.js
+++ b/node_modules/async/applyEach.js
@@ -0,0 +1,51 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });

 var _applyEach = require('./internal/applyEach');

 var _applyEach2 = _interopRequireDefault(_applyEach);

 var _map = require('./map');

 var _map2 = _interopRequireDefault(_map);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * Applies the provided arguments to each function in the array, calling
 * `callback` after all functions have completed. If you only provide the first
 * argument, `fns`, then it will return a function which lets you pass in the
 * arguments as if it were a single function call. If more arguments are
 * provided, `callback` is required while `args` is still optional.
 *
 * @name applyEach
 * @static
 * @memberOf module:ControlFlow
 * @method
 * @category Control Flow
 * @param {Array|Iterable|Object} fns - A collection of {@link AsyncFunction}s
 * to all call with the same arguments
 * @param {...*} [args] - any number of separate arguments to pass to the
 * function.
 * @param {Function} [callback] - the final argument should be the callback,
 * called when all functions have completed processing.
 * @returns {Function} - If only the first argument, `fns`, is provided, it will
 * return a function which lets you pass in the arguments as if it were a single
 * function call. The signature is `(..args, callback)`. If invoked with any
 * arguments, `callback` is required.
 * @example
 *
 * async.applyEach([enableSearch, updateSchema], 'bucket', callback);
 *
 * // partial application example:
 * async.each(
 *     buckets,
 *     async.applyEach([enableSearch, updateSchema]),
 *     callback
 * );
 */
 exports.default = (0, _applyEach2.default)(_map2.default);
 module.exports = exports['default'];
--- a/node_modules/async/applyEachSeries.js
+++ b/node_modules/async/applyEachSeries.js
@@ -0,0 +1,37 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });

 var _applyEach = require('./internal/applyEach');

 var _applyEach2 = _interopRequireDefault(_applyEach);

 var _mapSeries = require('./mapSeries');

 var _mapSeries2 = _interopRequireDefault(_mapSeries);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * The same as [`applyEach`]{@link module:ControlFlow.applyEach} but runs only a single async operation at a time.
 *
 * @name applyEachSeries
 * @static
 * @memberOf module:ControlFlow
 * @method
 * @see [async.applyEach]{@link module:ControlFlow.applyEach}
 * @category Control Flow
 * @param {Array|Iterable|Object} fns - A collection of {@link AsyncFunction}s to all
 * call with the same arguments
 * @param {...*} [args] - any number of separate arguments to pass to the
 * function.
 * @param {Function} [callback] - the final argument should be the callback,
 * called when all functions have completed processing.
 * @returns {Function} - If only the first argument is provided, it will return
 * a function which lets you pass in the arguments as if it were a single
 * function call.
 */
 exports.default = (0, _applyEach2.default)(_mapSeries2.default);
 module.exports = exports['default'];
--- a/node_modules/async/asyncify.js
+++ b/node_modules/async/asyncify.js
@@ -0,0 +1,110 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
    value: true
 });
 exports.default = asyncify;

 var _isObject = require('lodash/isObject');

 var _isObject2 = _interopRequireDefault(_isObject);

 var _initialParams = require('./internal/initialParams');

 var _initialParams2 = _interopRequireDefault(_initialParams);

 var _setImmediate = require('./internal/setImmediate');

 var _setImmediate2 = _interopRequireDefault(_setImmediate);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * Take a sync function and make it async, passing its return value to a
 * callback. This is useful for plugging sync functions into a waterfall,
 * series, or other async functions. Any arguments passed to the generated
 * function will be passed to the wrapped function (except for the final
 * callback argument). Errors thrown will be passed to the callback.
 *
 * If the function passed to `asyncify` returns a Promise, that promises's
 * resolved/rejected state will be used to call the callback, rather than simply
 * the synchronous return value.
 *
 * This also means you can asyncify ES2017 `async` functions.
 *
 * @name asyncify
 * @static
 * @memberOf module:Utils
 * @method
 * @alias wrapSync
 * @category Util
 * @param {Function} func - The synchronous function, or Promise-returning
 * function to convert to an {@link AsyncFunction}.
 * @returns {AsyncFunction} An asynchronous wrapper of the `func`. To be
 * invoked with `(args..., callback)`.
 * @example
 *
 * // passing a regular synchronous function
 * async.waterfall([
 *     async.apply(fs.readFile, filename, "utf8"),
 *     async.asyncify(JSON.parse),
 *     function (data, next) {
 *         // data is the result of parsing the text.
 *         // If there was a parsing error, it would have been caught.
 *     }
 * ], callback);
 *
 * // passing a function returning a promise
 * async.waterfall([
 *     async.apply(fs.readFile, filename, "utf8"),
 *     async.asyncify(function (contents) {
 *         return db.model.create(contents);
 *     }),
 *     function (model, next) {
 *         // `model` is the instantiated model object.
 *         // If there was an error, this function would be skipped.
 *     }
 * ], callback);
 *
 * // es2017 example, though `asyncify` is not needed if your JS environment
 * // supports async functions out of the box
 * var q = async.queue(async.asyncify(async function(file) {
 *     var intermediateStep = await processFile(file);
 *     return await somePromise(intermediateStep)
 * }));
 *
 * q.push(files);
 */
 function asyncify(func) {
    return (0, _initialParams2.default)(function (args, callback) {
        var result;
        try {
            result = func.apply(this, args);
        } catch (e) {
            return callback(e);
        }
        // if result is Promise object
        if ((0, _isObject2.default)(result) && typeof result.then === 'function') {
            result.then(function (value) {
                invokeCallback(callback, null, value);
            }, function (err) {
                invokeCallback(callback, err.message ? err : new Error(err));
            });
        } else {
            callback(null, result);
        }
    });
 }

 function invokeCallback(callback, error, value) {
    try {
        callback(error, value);
    } catch (e) {
        (0, _setImmediate2.default)(rethrow, e);
    }
 }

 function rethrow(error) {
    throw error;
 }
 module.exports = exports['default'];
--- a/node_modules/async/auto.js
+++ b/node_modules/async/auto.js
@@ -0,0 +1,289 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
    value: true
 });

 exports.default = function (tasks, concurrency, callback) {
    if (typeof concurrency === 'function') {
        // concurrency is optional, shift the args.
        callback = concurrency;
        concurrency = null;
    }
    callback = (0, _once2.default)(callback || _noop2.default);
    var keys = (0, _keys2.default)(tasks);
    var numTasks = keys.length;
    if (!numTasks) {
        return callback(null);
    }
    if (!concurrency) {
        concurrency = numTasks;
    }

    var results = {};
    var runningTasks = 0;
    var hasError = false;

    var listeners = Object.create(null);

    var readyTasks = [];

    // for cycle detection:
    var readyToCheck = []; // tasks that have been identified as reachable
    // without the possibility of returning to an ancestor task
    var uncheckedDependencies = {};

    (0, _baseForOwn2.default)(tasks, function (task, key) {
        if (!(0, _isArray2.default)(task)) {
            // no dependencies
            enqueueTask(key, [task]);
            readyToCheck.push(key);
            return;
        }

        var dependencies = task.slice(0, task.length - 1);
        var remainingDependencies = dependencies.length;
        if (remainingDependencies === 0) {
            enqueueTask(key, task);
            readyToCheck.push(key);
            return;
        }
        uncheckedDependencies[key] = remainingDependencies;

        (0, _arrayEach2.default)(dependencies, function (dependencyName) {
            if (!tasks[dependencyName]) {
                throw new Error('async.auto task `' + key + '` has a non-existent dependency `' + dependencyName + '` in ' + dependencies.join(', '));
            }
            addListener(dependencyName, function () {
                remainingDependencies--;
                if (remainingDependencies === 0) {
                    enqueueTask(key, task);
                }
            });
        });
    });

    checkForDeadlocks();
    processQueue();

    function enqueueTask(key, task) {
        readyTasks.push(function () {
            runTask(key, task);
        });
    }

    function processQueue() {
        if (readyTasks.length === 0 && runningTasks === 0) {
            return callback(null, results);
        }
        while (readyTasks.length && runningTasks < concurrency) {
            var run = readyTasks.shift();
            run();
        }
    }

    function addListener(taskName, fn) {
        var taskListeners = listeners[taskName];
        if (!taskListeners) {
            taskListeners = listeners[taskName] = [];
        }

        taskListeners.push(fn);
    }

    function taskComplete(taskName) {
        var taskListeners = listeners[taskName] || [];
        (0, _arrayEach2.default)(taskListeners, function (fn) {
            fn();
        });
        processQueue();
    }

    function runTask(key, task) {
        if (hasError) return;

        var taskCallback = (0, _onlyOnce2.default)(function (err, result) {
            runningTasks--;
            if (arguments.length > 2) {
                result = (0, _slice2.default)(arguments, 1);
            }
            if (err) {
                var safeResults = {};
                (0, _baseForOwn2.default)(results, function (val, rkey) {
                    safeResults[rkey] = val;
                });
                safeResults[key] = result;
                hasError = true;
                listeners = Object.create(null);

                callback(err, safeResults);
            } else {
                results[key] = result;
                taskComplete(key);
            }
        });

        runningTasks++;
        var taskFn = (0, _wrapAsync2.default)(task[task.length - 1]);
        if (task.length > 1) {
            taskFn(results, taskCallback);
        } else {
            taskFn(taskCallback);
        }
    }

    function checkForDeadlocks() {
        // Kahn's algorithm
        // https://en.wikipedia.org/wiki/Topological_sorting#Kahn.27s_algorithm
        // http://connalle.blogspot.com/2013/10/topological-sortingkahn-algorithm.html
        var currentTask;
        var counter = 0;
        while (readyToCheck.length) {
            currentTask = readyToCheck.pop();
            counter++;
            (0, _arrayEach2.default)(getDependents(currentTask), function (dependent) {
                if (--uncheckedDependencies[dependent] === 0) {
                    readyToCheck.push(dependent);
                }
            });
        }

        if (counter !== numTasks) {
            throw new Error('async.auto cannot execute tasks due to a recursive dependency');
        }
    }

    function getDependents(taskName) {
        var result = [];
        (0, _baseForOwn2.default)(tasks, function (task, key) {
            if ((0, _isArray2.default)(task) && (0, _baseIndexOf2.default)(task, taskName, 0) >= 0) {
                result.push(key);
            }
        });
        return result;
    }
 };

 var _arrayEach = require('lodash/_arrayEach');

 var _arrayEach2 = _interopRequireDefault(_arrayEach);

 var _baseForOwn = require('lodash/_baseForOwn');

 var _baseForOwn2 = _interopRequireDefault(_baseForOwn);

 var _baseIndexOf = require('lodash/_baseIndexOf');

 var _baseIndexOf2 = _interopRequireDefault(_baseIndexOf);

 var _isArray = require('lodash/isArray');

 var _isArray2 = _interopRequireDefault(_isArray);

 var _keys = require('lodash/keys');

 var _keys2 = _interopRequireDefault(_keys);

 var _noop = require('lodash/noop');

 var _noop2 = _interopRequireDefault(_noop);

 var _slice = require('./internal/slice');

 var _slice2 = _interopRequireDefault(_slice);

 var _once = require('./internal/once');

 var _once2 = _interopRequireDefault(_once);

 var _onlyOnce = require('./internal/onlyOnce');

 var _onlyOnce2 = _interopRequireDefault(_onlyOnce);

 var _wrapAsync = require('./internal/wrapAsync');

 var _wrapAsync2 = _interopRequireDefault(_wrapAsync);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 module.exports = exports['default'];

 /**
 * Determines the best order for running the {@link AsyncFunction}s in `tasks`, based on
 * their requirements. Each function can optionally depend on other functions
 * being completed first, and each function is run as soon as its requirements
 * are satisfied.
 *
 * If any of the {@link AsyncFunction}s pass an error to their callback, the `auto` sequence
 * will stop. Further tasks will not execute (so any other functions depending
 * on it will not run), and the main `callback` is immediately called with the
 * error.
 *
 * {@link AsyncFunction}s also receive an object containing the results of functions which
 * have completed so far as the first argument, if they have dependencies. If a
 * task function has no dependencies, it will only be passed a callback.
 *
 * @name auto
 * @static
 * @memberOf module:ControlFlow
 * @method
 * @category Control Flow
 * @param {Object} tasks - An object. Each of its properties is either a
 * function or an array of requirements, with the {@link AsyncFunction} itself the last item
 * in the array. The object's key of a property serves as the name of the task
 * defined by that property, i.e. can be used when specifying requirements for
 * other tasks. The function receives one or two arguments:
 * * a `results` object, containing the results of the previously executed
 *   functions, only passed if the task has any dependencies,
 * * a `callback(err, result)` function, which must be called when finished,
 *   passing an `error` (which can be `null`) and the result of the function's
 *   execution.
 * @param {number} [concurrency=Infinity] - An optional `integer` for
 * determining the maximum number of tasks that can be run in parallel. By
 * default, as many as possible.
 * @param {Function} [callback] - An optional callback which is called when all
 * the tasks have been completed. It receives the `err` argument if any `tasks`
 * pass an error to their callback. Results are always returned; however, if an
 * error occurs, no further `tasks` will be performed, and the results object
 * will only contain partial results. Invoked with (err, results).
 * @returns undefined
 * @example
 *
 * async.auto({
 *     // this function will just be passed a callback
 *     readData: async.apply(fs.readFile, 'data.txt', 'utf-8'),
 *     showData: ['readData', function(results, cb) {
 *         // results.readData is the file's contents
 *         // ...
 *     }]
 * }, callback);
 *
 * async.auto({
 *     get_data: function(callback) {
 *         console.log('in get_data');
 *         // async code to get some data
 *         callback(null, 'data', 'converted to array');
 *     },
 *     make_folder: function(callback) {
 *         console.log('in make_folder');
 *         // async code to create a directory to store a file in
 *         // this is run at the same time as getting the data
 *         callback(null, 'folder');
 *     },
 *     write_file: ['get_data', 'make_folder', function(results, callback) {
 *         console.log('in write_file', JSON.stringify(results));
 *         // once there is some data and the directory exists,
 *         // write the data to a file in the directory
 *         callback(null, 'filename');
 *     }],
 *     email_link: ['write_file', function(results, callback) {
 *         console.log('in email_link', JSON.stringify(results));
 *         // once the file is written let's email a link to it...
 *         // results.write_file contains the filename returned by write_file.
 *         callback(null, {'file':results.write_file, 'email':'user@example.com'});
 *     }]
 * }, function(err, results) {
 *     console.log('err = ', err);
 *     console.log('results = ', results);
 * });
 */
--- a/node_modules/async/autoInject.js
+++ b/node_modules/async/autoInject.js
@@ -0,0 +1,170 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
    value: true
 });
 exports.default = autoInject;

 var _auto = require('./auto');

 var _auto2 = _interopRequireDefault(_auto);

 var _baseForOwn = require('lodash/_baseForOwn');

 var _baseForOwn2 = _interopRequireDefault(_baseForOwn);

 var _arrayMap = require('lodash/_arrayMap');

 var _arrayMap2 = _interopRequireDefault(_arrayMap);

 var _isArray = require('lodash/isArray');

 var _isArray2 = _interopRequireDefault(_isArray);

 var _trim = require('lodash/trim');

 var _trim2 = _interopRequireDefault(_trim);

 var _wrapAsync = require('./internal/wrapAsync');

 var _wrapAsync2 = _interopRequireDefault(_wrapAsync);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

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

 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 (0, _trim2.default)(arg.replace(FN_ARG, ''));
    });
    return func;
 }

 /**
 * A dependency-injected version of the [async.auto]{@link module:ControlFlow.auto} function. Dependent
 * tasks are specified as parameters to the function, after the usual callback
 * parameter, with the parameter names matching the names of the tasks it
 * depends on. This can provide even more readable task graphs which can be
 * easier to maintain.
 *
 * If a final callback is specified, the task results are similarly injected,
 * specified as named parameters after the initial error parameter.
 *
 * The autoInject function is purely syntactic sugar and its semantics are
 * otherwise equivalent to [async.auto]{@link module:ControlFlow.auto}.
 *
 * @name autoInject
 * @static
 * @memberOf module:ControlFlow
 * @method
 * @see [async.auto]{@link module:ControlFlow.auto}
 * @category Control Flow
 * @param {Object} tasks - An object, each of whose properties is an {@link AsyncFunction} of
 * the form 'func([dependencies...], callback). The object's key of a property
 * serves as the name of the task defined by that property, i.e. can be used
 * when specifying requirements for other tasks.
 * * The `callback` parameter is a `callback(err, result)` which must be called
 *   when finished, passing an `error` (which can be `null`) and the result of
 *   the function's execution. The remaining parameters name other tasks on
 *   which the task is dependent, and the results from those tasks are the
 *   arguments of those parameters.
 * @param {Function} [callback] - An optional callback which is called when all
 * the tasks have been completed. It receives the `err` argument if any `tasks`
 * pass an error to their callback, and a `results` object with any completed
 * task results, similar to `auto`.
 * @example
 *
 * //  The example from `auto` can be rewritten as follows:
 * async.autoInject({
 *     get_data: function(callback) {
 *         // async code to get some data
 *         callback(null, 'data', 'converted to array');
 *     },
 *     make_folder: function(callback) {
 *         // async code to create a directory to store a file in
 *         // this is run at the same time as getting the data
 *         callback(null, 'folder');
 *     },
 *     write_file: function(get_data, make_folder, callback) {
 *         // once there is some data and the directory exists,
 *         // write the data to a file in the directory
 *         callback(null, 'filename');
 *     },
 *     email_link: function(write_file, callback) {
 *         // once the file is written let's email a link to it...
 *         // write_file contains the filename returned by write_file.
 *         callback(null, {'file':write_file, 'email':'user@example.com'});
 *     }
 * }, function(err, results) {
 *     console.log('err = ', err);
 *     console.log('email_link = ', results.email_link);
 * });
 *
 * // If you are using a JS minifier that mangles parameter names, `autoInject`
 * // will not work with plain functions, since the parameter names will be
 * // collapsed to a single letter identifier.  To work around this, you can
 * // explicitly specify the names of the parameters your task function needs
 * // in an array, similar to Angular.js dependency injection.
 *
 * // This still has an advantage over plain `auto`, since the results a task
 * // depends on are still spread into arguments.
 * async.autoInject({
 *     //...
 *     write_file: ['get_data', 'make_folder', function(get_data, make_folder, callback) {
 *         callback(null, 'filename');
 *     }],
 *     email_link: ['write_file', function(write_file, callback) {
 *         callback(null, {'file':write_file, 'email':'user@example.com'});
 *     }]
 *     //...
 * }, function(err, results) {
 *     console.log('err = ', err);
 *     console.log('email_link = ', results.email_link);
 * });
 */
 function autoInject(tasks, callback) {
    var newTasks = {};

    (0, _baseForOwn2.default)(tasks, function (taskFn, key) {
        var params;
        var fnIsAsync = (0, _wrapAsync.isAsync)(taskFn);
        var hasNoDeps = !fnIsAsync && taskFn.length === 1 || fnIsAsync && taskFn.length === 0;

        if ((0, _isArray2.default)(taskFn)) {
            params = taskFn.slice(0, -1);
            taskFn = taskFn[taskFn.length - 1];

            newTasks[key] = params.concat(params.length > 0 ? newTask : taskFn);
        } else if (hasNoDeps) {
            // no dependencies, use the function as-is
            newTasks[key] = taskFn;
        } else {
            params = parseParams(taskFn);
            if (taskFn.length === 0 && !fnIsAsync && params.length === 0) {
                throw new Error("autoInject task functions require explicit parameters.");
            }

            // remove callback param
            if (!fnIsAsync) params.pop();

            newTasks[key] = params.concat(newTask);
        }

        function newTask(results, taskCb) {
            var newArgs = (0, _arrayMap2.default)(params, function (name) {
                return results[name];
            });
            newArgs.push(taskCb);
            (0, _wrapAsync2.default)(taskFn).apply(null, newArgs);
        }
    });

    (0, _auto2.default)(newTasks, callback);
 }
 module.exports = exports['default'];
--- a/node_modules/async/bower.json
+++ b/node_modules/async/bower.json
@@ -0,0 +1,17 @@
 {
  "name": "async",
  "main": "dist/async.js",
  "ignore": [
    "bower_components",
    "lib",
    "mocha_test",
    "node_modules",
    "perf",
    "support",
    "**/.*",
    "*.config.js",
    "*.json",
    "index.js",
    "Makefile"
  ]
 }
--- a/node_modules/async/cargo.js
+++ b/node_modules/async/cargo.js
@@ -0,0 +1,94 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });
 exports.default = cargo;

 var _queue = require('./internal/queue');

 var _queue2 = _interopRequireDefault(_queue);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * A cargo of tasks for the worker function to complete. Cargo inherits all of
 * the same methods and event callbacks as [`queue`]{@link module:ControlFlow.queue}.
 * @typedef {Object} CargoObject
 * @memberOf module:ControlFlow
 * @property {Function} length - A function returning the number of items
 * waiting to be processed. Invoke like `cargo.length()`.
 * @property {number} payload - An `integer` for determining how many tasks
 * should be process per round. This property can be changed after a `cargo` is
 * created to alter the payload on-the-fly.
 * @property {Function} push - Adds `task` to the `queue`. The callback is
 * called once the `worker` has finished processing the task. Instead of a
 * single task, an array of `tasks` can be submitted. The respective callback is
 * used for every task in the list. Invoke like `cargo.push(task, [callback])`.
 * @property {Function} saturated - A callback that is called when the
 * `queue.length()` hits the concurrency and further tasks will be queued.
 * @property {Function} empty - A callback that is called when the last item
 * from the `queue` is given to a `worker`.
 * @property {Function} drain - A callback that is called when the last item
 * from the `queue` has returned from the `worker`.
 * @property {Function} idle - a function returning false if there are items
 * waiting or being processed, or true if not. Invoke like `cargo.idle()`.
 * @property {Function} pause - a function that pauses the processing of tasks
 * until `resume()` is called. Invoke like `cargo.pause()`.
 * @property {Function} resume - a function that resumes the processing of
 * queued tasks when the queue is paused. Invoke like `cargo.resume()`.
 * @property {Function} kill - a function that removes the `drain` callback and
 * empties remaining tasks from the queue forcing it to go idle. Invoke like `cargo.kill()`.
 */

 /**
 * Creates a `cargo` object with the specified payload. Tasks added to the
 * cargo will be processed altogether (up to the `payload` limit). If the
 * `worker` is in progress, the task is queued until it becomes available. Once
 * the `worker` has completed some tasks, each callback of those tasks is
 * called. Check out [these](https://camo.githubusercontent.com/6bbd36f4cf5b35a0f11a96dcd2e97711ffc2fb37/68747470733a2f2f662e636c6f75642e6769746875622e636f6d2f6173736574732f313637363837312f36383130382f62626330636662302d356632392d313165322d393734662d3333393763363464633835382e676966) [animations](https://camo.githubusercontent.com/f4810e00e1c5f5f8addbe3e9f49064fd5d102699/68747470733a2f2f662e636c6f75642e6769746875622e636f6d2f6173736574732f313637363837312f36383130312f38346339323036362d356632392d313165322d383134662d3964336430323431336266642e676966)
 * for how `cargo` and `queue` work.
 *
 * While [`queue`]{@link module:ControlFlow.queue} passes only one task to one of a group of workers
 * at a time, cargo passes an array of tasks to a single worker, repeating
 * when the worker is finished.
 *
 * @name cargo
 * @static
 * @memberOf module:ControlFlow
 * @method
 * @see [async.queue]{@link module:ControlFlow.queue}
 * @category Control Flow
 * @param {AsyncFunction} worker - An asynchronous function for processing an array
 * of queued tasks. Invoked with `(tasks, callback)`.
 * @param {number} [payload=Infinity] - An optional `integer` for determining
 * how many tasks should be processed per round; if omitted, the default is
 * unlimited.
 * @returns {module:ControlFlow.CargoObject} A cargo object to manage the tasks. Callbacks can
 * attached as certain properties to listen for specific events during the
 * lifecycle of the cargo and inner queue.
 * @example
 *
 * // create a cargo object with payload 2
 * var cargo = async.cargo(function(tasks, callback) {
 *     for (var i=0; i<tasks.length; i++) {
 *         console.log('hello ' + tasks[i].name);
 *     }
 *     callback();
 * }, 2);
 *
 * // add some items
 * cargo.push({name: 'foo'}, function(err) {
 *     console.log('finished processing foo');
 * });
 * cargo.push({name: 'bar'}, function(err) {
 *     console.log('finished processing bar');
 * });
 * cargo.push({name: 'baz'}, function(err) {
 *     console.log('finished processing baz');
 * });
 */
 function cargo(worker, payload) {
  return (0, _queue2.default)(worker, 1, payload);
 }
 module.exports = exports['default'];
--- a/node_modules/async/compose.js
+++ b/node_modules/async/compose.js
@@ -0,0 +1,58 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });

 exports.default = function () /*...args*/{
  return _seq2.default.apply(null, (0, _slice2.default)(arguments).reverse());
 };

 var _seq = require('./seq');

 var _seq2 = _interopRequireDefault(_seq);

 var _slice = require('./internal/slice');

 var _slice2 = _interopRequireDefault(_slice);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 ;

 /**
 * Creates a function which is a composition of the passed asynchronous
 * functions. Each function consumes the return value of the function that
 * follows. Composing functions `f()`, `g()`, and `h()` would produce the result
 * of `f(g(h()))`, only this version uses callbacks to obtain the return values.
 *
 * Each function is executed with the `this` binding of the composed function.
 *
 * @name compose
 * @static
 * @memberOf module:ControlFlow
 * @method
 * @category Control Flow
 * @param {...AsyncFunction} functions - the asynchronous functions to compose
 * @returns {Function} an asynchronous function that is the composed
 * asynchronous `functions`
 * @example
 *
 * function add1(n, callback) {
 *     setTimeout(function () {
 *         callback(null, n + 1);
 *     }, 10);
 * }
 *
 * function mul3(n, callback) {
 *     setTimeout(function () {
 *         callback(null, n * 3);
 *     }, 10);
 * }
 *
 * var add1mul3 = async.compose(mul3, add1);
 * add1mul3(4, function (err, result) {
 *     // result now equals 15
 * });
 */
 module.exports = exports['default'];
--- a/node_modules/async/concat.js
+++ b/node_modules/async/concat.js
@@ -0,0 +1,43 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });

 var _doLimit = require('./internal/doLimit');

 var _doLimit2 = _interopRequireDefault(_doLimit);

 var _concatLimit = require('./concatLimit');

 var _concatLimit2 = _interopRequireDefault(_concatLimit);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * Applies `iteratee` to each item in `coll`, concatenating the results. Returns
 * the concatenated list. The `iteratee`s are called in parallel, and the
 * results are concatenated as they return. There is no guarantee that the
 * results array will be returned in the original order of `coll` passed to the
 * `iteratee` function.
 *
 * @name concat
 * @static
 * @memberOf module:Collections
 * @method
 * @category Collection
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {AsyncFunction} iteratee - A function to apply to each item in `coll`,
 * which should use an array as its result. Invoked with (item, callback).
 * @param {Function} [callback(err)] - A callback which is called after all the
 * `iteratee` functions have finished, or an error occurs. Results is an array
 * containing the concatenated results of the `iteratee` function. Invoked with
 * (err, results).
 * @example
 *
 * async.concat(['dir1','dir2','dir3'], fs.readdir, function(err, files) {
 *     // files is now a list of filenames that exist in the 3 directories
 * });
 */
 exports.default = (0, _doLimit2.default)(_concatLimit2.default, Infinity);
 module.exports = exports['default'];
--- a/node_modules/async/concatLimit.js
+++ b/node_modules/async/concatLimit.js
@@ -0,0 +1,65 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
    value: true
 });

 exports.default = function (coll, limit, iteratee, callback) {
    callback = callback || _noop2.default;
    var _iteratee = (0, _wrapAsync2.default)(iteratee);
    (0, _mapLimit2.default)(coll, limit, function (val, callback) {
        _iteratee(val, function (err /*, ...args*/) {
            if (err) return callback(err);
            return callback(null, (0, _slice2.default)(arguments, 1));
        });
    }, function (err, mapResults) {
        var result = [];
        for (var i = 0; i < mapResults.length; i++) {
            if (mapResults[i]) {
                result = _concat.apply(result, mapResults[i]);
            }
        }

        return callback(err, result);
    });
 };

 var _noop = require('lodash/noop');

 var _noop2 = _interopRequireDefault(_noop);

 var _wrapAsync = require('./internal/wrapAsync');

 var _wrapAsync2 = _interopRequireDefault(_wrapAsync);

 var _slice = require('./internal/slice');

 var _slice2 = _interopRequireDefault(_slice);

 var _mapLimit = require('./mapLimit');

 var _mapLimit2 = _interopRequireDefault(_mapLimit);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 var _concat = Array.prototype.concat;

 /**
 * The same as [`concat`]{@link module:Collections.concat} but runs a maximum of `limit` async operations at a time.
 *
 * @name concatLimit
 * @static
 * @memberOf module:Collections
 * @method
 * @see [async.concat]{@link module:Collections.concat}
 * @category Collection
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {number} limit - The maximum number of async operations at a time.
 * @param {AsyncFunction} iteratee - A function to apply to each item in `coll`,
 * which should use an array as its result. Invoked with (item, callback).
 * @param {Function} [callback] - A callback which is called after all the
 * `iteratee` functions have finished, or an error occurs. Results is an array
 * containing the concatenated results of the `iteratee` function. Invoked with
 * (err, results).
 */
 module.exports = exports['default'];
--- a/node_modules/async/concatSeries.js
+++ b/node_modules/async/concatSeries.js
@@ -0,0 +1,36 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });

 var _doLimit = require('./internal/doLimit');

 var _doLimit2 = _interopRequireDefault(_doLimit);

 var _concatLimit = require('./concatLimit');

 var _concatLimit2 = _interopRequireDefault(_concatLimit);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * The same as [`concat`]{@link module:Collections.concat} but runs only a single async operation at a time.
 *
 * @name concatSeries
 * @static
 * @memberOf module:Collections
 * @method
 * @see [async.concat]{@link module:Collections.concat}
 * @category Collection
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {AsyncFunction} iteratee - A function to apply to each item in `coll`.
 * The iteratee should complete with an array an array of results.
 * Invoked with (item, callback).
 * @param {Function} [callback(err)] - A callback which is called after all the
 * `iteratee` functions have finished, or an error occurs. Results is an array
 * containing the concatenated results of the `iteratee` function. Invoked with
 * (err, results).
 */
 exports.default = (0, _doLimit2.default)(_concatLimit2.default, 1);
 module.exports = exports['default'];
--- a/node_modules/async/constant.js
+++ b/node_modules/async/constant.js
@@ -0,0 +1,66 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
    value: true
 });

 exports.default = function () /*...values*/{
    var values = (0, _slice2.default)(arguments);
    var args = [null].concat(values);
    return function () /*...ignoredArgs, callback*/{
        var callback = arguments[arguments.length - 1];
        return callback.apply(this, args);
    };
 };

 var _slice = require('./internal/slice');

 var _slice2 = _interopRequireDefault(_slice);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 ;

 /**
 * Returns a function that when called, calls-back with the values provided.
 * Useful as the first function in a [`waterfall`]{@link module:ControlFlow.waterfall}, or for plugging values in to
 * [`auto`]{@link module:ControlFlow.auto}.
 *
 * @name constant
 * @static
 * @memberOf module:Utils
 * @method
 * @category Util
 * @param {...*} arguments... - Any number of arguments to automatically invoke
 * callback with.
 * @returns {AsyncFunction} Returns a function that when invoked, automatically
 * invokes the callback with the previous given arguments.
 * @example
 *
 * async.waterfall([
 *     async.constant(42),
 *     function (value, next) {
 *         // value === 42
 *     },
 *     //...
 * ], callback);
 *
 * async.waterfall([
 *     async.constant(filename, "utf8"),
 *     fs.readFile,
 *     function (fileData, next) {
 *         //...
 *     }
 *     //...
 * ], callback);
 *
 * async.auto({
 *     hostname: async.constant("https://server.net/"),
 *     port: findFreePort,
 *     launchServer: ["hostname", "port", function (options, cb) {
 *         startServer(options, cb);
 *     }],
 *     //...
 * }, callback);
 */
 module.exports = exports['default'];
--- a/node_modules/async/detect.js
+++ b/node_modules/async/detect.js
@@ -0,0 +1,61 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });

 var _identity = require('lodash/identity');

 var _identity2 = _interopRequireDefault(_identity);

 var _createTester = require('./internal/createTester');

 var _createTester2 = _interopRequireDefault(_createTester);

 var _doParallel = require('./internal/doParallel');

 var _doParallel2 = _interopRequireDefault(_doParallel);

 var _findGetResult = require('./internal/findGetResult');

 var _findGetResult2 = _interopRequireDefault(_findGetResult);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * Returns the first value in `coll` that passes an async truth test. The
 * `iteratee` is applied in parallel, meaning the first iteratee to return
 * `true` will fire the detect `callback` with that result. That means the
 * result might not be the first item in the original `coll` (in terms of order)
 * that passes the test.

 * If order within the original `coll` is important, then look at
 * [`detectSeries`]{@link module:Collections.detectSeries}.
 *
 * @name detect
 * @static
 * @memberOf module:Collections
 * @method
 * @alias find
 * @category Collections
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {AsyncFunction} iteratee - A truth test to apply to each item in `coll`.
 * The iteratee must complete with a boolean value as its result.
 * Invoked with (item, callback).
 * @param {Function} [callback] - A callback which is called as soon as any
 * iteratee returns `true`, or after all the `iteratee` functions have finished.
 * Result will be the first item in the array that passes the truth test
 * (iteratee) or the value `undefined` if none passed. Invoked with
 * (err, result).
 * @example
 *
 * async.detect(['file1','file2','file3'], function(filePath, callback) {
 *     fs.access(filePath, function(err) {
 *         callback(null, !err)
 *     });
 * }, function(err, result) {
 *     // result now equals the first file in the list that exists
 * });
 */
 exports.default = (0, _doParallel2.default)((0, _createTester2.default)(_identity2.default, _findGetResult2.default));
 module.exports = exports['default'];
--- a/node_modules/async/detectLimit.js
+++ b/node_modules/async/detectLimit.js
@@ -0,0 +1,48 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });

 var _identity = require('lodash/identity');

 var _identity2 = _interopRequireDefault(_identity);

 var _createTester = require('./internal/createTester');

 var _createTester2 = _interopRequireDefault(_createTester);

 var _doParallelLimit = require('./internal/doParallelLimit');

 var _doParallelLimit2 = _interopRequireDefault(_doParallelLimit);

 var _findGetResult = require('./internal/findGetResult');

 var _findGetResult2 = _interopRequireDefault(_findGetResult);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * The same as [`detect`]{@link module:Collections.detect} but runs a maximum of `limit` async operations at a
 * time.
 *
 * @name detectLimit
 * @static
 * @memberOf module:Collections
 * @method
 * @see [async.detect]{@link module:Collections.detect}
 * @alias findLimit
 * @category Collections
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {number} limit - The maximum number of async operations at a time.
 * @param {AsyncFunction} iteratee - A truth test to apply to each item in `coll`.
 * The iteratee must complete with a boolean value as its result.
 * Invoked with (item, callback).
 * @param {Function} [callback] - A callback which is called as soon as any
 * iteratee returns `true`, or after all the `iteratee` functions have finished.
 * Result will be the first item in the array that passes the truth test
 * (iteratee) or the value `undefined` if none passed. Invoked with
 * (err, result).
 */
 exports.default = (0, _doParallelLimit2.default)((0, _createTester2.default)(_identity2.default, _findGetResult2.default));
 module.exports = exports['default'];
--- a/node_modules/async/detectSeries.js
+++ b/node_modules/async/detectSeries.js
@@ -0,0 +1,38 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });

 var _detectLimit = require('./detectLimit');

 var _detectLimit2 = _interopRequireDefault(_detectLimit);

 var _doLimit = require('./internal/doLimit');

 var _doLimit2 = _interopRequireDefault(_doLimit);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * The same as [`detect`]{@link module:Collections.detect} but runs only a single async operation at a time.
 *
 * @name detectSeries
 * @static
 * @memberOf module:Collections
 * @method
 * @see [async.detect]{@link module:Collections.detect}
 * @alias findSeries
 * @category Collections
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {AsyncFunction} iteratee - A truth test to apply to each item in `coll`.
 * The iteratee must complete with a boolean value as its result.
 * Invoked with (item, callback).
 * @param {Function} [callback] - A callback which is called as soon as any
 * iteratee returns `true`, or after all the `iteratee` functions have finished.
 * Result will be the first item in the array that passes the truth test
 * (iteratee) or the value `undefined` if none passed. Invoked with
 * (err, result).
 */
 exports.default = (0, _doLimit2.default)(_detectLimit2.default, 1);
 module.exports = exports['default'];
--- a/node_modules/async/dir.js
+++ b/node_modules/async/dir.js
@@ -0,0 +1,43 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });

 var _consoleFunc = require('./internal/consoleFunc');

 var _consoleFunc2 = _interopRequireDefault(_consoleFunc);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * Logs the result of an [`async` function]{@link AsyncFunction} to the
 * `console` using `console.dir` to display the properties of the resulting object.
 * Only works in Node.js or in browsers that support `console.dir` and
 * `console.error` (such as FF and Chrome).
 * If multiple arguments are returned from the async function,
 * `console.dir` is called on each argument in order.
 *
 * @name dir
 * @static
 * @memberOf module:Utils
 * @method
 * @category Util
 * @param {AsyncFunction} function - The function you want to eventually apply
 * all arguments to.
 * @param {...*} arguments... - Any number of arguments to apply to the function.
 * @example
 *
 * // in a module
 * var hello = function(name, callback) {
 *     setTimeout(function() {
 *         callback(null, {hello: name});
 *     }, 1000);
 * };
 *
 * // in the node repl
 * node> async.dir(hello, 'world');
 * {hello: 'world'}
 */
 exports.default = (0, _consoleFunc2.default)('dir');
 module.exports = exports['default'];
--- a/node_modules/async/dist/async.js
+++ b/node_modules/async/dist/async.js
--- a/node_modules/async/dist/async.min.js
+++ b/node_modules/async/dist/async.min.js
--- a/node_modules/async/dist/async.min.map
+++ b/node_modules/async/dist/async.min.map
--- a/node_modules/async/doDuring.js
+++ b/node_modules/async/doDuring.js
@@ -0,0 +1,66 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
    value: true
 });
 exports.default = doDuring;

 var _noop = require('lodash/noop');

 var _noop2 = _interopRequireDefault(_noop);

 var _slice = require('./internal/slice');

 var _slice2 = _interopRequireDefault(_slice);

 var _onlyOnce = require('./internal/onlyOnce');

 var _onlyOnce2 = _interopRequireDefault(_onlyOnce);

 var _wrapAsync = require('./internal/wrapAsync');

 var _wrapAsync2 = _interopRequireDefault(_wrapAsync);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * The post-check version of [`during`]{@link module:ControlFlow.during}. To reflect the difference in
 * the order of operations, the arguments `test` and `fn` are switched.
 *
 * Also a version of [`doWhilst`]{@link module:ControlFlow.doWhilst} with asynchronous `test` function.
 * @name doDuring
 * @static
 * @memberOf module:ControlFlow
 * @method
 * @see [async.during]{@link module:ControlFlow.during}
 * @category Control Flow
 * @param {AsyncFunction} fn - An async function which is called each time
 * `test` passes. Invoked with (callback).
 * @param {AsyncFunction} test - asynchronous truth test to perform before each
 * execution of `fn`. Invoked with (...args, callback), where `...args` are the
 * non-error args from the previous callback of `fn`.
 * @param {Function} [callback] - A callback which is called after the test
 * function has failed and repeated execution of `fn` has stopped. `callback`
 * will be passed an error if one occurred, otherwise `null`.
 */
 function doDuring(fn, test, callback) {
    callback = (0, _onlyOnce2.default)(callback || _noop2.default);
    var _fn = (0, _wrapAsync2.default)(fn);
    var _test = (0, _wrapAsync2.default)(test);

    function next(err /*, ...args*/) {
        if (err) return callback(err);
        var args = (0, _slice2.default)(arguments, 1);
        args.push(check);
        _test.apply(this, args);
    };

    function check(err, truth) {
        if (err) return callback(err);
        if (!truth) return callback(null);
        _fn(next);
    }

    check(null, true);
 }
 module.exports = exports['default'];
--- a/node_modules/async/doUntil.js
+++ b/node_modules/async/doUntil.js
@@ -0,0 +1,39 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
    value: true
 });
 exports.default = doUntil;

 var _doWhilst = require('./doWhilst');

 var _doWhilst2 = _interopRequireDefault(_doWhilst);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * Like ['doWhilst']{@link module:ControlFlow.doWhilst}, except the `test` is inverted. Note the
 * argument ordering differs from `until`.
 *
 * @name doUntil
 * @static
 * @memberOf module:ControlFlow
 * @method
 * @see [async.doWhilst]{@link module:ControlFlow.doWhilst}
 * @category Control Flow
 * @param {AsyncFunction} iteratee - An async function which is called each time
 * `test` fails. Invoked with (callback).
 * @param {Function} test - synchronous truth test to perform after each
 * execution of `iteratee`. Invoked with any non-error callback results of
 * `iteratee`.
 * @param {Function} [callback] - A callback which is called after the test
 * function has passed and repeated execution of `iteratee` has stopped. `callback`
 * will be passed an error and any arguments passed to the final `iteratee`'s
 * callback. Invoked with (err, [results]);
 */
 function doUntil(iteratee, test, callback) {
    (0, _doWhilst2.default)(iteratee, function () {
        return !test.apply(this, arguments);
    }, callback);
 }
 module.exports = exports['default'];
--- a/node_modules/async/doWhilst.js
+++ b/node_modules/async/doWhilst.js
@@ -0,0 +1,59 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
    value: true
 });
 exports.default = doWhilst;

 var _noop = require('lodash/noop');

 var _noop2 = _interopRequireDefault(_noop);

 var _slice = require('./internal/slice');

 var _slice2 = _interopRequireDefault(_slice);

 var _onlyOnce = require('./internal/onlyOnce');

 var _onlyOnce2 = _interopRequireDefault(_onlyOnce);

 var _wrapAsync = require('./internal/wrapAsync');

 var _wrapAsync2 = _interopRequireDefault(_wrapAsync);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * The post-check version of [`whilst`]{@link module:ControlFlow.whilst}. To reflect the difference in
 * the order of operations, the arguments `test` and `iteratee` are switched.
 *
 * `doWhilst` is to `whilst` as `do while` is to `while` in plain JavaScript.
 *
 * @name doWhilst
 * @static
 * @memberOf module:ControlFlow
 * @method
 * @see [async.whilst]{@link module:ControlFlow.whilst}
 * @category Control Flow
 * @param {AsyncFunction} iteratee - A function which is called each time `test`
 * passes. Invoked with (callback).
 * @param {Function} test - synchronous truth test to perform after each
 * execution of `iteratee`. Invoked with any non-error callback results of
 * `iteratee`.
 * @param {Function} [callback] - A callback which is called after the test
 * function has failed and repeated execution of `iteratee` has stopped.
 * `callback` will be passed an error and any arguments passed to the final
 * `iteratee`'s callback. Invoked with (err, [results]);
 */
 function doWhilst(iteratee, test, callback) {
    callback = (0, _onlyOnce2.default)(callback || _noop2.default);
    var _iteratee = (0, _wrapAsync2.default)(iteratee);
    var next = function (err /*, ...args*/) {
        if (err) return callback(err);
        var args = (0, _slice2.default)(arguments, 1);
        if (test.apply(this, args)) return _iteratee(next);
        callback.apply(null, [null].concat(args));
    };
    _iteratee(next);
 }
 module.exports = exports['default'];
--- a/node_modules/async/during.js
+++ b/node_modules/async/during.js
@@ -0,0 +1,76 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
    value: true
 });
 exports.default = during;

 var _noop = require('lodash/noop');

 var _noop2 = _interopRequireDefault(_noop);

 var _onlyOnce = require('./internal/onlyOnce');

 var _onlyOnce2 = _interopRequireDefault(_onlyOnce);

 var _wrapAsync = require('./internal/wrapAsync');

 var _wrapAsync2 = _interopRequireDefault(_wrapAsync);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * Like [`whilst`]{@link module:ControlFlow.whilst}, except the `test` is an asynchronous function that
 * is passed a callback in the form of `function (err, truth)`. If error is
 * passed to `test` or `fn`, the main callback is immediately called with the
 * value of the error.
 *
 * @name during
 * @static
 * @memberOf module:ControlFlow
 * @method
 * @see [async.whilst]{@link module:ControlFlow.whilst}
 * @category Control Flow
 * @param {AsyncFunction} test - asynchronous truth test to perform before each
 * execution of `fn`. Invoked with (callback).
 * @param {AsyncFunction} fn - An async function which is called each time
 * `test` passes. Invoked with (callback).
 * @param {Function} [callback] - A callback which is called after the test
 * function has failed and repeated execution of `fn` has stopped. `callback`
 * will be passed an error, if one occurred, otherwise `null`.
 * @example
 *
 * var count = 0;
 *
 * async.during(
 *     function (callback) {
 *         return callback(null, count < 5);
 *     },
 *     function (callback) {
 *         count++;
 *         setTimeout(callback, 1000);
 *     },
 *     function (err) {
 *         // 5 seconds have passed
 *     }
 * );
 */
 function during(test, fn, callback) {
    callback = (0, _onlyOnce2.default)(callback || _noop2.default);
    var _fn = (0, _wrapAsync2.default)(fn);
    var _test = (0, _wrapAsync2.default)(test);

    function next(err) {
        if (err) return callback(err);
        _test(check);
    }

    function check(err, truth) {
        if (err) return callback(err);
        if (!truth) return callback(null);
        _fn(next);
    }

    _test(check);
 }
 module.exports = exports['default'];
--- a/node_modules/async/each.js
+++ b/node_modules/async/each.js
@@ -0,0 +1,82 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });
 exports.default = eachLimit;

 var _eachOf = require('./eachOf');

 var _eachOf2 = _interopRequireDefault(_eachOf);

 var _withoutIndex = require('./internal/withoutIndex');

 var _withoutIndex2 = _interopRequireDefault(_withoutIndex);

 var _wrapAsync = require('./internal/wrapAsync');

 var _wrapAsync2 = _interopRequireDefault(_wrapAsync);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * Applies the function `iteratee` to each item in `coll`, in parallel.
 * The `iteratee` is called with an item from the list, and a callback for when
 * it has finished. If the `iteratee` passes an error to its `callback`, the
 * main `callback` (for the `each` function) is immediately called with the
 * error.
 *
 * Note, that since this function applies `iteratee` to each item in parallel,
 * there is no guarantee that the iteratee functions will complete in order.
 *
 * @name each
 * @static
 * @memberOf module:Collections
 * @method
 * @alias forEach
 * @category Collection
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {AsyncFunction} iteratee - An async function to apply to
 * each item in `coll`. Invoked with (item, callback).
 * The array index is not passed to the iteratee.
 * If you need the index, use `eachOf`.
 * @param {Function} [callback] - A callback which is called when all
 * `iteratee` functions have finished, or an error occurs. Invoked with (err).
 * @example
 *
 * // assuming openFiles is an array of file names and saveFile is a function
 * // to save the modified contents of that file:
 *
 * async.each(openFiles, saveFile, function(err){
 *   // if any of the saves produced an error, err would equal that error
 * });
 *
 * // assuming openFiles is an array of file names
 * async.each(openFiles, function(file, callback) {
 *
 *     // Perform operation on file here.
 *     console.log('Processing file ' + file);
 *
 *     if( file.length > 32 ) {
 *       console.log('This file name is too long');
 *       callback('File name too long');
 *     } else {
 *       // Do work to process file here
 *       console.log('File processed');
 *       callback();
 *     }
 * }, function(err) {
 *     // if any of the file processing produced an error, err would equal that error
 *     if( err ) {
 *       // One of the iterations produced an error.
 *       // All processing will now stop.
 *       console.log('A file failed to process');
 *     } else {
 *       console.log('All files have been processed successfully');
 *     }
 * });
 */
 function eachLimit(coll, iteratee, callback) {
  (0, _eachOf2.default)(coll, (0, _withoutIndex2.default)((0, _wrapAsync2.default)(iteratee)), callback);
 }
 module.exports = exports['default'];
--- a/node_modules/async/eachLimit.js
+++ b/node_modules/async/eachLimit.js
@@ -0,0 +1,45 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });
 exports.default = eachLimit;

 var _eachOfLimit = require('./internal/eachOfLimit');

 var _eachOfLimit2 = _interopRequireDefault(_eachOfLimit);

 var _withoutIndex = require('./internal/withoutIndex');

 var _withoutIndex2 = _interopRequireDefault(_withoutIndex);

 var _wrapAsync = require('./internal/wrapAsync');

 var _wrapAsync2 = _interopRequireDefault(_wrapAsync);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * The same as [`each`]{@link module:Collections.each} but runs a maximum of `limit` async operations at a time.
 *
 * @name eachLimit
 * @static
 * @memberOf module:Collections
 * @method
 * @see [async.each]{@link module:Collections.each}
 * @alias forEachLimit
 * @category Collection
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {number} limit - The maximum number of async operations at a time.
 * @param {AsyncFunction} iteratee - An async function to apply to each item in
 * `coll`.
 * The array index is not passed to the iteratee.
 * If you need the index, use `eachOfLimit`.
 * Invoked with (item, callback).
 * @param {Function} [callback] - A callback which is called when all
 * `iteratee` functions have finished, or an error occurs. Invoked with (err).
 */
 function eachLimit(coll, limit, iteratee, callback) {
  (0, _eachOfLimit2.default)(limit)(coll, (0, _withoutIndex2.default)((0, _wrapAsync2.default)(iteratee)), callback);
 }
 module.exports = exports['default'];
--- a/node_modules/async/eachOf.js
+++ b/node_modules/async/eachOf.js
@@ -0,0 +1,111 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
    value: true
 });

 exports.default = function (coll, iteratee, callback) {
    var eachOfImplementation = (0, _isArrayLike2.default)(coll) ? eachOfArrayLike : eachOfGeneric;
    eachOfImplementation(coll, (0, _wrapAsync2.default)(iteratee), callback);
 };

 var _isArrayLike = require('lodash/isArrayLike');

 var _isArrayLike2 = _interopRequireDefault(_isArrayLike);

 var _breakLoop = require('./internal/breakLoop');

 var _breakLoop2 = _interopRequireDefault(_breakLoop);

 var _eachOfLimit = require('./eachOfLimit');

 var _eachOfLimit2 = _interopRequireDefault(_eachOfLimit);

 var _doLimit = require('./internal/doLimit');

 var _doLimit2 = _interopRequireDefault(_doLimit);

 var _noop = require('lodash/noop');

 var _noop2 = _interopRequireDefault(_noop);

 var _once = require('./internal/once');

 var _once2 = _interopRequireDefault(_once);

 var _onlyOnce = require('./internal/onlyOnce');

 var _onlyOnce2 = _interopRequireDefault(_onlyOnce);

 var _wrapAsync = require('./internal/wrapAsync');

 var _wrapAsync2 = _interopRequireDefault(_wrapAsync);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 // eachOf implementation optimized for array-likes
 function eachOfArrayLike(coll, iteratee, callback) {
    callback = (0, _once2.default)(callback || _noop2.default);
    var index = 0,
        completed = 0,
        length = coll.length;
    if (length === 0) {
        callback(null);
    }

    function iteratorCallback(err, value) {
        if (err) {
            callback(err);
        } else if (++completed === length || value === _breakLoop2.default) {
            callback(null);
        }
    }

    for (; index < length; index++) {
        iteratee(coll[index], index, (0, _onlyOnce2.default)(iteratorCallback));
    }
 }

 // a generic version of eachOf which can handle array, object, and iterator cases.
 var eachOfGeneric = (0, _doLimit2.default)(_eachOfLimit2.default, Infinity);

 /**
 * Like [`each`]{@link module:Collections.each}, except that it passes the key (or index) as the second argument
 * to the iteratee.
 *
 * @name eachOf
 * @static
 * @memberOf module:Collections
 * @method
 * @alias forEachOf
 * @category Collection
 * @see [async.each]{@link module:Collections.each}
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {AsyncFunction} iteratee - A function to apply to each
 * item in `coll`.
 * The `key` is the item's key, or index in the case of an array.
 * Invoked with (item, key, callback).
 * @param {Function} [callback] - A callback which is called when all
 * `iteratee` functions have finished, or an error occurs. Invoked with (err).
 * @example
 *
 * var obj = {dev: "/dev.json", test: "/test.json", prod: "/prod.json"};
 * var configs = {};
 *
 * async.forEachOf(obj, function (value, key, callback) {
 *     fs.readFile(__dirname + value, "utf8", function (err, data) {
 *         if (err) return callback(err);
 *         try {
 *             configs[key] = JSON.parse(data);
 *         } catch (e) {
 *             return callback(e);
 *         }
 *         callback();
 *     });
 * }, function (err) {
 *     if (err) console.error(err.message);
 *     // configs is now a map of JSON data
 *     doSomethingWith(configs);
 * });
 */
 module.exports = exports['default'];
--- a/node_modules/async/eachOfLimit.js
+++ b/node_modules/async/eachOfLimit.js
@@ -0,0 +1,41 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });
 exports.default = eachOfLimit;

 var _eachOfLimit2 = require('./internal/eachOfLimit');

 var _eachOfLimit3 = _interopRequireDefault(_eachOfLimit2);

 var _wrapAsync = require('./internal/wrapAsync');

 var _wrapAsync2 = _interopRequireDefault(_wrapAsync);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * The same as [`eachOf`]{@link module:Collections.eachOf} but runs a maximum of `limit` async operations at a
 * time.
 *
 * @name eachOfLimit
 * @static
 * @memberOf module:Collections
 * @method
 * @see [async.eachOf]{@link module:Collections.eachOf}
 * @alias forEachOfLimit
 * @category Collection
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {number} limit - The maximum number of async operations at a time.
 * @param {AsyncFunction} iteratee - An async function to apply to each
 * item in `coll`. The `key` is the item's key, or index in the case of an
 * array.
 * Invoked with (item, key, callback).
 * @param {Function} [callback] - A callback which is called when all
 * `iteratee` functions have finished, or an error occurs. Invoked with (err).
 */
 function eachOfLimit(coll, limit, iteratee, callback) {
  (0, _eachOfLimit3.default)(limit)(coll, (0, _wrapAsync2.default)(iteratee), callback);
 }
 module.exports = exports['default'];
--- a/node_modules/async/eachOfSeries.js
+++ b/node_modules/async/eachOfSeries.js
@@ -0,0 +1,35 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });

 var _eachOfLimit = require('./eachOfLimit');

 var _eachOfLimit2 = _interopRequireDefault(_eachOfLimit);

 var _doLimit = require('./internal/doLimit');

 var _doLimit2 = _interopRequireDefault(_doLimit);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * The same as [`eachOf`]{@link module:Collections.eachOf} but runs only a single async operation at a time.
 *
 * @name eachOfSeries
 * @static
 * @memberOf module:Collections
 * @method
 * @see [async.eachOf]{@link module:Collections.eachOf}
 * @alias forEachOfSeries
 * @category Collection
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {AsyncFunction} iteratee - An async function to apply to each item in
 * `coll`.
 * Invoked with (item, key, callback).
 * @param {Function} [callback] - A callback which is called when all `iteratee`
 * functions have finished, or an error occurs. Invoked with (err).
 */
 exports.default = (0, _doLimit2.default)(_eachOfLimit2.default, 1);
 module.exports = exports['default'];
--- a/node_modules/async/eachSeries.js
+++ b/node_modules/async/eachSeries.js
@@ -0,0 +1,37 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });

 var _eachLimit = require('./eachLimit');

 var _eachLimit2 = _interopRequireDefault(_eachLimit);

 var _doLimit = require('./internal/doLimit');

 var _doLimit2 = _interopRequireDefault(_doLimit);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * The same as [`each`]{@link module:Collections.each} but runs only a single async operation at a time.
 *
 * @name eachSeries
 * @static
 * @memberOf module:Collections
 * @method
 * @see [async.each]{@link module:Collections.each}
 * @alias forEachSeries
 * @category Collection
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {AsyncFunction} iteratee - An async function to apply to each
 * item in `coll`.
 * The array index is not passed to the iteratee.
 * If you need the index, use `eachOfSeries`.
 * Invoked with (item, callback).
 * @param {Function} [callback] - A callback which is called when all
 * `iteratee` functions have finished, or an error occurs. Invoked with (err).
 */
 exports.default = (0, _doLimit2.default)(_eachLimit2.default, 1);
 module.exports = exports['default'];
--- a/node_modules/async/ensureAsync.js
+++ b/node_modules/async/ensureAsync.js
@@ -0,0 +1,73 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
    value: true
 });
 exports.default = ensureAsync;

 var _setImmediate = require('./internal/setImmediate');

 var _setImmediate2 = _interopRequireDefault(_setImmediate);

 var _initialParams = require('./internal/initialParams');

 var _initialParams2 = _interopRequireDefault(_initialParams);

 var _wrapAsync = require('./internal/wrapAsync');

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * Wrap an async function and ensure it calls its callback on a later tick of
 * the event loop.  If the function already calls its callback on a next tick,
 * no extra deferral is added. This is useful for preventing stack overflows
 * (`RangeError: Maximum call stack size exceeded`) and generally keeping
 * [Zalgo](http://blog.izs.me/post/59142742143/designing-apis-for-asynchrony)
 * contained. ES2017 `async` functions are returned as-is -- they are immune
 * to Zalgo's corrupting influences, as they always resolve on a later tick.
 *
 * @name ensureAsync
 * @static
 * @memberOf module:Utils
 * @method
 * @category Util
 * @param {AsyncFunction} fn - an async function, one that expects a node-style
 * callback as its last argument.
 * @returns {AsyncFunction} Returns a wrapped function with the exact same call
 * signature as the function passed in.
 * @example
 *
 * function sometimesAsync(arg, callback) {
 *     if (cache[arg]) {
 *         return callback(null, cache[arg]); // this would be synchronous!!
 *     } else {
 *         doSomeIO(arg, callback); // this IO would be asynchronous
 *     }
 * }
 *
 * // this has a risk of stack overflows if many results are cached in a row
 * async.mapSeries(args, sometimesAsync, done);
 *
 * // this will defer sometimesAsync's callback if necessary,
 * // preventing stack overflows
 * async.mapSeries(args, async.ensureAsync(sometimesAsync), done);
 */
 function ensureAsync(fn) {
    if ((0, _wrapAsync.isAsync)(fn)) return fn;
    return (0, _initialParams2.default)(function (args, callback) {
        var sync = true;
        args.push(function () {
            var innerArgs = arguments;
            if (sync) {
                (0, _setImmediate2.default)(function () {
                    callback.apply(null, innerArgs);
                });
            } else {
                callback.apply(null, innerArgs);
            }
        });
        fn.apply(this, args);
        sync = false;
    });
 }
 module.exports = exports['default'];
--- a/node_modules/async/every.js
+++ b/node_modules/async/every.js
@@ -0,0 +1,50 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });

 var _createTester = require('./internal/createTester');

 var _createTester2 = _interopRequireDefault(_createTester);

 var _doParallel = require('./internal/doParallel');

 var _doParallel2 = _interopRequireDefault(_doParallel);

 var _notId = require('./internal/notId');

 var _notId2 = _interopRequireDefault(_notId);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * Returns `true` if every element in `coll` satisfies an async test. If any
 * iteratee call returns `false`, the main `callback` is immediately called.
 *
 * @name every
 * @static
 * @memberOf module:Collections
 * @method
 * @alias all
 * @category Collection
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {AsyncFunction} iteratee - An async truth test to apply to each item
 * in the collection in parallel.
 * The iteratee must complete with a boolean result value.
 * Invoked with (item, callback).
 * @param {Function} [callback] - A callback which is called after all the
 * `iteratee` functions have finished. Result will be either `true` or `false`
 * depending on the values of the async tests. Invoked with (err, result).
 * @example
 *
 * async.every(['file1','file2','file3'], function(filePath, callback) {
 *     fs.access(filePath, function(err) {
 *         callback(null, !err)
 *     });
 * }, function(err, result) {
 *     // if result is true then every file exists
 * });
 */
 exports.default = (0, _doParallel2.default)((0, _createTester2.default)(_notId2.default, _notId2.default));
 module.exports = exports['default'];
--- a/node_modules/async/everyLimit.js
+++ b/node_modules/async/everyLimit.js
@@ -0,0 +1,42 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });

 var _createTester = require('./internal/createTester');

 var _createTester2 = _interopRequireDefault(_createTester);

 var _doParallelLimit = require('./internal/doParallelLimit');

 var _doParallelLimit2 = _interopRequireDefault(_doParallelLimit);

 var _notId = require('./internal/notId');

 var _notId2 = _interopRequireDefault(_notId);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * The same as [`every`]{@link module:Collections.every} but runs a maximum of `limit` async operations at a time.
 *
 * @name everyLimit
 * @static
 * @memberOf module:Collections
 * @method
 * @see [async.every]{@link module:Collections.every}
 * @alias allLimit
 * @category Collection
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {number} limit - The maximum number of async operations at a time.
 * @param {AsyncFunction} iteratee - An async truth test to apply to each item
 * in the collection in parallel.
 * The iteratee must complete with a boolean result value.
 * Invoked with (item, callback).
 * @param {Function} [callback] - A callback which is called after all the
 * `iteratee` functions have finished. Result will be either `true` or `false`
 * depending on the values of the async tests. Invoked with (err, result).
 */
 exports.default = (0, _doParallelLimit2.default)((0, _createTester2.default)(_notId2.default, _notId2.default));
 module.exports = exports['default'];
--- a/node_modules/async/everySeries.js
+++ b/node_modules/async/everySeries.js
@@ -0,0 +1,37 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });

 var _everyLimit = require('./everyLimit');

 var _everyLimit2 = _interopRequireDefault(_everyLimit);

 var _doLimit = require('./internal/doLimit');

 var _doLimit2 = _interopRequireDefault(_doLimit);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * The same as [`every`]{@link module:Collections.every} but runs only a single async operation at a time.
 *
 * @name everySeries
 * @static
 * @memberOf module:Collections
 * @method
 * @see [async.every]{@link module:Collections.every}
 * @alias allSeries
 * @category Collection
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {AsyncFunction} iteratee - An async truth test to apply to each item
 * in the collection in series.
 * The iteratee must complete with a boolean result value.
 * Invoked with (item, callback).
 * @param {Function} [callback] - A callback which is called after all the
 * `iteratee` functions have finished. Result will be either `true` or `false`
 * depending on the values of the async tests. Invoked with (err, result).
 */
 exports.default = (0, _doLimit2.default)(_everyLimit2.default, 1);
 module.exports = exports['default'];
--- a/node_modules/async/filter.js
+++ b/node_modules/async/filter.js
@@ -0,0 +1,45 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });

 var _filter = require('./internal/filter');

 var _filter2 = _interopRequireDefault(_filter);

 var _doParallel = require('./internal/doParallel');

 var _doParallel2 = _interopRequireDefault(_doParallel);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * Returns a new array of all the values in `coll` which pass an async truth
 * test. This operation is performed in parallel, but the results array will be
 * in the same order as the original.
 *
 * @name filter
 * @static
 * @memberOf module:Collections
 * @method
 * @alias select
 * @category Collection
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {Function} iteratee - A truth test to apply to each item in `coll`.
 * The `iteratee` is passed a `callback(err, truthValue)`, which must be called
 * with a boolean argument once it has completed. Invoked with (item, callback).
 * @param {Function} [callback] - A callback which is called after all the
 * `iteratee` functions have finished. Invoked with (err, results).
 * @example
 *
 * async.filter(['file1','file2','file3'], function(filePath, callback) {
 *     fs.access(filePath, function(err) {
 *         callback(null, !err)
 *     });
 * }, function(err, results) {
 *     // results now equals an array of the existing files
 * });
 */
 exports.default = (0, _doParallel2.default)(_filter2.default);
 module.exports = exports['default'];
--- a/node_modules/async/filterLimit.js
+++ b/node_modules/async/filterLimit.js
@@ -0,0 +1,37 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });

 var _filter = require('./internal/filter');

 var _filter2 = _interopRequireDefault(_filter);

 var _doParallelLimit = require('./internal/doParallelLimit');

 var _doParallelLimit2 = _interopRequireDefault(_doParallelLimit);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * The same as [`filter`]{@link module:Collections.filter} but runs a maximum of `limit` async operations at a
 * time.
 *
 * @name filterLimit
 * @static
 * @memberOf module:Collections
 * @method
 * @see [async.filter]{@link module:Collections.filter}
 * @alias selectLimit
 * @category Collection
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {number} limit - The maximum number of async operations at a time.
 * @param {Function} iteratee - A truth test to apply to each item in `coll`.
 * The `iteratee` is passed a `callback(err, truthValue)`, which must be called
 * with a boolean argument once it has completed. Invoked with (item, callback).
 * @param {Function} [callback] - A callback which is called after all the
 * `iteratee` functions have finished. Invoked with (err, results).
 */
 exports.default = (0, _doParallelLimit2.default)(_filter2.default);
 module.exports = exports['default'];
--- a/node_modules/async/filterSeries.js
+++ b/node_modules/async/filterSeries.js
@@ -0,0 +1,35 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });

 var _filterLimit = require('./filterLimit');

 var _filterLimit2 = _interopRequireDefault(_filterLimit);

 var _doLimit = require('./internal/doLimit');

 var _doLimit2 = _interopRequireDefault(_doLimit);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * The same as [`filter`]{@link module:Collections.filter} but runs only a single async operation at a time.
 *
 * @name filterSeries
 * @static
 * @memberOf module:Collections
 * @method
 * @see [async.filter]{@link module:Collections.filter}
 * @alias selectSeries
 * @category Collection
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {Function} iteratee - A truth test to apply to each item in `coll`.
 * The `iteratee` is passed a `callback(err, truthValue)`, which must be called
 * with a boolean argument once it has completed. Invoked with (item, callback).
 * @param {Function} [callback] - A callback which is called after all the
 * `iteratee` functions have finished. Invoked with (err, results)
 */
 exports.default = (0, _doLimit2.default)(_filterLimit2.default, 1);
 module.exports = exports['default'];
--- a/node_modules/async/find.js
+++ b/node_modules/async/find.js
@@ -0,0 +1,61 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });

 var _identity = require('lodash/identity');

 var _identity2 = _interopRequireDefault(_identity);

 var _createTester = require('./internal/createTester');

 var _createTester2 = _interopRequireDefault(_createTester);

 var _doParallel = require('./internal/doParallel');

 var _doParallel2 = _interopRequireDefault(_doParallel);

 var _findGetResult = require('./internal/findGetResult');

 var _findGetResult2 = _interopRequireDefault(_findGetResult);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * Returns the first value in `coll` that passes an async truth test. The
 * `iteratee` is applied in parallel, meaning the first iteratee to return
 * `true` will fire the detect `callback` with that result. That means the
 * result might not be the first item in the original `coll` (in terms of order)
 * that passes the test.

 * If order within the original `coll` is important, then look at
 * [`detectSeries`]{@link module:Collections.detectSeries}.
 *
 * @name detect
 * @static
 * @memberOf module:Collections
 * @method
 * @alias find
 * @category Collections
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {AsyncFunction} iteratee - A truth test to apply to each item in `coll`.
 * The iteratee must complete with a boolean value as its result.
 * Invoked with (item, callback).
 * @param {Function} [callback] - A callback which is called as soon as any
 * iteratee returns `true`, or after all the `iteratee` functions have finished.
 * Result will be the first item in the array that passes the truth test
 * (iteratee) or the value `undefined` if none passed. Invoked with
 * (err, result).
 * @example
 *
 * async.detect(['file1','file2','file3'], function(filePath, callback) {
 *     fs.access(filePath, function(err) {
 *         callback(null, !err)
 *     });
 * }, function(err, result) {
 *     // result now equals the first file in the list that exists
 * });
 */
 exports.default = (0, _doParallel2.default)((0, _createTester2.default)(_identity2.default, _findGetResult2.default));
 module.exports = exports['default'];
--- a/node_modules/async/findLimit.js
+++ b/node_modules/async/findLimit.js
@@ -0,0 +1,48 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });

 var _identity = require('lodash/identity');

 var _identity2 = _interopRequireDefault(_identity);

 var _createTester = require('./internal/createTester');

 var _createTester2 = _interopRequireDefault(_createTester);

 var _doParallelLimit = require('./internal/doParallelLimit');

 var _doParallelLimit2 = _interopRequireDefault(_doParallelLimit);

 var _findGetResult = require('./internal/findGetResult');

 var _findGetResult2 = _interopRequireDefault(_findGetResult);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * The same as [`detect`]{@link module:Collections.detect} but runs a maximum of `limit` async operations at a
 * time.
 *
 * @name detectLimit
 * @static
 * @memberOf module:Collections
 * @method
 * @see [async.detect]{@link module:Collections.detect}
 * @alias findLimit
 * @category Collections
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {number} limit - The maximum number of async operations at a time.
 * @param {AsyncFunction} iteratee - A truth test to apply to each item in `coll`.
 * The iteratee must complete with a boolean value as its result.
 * Invoked with (item, callback).
 * @param {Function} [callback] - A callback which is called as soon as any
 * iteratee returns `true`, or after all the `iteratee` functions have finished.
 * Result will be the first item in the array that passes the truth test
 * (iteratee) or the value `undefined` if none passed. Invoked with
 * (err, result).
 */
 exports.default = (0, _doParallelLimit2.default)((0, _createTester2.default)(_identity2.default, _findGetResult2.default));
 module.exports = exports['default'];
--- a/node_modules/async/findSeries.js
+++ b/node_modules/async/findSeries.js
@@ -0,0 +1,38 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });

 var _detectLimit = require('./detectLimit');

 var _detectLimit2 = _interopRequireDefault(_detectLimit);

 var _doLimit = require('./internal/doLimit');

 var _doLimit2 = _interopRequireDefault(_doLimit);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * The same as [`detect`]{@link module:Collections.detect} but runs only a single async operation at a time.
 *
 * @name detectSeries
 * @static
 * @memberOf module:Collections
 * @method
 * @see [async.detect]{@link module:Collections.detect}
 * @alias findSeries
 * @category Collections
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {AsyncFunction} iteratee - A truth test to apply to each item in `coll`.
 * The iteratee must complete with a boolean value as its result.
 * Invoked with (item, callback).
 * @param {Function} [callback] - A callback which is called as soon as any
 * iteratee returns `true`, or after all the `iteratee` functions have finished.
 * Result will be the first item in the array that passes the truth test
 * (iteratee) or the value `undefined` if none passed. Invoked with
 * (err, result).
 */
 exports.default = (0, _doLimit2.default)(_detectLimit2.default, 1);
 module.exports = exports['default'];
--- a/node_modules/async/foldl.js
+++ b/node_modules/async/foldl.js
@@ -0,0 +1,78 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
    value: true
 });
 exports.default = reduce;

 var _eachOfSeries = require('./eachOfSeries');

 var _eachOfSeries2 = _interopRequireDefault(_eachOfSeries);

 var _noop = require('lodash/noop');

 var _noop2 = _interopRequireDefault(_noop);

 var _once = require('./internal/once');

 var _once2 = _interopRequireDefault(_once);

 var _wrapAsync = require('./internal/wrapAsync');

 var _wrapAsync2 = _interopRequireDefault(_wrapAsync);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * Reduces `coll` into a single value using an async `iteratee` to return each
 * successive step. `memo` is the initial state of the reduction. This function
 * only operates in series.
 *
 * For performance reasons, it may make sense to split a call to this function
 * into a parallel map, and then use the normal `Array.prototype.reduce` on the
 * results. This function is for situations where each step in the reduction
 * needs to be async; if you can get the data before reducing it, then it's
 * probably a good idea to do so.
 *
 * @name reduce
 * @static
 * @memberOf module:Collections
 * @method
 * @alias inject
 * @alias foldl
 * @category Collection
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {*} memo - The initial state of the reduction.
 * @param {AsyncFunction} iteratee - A function applied to each item in the
 * array to produce the next step in the reduction.
 * The `iteratee` should complete with the next state of the reduction.
 * If the iteratee complete with an error, the reduction is stopped and the
 * main `callback` is immediately called with the error.
 * Invoked with (memo, item, callback).
 * @param {Function} [callback] - A callback which is called after all the
 * `iteratee` functions have finished. Result is the reduced value. Invoked with
 * (err, result).
 * @example
 *
 * async.reduce([1,2,3], 0, function(memo, item, callback) {
 *     // pointless async:
 *     process.nextTick(function() {
 *         callback(null, memo + item)
 *     });
 * }, function(err, result) {
 *     // result is now equal to the last value of memo, which is 6
 * });
 */
 function reduce(coll, memo, iteratee, callback) {
    callback = (0, _once2.default)(callback || _noop2.default);
    var _iteratee = (0, _wrapAsync2.default)(iteratee);
    (0, _eachOfSeries2.default)(coll, function (x, i, callback) {
        _iteratee(memo, x, function (err, v) {
            memo = v;
            callback(err);
        });
    }, function (err) {
        callback(err, memo);
    });
 }
 module.exports = exports['default'];
--- a/node_modules/async/foldr.js
+++ b/node_modules/async/foldr.js
@@ -0,0 +1,44 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });
 exports.default = reduceRight;

 var _reduce = require('./reduce');

 var _reduce2 = _interopRequireDefault(_reduce);

 var _slice = require('./internal/slice');

 var _slice2 = _interopRequireDefault(_slice);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * Same as [`reduce`]{@link module:Collections.reduce}, only operates on `array` in reverse order.
 *
 * @name reduceRight
 * @static
 * @memberOf module:Collections
 * @method
 * @see [async.reduce]{@link module:Collections.reduce}
 * @alias foldr
 * @category Collection
 * @param {Array} array - A collection to iterate over.
 * @param {*} memo - The initial state of the reduction.
 * @param {AsyncFunction} iteratee - A function applied to each item in the
 * array to produce the next step in the reduction.
 * The `iteratee` should complete with the next state of the reduction.
 * If the iteratee complete with an error, the reduction is stopped and the
 * main `callback` is immediately called with the error.
 * Invoked with (memo, item, callback).
 * @param {Function} [callback] - A callback which is called after all the
 * `iteratee` functions have finished. Result is the reduced value. Invoked with
 * (err, result).
 */
 function reduceRight(array, memo, iteratee, callback) {
  var reversed = (0, _slice2.default)(array).reverse();
  (0, _reduce2.default)(reversed, memo, iteratee, callback);
 }
 module.exports = exports['default'];
--- a/node_modules/async/forEach.js
+++ b/node_modules/async/forEach.js
@@ -0,0 +1,82 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });
 exports.default = eachLimit;

 var _eachOf = require('./eachOf');

 var _eachOf2 = _interopRequireDefault(_eachOf);

 var _withoutIndex = require('./internal/withoutIndex');

 var _withoutIndex2 = _interopRequireDefault(_withoutIndex);

 var _wrapAsync = require('./internal/wrapAsync');

 var _wrapAsync2 = _interopRequireDefault(_wrapAsync);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * Applies the function `iteratee` to each item in `coll`, in parallel.
 * The `iteratee` is called with an item from the list, and a callback for when
 * it has finished. If the `iteratee` passes an error to its `callback`, the
 * main `callback` (for the `each` function) is immediately called with the
 * error.
 *
 * Note, that since this function applies `iteratee` to each item in parallel,
 * there is no guarantee that the iteratee functions will complete in order.
 *
 * @name each
 * @static
 * @memberOf module:Collections
 * @method
 * @alias forEach
 * @category Collection
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {AsyncFunction} iteratee - An async function to apply to
 * each item in `coll`. Invoked with (item, callback).
 * The array index is not passed to the iteratee.
 * If you need the index, use `eachOf`.
 * @param {Function} [callback] - A callback which is called when all
 * `iteratee` functions have finished, or an error occurs. Invoked with (err).
 * @example
 *
 * // assuming openFiles is an array of file names and saveFile is a function
 * // to save the modified contents of that file:
 *
 * async.each(openFiles, saveFile, function(err){
 *   // if any of the saves produced an error, err would equal that error
 * });
 *
 * // assuming openFiles is an array of file names
 * async.each(openFiles, function(file, callback) {
 *
 *     // Perform operation on file here.
 *     console.log('Processing file ' + file);
 *
 *     if( file.length > 32 ) {
 *       console.log('This file name is too long');
 *       callback('File name too long');
 *     } else {
 *       // Do work to process file here
 *       console.log('File processed');
 *       callback();
 *     }
 * }, function(err) {
 *     // if any of the file processing produced an error, err would equal that error
 *     if( err ) {
 *       // One of the iterations produced an error.
 *       // All processing will now stop.
 *       console.log('A file failed to process');
 *     } else {
 *       console.log('All files have been processed successfully');
 *     }
 * });
 */
 function eachLimit(coll, iteratee, callback) {
  (0, _eachOf2.default)(coll, (0, _withoutIndex2.default)((0, _wrapAsync2.default)(iteratee)), callback);
 }
 module.exports = exports['default'];
--- a/node_modules/async/forEachLimit.js
+++ b/node_modules/async/forEachLimit.js
@@ -0,0 +1,45 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });
 exports.default = eachLimit;

 var _eachOfLimit = require('./internal/eachOfLimit');

 var _eachOfLimit2 = _interopRequireDefault(_eachOfLimit);

 var _withoutIndex = require('./internal/withoutIndex');

 var _withoutIndex2 = _interopRequireDefault(_withoutIndex);

 var _wrapAsync = require('./internal/wrapAsync');

 var _wrapAsync2 = _interopRequireDefault(_wrapAsync);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * The same as [`each`]{@link module:Collections.each} but runs a maximum of `limit` async operations at a time.
 *
 * @name eachLimit
 * @static
 * @memberOf module:Collections
 * @method
 * @see [async.each]{@link module:Collections.each}
 * @alias forEachLimit
 * @category Collection
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {number} limit - The maximum number of async operations at a time.
 * @param {AsyncFunction} iteratee - An async function to apply to each item in
 * `coll`.
 * The array index is not passed to the iteratee.
 * If you need the index, use `eachOfLimit`.
 * Invoked with (item, callback).
 * @param {Function} [callback] - A callback which is called when all
 * `iteratee` functions have finished, or an error occurs. Invoked with (err).
 */
 function eachLimit(coll, limit, iteratee, callback) {
  (0, _eachOfLimit2.default)(limit)(coll, (0, _withoutIndex2.default)((0, _wrapAsync2.default)(iteratee)), callback);
 }
 module.exports = exports['default'];
--- a/node_modules/async/forEachOf.js
+++ b/node_modules/async/forEachOf.js
@@ -0,0 +1,111 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
    value: true
 });

 exports.default = function (coll, iteratee, callback) {
    var eachOfImplementation = (0, _isArrayLike2.default)(coll) ? eachOfArrayLike : eachOfGeneric;
    eachOfImplementation(coll, (0, _wrapAsync2.default)(iteratee), callback);
 };

 var _isArrayLike = require('lodash/isArrayLike');

 var _isArrayLike2 = _interopRequireDefault(_isArrayLike);

 var _breakLoop = require('./internal/breakLoop');

 var _breakLoop2 = _interopRequireDefault(_breakLoop);

 var _eachOfLimit = require('./eachOfLimit');

 var _eachOfLimit2 = _interopRequireDefault(_eachOfLimit);

 var _doLimit = require('./internal/doLimit');

 var _doLimit2 = _interopRequireDefault(_doLimit);

 var _noop = require('lodash/noop');

 var _noop2 = _interopRequireDefault(_noop);

 var _once = require('./internal/once');

 var _once2 = _interopRequireDefault(_once);

 var _onlyOnce = require('./internal/onlyOnce');

 var _onlyOnce2 = _interopRequireDefault(_onlyOnce);

 var _wrapAsync = require('./internal/wrapAsync');

 var _wrapAsync2 = _interopRequireDefault(_wrapAsync);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 // eachOf implementation optimized for array-likes
 function eachOfArrayLike(coll, iteratee, callback) {
    callback = (0, _once2.default)(callback || _noop2.default);
    var index = 0,
        completed = 0,
        length = coll.length;
    if (length === 0) {
        callback(null);
    }

    function iteratorCallback(err, value) {
        if (err) {
            callback(err);
        } else if (++completed === length || value === _breakLoop2.default) {
            callback(null);
        }
    }

    for (; index < length; index++) {
        iteratee(coll[index], index, (0, _onlyOnce2.default)(iteratorCallback));
    }
 }

 // a generic version of eachOf which can handle array, object, and iterator cases.
 var eachOfGeneric = (0, _doLimit2.default)(_eachOfLimit2.default, Infinity);

 /**
 * Like [`each`]{@link module:Collections.each}, except that it passes the key (or index) as the second argument
 * to the iteratee.
 *
 * @name eachOf
 * @static
 * @memberOf module:Collections
 * @method
 * @alias forEachOf
 * @category Collection
 * @see [async.each]{@link module:Collections.each}
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {AsyncFunction} iteratee - A function to apply to each
 * item in `coll`.
 * The `key` is the item's key, or index in the case of an array.
 * Invoked with (item, key, callback).
 * @param {Function} [callback] - A callback which is called when all
 * `iteratee` functions have finished, or an error occurs. Invoked with (err).
 * @example
 *
 * var obj = {dev: "/dev.json", test: "/test.json", prod: "/prod.json"};
 * var configs = {};
 *
 * async.forEachOf(obj, function (value, key, callback) {
 *     fs.readFile(__dirname + value, "utf8", function (err, data) {
 *         if (err) return callback(err);
 *         try {
 *             configs[key] = JSON.parse(data);
 *         } catch (e) {
 *             return callback(e);
 *         }
 *         callback();
 *     });
 * }, function (err) {
 *     if (err) console.error(err.message);
 *     // configs is now a map of JSON data
 *     doSomethingWith(configs);
 * });
 */
 module.exports = exports['default'];
--- a/node_modules/async/forEachOfLimit.js
+++ b/node_modules/async/forEachOfLimit.js
@@ -0,0 +1,41 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });
 exports.default = eachOfLimit;

 var _eachOfLimit2 = require('./internal/eachOfLimit');

 var _eachOfLimit3 = _interopRequireDefault(_eachOfLimit2);

 var _wrapAsync = require('./internal/wrapAsync');

 var _wrapAsync2 = _interopRequireDefault(_wrapAsync);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * The same as [`eachOf`]{@link module:Collections.eachOf} but runs a maximum of `limit` async operations at a
 * time.
 *
 * @name eachOfLimit
 * @static
 * @memberOf module:Collections
 * @method
 * @see [async.eachOf]{@link module:Collections.eachOf}
 * @alias forEachOfLimit
 * @category Collection
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {number} limit - The maximum number of async operations at a time.
 * @param {AsyncFunction} iteratee - An async function to apply to each
 * item in `coll`. The `key` is the item's key, or index in the case of an
 * array.
 * Invoked with (item, key, callback).
 * @param {Function} [callback] - A callback which is called when all
 * `iteratee` functions have finished, or an error occurs. Invoked with (err).
 */
 function eachOfLimit(coll, limit, iteratee, callback) {
  (0, _eachOfLimit3.default)(limit)(coll, (0, _wrapAsync2.default)(iteratee), callback);
 }
 module.exports = exports['default'];
--- a/node_modules/async/forEachOfSeries.js
+++ b/node_modules/async/forEachOfSeries.js
@@ -0,0 +1,35 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });

 var _eachOfLimit = require('./eachOfLimit');

 var _eachOfLimit2 = _interopRequireDefault(_eachOfLimit);

 var _doLimit = require('./internal/doLimit');

 var _doLimit2 = _interopRequireDefault(_doLimit);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * The same as [`eachOf`]{@link module:Collections.eachOf} but runs only a single async operation at a time.
 *
 * @name eachOfSeries
 * @static
 * @memberOf module:Collections
 * @method
 * @see [async.eachOf]{@link module:Collections.eachOf}
 * @alias forEachOfSeries
 * @category Collection
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {AsyncFunction} iteratee - An async function to apply to each item in
 * `coll`.
 * Invoked with (item, key, callback).
 * @param {Function} [callback] - A callback which is called when all `iteratee`
 * functions have finished, or an error occurs. Invoked with (err).
 */
 exports.default = (0, _doLimit2.default)(_eachOfLimit2.default, 1);
 module.exports = exports['default'];
--- a/node_modules/async/forEachSeries.js
+++ b/node_modules/async/forEachSeries.js
@@ -0,0 +1,37 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });

 var _eachLimit = require('./eachLimit');

 var _eachLimit2 = _interopRequireDefault(_eachLimit);

 var _doLimit = require('./internal/doLimit');

 var _doLimit2 = _interopRequireDefault(_doLimit);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * The same as [`each`]{@link module:Collections.each} but runs only a single async operation at a time.
 *
 * @name eachSeries
 * @static
 * @memberOf module:Collections
 * @method
 * @see [async.each]{@link module:Collections.each}
 * @alias forEachSeries
 * @category Collection
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {AsyncFunction} iteratee - An async function to apply to each
 * item in `coll`.
 * The array index is not passed to the iteratee.
 * If you need the index, use `eachOfSeries`.
 * Invoked with (item, callback).
 * @param {Function} [callback] - A callback which is called when all
 * `iteratee` functions have finished, or an error occurs. Invoked with (err).
 */
 exports.default = (0, _doLimit2.default)(_eachLimit2.default, 1);
 module.exports = exports['default'];
--- a/node_modules/async/forever.js
+++ b/node_modules/async/forever.js
@@ -0,0 +1,65 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
    value: true
 });
 exports.default = forever;

 var _noop = require('lodash/noop');

 var _noop2 = _interopRequireDefault(_noop);

 var _onlyOnce = require('./internal/onlyOnce');

 var _onlyOnce2 = _interopRequireDefault(_onlyOnce);

 var _ensureAsync = require('./ensureAsync');

 var _ensureAsync2 = _interopRequireDefault(_ensureAsync);

 var _wrapAsync = require('./internal/wrapAsync');

 var _wrapAsync2 = _interopRequireDefault(_wrapAsync);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * Calls the asynchronous function `fn` with a callback parameter that allows it
 * to call itself again, in series, indefinitely.

 * If an error is passed to the callback then `errback` is called with the
 * error, and execution stops, otherwise it will never be called.
 *
 * @name forever
 * @static
 * @memberOf module:ControlFlow
 * @method
 * @category Control Flow
 * @param {AsyncFunction} fn - an async function to call repeatedly.
 * Invoked with (next).
 * @param {Function} [errback] - when `fn` passes an error to it's callback,
 * this function will be called, and execution stops. Invoked with (err).
 * @example
 *
 * async.forever(
 *     function(next) {
 *         // next is suitable for passing to things that need a callback(err [, whatever]);
 *         // it will result in this function being called again.
 *     },
 *     function(err) {
 *         // if next is called with a value in its first parameter, it will appear
 *         // in here as 'err', and execution will stop.
 *     }
 * );
 */
 function forever(fn, errback) {
    var done = (0, _onlyOnce2.default)(errback || _noop2.default);
    var task = (0, _wrapAsync2.default)((0, _ensureAsync2.default)(fn));

    function next(err) {
        if (err) return done(err);
        task(next);
    }
    next();
 }
 module.exports = exports['default'];
--- a/node_modules/async/groupBy.js
+++ b/node_modules/async/groupBy.js
@@ -0,0 +1,54 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });

 var _doLimit = require('./internal/doLimit');

 var _doLimit2 = _interopRequireDefault(_doLimit);

 var _groupByLimit = require('./groupByLimit');

 var _groupByLimit2 = _interopRequireDefault(_groupByLimit);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * Returns a new object, where each value corresponds to an array of items, from
 * `coll`, that returned the corresponding key. That is, the keys of the object
 * correspond to the values passed to the `iteratee` callback.
 *
 * Note: Since this function applies the `iteratee` to each item in parallel,
 * there is no guarantee that the `iteratee` functions will complete in order.
 * However, the values for each key in the `result` will be in the same order as
 * the original `coll`. For Objects, the values will roughly be in the order of
 * the original Objects' keys (but this can vary across JavaScript engines).
 *
 * @name groupBy
 * @static
 * @memberOf module:Collections
 * @method
 * @category Collection
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {AsyncFunction} iteratee - An async function to apply to each item in
 * `coll`.
 * The iteratee should complete with a `key` to group the value under.
 * Invoked with (value, callback).
 * @param {Function} [callback] - A callback which is called when all `iteratee`
 * functions have finished, or an error occurs. Result is an `Object` whoses
 * properties are arrays of values which returned the corresponding key.
 * @example
 *
 * async.groupBy(['userId1', 'userId2', 'userId3'], function(userId, callback) {
 *     db.findById(userId, function(err, user) {
 *         if (err) return callback(err);
 *         return callback(null, user.age);
 *     });
 * }, function(err, result) {
 *     // result is object containing the userIds grouped by age
 *     // e.g. { 30: ['userId1', 'userId3'], 42: ['userId2']};
 * });
 */
 exports.default = (0, _doLimit2.default)(_groupByLimit2.default, Infinity);
 module.exports = exports['default'];
--- a/node_modules/async/groupByLimit.js
+++ b/node_modules/async/groupByLimit.js
@@ -0,0 +1,71 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
    value: true
 });

 exports.default = function (coll, limit, iteratee, callback) {
    callback = callback || _noop2.default;
    var _iteratee = (0, _wrapAsync2.default)(iteratee);
    (0, _mapLimit2.default)(coll, limit, function (val, callback) {
        _iteratee(val, function (err, key) {
            if (err) return callback(err);
            return callback(null, { key: key, val: val });
        });
    }, function (err, mapResults) {
        var result = {};
        // from MDN, handle object having an `hasOwnProperty` prop
        var hasOwnProperty = Object.prototype.hasOwnProperty;

        for (var i = 0; i < mapResults.length; i++) {
            if (mapResults[i]) {
                var key = mapResults[i].key;
                var val = mapResults[i].val;

                if (hasOwnProperty.call(result, key)) {
                    result[key].push(val);
                } else {
                    result[key] = [val];
                }
            }
        }

        return callback(err, result);
    });
 };

 var _noop = require('lodash/noop');

 var _noop2 = _interopRequireDefault(_noop);

 var _mapLimit = require('./mapLimit');

 var _mapLimit2 = _interopRequireDefault(_mapLimit);

 var _wrapAsync = require('./internal/wrapAsync');

 var _wrapAsync2 = _interopRequireDefault(_wrapAsync);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 ;
 /**
 * The same as [`groupBy`]{@link module:Collections.groupBy} but runs a maximum of `limit` async operations at a time.
 *
 * @name groupByLimit
 * @static
 * @memberOf module:Collections
 * @method
 * @see [async.groupBy]{@link module:Collections.groupBy}
 * @category Collection
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {number} limit - The maximum number of async operations at a time.
 * @param {AsyncFunction} iteratee - An async function to apply to each item in
 * `coll`.
 * The iteratee should complete with a `key` to group the value under.
 * Invoked with (value, callback).
 * @param {Function} [callback] - A callback which is called when all `iteratee`
 * functions have finished, or an error occurs. Result is an `Object` whoses
 * properties are arrays of values which returned the corresponding key.
 */
 module.exports = exports['default'];
--- a/node_modules/async/groupBySeries.js
+++ b/node_modules/async/groupBySeries.js
@@ -0,0 +1,37 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });

 var _doLimit = require('./internal/doLimit');

 var _doLimit2 = _interopRequireDefault(_doLimit);

 var _groupByLimit = require('./groupByLimit');

 var _groupByLimit2 = _interopRequireDefault(_groupByLimit);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * The same as [`groupBy`]{@link module:Collections.groupBy} but runs only a single async operation at a time.
 *
 * @name groupBySeries
 * @static
 * @memberOf module:Collections
 * @method
 * @see [async.groupBy]{@link module:Collections.groupBy}
 * @category Collection
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {number} limit - The maximum number of async operations at a time.
 * @param {AsyncFunction} iteratee - An async function to apply to each item in
 * `coll`.
 * The iteratee should complete with a `key` to group the value under.
 * Invoked with (value, callback).
 * @param {Function} [callback] - A callback which is called when all `iteratee`
 * functions have finished, or an error occurs. Result is an `Object` whoses
 * properties are arrays of values which returned the corresponding key.
 */
 exports.default = (0, _doLimit2.default)(_groupByLimit2.default, 1);
 module.exports = exports['default'];
--- a/node_modules/async/index.js
+++ b/node_modules/async/index.js
@@ -0,0 +1,582 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });
 exports.wrapSync = exports.selectSeries = exports.selectLimit = exports.select = exports.foldr = exports.foldl = exports.inject = exports.forEachOfLimit = exports.forEachOfSeries = exports.forEachOf = exports.forEachLimit = exports.forEachSeries = exports.forEach = exports.findSeries = exports.findLimit = exports.find = exports.anySeries = exports.anyLimit = exports.any = exports.allSeries = exports.allLimit = exports.all = exports.whilst = exports.waterfall = exports.until = exports.unmemoize = exports.tryEach = exports.transform = exports.timesSeries = exports.timesLimit = exports.times = exports.timeout = exports.sortBy = exports.someSeries = exports.someLimit = exports.some = exports.setImmediate = exports.series = exports.seq = exports.retryable = exports.retry = exports.rejectSeries = exports.rejectLimit = exports.reject = exports.reflectAll = exports.reflect = exports.reduceRight = exports.reduce = exports.race = exports.queue = exports.priorityQueue = exports.parallelLimit = exports.parallel = exports.nextTick = exports.memoize = exports.mapValuesSeries = exports.mapValuesLimit = exports.mapValues = exports.mapSeries = exports.mapLimit = exports.map = exports.log = exports.groupBySeries = exports.groupByLimit = exports.groupBy = exports.forever = exports.filterSeries = exports.filterLimit = exports.filter = exports.everySeries = exports.everyLimit = exports.every = exports.ensureAsync = exports.eachSeries = exports.eachOfSeries = exports.eachOfLimit = exports.eachOf = exports.eachLimit = exports.each = exports.during = exports.doWhilst = exports.doUntil = exports.doDuring = exports.dir = exports.detectSeries = exports.detectLimit = exports.detect = exports.constant = exports.concatSeries = exports.concatLimit = exports.concat = exports.compose = exports.cargo = exports.autoInject = exports.auto = exports.asyncify = exports.applyEachSeries = exports.applyEach = exports.apply = undefined;

 var _apply = require('./apply');

 var _apply2 = _interopRequireDefault(_apply);

 var _applyEach = require('./applyEach');

 var _applyEach2 = _interopRequireDefault(_applyEach);

 var _applyEachSeries = require('./applyEachSeries');

 var _applyEachSeries2 = _interopRequireDefault(_applyEachSeries);

 var _asyncify = require('./asyncify');

 var _asyncify2 = _interopRequireDefault(_asyncify);

 var _auto = require('./auto');

 var _auto2 = _interopRequireDefault(_auto);

 var _autoInject = require('./autoInject');

 var _autoInject2 = _interopRequireDefault(_autoInject);

 var _cargo = require('./cargo');

 var _cargo2 = _interopRequireDefault(_cargo);

 var _compose = require('./compose');

 var _compose2 = _interopRequireDefault(_compose);

 var _concat = require('./concat');

 var _concat2 = _interopRequireDefault(_concat);

 var _concatLimit = require('./concatLimit');

 var _concatLimit2 = _interopRequireDefault(_concatLimit);

 var _concatSeries = require('./concatSeries');

 var _concatSeries2 = _interopRequireDefault(_concatSeries);

 var _constant = require('./constant');

 var _constant2 = _interopRequireDefault(_constant);

 var _detect = require('./detect');

 var _detect2 = _interopRequireDefault(_detect);

 var _detectLimit = require('./detectLimit');

 var _detectLimit2 = _interopRequireDefault(_detectLimit);

 var _detectSeries = require('./detectSeries');

 var _detectSeries2 = _interopRequireDefault(_detectSeries);

 var _dir = require('./dir');

 var _dir2 = _interopRequireDefault(_dir);

 var _doDuring = require('./doDuring');

 var _doDuring2 = _interopRequireDefault(_doDuring);

 var _doUntil = require('./doUntil');

 var _doUntil2 = _interopRequireDefault(_doUntil);

 var _doWhilst = require('./doWhilst');

 var _doWhilst2 = _interopRequireDefault(_doWhilst);

 var _during = require('./during');

 var _during2 = _interopRequireDefault(_during);

 var _each = require('./each');

 var _each2 = _interopRequireDefault(_each);

 var _eachLimit = require('./eachLimit');

 var _eachLimit2 = _interopRequireDefault(_eachLimit);

 var _eachOf = require('./eachOf');

 var _eachOf2 = _interopRequireDefault(_eachOf);

 var _eachOfLimit = require('./eachOfLimit');

 var _eachOfLimit2 = _interopRequireDefault(_eachOfLimit);

 var _eachOfSeries = require('./eachOfSeries');

 var _eachOfSeries2 = _interopRequireDefault(_eachOfSeries);

 var _eachSeries = require('./eachSeries');

 var _eachSeries2 = _interopRequireDefault(_eachSeries);

 var _ensureAsync = require('./ensureAsync');

 var _ensureAsync2 = _interopRequireDefault(_ensureAsync);

 var _every = require('./every');

 var _every2 = _interopRequireDefault(_every);

 var _everyLimit = require('./everyLimit');

 var _everyLimit2 = _interopRequireDefault(_everyLimit);

 var _everySeries = require('./everySeries');

 var _everySeries2 = _interopRequireDefault(_everySeries);

 var _filter = require('./filter');

 var _filter2 = _interopRequireDefault(_filter);

 var _filterLimit = require('./filterLimit');

 var _filterLimit2 = _interopRequireDefault(_filterLimit);

 var _filterSeries = require('./filterSeries');

 var _filterSeries2 = _interopRequireDefault(_filterSeries);

 var _forever = require('./forever');

 var _forever2 = _interopRequireDefault(_forever);

 var _groupBy = require('./groupBy');

 var _groupBy2 = _interopRequireDefault(_groupBy);

 var _groupByLimit = require('./groupByLimit');

 var _groupByLimit2 = _interopRequireDefault(_groupByLimit);

 var _groupBySeries = require('./groupBySeries');

 var _groupBySeries2 = _interopRequireDefault(_groupBySeries);

 var _log = require('./log');

 var _log2 = _interopRequireDefault(_log);

 var _map = require('./map');

 var _map2 = _interopRequireDefault(_map);

 var _mapLimit = require('./mapLimit');

 var _mapLimit2 = _interopRequireDefault(_mapLimit);

 var _mapSeries = require('./mapSeries');

 var _mapSeries2 = _interopRequireDefault(_mapSeries);

 var _mapValues = require('./mapValues');

 var _mapValues2 = _interopRequireDefault(_mapValues);

 var _mapValuesLimit = require('./mapValuesLimit');

 var _mapValuesLimit2 = _interopRequireDefault(_mapValuesLimit);

 var _mapValuesSeries = require('./mapValuesSeries');

 var _mapValuesSeries2 = _interopRequireDefault(_mapValuesSeries);

 var _memoize = require('./memoize');

 var _memoize2 = _interopRequireDefault(_memoize);

 var _nextTick = require('./nextTick');

 var _nextTick2 = _interopRequireDefault(_nextTick);

 var _parallel = require('./parallel');

 var _parallel2 = _interopRequireDefault(_parallel);

 var _parallelLimit = require('./parallelLimit');

 var _parallelLimit2 = _interopRequireDefault(_parallelLimit);

 var _priorityQueue = require('./priorityQueue');

 var _priorityQueue2 = _interopRequireDefault(_priorityQueue);

 var _queue = require('./queue');

 var _queue2 = _interopRequireDefault(_queue);

 var _race = require('./race');

 var _race2 = _interopRequireDefault(_race);

 var _reduce = require('./reduce');

 var _reduce2 = _interopRequireDefault(_reduce);

 var _reduceRight = require('./reduceRight');

 var _reduceRight2 = _interopRequireDefault(_reduceRight);

 var _reflect = require('./reflect');

 var _reflect2 = _interopRequireDefault(_reflect);

 var _reflectAll = require('./reflectAll');

 var _reflectAll2 = _interopRequireDefault(_reflectAll);

 var _reject = require('./reject');

 var _reject2 = _interopRequireDefault(_reject);

 var _rejectLimit = require('./rejectLimit');

 var _rejectLimit2 = _interopRequireDefault(_rejectLimit);

 var _rejectSeries = require('./rejectSeries');

 var _rejectSeries2 = _interopRequireDefault(_rejectSeries);

 var _retry = require('./retry');

 var _retry2 = _interopRequireDefault(_retry);

 var _retryable = require('./retryable');

 var _retryable2 = _interopRequireDefault(_retryable);

 var _seq = require('./seq');

 var _seq2 = _interopRequireDefault(_seq);

 var _series = require('./series');

 var _series2 = _interopRequireDefault(_series);

 var _setImmediate = require('./setImmediate');

 var _setImmediate2 = _interopRequireDefault(_setImmediate);

 var _some = require('./some');

 var _some2 = _interopRequireDefault(_some);

 var _someLimit = require('./someLimit');

 var _someLimit2 = _interopRequireDefault(_someLimit);

 var _someSeries = require('./someSeries');

 var _someSeries2 = _interopRequireDefault(_someSeries);

 var _sortBy = require('./sortBy');

 var _sortBy2 = _interopRequireDefault(_sortBy);

 var _timeout = require('./timeout');

 var _timeout2 = _interopRequireDefault(_timeout);

 var _times = require('./times');

 var _times2 = _interopRequireDefault(_times);

 var _timesLimit = require('./timesLimit');

 var _timesLimit2 = _interopRequireDefault(_timesLimit);

 var _timesSeries = require('./timesSeries');

 var _timesSeries2 = _interopRequireDefault(_timesSeries);

 var _transform = require('./transform');

 var _transform2 = _interopRequireDefault(_transform);

 var _tryEach = require('./tryEach');

 var _tryEach2 = _interopRequireDefault(_tryEach);

 var _unmemoize = require('./unmemoize');

 var _unmemoize2 = _interopRequireDefault(_unmemoize);

 var _until = require('./until');

 var _until2 = _interopRequireDefault(_until);

 var _waterfall = require('./waterfall');

 var _waterfall2 = _interopRequireDefault(_waterfall);

 var _whilst = require('./whilst');

 var _whilst2 = _interopRequireDefault(_whilst);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 exports.default = {
  apply: _apply2.default,
  applyEach: _applyEach2.default,
  applyEachSeries: _applyEachSeries2.default,
  asyncify: _asyncify2.default,
  auto: _auto2.default,
  autoInject: _autoInject2.default,
  cargo: _cargo2.default,
  compose: _compose2.default,
  concat: _concat2.default,
  concatLimit: _concatLimit2.default,
  concatSeries: _concatSeries2.default,
  constant: _constant2.default,
  detect: _detect2.default,
  detectLimit: _detectLimit2.default,
  detectSeries: _detectSeries2.default,
  dir: _dir2.default,
  doDuring: _doDuring2.default,
  doUntil: _doUntil2.default,
  doWhilst: _doWhilst2.default,
  during: _during2.default,
  each: _each2.default,
  eachLimit: _eachLimit2.default,
  eachOf: _eachOf2.default,
  eachOfLimit: _eachOfLimit2.default,
  eachOfSeries: _eachOfSeries2.default,
  eachSeries: _eachSeries2.default,
  ensureAsync: _ensureAsync2.default,
  every: _every2.default,
  everyLimit: _everyLimit2.default,
  everySeries: _everySeries2.default,
  filter: _filter2.default,
  filterLimit: _filterLimit2.default,
  filterSeries: _filterSeries2.default,
  forever: _forever2.default,
  groupBy: _groupBy2.default,
  groupByLimit: _groupByLimit2.default,
  groupBySeries: _groupBySeries2.default,
  log: _log2.default,
  map: _map2.default,
  mapLimit: _mapLimit2.default,
  mapSeries: _mapSeries2.default,
  mapValues: _mapValues2.default,
  mapValuesLimit: _mapValuesLimit2.default,
  mapValuesSeries: _mapValuesSeries2.default,
  memoize: _memoize2.default,
  nextTick: _nextTick2.default,
  parallel: _parallel2.default,
  parallelLimit: _parallelLimit2.default,
  priorityQueue: _priorityQueue2.default,
  queue: _queue2.default,
  race: _race2.default,
  reduce: _reduce2.default,
  reduceRight: _reduceRight2.default,
  reflect: _reflect2.default,
  reflectAll: _reflectAll2.default,
  reject: _reject2.default,
  rejectLimit: _rejectLimit2.default,
  rejectSeries: _rejectSeries2.default,
  retry: _retry2.default,
  retryable: _retryable2.default,
  seq: _seq2.default,
  series: _series2.default,
  setImmediate: _setImmediate2.default,
  some: _some2.default,
  someLimit: _someLimit2.default,
  someSeries: _someSeries2.default,
  sortBy: _sortBy2.default,
  timeout: _timeout2.default,
  times: _times2.default,
  timesLimit: _timesLimit2.default,
  timesSeries: _timesSeries2.default,
  transform: _transform2.default,
  tryEach: _tryEach2.default,
  unmemoize: _unmemoize2.default,
  until: _until2.default,
  waterfall: _waterfall2.default,
  whilst: _whilst2.default,

  // aliases
  all: _every2.default,
  allLimit: _everyLimit2.default,
  allSeries: _everySeries2.default,
  any: _some2.default,
  anyLimit: _someLimit2.default,
  anySeries: _someSeries2.default,
  find: _detect2.default,
  findLimit: _detectLimit2.default,
  findSeries: _detectSeries2.default,
  forEach: _each2.default,
  forEachSeries: _eachSeries2.default,
  forEachLimit: _eachLimit2.default,
  forEachOf: _eachOf2.default,
  forEachOfSeries: _eachOfSeries2.default,
  forEachOfLimit: _eachOfLimit2.default,
  inject: _reduce2.default,
  foldl: _reduce2.default,
  foldr: _reduceRight2.default,
  select: _filter2.default,
  selectLimit: _filterLimit2.default,
  selectSeries: _filterSeries2.default,
  wrapSync: _asyncify2.default
 }; /**
    * An "async function" in the context of Async is an asynchronous function with
    * a variable number of parameters, with the final parameter being a callback.
    * (`function (arg1, arg2, ..., callback) {}`)
    * The final callback is of the form `callback(err, results...)`, which must be
    * called once the function is completed.  The callback should be called with a
    * Error as its first argument to signal that an error occurred.
    * Otherwise, if no error occurred, it should be called with `null` as the first
    * argument, and any additional `result` arguments that may apply, to signal
    * successful completion.
    * The callback must be called exactly once, ideally on a later tick of the
    * JavaScript event loop.
    *
    * This type of function is also referred to as a "Node-style async function",
    * or a "continuation passing-style function" (CPS). Most of the methods of this
    * library are themselves CPS/Node-style async functions, or functions that
    * return CPS/Node-style async functions.
    *
    * Wherever we accept a Node-style async function, we also directly accept an
    * [ES2017 `async` function]{@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function}.
    * In this case, the `async` function will not be passed a final callback
    * argument, and any thrown error will be used as the `err` argument of the
    * implicit callback, and the return value will be used as the `result` value.
    * (i.e. a `rejected` of the returned Promise becomes the `err` callback
    * argument, and a `resolved` value becomes the `result`.)
    *
    * Note, due to JavaScript limitations, we can only detect native `async`
    * functions and not transpilied implementations.
    * Your environment must have `async`/`await` support for this to work.
    * (e.g. Node > v7.6, or a recent version of a modern browser).
    * If you are using `async` functions through a transpiler (e.g. Babel), you
    * must still wrap the function with [asyncify]{@link module:Utils.asyncify},
    * because the `async function` will be compiled to an ordinary function that
    * returns a promise.
    *
    * @typedef {Function} AsyncFunction
    * @static
    */

 /**
 * Async is a utility module which provides straight-forward, powerful functions
 * for working with asynchronous JavaScript. Although originally designed for
 * use with [Node.js](http://nodejs.org) and installable via
 * `npm install --save async`, it can also be used directly in the browser.
 * @module async
 * @see AsyncFunction
 */

 /**
 * A collection of `async` functions for manipulating collections, such as
 * arrays and objects.
 * @module Collections
 */

 /**
 * A collection of `async` functions for controlling the flow through a script.
 * @module ControlFlow
 */

 /**
 * A collection of `async` utility functions.
 * @module Utils
 */

 exports.apply = _apply2.default;
 exports.applyEach = _applyEach2.default;
 exports.applyEachSeries = _applyEachSeries2.default;
 exports.asyncify = _asyncify2.default;
 exports.auto = _auto2.default;
 exports.autoInject = _autoInject2.default;
 exports.cargo = _cargo2.default;
 exports.compose = _compose2.default;
 exports.concat = _concat2.default;
 exports.concatLimit = _concatLimit2.default;
 exports.concatSeries = _concatSeries2.default;
 exports.constant = _constant2.default;
 exports.detect = _detect2.default;
 exports.detectLimit = _detectLimit2.default;
 exports.detectSeries = _detectSeries2.default;
 exports.dir = _dir2.default;
 exports.doDuring = _doDuring2.default;
 exports.doUntil = _doUntil2.default;
 exports.doWhilst = _doWhilst2.default;
 exports.during = _during2.default;
 exports.each = _each2.default;
 exports.eachLimit = _eachLimit2.default;
 exports.eachOf = _eachOf2.default;
 exports.eachOfLimit = _eachOfLimit2.default;
 exports.eachOfSeries = _eachOfSeries2.default;
 exports.eachSeries = _eachSeries2.default;
 exports.ensureAsync = _ensureAsync2.default;
 exports.every = _every2.default;
 exports.everyLimit = _everyLimit2.default;
 exports.everySeries = _everySeries2.default;
 exports.filter = _filter2.default;
 exports.filterLimit = _filterLimit2.default;
 exports.filterSeries = _filterSeries2.default;
 exports.forever = _forever2.default;
 exports.groupBy = _groupBy2.default;
 exports.groupByLimit = _groupByLimit2.default;
 exports.groupBySeries = _groupBySeries2.default;
 exports.log = _log2.default;
 exports.map = _map2.default;
 exports.mapLimit = _mapLimit2.default;
 exports.mapSeries = _mapSeries2.default;
 exports.mapValues = _mapValues2.default;
 exports.mapValuesLimit = _mapValuesLimit2.default;
 exports.mapValuesSeries = _mapValuesSeries2.default;
 exports.memoize = _memoize2.default;
 exports.nextTick = _nextTick2.default;
 exports.parallel = _parallel2.default;
 exports.parallelLimit = _parallelLimit2.default;
 exports.priorityQueue = _priorityQueue2.default;
 exports.queue = _queue2.default;
 exports.race = _race2.default;
 exports.reduce = _reduce2.default;
 exports.reduceRight = _reduceRight2.default;
 exports.reflect = _reflect2.default;
 exports.reflectAll = _reflectAll2.default;
 exports.reject = _reject2.default;
 exports.rejectLimit = _rejectLimit2.default;
 exports.rejectSeries = _rejectSeries2.default;
 exports.retry = _retry2.default;
 exports.retryable = _retryable2.default;
 exports.seq = _seq2.default;
 exports.series = _series2.default;
 exports.setImmediate = _setImmediate2.default;
 exports.some = _some2.default;
 exports.someLimit = _someLimit2.default;
 exports.someSeries = _someSeries2.default;
 exports.sortBy = _sortBy2.default;
 exports.timeout = _timeout2.default;
 exports.times = _times2.default;
 exports.timesLimit = _timesLimit2.default;
 exports.timesSeries = _timesSeries2.default;
 exports.transform = _transform2.default;
 exports.tryEach = _tryEach2.default;
 exports.unmemoize = _unmemoize2.default;
 exports.until = _until2.default;
 exports.waterfall = _waterfall2.default;
 exports.whilst = _whilst2.default;
 exports.all = _every2.default;
 exports.allLimit = _everyLimit2.default;
 exports.allSeries = _everySeries2.default;
 exports.any = _some2.default;
 exports.anyLimit = _someLimit2.default;
 exports.anySeries = _someSeries2.default;
 exports.find = _detect2.default;
 exports.findLimit = _detectLimit2.default;
 exports.findSeries = _detectSeries2.default;
 exports.forEach = _each2.default;
 exports.forEachSeries = _eachSeries2.default;
 exports.forEachLimit = _eachLimit2.default;
 exports.forEachOf = _eachOf2.default;
 exports.forEachOfSeries = _eachOfSeries2.default;
 exports.forEachOfLimit = _eachOfLimit2.default;
 exports.inject = _reduce2.default;
 exports.foldl = _reduce2.default;
 exports.foldr = _reduceRight2.default;
 exports.select = _filter2.default;
 exports.selectLimit = _filterLimit2.default;
 exports.selectSeries = _filterSeries2.default;
 exports.wrapSync = _asyncify2.default;
--- a/node_modules/async/inject.js
+++ b/node_modules/async/inject.js
@@ -0,0 +1,78 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
    value: true
 });
 exports.default = reduce;

 var _eachOfSeries = require('./eachOfSeries');

 var _eachOfSeries2 = _interopRequireDefault(_eachOfSeries);

 var _noop = require('lodash/noop');

 var _noop2 = _interopRequireDefault(_noop);

 var _once = require('./internal/once');

 var _once2 = _interopRequireDefault(_once);

 var _wrapAsync = require('./internal/wrapAsync');

 var _wrapAsync2 = _interopRequireDefault(_wrapAsync);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * Reduces `coll` into a single value using an async `iteratee` to return each
 * successive step. `memo` is the initial state of the reduction. This function
 * only operates in series.
 *
 * For performance reasons, it may make sense to split a call to this function
 * into a parallel map, and then use the normal `Array.prototype.reduce` on the
 * results. This function is for situations where each step in the reduction
 * needs to be async; if you can get the data before reducing it, then it's
 * probably a good idea to do so.
 *
 * @name reduce
 * @static
 * @memberOf module:Collections
 * @method
 * @alias inject
 * @alias foldl
 * @category Collection
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {*} memo - The initial state of the reduction.
 * @param {AsyncFunction} iteratee - A function applied to each item in the
 * array to produce the next step in the reduction.
 * The `iteratee` should complete with the next state of the reduction.
 * If the iteratee complete with an error, the reduction is stopped and the
 * main `callback` is immediately called with the error.
 * Invoked with (memo, item, callback).
 * @param {Function} [callback] - A callback which is called after all the
 * `iteratee` functions have finished. Result is the reduced value. Invoked with
 * (err, result).
 * @example
 *
 * async.reduce([1,2,3], 0, function(memo, item, callback) {
 *     // pointless async:
 *     process.nextTick(function() {
 *         callback(null, memo + item)
 *     });
 * }, function(err, result) {
 *     // result is now equal to the last value of memo, which is 6
 * });
 */
 function reduce(coll, memo, iteratee, callback) {
    callback = (0, _once2.default)(callback || _noop2.default);
    var _iteratee = (0, _wrapAsync2.default)(iteratee);
    (0, _eachOfSeries2.default)(coll, function (x, i, callback) {
        _iteratee(memo, x, function (err, v) {
            memo = v;
            callback(err);
        });
    }, function (err) {
        callback(err, memo);
    });
 }
 module.exports = exports['default'];
--- a/node_modules/async/internal/DoublyLinkedList.js
+++ b/node_modules/async/internal/DoublyLinkedList.js
@@ -0,0 +1,88 @@
 "use strict";

 Object.defineProperty(exports, "__esModule", {
    value: true
 });
 exports.default = DLL;
 // Simple doubly linked list (https://en.wikipedia.org/wiki/Doubly_linked_list) implementation
 // used for queues. This implementation assumes that the node provided by the user can be modified
 // to adjust the next and last properties. We implement only the minimal functionality
 // for queue support.
 function DLL() {
    this.head = this.tail = null;
    this.length = 0;
 }

 function setInitial(dll, node) {
    dll.length = 1;
    dll.head = dll.tail = node;
 }

 DLL.prototype.removeLink = function (node) {
    if (node.prev) node.prev.next = node.next;else this.head = node.next;
    if (node.next) node.next.prev = node.prev;else this.tail = node.prev;

    node.prev = node.next = null;
    this.length -= 1;
    return node;
 };

 DLL.prototype.empty = function () {
    while (this.head) this.shift();
    return this;
 };

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

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

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

 DLL.prototype.push = function (node) {
    if (this.tail) this.insertAfter(this.tail, node);else setInitial(this, node);
 };

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

 DLL.prototype.pop = function () {
    return this.tail && this.removeLink(this.tail);
 };

 DLL.prototype.toArray = function () {
    var arr = Array(this.length);
    var curr = this.head;
    for (var idx = 0; idx < this.length; idx++) {
        arr[idx] = curr.data;
        curr = curr.next;
    }
    return arr;
 };

 DLL.prototype.remove = function (testFn) {
    var curr = this.head;
    while (!!curr) {
        var next = curr.next;
        if (testFn(curr)) {
            this.removeLink(curr);
        }
        curr = next;
    }
    return this;
 };
 module.exports = exports["default"];
--- a/node_modules/async/internal/applyEach.js
+++ b/node_modules/async/internal/applyEach.js
@@ -0,0 +1,38 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
    value: true
 });
 exports.default = applyEach;

 var _slice = require('./slice');

 var _slice2 = _interopRequireDefault(_slice);

 var _initialParams = require('./initialParams');

 var _initialParams2 = _interopRequireDefault(_initialParams);

 var _wrapAsync = require('./wrapAsync');

 var _wrapAsync2 = _interopRequireDefault(_wrapAsync);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 function applyEach(eachfn) {
    return function (fns /*, ...args*/) {
        var args = (0, _slice2.default)(arguments, 1);
        var go = (0, _initialParams2.default)(function (args, callback) {
            var that = this;
            return eachfn(fns, function (fn, cb) {
                (0, _wrapAsync2.default)(fn).apply(that, args.concat(cb));
            }, callback);
        });
        if (args.length) {
            return go.apply(this, args);
        } else {
            return go;
        }
    };
 }
 module.exports = exports['default'];
--- a/node_modules/async/internal/breakLoop.js
+++ b/node_modules/async/internal/breakLoop.js
@@ -0,0 +1,9 @@
 "use strict";

 Object.defineProperty(exports, "__esModule", {
  value: true
 });
 // A temporary value used to identify if the loop should be broken.
 // See #1064, #1293
 exports.default = {};
 module.exports = exports["default"];
--- a/node_modules/async/internal/consoleFunc.js
+++ b/node_modules/async/internal/consoleFunc.js
@@ -0,0 +1,42 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
    value: true
 });
 exports.default = consoleFunc;

 var _arrayEach = require('lodash/_arrayEach');

 var _arrayEach2 = _interopRequireDefault(_arrayEach);

 var _slice = require('./slice');

 var _slice2 = _interopRequireDefault(_slice);

 var _wrapAsync = require('./wrapAsync');

 var _wrapAsync2 = _interopRequireDefault(_wrapAsync);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 function consoleFunc(name) {
    return function (fn /*, ...args*/) {
        var args = (0, _slice2.default)(arguments, 1);
        args.push(function (err /*, ...args*/) {
            var args = (0, _slice2.default)(arguments, 1);
            if (typeof console === 'object') {
                if (err) {
                    if (console.error) {
                        console.error(err);
                    }
                } else if (console[name]) {
                    (0, _arrayEach2.default)(args, function (x) {
                        console[name](x);
                    });
                }
            }
        });
        (0, _wrapAsync2.default)(fn).apply(null, args);
    };
 }
 module.exports = exports['default'];
--- a/node_modules/async/internal/createTester.js
+++ b/node_modules/async/internal/createTester.js
@@ -0,0 +1,44 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
    value: true
 });
 exports.default = _createTester;

 var _noop = require('lodash/noop');

 var _noop2 = _interopRequireDefault(_noop);

 var _breakLoop = require('./breakLoop');

 var _breakLoop2 = _interopRequireDefault(_breakLoop);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 function _createTester(check, getResult) {
    return function (eachfn, arr, iteratee, cb) {
        cb = cb || _noop2.default;
        var testPassed = false;
        var testResult;
        eachfn(arr, function (value, _, callback) {
            iteratee(value, function (err, result) {
                if (err) {
                    callback(err);
                } else if (check(result) && !testResult) {
                    testPassed = true;
                    testResult = getResult(true, value);
                    callback(null, _breakLoop2.default);
                } else {
                    callback();
                }
            });
        }, function (err) {
            if (err) {
                cb(err);
            } else {
                cb(null, testPassed ? testResult : getResult(false));
            }
        });
    };
 }
 module.exports = exports['default'];
--- a/node_modules/async/internal/doLimit.js
+++ b/node_modules/async/internal/doLimit.js
@@ -0,0 +1,12 @@
 "use strict";

 Object.defineProperty(exports, "__esModule", {
    value: true
 });
 exports.default = doLimit;
 function doLimit(fn, limit) {
    return function (iterable, iteratee, callback) {
        return fn(iterable, limit, iteratee, callback);
    };
 }
 module.exports = exports["default"];
--- a/node_modules/async/internal/doParallel.js
+++ b/node_modules/async/internal/doParallel.js
@@ -0,0 +1,23 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
    value: true
 });
 exports.default = doParallel;

 var _eachOf = require('../eachOf');

 var _eachOf2 = _interopRequireDefault(_eachOf);

 var _wrapAsync = require('./wrapAsync');

 var _wrapAsync2 = _interopRequireDefault(_wrapAsync);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 function doParallel(fn) {
    return function (obj, iteratee, callback) {
        return fn(_eachOf2.default, obj, (0, _wrapAsync2.default)(iteratee), callback);
    };
 }
 module.exports = exports['default'];
--- a/node_modules/async/internal/doParallelLimit.js
+++ b/node_modules/async/internal/doParallelLimit.js
@@ -0,0 +1,23 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
    value: true
 });
 exports.default = doParallelLimit;

 var _eachOfLimit = require('./eachOfLimit');

 var _eachOfLimit2 = _interopRequireDefault(_eachOfLimit);

 var _wrapAsync = require('./wrapAsync');

 var _wrapAsync2 = _interopRequireDefault(_wrapAsync);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 function doParallelLimit(fn) {
    return function (obj, limit, iteratee, callback) {
        return fn((0, _eachOfLimit2.default)(limit), obj, (0, _wrapAsync2.default)(iteratee), callback);
    };
 }
 module.exports = exports['default'];
--- a/node_modules/async/internal/eachOfLimit.js
+++ b/node_modules/async/internal/eachOfLimit.js
@@ -0,0 +1,74 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
    value: true
 });
 exports.default = _eachOfLimit;

 var _noop = require('lodash/noop');

 var _noop2 = _interopRequireDefault(_noop);

 var _once = require('./once');

 var _once2 = _interopRequireDefault(_once);

 var _iterator = require('./iterator');

 var _iterator2 = _interopRequireDefault(_iterator);

 var _onlyOnce = require('./onlyOnce');

 var _onlyOnce2 = _interopRequireDefault(_onlyOnce);

 var _breakLoop = require('./breakLoop');

 var _breakLoop2 = _interopRequireDefault(_breakLoop);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 function _eachOfLimit(limit) {
    return function (obj, iteratee, callback) {
        callback = (0, _once2.default)(callback || _noop2.default);
        if (limit <= 0 || !obj) {
            return callback(null);
        }
        var nextElem = (0, _iterator2.default)(obj);
        var done = false;
        var running = 0;
        var looping = false;

        function iterateeCallback(err, value) {
            running -= 1;
            if (err) {
                done = true;
                callback(err);
            } else if (value === _breakLoop2.default || done && running <= 0) {
                done = true;
                return callback(null);
            } else if (!looping) {
                replenish();
            }
        }

        function replenish() {
            looping = true;
            while (running < limit && !done) {
                var elem = nextElem();
                if (elem === null) {
                    done = true;
                    if (running <= 0) {
                        callback(null);
                    }
                    return;
                }
                running += 1;
                iteratee(elem.value, elem.key, (0, _onlyOnce2.default)(iterateeCallback));
            }
            looping = false;
        }

        replenish();
    };
 }
 module.exports = exports['default'];
--- a/node_modules/async/internal/filter.js
+++ b/node_modules/async/internal/filter.js
@@ -0,0 +1,75 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
    value: true
 });
 exports.default = _filter;

 var _arrayMap = require('lodash/_arrayMap');

 var _arrayMap2 = _interopRequireDefault(_arrayMap);

 var _isArrayLike = require('lodash/isArrayLike');

 var _isArrayLike2 = _interopRequireDefault(_isArrayLike);

 var _baseProperty = require('lodash/_baseProperty');

 var _baseProperty2 = _interopRequireDefault(_baseProperty);

 var _noop = require('lodash/noop');

 var _noop2 = _interopRequireDefault(_noop);

 var _wrapAsync = require('./wrapAsync');

 var _wrapAsync2 = _interopRequireDefault(_wrapAsync);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 function filterArray(eachfn, arr, iteratee, callback) {
    var truthValues = new Array(arr.length);
    eachfn(arr, function (x, index, callback) {
        iteratee(x, function (err, v) {
            truthValues[index] = !!v;
            callback(err);
        });
    }, function (err) {
        if (err) return callback(err);
        var results = [];
        for (var i = 0; i < arr.length; i++) {
            if (truthValues[i]) results.push(arr[i]);
        }
        callback(null, results);
    });
 }

 function filterGeneric(eachfn, coll, iteratee, callback) {
    var results = [];
    eachfn(coll, function (x, index, callback) {
        iteratee(x, function (err, v) {
            if (err) {
                callback(err);
            } else {
                if (v) {
                    results.push({ index: index, value: x });
                }
                callback();
            }
        });
    }, function (err) {
        if (err) {
            callback(err);
        } else {
            callback(null, (0, _arrayMap2.default)(results.sort(function (a, b) {
                return a.index - b.index;
            }), (0, _baseProperty2.default)('value')));
        }
    });
 }

 function _filter(eachfn, coll, iteratee, callback) {
    var filter = (0, _isArrayLike2.default)(coll) ? filterArray : filterGeneric;
    filter(eachfn, coll, (0, _wrapAsync2.default)(iteratee), callback || _noop2.default);
 }
 module.exports = exports['default'];
--- a/node_modules/async/internal/findGetResult.js
+++ b/node_modules/async/internal/findGetResult.js
@@ -0,0 +1,10 @@
 "use strict";

 Object.defineProperty(exports, "__esModule", {
    value: true
 });
 exports.default = _findGetResult;
 function _findGetResult(v, x) {
    return x;
 }
 module.exports = exports["default"];
--- a/node_modules/async/internal/getIterator.js
+++ b/node_modules/async/internal/getIterator.js
@@ -0,0 +1,13 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
    value: true
 });

 exports.default = function (coll) {
    return iteratorSymbol && coll[iteratorSymbol] && coll[iteratorSymbol]();
 };

 var iteratorSymbol = typeof Symbol === 'function' && Symbol.iterator;

 module.exports = exports['default'];
--- a/node_modules/async/internal/initialParams.js
+++ b/node_modules/async/internal/initialParams.js
@@ -0,0 +1,21 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
    value: true
 });

 exports.default = function (fn) {
    return function () /*...args, callback*/{
        var args = (0, _slice2.default)(arguments);
        var callback = args.pop();
        fn.call(this, args, callback);
    };
 };

 var _slice = require('./slice');

 var _slice2 = _interopRequireDefault(_slice);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 module.exports = exports['default'];
--- a/node_modules/async/internal/iterator.js
+++ b/node_modules/async/internal/iterator.js
@@ -0,0 +1,58 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
    value: true
 });
 exports.default = iterator;

 var _isArrayLike = require('lodash/isArrayLike');

 var _isArrayLike2 = _interopRequireDefault(_isArrayLike);

 var _getIterator = require('./getIterator');

 var _getIterator2 = _interopRequireDefault(_getIterator);

 var _keys = require('lodash/keys');

 var _keys2 = _interopRequireDefault(_keys);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 function createArrayIterator(coll) {
    var i = -1;
    var len = coll.length;
    return function next() {
        return ++i < len ? { value: coll[i], key: i } : null;
    };
 }

 function createES2015Iterator(iterator) {
    var i = -1;
    return function next() {
        var item = iterator.next();
        if (item.done) return null;
        i++;
        return { value: item.value, key: i };
    };
 }

 function createObjectIterator(obj) {
    var okeys = (0, _keys2.default)(obj);
    var i = -1;
    var len = okeys.length;
    return function next() {
        var key = okeys[++i];
        return i < len ? { value: obj[key], key: key } : null;
    };
 }

 function iterator(coll) {
    if ((0, _isArrayLike2.default)(coll)) {
        return createArrayIterator(coll);
    }

    var iterator = (0, _getIterator2.default)(coll);
    return iterator ? createES2015Iterator(iterator) : createObjectIterator(coll);
 }
 module.exports = exports['default'];
--- a/node_modules/async/internal/map.js
+++ b/node_modules/async/internal/map.js
@@ -0,0 +1,35 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
    value: true
 });
 exports.default = _asyncMap;

 var _noop = require('lodash/noop');

 var _noop2 = _interopRequireDefault(_noop);

 var _wrapAsync = require('./wrapAsync');

 var _wrapAsync2 = _interopRequireDefault(_wrapAsync);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 function _asyncMap(eachfn, arr, iteratee, callback) {
    callback = callback || _noop2.default;
    arr = arr || [];
    var results = [];
    var counter = 0;
    var _iteratee = (0, _wrapAsync2.default)(iteratee);

    eachfn(arr, function (value, _, callback) {
        var index = counter++;
        _iteratee(value, function (err, v) {
            results[index] = v;
            callback(err);
        });
    }, function (err) {
        callback(err, results);
    });
 }
 module.exports = exports['default'];
--- a/node_modules/async/internal/notId.js
+++ b/node_modules/async/internal/notId.js
@@ -0,0 +1,10 @@
 "use strict";

 Object.defineProperty(exports, "__esModule", {
    value: true
 });
 exports.default = notId;
 function notId(v) {
    return !v;
 }
 module.exports = exports["default"];
--- a/node_modules/async/internal/once.js
+++ b/node_modules/async/internal/once.js
@@ -0,0 +1,15 @@
 "use strict";

 Object.defineProperty(exports, "__esModule", {
    value: true
 });
 exports.default = once;
 function once(fn) {
    return function () {
        if (fn === null) return;
        var callFn = fn;
        fn = null;
        callFn.apply(this, arguments);
    };
 }
 module.exports = exports["default"];
--- a/node_modules/async/internal/onlyOnce.js
+++ b/node_modules/async/internal/onlyOnce.js
@@ -0,0 +1,15 @@
 "use strict";

 Object.defineProperty(exports, "__esModule", {
    value: true
 });
 exports.default = onlyOnce;
 function onlyOnce(fn) {
    return function () {
        if (fn === null) throw new Error("Callback was already called.");
        var callFn = fn;
        fn = null;
        callFn.apply(this, arguments);
    };
 }
 module.exports = exports["default"];
--- a/node_modules/async/internal/parallel.js
+++ b/node_modules/async/internal/parallel.js
@@ -0,0 +1,42 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
    value: true
 });
 exports.default = _parallel;

 var _noop = require('lodash/noop');

 var _noop2 = _interopRequireDefault(_noop);

 var _isArrayLike = require('lodash/isArrayLike');

 var _isArrayLike2 = _interopRequireDefault(_isArrayLike);

 var _slice = require('./slice');

 var _slice2 = _interopRequireDefault(_slice);

 var _wrapAsync = require('./wrapAsync');

 var _wrapAsync2 = _interopRequireDefault(_wrapAsync);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 function _parallel(eachfn, tasks, callback) {
    callback = callback || _noop2.default;
    var results = (0, _isArrayLike2.default)(tasks) ? [] : {};

    eachfn(tasks, function (task, key, callback) {
        (0, _wrapAsync2.default)(task)(function (err, result) {
            if (arguments.length > 2) {
                result = (0, _slice2.default)(arguments, 1);
            }
            results[key] = result;
            callback(err);
        });
    }, function (err) {
        callback(err, results);
    });
 }
 module.exports = exports['default'];
--- a/node_modules/async/internal/queue.js
+++ b/node_modules/async/internal/queue.js
@@ -0,0 +1,204 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
    value: true
 });
 exports.default = queue;

 var _baseIndexOf = require('lodash/_baseIndexOf');

 var _baseIndexOf2 = _interopRequireDefault(_baseIndexOf);

 var _isArray = require('lodash/isArray');

 var _isArray2 = _interopRequireDefault(_isArray);

 var _noop = require('lodash/noop');

 var _noop2 = _interopRequireDefault(_noop);

 var _onlyOnce = require('./onlyOnce');

 var _onlyOnce2 = _interopRequireDefault(_onlyOnce);

 var _setImmediate = require('./setImmediate');

 var _setImmediate2 = _interopRequireDefault(_setImmediate);

 var _DoublyLinkedList = require('./DoublyLinkedList');

 var _DoublyLinkedList2 = _interopRequireDefault(_DoublyLinkedList);

 var _wrapAsync = require('./wrapAsync');

 var _wrapAsync2 = _interopRequireDefault(_wrapAsync);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 function queue(worker, concurrency, payload) {
    if (concurrency == null) {
        concurrency = 1;
    } else if (concurrency === 0) {
        throw new Error('Concurrency must not be zero');
    }

    var _worker = (0, _wrapAsync2.default)(worker);
    var numRunning = 0;
    var workersList = [];

    var processingScheduled = false;
    function _insert(data, insertAtFront, callback) {
        if (callback != null && typeof callback !== 'function') {
            throw new Error('task callback must be a function');
        }
        q.started = true;
        if (!(0, _isArray2.default)(data)) {
            data = [data];
        }
        if (data.length === 0 && q.idle()) {
            // call drain immediately if there are no tasks
            return (0, _setImmediate2.default)(function () {
                q.drain();
            });
        }

        for (var i = 0, l = data.length; i < l; i++) {
            var item = {
                data: data[i],
                callback: callback || _noop2.default
            };

            if (insertAtFront) {
                q._tasks.unshift(item);
            } else {
                q._tasks.push(item);
            }
        }

        if (!processingScheduled) {
            processingScheduled = true;
            (0, _setImmediate2.default)(function () {
                processingScheduled = false;
                q.process();
            });
        }
    }

    function _next(tasks) {
        return function (err) {
            numRunning -= 1;

            for (var i = 0, l = tasks.length; i < l; i++) {
                var task = tasks[i];

                var index = (0, _baseIndexOf2.default)(workersList, task, 0);
                if (index === 0) {
                    workersList.shift();
                } else if (index > 0) {
                    workersList.splice(index, 1);
                }

                task.callback.apply(task, arguments);

                if (err != null) {
                    q.error(err, task.data);
                }
            }

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

            if (q.idle()) {
                q.drain();
            }
            q.process();
        };
    }

    var isProcessing = false;
    var q = {
        _tasks: new _DoublyLinkedList2.default(),
        concurrency: concurrency,
        payload: payload,
        saturated: _noop2.default,
        unsaturated: _noop2.default,
        buffer: concurrency / 4,
        empty: _noop2.default,
        drain: _noop2.default,
        error: _noop2.default,
        started: false,
        paused: false,
        push: function (data, callback) {
            _insert(data, false, callback);
        },
        kill: function () {
            q.drain = _noop2.default;
            q._tasks.empty();
        },
        unshift: function (data, callback) {
            _insert(data, true, callback);
        },
        remove: function (testFn) {
            q._tasks.remove(testFn);
        },
        process: function () {
            // Avoid trying to start too many processing operations. This can occur
            // when callbacks resolve synchronously (#1267).
            if (isProcessing) {
                return;
            }
            isProcessing = true;
            while (!q.paused && numRunning < q.concurrency && q._tasks.length) {
                var tasks = [],
                    data = [];
                var l = q._tasks.length;
                if (q.payload) l = Math.min(l, q.payload);
                for (var i = 0; i < l; i++) {
                    var node = q._tasks.shift();
                    tasks.push(node);
                    workersList.push(node);
                    data.push(node.data);
                }

                numRunning += 1;

                if (q._tasks.length === 0) {
                    q.empty();
                }

                if (numRunning === q.concurrency) {
                    q.saturated();
                }

                var cb = (0, _onlyOnce2.default)(_next(tasks));
                _worker(data, cb);
            }
            isProcessing = false;
        },
        length: function () {
            return q._tasks.length;
        },
        running: function () {
            return numRunning;
        },
        workersList: function () {
            return workersList;
        },
        idle: function () {
            return q._tasks.length + numRunning === 0;
        },
        pause: function () {
            q.paused = true;
        },
        resume: function () {
            if (q.paused === false) {
                return;
            }
            q.paused = false;
            (0, _setImmediate2.default)(q.process);
        }
    };
    return q;
 }
 module.exports = exports['default'];
--- a/node_modules/async/internal/reject.js
+++ b/node_modules/async/internal/reject.js
@@ -0,0 +1,21 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
    value: true
 });
 exports.default = reject;

 var _filter = require('./filter');

 var _filter2 = _interopRequireDefault(_filter);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 function reject(eachfn, arr, iteratee, callback) {
    (0, _filter2.default)(eachfn, arr, function (value, cb) {
        iteratee(value, function (err, v) {
            cb(err, !v);
        });
    }, callback);
 }
 module.exports = exports['default'];
--- a/node_modules/async/internal/setImmediate.js
+++ b/node_modules/async/internal/setImmediate.js
@@ -0,0 +1,42 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
    value: true
 });
 exports.hasNextTick = exports.hasSetImmediate = undefined;
 exports.fallback = fallback;
 exports.wrap = wrap;

 var _slice = require('./slice');

 var _slice2 = _interopRequireDefault(_slice);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 var hasSetImmediate = exports.hasSetImmediate = typeof setImmediate === 'function' && setImmediate;
 var hasNextTick = exports.hasNextTick = typeof process === 'object' && typeof process.nextTick === 'function';

 function fallback(fn) {
    setTimeout(fn, 0);
 }

 function wrap(defer) {
    return function (fn /*, ...args*/) {
        var args = (0, _slice2.default)(arguments, 1);
        defer(function () {
            fn.apply(null, args);
        });
    };
 }

 var _defer;

 if (hasSetImmediate) {
    _defer = setImmediate;
 } else if (hasNextTick) {
    _defer = process.nextTick;
 } else {
    _defer = fallback;
 }

 exports.default = wrap(_defer);
--- a/node_modules/async/internal/slice.js
+++ b/node_modules/async/internal/slice.js
@@ -0,0 +1,16 @@
 "use strict";

 Object.defineProperty(exports, "__esModule", {
    value: true
 });
 exports.default = slice;
 function slice(arrayLike, start) {
    start = start | 0;
    var newLen = Math.max(arrayLike.length - start, 0);
    var newArr = Array(newLen);
    for (var idx = 0; idx < newLen; idx++) {
        newArr[idx] = arrayLike[start + idx];
    }
    return newArr;
 }
 module.exports = exports["default"];
--- a/node_modules/async/internal/withoutIndex.js
+++ b/node_modules/async/internal/withoutIndex.js
@@ -0,0 +1,12 @@
 "use strict";

 Object.defineProperty(exports, "__esModule", {
    value: true
 });
 exports.default = _withoutIndex;
 function _withoutIndex(iteratee) {
    return function (value, index, callback) {
        return iteratee(value, callback);
    };
 }
 module.exports = exports["default"];
--- a/node_modules/async/internal/wrapAsync.js
+++ b/node_modules/async/internal/wrapAsync.js
@@ -0,0 +1,25 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
    value: true
 });
 exports.isAsync = undefined;

 var _asyncify = require('../asyncify');

 var _asyncify2 = _interopRequireDefault(_asyncify);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 var supportsSymbol = typeof Symbol === 'function';

 function isAsync(fn) {
    return supportsSymbol && fn[Symbol.toStringTag] === 'AsyncFunction';
 }

 function wrapAsync(asyncFn) {
    return isAsync(asyncFn) ? (0, _asyncify2.default)(asyncFn) : asyncFn;
 }

 exports.default = wrapAsync;
 exports.isAsync = isAsync;
--- a/node_modules/async/log.js
+++ b/node_modules/async/log.js
@@ -0,0 +1,41 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });

 var _consoleFunc = require('./internal/consoleFunc');

 var _consoleFunc2 = _interopRequireDefault(_consoleFunc);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * Logs the result of an `async` function to the `console`. Only works in
 * Node.js or in browsers that support `console.log` and `console.error` (such
 * as FF and Chrome). If multiple arguments are returned from the async
 * function, `console.log` is called on each argument in order.
 *
 * @name log
 * @static
 * @memberOf module:Utils
 * @method
 * @category Util
 * @param {AsyncFunction} function - The function you want to eventually apply
 * all arguments to.
 * @param {...*} arguments... - Any number of arguments to apply to the function.
 * @example
 *
 * // in a module
 * var hello = function(name, callback) {
 *     setTimeout(function() {
 *         callback(null, 'hello ' + name);
 *     }, 1000);
 * };
 *
 * // in the node repl
 * node> async.log(hello, 'world');
 * 'hello world'
 */
 exports.default = (0, _consoleFunc2.default)('log');
 module.exports = exports['default'];
--- a/node_modules/async/map.js
+++ b/node_modules/async/map.js
@@ -0,0 +1,54 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });

 var _doParallel = require('./internal/doParallel');

 var _doParallel2 = _interopRequireDefault(_doParallel);

 var _map = require('./internal/map');

 var _map2 = _interopRequireDefault(_map);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * Produces a new collection of values by mapping each value in `coll` through
 * the `iteratee` function. The `iteratee` is called with an item from `coll`
 * and a callback for when it has finished processing. Each of these callback
 * takes 2 arguments: an `error`, and the transformed item from `coll`. If
 * `iteratee` passes an error to its callback, the main `callback` (for the
 * `map` function) is immediately called with the error.
 *
 * Note, that since this function applies the `iteratee` to each item in
 * parallel, there is no guarantee that the `iteratee` functions will complete
 * in order. However, the results array will be in the same order as the
 * original `coll`.
 *
 * If `map` is passed an Object, the results will be an Array.  The results
 * will roughly be in the order of the original Objects' keys (but this can
 * vary across JavaScript engines).
 *
 * @name map
 * @static
 * @memberOf module:Collections
 * @method
 * @category Collection
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {AsyncFunction} iteratee - An async function to apply to each item in
 * `coll`.
 * The iteratee should complete with the transformed item.
 * Invoked with (item, callback).
 * @param {Function} [callback] - A callback which is called when all `iteratee`
 * functions have finished, or an error occurs. Results is an Array of the
 * transformed items from the `coll`. Invoked with (err, results).
 * @example
 *
 * async.map(['file1','file2','file3'], fs.stat, function(err, results) {
 *     // results is now an array of stats for each file
 * });
 */
 exports.default = (0, _doParallel2.default)(_map2.default);
 module.exports = exports['default'];
--- a/node_modules/async/mapLimit.js
+++ b/node_modules/async/mapLimit.js
@@ -0,0 +1,37 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });

 var _doParallelLimit = require('./internal/doParallelLimit');

 var _doParallelLimit2 = _interopRequireDefault(_doParallelLimit);

 var _map = require('./internal/map');

 var _map2 = _interopRequireDefault(_map);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * The same as [`map`]{@link module:Collections.map} but runs a maximum of `limit` async operations at a time.
 *
 * @name mapLimit
 * @static
 * @memberOf module:Collections
 * @method
 * @see [async.map]{@link module:Collections.map}
 * @category Collection
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {number} limit - The maximum number of async operations at a time.
 * @param {AsyncFunction} iteratee - An async function to apply to each item in
 * `coll`.
 * The iteratee should complete with the transformed item.
 * Invoked with (item, callback).
 * @param {Function} [callback] - A callback which is called when all `iteratee`
 * functions have finished, or an error occurs. Results is an array of the
 * transformed items from the `coll`. Invoked with (err, results).
 */
 exports.default = (0, _doParallelLimit2.default)(_map2.default);
 module.exports = exports['default'];
--- a/node_modules/async/mapSeries.js
+++ b/node_modules/async/mapSeries.js
@@ -0,0 +1,36 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });

 var _mapLimit = require('./mapLimit');

 var _mapLimit2 = _interopRequireDefault(_mapLimit);

 var _doLimit = require('./internal/doLimit');

 var _doLimit2 = _interopRequireDefault(_doLimit);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * The same as [`map`]{@link module:Collections.map} but runs only a single async operation at a time.
 *
 * @name mapSeries
 * @static
 * @memberOf module:Collections
 * @method
 * @see [async.map]{@link module:Collections.map}
 * @category Collection
 * @param {Array|Iterable|Object} coll - A collection to iterate over.
 * @param {AsyncFunction} iteratee - An async function to apply to each item in
 * `coll`.
 * The iteratee should complete with the transformed item.
 * Invoked with (item, callback).
 * @param {Function} [callback] - A callback which is called when all `iteratee`
 * functions have finished, or an error occurs. Results is an array of the
 * transformed items from the `coll`. Invoked with (err, results).
 */
 exports.default = (0, _doLimit2.default)(_mapLimit2.default, 1);
 module.exports = exports['default'];
--- a/node_modules/async/mapValues.js
+++ b/node_modules/async/mapValues.js
@@ -0,0 +1,63 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });

 var _mapValuesLimit = require('./mapValuesLimit');

 var _mapValuesLimit2 = _interopRequireDefault(_mapValuesLimit);

 var _doLimit = require('./internal/doLimit');

 var _doLimit2 = _interopRequireDefault(_doLimit);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * A relative of [`map`]{@link module:Collections.map}, designed for use with objects.
 *
 * Produces a new Object by mapping each value of `obj` through the `iteratee`
 * function. The `iteratee` is called each `value` and `key` from `obj` and a
 * callback for when it has finished processing. Each of these callbacks takes
 * two arguments: an `error`, and the transformed item from `obj`. If `iteratee`
 * passes an error to its callback, the main `callback` (for the `mapValues`
 * function) is immediately called with the error.
 *
 * Note, the order of the keys in the result is not guaranteed.  The keys will
 * be roughly in the order they complete, (but this is very engine-specific)
 *
 * @name mapValues
 * @static
 * @memberOf module:Collections
 * @method
 * @category Collection
 * @param {Object} obj - A collection to iterate over.
 * @param {AsyncFunction} iteratee - A function to apply to each value and key
 * in `coll`.
 * The iteratee should complete with the transformed value as its result.
 * Invoked with (value, key, callback).
 * @param {Function} [callback] - A callback which is called when all `iteratee`
 * functions have finished, or an error occurs. `result` is a new object consisting
 * of each key from `obj`, with each transformed value on the right-hand side.
 * Invoked with (err, result).
 * @example
 *
 * async.mapValues({
 *     f1: 'file1',
 *     f2: 'file2',
 *     f3: 'file3'
 * }, function (file, key, callback) {
 *   fs.stat(file, callback);
 * }, function(err, result) {
 *     // result is now a map of stats for each file, e.g.
 *     // {
 *     //     f1: [stats for file1],
 *     //     f2: [stats for file2],
 *     //     f3: [stats for file3]
 *     // }
 * });
 */

 exports.default = (0, _doLimit2.default)(_mapValuesLimit2.default, Infinity);
 module.exports = exports['default'];
--- a/node_modules/async/mapValuesLimit.js
+++ b/node_modules/async/mapValuesLimit.js
@@ -0,0 +1,61 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
    value: true
 });
 exports.default = mapValuesLimit;

 var _eachOfLimit = require('./eachOfLimit');

 var _eachOfLimit2 = _interopRequireDefault(_eachOfLimit);

 var _noop = require('lodash/noop');

 var _noop2 = _interopRequireDefault(_noop);

 var _once = require('./internal/once');

 var _once2 = _interopRequireDefault(_once);

 var _wrapAsync = require('./internal/wrapAsync');

 var _wrapAsync2 = _interopRequireDefault(_wrapAsync);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * The same as [`mapValues`]{@link module:Collections.mapValues} but runs a maximum of `limit` async operations at a
 * time.
 *
 * @name mapValuesLimit
 * @static
 * @memberOf module:Collections
 * @method
 * @see [async.mapValues]{@link module:Collections.mapValues}
 * @category Collection
 * @param {Object} obj - A collection to iterate over.
 * @param {number} limit - The maximum number of async operations at a time.
 * @param {AsyncFunction} iteratee - A function to apply to each value and key
 * in `coll`.
 * The iteratee should complete with the transformed value as its result.
 * Invoked with (value, key, callback).
 * @param {Function} [callback] - A callback which is called when all `iteratee`
 * functions have finished, or an error occurs. `result` is a new object consisting
 * of each key from `obj`, with each transformed value on the right-hand side.
 * Invoked with (err, result).
 */
 function mapValuesLimit(obj, limit, iteratee, callback) {
    callback = (0, _once2.default)(callback || _noop2.default);
    var newObj = {};
    var _iteratee = (0, _wrapAsync2.default)(iteratee);
    (0, _eachOfLimit2.default)(obj, limit, function (val, key, next) {
        _iteratee(val, key, function (err, result) {
            if (err) return next(err);
            newObj[key] = result;
            next();
        });
    }, function (err) {
        callback(err, newObj);
    });
 }
 module.exports = exports['default'];
--- a/node_modules/async/mapValuesSeries.js
+++ b/node_modules/async/mapValuesSeries.js
@@ -0,0 +1,37 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
  value: true
 });

 var _mapValuesLimit = require('./mapValuesLimit');

 var _mapValuesLimit2 = _interopRequireDefault(_mapValuesLimit);

 var _doLimit = require('./internal/doLimit');

 var _doLimit2 = _interopRequireDefault(_doLimit);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 /**
 * The same as [`mapValues`]{@link module:Collections.mapValues} but runs only a single async operation at a time.
 *
 * @name mapValuesSeries
 * @static
 * @memberOf module:Collections
 * @method
 * @see [async.mapValues]{@link module:Collections.mapValues}
 * @category Collection
 * @param {Object} obj - A collection to iterate over.
 * @param {AsyncFunction} iteratee - A function to apply to each value and key
 * in `coll`.
 * The iteratee should complete with the transformed value as its result.
 * Invoked with (value, key, callback).
 * @param {Function} [callback] - A callback which is called when all `iteratee`
 * functions have finished, or an error occurs. `result` is a new object consisting
 * of each key from `obj`, with each transformed value on the right-hand side.
 * Invoked with (err, result).
 */
 exports.default = (0, _doLimit2.default)(_mapValuesLimit2.default, 1);
 module.exports = exports['default'];
--- a/node_modules/async/memoize.js
+++ b/node_modules/async/memoize.js
@@ -0,0 +1,101 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
    value: true
 });
 exports.default = memoize;

 var _identity = require('lodash/identity');

 var _identity2 = _interopRequireDefault(_identity);

 var _slice = require('./internal/slice');

 var _slice2 = _interopRequireDefault(_slice);

 var _setImmediate = require('./internal/setImmediate');

 var _setImmediate2 = _interopRequireDefault(_setImmediate);

 var _initialParams = require('./internal/initialParams');

 var _initialParams2 = _interopRequireDefault(_initialParams);

 var _wrapAsync = require('./internal/wrapAsync');

 var _wrapAsync2 = _interopRequireDefault(_wrapAsync);

 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

 function has(obj, key) {
    return key in obj;
 }

 /**
 * Caches the results of an async function. When creating a hash to store
 * function results against, the callback is omitted from the hash and an
 * optional hash function can be used.
 *
 * If no hash function is specified, the first argument is used as a hash key,
 * which may work reasonably if it is a string or a data type that converts to a
 * distinct string. Note that objects and arrays will not behave reasonably.
 * Neither will cases where the other arguments are significant. In such cases,
 * specify your own hash function.
 *
 * The cache of results is exposed as the `memo` property of the function
 * returned by `memoize`.
 *
 * @name memoize
 * @static
 * @memberOf module:Utils
 * @method
 * @category Util
 * @param {AsyncFunction} fn - The async function to proxy and cache results from.
 * @param {Function} hasher - An optional function for generating a custom hash
 * for storing results. It has all the arguments applied to it apart from the
 * callback, and must be synchronous.
 * @returns {AsyncFunction} a memoized version of `fn`
 * @example
 *
 * var slow_fn = function(name, callback) {
 *     // do something
 *     callback(null, result);
 * };
 * var fn = async.memoize(slow_fn);
 *
 * // fn can now be used as if it were slow_fn
 * fn('some name', function() {
 *     // callback
 * });
 */
 function memoize(fn, hasher) {
    var memo = Object.create(null);
    var queues = Object.create(null);
    hasher = hasher || _identity2.default;
    var _fn = (0, _wrapAsync2.default)(fn);
    var memoized = (0, _initialParams2.default)(function memoized(args, callback) {
        var key = hasher.apply(null, args);
        if (has(memo, key)) {
            (0, _setImmediate2.default)(function () {
                callback.apply(null, memo[key]);
            });
        } else if (has(queues, key)) {
            queues[key].push(callback);
        } else {
            queues[key] = [callback];
            _fn.apply(null, args.concat(function () /*args*/{
                var args = (0, _slice2.default)(arguments);
                memo[key] = args;
                var q = queues[key];
                delete queues[key];
                for (var i = 0, l = q.length; i < l; i++) {
                    q[i].apply(null, args);
                }
            }));
        }
    });
    memoized.memo = memo;
    memoized.unmemoized = fn;
    return memoized;
 }
 module.exports = exports['default'];
--- a/node_modules/async/nextTick.js
+++ b/node_modules/async/nextTick.js
@@ -0,0 +1,51 @@
 'use strict';

 Object.defineProperty(exports, "__esModule", {
    value: true
 });

 var _setImmediate = require('./internal/setImmediate');

 /**
 * Calls `callback` on a later loop around the event loop. In Node.js this just
 * calls `process.nextTick`.  In the browser it will use `setImmediate` if
 * available, otherwise `setTimeout(callback, 0)`, which means other higher
 * priority events may precede the execution of `callback`.
 *
 * This is used internally for browser-compatibility purposes.
 *
 * @name nextTick
 * @static
 * @memberOf module:Utils
 * @method
 * @see [async.setImmediate]{@link module:Utils.setImmediate}
 * @category Util
 * @param {Function} callback - The function to call on a later loop around
 * the event loop. Invoked with (args...).
 * @param {...*} args... - any number of additional arguments to pass to the
 * callback on the next tick.
 * @example
 *
 * var call_order = [];
 * async.nextTick(function() {
 *     call_order.push('two');
 *     // call_order now equals ['one','two']
 * });
 * call_order.push('one');
 *
 * async.setImmediate(function (a, b, c) {
 *     // a, b, and c equal 1, 2, and 3
 * }, 1, 2, 3);
 */
 var _defer;

 if (_setImmediate.hasNextTick) {
    _defer = process.nextTick;
 } else if (_setImmediate.hasSetImmediate) {
    _defer = setImmediate;
 } else {
    _defer = _setImmediate.fallback;
 }

 exports.default = (0, _setImmediate.wrap)(_defer);
 module.exports = exports['default'];
--- a/node_modules/async/package.json
+++ b/node_modules/async/package.json