https://shc.co.jp/assets/libs/kuromoji/kuromoji.js

1(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.kuromoji = f()}})(function(){var define,module,exports;return (function(){function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s}return e})()({1:[function(require,module,exports){
2  (function (process,global){
3  (function (global, factory) {
4    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
5    typeof define === 'function' && define.amd ? define(['exports'], factory) :
6    (factory((global.async = global.async || {})));
7  }(this, (function (exports) { 'use strict';
8  
9  function slice(arrayLike, start) {
10      start = start|0;
11      var newLen = Math.max(arrayLike.length - start, 0);
12      var newArr = Array(newLen);
13      for(var idx = 0; idx < newLen; idx++)  {
14          newArr[idx] = arrayLike[start + idx];
15      }
16      return newArr;
17  }
18  
19  /**
20   * Creates a continuation function with some arguments already applied.
21   *
22   * Useful as a shorthand when combined with other control flow functions. Any
23   * arguments passed to the returned function are added to the arguments
24   * originally passed to apply.
25   *
26   * @name apply
27   * @static
28   * @memberOf module:Utils
29   * @method
30   * @category Util
31   * @param {Function} fn - The function you want to eventually apply all
32   * arguments to. Invokes with (arguments...).
33   * @param {...*} arguments... - Any number of arguments to automatically apply
34   * when the continuation is called.
35   * @returns {Function} the partially-applied function
36   * @example
37   *
38   * // using apply
39   * async.parallel([
40   *     async.apply(fs.writeFile, 'testfile1', 'test1'),
41   *     async.apply(fs.writeFile, 'testfile2', 'test2')
42   * ]);
43   *
44   *
45   * // the same process without using apply
46   * async.parallel([
47   *     function(callback) {
48   *         fs.writeFile('testfile1', 'test1', callback);
49   *     },
50   *     function(callback) {
51   *         fs.writeFile('testfile2', 'test2', callback);
52   *     }
53   * ]);
54   *
55   * // It's possible to pass any number of additional arguments when calling the
56   * // continuation:
57   *
58   * node> var fn = async.apply(sys.puts, 'one');
59   * node> fn('two', 'three');
60   * one
61   * two
62   * three
63   */
64  var apply = function(fn/*, ...args*/) {
65      var args = slice(arguments, 1);
66      return function(/*callArgs*/) {
67          var callArgs = slice(arguments);
68          return fn.apply(null, args.concat(callArgs));
69      };
70  };
71  
72  var initialParams = function (fn) {
73      return function (/*...args, callback*/) {
74          var args = slice(arguments);
75          var callback = args.pop();
76          fn.call(this, args, callback);
77      };
78  };
79  
80  /**
81   * Checks if `value` is the
82   * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
83   * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
84   *
85   * @static
86   * @memberOf _
87   * @since 0.1.0
88   * @category Lang
89   * @param {*} value The value to check.
90   * @returns {boolean} Returns `true` if `value` is an object, else `false`.
91   * @example
92   *
93   * _.isObject({});
94   * // => true
95   *
96   * _.isObject([1, 2, 3]);
97   * // => true
98   *
99   * _.isObject(_.noop);
100   * // => true
101   *
102   * _.isObject(null);
103   * // => false
104   */
105  function isObject(value) {
106    var type = typeof value;
107    return value != null && (type == 'object' || type == 'function');
108  }
109  
110  var hasSetImmediate = typeof setImmediate === 'function' && setImmediate;
111  var hasNextTick = typeof process === 'object' && typeof process.nextTick === 'function';
112  
113  function fallback(fn) {
114      setTimeout(fn, 0);
115  }
116  
117  function wrap(defer) {
118      return function (fn/*, ...args*/) {
119          var args = slice(arguments, 1);
120          defer(function () {
121              fn.apply(null, args);
122          });
123      };
124  }
125  
126  var _defer;
127  
128  if (hasSetImmediate) {
129      _defer = setImmediate;
130  } else if (hasNextTick) {
131      _defer = process.nextTick;
132  } else {
133      _defer = fallback;
134  }
135  
136  var setImmediate$1 = wrap(_defer);
137  
138  /**
139   * Take a sync function and make it async, passing its return value to a
140   * callback. This is useful for plugging sync functions into a waterfall,
141   * series, or other async functions. Any arguments passed to the generated
142   * function will be passed to the wrapped function (except for the final
143   * callback argument). Errors thrown will be passed to the callback.
144   *
145   * If the function passed to `asyncify` returns a Promise, that promises's
146   * resolved/rejected state will be used to call the callback, rather than simply
147   * the synchronous return value.
148   *
149   * This also means you can asyncify ES2017 `async` functions.
150   *
151   * @name asyncify
152   * @static
153   * @memberOf module:Utils
154   * @method
155   * @alias wrapSync
156   * @category Util
157   * @param {Function} func - The synchronous function, or Promise-returning
158   * function to convert to an {@link AsyncFunction}.
159   * @returns {AsyncFunction} An asynchronous wrapper of the `func`. To be
160   * invoked with `(args..., callback)`.
161   * @example
162   *
163   * // passing a regular synchronous function
164   * async.waterfall([
165   *     async.apply(fs.readFile, filename, "utf8"),
166   *     async.asyncify(JSON.parse),
167   *     function (data, next) {
168   *         // data is the result of parsing the text.
169   *         // If there was a parsing error, it would have been caught.
170   *     }
171   * ], callback);
172   *
173   * // passing a function returning a promise
174   * async.waterfall([
175   *     async.apply(fs.readFile, filename, "utf8"),
176   *     async.asyncify(function (contents) {
177   *         return db.model.create(contents);
178   *     }),
179   *     function (model, next) {
180   *         // `model` is the instantiated model object.
181   *         // If there was an error, this function would be skipped.
182   *     }
183   * ], callback);
184   *
185   * // es2017 example, though `asyncify` is not needed if your JS environment
186   * // supports async functions out of the box
187   * var q = async.queue(async.asyncify(async function(file) {
188   *     var intermediateStep = await processFile(file);
189   *     return await somePromise(intermediateStep)
190   * }));
191   *
192   * q.push(files);
193   */
194  function asyncify(func) {
195      return initialParams(function (args, callback) {
196          var result;
197          try {
198              result = func.apply(this, args);
199          } catch (e) {
200              return callback(e);
201          }
202          // if result is Promise object
203          if (isObject(result) && typeof result.then === 'function') {
204              result.then(function(value) {
205                  invokeCallback(callback, null, value);
206              }, function(err) {
207                  invokeCallback(callback, err.message ? err : new Error(err));
208              });
209          } else {
210              callback(null, result);
211          }
212      });
213  }
214  
215  function invokeCallback(callback, error, value) {
216      try {
217          callback(error, value);
218      } catch (e) {
219          setImmediate$1(rethrow, e);
220      }
221  }
222  
223  function rethrow(error) {
224      throw error;
225  }
226  
227  var supportsSymbol = typeof Symbol === 'function';
228  
229  function isAsync(fn) {
230      return supportsSymbol && fn[Symbol.toStringTag] === 'AsyncFunction';
231  }
232  
233  function wrapAsync(asyncFn) {
234      return isAsync(asyncFn) ? asyncify(asyncFn) : asyncFn;
235  }
236  
237  function applyEach$1(eachfn) {
238      return function(fns/*, ...args*/) {
239          var args = slice(arguments, 1);
240          var go = initialParams(function(args, callback) {
241              var that = this;
242              return eachfn(fns, function (fn, cb) {
243                  wrapAsync(fn).apply(that, args.concat(cb));
244              }, callback);
245          });
246          if (args.length) {
247              return go.apply(this, args);
248          }
249          else {
250              return go;
251          }
252      };
253  }
254  
255  /** Detect free variable `global` from Node.js. */
256  var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
257  
258  /** Detect free variable `self`. */
259  var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
260  
261  /** Used as a reference to the global object. */
262  var root = freeGlobal || freeSelf || Function('return this')();
263  
264  /** Built-in value references. */
265  var Symbol$1 = root.Symbol;
266  
267  /** Used for built-in method references. */
268  var objectProto = Object.prototype;
269  
270  /** Used to check objects for own properties. */
271  var hasOwnProperty = objectProto.hasOwnProperty;
272  
273  /**
274   * Used to resolve the
275   * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
276   * of values.
277   */
278  var nativeObjectToString = objectProto.toString;
279  
280  /** Built-in value references. */
281  var symToStringTag$1 = Symbol$1 ? Symbol$1.toStringTag : undefined;
282  
283  /**
284   * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
285   *
286   * @private
287   * @param {*} value The value to query.
288   * @returns {string} Returns the raw `toStringTag`.
289   */
290  function getRawTag(value) {
291    var isOwn = hasOwnProperty.call(value, symToStringTag$1),
292        tag = value[symToStringTag$1];
293  
294    try {
295      value[symToStringTag$1] = undefined;
296      var unmasked = true;
297    } catch (e) {}
298  
299    var result = nativeObjectToString.call(value);
300    if (unmasked) {
301      if (isOwn) {
302        value[symToStringTag$1] = tag;
303      } else {
304        delete value[symToStringTag$1];
305      }
306    }
307    return result;
308  }
309  
310  /** Used for built-in method references. */
311  var objectProto$1 = Object.prototype;
312  
313  /**
314   * Used to resolve the
315   * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
316   * of values.
317   */
318  var nativeObjectToString$1 = objectProto$1.toString;
319  
320  /**
321   * Converts `value` to a string using `Object.prototype.toString`.
322   *
323   * @private
324   * @param {*} value The value to convert.
325   * @returns {string} Returns the converted string.
326   */
327  function objectToString(value) {
328    return nativeObjectToString$1.call(value);
329  }
330  
331  /** `Object#toString` result references. */
332  var nullTag = '[object Null]';
333  var undefinedTag = '[object Undefined]';
334  
335  /** Built-in value references. */
336  var symToStringTag = Symbol$1 ? Symbol$1.toStringTag : undefined;
337  
338  /**
339   * The base implementation of `getTag` without fallbacks for buggy environments.
340   *
341   * @private
342   * @param {*} value The value to query.
343   * @returns {string} Returns the `toStringTag`.
344   */
345  function baseGetTag(value) {
346    if (value == null) {
347      return value === undefined ? undefinedTag : nullTag;
348    }
349    return (symToStringTag && symToStringTag in Object(value))
350      ? getRawTag(value)
351      : objectToString(value);
352  }
353  
354  /** `Object#toString` result references. */
355  var asyncTag = '[object AsyncFunction]';
356  var funcTag = '[object Function]';
357  var genTag = '[object GeneratorFunction]';
358  var proxyTag = '[object Proxy]';
359  
360  /**
361   * Checks if `value` is classified as a `Function` object.
362   *
363   * @static
364   * @memberOf _
365   * @since 0.1.0
366   * @category Lang
367   * @param {*} value The value to check.
368   * @returns {boolean} Returns `true` if `value` is a function, else `false`.
369   * @example
370   *
371   * _.isFunction(_);
372   * // => true
373   *
374   * _.isFunction(/abc/);
375   * // => false
376   */
377  function isFunction(value) {
378    if (!isObject(value)) {
379      return false;
380    }
381    // The use of `Object#toString` avoids issues with the `typeof` operator
382    // in Safari 9 which returns 'object' for typed arrays and other constructors.
383    var tag = baseGetTag(value);
384    return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
385  }
386  
387  /** Used as references for various `Number` constants. */
388  var MAX_SAFE_INTEGER = 9007199254740991;
389  
390  /**
391   * Checks if `value` is a valid array-like length.
392   *
393   * **Note:** This method is loosely based on
394   * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
395   *
396   * @static
397   * @memberOf _
398   * @since 4.0.0
399   * @category Lang
400   * @param {*} value The value to check.
401   * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
402   * @example
403   *
404   * _.isLength(3);
405   * // => true
406   *
407   * _.isLength(Number.MIN_VALUE);
408   * // => false
409   *
410   * _.isLength(Infinity);
411   * // => false
412   *
413   * _.isLength('3');
414   * // => false
415   */
416  function isLength(value) {
417    return typeof value == 'number' &&
418      value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
419  }
420  
421  /**
422   * Checks if `value` is array-like. A value is considered array-like if it's
423   * not a function and has a `value.length` that's an integer greater than or
424   * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
425   *
426   * @static
427   * @memberOf _
428   * @since 4.0.0
429   * @category Lang
430   * @param {*} value The value to check.
431   * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
432   * @example
433   *
434   * _.isArrayLike([1, 2, 3]);
435   * // => true
436   *
437   * _.isArrayLike(document.body.children);
438   * // => true
439   *
440   * _.isArrayLike('abc');
441   * // => true
442   *
443   * _.isArrayLike(_.noop);
444   * // => false
445   */
446  function isArrayLike(value) {
447    return value != null && isLength(value.length) && !isFunction(value);
448  }
449  
450  // A temporary value used to identify if the loop should be broken.
451  // See #1064, #1293
452  var breakLoop = {};
453  
454  /**
455   * This method returns `undefined`.
456   *
457   * @static
458   * @memberOf _
459   * @since 2.3.0
460   * @category Util
461   * @example
462   *
463   * _.times(2, _.noop);
464   * // => [undefined, undefined]
465   */
466  function noop() {
467    // No operation performed.
468  }
469  
470  function once(fn) {
471      return function () {
472          if (fn === null) return;
473          var callFn = fn;
474          fn = null;
475          callFn.apply(this, arguments);
476      };
477  }
478  
479  var iteratorSymbol = typeof Symbol === 'function' && Symbol.iterator;
480  
481  var getIterator = function (coll) {
482      return iteratorSymbol && coll[iteratorSymbol] && coll[iteratorSymbol]();
483  };
484  
485  /**

693  var float64Tag = '[object Float64Array]';
694  var int8Tag = '[object Int8Array]';
695  var int16Tag = '[object Int16Array]';
696  var int32Tag = '[object Int32Array]';
697  var uint8Tag = '[object Uint8Array]';
698  var uint8ClampedTag = '[object Uint8ClampedArray]';
699  var uint16Tag = '[object Uint16Array]';
700  var uint32Tag = '[object Uint32Array]';
701  
702  /** Used to identify `toStringTag` values of typed arrays. */
703  var typedArrayTags = {};
704  typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =
705  typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =
706  typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =
707  typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =
708  typedArrayTags[uint32Tag] = true;
709  typedArrayTags[argsTag$1] = typedArrayTags[arrayTag] =
710  typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =
711  typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =
712  typedArrayTags[errorTag] = typedArrayTags[funcTag$1] =
713  typedArrayTags[mapTag] = typedArrayTags[numberTag] =
714  typedArrayTags[objectTag] = typedArrayTags[regexpTag] =
715  typedArrayTags[setTag] = typedArrayTags[stringTag] =
716  typedArrayTags[weakMapTag] = false;
717  
718  /**
719   * The base implementation of `_.isTypedArray` without Node.js optimizations.
720   *
721   * @private
722   * @param {*} value The value to check.
723   * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
724   */
725  function baseIsTypedArray(value) {
726    return isObjectLike(value) &&
727      isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
728  }
729  
730  /**
731   * The base implementation of `_.unary` without support for storing metadata.
732   *
733   * @private
734   * @param {Function} func The function to cap arguments for.
735   * @returns {Function} Returns the new capped function.
736   */
737  function baseUnary(func) {
738    return function(value) {
739      return func(value);
740    };
741  }
742  
743  /** Detect free variable `exports`. */
744  var freeExports$1 = typeof exports == 'object' && exports && !exports.nodeType && exports;
745  
746  /** Detect free variable `module`. */
747  var freeModule$1 = freeExports$1 && typeof module == 'object' && module && !module.nodeType && module;
748  
749  /** Detect the popular CommonJS extension `module.exports`. */
750  var moduleExports$1 = freeModule$1 && freeModule$1.exports === freeExports$1;
751  
752  /** Detect free variable `process` from Node.js. */
753  var freeProcess = moduleExports$1 && freeGlobal.process;
754  
755  /** Used to access faster Node.js helpers. */
756  var nodeUtil = (function() {
757    try {
758      return freeProcess && freeProcess.binding && freeProcess.binding('util');
759    } catch (e) {}
760  }());
761  
762  /* Node.js helper references. */
763  var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
764  
765  /**
766   * Checks if `value` is classified as a typed array.
767   *
768   * @static
769   * @memberOf _
770   * @since 3.0.0
771   * @category Lang
772   * @param {*} value The value to check.
773   * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
774   * @example
775   *
776   * _.isTypedArray(new Uint8Array);
777   * // => true
778   *
779   * _.isTypedArray([]);
780   * // => false
781   */
782  var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
783  
784  /** Used for built-in method references. */
785  var objectProto$2 = Object.prototype;
786  
787  /** Used to check objects for own properties. */
788  var hasOwnProperty$1 = objectProto$2.hasOwnProperty;
789  
790  /**
791   * Creates an array of the enumerable property names of the array-like `value`.
792   *
793   * @private
794   * @param {*} value The value to query.
795   * @param {boolean} inherited Specify returning inherited property names.
796   * @returns {Array} Returns the array of property names.
797   */
798  function arrayLikeKeys(value, inherited) {
799    var isArr = isArray(value),
800        isArg = !isArr && isArguments(value),
801        isBuff = !isArr && !isArg && isBuffer(value),
802        isType = !isArr && !isArg && !isBuff && isTypedArray(value),
803        skipIndexes = isArr || isArg || isBuff || isType,
804        result = skipIndexes ? baseTimes(value.length, String) : [],
805        length = result.length;
806  
807    for (var key in value) {
808      if ((inherited || hasOwnProperty$1.call(value, key)) &&
809          !(skipIndexes && (
810             // Safari 9 has enumerable `arguments.length` in strict mode.
811             key == 'length' ||
812             // Node.js 0.10 has enumerable non-index properties on buffers.
813             (isBuff && (key == 'offset' || key == 'parent')) ||
814             // PhantomJS 2 has enumerable non-index properties on typed arrays.
815             (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||
816             // Skip index properties.
817             isIndex(key, length)
818          ))) {
819        result.push(key);
820      }
821    }
822    return result;
823  }
824  
825  /** Used for built-in method references. */
826  var objectProto$5 = Object.prototype;
827  
828  /**
829   * Checks if `value` is likely a prototype object.
830   *
831   * @private
832   * @param {*} value The value to check.
833   * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
834   */
835  function isPrototype(value) {
836    var Ctor = value && value.constructor,
837        proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto$5;
838  
839    return value === proto;
840  }
841  
842  /**
843   * Creates a unary function that invokes `func` with its argument transformed.
844   *
845   * @private
846   * @param {Function} func The function to wrap.
847   * @param {Function} transform The argument transform.
848   * @returns {Function} Returns the new function.
849   */
850  function overArg(func, transform) {
851    return function(arg) {
852      return func(transform(arg));
853    };
854  }
855  
856  /* Built-in method references for those with the same name as other `lodash` methods. */
857  var nativeKeys = overArg(Object.keys, Object);
858  
859  /** Used for built-in method references. */
860  var objectProto$4 = Object.prototype;
861  
862  /** Used to check objects for own properties. */
863  var hasOwnProperty$3 = objectProto$4.hasOwnProperty;
864  
865  /**
866   * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.
867   *
868   * @private
869   * @param {Object} object The object to query.
870   * @returns {Array} Returns the array of property names.
871   */
872  function baseKeys(object) {
873    if (!isPrototype(object)) {
874      return nativeKeys(object);
875    }
876    var result = [];
877    for (var key in Object(object)) {
878      if (hasOwnProperty$3.call(object, key) && key != 'constructor') {
879        result.push(key);
880      }
881    }
882    return result;
883  }
884  
885  /**
886   * Creates an array of the own enumerable property names of `object`.
887   *
888   * **Note:** Non-object values are coerced to objects. See the
889   * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
890   * for more details.
891   *
892   * @static
893   * @since 0.1.0
894   * @memberOf _
895   * @category Object
896   * @param {Object} object The object to query.
897   * @returns {Array} Returns the array of property names.
898   * @example
899   *
900   * function Foo() {
901   *   this.a = 1;
902   *   this.b = 2;
903   * }
904   *
905   * Foo.prototype.c = 3;
906   *
907   * _.keys(new Foo);
908   * // => ['a', 'b'] (iteration order is not guaranteed)
909   *
910   * _.keys('hi');
911   * // => ['0', '1']
912   */
913  function keys(object) {
914    return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
915  }
916  
917  function createArrayIterator(coll) {
918      var i = -1;
919      var len = coll.length;
920      return function next() {
921          return ++i < len ? {value: coll[i], key: i} : null;
922      }
923  }
924  
925  function createES2015Iterator(iterator) {
926      var i = -1;
927      return function next() {
928          var item = iterator.next();
929          if (item.done)
930              return null;
931          i++;
932          return {value: item.value, key: i};
933      }
934  }
935  
936  function createObjectIterator(obj) {
937      var okeys = keys(obj);
938      var i = -1;
939      var len = okeys.length;
940      return function next() {
941          var key = okeys[++i];
942          return i < len ? {value: obj[key], key: key} : null;
943      };
944  }
945  
946  function iterator(coll) {
947      if (isArrayLike(coll)) {
948          return createArrayIterator(coll);
949      }
950  
951      var iterator = getIterator(coll);
952      return iterator ? createES2015Iterator(iterator) : createObjectIterator(coll);
953  }
954  
955  function onlyOnce(fn) {
956      return function() {
957          if (fn === null) throw new Error("Callback was already called.");
958          var callFn = fn;
959          fn = null;
960          callFn.apply(this, arguments);
961      };
962  }
963  
964  function _eachOfLimit(limit) {
965      return function (obj, iteratee, callback) {
966          callback = once(callback || noop);
967          if (limit <= 0 || !obj) {
968              return callback(null);
969          }
970          var nextElem = iterator(obj);
971          var done = false;
972          var running = 0;
973  
974          function iterateeCallback(err, value) {
975              running -= 1;
976              if (err) {
977                  done = true;
978                  callback(err);
979              }
980              else if (value === breakLoop || (done && running <= 0)) {
981                  done = true;
982                  return callback(null);
983              }
984              else {
985                  replenish();
986              }
987          }
988  
989          function replenish () {
990              while (running < limit && !done) {
991                  var elem = nextElem();
992                  if (elem === null) {
993                      done = true;
994                      if (running <= 0) {
995                          callback(null);
996                      }
997                      return;
998                  }
999                  running += 1;
1000                  iteratee(elem.value, elem.key, onlyOnce(iterateeCallback));
1001              }
1002          }
1003  
1004          replenish();
1005      };
1006  }
1007  
1008  /**
1009   * The same as [`eachOf`]{@link module:Collections.eachOf} but runs a maximum of `limit` async operations at a
1010   * time.
1011   *
1012   * @name eachOfLimit
1013   * @static
1014   * @memberOf module:Collections
1015   * @method
1016   * @see [async.eachOf]{@link module:Collections.eachOf}
1017   * @alias forEachOfLimit
1018   * @category Collection
1019   * @param {Array|Iterable|Object} coll - A collection to iterate over.
1020   * @param {number} limit - The maximum number of async operations at a time.
1021   * @param {AsyncFunction} iteratee - An async function to apply to each
1022   * item in `coll`. The `key` is the item's key, or index in the case of an
1023   * array.
1024   * Invoked with (item, key, callback).
1025   * @param {Function} [callback] - A callback which is called when all
1026   * `iteratee` functions have finished, or an error occurs. Invoked with (err).
1027   */
1028  function eachOfLimit(coll, limit, iteratee, callback) {
1029      _eachOfLimit(limit)(coll, wrapAsync(iteratee), callback);
1030  }
1031  
1032  function doLimit(fn, limit) {
1033      return function (iterable, iteratee, callback) {
1034          return fn(iterable, limit, iteratee, callback);
1035      };
1036  }
1037  
1038  // eachOf implementation optimized for array-likes
1039  function eachOfArrayLike(coll, iteratee, callback) {
1040      callback = once(callback || noop);
1041      var index = 0,
1042          completed = 0,
1043          length = coll.length;
1044      if (length === 0) {
1045          callback(null);
1046      }
1047  
1048      function iteratorCallback(err, value) {
1049          if (err) {
1050              callback(err);
1051          } else if ((++completed === length) || value === breakLoop) {
1052              callback(null);
1053          }
1054      }
1055  
1056      for (; index < length; index++) {
1057          iteratee(coll[index], index, onlyOnce(iteratorCallback));
1058      }
1059  }
1060  
1061  // a generic version of eachOf which can handle array, object, and iterator cases.
1062  var eachOfGeneric = doLimit(eachOfLimit, Infinity);
1063  
1064  /**
1065   * Like [`each`]{@link module:Collections.each}, except that it passes the key (or index) as the second argument
1066   * to the iteratee.
1067   *
1068   * @name eachOf
1069   * @static
1070   * @memberOf module:Collections
1071   * @method
1072   * @alias forEachOf
1073   * @category Collection
1074   * @see [async.each]{@link module:Collections.each}
1075   * @param {Array|Iterable|Object} coll - A collection to iterate over.
1076   * @param {AsyncFunction} iteratee - A function to apply to each
1077   * item in `coll`.
1078   * The `key` is the item's key, or index in the case of an array.
1079   * Invoked with (item, key, callback).
1080   * @param {Function} [callback] - A callback which is called when all
1081   * `iteratee` functions have finished, or an error occurs. Invoked with (err).
1082   * @example
1083   *
1084   * var obj = {dev: "/dev.json", test: "/test.json", prod: "/prod.json"};
1085   * var configs = {};
1086   *
1087   * async.forEachOf(obj, function (value, key, callback) {
1088   *     fs.readFile(__dirname + value, "utf8", function (err, data) {
1089   *         if (err) return callback(err);
1090   *         try {
1091   *             configs[key] = JSON.parse(data);
1092   *         } catch (e) {
1093   *             return callback(e);
1094   *         }
1095   *         callback();
1096   *     });
1097   * }, function (err) {
1098   *     if (err) console.error(err.message);
1099   *     // configs is now a map of JSON data
1100   *     doSomethingWith(configs);
1101   * });
1102   */
1103  var eachOf = function(coll, iteratee, callback) {
1104      var eachOfImplementation = isArrayLike(coll) ? eachOfArrayLike : eachOfGeneric;
1105      eachOfImplementation(coll, wrapAsync(iteratee), callback);
1106  };
1107  
1108  function doParallel(fn) {
1109      return function (obj, iteratee, callback) {
1110          return fn(eachOf, obj, wrapAsync(iteratee), callback);
1111      };
1112  }
1113  
1114  function _asyncMap(eachfn, arr, iteratee, callback) {
1115      callback = callback || noop;
1116      arr = arr || [];
1117      var results = [];
1118      var counter = 0;
1119      var _iteratee = wrapAsync(iteratee);
1120  
1121      eachfn(arr, function (value, _, callback) {
1122          var index = counter++;
1123          _iteratee(value, function (err, v) {
1124              results[index] = v;
1125              callback(err);
1126          });
1127      }, function (err) {
1128          callback(err, results);
1129      });
1130  }
1131  
1132  /**
1133   * Produces a new collection of values by mapping each value in `coll` through
1134   * the `iteratee` function. The `iteratee` is called with an item from `coll`
1135   * and a callback for when it has finished processing. Each of these callback
1136   * takes 2 arguments: an `error`, and the transformed item from `coll`. If
1137   * `iteratee` passes an error to its callback, the main `callback` (for the
1138   * `map` function) is immediately called with the error.
1139   *
1140   * Note, that since this function applies the `iteratee` to each item in
1141   * parallel, there is no guarantee that the `iteratee` functions will complete
1142   * in order. However, the results array will be in the same order as the
1143   * original `coll`.
1144   *
1145   * If `map` is passed an Object, the results will be an Array.  The results
1146   * will roughly be in the order of the original Objects' keys (but this can
1147   * vary across JavaScript engines).
1148   *
1149   * @name map
1150   * @static
1151   * @memberOf module:Collections
1152   * @method
1153   * @category Collection
1154   * @param {Array|Iterable|Object} coll - A collection to iterate over.
1155   * @param {AsyncFunction} iteratee - An async function to apply to each item in
1156   * `coll`.
1157   * The iteratee should complete with the transformed item.
1158   * Invoked with (item, callback).
1159   * @param {Function} [callback] - A callback which is called when all `iteratee`
1160   * functions have finished, or an error occurs. Results is an Array of the
1161   * transformed items from the `coll`. Invoked with (err, results).
1162   * @example
1163   *
1164   * async.map(['file1','file2','file3'], fs.stat, function(err, results) {
1165   *     // results is now an array of stats for each file
1166   * });
1167   */
1168  var map = doParallel(_asyncMap);
1169  
1170  /**
1171   * Applies the provided arguments to each function in the array, calling
1172   * `callback` after all functions have completed. If you only provide the first
1173   * argument, `fns`, then it will return a function which lets you pass in the
1174   * arguments as if it were a single function call. If more arguments are
1175   * provided, `callback` is required while `args` is still optional.
1176   *
1177   * @name applyEach
1178   * @static
1179   * @memberOf module:ControlFlow
1180   * @method
1181   * @category Control Flow
1182   * @param {Array|Iterable|Object} fns - A collection of {@link AsyncFunction}s
1183   * to all call with the same arguments
1184   * @param {...*} [args] - any number of separate arguments to pass to the
1185   * function.
1186   * @param {Function} [callback] - the final argument should be the callback,
1187   * called when all functions have completed processing.
1188   * @returns {Function} - If only the first argument, `fns`, is provided, it will
1189   * return a function which lets you pass in the arguments as if it were a single
1190   * function call. The signature is `(..args, callback)`. If invoked with any
1191   * arguments, `callback` is required.
1192   * @example
1193   *
1194   * async.applyEach([enableSearch, updateSchema], 'bucket', callback);
1195   *
1196   * // partial application example:
1197   * async.each(
1198   *     buckets,
1199   *     async.applyEach([enableSearch, updateSchema]),
1200   *     callback
1201   * );
1202   */
1203  var applyEach = applyEach$1(map);
1204  
1205  function doParallelLimit(fn) {
1206      return function (obj, limit, iteratee, callback) {
1207          return fn(_eachOfLimit(limit), obj, wrapAsync(iteratee), callback);
1208      };
1209  }
1210  
1211  /**
1212   * The same as [`map`]{@link module:Collections.map} but runs a maximum of `limit` async operations at a time.
1213   *
1214   * @name mapLimit
1215   * @static
1216   * @memberOf module:Collections
1217   * @method
1218   * @see [async.map]{@link module:Collections.map}
1219   * @category Collection
1220   * @param {Array|Iterable|Object} coll - A collection to iterate over.
1221   * @param {number} limit - The maximum number of async operations at a time.
1222   * @param {AsyncFunction} iteratee - An async function to apply to each item in
1223   * `coll`.
1224   * The iteratee should complete with the transformed item.
1225   * Invoked with (item, callback).
1226   * @param {Function} [callback] - A callback which is called when all `iteratee`
1227   * functions have finished, or an error occurs. Results is an array of the
1228   * transformed items from the `coll`. Invoked with (err, results).
1229   */
1230  var mapLimit = doParallelLimit(_asyncMap);
1231  
1232  /**
1233   * The same as [`map`]{@link module:Collections.map} but runs only a single async operation at a time.
1234   *
1235   * @name mapSeries
1236   * @static
1237   * @memberOf module:Collections
1238   * @method
1239   * @see [async.map]{@link module:Collections.map}
1240   * @category Collection
1241   * @param {Array|Iterable|Object} coll - A collection to iterate over.
1242   * @param {AsyncFunction} iteratee - An async function to apply to each item in
1243   * `coll`.
1244   * The iteratee should complete with the transformed item.
1245   * Invoked with (item, callback).
1246   * @param {Function} [callback] - A callback which is called when all `iteratee`
1247   * functions have finished, or an error occurs. Results is an array of the
1248   * transformed items from the `coll`. Invoked with (err, results).
1249   */
1250  var mapSeries = doLimit(mapLimit, 1);
1251  
1252  /**
1253   * The same as [`applyEach`]{@link module:ControlFlow.applyEach} but runs only a single async operation at a time.
1254   *
1255   * @name applyEachSeries
1256   * @static
1257   * @memberOf module:ControlFlow
1258   * @method
1259   * @see [async.applyEach]{@link module:ControlFlow.applyEach}
1260   * @category Control Flow
1261   * @param {Array|Iterable|Object} fns - A collection of {@link AsyncFunction}s to all
1262   * call with the same arguments
1263   * @param {...*} [args] - any number of separate arguments to pass to the
1264   * function.
1265   * @param {Function} [callback] - the final argument should be the callback,
1266   * called when all functions have completed processing.
1267   * @returns {Function} - If only the first argument is provided, it will return
1268   * a function which lets you pass in the arguments as if it were a single
1269   * function call.
1270   */
1271  var applyEachSeries = applyEach$1(mapSeries);
1272  
1273  /**
1274   * A specialized version of `_.forEach` for arrays without support for
1275   * iteratee shorthands.
1276   *
1277   * @private
1278   * @param {Array} [array] The array to iterate over.
1279   * @param {Function} iteratee The function invoked per iteration.
1280   * @returns {Array} Returns `array`.
1281   */
1282  function arrayEach(array, iteratee) {
1283    var index = -1,
1284        length = array == null ? 0 : array.length;
1285  
1286    while (++index < length) {
1287      if (iteratee(array[index], index, array) === false) {
1288        break;
1289      }
1290    }
1291    return array;
1292  }
1293  
1294  /**
1295   * Creates a base function for methods like `_.forIn` and `_.forOwn`.
1296   *
1297   * @private
1298   * @param {boolean} [fromRight] Specify iterating from right to left.
1299   * @returns {Function} Returns the new base function.
1300   */
1301  function createBaseFor(fromRight) {
1302    return function(object, iteratee, keysFunc) {
1303      var index = -1,
1304          iterable = Object(object),
1305          props = keysFunc(object),
1306          length = props.length;
1307  
1308      while (length--) {
1309        var key = props[fromRight ? length : ++index];
1310        if (iteratee(iterable[key], key, iterable) === false) {
1311          break;
1312        }
1313      }
1314      return object;
1315    };
1316  }
1317  
1318  /**
1319   * The base implementation of `baseForOwn` which iterates over `object`
1320   * properties returned by `keysFunc` and invokes `iteratee` for each property.
1321   * Iteratee functions may exit iteration early by explicitly returning `false`.
1322   *
1323   * @private
1324   * @param {Object} object The object to iterate over.
1325   * @param {Function} iteratee The function invoked per iteration.
1326   * @param {Function} keysFunc The function to get the keys of `object`.
1327   * @returns {Object} Returns `object`.
1328   */
1329  var baseFor = createBaseFor();
1330  
1331  /**
1332   * The base implementation of `_.forOwn` without support for iteratee shorthands.
1333   *
1334   * @private
1335   * @param {Object} object The object to iterate over.
1336   * @param {Function} iteratee The function invoked per iteration.
1337   * @returns {Object} Returns `object`.
1338   */
1339  function baseForOwn(object, iteratee) {
1340    return object && baseFor(object, iteratee, keys);
1341  }
1342  
1343  /**
1344   * The base implementation of `_.findIndex` and `_.findLastIndex` without
1345   * support for iteratee shorthands.
1346   *
1347   * @private
1348   * @param {Array} array The array to inspect.
1349   * @param {Function} predicate The function invoked per iteration.
1350   * @param {number} fromIndex The index to search from.
1351   * @param {boolean} [fromRight] Specify iterating from right to left.
1352   * @returns {number} Returns the index of the matched value, else `-1`.
1353   */
1354  function baseFindIndex(array, predicate, fromIndex, fromRight) {
1355    var length = array.length,
1356        index = fromIndex + (fromRight ? 1 : -1);
1357  
1358    while ((fromRight ? index-- : ++index < length)) {
1359      if (predicate(array[index], index, array)) {
1360        return index;
1361      }
1362    }
1363    return -1;
1364  }
1365  
1366  /**
1367   * The base implementation of `_.isNaN` without support for number objects.
1368   *
1369   * @private
1370   * @param {*} value The value to check.
1371   * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.
1372   */
1373  function baseIsNaN(value) {
1374    return value !== value;
1375  }
1376  
1377  /**
1378   * A specialized version of `_.indexOf` which performs strict equality
1379   * comparisons of values, i.e. `===`.
1380   *
1381   * @private
1382   * @param {Array} array The array to inspect.
1383   * @param {*} value The value to search for.
1384   * @param {number} fromIndex The index to search from.
1385   * @returns {number} Returns the index of the matched value, else `-1`.
1386   */
1387  function strictIndexOf(array, value, fromIndex) {
1388    var index = fromIndex - 1,
1389        length = array.length;
1390  
1391    while (++index < length) {
1392      if (array[index] === value) {
1393        return index;
1394      }
1395    }
1396    return -1;
1397  }
1398  
1399  /**
1400   * The base implementation of `_.indexOf` without `fromIndex` bounds checks.
1401   *
1402   * @private
1403   * @param {Array} array The array to inspect.
1404   * @param {*} value The value to search for.
1405   * @param {number} fromIndex The index to search from.
1406   * @returns {number} Returns the index of the matched value, else `-1`.
1407   */
1408  function baseIndexOf(array, value, fromIndex) {
1409    return value === value

1512  
1513      var listeners = Object.create(null);
1514  
1515      var readyTasks = [];
1516  
1517      // for cycle detection:
1518      var readyToCheck = []; // tasks that have been identified as reachable
1519      // without the possibility of returning to an ancestor task
1520      var uncheckedDependencies = {};
1521  
1522      baseForOwn(tasks, function (task, key) {
1523          if (!isArray(task)) {
1524              // no dependencies
1525              enqueueTask(key, [task]);
1526              readyToCheck.push(key);
1527              return;
1528          }
1529  
1530          var dependencies = task.slice(0, task.length - 1);
1531          var remainingDependencies = dependencies.length;
1532          if (remainingDependencies === 0) {
1533              enqueueTask(key, task);
1534              readyToCheck.push(key);
1535              return;
1536          }
1537          uncheckedDependencies[key] = remainingDependencies;
1538  
1539          arrayEach(dependencies, function (dependencyName) {
1540              if (!tasks[dependencyName]) {
1541                  throw new Error('async.auto task `' + key +
1542                      '` has a non-existent dependency `' +
1543                      dependencyName + '` in ' +
1544                      dependencies.join(', '));
1545              }
1546              addListener(dependencyName, function () {
1547                  remainingDependencies--;
1548                  if (remainingDependencies === 0) {
1549                      enqueueTask(key, task);
1550                  }
1551              });
1552          });
1553      });
1554  
1555      checkForDeadlocks();
1556      processQueue();
1557  
1558      function enqueueTask(key, task) {
1559          readyTasks.push(function () {
1560              runTask(key, task);
1561          });
1562      }
1563  
1564      function processQueue() {
1565          if (readyTasks.length === 0 && runningTasks === 0) {
1566              return callback(null, results);
1567          }
1568          while(readyTasks.length && runningTasks < concurrency) {
1569              var run = readyTasks.shift();
1570              run();
1571          }
1572  
1573      }
1574  
1575      function addListener(taskName, fn) {
1576          var taskListeners = listeners[taskName];
1577          if (!taskListeners) {
1578              taskListeners = listeners[taskName] = [];
1579          }
1580  
1581          taskListeners.push(fn);
1582      }
1583  
1584      function taskComplete(taskName) {
1585          var taskListeners = listeners[taskName] || [];
1586          arrayEach(taskListeners, function (fn) {
1587              fn();
1588          });
1589          processQueue();
1590      }
1591  
1592  
1593      function runTask(key, task) {
1594          if (hasError) return;
1595  
1596          var taskCallback = onlyOnce(function(err, result) {
1597              runningTasks--;
1598              if (arguments.length > 2) {
1599                  result = slice(arguments, 1);
1600              }
1601              if (err) {
1602                  var safeResults = {};
1603                  baseForOwn(results, function(val, rkey) {
1604                      safeResults[rkey] = val;
1605                  });
1606                  safeResults[key] = result;
1607                  hasError = true;
1608                  listeners = Object.create(null);
1609  
1610                  callback(err, safeResults);
1611              } else {
1612                  results[key] = result;
1613                  taskComplete(key);
1614              }
1615          });
1616  
1617          runningTasks++;
1618          var taskFn = wrapAsync(task[task.length - 1]);
1619          if (task.length > 1) {
1620              taskFn(results, taskCallback);
1621          } else {
1622              taskFn(taskCallback);
1623          }
1624      }
1625  
1626      function checkForDeadlocks() {
1627          // Kahn's algorithm
1628          // https://en.wikipedia.org/wiki/Topological_sorting#Kahn.27s_algorithm
1629          // http://connalle.blogspot.com/2013/10/topological-sortingkahn-algorithm.html
1630          var currentTask;
1631          var counter = 0;
1632          while (readyToCheck.length) {
1633              currentTask = readyToCheck.pop();
1634              counter++;
1635              arrayEach(getDependents(currentTask), function (dependent) {
1636                  if (--uncheckedDependencies[dependent] === 0) {
1637                      readyToCheck.push(dependent);
1638                  }
1639              });
1640          }
1641  
1642          if (counter !== numTasks) {
1643              throw new Error(
1644                  'async.auto cannot execute tasks due to a recursive dependency'
1645              );
1646          }
1647      }
1648  
1649      function getDependents(taskName) {
1650          var result = [];
1651          baseForOwn(tasks, function (task, key) {
1652              if (isArray(task) && baseIndexOf(task, taskName, 0) >= 0) {
1653                  result.push(key);
1654              }
1655          });
1656          return result;
1657      }
1658  };
1659  
1660  /**
1661   * A specialized version of `_.map` for arrays without support for iteratee
1662   * shorthands.
1663   *
1664   * @private
1665   * @param {Array} [array] The array to iterate over.
1666   * @param {Function} iteratee The function invoked per iteration.
1667   * @returns {Array} Returns the new mapped array.

1668   */
1669  function arrayMap(array, iteratee) {
1670    var index = -1,
1671        length = array == null ? 0 : array.length,
1672        result = Array(length);
1673  
1674    while (++index < length) {
1675      result[index] = iteratee(array[index], index, array);
1676    }
1677    return result;
1678  }
1679  
1680  /** `Object#toString` result references. */
1681  var symbolTag = '[object Symbol]';
1682  
1683  /**
1684   * Checks if `value` is classified as a `Symbol` primitive or object.
1685   *
1686   * @static
1687   * @memberOf _
1688   * @since 4.0.0
1689   * @category Lang
1690   * @param {*} value The value to check.
1691   * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
1692   * @example
1693   *
1694   * _.isSymbol(Symbol.iterator);
1695   * // => true
1696   *
1697   * _.isSymbol('abc');
1698   * // => false
1699   */
1700  function isSymbol(value) {
1701    return typeof value == 'symbol' ||
1702      (isObjectLike(value) && baseGetTag(value) == symbolTag);
1703  }
1704  
1705  /** Used as references for various `Number` constants. */
1706  var INFINITY = 1 / 0;
1707  
1708  /** Used to convert symbols to primitives and strings. */
1709  var symbolProto = Symbol$1 ? Symbol$1.prototype : undefined;
1710  var symbolToString = symbolProto ? symbolProto.toString : undefined;
1711  
1712  /**
1713   * The base implementation of `_.toString` which doesn't convert nullish
1714   * values to empty strings.
1715   *
1716   * @private
1717   * @param {*} value The value to process.
1718   * @returns {string} Returns the string.
1719   */
1720  function baseToString(value) {
1721    // Exit early for strings to avoid a performance hit in some environments.
1722    if (typeof value == 'string') {
1723      return value;
1724    }
1725    if (isArray(value)) {
1726      // Recursively convert values (susceptible to call stack limits).
1727      return arrayMap(value, baseToString) + '';
1728    }
1729    if (isSymbol(value)) {
1730      return symbolToString ? symbolToString.call(value) : '';
1731    }
1732    var result = (value + '');
1733    return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;
1734  }
1735  
1736  /**
1737   * The base implementation of `_.slice` without an iteratee call guard.
1738   *
1739   * @private
1740   * @param {Array} array The array to slice.
1741   * @param {number} [start=0] The start position.
1742   * @param {number} [end=array.length] The end position.
1743   * @returns {Array} Returns the slice of `array`.
1744   */
1745  function baseSlice(array, start, end) {
1746    var index = -1,
1747        length = array.length;
1748  
1749    if (start < 0) {
1750      start = -start > length ? 0 : (length + start);
1751    }
1752    end = end > length ? length : end;
1753    if (end < 0) {
1754      end += length;
1755    }
1756    length = start > end ? 0 : ((end - start) >>> 0);
1757    start >>>= 0;
1758  
1759    var result = Array(length);
1760    while (++index < length) {
1761      result[index] = array[index + start];
1762    }
1763    return result;
1764  }
1765  
1766  /**
1767   * Casts `array` to a slice if it's needed.
1768   *
1769   * @private
1770   * @param {Array} array The array to inspect.
1771   * @param {number} start The start position.
1772   * @param {number} [end=array.length] The end position.
1773   * @returns {Array} Returns the cast slice.
1774   */
1775  function castSlice(array, start, end) {
1776    var length = array.length;
1777    end = end === undefined ? length : end;
1778    return (!start && end >= length) ? array : baseSlice(array, start, end);
1779  }
1780  
1781  /**
1782   * Used by `_.trim` and `_.trimEnd` to get the index of the last string symbol
1783   * that is not found in the character symbols.
1784   *
1785   * @private
1786   * @param {Array} strSymbols The string symbols to inspect.
1787   * @param {Array} chrSymbols The character symbols to find.
1788   * @returns {number} Returns the index of the last unmatched string symbol.
1789   */
1790  function charsEndIndex(strSymbols, chrSymbols) {
1791    var index = strSymbols.length;
1792  
1793    while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}
1794    return index;
1795  }
1796  
1797  /**
1798   * Used by `_.trim` and `_.trimStart` to get the index of the first string symbol
1799   * that is not found in the character symbols.
1800   *
1801   * @private
1802   * @param {Array} strSymbols The string symbols to inspect.
1803   * @param {Array} chrSymbols The character symbols to find.
1804   * @returns {number} Returns the index of the first unmatched string symbol.
1805   */
1806  function charsStartIndex(strSymbols, chrSymbols) {
1807    var index = -1,
1808        length = strSymbols.length;
1809  
1810    while (++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0

1810) > -1) {}
1811    return index;
1812  }
1813  
1814  /**
1815   * Converts an ASCII `string` to an array.
1816   *
1817   * @private
1818   * @param {string} string The string to convert.
1819   * @returns {Array} Returns the converted array.
1820   */
1821  function asciiToArray(string) {
1822    return string.split('');
1823  }
1824  
1825  /** Used to compose unicode character classes. */
1826  var rsAstralRange = '\\ud800-\\udfff';
1827  var rsComboMarksRange = '\\u0300-\\u036f';
1828  var reComboHalfMarksRange = '\\ufe20-\\ufe2f';
1829  var rsComboSymbolsRange = '\\u20d0-\\u20ff';
1830  var rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange;
1831  var rsVarRange = '\\ufe0e\\ufe0f';
1832  
1833  /** Used to compose unicode capture groups. */
1834  var rsZWJ = '\\u200d';
1835  
1836  /** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */
1837  var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange  + rsComboRange + rsVarRange + ']');
1838  
1839  /**
1840   * Checks if `string` contains Unicode symbols.
1841   *
1842   * @private
1843   * @param {string} string The string to inspect.
1844   * @returns {boolean} Returns `true` if a symbol is found, else `false`.
1845   */
1846  function hasUnicode(string) {
1847    return reHasUnicode.test(string);
1848  }
1849  
1850  /** Used to compose unicode character classes. */
1851  var rsAstralRange$1 = '\\ud800-\\udfff';
1852  var rsComboMarksRange$1 = '\\u0300-\\u036f';
1853  var reComboHalfMarksRange$1 = '\\ufe20-\\ufe2f';
1854  var rsComboSymbolsRange$1 = '\\u20d0-\\u20ff';
1855  var rsComboRange$1 = rsComboMarksRange$1 + reComboHalfMarksRange$1 + rsComboSymbolsRange$1;
1856  var rsVarRange$1 = '\\ufe0e\\ufe0f';
1857  
1858  /** Used to compose unicode capture groups. */
1859  var rsAstral = '[' + rsAstralRange$1 + ']';
1860  var rsCombo = '[' + rsComboRange$1 + ']';
1861  var rsFitz = '\\ud83c[\\udffb-\\udfff]';
1862  var rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')';
1863  var rsNonAstral = '[^' + rsAstralRange$1 + ']';
1864  var rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}';
1865  var rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]';
1866  var rsZWJ$1 = '\\u200d';
1867  
1868  /** Used to compose unicode regexes. */
1869  var reOptMod = rsModifier + '?';
1870  var rsOptVar = '[' + rsVarRange$1 + ']?';
1871  var rsOptJoin = '(?:' + rsZWJ$1 + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*';
1872  var rsSeq = rsOptVar + reOptMod + rsOptJoin;
1873  var rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';
1874  
1875  /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */
1876  var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');
1877  
1878  /**
1879   * Converts a Unicode `string` to an array.
1880   *
1881   * @private
1882   * @param {string} string The string to convert.
1883   * @returns {Array} Returns the converted array.
1884   */
1885  function unicodeToArray(string) {
1886    return string.match(reUnicode) || [];
1887  }
1888  
1889  /**
1890   * Converts `string` to an array.
1891   *
1892   * @private
1893   * @param {string} string The string to convert.
1894   * @returns {Array} Returns the converted array.
1895   */
1896  function stringToArray(string) {
1897    return hasUnicode(string)
1898      ? unicodeToArray(string)
1899      : asciiToArray(string);
1900  }
1901  
1902  /**
1903   * Converts `value` to a string. An empty string is returned for `null`
1904   * and `undefined` values. The sign of `-0` is preserved.
1905   *
1906   * @static
1907   * @memberOf _
1908   * @since 4.0.0
1909   * @category Lang
1910   * @param {*} value The value to convert.
1911   * @returns {string} Returns the converted string.
1912   * @example
1913   *
1914   * _.toString(null);
1915   * // => ''
1916   *
1917   * _.toString(-0);
1918   * // => '-0'
1919   *
1920   * _.toString([1, 2, 3]);
1921   * // => '1,2,3'
1922   */
1923  function toString(value) {
1924    return value == null ? '' : baseToString(value);
1925  }
1926  
1927  /** Used to match leading and trailing whitespace. */
1928  var reTrim = /^\s+|\s+$/g;
1929  
1930  /**
1931   * Removes leading and trailing whitespace or specified characters from `string`.
1932   *
1933   * @static
1934   * @memberOf _
1935   * @since 3.0.0
1936   * @category String
1937   * @param {string} [string=''] The string to trim.
1938   * @param {string} [chars=whitespace] The characters to trim.
1939   * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.
1940   * @returns {string} Returns the trimmed string.
1941   * @example
1942   *
1943   * _.trim('  abc  ');
1944   * // => 'abc'
1945   *
1946   * _.trim('-_-abc-_-', '_-');
1947   * // => 'abc'
1948   *
1949   * _.map(['  foo  ', '  bar  '], _.trim);
1950   * // => ['foo', 'bar']
1951   */
1952  function trim(string, chars, guard) {
1953    string = toString(string);
1954    if (string && (guard || chars === undefined)) {
1955      return string.replace(reTrim, '');
1956    }
1957    if (!string || !(chars = baseToString(chars))) {
1958      return string;
1959    }
1960    var strSymbols = stringToArray(string),
1961        chrSymbols = stringToArray(chars),
1962        start = charsStartIndex(strSymbols, chrSymbols),
1963        end = charsEndIndex(strSymbols, chrSymbols) + 1;
1964  
1965    return castSlice(strSymbols, start, end).join('');
1966  }
1967  
1968  var FN_ARGS = /^(?:async\s+)?(function)?\s*[^\(]*\(\s*([^\)]*)\)/m;
1969  var FN_ARG_SPLIT = /,/;
1970  var FN_ARG = /(=.+)?(\s*)$/;
1971  var STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;
1972  
1973  function parseParams(func) {
1974      func = func.toString().replace(STRIP_COMMENTS, '');
1975      func = func.match(FN_ARGS)[2].replace(' ', '');
1976      func = func ? func.split(FN_ARG_SPLIT) : [];
1977      func = func.map(function (arg){
1978          return trim(arg.replace(FN_ARG, ''));
1979      });
1980      return func;
1981  }
1982  
1983  /**
1984   * A dependency-injected version of the [async.auto]{@link module:ControlFlow.auto} function. Dependent
1985   * tasks are specified as parameters to the function, after the usual callback
1986   * parameter, with the parameter names matching the names of the tasks it
1987   * depends on. This can provide even more readable task graphs which can be
1988   * easier to maintain.
1989   *
1990   * If a final callback is specified, the task results are similarly injected,
1991   * specified as named parameters after the initial error parameter.
1992   *
1993   * The autoInject function is purely syntactic sugar and its semantics are
1994   * otherwise equivalent to [async.auto]{@link module:ControlFlow.auto}.
1995   *
1996   * @name autoInject
1997   * @static
1998   * @memberOf module:ControlFlow
1999   * @method
2000   * @see [async.auto]{@link module:ControlFlow.auto}
2001   * @category Control Flow
2002   * @param {Object} tasks - An object, each of whose properties is an {@link AsyncFunction} of
2003   * the form 'func([dependencies...], callback). The object's key of a property
2004   * serves as the name of the task defined by that property, i.e. can be used
2005   * when specifying requirements for other tasks.
2006   * * The `callback` parameter is a `callback(err, result)` which must be called
2007   *   when finished, passing an `error` (which can be `null`) and the result of
2008   *   the function's execution. The remaining parameters name other tasks on
2009   *   which the task is dependent, and the results from those tasks are the
2010   *   arguments of those parameters.
2011   * @param {Function} [callback] - An optional callback which is called when all
2012   * the tasks have been completed. It receives the `err` argument if any `tasks`
2013   * pass an error to their callback, and a `results` object with any completed
2014   * task results, similar to `auto`.
2015   * @example
2016   *
2017   * //  The example from `auto` can be rewritten as follows:
2018   * async.autoInject({
2019   *     get_data: function(callback) {
2020   *         // async code to get some data
2021   *         callback(null, 'data', 'converted to array');
2022   *     },
2023   *     make_folder: function(callback) {
2024   *         // async code to create a directory to store a file in
2025   *         // this is run at the same time as getting the data
2026   *         callback(null, 'folder');
2027   *     },
2028   *     write_file: function(get_data, make_folder, callback) {
2029   *         // once there is some data and the directory exists,
2030   *         // write the data to a file in the directory
2031   *         callback(null, 'filename');
2032   *     },
2033   *     email_link: function(write_file, callback) {
2034   *         // once the file is written let's email a link to it...
2035   *         // write_file contains the filename returned by write_file.
2036   *         callback(null, {'file':write_file, 'email':'[email protected]'});
2037   *     }
2038   * }, function(err, results) {
2039   *     console.log('err = ', err);
2040   *     console.log('email_link = ', results.email_link);
2041   * });
2042   *
2043   * // If you are using a JS minifier that mangles parameter names, `autoInject`
2044   * // will not work with plain functions, since the parameter names will be
2045   * // collapsed to a single letter identifier.  To work around this, you can
2046   * // explicitly specify the names of the parameters your task function needs
2047   * // in an array, similar to Angular.js dependency injection.
2048   *
2049   * // This still has an advantage over plain `auto`, since the results a task
2050   * // depends on are still spread into arguments.
2051   * async.autoInject({
2052   *     //...
2053   *     write_file: ['get_data', 'make_folder', function(get_data, make_folder, callback) {
2054   *         callback(null, 'filename');
2055   *     }],
2056   *     email_link: ['write_file', function(write_file, callback) {
2057   *         callback(null, {'file':write_file, 'email':'[email protected]'});
2058   *     }]
2059   *     //...
2060   * }, function(err, results) {
2061   *     console.log('err = ', err);
2062   *     console.log('email_link = ', results.email_link);
2063   * });
2064   */
2065  function autoInject(tasks, callback) {
2066      var newTasks = {};
2067  
2068      baseForOwn(tasks, function (taskFn, key) {
2069          var params;
2070          var fnIsAsync = isAsync(taskFn);
2071          var hasNoDeps =
2072              (!fnIsAsync && taskFn.length === 1) ||
2073              (fnIsAsync && taskFn.length === 0);
2074  
2075          if (isArray(taskFn)) {
2076              params = taskFn.slice(0, -1);
2077              taskFn = taskFn[taskFn.length - 1];
2078  
2079              newTasks[key] = params.concat(params.length > 0 ? newTask : taskFn);
2080          } else if (hasNoDeps) {
2081              // no dependencies, use the function as-is
2082              newTasks[key] = taskFn;
2083          } else {
2084              params = parseParams(taskFn);
2085              if (taskFn.length === 0 && !fnIsAsync && params.length === 0) {
2086                  throw new Error("autoInject task functions require explicit parameters.");
2087              }
2088  
2089              // remove callback param
2090              if (!fnIsAsync) params.pop();
2091  
2092              newTasks[key] = params.concat(newTask);
2093          }
2094  
2095          function newTask(results, taskCb) {
2096              var newArgs = arrayMap(params, function (name) {
2097                  return results[name];
2098              });
2099              newArgs.push(taskCb);
2100              wrapAsync(taskFn).apply(null, newArgs);
2101          }
2102      });
2103  
2104      auto(newTasks, callback);
2105  }
2106  
2107  // Simple doubly linked list (https://en.wikipedia.org/wiki/Doubly_linked_list) implementation
2108  // used for queues. This implementation assumes that the node provided by the user can be modified
2109  // to adjust the next and last properties. We implement only the minimal functionality
2110  // for queue support.
2111  function DLL() {
2112      this.head = this.tail = null;
2113      this.length = 0;
2114  }
2115  
2116  function setInitial(dll, node) {
2117      dll.length = 1;
2118      dll.head = dll.tail = node;
2119  }
2120  
2121  DLL.prototype.removeLink = function(node) {
2122      if (node.prev) node.prev.next = node.next;
2123      else this.head = node.next;
2124      if (node.next) node.next.prev = node.prev;
2125      else this.tail = node.prev;
2126  
2127      node.prev = node.next = null;
2128      this.length -= 1;
2129      return node;
2130  };
2131  
2132  DLL.prototype.empty = function () {
2133      while(this.head) this.shift();
2134      return this;
2135  };
2136  
2137  DLL.prototype.insertAfter = function(node, newNode) {
2138      newNode.prev = node;
2139      newNode.next = node.next;
2140      if (node.next) node.next.prev = newNode;
2141      else this.tail = newNode;
2142      node.next = newNode;
2143      this.length += 1;
2144  };
2145  
2146  DLL.prototype.insertBefore = function(node, newNode) {
2147      newNode.prev = node.prev;
2148      newNode.next = node;
2149      if (node.prev) node.prev.next = newNode;
2150      else this.head = newNode;
2151      node.prev = newNode;
2152      this.length += 1;
2153  };
2154  
2155  DLL.prototype.unshift = function(node) {
2156      if (this.head) this.insertBefore(this.head, node);
2157      else setInitial(this, node);
2158  };
2159  
2160  DLL.prototype.push = function(node) {
2161      if (this.tail) this.insertAfter(this.tail, node);
2162      else setInitial(this, node);
2163  };
2164  
2165  DLL.prototype.shift = function() {
2166      return this.head && this.removeLink(this.head);
2167  };
2168  
2169  DLL.prototype.pop = function() {
2170      return this.tail && this.removeLink(this.tail);
2171  };
2172  
2173  DLL.prototype.toArray = function () {
2174      var arr = Array(this.length);
2175      var curr = this.head;
2176      for(var idx = 0; idx < this.length; idx++) {
2177          arr[idx] = curr.data;
2178          curr = curr.next;
2179      }
2180      return arr;
2181  };
2182  
2183  DLL.prototype.remove = function (testFn) {
2184      var curr = this.head;
2185      while(!!curr) {
2186          var next = curr.next;
2187          if (testFn(curr)) {
2188              this.removeLink(curr);
2189          }
2190          curr = next;
2191      }
2192      return this;
2193  };
2194  
2195  function queue(worker, concurrency, payload) {
2196      if (concurrency == null) {
2197          concurrency = 1;
2198      }
2199      else if(concurrency === 0) {
2200          throw new Error('Concurrency must not be zero');
2201      }
2202  
2203      var _worker = wrapAsync(worker);
2204      var numRunning = 0;
2205      var workersList = [];
2206  
2207      var processingScheduled = false;
2208      function _insert(data, insertAtFront, callback) {
2209          if (callback != null && typeof callback !== 'function') {
2210              throw new Error('task callback must be a function');
2211          }
2212          q.started = true;
2213          if (!isArray(data)) {
2214              data = [data];
2215          }
2216          if (data.length === 0 && q.idle()) {
2217              // call drain immediately if there are no tasks
2218              return setImmediate$1(function() {
2219                  q.drain();
2220              });
2221          }
2222  
2223          for (var i = 0, l = data.length; i < l; i++) {
2224              var item = {
2225                  data: data[i],
2226                  callback: callback || noop
2227              };
2228  
2229              if (insertAtFront) {
2230                  q._tasks.unshift(item);
2231              } else {
2232                  q._tasks.push(item);
2233              }
2234          }
2235  
2236          if (!processingScheduled) {
2237              processingScheduled = true;
2238              setImmediate$1(function() {
2239                  processingScheduled = false;
2240                  q.process();
2241              });
2242          }
2243      }
2244  
2245      function _next(tasks) {
2246          return function(err){
2247              numRunning -= 1;
2248  
2249              for (var i = 0, l = tasks.length; i < l; i++) {
2250                  var task = tasks[i];
2251  
2252                  var index = baseIndexOf(workersList, task, 0);
2253                  if (index === 0) {
2254                      workersList.shift();
2255                  } else if (index > 0) {
2256                      workersList.splice(index, 1);
2257                  }
2258  
2259                  task.callback.apply(task, arguments);
2260  
2261                  if (err != null) {
2262                      q.error(err, task.data);
2263                  }
2264              }
2265  
2266              if (numRunning <= (q.concurrency - q.buffer) ) {
2267                  q.unsaturated();
2268              }
2269  
2270              if (q.idle()) {
2271                  q.drain();
2272              }
2273              q.process();
2274          };
2275      }
2276  
2277      var isProcessing = false;
2278      var q = {
2279          _tasks: new DLL(),
2280          concurrency: concurrency,
2281          payload: payload,
2282          saturated: noop,
2283          unsaturated:noop,
2284          buffer: concurrency / 4,
2285          empty: noop,
2286          drain: noop,
2287          error: noop,
2288          started: false,
2289          paused: false,
2290          push: function (data, callback) {
2291              _insert(data, false, callback);
2292          },
2293          kill: function () {
2294              q.drain = noop;
2295              q._tasks.empty();
2296          },
2297          unshift: function (data, callback) {
2298              _insert(data, true, callback);
2299          },
2300          remove: function (testFn) {
2301              q._tasks.remove(testFn);
2302          },
2303          process: function () {
2304              // Avoid trying to start too many processing operations. This can occur
2305              // when callbacks resolve synchronously (#1267).
2306              if (isProcessing) {
2307                  return;
2308              }
2309              isProcessing = true;
2310              while(!q.paused && numRunning < q.concurrency && q._tasks.length){
2311                  var tasks = [], data = [];
2312                  var l = q._tasks.length;
2313                  if (q.payload) l = Math.min(l, q.payload);
2314                  for (var i = 0; i < l; i++) {
2315                      var node = q._tasks.shift();
2316                      tasks.push(node);
2317                      workersList.push(node);
2318                      data.push(node.data);
2319                  }
2320  
2321                  numRunning += 1;
2322  
2323                  if (q._tasks.length === 0) {
2324                      q.empty();
2325                  }
2326  
2327                  if (numRunning === q.concurrency) {
2328                      q.saturated();
2329                  }
2330  
2331                  var cb = onlyOnce(_next(tasks));
2332                  _worker(data, cb);
2333              }
2334              isProcessing = false;
2335          },
2336          length: function () {
2337              return q._tasks.length;
2338          },
2339          running: function () {
2340              return numRunning;
2341          },
2342          workersList: function () {
2343              return workersList;
2344          },
2345          idle: function() {
2346              return q._tasks.length + numRunning === 0;
2347          },
2348          pause: function () {
2349              q.paused = true;
2350          },
2351          resume: function () {
2352              if (q.paused === false) { return; }
2353              q.paused = false;
2354              setImmediate$1(q.process);
2355          }
2356      };
2357      return q;
2358  }
2359  
2360  /**
2361   * A cargo of tasks for the worker function to complete. Cargo inherits all of
2362   * the same methods and event callbacks as [`queue`]{@link module:ControlFlow.queue}.
2363   * @typedef {Object} CargoObject
2364   * @memberOf module:ControlFlow
2365   * @property {Function} length - A function returning the number of items
2366   * waiting to be processed. Invoke like `cargo.length()`.
2367   * @property {number} payload - An `integer` for determining how many tasks
2368   * should be process per round. This property can be changed after a `cargo` is
2369   * created to alter the payload on-the-fly.
2370   * @property {Function} push - Adds `task` to the `queue`. The callback is
2371   * called once the `worker` has finished processing the task. Instead of a
2372   * single task, an array of `tasks` can be submitted. The respective callback is
2373   * used for every task in the list. Invoke like `cargo.push(task, [callback])`.
2374   * @property {Function} saturated - A callback that is called when the
2375   * `queue.length()` hits the concurrency and further tasks will be queued.
2376   * @property {Function} empty - A callback that is called when the last item
2377   * from the `queue` is given to a `worker`.
2378   * @property {Function} drain - A callback that is called when the last item
2379   * from the `queue` has returned from the `worker`.
2380   * @property {Function} idle - a function returning false if there are items
2381   * waiting or being processed, or true if not. Invoke like `cargo.idle()`.
2382   * @property {Function} pause - a function that pauses the processing of tasks
2383   * until `resume()` is called. Invoke like `cargo.pause()`.
2384   * @property {Function} resume - a function that resumes the processing of
2385   * queued tasks when the queue is paused. Invoke like `cargo.resume()`.
2386   * @property {Function} kill - a function that removes the `drain` callback and
2387   * empties remaining tasks from the queue forcing it to go idle. Invoke like `cargo.kill()`.
2388   */
2389  
2390  /**
2391   * Creates a `cargo` object with the specified payload. Tasks added to the
2392   * cargo will be processed altogether (up to the `payload` limit). If the
2393   * `worker` is in progress, the task is queued until it becomes available. Once
2394   * the `worker` has completed some tasks, each callback of those tasks is
2395   * called. Check out [these](https://camo.githubusercontent.com/6bbd36f4cf5b35a0f11a96dcd2e97711ffc2fb37/68747470733a2f2f662e636c6f75642e676974687

2503      eachOfSeries(coll, function(x, i, callback) {
2504          _iteratee(memo, x, function(err, v) {
2505              memo = v;
2506              callback(err);
2507          });
2508      }, function(err) {
2509          callback(err, memo);
2510      });
2511  }
2512  
2513  /**
2514   * Version of the compose function that is more natural to read. Each function
2515   * consumes the return value of the previous function. It is the equivalent of
2516   * [compose]{@link module:ControlFlow.compose} with the arguments reversed.
2517   *
2518   * Each function is executed with the `this` binding of the composed function.
2519   *
2520   * @name seq
2521   * @static
2522   * @memberOf module:ControlFlow
2523   * @method
2524   * @see [async.compose]{@link module:ControlFlow.compose}
2525   * @category Control Flow
2526   * @param {...AsyncFunction} functions - the asynchronous functions to compose
2527   * @returns {Function} a function that composes the `functions` in order
2528   * @example
2529   *
2530   * // Requires lodash (or underscore), express3 and dresende's orm2.
2531   * // Part of an app, that fetches cats of the logged user.
2532   * // This example uses `seq` function to avoid overnesting and error
2533   * // handling clutter.
2534   * app.get('/cats', function(request, response) {
2535   *     var User = request.models.User;
2536   *     async.seq(
2537   *         _.bind(User.get, User),  // 'User.get' has signature (id, callback(err, data))
2538   *         function(user, fn) {
2539   *             user.getCats(fn);      // 'getCats' has signature (callback(err, data))
2540   *         }
2541   *     )(req.session.user_id, function (err, cats) {
2542   *         if (err) {
2543   *             console.error(err);
2544   *             response.json({ status: 'error', message: err.message });
2545   *         } else {
2546   *             response.json({ status: 'ok', message: 'Cats found', data: cats });
2547   *         }
2548   *     });
2549   * });
2550   */
2551  function seq(/*...functions*/) {
2552      var _functions = arrayMap(arguments, wrapAsync);
2553      return function(/*...args*/) {
2554          var args = slice(arguments);
2555          var that = this;
2556  
2557          var cb = args[args.length - 1];
2558          if (typeof cb == 'function') {
2559              args.pop();
2560          } else {
2561              cb = noop;
2562          }
2563  
2564          reduce(_functions, args, function(newargs, fn, cb) {
2565              fn.apply(that, newargs.concat(function(err/*, ...nextargs*/) {
2566                  var nextargs = slice(arguments, 1);
2567                  cb(err, nextargs);
2568              }));
2569          },
2570          function(err, results) {
2571              cb.apply(that, [err].concat(results));
2572          });
2573      };
2574  }
2575  
2576  /**
2577   * Creates a function which is a composition of the passed asynchronous
2578   * functions. Each function consumes the return value of the function that
2579   * follows. Composing functions `f()`, `g()`, and `h()` would produce the result
2580   * of `f(g(h()))`, only this version uses callbacks to obtain the return values.
2581   *
2582   * Each function is executed with the `this` binding of the composed function.
2583   *
2584   * @name compose
2585   * @static
2586   * @memberOf module:ControlFlow
2587   * @method
2588   * @category Control Flow
2589   * @param {...AsyncFunction} functions - the asynchronous functions to compose
2590   * @returns {Function} an asynchronous function that is the composed
2591   * asynchronous `functions`
2592   * @example
2593   *
2594   * function add1(n, callback) {
2595   *     setTimeout(function () {
2596   *         callback(null, n + 1);
2597   *     }, 10);
2598   * }
2599   *
2600   * function mul3(n, callback) {
2601   *     setTimeout(function () {
2602   *         callback(null, n * 3);
2603   *     }, 10);
2604   * }
2605   *
2606   * var add1mul3 = async.compose(mul3, add1);
2607   * add1mul3(4, function (err, result) {
2608   *     // result now equals 15
2609   * });
2610   */
2611  var compose = function(/*...args*/) {
2612      return seq.apply(null, slice(arguments).reverse());
2613  };
2614  
2615  var _concat = Array.prototype.concat;
2616  
2617  /**
2618   * The same as [`concat`]{@link module:Collections.concat} but runs a maximum of `limit` async operations at a time.
2619   *
2620   * @name concatLimit
2621   * @static
2622   * @memberOf module:Collections
2623   * @method
2624   * @see [async.concat]{@link module:Collections.concat}
2625   * @category Collection
2626   * @param {Array|Iterable|Object} coll - A collection to iterate over.
2627   * @param {number} limit - The maximum number of async operations at a time.
2628   * @param {AsyncFunction} iteratee - A function to apply to each item in `coll`,
2629   * which should use an array as its result. Invoked with (item, callback).
2630   * @param {Function} [callback] - A callback which is called after all the
2631   * `iteratee` functions have finished, or an error occurs. Results is an array
2632   * containing the concatenated results of the `iteratee` function. Invoked with
2633   * (err, results).
2634   */
2635  var concatLimit = function(coll, limit, iteratee, callback) {
2636      callback = callback || noop;
2637      var _iteratee = wrapAsync(iteratee);
2638      mapLimit(coll, limit, function(val, callback) {
2639          _iteratee(val, function(err /*, ...args*/) {
2640              if (err) return callback(err);
2641              return callback(null, slice(arguments, 1));
2642          });
2643      }, function(err, mapResults) {
2644          var result = [];
2645          for (var i = 0; i < mapResults.length; i++) {
2646              if (mapResults[i]) {
2647                  result = _concat.apply(result, mapResults[i]);
2648              }
2649          }
2650  
2651          return callback(err, result);
2652      });
2653  };
2654  
2655  /**
2656   * Applies `iteratee` to each item in `coll`, concatenating the results. Returns
2657   * the concatenated list. The `iteratee`s are called in parallel, and the
2658   * results are concatenated as they return. There is no guarantee that the
2659   * results array will be returned in the original order of `coll` passed to the
2660   * `iteratee` function.
2661   *
2662   * @name concat
2663   * @static
2664   * @memberOf module:Collections
2665   * @method
2666   * @category Collection
2667   * @param {Array|Iterable|Object} coll - A collection to iterate over.
2668   * @param {AsyncFunction} iteratee - A function to apply to each item in `coll`,
2669   * which should use an array as its result. Invoked with (item, callback).
2670   * @param {Function} [callback(err)] - A callback which is called after all the
2671   * `iteratee` functions have finished, or an error occurs. Results is an array
2672   * containing the concatenated results of the `iteratee` function. Invoked with
2673   * (err, results).
2674   * @example
2675   *
2676   * async.concat(['dir1','dir2','dir3'], fs.readdir, function(err, files) {
2677   *     // files is now a list of filenames that exist in the 3 directories
2678   * });
2679   */
2680  var concat = doLimit(concatLimit, Infinity);
2681  
2682  /**
2683   * The same as [`concat`]{@link module:Collections.concat} but runs only a single async operation at a time.
2684   *
2685   * @name concatSeries
2686   * @static
2687   * @memberOf module:Collections
2688   * @method
2689   * @see [async.concat]{@link module:Collections.concat}
2690   * @category Collection
2691   * @param {Array|Iterable|Object} coll - A collection to iterate over.
2692   * @param {AsyncFunction} iteratee - A function to apply to each item in `coll`.
2693   * The iteratee should complete with an array an array of results.
2694   * Invoked with (item, callback).
2695   * @param {Function} [callback(err)] - A callback which is called after all the
2696   * `iteratee` functions have finished, or an error occurs. Results is an array
2697   * containing the concatenated results of the `iteratee` function. Invoked with
2698   * (err, results).
2699   */
2700  var concatSeries = doLimit(concatLimit, 1);
2701  
2702  /**
2703   * Returns a function that when called, calls-back with the values provided.
2704   * Useful as the first function in a [`waterfall`]{@link module:ControlFlow.waterfall}, or for plugging values in to
2705   * [`auto`]{@link module:ControlFlow.auto}.
2706   *
2707   * @name constant
2708   * @static
2709   * @memberOf module:Utils
2710   * @method
2711   * @category Util
2712   * @param {...*} arguments... - Any number of arguments to automatically invoke
2713   * callback with.
2714   * @returns {AsyncFunction} Returns a function that when invoked, automatically
2715   * invokes the callback with the previous given arguments.
2716   * @example
2717   *
2718   * async.waterfall([
2719   *     async.constant(42),
2720   *     function (value, next) {
2721   *         // value === 42
2722   *     },
2723   *     //...
2724   * ], callback);
2725   *
2726   * async.waterfall([
2727   *     async.constant(filename, "utf8"),
2728   *     fs.readFile,
2729   *     function (fileData, next) {
2730   *         //...
2731   *     }
2732   *     //...
2733   * ], callback);
2734   *
2735   * async.auto({
2736   *     hostname: async.constant("https://server.net/"),
2737   *     port: findFreePort,
2738   *     launchServer: ["hostname", "port", function (options, cb) {
2739   *         startServer(options, cb);
2740   *     }],
2741   *     //...
2742   * }, callback);
2743   */
2744  var constant = function(/*...values*/) {
2745      var values = slice(arguments);
2746      var args = [null].concat(values);
2747      return function (/*...ignoredArgs, callback*/) {
2748          var callback = arguments[arguments.length - 1];
2749          return callback.apply(this, args);
2750      };
2751  };
2752  
2753  /**
2754   * This method returns the first argument it receives.
2755   *
2756   * @static
2757   * @since 0.1.0
2758   * @memberOf _
2759   * @category Util
2760   * @param {*} value Any value.
2761   * @returns {*} Returns `value`.
2762   * @example
2763   *
2764   * var object = { 'a': 1 };
2765   *
2766   * console.log(_.identity(object) === object);
2767   * // => true
2768   */
2769  function identity(value) {
2770    return value;
2771  }
2772  
2773  function _createTester(check, getResult) {
2774      return function(eachfn, arr, iteratee, cb) {
2775          cb = cb || noop;
2776          var testPassed = false;
2777          var testResult;
2778          eachfn(arr, function(value, _, callback) {
2779              iteratee(value, function(err, result) {
2780                  if (err) {
2781                      callback(err);
2782                  } else if (check(result) && !testResult) {
2783                      testPassed = true;
2784                      testResult = getResult(true, value);
2785                      callback(null, breakLoop);
2786                  } else {
2787                      callback();
2788                  }
2789              });
2790          }, function(err) {
2791              if (err) {
2792                  cb(err);
2793              } else {
2794                  cb(null, testPassed ? testResult : getResult(false));
2795              }
2796          });
2797      };
2798  }
2799  
2800  function _findGetResult(v, x) {
2801      return x;
2802  }
2803  
2804  /**
2805   * Returns the first value in `coll` that passes an async truth test. The
2806   * `iteratee` is applied in parallel, meaning the first iteratee to return
2807   * `true` will fire the detect `callback` with that result. That means the
2808   * result might not be the first item in the original `coll` (in terms of order)
2809   * that passes the test.
2810  
2811   * If order within the original `coll` is important, then look at
2812   * [`detectSeries`]{@link module:Collections.detectSeries}.
2813   *
2814   * @name detect
2815   * @static
2816   * @memberOf module:Collections
2817   * @method
2818   * @alias find
2819   * @category Collections
2820   * @param {Array|Iterable|Object} coll - A collection to iterate over.
2821   * @param {AsyncFunction} iteratee - A truth test to apply to each item in `coll`.
2822   * The iteratee must complete with a boolean value as its result.
2823   * Invoked with (item, callback).
2824   * @param {Function} [callback] - A callback which is called as soon as any
2825   * iteratee returns `true`, or after all the `iteratee` functions have finished.
2826   * Result will be the first item in the array that passes the truth test
2827   * (iteratee) or the value `undefined` if none passed. Invoked with
2828   * (err, result).
2829   * @example
2830   *
2831   * async.detect(['file1','file2','file3'], function(filePath, callback) {
2832   *     fs.access(filePath, function(err) {
2833   *         callback(null, !err)
2834   *     });
2835   * }, function(err, result) {
2836   *     // result now equals the first file in the list that exists
2837   * });
2838   */
2839  var detect = doParallel(_createTester(identity, _findGetResult));
2840  
2841  /**
2842   * The same as [`detect`]{@link module:Collections.detect} but runs a maximum of `limit` async operations at a
2843   * time.
2844   *
2845   * @name detectLimit
2846   * @static
2847   * @memberOf module:Collections
2848   * @method
2849   * @see [async.detect]{@link module:Collections.detect}
2850   * @alias findLimit
2851   * @category Collections
2852   * @param {Array|Iterable|Object} coll - A collection to iterate over.
2853   * @param {number} limit - The maximum number of async operations at a time.
2854   * @param {AsyncFunction} iteratee - A truth test to apply to each item in `coll`.
2855   * The iteratee must complete with a boolean value as its result.
2856   * Invoked with (item, callback).
2857   * @param {Function} [callback] - A callback which is called as soon as any
2858   * iteratee returns `true`, or after all the `iteratee` functions have finished.
2859   * Result will be the first item in the array that passes the truth test
2860   * (iteratee) or the value `undefined` if none passed. Invoked with
2861   * (err, result).
2862   */
2863  var detectLimit = doParallelLimit(_createTester(identity, _findGetResult));
2864  
2865  /**
2866   * The same as [`detect`]{@link module:Collections.detect} but runs only a single async operation at a time.
2867   *
2868   * @name detectSeries
2869   * @static
2870   * @memberOf module:Collections
2871   * @method
2872   * @see [async.detect]{@link module:Collections.detect}
2873   * @alias findSeries
2874   * @category Collections
2875   * @param {Array|Iterable|Object} coll - A collection to iterate over.
2876   * @param {AsyncFunction} iteratee - A truth test to apply to each item in `coll`.
2877   * The iteratee must complete with a boolean value as its result.
2878   * Invoked with (item, callback).
2879   * @param {Function} [callback] - A callback which is called as soon as any
2880   * iteratee returns `true`, or after all the `iteratee` functions have finished.
2881   * Result will be the first item in the array that passes the truth test
2882   * (iteratee) or the value `undefined` if none passed. Invoked with
2883   * (err, result).
2884   */
2885  var detectSeries = doLimit(detectLimit, 1);
2886  
2887  function consoleFunc(name) {
2888      return function (fn/*, ...args*/) {
2889          var args = slice(arguments, 1);
2890          args.push(function (err/*, ...args*/) {
2891              var args = slice(arguments, 1);
2892              if (typeof console === 'object') {
2893                  if (err) {
2894                      if (console.error) {
2895                          console.error(err);
2896                      }
2897                  } else if (console[name]) {
2898                      arrayEach(args, function (x) {
2899                          console[name](x);
2900                      });
2901                  }
2902              }
2903          });
2904          wrapAsync(fn).apply(null, args);
2905      };
2906  }
2907  
2908  /**
2909   * Logs the result of an [`async` function]{@link AsyncFunction} to the
2910   * `console` using `console.dir` to display the properties of the resulting object.
2911   * Only works in Node.js or in browsers that support `console.dir` and
2912   * `console.error` (such as FF and Chrome).
2913   * If multiple arguments are returned from the async function,
2914   * `console.dir` is called on each argument in order.
2915   *
2916   * @name dir
2917   * @static
2918   * @memberOf module:Utils
2919   * @method
2920   * @category Util
2921   * @param {AsyncFunction} function - The function you want to eventually apply
2922   * all arguments to.
2923   * @param {...*} arguments... - Any number of arguments to apply to the function.
2924   * @example
2925   *
2926   * // in a module
2927   * var hello = function(name, callback) {
2928   *     setTimeout(function() {
2929   *         callback(null, {hello: name});
2930   *     }, 1000);
2931   * };
2932   *
2933   * // in the node repl
2934   * node> async.dir(hello, 'world');
2935   * {hello: 'world'}
2936   */
2937  var dir = consoleFunc('dir');
2938  
2939  /**
2940   * The post-check version of [`during`]{@link module:ControlFlow.during}. To reflect the difference in
2941   * the order of operations, the arguments `test` and `fn` are switched.
2942   *
2943   * Also a version of [`doWhilst`]{@link module:ControlFlow.doWhilst} with asynchronous `test` function.
2944   * @name doDuring
2945   * @static
2946   * @memberOf module:ControlFlow
2947   * @method
2948   * @see [async.during]{@link module:ControlFlow.during}
2949   * @category Control Flow
2950   * @param {AsyncFunction} fn - An async function which is called each time
2951   * `test` passes. Invoked with (callback).
2952   * @param {AsyncFunction} test - asynchronous truth test to perform before each
2953   * execution of `fn`. Invoked with (...args, callback), where `...args` are the
2954   * non-error args from the previous callback of `fn`.
2955   * @param {Function} [callback] - A callback which is called after the test
2956   * function has failed and repeated execution of `fn` has stopped. `callback`
2957   * will be passed an error if one occurred, otherwise `null`.
2958   */
2959  function doDuring(fn, test, callback) {
2960      callback = onlyOnce(callback || noop);
2961      var _fn = wrapAsync(fn);
2962      var _test = wrapAsync(test);
2963  
2964      function next(err/*, ...args*/) {
2965          if (err) return callback(err);
2966          var args = slice(arguments, 1);
2967          args.push(check);
2968          _test.apply(this, args);
2969      }
2970  
2971      function check(err, truth) {
2972          if (err) return callback(err);
2973          if (!truth) return callback(null);
2974          _fn(next);
2975      }
2976  
2977      check(null, true);
2978  
2979  }
2980  
2981  /**
2982   * The post-check version of [`whilst`]{@link module:ControlFlow.whilst}. To reflect the difference in
2983   * the order of operations, the arguments `test` and `iteratee` are switched.
2984   *
2985   * `doWhilst` is to `whilst` as `do while` is to `while` in plain JavaScript.
2986   *
2987   * @name doWhilst
2988   * @static
2989   * @memberOf module:ControlFlow
2990   * @method
2991   * @see [async.whilst]{@link module:ControlFlow.whilst}
2992   * @category Control Flow
2993   * @param {AsyncFunction} iteratee - A function which is called each time `test`
2994   * passes. Invoked with (callback).
2995   * @param {Function} test - synchronous truth test to perform after each
2996   * execution of `iteratee`. Invoked with any non-error callback results of
2997   * `iteratee`.
2998   * @param {Function} [callback] - A callback which is called after the test
2999   * function has failed and repeated execution of `iteratee` has stopped.
3000   * `callback` will be passed an error and any arguments passed to the final
3001   * `iteratee`'s callback. Invoked with (err, [results]);
3002   */
3003  function doWhilst(iteratee, test, callback) {
3004      callback = onlyOnce(callback || noop);
3005      var _iteratee = wrapAsync(iteratee);
3006      var next = function(err/*, ...args*/) {
3007          if (err) return callback(err);
3008          var args = slice(arguments, 1);
3009          if (test.apply(this, args)) return _iteratee(next);
3010          callback.apply(null, [null].concat(args));
3011      };
3012      _iteratee(next);
3013  }
3014  
3015  /**
3016   * Like ['doWhilst']{@link module:ControlFlow.doWhilst}, except the `test` is inverted. Note the
3017   * argument ordering differs from `until`.
3018   *
3019   * @name doUntil
3020   * @static
3021   * @memberOf module:ControlFlow
3022   * @method
3023   * @see [async.doWhilst]{@link module:ControlFlow.doWhilst}
3024   * @category Control Flow
3025   * @param {AsyncFunction} iteratee - An async function which is called each time
3026   * `test` fails. Invoked with (callback).
3027   * @param {Function} test - synchronous truth test to perform after each
3028   * execution of `iteratee`. Invoked with any non-error callback results of
3029   * `iteratee`.
3030   * @param {Function} [callback] - A callback which is called after the test
3031   * function has passed and repeated execution of `iteratee` has stopped. `callback`
3032   * will be passed an error and any arguments passed to the final `iteratee`'s
3033   * callback. Invoked with (err, [results]);
3034   */
3035  function doUntil(iteratee, test, callback) {
3036      doWhilst(iteratee, function() {
3037          return !test.apply(this, arguments);
3038      }, callback);
3039  }
3040  
3041  /**
3042   * Like [`whilst`]{@link module:ControlFlow.whilst}, except the `test` is an asynchronous function that
3043   * is passed a callback in the form of `function (err, truth)`. If error is
3044   * passed to `test` or `fn`, the main callback is immediately called with the
3045   * value of the error.
3046   *
3047   * @name during
3048   * @static
3049   * @memberOf module:ControlFlow
3050   * @method
3051   * @see [async.whilst]{@link module:ControlFlow.whilst}
3052   * @category Control Flow
3053   * @param {AsyncFunction} test - asynchronous truth test to perform before each
3054   * execution of `fn`. Invoked with (callback).
3055   * @param {AsyncFunction} fn - An async function which is called each time
3056   * `test` passes. Invoked with (callback).
3057   * @param {Function} [callback] - A callback which is called after the test
3058   * function has failed and repeated execution of `fn` has stopped. `callback`
3059   * will be passed an error, if one occurred, otherwise `null`.
3060   * @example
3061   *
3062   * var count = 0;
3063   *
3064   * async.during(
3065   *     function (callback) {
3066   *         return callback(null, count < 5);
3067   *     },
3068   *     function (callback) {
3069   *         count++;
3070   *         setTimeout(callback, 1000);
3071   *     },
3072   *     function (err) {
3073   *         // 5 seconds have passed
3074   *     }
3075   * );
3076   */
3077  function during(test, fn, callback) {
3078      callback = onlyOnce(callback || noop);
3079      var _fn = wrapAsync(fn);
3080      var _test = wrapAsync(test);
3081  
3082      function next(err) {
3083          if (err) return callback(err);
3084          _test(check);
3085      }
3086  
3087      function check(err, truth) {
3088          if (err) return callback(err);
3089          if (!truth) return callback(null);
3090          _fn(next);
3091      }
3092  
3093      _test(check);
3094  }
3095  
3096  function _withoutIndex(iteratee) {
3097      return function (value, index, callback) {
3098          return iteratee(value, callback);
3099      };
3100  }
3101  
3102  /**
3103   * Applies the function `iteratee` to each item in `coll`, in parallel.
3104   * The `iteratee` is called with an item from the list, and a callback for when
3105   * it has finished. If the `iteratee` passes an error to its `callback`, the
3106   * main `callback` (for the `each` function) is immediately called with the
3107   * error.
3108   *
3109   * Note, that since this function applies `iteratee` to each item in parallel,
3110   * there is no guarantee that the iteratee functions will complete in order.
3111   *
3112   * @name each
3113   * @static
3114   * @memberOf module:Collections
3115   * @method
3116   * @alias forEach
3117   * @category Collection
3118   * @param {Array|Iterable|Object} coll - A collection to iterate over.
3119   * @param {AsyncFunction} iteratee - An async function to apply to
3120   * each item in `coll`. Invoked with (item, callback).
3121   * The array index is not passed to the iteratee.
3122   * If you need the index, use `eachOf`.
3123   * @param {Function} [callback] - A callback which is called when all
3124   * `iteratee` functions have finished, or an error occurs. Invoked with (err).