source: trip-planner-front/node_modules/neo-async/async.js@ b738035

Last change on this file since b738035 was 6a3a178, checked in by Ema <ema_spirova@…>, 3 years ago

initial commit
  • Property mode set to 100644
File size: 229.6 KB
RevLine 
[6a3a178]1(function(global, factory) {
2 /*jshint -W030 */
3 'use strict';
4 typeof exports === 'object' && typeof module !== 'undefined'
5 ? factory(exports)
6 : typeof define === 'function' && define.amd
7 ? define(['exports'], factory)
8 : global.async
9 ? factory((global.neo_async = global.neo_async || {}))
10 : factory((global.async = global.async || {}));
11})(this, function(exports) {
12 'use strict';
13
14 var noop = function noop() {};
15 var throwError = function throwError() {
16 throw new Error('Callback was already called.');
17 };
18
19 var DEFAULT_TIMES = 5;
20 var DEFAULT_INTERVAL = 0;
21
22 var obj = 'object';
23 var func = 'function';
24 var isArray = Array.isArray;
25 var nativeKeys = Object.keys;
26 var nativePush = Array.prototype.push;
27 var iteratorSymbol = typeof Symbol === func && Symbol.iterator;
28
29 var nextTick, asyncNextTick, asyncSetImmediate;
30 createImmediate();
31
32 /**
33 * @memberof async
34 * @namespace each
35 * @param {Array|Object} collection
36 * @param {Function} iterator
37 * @param {Function} callback
38 * @example
39 *
40 * // array
41 * var order = [];
42 * var array = [1, 3, 2];
43 * var iterator = function(num, done) {
44 * setTimeout(function() {
45 * order.push(num);
46 * done();
47 * }, num * 10);
48 * };
49 * async.each(array, iterator, function(err, res) {
50 * console.log(res); // undefined
51 * console.log(order); // [1, 2, 3]
52 * });
53 *
54 * @example
55 *
56 * // array with index
57 * var order = [];
58 * var array = [1, 3, 2];
59 * var iterator = function(num, index, done) {
60 * setTimeout(function() {
61 * order.push([num, index]);
62 * done();
63 * }, num * 10);
64 * };
65 * async.each(array, iterator, function(err, res) {
66 * console.log(res); // undefined
67 * console.log(order); // [[1, 0], [2, 2], [3, 1]]
68 * });
69 *
70 * @example
71 *
72 * // object
73 * var order = [];
74 * var object = { a: 1, b: 3, c: 2 };
75 * var iterator = function(num, done) {
76 * setTimeout(function() {
77 * order.push(num);
78 * done();
79 * }, num * 10);
80 * };
81 * async.each(object, iterator, function(err, res) {
82 * console.log(res); // undefined
83 * console.log(order); // [1, 2, 3]
84 * });
85 *
86 * @example
87 *
88 * // object with key
89 * var order = [];
90 * var object = { a: 1, b: 3, c: 2 };
91 * var iterator = function(num, key, done) {
92 * setTimeout(function() {
93 * order.push([num, key]);
94 * done();
95 * }, num * 10);
96 * };
97 * async.each(object, iterator, function(err, res) {
98 * console.log(res); // undefined
99 * console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b']]
100 * });
101 *
102 * @example
103 *
104 * // break
105 * var order = [];
106 * var array = [1, 3, 2];
107 * var iterator = function(num, done) {
108 * setTimeout(function() {
109 * order.push(num);
110 * done(null, num !== 2);
111 * }, num * 10);
112 * };
113 * async.each(array, iterator, function(err, res) {
114 * console.log(res); // undefined
115 * console.log(order); // [1, 2]
116 * });
117 *
118 */
119 var each = createEach(arrayEach, baseEach, symbolEach);
120
121 /**
122 * @memberof async
123 * @namespace map
124 * @param {Array|Object} collection
125 * @param {Function} iterator
126 * @param {Function} callback
127 * @example
128 *
129 * // array
130 * var order = [];
131 * var array = [1, 3, 2];
132 * var iterator = function(num, done) {
133 * setTimeout(function() {
134 * order.push(num);
135 * done(null, num);
136 * }, num * 10);
137 * };
138 * async.map(array, iterator, function(err, res) {
139 * console.log(res); // [1, 3, 2];
140 * console.log(order); // [1, 2, 3]
141 * });
142 *
143 * @example
144 *
145 * // array with index
146 * var order = [];
147 * var array = [1, 3, 2];
148 * var iterator = function(num, index, done) {
149 * setTimeout(function() {
150 * order.push([num, index]);
151 * done(null, num);
152 * }, num * 10);
153 * };
154 * async.map(array, iterator, function(err, res) {
155 * console.log(res); // [1, 3, 2]
156 * console.log(order); // [[1, 0], [2, 2], [3, 1]]
157 * });
158 *
159 * @example
160 *
161 * // object
162 * var order = [];
163 * var object = { a: 1, b: 3, c: 2 };
164 * var iterator = function(num, done) {
165 * setTimeout(function() {
166 * order.push(num);
167 * done(null, num);
168 * }, num * 10);
169 * };
170 * async.map(object, iterator, function(err, res) {
171 * console.log(res); // [1, 3, 2]
172 * console.log(order); // [1, 2, 3]
173 * });
174 *
175 * @example
176 *
177 * // object with key
178 * var order = [];
179 * var object = { a: 1, b: 3, c: 2 };
180 * var iterator = function(num, key, done) {
181 * setTimeout(function() {
182 * order.push([num, key]);
183 * done(null, num);
184 * }, num * 10);
185 * };
186 * async.map(object, iterator, function(err, res) {
187 * console.log(res); // [1, 3, 2]
188 * console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b']]
189 * });
190 *
191 */
192 var map = createMap(arrayEachIndex, baseEachIndex, symbolEachIndex, true);
193
194 /**
195 * @memberof async
196 * @namespace mapValues
197 * @param {Array|Object} collection
198 * @param {Function} iterator
199 * @param {Function} callback
200 * @example
201 *
202 * // array
203 * var order = [];
204 * var array = [1, 3, 2];
205 * var iterator = function(num, done) {
206 * setTimeout(function() {
207 * order.push(num);
208 * done(null, num);
209 * }, num * 10);
210 * };
211 * async.mapValues(array, iterator, function(err, res) {
212 * console.log(res); // { '0': 1, '1': 3, '2': 2 }
213 * console.log(order); // [1, 2, 3]
214 * });
215 *
216 * @example
217 *
218 * // array with index
219 * var order = [];
220 * var array = [1, 3, 2];
221 * var iterator = function(num, index, done) {
222 * setTimeout(function() {
223 * order.push([num, index]);
224 * done(null, num);
225 * }, num * 10);
226 * };
227 * async.mapValues(array, iterator, function(err, res) {
228 * console.log(res); // { '0': 1, '1': 3, '2': 2 }
229 * console.log(order); // [[1, 0], [2, 2], [3, 1]]
230 * });
231 *
232 * @example
233 *
234 * // object
235 * var order = [];
236 * var object = { a: 1, b: 3, c: 2 };
237 * var iterator = function(num, done) {
238 * setTimeout(function() {
239 * order.push(num);
240 * done(null, num);
241 * }, num * 10);
242 * };
243 * async.mapValues(object, iterator, function(err, res) {
244 * console.log(res); // { a: 1, b: 3, c: 2 }
245 * console.log(order); // [1, 2, 3]
246 * });
247 *
248 * @example
249 *
250 * // object with key
251 * var order = [];
252 * var object = { a: 1, b: 3, c: 2 };
253 * var iterator = function(num, key, done) {
254 * setTimeout(function() {
255 * order.push([num, key]);
256 * done(null, num);
257 * }, num * 10);
258 * };
259 * async.mapValues(object, iterator, function(err, res) {
260 * console.log(res); // { a: 1, b: 3, c: 2 }
261 * console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b']]
262 * });
263 *
264 */
265 var mapValues = createMap(arrayEachIndex, baseEachKey, symbolEachKey, false);
266
267 /**
268 * @memberof async
269 * @namespace filter
270 * @param {Array|Object} collection
271 * @param {Function} iterator
272 * @param {Function} callback
273 * @example
274 *
275 * // array
276 * var order = [];
277 * var array = [1, 3, 2];
278 * var iterator = function(num, done) {
279 * setTimeout(function() {
280 * order.push(num);
281 * done(null, num % 2);
282 * }, num * 10);
283 * };
284 * async.filter(array, iterator, function(err, res) {
285 * console.log(res); // [1, 3];
286 * console.log(order); // [1, 2, 3]
287 * });
288 *
289 * @example
290 *
291 * // array with index
292 * var order = [];
293 * var array = [1, 3, 2];
294 * var iterator = function(num, index, done) {
295 * setTimeout(function() {
296 * order.push([num, index]);
297 * done(null, num % 2);
298 * }, num * 10);
299 * };
300 * async.filter(array, iterator, function(err, res) {
301 * console.log(res); // [1, 3];
302 * console.log(order); // [[1, 0], [2, 2], [3, 1]]
303 * });
304 *
305 * @example
306 *
307 * // object
308 * var order = [];
309 * var object = { a: 1, b: 3, c: 2 };
310 * var iterator = function(num, done) {
311 * setTimeout(function() {
312 * order.push(num);
313 * done(null, num % 2);
314 * }, num * 10);
315 * };
316 * async.filter(object, iterator, function(err, res) {
317 * console.log(res); // [1, 3];
318 * console.log(order); // [1, 2, 3]
319 * });
320 *
321 * @example
322 *
323 * // object with key
324 * var order = [];
325 * var object = { a: 1, b: 3, c: 2 };
326 * var iterator = function(num, key, done) {
327 * setTimeout(function() {
328 * order.push([num, key]);
329 * done(null, num % 2);
330 * }, num * 10);
331 * };
332 * async.filter(object, iterator, function(err, res) {
333 * console.log(res); // [1, 3];
334 * console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b']]
335 * });
336 *
337 */
338 var filter = createFilter(arrayEachIndexValue, baseEachIndexValue, symbolEachIndexValue, true);
339
340 /**
341 * @memberof async
342 * @namespace filterSeries
343 * @param {Array|Object} collection
344 * @param {Function} iterator
345 * @param {Function} callback
346 * @example
347 *
348 * // array
349 * var order = [];
350 * var array = [1, 3, 2];
351 * var iterator = function(num, done) {
352 * setTimeout(function() {
353 * order.push(num);
354 * done(null, num % 2);
355 * }, num * 10);
356 * };
357 * async.filterSeries(array, iterator, function(err, res) {
358 * console.log(res); // [1, 3];
359 * console.log(order); // [1, 3, 2]
360 * });
361 *
362 * @example
363 *
364 * // array with index
365 * var order = [];
366 * var array = [1, 3, 2];
367 * var iterator = function(num, index, done) {
368 * setTimeout(function() {
369 * order.push([num, index]);
370 * done(null, num % 2);
371 * }, num * 10);
372 * };
373 * async.filterSeries(array, iterator, function(err, res) {
374 * console.log(res); // [1, 3]
375 * console.log(order); // [[1, 0], [3, 1], [2, 2]]
376 * });
377 *
378 * @example
379 *
380 * // object
381 * var order = [];
382 * var object = { a: 1, b: 3, c: 2 };
383 * var iterator = function(num, done) {
384 * setTimeout(function() {
385 * order.push(num);
386 * done(null, num % 2);
387 * }, num * 10);
388 * };
389 * async.filterSeries(object, iterator, function(err, res) {
390 * console.log(res); // [1, 3]
391 * console.log(order); // [1, 3, 2]
392 * });
393 *
394 * @example
395 *
396 * // object with key
397 * var order = [];
398 * var object = { a: 1, b: 3, c: 2 };
399 * var iterator = function(num, key, done) {
400 * setTimeout(function() {
401 * order.push([num, key]);
402 * done(null, num % 2);
403 * }, num * 10);
404 * };
405 * async.filterSeries(object, iterator, function(err, res) {
406 * console.log(res); // [1, 3]
407 * console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c']]
408 * });
409 *
410 */
411 var filterSeries = createFilterSeries(true);
412
413 /**
414 * @memberof async
415 * @namespace filterLimit
416 * @param {Array|Object} collection
417 * @param {number} limit - limit >= 1
418 * @param {Function} iterator
419 * @param {Function} callback
420 * @example
421 *
422 * // array
423 * var order = [];
424 * var array = [1, 5, 3, 4, 2];
425 * var iterator = function(num, done) {
426 * setTimeout(function() {
427 * order.push(num);
428 * done(null, num % 2);
429 * }, num * 10);
430 * };
431 * async.filterLimit(array, 2, iterator, function(err, res) {
432 * console.log(res); // [1, 5, 3]
433 * console.log(order); // [1, 3, 5, 2, 4]
434 * });
435 *
436 * @example
437 *
438 * // array with index
439 * var order = [];
440 * var array = [1, 5, 3, 4, 2];
441 * var iterator = function(num, index, done) {
442 * setTimeout(function() {
443 * order.push([num, index]);
444 * done(null, num % 2);
445 * }, num * 10);
446 * };
447 * async.filterLimit(array, 2, iterator, function(err, res) {
448 * console.log(res); // [1, 5, 3]
449 * console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
450 * });
451 *
452 * @example
453 *
454 * // object
455 * var order = [];
456 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
457 * var iterator = function(num, done) {
458 * setTimeout(function() {
459 * order.push(num);
460 * done(null, num % 2);
461 * }, num * 10);
462 * };
463 * async.filterLimit(object, 2, iterator, function(err, res) {
464 * console.log(res); // [1, 5, 3]
465 * console.log(order); // [1, 3, 5, 2, 4]
466 * });
467 *
468 * @example
469 *
470 * // object with key
471 * var order = [];
472 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
473 * var iterator = function(num, key, done) {
474 * setTimeout(function() {
475 * order.push([num, key]);
476 * done(null, num % 2);
477 * }, num * 10);
478 * };
479 * async.filterLimit(object, 2, iterator, function(err, res) {
480 * console.log(res); // [1, 5, 3]
481 * console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
482 * });
483 *
484 */
485 var filterLimit = createFilterLimit(true);
486
487 /**
488 * @memberof async
489 * @namespace reject
490 * @param {Array|Object} collection
491 * @param {Function} iterator
492 * @param {Function} callback
493 * @example
494 *
495 * // array
496 * var order = [];
497 * var array = [1, 3, 2];
498 * var iterator = function(num, done) {
499 * setTimeout(function() {
500 * order.push(num);
501 * done(null, num % 2);
502 * }, num * 10);
503 * };
504 * async.reject(array, iterator, function(err, res) {
505 * console.log(res); // [2];
506 * console.log(order); // [1, 2, 3]
507 * });
508 *
509 * @example
510 *
511 * // array with index
512 * var order = [];
513 * var array = [1, 3, 2];
514 * var iterator = function(num, index, done) {
515 * setTimeout(function() {
516 * order.push([num, index]);
517 * done(null, num % 2);
518 * }, num * 10);
519 * };
520 * async.reject(array, iterator, function(err, res) {
521 * console.log(res); // [2];
522 * console.log(order); // [[1, 0], [2, 2], [3, 1]]
523 * });
524 *
525 * @example
526 *
527 * // object
528 * var order = [];
529 * var object = { a: 1, b: 3, c: 2 };
530 * var iterator = function(num, done) {
531 * setTimeout(function() {
532 * order.push(num);
533 * done(null, num % 2);
534 * }, num * 10);
535 * };
536 * async.reject(object, iterator, function(err, res) {
537 * console.log(res); // [2];
538 * console.log(order); // [1, 2, 3]
539 * });
540 *
541 * @example
542 *
543 * // object with key
544 * var order = [];
545 * var object = { a: 1, b: 3, c: 2 };
546 * var iterator = function(num, key, done) {
547 * setTimeout(function() {
548 * order.push([num, key]);
549 * done(null, num % 2);
550 * }, num * 10);
551 * };
552 * async.reject(object, iterator, function(err, res) {
553 * console.log(res); // [2];
554 * console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b']]
555 * });
556 *
557 */
558 var reject = createFilter(arrayEachIndexValue, baseEachIndexValue, symbolEachIndexValue, false);
559
560 /**
561 * @memberof async
562 * @namespace rejectSeries
563 * @param {Array|Object} collection
564 * @param {Function} iterator
565 * @param {Function} callback
566 * @example
567 *
568 * // array
569 * var order = [];
570 * var array = [1, 3, 2];
571 * var iterator = function(num, done) {
572 * setTimeout(function() {
573 * order.push(num);
574 * done(null, num % 2);
575 * }, num * 10);
576 * };
577 * async.rejectSeries(array, iterator, function(err, res) {
578 * console.log(res); // [2];
579 * console.log(order); // [1, 3, 2]
580 * });
581 *
582 * @example
583 *
584 * // object
585 * var order = [];
586 * var object = { a: 1, b: 3, c: 2 };
587 * var iterator = function(num, done) {
588 * setTimeout(function() {
589 * order.push(num);
590 * done(null, num % 2);
591 * }, num * 10);
592 * };
593 * async.rejectSeries(object, iterator, function(err, res) {
594 * console.log(res); // [2];
595 * console.log(order); // [1, 3, 2]
596 * });
597 *
598 * @example
599 *
600 * // object with key
601 * var order = [];
602 * var object = { a: 1, b: 3, c: 2 };
603 * var iterator = function(num, key, done) {
604 * setTimeout(function() {
605 * order.push([num, key]);
606 * done(null, num % 2);
607 * }, num * 10);
608 * };
609 * async.rejectSeries(object, iterator, function(err, res) {
610 * console.log(res); // [2];
611 * console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c']]
612 * });
613 *
614 */
615 var rejectSeries = createFilterSeries(false);
616
617 /**
618 * @memberof async
619 * @namespace rejectLimit
620 * @param {Array|Object} collection
621 * @param {number} limit - limit >= 1
622 * @param {Function} iterator
623 * @param {Function} callback
624 * @example
625 *
626 * // array
627 * var order = [];
628 * var array = [1, 5, 3, 4, 2];
629 * var iterator = function(num, done) {
630 * setTimeout(function() {
631 * order.push(num);
632 * done(null, num % 2);
633 * }, num * 10);
634 * };
635 * async.rejectLimit(array, 2, iterator, function(err, res) {
636 * console.log(res); // [4, 2]
637 * console.log(order); // [1, 3, 5, 2, 4]
638 * });
639 *
640 * @example
641 *
642 * // array with index
643 * var order = [];
644 * var array = [1, 5, 3, 4, 2];
645 * var iterator = function(num, index, done) {
646 * setTimeout(function() {
647 * order.push([num, index]);
648 * done(null, num % 2);
649 * }, num * 10);
650 * };
651 * async.rejectLimit(array, 2, iterator, function(err, res) {
652 * console.log(res); // [4, 2]
653 * console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
654 * });
655 *
656 * @example
657 *
658 * // object
659 * var order = [];
660 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
661 * var iterator = function(num, done) {
662 * setTimeout(function() {
663 * order.push(num);
664 * done(null, num % 2);
665 * }, num * 10);
666 * };
667 * async.rejectLimit(object, 2, iterator, function(err, res) {
668 * console.log(res); // [4, 2]
669 * console.log(order); // [1, 3, 5, 2, 4]
670 * });
671 *
672 * @example
673 *
674 * // object with key
675 * var order = [];
676 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
677 * var iterator = function(num, key, done) {
678 * setTimeout(function() {
679 * order.push([num, key]);
680 * done(null, num % 2);
681 * }, num * 10);
682 * };
683 * async.rejectLimit(object, 2, iterator, function(err, res) {
684 * console.log(res); // [4, 2]
685 * console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
686 * });
687 *
688 */
689 var rejectLimit = createFilterLimit(false);
690
691 /**
692 * @memberof async
693 * @namespace detect
694 * @param {Array|Object} collection
695 * @param {Function} iterator
696 * @param {Function} callback
697 * @example
698 *
699 * // array
700 * var order = [];
701 * var array = [1, 3, 2];
702 * var iterator = function(num, done) {
703 * setTimeout(function() {
704 * order.push(num);
705 * done(null, num % 2);
706 * }, num * 10);
707 * };
708 * async.detect(array, iterator, function(err, res) {
709 * console.log(res); // 1
710 * console.log(order); // [1]
711 * });
712 *
713 * @example
714 *
715 * // array with index
716 * var order = [];
717 * var array = [1, 3, 2];
718 * var iterator = function(num, index, done) {
719 * setTimeout(function() {
720 * order.push([num, index]);
721 * done(null, num % 2);
722 * }, num * 10);
723 * };
724 * async.detect(array, iterator, function(err, res) {
725 * console.log(res); // 1
726 * console.log(order); // [[1, 0]]
727 * });
728 *
729 * @example
730 *
731 * // object
732 * var order = [];
733 * var object = { a: 1, b: 3, c: 2 };
734 * var iterator = function(num, done) {
735 * setTimeout(function() {
736 * order.push(num);
737 * done(null, num % 2);
738 * }, num * 10);
739 * };
740 * async.detect(object, iterator, function(err, res) {
741 * console.log(res); // 1
742 * console.log(order); // [1]
743 * });
744 *
745 * @example
746 *
747 * // object with key
748 * var order = [];
749 * var object = { a: 1, b: 3, c: 2 };
750 * var iterator = function(num, key, done) {
751 * setTimeout(function() {
752 * order.push([num, key]);
753 * done(null, num % 2);
754 * }, num * 10);
755 * };
756 * async.detect(object, iterator, function(err, res) {
757 * console.log(res); // 1
758 * console.log(order); // [[1, 'a']]
759 * });
760 *
761 */
762 var detect = createDetect(arrayEachValue, baseEachValue, symbolEachValue, true);
763
764 /**
765 * @memberof async
766 * @namespace detectSeries
767 * @param {Array|Object} collection
768 * @param {Function} iterator
769 * @param {Function} callback
770 * @example
771 *
772 * // array
773 * var order = [];
774 * var array = [1, 3, 2];
775 * var iterator = function(num, done) {
776 * setTimeout(function() {
777 * order.push(num);
778 * done(null, num % 2);
779 * }, num * 10);
780 * };
781 * async.detectSeries(array, iterator, function(err, res) {
782 * console.log(res); // 1
783 * console.log(order); // [1]
784 * });
785 *
786 * @example
787 *
788 * // array with index
789 * var order = [];
790 * var array = [1, 3, 2];
791 * var iterator = function(num, index, done) {
792 * setTimeout(function() {
793 * order.push([num, index]);
794 * done(null, num % 2);
795 * }, num * 10);
796 * };
797 * async.detectSeries(array, iterator, function(err, res) {
798 * console.log(res); // 1
799 * console.log(order); // [[1, 0]]
800 * });
801 *
802 * @example
803 *
804 * // object
805 * var order = [];
806 * var object = { a: 1, b: 3, c: 2 };
807 * var iterator = function(num, done) {
808 * setTimeout(function() {
809 * order.push(num);
810 * done(null, num % 2);
811 * }, num * 10);
812 * };
813 * async.detectSeries(object, iterator, function(err, res) {
814 * console.log(res); // 1
815 * console.log(order); // [1]
816 * });
817 *
818 * @example
819 *
820 * // object with key
821 * var order = [];
822 * var object = { a: 1, b: 3, c: 2 };
823 * var iterator = function(num, key, done) {
824 * setTimeout(function() {
825 * order.push([num, key]);
826 * done(null, num % 2);
827 * }, num * 10);
828 * };
829 * async.detectSeries(object, iterator, function(err, res) {
830 * console.log(res); // 1
831 * console.log(order); // [[1, 'a']]
832 * });
833 *
834 */
835 var detectSeries = createDetectSeries(true);
836
837 /**
838 * @memberof async
839 * @namespace detectLimit
840 * @param {Array|Object} collection
841 * @param {number} limit - limit >= 1
842 * @param {Function} iterator
843 * @param {Function} callback
844 * @example
845 *
846 * // array
847 * var order = [];
848 * var array = [1, 5, 3, 4, 2];
849 * var iterator = function(num, done) {
850 * setTimeout(function() {
851 * order.push(num);
852 * done(null, num % 2);
853 * }, num * 10);
854 * };
855 * async.detectLimit(array, 2, iterator, function(err, res) {
856 * console.log(res); // 1
857 * console.log(order); // [1]
858 * });
859 *
860 * @example
861 *
862 * // array with index
863 * var order = [];
864 * var array = [1, 5, 3, 4, 2];
865 * var iterator = function(num, index, done) {
866 * setTimeout(function() {
867 * order.push([num, index]);
868 * done(null, num % 2);
869 * }, num * 10);
870 * };
871 * async.detectLimit(array, 2, iterator, function(err, res) {
872 * console.log(res); // 1
873 * console.log(order); // [[1, 0]]
874 * });
875 *
876 * @example
877 *
878 * // object
879 * var order = [];
880 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
881 * var iterator = function(num, done) {
882 * setTimeout(function() {
883 * order.push(num);
884 * done(null, num % 2);
885 * }, num * 10);
886 * };
887 * async.detectLimit(object, 2, iterator, function(err, res) {
888 * console.log(res); // 1
889 * console.log(order); // [1]
890 * });
891 *
892 * @example
893 *
894 * // object with key
895 * var order = [];
896 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
897 * var iterator = function(num, key, done) {
898 * setTimeout(function() {
899 * order.push([num, key]);
900 * done(null, num % 2);
901 * }, num * 10);
902 * };
903 * async.detectLimit(object, 2, iterator, function(err, res) {
904 * console.log(res); // 1
905 * console.log(order); // [[1, 'a']]
906 * });
907 *
908 */
909 var detectLimit = createDetectLimit(true);
910
911 /**
912 * @memberof async
913 * @namespace every
914 * @param {Array|Object} collection
915 * @param {Function} iterator
916 * @param {Function} callback
917 * @example
918 *
919 * // array
920 * var order = [];
921 * var array = [1, 3, 2];
922 * var iterator = function(num, done) {
923 * setTimeout(function() {
924 * order.push(num);
925 * done(null, num % 2);
926 * }, num * 10);
927 * };
928 * async.every(array, iterator, function(err, res) {
929 * console.log(res); // false
930 * console.log(order); // [1, 2]
931 * });
932 *
933 * @example
934 *
935 * // array with index
936 * var order = [];
937 * var array = [1, 3, 2];
938 * var iterator = function(num, index, done) {
939 * setTimeout(function() {
940 * order.push([num, index]);
941 * done(null, num % 2);
942 * }, num * 10);
943 * };
944 * async.every(array, iterator, function(err, res) {
945 * console.log(res); // false
946 * console.log(order); // [[1, 0], [2, 2]]
947 * });
948 *
949 * @example
950 *
951 * // object
952 * var order = [];
953 * var object = { a: 1, b: 3, c: 2 };
954 * var iterator = function(num, done) {
955 * setTimeout(function() {
956 * order.push(num);
957 * done(null, num % 2);
958 * }, num * 10);
959 * };
960 * async.every(object, iterator, function(err, res) {
961 * console.log(res); // false
962 * console.log(order); // [1, 2]
963 * });
964 *
965 * @example
966 *
967 * // object with key
968 * var order = [];
969 * var object = { a: 1, b: 3, c: 2 };
970 * var iterator = function(num, key, done) {
971 * setTimeout(function() {
972 * order.push([num, key]);
973 * done(null, num % 2);
974 * }, num * 10);
975 * };
976 * async.every(object, iterator, function(err, res) {
977 * console.log(res); // false
978 * console.log(order); // [[1, 'a'], [2, 'c']]
979 * });
980 *
981 */
982 var every = createEvery(arrayEachValue, baseEachValue, symbolEachValue);
983
984 /**
985 * @memberof async
986 * @namespace everySeries
987 * @param {Array|Object} collection
988 * @param {Function} iterator
989 * @param {Function} callback
990 * @example
991 *
992 * // array
993 * var order = [];
994 * var array = [1, 3, 2];
995 * var iterator = function(num, done) {
996 * setTimeout(function() {
997 * order.push(num);
998 * done(null, num % 2);
999 * }, num * 10);
1000 * };
1001 * async.everySeries(array, iterator, function(err, res) {
1002 * console.log(res); // false
1003 * console.log(order); // [1, 3, 2]
1004 * });
1005 *
1006 * @example
1007 *
1008 * // array with index
1009 * var order = [];
1010 * var array = [1, 3, 2];
1011 * var iterator = function(num, index, done) {
1012 * setTimeout(function() {
1013 * order.push([num, index]);
1014 * done(null, num % 2);
1015 * }, num * 10);
1016 * };
1017 * async.everySeries(array, iterator, function(err, res) {
1018 * console.log(res); // false
1019 * console.log(order); // [[1, 0], [3, 1], [2, 2]]
1020 * });
1021 *
1022 * @example
1023 *
1024 * // object
1025 * var order = [];
1026 * var object = { a: 1, b: 3, c: 2 };
1027 * var iterator = function(num, done) {
1028 * setTimeout(function() {
1029 * order.push(num);
1030 * done(null, num % 2);
1031 * }, num * 10);
1032 * };
1033 * async.everySeries(object, iterator, function(err, res) {
1034 * console.log(res); // false
1035 * console.log(order); // [1, 3, 2]
1036 * });
1037 *
1038 * @example
1039 *
1040 * // object with key
1041 * var order = [];
1042 * var object = { a: 1, b: 3, c: 2 };
1043 * var iterator = function(num, key, done) {
1044 * setTimeout(function() {
1045 * order.push([num, key]);
1046 * done(null, num % 2);
1047 * }, num * 10);
1048 * };
1049 * async.everySeries(object, iterator, function(err, res) {
1050 * console.log(res); // false
1051 * console.log(order); // [[1, 'a'], [3, 'b'] [2, 'c']]
1052 * });
1053 *
1054 */
1055 var everySeries = createEverySeries();
1056
1057 /**
1058 * @memberof async
1059 * @namespace everyLimit
1060 * @param {Array|Object} collection
1061 * @param {number} limit - limit >= 1
1062 * @param {Function} iterator
1063 * @param {Function} callback
1064 * @example
1065 *
1066 * // array
1067 * var order = [];
1068 * var array = [1, 5, 3, 4, 2];
1069 * var iterator = function(num, done) {
1070 * setTimeout(function() {
1071 * order.push(num);
1072 * done(null, num % 2);
1073 * }, num * 10);
1074 * };
1075 * async.everyLimit(array, 2, iterator, function(err, res) {
1076 * console.log(res); // false
1077 * console.log(order); // [1, 3, 5, 2]
1078 * });
1079 *
1080 * @example
1081 *
1082 * // array with index
1083 * var order = [];
1084 * var array = [1, 5, 3, 4, 2];
1085 * var iterator = function(num, index, done) {
1086 * setTimeout(function() {
1087 * order.push([num, index]);
1088 * done(null, num % 2);
1089 * }, num * 10);
1090 * };
1091 * async.everyLimit(array, 2, iterator, function(err, res) {
1092 * console.log(res); // false
1093 * console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4]]
1094 * });
1095 *
1096 * @example
1097 *
1098 * // object
1099 * var order = [];
1100 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
1101 * var iterator = function(num, done) {
1102 * setTimeout(function() {
1103 * order.push(num);
1104 * done(null, num % 2);
1105 * }, num * 10);
1106 * };
1107 * async.everyLimit(object, 2, iterator, function(err, res) {
1108 * console.log(res); // false
1109 * console.log(order); // [1, 3, 5, 2]
1110 * });
1111 *
1112 * @example
1113 *
1114 * // object with key
1115 * var order = [];
1116 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
1117 * var iterator = function(num, key, done) {
1118 * setTimeout(function() {
1119 * order.push([num, key]);
1120 * done(null, num % 2);
1121 * }, num * 10);
1122 * };
1123 * async.everyLimit(object, 2, iterator, function(err, res) {
1124 * console.log(res); // false
1125 * console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e']]
1126 * });
1127 *
1128 */
1129 var everyLimit = createEveryLimit();
1130
1131 /**
1132 * @memberof async
1133 * @namespace pick
1134 * @param {Array|Object} collection
1135 * @param {Function} iterator
1136 * @param {Function} callback
1137 * @example
1138 *
1139 * // array
1140 * var order = [];
1141 * var array = [1, 3, 2, 4];
1142 * var iterator = function(num, done) {
1143 * setTimeout(function() {
1144 * order.push(num);
1145 * done(null, num % 2);
1146 * }, num * 10);
1147 * };
1148 * async.pick(array, iterator, function(err, res) {
1149 * console.log(res); // { '0': 1, '1': 3 }
1150 * console.log(order); // [1, 2, 3, 4]
1151 * });
1152 *
1153 * @example
1154 *
1155 * // array with index
1156 * var order = [];
1157 * var array = [1, 3, 2, 4];
1158 * var iterator = function(num, index, done) {
1159 * setTimeout(function() {
1160 * order.push([num, index]);
1161 * done(null, num % 2);
1162 * }, num * 10);
1163 * };
1164 * async.pick(array, iterator, function(err, res) {
1165 * console.log(res); // { '0': 1, '1': 3 }
1166 * console.log(order); // [[0, 1], [2, 2], [3, 1], [4, 3]]
1167 * });
1168 *
1169 * @example
1170 *
1171 * // object
1172 * var order = [];
1173 * var object = { a: 1, b: 3, c: 2, d: 4 };
1174 * var iterator = function(num, done) {
1175 * setTimeout(function() {
1176 * order.push(num);
1177 * done(null, num % 2);
1178 * }, num * 10);
1179 * };
1180 * async.pick(object, iterator, function(err, res) {
1181 * console.log(res); // { a: 1, b: 3 }
1182 * console.log(order); // [1, 2, 3, 4]
1183 * });
1184 *
1185 * @example
1186 *
1187 * // object with key
1188 * var order = [];
1189 * var object = { a: 1, b: 3, c: 2, d: 4 };
1190 * var iterator = function(num, key, done) {
1191 * setTimeout(function() {
1192 * order.push([num, key]);
1193 * done(null, num % 2);
1194 * }, num * 10);
1195 * };
1196 * async.pick(object, iterator, function(err, res) {
1197 * console.log(res); // { a: 1, b: 3 }
1198 * console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b'], [4, 'd']]
1199 * });
1200 *
1201 */
1202 var pick = createPick(arrayEachIndexValue, baseEachKeyValue, symbolEachKeyValue, true);
1203
1204 /**
1205 * @memberof async
1206 * @namespace pickSeries
1207 * @param {Array|Object} collection
1208 * @param {Function} iterator
1209 * @param {Function} callback
1210 * @example
1211 *
1212 * // array
1213 * var order = [];
1214 * var array = [1, 3, 2, 4];
1215 * var iterator = function(num, done) {
1216 * setTimeout(function() {
1217 * order.push(num);
1218 * done(null, num % 2);
1219 * }, num * 10);
1220 * };
1221 * async.pickSeries(array, iterator, function(err, res) {
1222 * console.log(res); // { '0': 1, '1': 3 }
1223 * console.log(order); // [1, 3, 2, 4]
1224 * });
1225 *
1226 * @example
1227 *
1228 * // array with index
1229 * var order = [];
1230 * var array = [1, 3, 2, 4];
1231 * var iterator = function(num, index, done) {
1232 * setTimeout(function() {
1233 * order.push([num, index]);
1234 * done(null, num % 2);
1235 * }, num * 10);
1236 * };
1237 * async.pickSeries(array, iterator, function(err, res) {
1238 * console.log(res); // { '0': 1, '1': 3 }
1239 * console.log(order); // [[0, 1], [3, 1], [2, 2], [4, 3]]
1240 * });
1241 *
1242 * @example
1243 *
1244 * // object
1245 * var order = [];
1246 * var object = { a: 1, b: 3, c: 2, d: 4 };
1247 * var iterator = function(num, done) {
1248 * setTimeout(function() {
1249 * order.push(num);
1250 * done(null, num % 2);
1251 * }, num * 10);
1252 * };
1253 * async.pickSeries(object, iterator, function(err, res) {
1254 * console.log(res); // { a: 1, b: 3 }
1255 * console.log(order); // [1, 3, 2, 4]
1256 * });
1257 *
1258 * @example
1259 *
1260 * // object with key
1261 * var order = [];
1262 * var object = { a: 1, b: 3, c: 2, d: 4 };
1263 * var iterator = function(num, key, done) {
1264 * setTimeout(function() {
1265 * order.push([num, key]);
1266 * done(null, num % 2);
1267 * }, num * 10);
1268 * };
1269 * async.pickSeries(object, iterator, function(err, res) {
1270 * console.log(res); // { a: 1, b: 3 }
1271 * console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c'], [4, 'd']]
1272 * });
1273 *
1274 */
1275 var pickSeries = createPickSeries(true);
1276
1277 /**
1278 * @memberof async
1279 * @namespace pickLimit
1280 * @param {Array|Object} collection
1281 * @param {number} limit - limit >= 1
1282 * @param {Function} iterator
1283 * @param {Function} callback
1284 * @example
1285 *
1286 * // array
1287 * var order = [];
1288 * var array = [1, 5, 3, 4, 2];
1289 * var iterator = function(num, done) {
1290 * setTimeout(function() {
1291 * order.push(num);
1292 * done(null, num % 2);
1293 * }, num * 10);
1294 * };
1295 * async.pickLimit(array, 2, iterator, function(err, res) {
1296 * console.log(res); // { '0': 1, '1': 5, '2': 3 }
1297 * console.log(order); // [1, 3, 5, 2, 4]
1298 * });
1299 *
1300 * @example
1301 *
1302 * // array with index
1303 * var order = [];
1304 * var array = [1, 5, 3, 4, 2];
1305 * var iterator = function(num, index, done) {
1306 * setTimeout(function() {
1307 * order.push([num, index]);
1308 * done(null, num % 2);
1309 * }, num * 10);
1310 * };
1311 * async.pickLimit(array, 2, iterator, function(err, res) {
1312 * console.log(res); // { '0': 1, '1': 5, '2': 3 }
1313 * console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
1314 * });
1315 *
1316 * @example
1317 *
1318 * // object
1319 * var order = [];
1320 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
1321 * var iterator = function(num, done) {
1322 * setTimeout(function() {
1323 * order.push(num);
1324 * done(null, num % 2);
1325 * }, num * 10);
1326 * };
1327 * async.pickLimit(object, 2, iterator, function(err, res) {
1328 * console.log(res); // { a: 1, b: 5, c: 3 }
1329 * console.log(order); // [1, 3, 5, 2, 4]
1330 * });
1331 *
1332 * @example
1333 *
1334 * // object with key
1335 * var order = [];
1336 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
1337 * var iterator = function(num, key, done) {
1338 * setTimeout(function() {
1339 * order.push([num, key]);
1340 * done(null, num % 2);
1341 * }, num * 10);
1342 * };
1343 * async.pickLimit(object, 2, iterator, function(err, res) {
1344 * console.log(res); // { a: 1, b: 5, c: 3 }
1345 * console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
1346 * });
1347 *
1348 */
1349 var pickLimit = createPickLimit(true);
1350
1351 /**
1352 * @memberof async
1353 * @namespace omit
1354 * @param {Array|Object} collection
1355 * @param {Function} iterator
1356 * @param {Function} callback
1357 * @example
1358 *
1359 * // array
1360 * var order = [];
1361 * var array = [1, 3, 2, 4];
1362 * var iterator = function(num, done) {
1363 * setTimeout(function() {
1364 * order.push(num);
1365 * done(null, num % 2);
1366 * }, num * 10);
1367 * };
1368 * async.omit(array, iterator, function(err, res) {
1369 * console.log(res); // { '2': 2, '3': 4 }
1370 * console.log(order); // [1, 2, 3, 4]
1371 * });
1372 *
1373 * @example
1374 *
1375 * // array with index
1376 * var order = [];
1377 * var array = [1, 3, 2, 4];
1378 * var iterator = function(num, index, done) {
1379 * setTimeout(function() {
1380 * order.push([num, index]);
1381 * done(null, num % 2);
1382 * }, num * 10);
1383 * };
1384 * async.omit(array, iterator, function(err, res) {
1385 * console.log(res); // { '2': 2, '3': 4 }
1386 * console.log(order); // [[0, 1], [2, 2], [3, 1], [4, 3]]
1387 * });
1388 *
1389 * @example
1390 *
1391 * // object
1392 * var order = [];
1393 * var object = { a: 1, b: 3, c: 2, d: 4 };
1394 * var iterator = function(num, done) {
1395 * setTimeout(function() {
1396 * order.push(num);
1397 * done(null, num % 2);
1398 * }, num * 10);
1399 * };
1400 * async.omit(object, iterator, function(err, res) {
1401 * console.log(res); // { c: 2, d: 4 }
1402 * console.log(order); // [1, 2, 3, 4]
1403 * });
1404 *
1405 * @example
1406 *
1407 * // object with key
1408 * var order = [];
1409 * var object = { a: 1, b: 3, c: 2, d: 4 };
1410 * var iterator = function(num, key, done) {
1411 * setTimeout(function() {
1412 * order.push([num, key]);
1413 * done(null, num % 2);
1414 * }, num * 10);
1415 * };
1416 * async.omit(object, iterator, function(err, res) {
1417 * console.log(res); // { c: 2, d: 4 }
1418 * console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b'], [4, 'd']]
1419 * });
1420 *
1421 */
1422 var omit = createPick(arrayEachIndexValue, baseEachKeyValue, symbolEachKeyValue, false);
1423
1424 /**
1425 * @memberof async
1426 * @namespace omitSeries
1427 * @param {Array|Object} collection
1428 * @param {Function} iterator
1429 * @param {Function} callback
1430 * @example
1431 *
1432 * // array
1433 * var order = [];
1434 * var array = [1, 3, 2, 4];
1435 * var iterator = function(num, done) {
1436 * setTimeout(function() {
1437 * order.push(num);
1438 * done(null, num % 2);
1439 * }, num * 10);
1440 * };
1441 * async.omitSeries(array, iterator, function(err, res) {
1442 * console.log(res); // { '2': 2, '3': 4 }
1443 * console.log(order); // [1, 3, 2, 4]
1444 * });
1445 *
1446 * @example
1447 *
1448 * // array with index
1449 * var order = [];
1450 * var array = [1, 3, 2, 4];
1451 * var iterator = function(num, index, done) {
1452 * setTimeout(function() {
1453 * order.push([num, index]);
1454 * done(null, num % 2);
1455 * }, num * 10);
1456 * };
1457 * async.omitSeries(array, iterator, function(err, res) {
1458 * console.log(res); // { '2': 2, '3': 4 }
1459 * console.log(order); // [[0, 1], [3, 1], [2, 2], [4, 3]]
1460 * });
1461 *
1462 * @example
1463 *
1464 * // object
1465 * var order = [];
1466 * var object = { a: 1, b: 3, c: 2, d: 4 };
1467 * var iterator = function(num, done) {
1468 * setTimeout(function() {
1469 * order.push(num);
1470 * done(null, num % 2);
1471 * }, num * 10);
1472 * };
1473 * async.omitSeries(object, iterator, function(err, res) {
1474 * console.log(res); // { c: 2, d: 4 }
1475 * console.log(order); // [1, 3, 2, 4]
1476 * });
1477 *
1478 * @example
1479 *
1480 * // object with key
1481 * var order = [];
1482 * var object = { a: 1, b: 3, c: 2, d: 4 };
1483 * var iterator = function(num, key, done) {
1484 * setTimeout(function() {
1485 * order.push([num, key]);
1486 * done(null, num % 2);
1487 * }, num * 10);
1488 * };
1489 * async.omitSeries(object, iterator, function(err, res) {
1490 * console.log(res); // { c: 2, d: 4 }
1491 * console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c'], [4, 'd']]
1492 * });
1493 *
1494 */
1495 var omitSeries = createPickSeries(false);
1496
1497 /**
1498 * @memberof async
1499 * @namespace omitLimit
1500 * @param {Array|Object} collection
1501 * @param {number} limit - limit >= 1
1502 * @param {Function} iterator
1503 * @param {Function} callback
1504 * @example
1505 *
1506 * // array
1507 * var order = [];
1508 * var array = [1, 5, 3, 4, 2];
1509 * var iterator = function(num, done) {
1510 * setTimeout(function() {
1511 * order.push(num);
1512 * done(null, num % 2);
1513 * }, num * 10);
1514 * };
1515 * async.omitLimit(array, 2, iterator, function(err, res) {
1516 * console.log(res); // { '3': 4, '4': 2 }
1517 * console.log(order); // [1, 3, 5, 2, 4]
1518 * });
1519 *
1520 * @example
1521 *
1522 * // array with index
1523 * var order = [];
1524 * var array = [1, 5, 3, 4, 2];
1525 * var iterator = function(num, index, done) {
1526 * setTimeout(function() {
1527 * order.push([num, index]);
1528 * done(null, num % 2);
1529 * }, num * 10);
1530 * };
1531 * async.omitLimit(array, 2, iterator, function(err, res) {
1532 * console.log(res); // { '3': 4, '4': 2 }
1533 * console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
1534 * });
1535 *
1536 * @example
1537 *
1538 * // object
1539 * var order = [];
1540 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
1541 * var iterator = function(num, done) {
1542 * setTimeout(function() {
1543 * order.push(num);
1544 * done(null, num % 2);
1545 * }, num * 10);
1546 * };
1547 * async.omitLimit(object, 2, iterator, function(err, res) {
1548 * console.log(res); // { d: 4, e: 2 }
1549 * console.log(order); // [1, 3, 5, 2, 4]
1550 * });
1551 *
1552 * @example
1553 *
1554 * // object with key
1555 * var order = [];
1556 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
1557 * var iterator = function(num, key, done) {
1558 * setTimeout(function() {
1559 * order.push([num, key]);
1560 * done(null, num % 2);
1561 * }, num * 10);
1562 * };
1563 * async.omitLimit(object, 2, iterator, function(err, res) {
1564 * console.log(res); // { d: 4, e: 2 }
1565 * console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
1566 * });
1567 *
1568 */
1569 var omitLimit = createPickLimit(false);
1570
1571 /**
1572 * @memberof async
1573 * @namespace transform
1574 * @param {Array|Object} collection
1575 * @param {Array|Object|Function} [accumulator]
1576 * @param {Function} [iterator]
1577 * @param {Function} [callback]
1578 * @example
1579 *
1580 * // array
1581 * var order = [];
1582 * var collection = [1, 3, 2, 4];
1583 * var iterator = function(result, num, done) {
1584 * setTimeout(function() {
1585 * order.push(num);
1586 * result.push(num)
1587 * done();
1588 * }, num * 10);
1589 * };
1590 * async.transform(collection, iterator, function(err, res) {
1591 * console.log(res); // [1, 2, 3, 4]
1592 * console.log(order); // [1, 2, 3, 4]
1593 * });
1594 *
1595 * @example
1596 *
1597 * // array with index and accumulator
1598 * var order = [];
1599 * var collection = [1, 3, 2, 4];
1600 * var iterator = function(result, num, index, done) {
1601 * setTimeout(function() {
1602 * order.push([num, index]);
1603 * result[index] = num;
1604 * done();
1605 * }, num * 10);
1606 * };
1607 * async.transform(collection, {}, iterator, function(err, res) {
1608 * console.log(res); // { '0': 1, '1': 3, '2': 2, '3': 4 }
1609 * console.log(order); // [[1, 0], [2, 2], [3, 1], [4, 3]]
1610 * });
1611 *
1612 * @example
1613 *
1614 * // object with accumulator
1615 * var order = [];
1616 * var object = { a: 1, b: 3, c: 2, d: 4 };
1617 * var iterator = function(result, num, done) {
1618 * setTimeout(function() {
1619 * order.push(num);
1620 * result.push(num);
1621 * done();
1622 * }, num * 10);
1623 * };
1624 * async.transform(collection, [], iterator, function(err, res) {
1625 * console.log(res); // [1, 2, 3, 4]
1626 * console.log(order); // [1, 2, 3, 4]
1627 * });
1628 *
1629 * @example
1630 *
1631 * // object with key
1632 * var order = [];
1633 * var object = { a: 1, b: 3, c: 2, d: 4 };
1634 * var iterator = function(result, num, key, done) {
1635 * setTimeout(function() {
1636 * order.push([num, key]);
1637 * result[key] = num;
1638 * done();
1639 * }, num * 10);
1640 * };
1641 * async.transform(collection, iterator, function(err, res) {
1642 * console.log(res); // { a: 1, b: 3, c: 2, d: 4 }
1643 * console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b'], [4, 'd']]
1644 * });
1645 *
1646 */
1647 var transform = createTransform(arrayEachResult, baseEachResult, symbolEachResult);
1648
1649 /**
1650 * @memberof async
1651 * @namespace sortBy
1652 * @param {Array|Object} collection
1653 * @param {Function} iterator
1654 * @param {Function} callback
1655 * @example
1656 *
1657 * // array
1658 * var order = [];
1659 * var array = [1, 3, 2];
1660 * var iterator = function(num, done) {
1661 * setTimeout(function() {
1662 * order.push(num);
1663 * done(null, num);
1664 * }, num * 10);
1665 * };
1666 * async.sortBy(array, iterator, function(err, res) {
1667 * console.log(res); // [1, 2, 3];
1668 * console.log(order); // [1, 2, 3]
1669 * });
1670 *
1671 * @example
1672 *
1673 * // array with index
1674 * var order = [];
1675 * var array = [1, 3, 2];
1676 * var iterator = function(num, index, done) {
1677 * setTimeout(function() {
1678 * order.push([num, index]);
1679 * done(null, num);
1680 * }, num * 10);
1681 * };
1682 * async.sortBy(array, iterator, function(err, res) {
1683 * console.log(res); // [1, 2, 3]
1684 * console.log(order); // [[1, 0], [2, 2], [3, 1]]
1685 * });
1686 *
1687 * @example
1688 *
1689 * // object
1690 * var order = [];
1691 * var object = { a: 1, b: 3, c: 2 };
1692 * var iterator = function(num, done) {
1693 * setTimeout(function() {
1694 * order.push(num);
1695 * done(null, num);
1696 * }, num * 10);
1697 * };
1698 * async.sortBy(object, iterator, function(err, res) {
1699 * console.log(res); // [1, 2, 3]
1700 * console.log(order); // [1, 2, 3]
1701 * });
1702 *
1703 * @example
1704 *
1705 * // object with key
1706 * var order = [];
1707 * var object = { a: 1, b: 3, c: 2 };
1708 * var iterator = function(num, key, done) {
1709 * setTimeout(function() {
1710 * order.push([num, key]);
1711 * done(null, num);
1712 * }, num * 10);
1713 * };
1714 * async.sortBy(object, iterator, function(err, res) {
1715 * console.log(res); // [1, 2, 3]
1716 * console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b']]
1717 * });
1718 *
1719 */
1720 var sortBy = createSortBy(arrayEachIndexValue, baseEachIndexValue, symbolEachIndexValue);
1721
1722 /**
1723 * @memberof async
1724 * @namespace concat
1725 * @param {Array|Object} collection
1726 * @param {Function} iterator
1727 * @param {Function} callback
1728 * @example
1729 *
1730 * // array
1731 * var order = [];
1732 * var array = [1, 3, 2];
1733 * var iterator = function(num, done) {
1734 * setTimeout(function() {
1735 * order.push(num);
1736 * done(null, [num]);
1737 * }, num * 10);
1738 * };
1739 * async.concat(array, iterator, function(err, res) {
1740 * console.log(res); // [1, 2, 3];
1741 * console.log(order); // [1, 2, 3]
1742 * });
1743 *
1744 * @example
1745 *
1746 * // array with index
1747 * var order = [];
1748 * var array = [1, 3, 2];
1749 * var iterator = function(num, index, done) {
1750 * setTimeout(function() {
1751 * order.push([num, index]);
1752 * done(null, [num]);
1753 * }, num * 10);
1754 * };
1755 * async.concat(array, iterator, function(err, res) {
1756 * console.log(res); // [1, 2, 3]
1757 * console.log(order); // [[1, 0], [2, 2], [3, 1]]
1758 * });
1759 *
1760 * @example
1761 *
1762 * // object
1763 * var order = [];
1764 * var object = { a: 1, b: 3, c: 2 };
1765 * var iterator = function(num, done) {
1766 * setTimeout(function() {
1767 * order.push(num);
1768 * done(null, [num]);
1769 * }, num * 10);
1770 * };
1771 * async.concat(object, iterator, function(err, res) {
1772 * console.log(res); // [1, 2, 3]
1773 * console.log(order); // [1, 2, 3]
1774 * });
1775 *
1776 * @example
1777 *
1778 * // object with key
1779 * var order = [];
1780 * var object = { a: 1, b: 3, c: 2 };
1781 * var iterator = function(num, key, done) {
1782 * setTimeout(function() {
1783 * order.push([num, key]);
1784 * done(null, [num]);
1785 * }, num * 10);
1786 * };
1787 * async.concat(object, iterator, function(err, res) {
1788 * console.log(res); // [1, 2, 3]
1789 * console.log(order); // [[1, 'a'], [2, 'c'], [3, 'b']]
1790 * });
1791 *
1792 */
1793 var concat = createConcat(arrayEachIndex, baseEachIndex, symbolEachIndex);
1794
1795 /**
1796 * @memberof async
1797 * @namespace groupBy
1798 * @param {Array|Object} collection
1799 * @param {Function} iterator
1800 * @param {Function} callback
1801 * @example
1802 *
1803 * // array
1804 * var order = [];
1805 * var array = [4.2, 6.4, 6.1];
1806 * var iterator = function(num, done) {
1807 * setTimeout(function() {
1808 * order.push(num);
1809 * done(null, Math.floor(num));
1810 * }, num * 10);
1811 * };
1812 * async.groupBy(array, iterator, function(err, res) {
1813 * console.log(res); // { '4': [4.2], '6': [6.1, 6.4] }
1814 * console.log(order); // [4.2, 6.1, 6.4]
1815 * });
1816 *
1817 * @example
1818 *
1819 * // array with index
1820 * var order = [];
1821 * var array = [4.2, 6.4, 6.1];
1822 * var iterator = function(num, index, done) {
1823 * setTimeout(function() {
1824 * order.push([num, index]);
1825 * done(null, Math.floor(num));
1826 * }, num * 10);
1827 * };
1828 * async.groupBy(array, iterator, function(err, res) {
1829 * console.log(res); // { '4': [4.2], '6': [6.1, 6.4] }
1830 * console.log(order); // [[4.2, 0], [6.1, 2], [6.4, 1]]
1831 * });
1832 *
1833 * @example
1834 *
1835 * // object
1836 * var order = [];
1837 * var object = { a: 4.2, b: 6.4, c: 6.1 };
1838 * var iterator = function(num, done) {
1839 * setTimeout(function() {
1840 * order.push(num);
1841 * done(null, Math.floor(num));
1842 * }, num * 10);
1843 * };
1844 * async.groupBy(object, iterator, function(err, res) {
1845 * console.log(res); // { '4': [4.2], '6': [6.1, 6.4] }
1846 * console.log(order); // [4.2, 6.1, 6.4]
1847 * });
1848 *
1849 * @example
1850 *
1851 * // object with key
1852 * var order = [];
1853 * var object = { a: 4.2, b: 6.4, c: 6.1 };
1854 * var iterator = function(num, key, done) {
1855 * setTimeout(function() {
1856 * order.push([num, key]);
1857 * done(null, Math.floor(num));
1858 * }, num * 10);
1859 * };
1860 * async.groupBy(object, iterator, function(err, res) {
1861 * console.log(res); // { '4': [4.2], '6': [6.1, 6.4] }
1862 * console.log(order); // [[4.2, 'a'], [6.1, 'c'], [6.4, 'b']]
1863 * });
1864 *
1865 */
1866 var groupBy = createGroupBy(arrayEachValue, baseEachValue, symbolEachValue);
1867
1868 /**
1869 * @memberof async
1870 * @namespace parallel
1871 * @param {Array|Object} tasks - functions
1872 * @param {Function} callback
1873 * @example
1874 *
1875 * var order = [];
1876 * var tasks = [
1877 * function(done) {
1878 * setTimeout(function() {
1879 * order.push(1);
1880 * done(null, 1);
1881 * }, 10);
1882 * },
1883 * function(done) {
1884 * setTimeout(function() {
1885 * order.push(2);
1886 * done(null, 2);
1887 * }, 30);
1888 * },
1889 * function(done) {
1890 * setTimeout(function() {
1891 * order.push(3);
1892 * done(null, 3);
1893 * }, 40);
1894 * },
1895 * function(done) {
1896 * setTimeout(function() {
1897 * order.push(4);
1898 * done(null, 4);
1899 * }, 20);
1900 * }
1901 * ];
1902 * async.parallel(tasks, function(err, res) {
1903 * console.log(res); // [1, 2, 3, 4];
1904 * console.log(order); // [1, 4, 2, 3]
1905 * });
1906 *
1907 * @example
1908 *
1909 * var order = [];
1910 * var tasks = {
1911 * 'a': function(done) {
1912 * setTimeout(function() {
1913 * order.push(1);
1914 * done(null, 1);
1915 * }, 10);
1916 * },
1917 * 'b': function(done) {
1918 * setTimeout(function() {
1919 * order.push(2);
1920 * done(null, 2);
1921 * }, 30);
1922 * },
1923 * 'c': function(done) {
1924 * setTimeout(function() {
1925 * order.push(3);
1926 * done(null, 3);
1927 * }, 40);
1928 * },
1929 * 'd': function(done) {
1930 * setTimeout(function() {
1931 * order.push(4);
1932 * done(null, 4);
1933 * }, 20);
1934 * }
1935 * };
1936 * async.parallel(tasks, function(err, res) {
1937 * console.log(res); // { a: 1, b: 2, c: 3, d:4 }
1938 * console.log(order); // [1, 4, 2, 3]
1939 * });
1940 *
1941 */
1942 var parallel = createParallel(arrayEachFunc, baseEachFunc);
1943
1944 /**
1945 * @memberof async
1946 * @namespace applyEach
1947 */
1948 var applyEach = createApplyEach(map);
1949
1950 /**
1951 * @memberof async
1952 * @namespace applyEachSeries
1953 */
1954 var applyEachSeries = createApplyEach(mapSeries);
1955
1956 /**
1957 * @memberof async
1958 * @namespace log
1959 */
1960 var log = createLogger('log');
1961
1962 /**
1963 * @memberof async
1964 * @namespace dir
1965 */
1966 var dir = createLogger('dir');
1967
1968 /**
1969 * @version 2.6.2
1970 * @namespace async
1971 */
1972 var index = {
1973 VERSION: '2.6.2',
1974
1975 // Collections
1976 each: each,
1977 eachSeries: eachSeries,
1978 eachLimit: eachLimit,
1979 forEach: each,
1980 forEachSeries: eachSeries,
1981 forEachLimit: eachLimit,
1982 eachOf: each,
1983 eachOfSeries: eachSeries,
1984 eachOfLimit: eachLimit,
1985 forEachOf: each,
1986 forEachOfSeries: eachSeries,
1987 forEachOfLimit: eachLimit,
1988 map: map,
1989 mapSeries: mapSeries,
1990 mapLimit: mapLimit,
1991 mapValues: mapValues,
1992 mapValuesSeries: mapValuesSeries,
1993 mapValuesLimit: mapValuesLimit,
1994 filter: filter,
1995 filterSeries: filterSeries,
1996 filterLimit: filterLimit,
1997 select: filter,
1998 selectSeries: filterSeries,
1999 selectLimit: filterLimit,
2000 reject: reject,
2001 rejectSeries: rejectSeries,
2002 rejectLimit: rejectLimit,
2003 detect: detect,
2004 detectSeries: detectSeries,
2005 detectLimit: detectLimit,
2006 find: detect,
2007 findSeries: detectSeries,
2008 findLimit: detectLimit,
2009 pick: pick,
2010 pickSeries: pickSeries,
2011 pickLimit: pickLimit,
2012 omit: omit,
2013 omitSeries: omitSeries,
2014 omitLimit: omitLimit,
2015 reduce: reduce,
2016 inject: reduce,
2017 foldl: reduce,
2018 reduceRight: reduceRight,
2019 foldr: reduceRight,
2020 transform: transform,
2021 transformSeries: transformSeries,
2022 transformLimit: transformLimit,
2023 sortBy: sortBy,
2024 sortBySeries: sortBySeries,
2025 sortByLimit: sortByLimit,
2026 some: some,
2027 someSeries: someSeries,
2028 someLimit: someLimit,
2029 any: some,
2030 anySeries: someSeries,
2031 anyLimit: someLimit,
2032 every: every,
2033 everySeries: everySeries,
2034 everyLimit: everyLimit,
2035 all: every,
2036 allSeries: everySeries,
2037 allLimit: everyLimit,
2038 concat: concat,
2039 concatSeries: concatSeries,
2040 concatLimit: concatLimit,
2041 groupBy: groupBy,
2042 groupBySeries: groupBySeries,
2043 groupByLimit: groupByLimit,
2044
2045 // Control Flow
2046 parallel: parallel,
2047 series: series,
2048 parallelLimit: parallelLimit,
2049 tryEach: tryEach,
2050 waterfall: waterfall,
2051 angelFall: angelFall,
2052 angelfall: angelFall,
2053 whilst: whilst,
2054 doWhilst: doWhilst,
2055 until: until,
2056 doUntil: doUntil,
2057 during: during,
2058 doDuring: doDuring,
2059 forever: forever,
2060 compose: compose,
2061 seq: seq,
2062 applyEach: applyEach,
2063 applyEachSeries: applyEachSeries,
2064 queue: queue,
2065 priorityQueue: priorityQueue,
2066 cargo: cargo,
2067 auto: auto,
2068 autoInject: autoInject,
2069 retry: retry,
2070 retryable: retryable,
2071 iterator: iterator,
2072 times: times,
2073 timesSeries: timesSeries,
2074 timesLimit: timesLimit,
2075 race: race,
2076
2077 // Utils
2078 apply: apply,
2079 nextTick: asyncNextTick,
2080 setImmediate: asyncSetImmediate,
2081 memoize: memoize,
2082 unmemoize: unmemoize,
2083 ensureAsync: ensureAsync,
2084 constant: constant,
2085 asyncify: asyncify,
2086 wrapSync: asyncify,
2087 log: log,
2088 dir: dir,
2089 reflect: reflect,
2090 reflectAll: reflectAll,
2091 timeout: timeout,
2092 createLogger: createLogger,
2093
2094 // Mode
2095 safe: safe,
2096 fast: fast
2097 };
2098
2099 exports['default'] = index;
2100 baseEachSync(
2101 index,
2102 function(func, key) {
2103 exports[key] = func;
2104 },
2105 nativeKeys(index)
2106 );
2107
2108 /**
2109 * @private
2110 */
2111 function createImmediate(safeMode) {
2112 var delay = function delay(fn) {
2113 var args = slice(arguments, 1);
2114 setTimeout(function() {
2115 fn.apply(null, args);
2116 });
2117 };
2118 asyncSetImmediate = typeof setImmediate === func ? setImmediate : delay;
2119 if (typeof process === obj && typeof process.nextTick === func) {
2120 nextTick = /^v0.10/.test(process.version) ? asyncSetImmediate : process.nextTick;
2121 asyncNextTick = /^v0/.test(process.version) ? asyncSetImmediate : process.nextTick;
2122 } else {
2123 asyncNextTick = nextTick = asyncSetImmediate;
2124 }
2125 if (safeMode === false) {
2126 nextTick = function(cb) {
2127 cb();
2128 };
2129 }
2130 }
2131
2132 /* sync functions based on lodash */
2133
2134 /**
2135 * Converts `arguments` to an array.
2136 *
2137 * @private
2138 * @param {Array} array = The array to slice.
2139 */
2140 function createArray(array) {
2141 var index = -1;
2142 var size = array.length;
2143 var result = Array(size);
2144
2145 while (++index < size) {
2146 result[index] = array[index];
2147 }
2148 return result;
2149 }
2150
2151 /**
2152 * Create an array from `start`
2153 *
2154 * @private
2155 * @param {Array} array - The array to slice.
2156 * @param {number} start - The start position.
2157 */
2158 function slice(array, start) {
2159 var end = array.length;
2160 var index = -1;
2161 var size = end - start;
2162 if (size <= 0) {
2163 return [];
2164 }
2165 var result = Array(size);
2166
2167 while (++index < size) {
2168 result[index] = array[index + start];
2169 }
2170 return result;
2171 }
2172
2173 /**
2174 * @private
2175 * @param {Object} object
2176 */
2177 function objectClone(object) {
2178 var keys = nativeKeys(object);
2179 var size = keys.length;
2180 var index = -1;
2181 var result = {};
2182
2183 while (++index < size) {
2184 var key = keys[index];
2185 result[key] = object[key];
2186 }
2187 return result;
2188 }
2189
2190 /**
2191 * Create an array with all falsey values removed.
2192 *
2193 * @private
2194 * @param {Array} array - The array to compact.
2195 */
2196 function compact(array) {
2197 var index = -1;
2198 var size = array.length;
2199 var result = [];
2200
2201 while (++index < size) {
2202 var value = array[index];
2203 if (value) {
2204 result[result.length] = value;
2205 }
2206 }
2207 return result;
2208 }
2209
2210 /**
2211 * Create an array of reverse sequence.
2212 *
2213 * @private
2214 * @param {Array} array - The array to reverse.
2215 */
2216 function reverse(array) {
2217 var index = -1;
2218 var size = array.length;
2219 var result = Array(size);
2220 var resIndex = size;
2221
2222 while (++index < size) {
2223 result[--resIndex] = array[index];
2224 }
2225 return result;
2226 }
2227
2228 /**
2229 * Checks if key exists in object property.
2230 *
2231 * @private
2232 * @param {Object} object - The object to inspect.
2233 * @param {string} key - The key to check.
2234 */
2235 function has(object, key) {
2236 return object.hasOwnProperty(key);
2237 }
2238
2239 /**
2240 * Check if target exists in array.
2241 * @private
2242 * @param {Array} array
2243 * @param {*} target
2244 */
2245 function notInclude(array, target) {
2246 var index = -1;
2247 var size = array.length;
2248
2249 while (++index < size) {
2250 if (array[index] === target) {
2251 return false;
2252 }
2253 }
2254 return true;
2255 }
2256
2257 /**
2258 * @private
2259 * @param {Array} array - The array to iterate over.
2260 * @param {Function} iterator - The function invoked per iteration.
2261 */
2262 function arrayEachSync(array, iterator) {
2263 var index = -1;
2264 var size = array.length;
2265
2266 while (++index < size) {
2267 iterator(array[index], index);
2268 }
2269 return array;
2270 }
2271
2272 /**
2273 * @private
2274 * @param {Object} object - The object to iterate over.
2275 * @param {Function} iterator - The function invoked per iteration.
2276 * @param {Array} keys
2277 */
2278 function baseEachSync(object, iterator, keys) {
2279 var index = -1;
2280 var size = keys.length;
2281
2282 while (++index < size) {
2283 var key = keys[index];
2284 iterator(object[key], key);
2285 }
2286 return object;
2287 }
2288
2289 /**
2290 * @private
2291 * @param {number} n
2292 * @param {Function} iterator
2293 */
2294 function timesSync(n, iterator) {
2295 var index = -1;
2296 while (++index < n) {
2297 iterator(index);
2298 }
2299 }
2300
2301 /**
2302 * @private
2303 * @param {Array} array
2304 * @param {number[]} criteria
2305 */
2306 function sortByCriteria(array, criteria) {
2307 var l = array.length;
2308 var indices = Array(l);
2309 var i;
2310 for (i = 0; i < l; i++) {
2311 indices[i] = i;
2312 }
2313 quickSort(criteria, 0, l - 1, indices);
2314 var result = Array(l);
2315 for (var n = 0; n < l; n++) {
2316 i = indices[n];
2317 result[n] = i === undefined ? array[n] : array[i];
2318 }
2319 return result;
2320 }
2321
2322 function partition(array, i, j, mid, indices) {
2323 var l = i;
2324 var r = j;
2325 while (l <= r) {
2326 i = l;
2327 while (l < r && array[l] < mid) {
2328 l++;
2329 }
2330 while (r >= i && array[r] >= mid) {
2331 r--;
2332 }
2333 if (l > r) {
2334 break;
2335 }
2336 swap(array, indices, l++, r--);
2337 }
2338 return l;
2339 }
2340
2341 function swap(array, indices, l, r) {
2342 var n = array[l];
2343 array[l] = array[r];
2344 array[r] = n;
2345 var i = indices[l];
2346 indices[l] = indices[r];
2347 indices[r] = i;
2348 }
2349
2350 function quickSort(array, i, j, indices) {
2351 if (i === j) {
2352 return;
2353 }
2354 var k = i;
2355 while (++k <= j && array[i] === array[k]) {
2356 var l = k - 1;
2357 if (indices[l] > indices[k]) {
2358 var index = indices[l];
2359 indices[l] = indices[k];
2360 indices[k] = index;
2361 }
2362 }
2363 if (k > j) {
2364 return;
2365 }
2366 var p = array[i] > array[k] ? i : k;
2367 k = partition(array, i, j, array[p], indices);
2368 quickSort(array, i, k - 1, indices);
2369 quickSort(array, k, j, indices);
2370 }
2371
2372 /**
2373 * @Private
2374 */
2375 function makeConcatResult(array) {
2376 var result = [];
2377 arrayEachSync(array, function(value) {
2378 if (value === noop) {
2379 return;
2380 }
2381 if (isArray(value)) {
2382 nativePush.apply(result, value);
2383 } else {
2384 result.push(value);
2385 }
2386 });
2387 return result;
2388 }
2389
2390 /* async functions */
2391
2392 /**
2393 * @private
2394 */
2395 function arrayEach(array, iterator, callback) {
2396 var index = -1;
2397 var size = array.length;
2398
2399 if (iterator.length === 3) {
2400 while (++index < size) {
2401 iterator(array[index], index, onlyOnce(callback));
2402 }
2403 } else {
2404 while (++index < size) {
2405 iterator(array[index], onlyOnce(callback));
2406 }
2407 }
2408 }
2409
2410 /**
2411 * @private
2412 */
2413 function baseEach(object, iterator, callback, keys) {
2414 var key;
2415 var index = -1;
2416 var size = keys.length;
2417
2418 if (iterator.length === 3) {
2419 while (++index < size) {
2420 key = keys[index];
2421 iterator(object[key], key, onlyOnce(callback));
2422 }
2423 } else {
2424 while (++index < size) {
2425 iterator(object[keys[index]], onlyOnce(callback));
2426 }
2427 }
2428 }
2429
2430 /**
2431 * @private
2432 */
2433 function symbolEach(collection, iterator, callback) {
2434 var iter = collection[iteratorSymbol]();
2435 var index = 0;
2436 var item;
2437 if (iterator.length === 3) {
2438 while ((item = iter.next()).done === false) {
2439 iterator(item.value, index++, onlyOnce(callback));
2440 }
2441 } else {
2442 while ((item = iter.next()).done === false) {
2443 index++;
2444 iterator(item.value, onlyOnce(callback));
2445 }
2446 }
2447 return index;
2448 }
2449
2450 /**
2451 * @private
2452 */
2453 function arrayEachResult(array, result, iterator, callback) {
2454 var index = -1;
2455 var size = array.length;
2456
2457 if (iterator.length === 4) {
2458 while (++index < size) {
2459 iterator(result, array[index], index, onlyOnce(callback));
2460 }
2461 } else {
2462 while (++index < size) {
2463 iterator(result, array[index], onlyOnce(callback));
2464 }
2465 }
2466 }
2467
2468 /**
2469 * @private
2470 */
2471 function baseEachResult(object, result, iterator, callback, keys) {
2472 var key;
2473 var index = -1;
2474 var size = keys.length;
2475
2476 if (iterator.length === 4) {
2477 while (++index < size) {
2478 key = keys[index];
2479 iterator(result, object[key], key, onlyOnce(callback));
2480 }
2481 } else {
2482 while (++index < size) {
2483 iterator(result, object[keys[index]], onlyOnce(callback));
2484 }
2485 }
2486 }
2487
2488 /**
2489 * @private
2490 */
2491 function symbolEachResult(collection, result, iterator, callback) {
2492 var item;
2493 var index = 0;
2494 var iter = collection[iteratorSymbol]();
2495
2496 if (iterator.length === 4) {
2497 while ((item = iter.next()).done === false) {
2498 iterator(result, item.value, index++, onlyOnce(callback));
2499 }
2500 } else {
2501 while ((item = iter.next()).done === false) {
2502 index++;
2503 iterator(result, item.value, onlyOnce(callback));
2504 }
2505 }
2506 return index;
2507 }
2508
2509 /**
2510 * @private
2511 */
2512 function arrayEachFunc(array, createCallback) {
2513 var index = -1;
2514 var size = array.length;
2515
2516 while (++index < size) {
2517 array[index](createCallback(index));
2518 }
2519 }
2520
2521 /**
2522 * @private
2523 */
2524 function baseEachFunc(object, createCallback, keys) {
2525 var key;
2526 var index = -1;
2527 var size = keys.length;
2528
2529 while (++index < size) {
2530 key = keys[index];
2531 object[key](createCallback(key));
2532 }
2533 }
2534
2535 /**
2536 * @private
2537 */
2538 function arrayEachIndex(array, iterator, createCallback) {
2539 var index = -1;
2540 var size = array.length;
2541
2542 if (iterator.length === 3) {
2543 while (++index < size) {
2544 iterator(array[index], index, createCallback(index));
2545 }
2546 } else {
2547 while (++index < size) {
2548 iterator(array[index], createCallback(index));
2549 }
2550 }
2551 }
2552
2553 /**
2554 * @private
2555 */
2556 function baseEachIndex(object, iterator, createCallback, keys) {
2557 var key;
2558 var index = -1;
2559 var size = keys.length;
2560
2561 if (iterator.length === 3) {
2562 while (++index < size) {
2563 key = keys[index];
2564 iterator(object[key], key, createCallback(index));
2565 }
2566 } else {
2567 while (++index < size) {
2568 iterator(object[keys[index]], createCallback(index));
2569 }
2570 }
2571 }
2572
2573 /**
2574 * @private
2575 */
2576 function symbolEachIndex(collection, iterator, createCallback) {
2577 var item;
2578 var index = 0;
2579 var iter = collection[iteratorSymbol]();
2580
2581 if (iterator.length === 3) {
2582 while ((item = iter.next()).done === false) {
2583 iterator(item.value, index, createCallback(index++));
2584 }
2585 } else {
2586 while ((item = iter.next()).done === false) {
2587 iterator(item.value, createCallback(index++));
2588 }
2589 }
2590 return index;
2591 }
2592
2593 /**
2594 * @private
2595 */
2596 function baseEachKey(object, iterator, createCallback, keys) {
2597 var key;
2598 var index = -1;
2599 var size = keys.length;
2600
2601 if (iterator.length === 3) {
2602 while (++index < size) {
2603 key = keys[index];
2604 iterator(object[key], key, createCallback(key));
2605 }
2606 } else {
2607 while (++index < size) {
2608 key = keys[index];
2609 iterator(object[key], createCallback(key));
2610 }
2611 }
2612 }
2613
2614 /**
2615 * @private
2616 */
2617 function symbolEachKey(collection, iterator, createCallback) {
2618 var item;
2619 var index = 0;
2620 var iter = collection[iteratorSymbol]();
2621
2622 if (iterator.length === 3) {
2623 while ((item = iter.next()).done === false) {
2624 iterator(item.value, index, createCallback(index++));
2625 }
2626 } else {
2627 while ((item = iter.next()).done === false) {
2628 iterator(item.value, createCallback(index++));
2629 }
2630 }
2631 return index;
2632 }
2633
2634 /**
2635 * @private
2636 */
2637 function arrayEachValue(array, iterator, createCallback) {
2638 var value;
2639 var index = -1;
2640 var size = array.length;
2641
2642 if (iterator.length === 3) {
2643 while (++index < size) {
2644 value = array[index];
2645 iterator(value, index, createCallback(value));
2646 }
2647 } else {
2648 while (++index < size) {
2649 value = array[index];
2650 iterator(value, createCallback(value));
2651 }
2652 }
2653 }
2654
2655 /**
2656 * @private
2657 */
2658 function baseEachValue(object, iterator, createCallback, keys) {
2659 var key, value;
2660 var index = -1;
2661 var size = keys.length;
2662
2663 if (iterator.length === 3) {
2664 while (++index < size) {
2665 key = keys[index];
2666 value = object[key];
2667 iterator(value, key, createCallback(value));
2668 }
2669 } else {
2670 while (++index < size) {
2671 value = object[keys[index]];
2672 iterator(value, createCallback(value));
2673 }
2674 }
2675 }
2676
2677 /**
2678 * @private
2679 */
2680 function symbolEachValue(collection, iterator, createCallback) {
2681 var value, item;
2682 var index = 0;
2683 var iter = collection[iteratorSymbol]();
2684
2685 if (iterator.length === 3) {
2686 while ((item = iter.next()).done === false) {
2687 value = item.value;
2688 iterator(value, index++, createCallback(value));
2689 }
2690 } else {
2691 while ((item = iter.next()).done === false) {
2692 index++;
2693 value = item.value;
2694 iterator(value, createCallback(value));
2695 }
2696 }
2697 return index;
2698 }
2699
2700 /**
2701 * @private
2702 */
2703 function arrayEachIndexValue(array, iterator, createCallback) {
2704 var value;
2705 var index = -1;
2706 var size = array.length;
2707
2708 if (iterator.length === 3) {
2709 while (++index < size) {
2710 value = array[index];
2711 iterator(value, index, createCallback(index, value));
2712 }
2713 } else {
2714 while (++index < size) {
2715 value = array[index];
2716 iterator(value, createCallback(index, value));
2717 }
2718 }
2719 }
2720
2721 /**
2722 * @private
2723 */
2724 function baseEachIndexValue(object, iterator, createCallback, keys) {
2725 var key, value;
2726 var index = -1;
2727 var size = keys.length;
2728
2729 if (iterator.length === 3) {
2730 while (++index < size) {
2731 key = keys[index];
2732 value = object[key];
2733 iterator(value, key, createCallback(index, value));
2734 }
2735 } else {
2736 while (++index < size) {
2737 value = object[keys[index]];
2738 iterator(value, createCallback(index, value));
2739 }
2740 }
2741 }
2742
2743 /**
2744 * @private
2745 */
2746 function symbolEachIndexValue(collection, iterator, createCallback) {
2747 var value, item;
2748 var index = 0;
2749 var iter = collection[iteratorSymbol]();
2750
2751 if (iterator.length === 3) {
2752 while ((item = iter.next()).done === false) {
2753 value = item.value;
2754 iterator(value, index, createCallback(index++, value));
2755 }
2756 } else {
2757 while ((item = iter.next()).done === false) {
2758 value = item.value;
2759 iterator(value, createCallback(index++, value));
2760 }
2761 }
2762 return index;
2763 }
2764
2765 /**
2766 * @private
2767 */
2768 function baseEachKeyValue(object, iterator, createCallback, keys) {
2769 var key, value;
2770 var index = -1;
2771 var size = keys.length;
2772
2773 if (iterator.length === 3) {
2774 while (++index < size) {
2775 key = keys[index];
2776 value = object[key];
2777 iterator(value, key, createCallback(key, value));
2778 }
2779 } else {
2780 while (++index < size) {
2781 key = keys[index];
2782 value = object[key];
2783 iterator(value, createCallback(key, value));
2784 }
2785 }
2786 }
2787
2788 /**
2789 * @private
2790 */
2791 function symbolEachKeyValue(collection, iterator, createCallback) {
2792 var value, item;
2793 var index = 0;
2794 var iter = collection[iteratorSymbol]();
2795
2796 if (iterator.length === 3) {
2797 while ((item = iter.next()).done === false) {
2798 value = item.value;
2799 iterator(value, index, createCallback(index++, value));
2800 }
2801 } else {
2802 while ((item = iter.next()).done === false) {
2803 value = item.value;
2804 iterator(value, createCallback(index++, value));
2805 }
2806 }
2807 return index;
2808 }
2809
2810 /**
2811 * @private
2812 * @param {Function} func
2813 */
2814 function onlyOnce(func) {
2815 return function(err, res) {
2816 var fn = func;
2817 func = throwError;
2818 fn(err, res);
2819 };
2820 }
2821
2822 /**
2823 * @private
2824 * @param {Function} func
2825 */
2826 function once(func) {
2827 return function(err, res) {
2828 var fn = func;
2829 func = noop;
2830 fn(err, res);
2831 };
2832 }
2833
2834 /**
2835 * @private
2836 * @param {Function} arrayEach
2837 * @param {Function} baseEach
2838 */
2839 function createEach(arrayEach, baseEach, symbolEach) {
2840 return function each(collection, iterator, callback) {
2841 callback = once(callback || noop);
2842 var size, keys;
2843 var completed = 0;
2844 if (isArray(collection)) {
2845 size = collection.length;
2846 arrayEach(collection, iterator, done);
2847 } else if (!collection) {
2848 } else if (iteratorSymbol && collection[iteratorSymbol]) {
2849 size = symbolEach(collection, iterator, done);
2850 size && size === completed && callback(null);
2851 } else if (typeof collection === obj) {
2852 keys = nativeKeys(collection);
2853 size = keys.length;
2854 baseEach(collection, iterator, done, keys);
2855 }
2856 if (!size) {
2857 callback(null);
2858 }
2859
2860 function done(err, bool) {
2861 if (err) {
2862 callback = once(callback);
2863 callback(err);
2864 } else if (++completed === size) {
2865 callback(null);
2866 } else if (bool === false) {
2867 callback = once(callback);
2868 callback(null);
2869 }
2870 }
2871 };
2872 }
2873
2874 /**
2875 * @private
2876 * @param {Function} arrayEach
2877 * @param {Function} baseEach
2878 * @param {Function} symbolEach
2879 */
2880 function createMap(arrayEach, baseEach, symbolEach, useArray) {
2881 var init, clone;
2882 if (useArray) {
2883 init = Array;
2884 clone = createArray;
2885 } else {
2886 init = function() {
2887 return {};
2888 };
2889 clone = objectClone;
2890 }
2891
2892 return function(collection, iterator, callback) {
2893 callback = callback || noop;
2894 var size, keys, result;
2895 var completed = 0;
2896
2897 if (isArray(collection)) {
2898 size = collection.length;
2899 result = init(size);
2900 arrayEach(collection, iterator, createCallback);
2901 } else if (!collection) {
2902 } else if (iteratorSymbol && collection[iteratorSymbol]) {
2903 // TODO: size could be changed
2904 result = init(0);
2905 size = symbolEach(collection, iterator, createCallback);
2906 size && size === completed && callback(null, result);
2907 } else if (typeof collection === obj) {
2908 keys = nativeKeys(collection);
2909 size = keys.length;
2910 result = init(size);
2911 baseEach(collection, iterator, createCallback, keys);
2912 }
2913 if (!size) {
2914 callback(null, init());
2915 }
2916
2917 function createCallback(key) {
2918 return function done(err, res) {
2919 if (key === null) {
2920 throwError();
2921 }
2922 if (err) {
2923 key = null;
2924 callback = once(callback);
2925 callback(err, clone(result));
2926 return;
2927 }
2928 result[key] = res;
2929 key = null;
2930 if (++completed === size) {
2931 callback(null, result);
2932 }
2933 };
2934 }
2935 };
2936 }
2937
2938 /**
2939 * @private
2940 * @param {Function} arrayEach
2941 * @param {Function} baseEach
2942 * @param {Function} symbolEach
2943 * @param {boolean} bool
2944 */
2945 function createFilter(arrayEach, baseEach, symbolEach, bool) {
2946 return function(collection, iterator, callback) {
2947 callback = callback || noop;
2948 var size, keys, result;
2949 var completed = 0;
2950
2951 if (isArray(collection)) {
2952 size = collection.length;
2953 result = Array(size);
2954 arrayEach(collection, iterator, createCallback);
2955 } else if (!collection) {
2956 } else if (iteratorSymbol && collection[iteratorSymbol]) {
2957 result = [];
2958 size = symbolEach(collection, iterator, createCallback);
2959 size && size === completed && callback(null, compact(result));
2960 } else if (typeof collection === obj) {
2961 keys = nativeKeys(collection);
2962 size = keys.length;
2963 result = Array(size);
2964 baseEach(collection, iterator, createCallback, keys);
2965 }
2966 if (!size) {
2967 return callback(null, []);
2968 }
2969
2970 function createCallback(index, value) {
2971 return function done(err, res) {
2972 if (index === null) {
2973 throwError();
2974 }
2975 if (err) {
2976 index = null;
2977 callback = once(callback);
2978 callback(err);
2979 return;
2980 }
2981 if (!!res === bool) {
2982 result[index] = value;
2983 }
2984 index = null;
2985 if (++completed === size) {
2986 callback(null, compact(result));
2987 }
2988 };
2989 }
2990 };
2991 }
2992
2993 /**
2994 * @private
2995 * @param {boolean} bool
2996 */
2997 function createFilterSeries(bool) {
2998 return function(collection, iterator, callback) {
2999 callback = onlyOnce(callback || noop);
3000 var size, key, value, keys, iter, item, iterate;
3001 var sync = false;
3002 var completed = 0;
3003 var result = [];
3004
3005 if (isArray(collection)) {
3006 size = collection.length;
3007 iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
3008 } else if (!collection) {
3009 } else if (iteratorSymbol && collection[iteratorSymbol]) {
3010 size = Infinity;
3011 iter = collection[iteratorSymbol]();
3012 iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
3013 } else if (typeof collection === obj) {
3014 keys = nativeKeys(collection);
3015 size = keys.length;
3016 iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
3017 }
3018 if (!size) {
3019 return callback(null, []);
3020 }
3021 iterate();
3022
3023 function arrayIterator() {
3024 value = collection[completed];
3025 iterator(value, done);
3026 }
3027
3028 function arrayIteratorWithIndex() {
3029 value = collection[completed];
3030 iterator(value, completed, done);
3031 }
3032
3033 function symbolIterator() {
3034 item = iter.next();
3035 value = item.value;
3036 item.done ? callback(null, result) : iterator(value, done);
3037 }
3038
3039 function symbolIteratorWithKey() {
3040 item = iter.next();
3041 value = item.value;
3042 item.done ? callback(null, result) : iterator(value, completed, done);
3043 }
3044
3045 function objectIterator() {
3046 key = keys[completed];
3047 value = collection[key];
3048 iterator(value, done);
3049 }
3050
3051 function objectIteratorWithKey() {
3052 key = keys[completed];
3053 value = collection[key];
3054 iterator(value, key, done);
3055 }
3056
3057 function done(err, res) {
3058 if (err) {
3059 callback(err);
3060 return;
3061 }
3062 if (!!res === bool) {
3063 result[result.length] = value;
3064 }
3065 if (++completed === size) {
3066 iterate = throwError;
3067 callback(null, result);
3068 } else if (sync) {
3069 nextTick(iterate);
3070 } else {
3071 sync = true;
3072 iterate();
3073 }
3074 sync = false;
3075 }
3076 };
3077 }
3078
3079 /**
3080 * @private
3081 * @param {boolean} bool
3082 */
3083 function createFilterLimit(bool) {
3084 return function(collection, limit, iterator, callback) {
3085 callback = callback || noop;
3086 var size, index, key, value, keys, iter, item, iterate, result;
3087 var sync = false;
3088 var started = 0;
3089 var completed = 0;
3090
3091 if (isArray(collection)) {
3092 size = collection.length;
3093 iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
3094 } else if (!collection) {
3095 } else if (iteratorSymbol && collection[iteratorSymbol]) {
3096 size = Infinity;
3097 result = [];
3098 iter = collection[iteratorSymbol]();
3099 iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
3100 } else if (typeof collection === obj) {
3101 keys = nativeKeys(collection);
3102 size = keys.length;
3103 iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
3104 }
3105 if (!size || isNaN(limit) || limit < 1) {
3106 return callback(null, []);
3107 }
3108 result = result || Array(size);
3109 timesSync(limit > size ? size : limit, iterate);
3110
3111 function arrayIterator() {
3112 index = started++;
3113 if (index < size) {
3114 value = collection[index];
3115 iterator(value, createCallback(value, index));
3116 }
3117 }
3118
3119 function arrayIteratorWithIndex() {
3120 index = started++;
3121 if (index < size) {
3122 value = collection[index];
3123 iterator(value, index, createCallback(value, index));
3124 }
3125 }
3126
3127 function symbolIterator() {
3128 item = iter.next();
3129 if (item.done === false) {
3130 value = item.value;
3131 iterator(value, createCallback(value, started++));
3132 } else if (completed === started && iterator !== noop) {
3133 iterator = noop;
3134 callback(null, compact(result));
3135 }
3136 }
3137
3138 function symbolIteratorWithKey() {
3139 item = iter.next();
3140 if (item.done === false) {
3141 value = item.value;
3142 iterator(value, started, createCallback(value, started++));
3143 } else if (completed === started && iterator !== noop) {
3144 iterator = noop;
3145 callback(null, compact(result));
3146 }
3147 }
3148
3149 function objectIterator() {
3150 index = started++;
3151 if (index < size) {
3152 value = collection[keys[index]];
3153 iterator(value, createCallback(value, index));
3154 }
3155 }
3156
3157 function objectIteratorWithKey() {
3158 index = started++;
3159 if (index < size) {
3160 key = keys[index];
3161 value = collection[key];
3162 iterator(value, key, createCallback(value, index));
3163 }
3164 }
3165
3166 function createCallback(value, index) {
3167 return function(err, res) {
3168 if (index === null) {
3169 throwError();
3170 }
3171 if (err) {
3172 index = null;
3173 iterate = noop;
3174 callback = once(callback);
3175 callback(err);
3176 return;
3177 }
3178 if (!!res === bool) {
3179 result[index] = value;
3180 }
3181 index = null;
3182 if (++completed === size) {
3183 callback = onlyOnce(callback);
3184 callback(null, compact(result));
3185 } else if (sync) {
3186 nextTick(iterate);
3187 } else {
3188 sync = true;
3189 iterate();
3190 }
3191 sync = false;
3192 };
3193 }
3194 };
3195 }
3196
3197 /**
3198 * @memberof async
3199 * @namespace eachSeries
3200 * @param {Array|Object} collection
3201 * @param {Function} iterator
3202 * @param {Function} callback
3203 * @example
3204 *
3205 * // array
3206 * var order = [];
3207 * var array = [1, 3, 2];
3208 * var iterator = function(num, done) {
3209 * setTimeout(function() {
3210 * order.push(num);
3211 * done();
3212 * }, num * 10);
3213 * };
3214 * async.eachSeries(array, iterator, function(err, res) {
3215 * console.log(res); // undefined
3216 * console.log(order); // [1, 3, 2]
3217 * });
3218 *
3219 * @example
3220 *
3221 * // array with index
3222 * var order = [];
3223 * var array = [1, 3, 2];
3224 * var iterator = function(num, index, done) {
3225 * setTimeout(function() {
3226 * order.push([num, index]);
3227 * done();
3228 * }, num * 10);
3229 * };
3230 * async.eachSeries(array, iterator, function(err, res) {
3231 * console.log(res); // undefined
3232 * console.log(order); // [[1, 0], [3, 1], [2, 2]]
3233 * });
3234 *
3235 * @example
3236 *
3237 * // object
3238 * var order = [];
3239 * var object = { a: 1, b: 3, c: 2 };
3240 * var iterator = function(num, done) {
3241 * setTimeout(function() {
3242 * order.push(num);
3243 * done();
3244 * }, num * 10);
3245 * };
3246 * async.eachSeries(object, iterator, function(err, res) {
3247 * console.log(res); // undefined
3248 * console.log(order); // [1, 3, 2]
3249 * });
3250 *
3251 * @example
3252 *
3253 * // object with key
3254 * var order = [];
3255 * var object = { a: 1, b: 3, c: 2 };
3256 * var iterator = function(num, key, done) {
3257 * setTimeout(function() {
3258 * order.push([num, key]);
3259 * done();
3260 * }, num * 10);
3261 * };
3262 * async.eachSeries(object, iterator, function(err, res) {
3263 * console.log(res); // undefined
3264 * console.log(order); // [[1, 'a'], [3, 'b'], [2, 'b']]
3265 * });
3266 *
3267 * @example
3268 *
3269 * // break
3270 * var order = [];
3271 * var array = [1, 3, 2];
3272 * var iterator = function(num, done) {
3273 * setTimeout(function() {
3274 * order.push(num);
3275 * done(null, num !== 3);
3276 * }, num * 10);
3277 * };
3278 * async.eachSeries(array, iterator, function(err, res) {
3279 * console.log(res); // undefined
3280 * console.log(order); // [1, 3]
3281 * });
3282 */
3283 function eachSeries(collection, iterator, callback) {
3284 callback = onlyOnce(callback || noop);
3285 var size, key, keys, iter, item, iterate;
3286 var sync = false;
3287 var completed = 0;
3288
3289 if (isArray(collection)) {
3290 size = collection.length;
3291 iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
3292 } else if (!collection) {
3293 } else if (iteratorSymbol && collection[iteratorSymbol]) {
3294 size = Infinity;
3295 iter = collection[iteratorSymbol]();
3296 iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
3297 } else if (typeof collection === obj) {
3298 keys = nativeKeys(collection);
3299 size = keys.length;
3300 iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
3301 }
3302 if (!size) {
3303 return callback(null);
3304 }
3305 iterate();
3306
3307 function arrayIterator() {
3308 iterator(collection[completed], done);
3309 }
3310
3311 function arrayIteratorWithIndex() {
3312 iterator(collection[completed], completed, done);
3313 }
3314
3315 function symbolIterator() {
3316 item = iter.next();
3317 item.done ? callback(null) : iterator(item.value, done);
3318 }
3319
3320 function symbolIteratorWithKey() {
3321 item = iter.next();
3322 item.done ? callback(null) : iterator(item.value, completed, done);
3323 }
3324
3325 function objectIterator() {
3326 iterator(collection[keys[completed]], done);
3327 }
3328
3329 function objectIteratorWithKey() {
3330 key = keys[completed];
3331 iterator(collection[key], key, done);
3332 }
3333
3334 function done(err, bool) {
3335 if (err) {
3336 callback(err);
3337 } else if (++completed === size || bool === false) {
3338 iterate = throwError;
3339 callback(null);
3340 } else if (sync) {
3341 nextTick(iterate);
3342 } else {
3343 sync = true;
3344 iterate();
3345 }
3346 sync = false;
3347 }
3348 }
3349
3350 /**
3351 * @memberof async
3352 * @namespace eachLimit
3353 * @param {Array|Object} collection
3354 * @param {number} limit - limit >= 1
3355 * @param {Function} iterator
3356 * @param {Function} callback
3357 * @example
3358 *
3359 * // array
3360 * var order = [];
3361 * var array = [1, 5, 3, 4, 2];
3362 * var iterator = function(num, done) {
3363 * setTimeout(function() {
3364 * order.push(num);
3365 * done();
3366 * }, num * 10);
3367 * };
3368 * async.eachLimit(array, 2, iterator, function(err, res) {
3369 * console.log(res); // undefined
3370 * console.log(order); // [1, 3, 5, 2, 4]
3371 * });
3372 *
3373 * @example
3374 *
3375 * // array with index
3376 * var order = [];
3377 * var array = [1, 5, 3, 4, 2];
3378 * var iterator = function(num, index, done) {
3379 * setTimeout(function() {
3380 * order.push([num, index]);
3381 * done();
3382 * }, num * 10);
3383 * };
3384 * async.eachLimit(array, 2, iterator, function(err, res) {
3385 * console.log(res); // undefined
3386 * console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
3387 * });
3388 *
3389 * @example
3390 *
3391 * // object
3392 * var order = [];
3393 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
3394 * var iterator = function(num, done) {
3395 * setTimeout(function() {
3396 * order.push(num);
3397 * done();
3398 * }, num * 10);
3399 * };
3400 * async.eachLimit(object, 2, iterator, function(err, res) {
3401 * console.log(res); // undefined
3402 * console.log(order); // [1, 3, 5, 2, 4]
3403 * });
3404 *
3405 * @example
3406 *
3407 * // object with key
3408 * var order = [];
3409 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
3410 * var iterator = function(num, key, done) {
3411 * setTimeout(function() {
3412 * order.push([num, key]);
3413 * done();
3414 * }, num * 10);
3415 * };
3416 * async.eachLimit(object, 2, iterator, function(err, res) {
3417 * console.log(res); // undefined
3418 * console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
3419 * });
3420 *
3421 * @example
3422 *
3423 * // break
3424 * var order = [];
3425 * var array = [1, 5, 3, 4, 2];
3426 * var iterator = function(num, done) {
3427 * setTimeout(function() {
3428 * order.push(num);
3429 * done(null, num !== 5);
3430 * }, num * 10);
3431 * };
3432 * async.eachLimit(array, 2, iterator, function(err, res) {
3433 * console.log(res); // undefined
3434 * console.log(order); // [1, 3, 5]
3435 * });
3436 *
3437 */
3438 function eachLimit(collection, limit, iterator, callback) {
3439 callback = callback || noop;
3440 var size, index, key, keys, iter, item, iterate;
3441 var sync = false;
3442 var started = 0;
3443 var completed = 0;
3444
3445 if (isArray(collection)) {
3446 size = collection.length;
3447 iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
3448 } else if (!collection) {
3449 } else if (iteratorSymbol && collection[iteratorSymbol]) {
3450 size = Infinity;
3451 iter = collection[iteratorSymbol]();
3452 iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
3453 } else if (typeof collection === obj) {
3454 keys = nativeKeys(collection);
3455 size = keys.length;
3456 iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
3457 } else {
3458 return callback(null);
3459 }
3460 if (!size || isNaN(limit) || limit < 1) {
3461 return callback(null);
3462 }
3463 timesSync(limit > size ? size : limit, iterate);
3464
3465 function arrayIterator() {
3466 if (started < size) {
3467 iterator(collection[started++], done);
3468 }
3469 }
3470
3471 function arrayIteratorWithIndex() {
3472 index = started++;
3473 if (index < size) {
3474 iterator(collection[index], index, done);
3475 }
3476 }
3477
3478 function symbolIterator() {
3479 item = iter.next();
3480 if (item.done === false) {
3481 started++;
3482 iterator(item.value, done);
3483 } else if (completed === started && iterator !== noop) {
3484 iterator = noop;
3485 callback(null);
3486 }
3487 }
3488
3489 function symbolIteratorWithKey() {
3490 item = iter.next();
3491 if (item.done === false) {
3492 iterator(item.value, started++, done);
3493 } else if (completed === started && iterator !== noop) {
3494 iterator = noop;
3495 callback(null);
3496 }
3497 }
3498
3499 function objectIterator() {
3500 if (started < size) {
3501 iterator(collection[keys[started++]], done);
3502 }
3503 }
3504
3505 function objectIteratorWithKey() {
3506 index = started++;
3507 if (index < size) {
3508 key = keys[index];
3509 iterator(collection[key], key, done);
3510 }
3511 }
3512
3513 function done(err, bool) {
3514 if (err || bool === false) {
3515 iterate = noop;
3516 callback = once(callback);
3517 callback(err);
3518 } else if (++completed === size) {
3519 iterator = noop;
3520 iterate = throwError;
3521 callback = onlyOnce(callback);
3522 callback(null);
3523 } else if (sync) {
3524 nextTick(iterate);
3525 } else {
3526 sync = true;
3527 iterate();
3528 }
3529 sync = false;
3530 }
3531 }
3532
3533 /**
3534 * @memberof async
3535 * @namespace mapSeries
3536 * @param {Array|Object} collection
3537 * @param {Function} iterator
3538 * @param {Function} callback
3539 * @example
3540 *
3541 * // array
3542 * var order = [];
3543 * var array = [1, 3, 2];
3544 * var iterator = function(num, done) {
3545 * setTimeout(function() {
3546 * order.push(num);
3547 * done(null, num);
3548 * }, num * 10);
3549 * };
3550 * async.mapSeries(array, iterator, function(err, res) {
3551 * console.log(res); // [1, 3, 2];
3552 * console.log(order); // [1, 3, 2]
3553 * });
3554 *
3555 * @example
3556 *
3557 * // array with index
3558 * var order = [];
3559 * var array = [1, 3, 2];
3560 * var iterator = function(num, index, done) {
3561 * setTimeout(function() {
3562 * order.push([num, index]);
3563 * done(null, num);
3564 * }, num * 10);
3565 * };
3566 * async.mapSeries(array, iterator, function(err, res) {
3567 * console.log(res); // [1, 3, 2]
3568 * console.log(order); // [[1, 0], [3, 1], [2, 2]]
3569 * });
3570 *
3571 * @example
3572 *
3573 * // object
3574 * var order = [];
3575 * var object = { a: 1, b: 3, c: 2 };
3576 * var iterator = function(num, done) {
3577 * setTimeout(function() {
3578 * order.push(num);
3579 * done(null, num);
3580 * }, num * 10);
3581 * };
3582 * async.mapSeries(object, iterator, function(err, res) {
3583 * console.log(res); // [1, 3, 2]
3584 * console.log(order); // [1, 3, 2]
3585 * });
3586 *
3587 * @example
3588 *
3589 * // object with key
3590 * var order = [];
3591 * var object = { a: 1, b: 3, c: 2 };
3592 * var iterator = function(num, key, done) {
3593 * setTimeout(function() {
3594 * order.push([num, key]);
3595 * done(null, num);
3596 * }, num * 10);
3597 * };
3598 * async.mapSeries(object, iterator, function(err, res) {
3599 * console.log(res); // [1, 3, 2]
3600 * console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c']]
3601 * });
3602 *
3603 */
3604 function mapSeries(collection, iterator, callback) {
3605 callback = callback || noop;
3606 var size, key, keys, iter, item, result, iterate;
3607 var sync = false;
3608 var completed = 0;
3609
3610 if (isArray(collection)) {
3611 size = collection.length;
3612 iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
3613 } else if (!collection) {
3614 } else if (iteratorSymbol && collection[iteratorSymbol]) {
3615 size = Infinity;
3616 result = [];
3617 iter = collection[iteratorSymbol]();
3618 iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
3619 } else if (typeof collection === obj) {
3620 keys = nativeKeys(collection);
3621 size = keys.length;
3622 iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
3623 }
3624 if (!size) {
3625 return callback(null, []);
3626 }
3627 result = result || Array(size);
3628 iterate();
3629
3630 function arrayIterator() {
3631 iterator(collection[completed], done);
3632 }
3633
3634 function arrayIteratorWithIndex() {
3635 iterator(collection[completed], completed, done);
3636 }
3637
3638 function symbolIterator() {
3639 item = iter.next();
3640 item.done ? callback(null, result) : iterator(item.value, done);
3641 }
3642
3643 function symbolIteratorWithKey() {
3644 item = iter.next();
3645 item.done ? callback(null, result) : iterator(item.value, completed, done);
3646 }
3647
3648 function objectIterator() {
3649 iterator(collection[keys[completed]], done);
3650 }
3651
3652 function objectIteratorWithKey() {
3653 key = keys[completed];
3654 iterator(collection[key], key, done);
3655 }
3656
3657 function done(err, res) {
3658 if (err) {
3659 iterate = throwError;
3660 callback = onlyOnce(callback);
3661 callback(err, createArray(result));
3662 return;
3663 }
3664 result[completed] = res;
3665 if (++completed === size) {
3666 iterate = throwError;
3667 callback(null, result);
3668 callback = throwError;
3669 } else if (sync) {
3670 nextTick(iterate);
3671 } else {
3672 sync = true;
3673 iterate();
3674 }
3675 sync = false;
3676 }
3677 }
3678
3679 /**
3680 * @memberof async
3681 * @namespace mapLimit
3682 * @param {Array|Object} collection
3683 * @param {number} limit - limit >= 1
3684 * @param {Function} iterator
3685 * @param {Function} callback
3686 * @example
3687 *
3688 * // array
3689 * var order = [];
3690 * var array = [1, 5, 3, 4, 2];
3691 * var iterator = function(num, done) {
3692 * setTimeout(function() {
3693 * order.push(num);
3694 * done(null, num);
3695 * }, num * 10);
3696 * };
3697 * async.mapLimit(array, 2, iterator, function(err, res) {
3698 * console.log(res); // [1, 5, 3, 4, 2]
3699 * console.log(order); // [1, 3, 5, 2, 4]
3700 * });
3701 *
3702 * @example
3703 *
3704 * // array with index
3705 * var order = [];
3706 * var array = [1, 5, 3, 4, 2];
3707 * var iterator = function(num, index, done) {
3708 * setTimeout(function() {
3709 * order.push([num, index]);
3710 * done(null, num);
3711 * }, num * 10);
3712 * };
3713 * async.mapLimit(array, 2, iterator, function(err, res) {
3714 * console.log(res); // [1, 5, 3, 4, 2]
3715 * console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
3716 * });
3717 *
3718 * @example
3719 *
3720 * // object
3721 * var order = [];
3722 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
3723 * var iterator = function(num, done) {
3724 * setTimeout(function() {
3725 * order.push(num);
3726 * done(null, num);
3727 * }, num * 10);
3728 * };
3729 * async.mapLimit(object, 2, iterator, function(err, res) {
3730 * console.log(res); // [1, 5, 3, 4, 2]
3731 * console.log(order); // [1, 3, 5, 2, 4]
3732 * });
3733 *
3734 * @example
3735 *
3736 * // object with key
3737 * var order = [];
3738 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
3739 * var iterator = function(num, key, done) {
3740 * setTimeout(function() {
3741 * order.push([num, key]);
3742 * done(null, num);
3743 * }, num * 10);
3744 * };
3745 * async.mapLimit(object, 2, iterator, function(err, res) {
3746 * console.log(res); // [1, 5, 3, 4, 2]
3747 * console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
3748 * });
3749 *
3750 */
3751 function mapLimit(collection, limit, iterator, callback) {
3752 callback = callback || noop;
3753 var size, index, key, keys, iter, item, result, iterate;
3754 var sync = false;
3755 var started = 0;
3756 var completed = 0;
3757
3758 if (isArray(collection)) {
3759 size = collection.length;
3760 iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
3761 } else if (!collection) {
3762 } else if (iteratorSymbol && collection[iteratorSymbol]) {
3763 size = Infinity;
3764 result = [];
3765 iter = collection[iteratorSymbol]();
3766 iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
3767 } else if (typeof collection === obj) {
3768 keys = nativeKeys(collection);
3769 size = keys.length;
3770 iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
3771 }
3772 if (!size || isNaN(limit) || limit < 1) {
3773 return callback(null, []);
3774 }
3775 result = result || Array(size);
3776 timesSync(limit > size ? size : limit, iterate);
3777
3778 function arrayIterator() {
3779 index = started++;
3780 if (index < size) {
3781 iterator(collection[index], createCallback(index));
3782 }
3783 }
3784
3785 function arrayIteratorWithIndex() {
3786 index = started++;
3787 if (index < size) {
3788 iterator(collection[index], index, createCallback(index));
3789 }
3790 }
3791
3792 function symbolIterator() {
3793 item = iter.next();
3794 if (item.done === false) {
3795 iterator(item.value, createCallback(started++));
3796 } else if (completed === started && iterator !== noop) {
3797 iterator = noop;
3798 callback(null, result);
3799 }
3800 }
3801
3802 function symbolIteratorWithKey() {
3803 item = iter.next();
3804 if (item.done === false) {
3805 iterator(item.value, started, createCallback(started++));
3806 } else if (completed === started && iterator !== noop) {
3807 iterator = noop;
3808 callback(null, result);
3809 }
3810 }
3811
3812 function objectIterator() {
3813 index = started++;
3814 if (index < size) {
3815 iterator(collection[keys[index]], createCallback(index));
3816 }
3817 }
3818
3819 function objectIteratorWithKey() {
3820 index = started++;
3821 if (index < size) {
3822 key = keys[index];
3823 iterator(collection[key], key, createCallback(index));
3824 }
3825 }
3826
3827 function createCallback(index) {
3828 return function(err, res) {
3829 if (index === null) {
3830 throwError();
3831 }
3832 if (err) {
3833 index = null;
3834 iterate = noop;
3835 callback = once(callback);
3836 callback(err, createArray(result));
3837 return;
3838 }
3839 result[index] = res;
3840 index = null;
3841 if (++completed === size) {
3842 iterate = throwError;
3843 callback(null, result);
3844 callback = throwError;
3845 } else if (sync) {
3846 nextTick(iterate);
3847 } else {
3848 sync = true;
3849 iterate();
3850 }
3851 sync = false;
3852 };
3853 }
3854 }
3855
3856 /**
3857 * @memberof async
3858 * @namespace mapValuesSeries
3859 * @param {Array|Object} collection
3860 * @param {Function} iterator
3861 * @param {Function} callback
3862 * @example
3863 *
3864 * // array
3865 * var order = [];
3866 * var array = [1, 3, 2];
3867 * var iterator = function(num, done) {
3868 * setTimeout(function() {
3869 * order.push(num);
3870 * done(null, num);
3871 * }, num * 10);
3872 * };
3873 * async.mapValuesSeries(array, iterator, function(err, res) {
3874 * console.log(res); // { '0': 1, '1': 3, '2': 2 }
3875 * console.log(order); // [1, 3, 2]
3876 * });
3877 *
3878 * @example
3879 *
3880 * // array with index
3881 * var order = [];
3882 * var array = [1, 3, 2];
3883 * var iterator = function(num, index, done) {
3884 * setTimeout(function() {
3885 * order.push([num, index]);
3886 * done(null, num);
3887 * }, num * 10);
3888 * };
3889 * async.mapValuesSeries(array, iterator, function(err, res) {
3890 * console.log(res); // { '0': 1, '1': 3, '2': 2 }
3891 * console.log(order); // [[1, 0], [3, 1], [2, 2]]
3892 * });
3893 *
3894 * @example
3895 *
3896 * // object
3897 * var order = [];
3898 * var object = { a: 1, b: 3, c: 2 };
3899 * var iterator = function(num, done) {
3900 * setTimeout(function() {
3901 * order.push(num);
3902 * done(null, num);
3903 * }, num * 10);
3904 * };
3905 * async.mapValuesSeries(object, iterator, function(err, res) {
3906 * console.log(res); // { a: 1, b: 3, c: 2 }
3907 * console.log(order); // [1, 3, 2]
3908 * });
3909 *
3910 * @example
3911 *
3912 * // object with key
3913 * var order = [];
3914 * var object = { a: 1, b: 3, c: 2 };
3915 * var iterator = function(num, key, done) {
3916 * setTimeout(function() {
3917 * order.push([num, key]);
3918 * done(null, num);
3919 * }, num * 10);
3920 * };
3921 * async.mapValuesSeries(object, iterator, function(err, res) {
3922 * console.log(res); // { a: 1, b: 3, c: 2 }
3923 * console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c']]
3924 * });
3925 *
3926 */
3927 function mapValuesSeries(collection, iterator, callback) {
3928 callback = callback || noop;
3929 var size, key, keys, iter, item, iterate;
3930 var sync = false;
3931 var result = {};
3932 var completed = 0;
3933
3934 if (isArray(collection)) {
3935 size = collection.length;
3936 iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
3937 } else if (!collection) {
3938 } else if (iteratorSymbol && collection[iteratorSymbol]) {
3939 size = Infinity;
3940 iter = collection[iteratorSymbol]();
3941 iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
3942 } else if (typeof collection === obj) {
3943 keys = nativeKeys(collection);
3944 size = keys.length;
3945 iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
3946 }
3947 if (!size) {
3948 return callback(null, result);
3949 }
3950 iterate();
3951
3952 function arrayIterator() {
3953 key = completed;
3954 iterator(collection[completed], done);
3955 }
3956
3957 function arrayIteratorWithIndex() {
3958 key = completed;
3959 iterator(collection[completed], completed, done);
3960 }
3961
3962 function symbolIterator() {
3963 key = completed;
3964 item = iter.next();
3965 item.done ? callback(null, result) : iterator(item.value, done);
3966 }
3967
3968 function symbolIteratorWithKey() {
3969 key = completed;
3970 item = iter.next();
3971 item.done ? callback(null, result) : iterator(item.value, completed, done);
3972 }
3973
3974 function objectIterator() {
3975 key = keys[completed];
3976 iterator(collection[key], done);
3977 }
3978
3979 function objectIteratorWithKey() {
3980 key = keys[completed];
3981 iterator(collection[key], key, done);
3982 }
3983
3984 function done(err, res) {
3985 if (err) {
3986 iterate = throwError;
3987 callback = onlyOnce(callback);
3988 callback(err, objectClone(result));
3989 return;
3990 }
3991 result[key] = res;
3992 if (++completed === size) {
3993 iterate = throwError;
3994 callback(null, result);
3995 callback = throwError;
3996 } else if (sync) {
3997 nextTick(iterate);
3998 } else {
3999 sync = true;
4000 iterate();
4001 }
4002 sync = false;
4003 }
4004 }
4005
4006 /**
4007 * @memberof async
4008 * @namespace mapValuesLimit
4009 * @param {Array|Object} collection
4010 * @param {number} limit - limit >= 1
4011 * @param {Function} iterator
4012 * @param {Function} callback
4013 * @example
4014 *
4015 * // array
4016 * var order = [];
4017 * var array = [1, 5, 3, 4, 2];
4018 * var iterator = function(num, done) {
4019 * setTimeout(function() {
4020 * order.push(num);
4021 * done(null, num);
4022 * }, num * 10);
4023 * };
4024 * async.mapValuesLimit(array, 2, iterator, function(err, res) {
4025 * console.log(res); // { '0': 1, '1': 5, '2': 3, '3': 4, '4': 2 }
4026 * console.log(order); // [1, 3, 5, 2, 4]
4027 * });
4028 *
4029 * @example
4030 *
4031 * // array with index
4032 * var order = [];
4033 * var array = [1, 5, 3, 4, 2];
4034 * var iterator = function(num, index, done) {
4035 * setTimeout(function() {
4036 * order.push([num, index]);
4037 * done(null, num);
4038 * }, num * 10);
4039 * };
4040 * async.mapValuesLimit(array, 2, iterator, function(err, res) {
4041 * console.log(res); // { '0': 1, '1': 5, '2': 3, '3': 4, '4': 2 }
4042 * console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
4043 * });
4044 *
4045 * @example
4046 *
4047 * // object
4048 * var order = [];
4049 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
4050 * var iterator = function(num, done) {
4051 * setTimeout(function() {
4052 * order.push(num);
4053 * done(null, num);
4054 * }, num * 10);
4055 * };
4056 * async.mapValuesLimit(object, 2, iterator, function(err, res) {
4057 * console.log(res); // { a: 1, b: 5, c: 3, d: 4, e: 2 }
4058 * console.log(order); // [1, 3, 5, 2, 4]
4059 * });
4060 *
4061 * @example
4062 *
4063 * // object with key
4064 * var order = [];
4065 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
4066 * var iterator = function(num, key, done) {
4067 * setTimeout(function() {
4068 * order.push([num, key]);
4069 * done(null, num);
4070 * }, num * 10);
4071 * };
4072 * async.mapValuesLimit(object, 2, iterator, function(err, res) {
4073 * console.log(res); // { a: 1, b: 5, c: 3, d: 4, e: 2 }
4074 * console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
4075 * });
4076 *
4077 */
4078 function mapValuesLimit(collection, limit, iterator, callback) {
4079 callback = callback || noop;
4080 var size, index, key, keys, iter, item, iterate;
4081 var sync = false;
4082 var result = {};
4083 var started = 0;
4084 var completed = 0;
4085
4086 if (isArray(collection)) {
4087 size = collection.length;
4088 iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
4089 } else if (!collection) {
4090 } else if (iteratorSymbol && collection[iteratorSymbol]) {
4091 size = Infinity;
4092 iter = collection[iteratorSymbol]();
4093 iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
4094 } else if (typeof collection === obj) {
4095 keys = nativeKeys(collection);
4096 size = keys.length;
4097 iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
4098 }
4099 if (!size || isNaN(limit) || limit < 1) {
4100 return callback(null, result);
4101 }
4102 timesSync(limit > size ? size : limit, iterate);
4103
4104 function arrayIterator() {
4105 index = started++;
4106 if (index < size) {
4107 iterator(collection[index], createCallback(index));
4108 }
4109 }
4110
4111 function arrayIteratorWithIndex() {
4112 index = started++;
4113 if (index < size) {
4114 iterator(collection[index], index, createCallback(index));
4115 }
4116 }
4117
4118 function symbolIterator() {
4119 item = iter.next();
4120 if (item.done === false) {
4121 iterator(item.value, createCallback(started++));
4122 } else if (completed === started && iterator !== noop) {
4123 iterator = noop;
4124 callback(null, result);
4125 }
4126 }
4127
4128 function symbolIteratorWithKey() {
4129 item = iter.next();
4130 if (item.done === false) {
4131 iterator(item.value, started, createCallback(started++));
4132 } else if (completed === started && iterator !== noop) {
4133 iterator = noop;
4134 callback(null, result);
4135 }
4136 }
4137
4138 function objectIterator() {
4139 index = started++;
4140 if (index < size) {
4141 key = keys[index];
4142 iterator(collection[key], createCallback(key));
4143 }
4144 }
4145
4146 function objectIteratorWithKey() {
4147 index = started++;
4148 if (index < size) {
4149 key = keys[index];
4150 iterator(collection[key], key, createCallback(key));
4151 }
4152 }
4153
4154 function createCallback(key) {
4155 return function(err, res) {
4156 if (key === null) {
4157 throwError();
4158 }
4159 if (err) {
4160 key = null;
4161 iterate = noop;
4162 callback = once(callback);
4163 callback(err, objectClone(result));
4164 return;
4165 }
4166 result[key] = res;
4167 key = null;
4168 if (++completed === size) {
4169 callback(null, result);
4170 } else if (sync) {
4171 nextTick(iterate);
4172 } else {
4173 sync = true;
4174 iterate();
4175 }
4176 sync = false;
4177 };
4178 }
4179 }
4180
4181 /**
4182 * @private
4183 * @param {Function} arrayEach
4184 * @param {Function} baseEach
4185 * @param {Function} symbolEach
4186 * @param {boolean} bool
4187 */
4188 function createDetect(arrayEach, baseEach, symbolEach, bool) {
4189 return function(collection, iterator, callback) {
4190 callback = callback || noop;
4191 var size, keys;
4192 var completed = 0;
4193
4194 if (isArray(collection)) {
4195 size = collection.length;
4196 arrayEach(collection, iterator, createCallback);
4197 } else if (!collection) {
4198 } else if (iteratorSymbol && collection[iteratorSymbol]) {
4199 size = symbolEach(collection, iterator, createCallback);
4200 size && size === completed && callback(null);
4201 } else if (typeof collection === obj) {
4202 keys = nativeKeys(collection);
4203 size = keys.length;
4204 baseEach(collection, iterator, createCallback, keys);
4205 }
4206 if (!size) {
4207 callback(null);
4208 }
4209
4210 function createCallback(value) {
4211 var called = false;
4212 return function done(err, res) {
4213 if (called) {
4214 throwError();
4215 }
4216 called = true;
4217 if (err) {
4218 callback = once(callback);
4219 callback(err);
4220 } else if (!!res === bool) {
4221 callback = once(callback);
4222 callback(null, value);
4223 } else if (++completed === size) {
4224 callback(null);
4225 }
4226 };
4227 }
4228 };
4229 }
4230
4231 /**
4232 * @private
4233 * @param {boolean} bool
4234 */
4235 function createDetectSeries(bool) {
4236 return function(collection, iterator, callback) {
4237 callback = onlyOnce(callback || noop);
4238 var size, key, value, keys, iter, item, iterate;
4239 var sync = false;
4240 var completed = 0;
4241
4242 if (isArray(collection)) {
4243 size = collection.length;
4244 iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
4245 } else if (!collection) {
4246 } else if (iteratorSymbol && collection[iteratorSymbol]) {
4247 size = Infinity;
4248 iter = collection[iteratorSymbol]();
4249 iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
4250 } else if (typeof collection === obj) {
4251 keys = nativeKeys(collection);
4252 size = keys.length;
4253 iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
4254 }
4255 if (!size) {
4256 return callback(null);
4257 }
4258 iterate();
4259
4260 function arrayIterator() {
4261 value = collection[completed];
4262 iterator(value, done);
4263 }
4264
4265 function arrayIteratorWithIndex() {
4266 value = collection[completed];
4267 iterator(value, completed, done);
4268 }
4269
4270 function symbolIterator() {
4271 item = iter.next();
4272 value = item.value;
4273 item.done ? callback(null) : iterator(value, done);
4274 }
4275
4276 function symbolIteratorWithKey() {
4277 item = iter.next();
4278 value = item.value;
4279 item.done ? callback(null) : iterator(value, completed, done);
4280 }
4281
4282 function objectIterator() {
4283 value = collection[keys[completed]];
4284 iterator(value, done);
4285 }
4286
4287 function objectIteratorWithKey() {
4288 key = keys[completed];
4289 value = collection[key];
4290 iterator(value, key, done);
4291 }
4292
4293 function done(err, res) {
4294 if (err) {
4295 callback(err);
4296 } else if (!!res === bool) {
4297 iterate = throwError;
4298 callback(null, value);
4299 } else if (++completed === size) {
4300 iterate = throwError;
4301 callback(null);
4302 } else if (sync) {
4303 nextTick(iterate);
4304 } else {
4305 sync = true;
4306 iterate();
4307 }
4308 sync = false;
4309 }
4310 };
4311 }
4312
4313 /**
4314 * @private
4315 * @param {boolean} bool
4316 */
4317 function createDetectLimit(bool) {
4318 return function(collection, limit, iterator, callback) {
4319 callback = callback || noop;
4320 var size, index, key, value, keys, iter, item, iterate;
4321 var sync = false;
4322 var started = 0;
4323 var completed = 0;
4324
4325 if (isArray(collection)) {
4326 size = collection.length;
4327 iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
4328 } else if (!collection) {
4329 } else if (iteratorSymbol && collection[iteratorSymbol]) {
4330 size = Infinity;
4331 iter = collection[iteratorSymbol]();
4332 iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
4333 } else if (typeof collection === obj) {
4334 keys = nativeKeys(collection);
4335 size = keys.length;
4336 iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
4337 }
4338 if (!size || isNaN(limit) || limit < 1) {
4339 return callback(null);
4340 }
4341 timesSync(limit > size ? size : limit, iterate);
4342
4343 function arrayIterator() {
4344 index = started++;
4345 if (index < size) {
4346 value = collection[index];
4347 iterator(value, createCallback(value));
4348 }
4349 }
4350
4351 function arrayIteratorWithIndex() {
4352 index = started++;
4353 if (index < size) {
4354 value = collection[index];
4355 iterator(value, index, createCallback(value));
4356 }
4357 }
4358
4359 function symbolIterator() {
4360 item = iter.next();
4361 if (item.done === false) {
4362 started++;
4363 value = item.value;
4364 iterator(value, createCallback(value));
4365 } else if (completed === started && iterator !== noop) {
4366 iterator = noop;
4367 callback(null);
4368 }
4369 }
4370
4371 function symbolIteratorWithKey() {
4372 item = iter.next();
4373 if (item.done === false) {
4374 value = item.value;
4375 iterator(value, started++, createCallback(value));
4376 } else if (completed === started && iterator !== noop) {
4377 iterator = noop;
4378 callback(null);
4379 }
4380 }
4381
4382 function objectIterator() {
4383 index = started++;
4384 if (index < size) {
4385 value = collection[keys[index]];
4386 iterator(value, createCallback(value));
4387 }
4388 }
4389
4390 function objectIteratorWithKey() {
4391 if (started < size) {
4392 key = keys[started++];
4393 value = collection[key];
4394 iterator(value, key, createCallback(value));
4395 }
4396 }
4397
4398 function createCallback(value) {
4399 var called = false;
4400 return function(err, res) {
4401 if (called) {
4402 throwError();
4403 }
4404 called = true;
4405 if (err) {
4406 iterate = noop;
4407 callback = once(callback);
4408 callback(err);
4409 } else if (!!res === bool) {
4410 iterate = noop;
4411 callback = once(callback);
4412 callback(null, value);
4413 } else if (++completed === size) {
4414 callback(null);
4415 } else if (sync) {
4416 nextTick(iterate);
4417 } else {
4418 sync = true;
4419 iterate();
4420 }
4421 sync = false;
4422 };
4423 }
4424 };
4425 }
4426
4427 /**
4428 * @private
4429 * @param {Function} arrayEach
4430 * @param {Function} baseEach
4431 * @param {Function} symbolEach
4432 * @param {boolean} bool
4433 */
4434 function createPick(arrayEach, baseEach, symbolEach, bool) {
4435 return function(collection, iterator, callback) {
4436 callback = callback || noop;
4437 var size, keys;
4438 var completed = 0;
4439 var result = {};
4440
4441 if (isArray(collection)) {
4442 size = collection.length;
4443 arrayEach(collection, iterator, createCallback);
4444 } else if (!collection) {
4445 } else if (iteratorSymbol && collection[iteratorSymbol]) {
4446 size = symbolEach(collection, iterator, createCallback);
4447 size && size === completed && callback(null, result);
4448 } else if (typeof collection === obj) {
4449 keys = nativeKeys(collection);
4450 size = keys.length;
4451 baseEach(collection, iterator, createCallback, keys);
4452 }
4453 if (!size) {
4454 return callback(null, {});
4455 }
4456
4457 function createCallback(key, value) {
4458 return function done(err, res) {
4459 if (key === null) {
4460 throwError();
4461 }
4462 if (err) {
4463 key = null;
4464 callback = once(callback);
4465 callback(err, objectClone(result));
4466 return;
4467 }
4468 if (!!res === bool) {
4469 result[key] = value;
4470 }
4471 key = null;
4472 if (++completed === size) {
4473 callback(null, result);
4474 }
4475 };
4476 }
4477 };
4478 }
4479
4480 /**
4481 * @private
4482 * @param {boolean} bool
4483 */
4484 function createPickSeries(bool) {
4485 return function(collection, iterator, callback) {
4486 callback = onlyOnce(callback || noop);
4487 var size, key, value, keys, iter, item, iterate;
4488 var sync = false;
4489 var result = {};
4490 var completed = 0;
4491
4492 if (isArray(collection)) {
4493 size = collection.length;
4494 iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
4495 } else if (!collection) {
4496 } else if (iteratorSymbol && collection[iteratorSymbol]) {
4497 size = Infinity;
4498 iter = collection[iteratorSymbol]();
4499 iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
4500 } else if (typeof collection === obj) {
4501 keys = nativeKeys(collection);
4502 size = keys.length;
4503 iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
4504 }
4505 if (!size) {
4506 return callback(null, {});
4507 }
4508 iterate();
4509
4510 function arrayIterator() {
4511 key = completed;
4512 value = collection[completed];
4513 iterator(value, done);
4514 }
4515
4516 function arrayIteratorWithIndex() {
4517 key = completed;
4518 value = collection[completed];
4519 iterator(value, completed, done);
4520 }
4521
4522 function symbolIterator() {
4523 key = completed;
4524 item = iter.next();
4525 value = item.value;
4526 item.done ? callback(null, result) : iterator(value, done);
4527 }
4528
4529 function symbolIteratorWithKey() {
4530 key = completed;
4531 item = iter.next();
4532 value = item.value;
4533 item.done ? callback(null, result) : iterator(value, key, done);
4534 }
4535
4536 function objectIterator() {
4537 key = keys[completed];
4538 value = collection[key];
4539 iterator(value, done);
4540 }
4541
4542 function objectIteratorWithKey() {
4543 key = keys[completed];
4544 value = collection[key];
4545 iterator(value, key, done);
4546 }
4547
4548 function done(err, res) {
4549 if (err) {
4550 callback(err, result);
4551 return;
4552 }
4553 if (!!res === bool) {
4554 result[key] = value;
4555 }
4556 if (++completed === size) {
4557 iterate = throwError;
4558 callback(null, result);
4559 } else if (sync) {
4560 nextTick(iterate);
4561 } else {
4562 sync = true;
4563 iterate();
4564 }
4565 sync = false;
4566 }
4567 };
4568 }
4569
4570 /**
4571 * @private
4572 * @param {boolean} bool
4573 */
4574 function createPickLimit(bool) {
4575 return function(collection, limit, iterator, callback) {
4576 callback = callback || noop;
4577 var size, index, key, value, keys, iter, item, iterate;
4578 var sync = false;
4579 var result = {};
4580 var started = 0;
4581 var completed = 0;
4582
4583 if (isArray(collection)) {
4584 size = collection.length;
4585 iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
4586 } else if (!collection) {
4587 } else if (iteratorSymbol && collection[iteratorSymbol]) {
4588 size = Infinity;
4589 iter = collection[iteratorSymbol]();
4590 iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
4591 } else if (typeof collection === obj) {
4592 keys = nativeKeys(collection);
4593 size = keys.length;
4594 iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
4595 }
4596 if (!size || isNaN(limit) || limit < 1) {
4597 return callback(null, {});
4598 }
4599 timesSync(limit > size ? size : limit, iterate);
4600
4601 function arrayIterator() {
4602 index = started++;
4603 if (index < size) {
4604 value = collection[index];
4605 iterator(value, createCallback(value, index));
4606 }
4607 }
4608
4609 function arrayIteratorWithIndex() {
4610 index = started++;
4611 if (index < size) {
4612 value = collection[index];
4613 iterator(value, index, createCallback(value, index));
4614 }
4615 }
4616
4617 function symbolIterator() {
4618 item = iter.next();
4619 if (item.done === false) {
4620 value = item.value;
4621 iterator(value, createCallback(value, started++));
4622 } else if (completed === started && iterator !== noop) {
4623 iterator = noop;
4624 callback(null, result);
4625 }
4626 }
4627
4628 function symbolIteratorWithKey() {
4629 item = iter.next();
4630 if (item.done === false) {
4631 value = item.value;
4632 iterator(value, started, createCallback(value, started++));
4633 } else if (completed === started && iterator !== noop) {
4634 iterator = noop;
4635 callback(null, result);
4636 }
4637 }
4638
4639 function objectIterator() {
4640 if (started < size) {
4641 key = keys[started++];
4642 value = collection[key];
4643 iterator(value, createCallback(value, key));
4644 }
4645 }
4646
4647 function objectIteratorWithKey() {
4648 if (started < size) {
4649 key = keys[started++];
4650 value = collection[key];
4651 iterator(value, key, createCallback(value, key));
4652 }
4653 }
4654
4655 function createCallback(value, key) {
4656 return function(err, res) {
4657 if (key === null) {
4658 throwError();
4659 }
4660 if (err) {
4661 key = null;
4662 iterate = noop;
4663 callback = once(callback);
4664 callback(err, objectClone(result));
4665 return;
4666 }
4667 if (!!res === bool) {
4668 result[key] = value;
4669 }
4670 key = null;
4671 if (++completed === size) {
4672 iterate = throwError;
4673 callback = onlyOnce(callback);
4674 callback(null, result);
4675 } else if (sync) {
4676 nextTick(iterate);
4677 } else {
4678 sync = true;
4679 iterate();
4680 }
4681 sync = false;
4682 };
4683 }
4684 };
4685 }
4686
4687 /**
4688 * @memberof async
4689 * @namespace reduce
4690 * @param {Array|Object} collection
4691 * @param {*} result
4692 * @param {Function} iterator
4693 * @param {Function} callback
4694 * @example
4695 *
4696 * // array
4697 * var order = [];
4698 * var collection = [1, 3, 2, 4];
4699 * var iterator = function(result, num, done) {
4700 * setTimeout(function() {
4701 * order.push(num);
4702 * done(null, result + num);
4703 * }, num * 10);
4704 * };
4705 * async.reduce(collection, 0, iterator, function(err, res) {
4706 * console.log(res); // 10
4707 * console.log(order); // [1, 3, 2, 4]
4708 * });
4709 *
4710 * @example
4711 *
4712 * // array with index
4713 * var order = [];
4714 * var collection = [1, 3, 2, 4];
4715 * var iterator = function(result, num, index, done) {
4716 * setTimeout(function() {
4717 * order.push([num, index]);
4718 * done(null, result + num);
4719 * }, num * 10);
4720 * };
4721 * async.reduce(collection, '', iterator, function(err, res) {
4722 * console.log(res); // '1324'
4723 * console.log(order); // [[1, 0], [3, 1], [2, 2], [4, 3]]
4724 * });
4725 *
4726 * @example
4727 *
4728 * // object
4729 * var order = [];
4730 * var object = { a: 1, b: 3, c: 2, d: 4 };
4731 * var iterator = function(result, num, done) {
4732 * setTimeout(function() {
4733 * order.push(num);
4734 * done(null, result + num);
4735 * }, num * 10);
4736 * };
4737 * async.reduce(collection, '', iterator, function(err, res) {
4738 * console.log(res); // '1324'
4739 * console.log(order); // [1, 3, 2, 4]
4740 * });
4741 *
4742 * @example
4743 *
4744 * // object with key
4745 * var order = [];
4746 * var object = { a: 1, b: 3, c: 2, d: 4 };
4747 * var iterator = function(result, num, key, done) {
4748 * setTimeout(function() {
4749 * order.push([num, key]);
4750 * done(null, result + num);
4751 * }, num * 10);
4752 * };
4753 * async.reduce(collection, 0, iterator, function(err, res) {
4754 * console.log(res); // 10
4755 * console.log(order); // [[1, 'a'], [3, 'b'], [2, 'b'], [4, 'd']]
4756 * });
4757 *
4758 */
4759 function reduce(collection, result, iterator, callback) {
4760 callback = onlyOnce(callback || noop);
4761 var size, key, keys, iter, item, iterate;
4762 var sync = false;
4763 var completed = 0;
4764
4765 if (isArray(collection)) {
4766 size = collection.length;
4767 iterate = iterator.length === 4 ? arrayIteratorWithIndex : arrayIterator;
4768 } else if (!collection) {
4769 } else if (iteratorSymbol && collection[iteratorSymbol]) {
4770 size = Infinity;
4771 iter = collection[iteratorSymbol]();
4772 iterate = iterator.length === 4 ? symbolIteratorWithKey : symbolIterator;
4773 } else if (typeof collection === obj) {
4774 keys = nativeKeys(collection);
4775 size = keys.length;
4776 iterate = iterator.length === 4 ? objectIteratorWithKey : objectIterator;
4777 }
4778 if (!size) {
4779 return callback(null, result);
4780 }
4781 iterate(result);
4782
4783 function arrayIterator(result) {
4784 iterator(result, collection[completed], done);
4785 }
4786
4787 function arrayIteratorWithIndex(result) {
4788 iterator(result, collection[completed], completed, done);
4789 }
4790
4791 function symbolIterator(result) {
4792 item = iter.next();
4793 item.done ? callback(null, result) : iterator(result, item.value, done);
4794 }
4795
4796 function symbolIteratorWithKey(result) {
4797 item = iter.next();
4798 item.done ? callback(null, result) : iterator(result, item.value, completed, done);
4799 }
4800
4801 function objectIterator(result) {
4802 iterator(result, collection[keys[completed]], done);
4803 }
4804
4805 function objectIteratorWithKey(result) {
4806 key = keys[completed];
4807 iterator(result, collection[key], key, done);
4808 }
4809
4810 function done(err, result) {
4811 if (err) {
4812 callback(err, result);
4813 } else if (++completed === size) {
4814 iterator = throwError;
4815 callback(null, result);
4816 } else if (sync) {
4817 nextTick(function() {
4818 iterate(result);
4819 });
4820 } else {
4821 sync = true;
4822 iterate(result);
4823 }
4824 sync = false;
4825 }
4826 }
4827
4828 /**
4829 * @memberof async
4830 * @namespace reduceRight
4831 * @param {Array|Object} collection
4832 * @param {*} result
4833 * @param {Function} iterator
4834 * @param {Function} callback
4835 * @example
4836 *
4837 * // array
4838 * var order = [];
4839 * var collection = [1, 3, 2, 4];
4840 * var iterator = function(result, num, done) {
4841 * setTimeout(function() {
4842 * order.push(num);
4843 * done(null, result + num);
4844 * }, num * 10);
4845 * };
4846 * async.reduceRight(collection, 0, iterator, function(err, res) {
4847 * console.log(res); // 10
4848 * console.log(order); // [4, 2, 3, 1]
4849 * });
4850 *
4851 * @example
4852 *
4853 * // array with index
4854 * var order = [];
4855 * var collection = [1, 3, 2, 4];
4856 * var iterator = function(result, num, index, done) {
4857 * setTimeout(function() {
4858 * order.push([num, index]);
4859 * done(null, result + num);
4860 * }, num * 10);
4861 * };
4862 * async.reduceRight(collection, '', iterator, function(err, res) {
4863 * console.log(res); // '4231'
4864 * console.log(order); // [[4, 3], [2, 2], [3, 1], [1, 0]]
4865 * });
4866 *
4867 * @example
4868 *
4869 * // object
4870 * var order = [];
4871 * var object = { a: 1, b: 3, c: 2, d: 4 };
4872 * var iterator = function(result, num, done) {
4873 * setTimeout(function() {
4874 * order.push(num);
4875 * done(null, result + num);
4876 * }, num * 10);
4877 * };
4878 * async.reduceRight(collection, '', iterator, function(err, res) {
4879 * console.log(res); // '4231'
4880 * console.log(order); // [4, 2, 3, 1]
4881 * });
4882 *
4883 * @example
4884 *
4885 * // object with key
4886 * var order = [];
4887 * var object = { a: 1, b: 3, c: 2, d: 4 };
4888 * var iterator = function(result, num, key, done) {
4889 * setTimeout(function() {
4890 * order.push([num, key]);
4891 * done(null, result + num);
4892 * }, num * 10);
4893 * };
4894 * async.reduceRight(collection, 0, iterator, function(err, res) {
4895 * console.log(res); // 10
4896 * console.log(order); // [[4, 3], [2, 2], [3, 1], [1, 0]]
4897 * });
4898 *
4899 */
4900 function reduceRight(collection, result, iterator, callback) {
4901 callback = onlyOnce(callback || noop);
4902 var resIndex, index, key, keys, iter, item, col, iterate;
4903 var sync = false;
4904
4905 if (isArray(collection)) {
4906 resIndex = collection.length;
4907 iterate = iterator.length === 4 ? arrayIteratorWithIndex : arrayIterator;
4908 } else if (!collection) {
4909 } else if (iteratorSymbol && collection[iteratorSymbol]) {
4910 col = [];
4911 iter = collection[iteratorSymbol]();
4912 index = -1;
4913 while ((item = iter.next()).done === false) {
4914 col[++index] = item.value;
4915 }
4916 collection = col;
4917 resIndex = col.length;
4918 iterate = iterator.length === 4 ? arrayIteratorWithIndex : arrayIterator;
4919 } else if (typeof collection === obj) {
4920 keys = nativeKeys(collection);
4921 resIndex = keys.length;
4922 iterate = iterator.length === 4 ? objectIteratorWithKey : objectIterator;
4923 }
4924 if (!resIndex) {
4925 return callback(null, result);
4926 }
4927 iterate(result);
4928
4929 function arrayIterator(result) {
4930 iterator(result, collection[--resIndex], done);
4931 }
4932
4933 function arrayIteratorWithIndex(result) {
4934 iterator(result, collection[--resIndex], resIndex, done);
4935 }
4936
4937 function objectIterator(result) {
4938 iterator(result, collection[keys[--resIndex]], done);
4939 }
4940
4941 function objectIteratorWithKey(result) {
4942 key = keys[--resIndex];
4943 iterator(result, collection[key], key, done);
4944 }
4945
4946 function done(err, result) {
4947 if (err) {
4948 callback(err, result);
4949 } else if (resIndex === 0) {
4950 iterate = throwError;
4951 callback(null, result);
4952 } else if (sync) {
4953 nextTick(function() {
4954 iterate(result);
4955 });
4956 } else {
4957 sync = true;
4958 iterate(result);
4959 }
4960 sync = false;
4961 }
4962 }
4963
4964 /**
4965 * @private
4966 * @param {Function} arrayEach
4967 * @param {Function} baseEach
4968 * @param {Function} symbolEach
4969 */
4970 function createTransform(arrayEach, baseEach, symbolEach) {
4971 return function transform(collection, accumulator, iterator, callback) {
4972 if (arguments.length === 3) {
4973 callback = iterator;
4974 iterator = accumulator;
4975 accumulator = undefined;
4976 }
4977 callback = callback || noop;
4978 var size, keys, result;
4979 var completed = 0;
4980
4981 if (isArray(collection)) {
4982 size = collection.length;
4983 result = accumulator !== undefined ? accumulator : [];
4984 arrayEach(collection, result, iterator, done);
4985 } else if (!collection) {
4986 } else if (iteratorSymbol && collection[iteratorSymbol]) {
4987 result = accumulator !== undefined ? accumulator : {};
4988 size = symbolEach(collection, result, iterator, done);
4989 size && size === completed && callback(null, result);
4990 } else if (typeof collection === obj) {
4991 keys = nativeKeys(collection);
4992 size = keys.length;
4993 result = accumulator !== undefined ? accumulator : {};
4994 baseEach(collection, result, iterator, done, keys);
4995 }
4996 if (!size) {
4997 callback(null, accumulator !== undefined ? accumulator : result || {});
4998 }
4999
5000 function done(err, bool) {
5001 if (err) {
5002 callback = once(callback);
5003 callback(err, isArray(result) ? createArray(result) : objectClone(result));
5004 } else if (++completed === size) {
5005 callback(null, result);
5006 } else if (bool === false) {
5007 callback = once(callback);
5008 callback(null, isArray(result) ? createArray(result) : objectClone(result));
5009 }
5010 }
5011 };
5012 }
5013
5014 /**
5015 * @memberof async
5016 * @namespace transformSeries
5017 * @param {Array|Object} collection
5018 * @param {Array|Object|Function} [accumulator]
5019 * @param {Function} [iterator]
5020 * @param {Function} [callback]
5021 * @example
5022 *
5023 * // array
5024 * var order = [];
5025 * var collection = [1, 3, 2, 4];
5026 * var iterator = function(result, num, done) {
5027 * setTimeout(function() {
5028 * order.push(num);
5029 * result.push(num)
5030 * done();
5031 * }, num * 10);
5032 * };
5033 * async.transformSeries(collection, iterator, function(err, res) {
5034 * console.log(res); // [1, 3, 2, 4]
5035 * console.log(order); // [1, 3, 2, 4]
5036 * });
5037 *
5038 * @example
5039 *
5040 * // array with index and accumulator
5041 * var order = [];
5042 * var collection = [1, 3, 2, 4];
5043 * var iterator = function(result, num, index, done) {
5044 * setTimeout(function() {
5045 * order.push([num, index]);
5046 * result[index] = num;
5047 * done();
5048 * }, num * 10);
5049 * };
5050 * async.transformSeries(collection, {}, iterator, function(err, res) {
5051 * console.log(res); // { '0': 1, '1': 3, '2': 2, '3': 4 }
5052 * console.log(order); // [[1, 0], [3, 1], [2, 2], [4, 3]]
5053 * });
5054 *
5055 * @example
5056 *
5057 * // object with accumulator
5058 * var order = [];
5059 * var object = { a: 1, b: 3, c: 2, d: 4 };
5060 * var iterator = function(result, num, done) {
5061 * setTimeout(function() {
5062 * order.push(num);
5063 * result.push(num);
5064 * done();
5065 * }, num * 10);
5066 * };
5067 * async.transformSeries(collection, [], iterator, function(err, res) {
5068 * console.log(res); // [1, 3, 2, 4]
5069 * console.log(order); // [1, 3, 2, 4]
5070 * });
5071 *
5072 * @example
5073 *
5074 * // object with key
5075 * var order = [];
5076 * var object = { a: 1, b: 3, c: 2, d: 4 };
5077 * var iterator = function(result, num, key, done) {
5078 * setTimeout(function() {
5079 * order.push([num, key]);
5080 * result[key] = num;
5081 * done();
5082 * }, num * 10);
5083 * };
5084 * async.transformSeries(collection, iterator, function(err, res) {
5085 * console.log(res); // { a: 1, b: 3, c: 2, d: 4 }
5086 * console.log(order); // [[1, 'a'], [3, 'b'], [2, 'b'], [4, 'd']]
5087 * });
5088 *
5089 */
5090 function transformSeries(collection, accumulator, iterator, callback) {
5091 if (arguments.length === 3) {
5092 callback = iterator;
5093 iterator = accumulator;
5094 accumulator = undefined;
5095 }
5096 callback = onlyOnce(callback || noop);
5097 var size, key, keys, iter, item, iterate, result;
5098 var sync = false;
5099 var completed = 0;
5100
5101 if (isArray(collection)) {
5102 size = collection.length;
5103 result = accumulator !== undefined ? accumulator : [];
5104 iterate = iterator.length === 4 ? arrayIteratorWithIndex : arrayIterator;
5105 } else if (!collection) {
5106 } else if (iteratorSymbol && collection[iteratorSymbol]) {
5107 size = Infinity;
5108 iter = collection[iteratorSymbol]();
5109 result = accumulator !== undefined ? accumulator : {};
5110 iterate = iterator.length === 4 ? symbolIteratorWithKey : symbolIterator;
5111 } else if (typeof collection === obj) {
5112 keys = nativeKeys(collection);
5113 size = keys.length;
5114 result = accumulator !== undefined ? accumulator : {};
5115 iterate = iterator.length === 4 ? objectIteratorWithKey : objectIterator;
5116 }
5117 if (!size) {
5118 return callback(null, accumulator !== undefined ? accumulator : result || {});
5119 }
5120 iterate();
5121
5122 function arrayIterator() {
5123 iterator(result, collection[completed], done);
5124 }
5125
5126 function arrayIteratorWithIndex() {
5127 iterator(result, collection[completed], completed, done);
5128 }
5129
5130 function symbolIterator() {
5131 item = iter.next();
5132 item.done ? callback(null, result) : iterator(result, item.value, done);
5133 }
5134
5135 function symbolIteratorWithKey() {
5136 item = iter.next();
5137 item.done ? callback(null, result) : iterator(result, item.value, completed, done);
5138 }
5139
5140 function objectIterator() {
5141 iterator(result, collection[keys[completed]], done);
5142 }
5143
5144 function objectIteratorWithKey() {
5145 key = keys[completed];
5146 iterator(result, collection[key], key, done);
5147 }
5148
5149 function done(err, bool) {
5150 if (err) {
5151 callback(err, result);
5152 } else if (++completed === size || bool === false) {
5153 iterate = throwError;
5154 callback(null, result);
5155 } else if (sync) {
5156 nextTick(iterate);
5157 } else {
5158 sync = true;
5159 iterate();
5160 }
5161 sync = false;
5162 }
5163 }
5164
5165 /**
5166 * @memberof async
5167 * @namespace transformLimit
5168 * @param {Array|Object} collection
5169 * @param {number} limit - limit >= 1
5170 * @param {Array|Object|Function} [accumulator]
5171 * @param {Function} [iterator]
5172 * @param {Function} [callback]
5173 * @example
5174 *
5175 * // array
5176 * var order = [];
5177 * var array = [1, 5, 3, 4, 2];
5178 * var iterator = function(result, num, done) {
5179 * setTimeout(function() {
5180 * order.push(num);
5181 * result.push(num);
5182 * done();
5183 * }, num * 10);
5184 * };
5185 * async.transformLimit(array, 2, iterator, function(err, res) {
5186 * console.log(res); // [1, 3, 5, 2, 4]
5187 * console.log(order); // [1, 3, 5, 2, 4]
5188 * });
5189 *
5190 * @example
5191 *
5192 * // array with index and accumulator
5193 * var order = [];
5194 * var array = [1, 5, 3, 4, 2];
5195 * var iterator = function(result, num, index, done) {
5196 * setTimeout(function() {
5197 * order.push([num, index]);
5198 * result[index] = key;
5199 * done();
5200 * }, num * 10);
5201 * };
5202 * async.transformLimit(array, 2, {}, iterator, function(err, res) {
5203 * console.log(res); // { '0': 1, '1': 5, '2': 3, '3': 4, '4': 2 }
5204 * console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
5205 * });
5206 *
5207 * @example
5208 *
5209 * // object with accumulator
5210 * var order = [];
5211 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
5212 * var iterator = function(result, num, done) {
5213 * setTimeout(function() {
5214 * order.push(num);
5215 * result.push(num);
5216 * done();
5217 * }, num * 10);
5218 * };
5219 * async.transformLimit(object, 2, [], iterator, function(err, res) {
5220 * console.log(res); // [1, 3, 5, 2, 4]
5221 * console.log(order); // [1, 3, 5, 2, 4]
5222 * });
5223 *
5224 * @example
5225 *
5226 * // object with key
5227 * var order = [];
5228 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
5229 * var iterator = function(result, num, key, done) {
5230 * setTimeout(function() {
5231 * order.push([num, key]);
5232 * result[key] = num;
5233 * done();
5234 * }, num * 10);
5235 * };
5236 * async.transformLimit(object, 2, iterator, function(err, res) {
5237 * console.log(res); // { a: 1, b: 5, c: 3, d: 4, e: 2 };
5238 * console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
5239 * });
5240 *
5241 */
5242 function transformLimit(collection, limit, accumulator, iterator, callback) {
5243 if (arguments.length === 4) {
5244 callback = iterator;
5245 iterator = accumulator;
5246 accumulator = undefined;
5247 }
5248 callback = callback || noop;
5249 var size, index, key, keys, iter, item, iterate, result;
5250 var sync = false;
5251 var started = 0;
5252 var completed = 0;
5253
5254 if (isArray(collection)) {
5255 size = collection.length;
5256 result = accumulator !== undefined ? accumulator : [];
5257 iterate = iterator.length === 4 ? arrayIteratorWithIndex : arrayIterator;
5258 } else if (!collection) {
5259 } else if (iteratorSymbol && collection[iteratorSymbol]) {
5260 size = Infinity;
5261 iter = collection[iteratorSymbol]();
5262 result = accumulator !== undefined ? accumulator : {};
5263 iterate = iterator.length === 4 ? symbolIteratorWithKey : symbolIterator;
5264 } else if (typeof collection === obj) {
5265 keys = nativeKeys(collection);
5266 size = keys.length;
5267 result = accumulator !== undefined ? accumulator : {};
5268 iterate = iterator.length === 4 ? objectIteratorWithKey : objectIterator;
5269 }
5270 if (!size || isNaN(limit) || limit < 1) {
5271 return callback(null, accumulator !== undefined ? accumulator : result || {});
5272 }
5273 timesSync(limit > size ? size : limit, iterate);
5274
5275 function arrayIterator() {
5276 index = started++;
5277 if (index < size) {
5278 iterator(result, collection[index], onlyOnce(done));
5279 }
5280 }
5281
5282 function arrayIteratorWithIndex() {
5283 index = started++;
5284 if (index < size) {
5285 iterator(result, collection[index], index, onlyOnce(done));
5286 }
5287 }
5288
5289 function symbolIterator() {
5290 item = iter.next();
5291 if (item.done === false) {
5292 started++;
5293 iterator(result, item.value, onlyOnce(done));
5294 } else if (completed === started && iterator !== noop) {
5295 iterator = noop;
5296 callback(null, result);
5297 }
5298 }
5299
5300 function symbolIteratorWithKey() {
5301 item = iter.next();
5302 if (item.done === false) {
5303 iterator(result, item.value, started++, onlyOnce(done));
5304 } else if (completed === started && iterator !== noop) {
5305 iterator = noop;
5306 callback(null, result);
5307 }
5308 }
5309
5310 function objectIterator() {
5311 index = started++;
5312 if (index < size) {
5313 iterator(result, collection[keys[index]], onlyOnce(done));
5314 }
5315 }
5316
5317 function objectIteratorWithKey() {
5318 index = started++;
5319 if (index < size) {
5320 key = keys[index];
5321 iterator(result, collection[key], key, onlyOnce(done));
5322 }
5323 }
5324
5325 function done(err, bool) {
5326 if (err || bool === false) {
5327 iterate = noop;
5328 callback(err || null, isArray(result) ? createArray(result) : objectClone(result));
5329 callback = noop;
5330 } else if (++completed === size) {
5331 iterator = noop;
5332 callback(null, result);
5333 } else if (sync) {
5334 nextTick(iterate);
5335 } else {
5336 sync = true;
5337 iterate();
5338 }
5339 sync = false;
5340 }
5341 }
5342
5343 /**
5344 * @private
5345 * @param {function} arrayEach
5346 * @param {function} baseEach
5347 * @param {function} symbolEach
5348 */
5349 function createSortBy(arrayEach, baseEach, symbolEach) {
5350 return function sortBy(collection, iterator, callback) {
5351 callback = callback || noop;
5352 var size, array, criteria;
5353 var completed = 0;
5354
5355 if (isArray(collection)) {
5356 size = collection.length;
5357 array = Array(size);
5358 criteria = Array(size);
5359 arrayEach(collection, iterator, createCallback);
5360 } else if (!collection) {
5361 } else if (iteratorSymbol && collection[iteratorSymbol]) {
5362 array = [];
5363 criteria = [];
5364 size = symbolEach(collection, iterator, createCallback);
5365 size && size === completed && callback(null, sortByCriteria(array, criteria));
5366 } else if (typeof collection === obj) {
5367 var keys = nativeKeys(collection);
5368 size = keys.length;
5369 array = Array(size);
5370 criteria = Array(size);
5371 baseEach(collection, iterator, createCallback, keys);
5372 }
5373 if (!size) {
5374 callback(null, []);
5375 }
5376
5377 function createCallback(index, value) {
5378 var called = false;
5379 array[index] = value;
5380 return function done(err, criterion) {
5381 if (called) {
5382 throwError();
5383 }
5384 called = true;
5385 criteria[index] = criterion;
5386 if (err) {
5387 callback = once(callback);
5388 callback(err);
5389 } else if (++completed === size) {
5390 callback(null, sortByCriteria(array, criteria));
5391 }
5392 };
5393 }
5394 };
5395 }
5396
5397 /**
5398 * @memberof async
5399 * @namespace sortBySeries
5400 * @param {Array|Object} collection
5401 * @param {Function} iterator
5402 * @param {Function} callback
5403 * @example
5404 *
5405 * // array
5406 * var order = [];
5407 * var array = [1, 3, 2];
5408 * var iterator = function(num, done) {
5409 * setTimeout(function() {
5410 * order.push(num);
5411 * done(null, num);
5412 * }, num * 10);
5413 * };
5414 * async.sortBySeries(array, iterator, function(err, res) {
5415 * console.log(res); // [1, 2, 3];
5416 * console.log(order); // [1, 3, 2]
5417 * });
5418 *
5419 * @example
5420 *
5421 * // array with index
5422 * var order = [];
5423 * var array = [1, 3, 2];
5424 * var iterator = function(num, index, done) {
5425 * setTimeout(function() {
5426 * order.push([num, index]);
5427 * done(null, num);
5428 * }, num * 10);
5429 * };
5430 * async.sortBySeries(array, iterator, function(err, res) {
5431 * console.log(res); // [1, 2, 3]
5432 * console.log(order); // [[1, 0], [3, 1], [2, 2]]
5433 * });
5434 *
5435 * @example
5436 *
5437 * // object
5438 * var order = [];
5439 * var object = { a: 1, b: 3, c: 2 };
5440 * var iterator = function(num, done) {
5441 * setTimeout(function() {
5442 * order.push(num);
5443 * done(null, num);
5444 * }, num * 10);
5445 * };
5446 * async.sortBySeries(object, iterator, function(err, res) {
5447 * console.log(res); // [1, 2, 3]
5448 * console.log(order); // [1, 3, 2]
5449 * });
5450 *
5451 * @example
5452 *
5453 * // object with key
5454 * var order = [];
5455 * var object = { a: 1, b: 3, c: 2 };
5456 * var iterator = function(num, key, done) {
5457 * setTimeout(function() {
5458 * order.push([num, key]);
5459 * done(null, num);
5460 * }, num * 10);
5461 * };
5462 * async.sortBySeries(object, iterator, function(err, res) {
5463 * console.log(res); // [1, 2, 3]
5464 * console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c']]
5465 * });
5466 *
5467 */
5468 function sortBySeries(collection, iterator, callback) {
5469 callback = onlyOnce(callback || noop);
5470 var size, key, value, keys, iter, item, array, criteria, iterate;
5471 var sync = false;
5472 var completed = 0;
5473
5474 if (isArray(collection)) {
5475 size = collection.length;
5476 array = collection;
5477 criteria = Array(size);
5478 iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
5479 } else if (!collection) {
5480 } else if (iteratorSymbol && collection[iteratorSymbol]) {
5481 size = Infinity;
5482 array = [];
5483 criteria = [];
5484 iter = collection[iteratorSymbol]();
5485 iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
5486 } else if (typeof collection === obj) {
5487 keys = nativeKeys(collection);
5488 size = keys.length;
5489 array = Array(size);
5490 criteria = Array(size);
5491 iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
5492 }
5493 if (!size) {
5494 return callback(null, []);
5495 }
5496 iterate();
5497
5498 function arrayIterator() {
5499 value = collection[completed];
5500 iterator(value, done);
5501 }
5502
5503 function arrayIteratorWithIndex() {
5504 value = collection[completed];
5505 iterator(value, completed, done);
5506 }
5507
5508 function symbolIterator() {
5509 item = iter.next();
5510 if (item.done) {
5511 return callback(null, sortByCriteria(array, criteria));
5512 }
5513 value = item.value;
5514 array[completed] = value;
5515 iterator(value, done);
5516 }
5517
5518 function symbolIteratorWithKey() {
5519 item = iter.next();
5520 if (item.done) {
5521 return callback(null, sortByCriteria(array, criteria));
5522 }
5523 value = item.value;
5524 array[completed] = value;
5525 iterator(value, completed, done);
5526 }
5527
5528 function objectIterator() {
5529 value = collection[keys[completed]];
5530 array[completed] = value;
5531 iterator(value, done);
5532 }
5533
5534 function objectIteratorWithKey() {
5535 key = keys[completed];
5536 value = collection[key];
5537 array[completed] = value;
5538 iterator(value, key, done);
5539 }
5540
5541 function done(err, criterion) {
5542 criteria[completed] = criterion;
5543 if (err) {
5544 callback(err);
5545 } else if (++completed === size) {
5546 iterate = throwError;
5547 callback(null, sortByCriteria(array, criteria));
5548 } else if (sync) {
5549 nextTick(iterate);
5550 } else {
5551 sync = true;
5552 iterate();
5553 }
5554 sync = false;
5555 }
5556 }
5557
5558 /**
5559 * @memberof async
5560 * @namespace sortByLimit
5561 * @param {Array|Object} collection
5562 * @param {number} limit - limit >= 1
5563 * @param {Function} iterator
5564 * @param {Function} callback
5565 * @example
5566 *
5567 * // array
5568 * var order = [];
5569 * var array = [1, 5, 3, 4, 2];
5570 * var iterator = function(num, done) {
5571 * setTimeout(function() {
5572 * order.push(num);
5573 * done(null, num);
5574 * }, num * 10);
5575 * };
5576 * async.sortByLimit(array, 2, iterator, function(err, res) {
5577 * console.log(res); // [1, 2, 3, 4, 5]
5578 * console.log(order); // [1, 3, 5, 2, 4]
5579 * });
5580 *
5581 * @example
5582 *
5583 * // array with index
5584 * var order = [];
5585 * var array = [1, 5, 3, 4, 2];
5586 * var iterator = function(num, index, done) {
5587 * setTimeout(function() {
5588 * order.push([num, index]);
5589 * done(null, num);
5590 * }, num * 10);
5591 * };
5592 * async.sortByLimit(array, 2, iterator, function(err, res) {
5593 * console.log(res); // [1, 2, 3, 4, 5]
5594 * console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
5595 * });
5596 *
5597 * @example
5598 *
5599 * // object
5600 * var order = [];
5601 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
5602 * var iterator = function(num, done) {
5603 * setTimeout(function() {
5604 * order.push(num);
5605 * done(null, num);
5606 * }, num * 10);
5607 * };
5608 * async.sortByLimit(object, 2, iterator, function(err, res) {
5609 * console.log(res); // [1, 2, 3, 4, 5]
5610 * console.log(order); // [1, 3, 5, 2, 4]
5611 * });
5612 *
5613 * @example
5614 *
5615 * // object with key
5616 * var order = [];
5617 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
5618 * var iterator = function(num, key, done) {
5619 * setTimeout(function() {
5620 * order.push([num, key]);
5621 * done(null, num);
5622 * }, num * 10);
5623 * };
5624 * async.sortByLimit(object, 2, iterator, function(err, res) {
5625 * console.log(res); // [1, 2, 3, 4, 5]
5626 * console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
5627 * });
5628 *
5629 */
5630 function sortByLimit(collection, limit, iterator, callback) {
5631 callback = callback || noop;
5632 var size, index, key, value, array, keys, iter, item, criteria, iterate;
5633 var sync = false;
5634 var started = 0;
5635 var completed = 0;
5636
5637 if (isArray(collection)) {
5638 size = collection.length;
5639 array = collection;
5640 iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
5641 } else if (!collection) {
5642 } else if (iteratorSymbol && collection[iteratorSymbol]) {
5643 size = Infinity;
5644 iter = collection[iteratorSymbol]();
5645 array = [];
5646 criteria = [];
5647 iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
5648 } else if (typeof collection === obj) {
5649 keys = nativeKeys(collection);
5650 size = keys.length;
5651 array = Array(size);
5652 iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
5653 }
5654 if (!size || isNaN(limit) || limit < 1) {
5655 return callback(null, []);
5656 }
5657 criteria = criteria || Array(size);
5658 timesSync(limit > size ? size : limit, iterate);
5659
5660 function arrayIterator() {
5661 if (started < size) {
5662 value = collection[started];
5663 iterator(value, createCallback(value, started++));
5664 }
5665 }
5666
5667 function arrayIteratorWithIndex() {
5668 index = started++;
5669 if (index < size) {
5670 value = collection[index];
5671 iterator(value, index, createCallback(value, index));
5672 }
5673 }
5674
5675 function symbolIterator() {
5676 item = iter.next();
5677 if (item.done === false) {
5678 value = item.value;
5679 array[started] = value;
5680 iterator(value, createCallback(value, started++));
5681 } else if (completed === started && iterator !== noop) {
5682 iterator = noop;
5683 callback(null, sortByCriteria(array, criteria));
5684 }
5685 }
5686
5687 function symbolIteratorWithKey() {
5688 item = iter.next();
5689 if (item.done === false) {
5690 value = item.value;
5691 array[started] = value;
5692 iterator(value, started, createCallback(value, started++));
5693 } else if (completed === started && iterator !== noop) {
5694 iterator = noop;
5695 callback(null, sortByCriteria(array, criteria));
5696 }
5697 }
5698
5699 function objectIterator() {
5700 if (started < size) {
5701 value = collection[keys[started]];
5702 array[started] = value;
5703 iterator(value, createCallback(value, started++));
5704 }
5705 }
5706
5707 function objectIteratorWithKey() {
5708 if (started < size) {
5709 key = keys[started];
5710 value = collection[key];
5711 array[started] = value;
5712 iterator(value, key, createCallback(value, started++));
5713 }
5714 }
5715
5716 function createCallback(value, index) {
5717 var called = false;
5718 return function(err, criterion) {
5719 if (called) {
5720 throwError();
5721 }
5722 called = true;
5723 criteria[index] = criterion;
5724 if (err) {
5725 iterate = noop;
5726 callback(err);
5727 callback = noop;
5728 } else if (++completed === size) {
5729 callback(null, sortByCriteria(array, criteria));
5730 } else if (sync) {
5731 nextTick(iterate);
5732 } else {
5733 sync = true;
5734 iterate();
5735 }
5736 sync = false;
5737 };
5738 }
5739 }
5740
5741 /**
5742 * @memberof async
5743 * @namespace some
5744 * @param {Array|Object} collection
5745 * @param {Function} iterator
5746 * @param {Function} callback
5747 * @example
5748 *
5749 * // array
5750 * var order = [];
5751 * var array = [1, 3, 2];
5752 * var iterator = function(num, done) {
5753 * setTimeout(function() {
5754 * order.push(num);
5755 * done(null, num % 2);
5756 * }, num * 10);
5757 * };
5758 * async.some(array, iterator, function(err, res) {
5759 * console.log(res); // true
5760 * console.log(order); // [1]
5761 * });
5762 *
5763 * @example
5764 *
5765 * // array with index
5766 * var order = [];
5767 * var array = [1, 3, 2];
5768 * var iterator = function(num, index, done) {
5769 * setTimeout(function() {
5770 * order.push([num, index]);
5771 * done(null, num % 2);
5772 * }, num * 10);
5773 * };
5774 * async.some(array, iterator, function(err, res) {
5775 * console.log(res); // true
5776 * console.log(order); // [[1, 0]]
5777 * });
5778 *
5779 * @example
5780 *
5781 * // object
5782 * var order = [];
5783 * var object = { a: 1, b: 3, c: 2 };
5784 * var iterator = function(num, done) {
5785 * setTimeout(function() {
5786 * order.push(num);
5787 * done(null, num % 2);
5788 * }, num * 10);
5789 * };
5790 * async.some(object, iterator, function(err, res) {
5791 * console.log(res); // true
5792 * console.log(order); // [1]
5793 * });
5794 *
5795 * @example
5796 *
5797 * // object with key
5798 * var order = [];
5799 * var object = { a: 1, b: 3, c: 2 };
5800 * var iterator = function(num, key, done) {
5801 * setTimeout(function() {
5802 * order.push([num, key]);
5803 * done(null, num % 2);
5804 * }, num * 10);
5805 * };
5806 * async.some(object, iterator, function(err, res) {
5807 * console.log(res); // true
5808 * console.log(order); // [[1, 'a']]
5809 * });
5810 *
5811 */
5812 function some(collection, iterator, callback) {
5813 callback = callback || noop;
5814 detect(collection, iterator, done);
5815
5816 function done(err, res) {
5817 if (err) {
5818 return callback(err);
5819 }
5820 callback(null, !!res);
5821 }
5822 }
5823
5824 /**
5825 * @memberof async
5826 * @namespace someSeries
5827 * @param {Array|Object} collection
5828 * @param {Function} iterator
5829 * @param {Function} callback
5830 * @example
5831 *
5832 * // array
5833 * var order = [];
5834 * var array = [1, 3, 2];
5835 * var iterator = function(num, done) {
5836 * setTimeout(function() {
5837 * order.push(num);
5838 * done(null, num % 2);
5839 * }, num * 10);
5840 * };
5841 * async.someSeries(array, iterator, function(err, res) {
5842 * console.log(res); // true
5843 * console.log(order); // [1]
5844 * });
5845 *
5846 * @example
5847 *
5848 * // array with index
5849 * var order = [];
5850 * var array = [1, 3, 2];
5851 * var iterator = function(num, index, done) {
5852 * setTimeout(function() {
5853 * order.push([num, index]);
5854 * done(null, num % 2);
5855 * }, num * 10);
5856 * };
5857 * async.someSeries(array, iterator, function(err, res) {
5858 * console.log(res); // true
5859 * console.log(order); // [[1, 0]]
5860 * });
5861 *
5862 * @example
5863 *
5864 * // object
5865 * var order = [];
5866 * var object = { a: 1, b: 3, c: 2 };
5867 * var iterator = function(num, done) {
5868 * setTimeout(function() {
5869 * order.push(num);
5870 * done(null, num % 2);
5871 * }, num * 10);
5872 * };
5873 * async.someSeries(object, iterator, function(err, res) {
5874 * console.log(res); // true
5875 * console.log(order); // [1]
5876 * });
5877 *
5878 * @example
5879 *
5880 * // object with key
5881 * var order = [];
5882 * var object = { a: 1, b: 3, c: 2 };
5883 * var iterator = function(num, key, done) {
5884 * setTimeout(function() {
5885 * order.push([num, key]);
5886 * done(null, num % 2);
5887 * }, num * 10);
5888 * };
5889 * async.someSeries(object, iterator, function(err, res) {
5890 * console.log(res); // true
5891 * console.log(order); // [[1, 'a']]
5892 * });
5893 *
5894 */
5895 function someSeries(collection, iterator, callback) {
5896 callback = callback || noop;
5897 detectSeries(collection, iterator, done);
5898
5899 function done(err, res) {
5900 if (err) {
5901 return callback(err);
5902 }
5903 callback(null, !!res);
5904 }
5905 }
5906
5907 /**
5908 * @memberof async
5909 * @namespace someLimit
5910 * @param {Array|Object} collection
5911 * @param {number} limit - limit >= 1
5912 * @param {Function} iterator
5913 * @param {Function} callback
5914 * @example
5915 *
5916 * // array
5917 * var order = [];
5918 * var array = [1, 5, 3, 4, 2];
5919 * var iterator = function(num, done) {
5920 * setTimeout(function() {
5921 * order.push(num);
5922 * done(null, num % 2);
5923 * }, num * 10);
5924 * };
5925 * async.someLimit(array, 2, iterator, function(err, res) {
5926 * console.log(res); // true
5927 * console.log(order); // [1]
5928 * });
5929 *
5930 * @example
5931 *
5932 * // array with index
5933 * var order = [];
5934 * var array = [1, 5, 3, 4, 2];
5935 * var iterator = function(num, index, done) {
5936 * setTimeout(function() {
5937 * order.push([num, index]);
5938 * done(null, num % 2);
5939 * }, num * 10);
5940 * };
5941 * async.someLimit(array, 2, iterator, function(err, res) {
5942 * console.log(res); // true
5943 * console.log(order); // [[1, 0]]
5944 * });
5945 *
5946 * @example
5947 *
5948 * // object
5949 * var order = [];
5950 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
5951 * var iterator = function(num, done) {
5952 * setTimeout(function() {
5953 * order.push(num);
5954 * done(null, num % 2);
5955 * }, num * 10);
5956 * };
5957 * async.someLimit(object, 2, iterator, function(err, res) {
5958 * console.log(res); // true
5959 * console.log(order); // [1]
5960 * });
5961 *
5962 * @example
5963 *
5964 * // object with key
5965 * var order = [];
5966 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
5967 * var iterator = function(num, key, done) {
5968 * setTimeout(function() {
5969 * order.push([num, key]);
5970 * done(null, num % 2);
5971 * }, num * 10);
5972 * };
5973 * async.someLimit(object, 2, iterator, function(err, res) {
5974 * console.log(res); // true
5975 * console.log(order); // [[1, 'a']]
5976 * });
5977 *
5978 */
5979 function someLimit(collection, limit, iterator, callback) {
5980 callback = callback || noop;
5981 detectLimit(collection, limit, iterator, done);
5982
5983 function done(err, res) {
5984 if (err) {
5985 return callback(err);
5986 }
5987 callback(null, !!res);
5988 }
5989 }
5990
5991 /**
5992 * @private
5993 * @param {Function} arrayEach
5994 * @param {Function} baseEach
5995 * @param {Function} symbolEach
5996 */
5997 function createEvery(arrayEach, baseEach, symbolEach) {
5998 var deny = createDetect(arrayEach, baseEach, symbolEach, false);
5999
6000 return function every(collection, iterator, callback) {
6001 callback = callback || noop;
6002 deny(collection, iterator, done);
6003
6004 function done(err, res) {
6005 if (err) {
6006 return callback(err);
6007 }
6008 callback(null, !res);
6009 }
6010 };
6011 }
6012
6013 /**
6014 * @private
6015 */
6016 function createEverySeries() {
6017 var denySeries = createDetectSeries(false);
6018
6019 return function everySeries(collection, iterator, callback) {
6020 callback = callback || noop;
6021 denySeries(collection, iterator, done);
6022
6023 function done(err, res) {
6024 if (err) {
6025 return callback(err);
6026 }
6027 callback(null, !res);
6028 }
6029 };
6030 }
6031
6032 /**
6033 * @private
6034 */
6035 function createEveryLimit() {
6036 var denyLimit = createDetectLimit(false);
6037
6038 return function everyLimit(collection, limit, iterator, callback) {
6039 callback = callback || noop;
6040 denyLimit(collection, limit, iterator, done);
6041
6042 function done(err, res) {
6043 if (err) {
6044 return callback(err);
6045 }
6046 callback(null, !res);
6047 }
6048 };
6049 }
6050
6051 /**
6052 * @private
6053 * @param {Function} arrayEach
6054 * @param {Function} baseEach
6055 * @param {Function} symbolEach
6056 */
6057 function createConcat(arrayEach, baseEach, symbolEach) {
6058 return function concat(collection, iterator, callback) {
6059 callback = callback || noop;
6060 var size, result;
6061 var completed = 0;
6062
6063 if (isArray(collection)) {
6064 size = collection.length;
6065 result = Array(size);
6066 arrayEach(collection, iterator, createCallback);
6067 } else if (!collection) {
6068 } else if (iteratorSymbol && collection[iteratorSymbol]) {
6069 result = [];
6070 size = symbolEach(collection, iterator, createCallback);
6071 size && size === completed && callback(null, result);
6072 } else if (typeof collection === obj) {
6073 var keys = nativeKeys(collection);
6074 size = keys.length;
6075 result = Array(size);
6076 baseEach(collection, iterator, createCallback, keys);
6077 }
6078 if (!size) {
6079 callback(null, []);
6080 }
6081
6082 function createCallback(index) {
6083 return function done(err, res) {
6084 if (index === null) {
6085 throwError();
6086 }
6087 if (err) {
6088 index = null;
6089 callback = once(callback);
6090 arrayEachSync(result, function(array, index) {
6091 if (array === undefined) {
6092 result[index] = noop;
6093 }
6094 });
6095 callback(err, makeConcatResult(result));
6096 return;
6097 }
6098 switch (arguments.length) {
6099 case 0:
6100 case 1:
6101 result[index] = noop;
6102 break;
6103 case 2:
6104 result[index] = res;
6105 break;
6106 default:
6107 result[index] = slice(arguments, 1);
6108 break;
6109 }
6110 index = null;
6111 if (++completed === size) {
6112 callback(null, makeConcatResult(result));
6113 }
6114 };
6115 }
6116 };
6117 }
6118
6119 /**
6120 * @memberof async
6121 * @namespace concatSeries
6122 * @param {Array|Object} collection
6123 * @param {Function} iterator
6124 * @param {Function} callback
6125 * @example
6126 *
6127 * // array
6128 * var order = [];
6129 * var array = [1, 3, 2];
6130 * var iterator = function(num, done) {
6131 * setTimeout(function() {
6132 * order.push(num);
6133 * done(null, [num]);
6134 * }, num * 10);
6135 * };
6136 * async.concatSeries(array, iterator, function(err, res) {
6137 * console.log(res); // [1, 3, 2];
6138 * console.log(order); // [1, 3, 2]
6139 * });
6140 *
6141 * @example
6142 *
6143 * // array with index
6144 * var order = [];
6145 * var array = [1, 3, 2];
6146 * var iterator = function(num, index, done) {
6147 * setTimeout(function() {
6148 * order.push([num, index]);
6149 * done(null, [num]);
6150 * }, num * 10);
6151 * };
6152 * async.concatSeries(array, iterator, function(err, res) {
6153 * console.log(res); // [1, 3, 2]
6154 * console.log(order); // [[1, 0], [3, 1], [2, 2]]
6155 * });
6156 *
6157 * @example
6158 *
6159 * // object
6160 * var order = [];
6161 * var object = { a: 1, b: 3, c: 2 };
6162 * var iterator = function(num, done) {
6163 * setTimeout(function() {
6164 * order.push(num);
6165 * done(null, [num]);
6166 * }, num * 10);
6167 * };
6168 * async.concatSeries(object, iterator, function(err, res) {
6169 * console.log(res); // [1, 3, 2]
6170 * console.log(order); // [1, 3, 2]
6171 * });
6172 *
6173 * @example
6174 *
6175 * // object with key
6176 * var order = [];
6177 * var object = { a: 1, b: 3, c: 2 };
6178 * var iterator = function(num, key, done) {
6179 * setTimeout(function() {
6180 * order.push([num, key]);
6181 * done(null, [num]);
6182 * }, num * 10);
6183 * };
6184 * async.concatSeries(object, iterator, function(err, res) {
6185 * console.log(res); // [1, 3, 2]
6186 * console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c']]
6187 * });
6188 *
6189 */
6190 function concatSeries(collection, iterator, callback) {
6191 callback = onlyOnce(callback || noop);
6192 var size, key, keys, iter, item, iterate;
6193 var sync = false;
6194 var result = [];
6195 var completed = 0;
6196
6197 if (isArray(collection)) {
6198 size = collection.length;
6199 iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
6200 } else if (!collection) {
6201 } else if (iteratorSymbol && collection[iteratorSymbol]) {
6202 size = Infinity;
6203 iter = collection[iteratorSymbol]();
6204 iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
6205 } else if (typeof collection === obj) {
6206 keys = nativeKeys(collection);
6207 size = keys.length;
6208 iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
6209 }
6210 if (!size) {
6211 return callback(null, result);
6212 }
6213 iterate();
6214
6215 function arrayIterator() {
6216 iterator(collection[completed], done);
6217 }
6218
6219 function arrayIteratorWithIndex() {
6220 iterator(collection[completed], completed, done);
6221 }
6222
6223 function symbolIterator() {
6224 item = iter.next();
6225 item.done ? callback(null, result) : iterator(item.value, done);
6226 }
6227
6228 function symbolIteratorWithKey() {
6229 item = iter.next();
6230 item.done ? callback(null, result) : iterator(item.value, completed, done);
6231 }
6232
6233 function objectIterator() {
6234 iterator(collection[keys[completed]], done);
6235 }
6236
6237 function objectIteratorWithKey() {
6238 key = keys[completed];
6239 iterator(collection[key], key, done);
6240 }
6241
6242 function done(err, array) {
6243 if (isArray(array)) {
6244 nativePush.apply(result, array);
6245 } else if (arguments.length >= 2) {
6246 nativePush.apply(result, slice(arguments, 1));
6247 }
6248 if (err) {
6249 callback(err, result);
6250 } else if (++completed === size) {
6251 iterate = throwError;
6252 callback(null, result);
6253 } else if (sync) {
6254 nextTick(iterate);
6255 } else {
6256 sync = true;
6257 iterate();
6258 }
6259 sync = false;
6260 }
6261 }
6262
6263 /**
6264 * @memberof async
6265 * @namespace concatLimit
6266 * @param {Array|Object} collection
6267 * @param {number} limit - limit >= 1
6268 * @param {Function} iterator
6269 * @param {Function} callback
6270 * @example
6271 *
6272 * // array
6273 * var order = [];
6274 * var array = [1, 5, 3, 4, 2];
6275 * var iterator = function(num, done) {
6276 * setTimeout(function() {
6277 * order.push(num);
6278 * done(null, [num]);
6279 * }, num * 10);
6280 * };
6281 * async.concatLimit(array, 2, iterator, function(err, res) {
6282 * console.log(res); // [1, 3, 5, 2, 4]
6283 * console.log(order); // [1, 3, 5, 2, 4]
6284 * });
6285 *
6286 * @example
6287 *
6288 * // array with index
6289 * var order = [];
6290 * var array = [1, 5, 3, 4, 2];
6291 * var iterator = function(num, index, done) {
6292 * setTimeout(function() {
6293 * order.push([num, index]);
6294 * done(null, [num]);
6295 * }, num * 10);
6296 * };
6297 * async.cocnatLimit(array, 2, iterator, function(err, res) {
6298 * console.log(res); // [1, 3, 5, 2, 4]
6299 * console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]
6300 * });
6301 *
6302 * @example
6303 *
6304 * // object
6305 * var order = [];
6306 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
6307 * var iterator = function(num, done) {
6308 * setTimeout(function() {
6309 * order.push(num);
6310 * done(null, [num]);
6311 * }, num * 10);
6312 * };
6313 * async.concatLimit(object, 2, iterator, function(err, res) {
6314 * console.log(res); // [1, 3, 5, 2, 4]
6315 * console.log(order); // [1, 3, 5, 2, 4]
6316 * });
6317 *
6318 * @example
6319 *
6320 * // object with key
6321 * var order = [];
6322 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };
6323 * var iterator = function(num, key, done) {
6324 * setTimeout(function() {
6325 * order.push([num, key]);
6326 * done(null, num);
6327 * }, num * 10);
6328 * };
6329 * async.cocnatLimit(object, 2, iterator, function(err, res) {
6330 * console.log(res); // [1, 3, 5, 2, 4]
6331 * console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]
6332 * });
6333 *
6334 */
6335 function concatLimit(collection, limit, iterator, callback) {
6336 callback = callback || noop;
6337 var size, key, iter, item, iterate, result;
6338 var sync = false;
6339 var started = 0;
6340 var completed = 0;
6341
6342 if (isArray(collection)) {
6343 size = collection.length;
6344 iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
6345 } else if (!collection) {
6346 } else if (iteratorSymbol && collection[iteratorSymbol]) {
6347 size = Infinity;
6348 result = [];
6349 iter = collection[iteratorSymbol]();
6350 iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
6351 } else if (typeof collection === obj) {
6352 var keys = nativeKeys(collection);
6353 size = keys.length;
6354 iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
6355 }
6356 if (!size || isNaN(limit) || limit < 1) {
6357 return callback(null, []);
6358 }
6359 result = result || Array(size);
6360 timesSync(limit > size ? size : limit, iterate);
6361
6362 function arrayIterator() {
6363 if (started < size) {
6364 iterator(collection[started], createCallback(started++));
6365 }
6366 }
6367
6368 function arrayIteratorWithIndex() {
6369 if (started < size) {
6370 iterator(collection[started], started, createCallback(started++));
6371 }
6372 }
6373
6374 function symbolIterator() {
6375 item = iter.next();
6376 if (item.done === false) {
6377 iterator(item.value, createCallback(started++));
6378 } else if (completed === started && iterator !== noop) {
6379 iterator = noop;
6380 callback(null, makeConcatResult(result));
6381 }
6382 }
6383
6384 function symbolIteratorWithKey() {
6385 item = iter.next();
6386 if (item.done === false) {
6387 iterator(item.value, started, createCallback(started++));
6388 } else if (completed === started && iterator !== noop) {
6389 iterator = noop;
6390 callback(null, makeConcatResult(result));
6391 }
6392 }
6393
6394 function objectIterator() {
6395 if (started < size) {
6396 iterator(collection[keys[started]], createCallback(started++));
6397 }
6398 }
6399
6400 function objectIteratorWithKey() {
6401 if (started < size) {
6402 key = keys[started];
6403 iterator(collection[key], key, createCallback(started++));
6404 }
6405 }
6406
6407 function createCallback(index) {
6408 return function(err, res) {
6409 if (index === null) {
6410 throwError();
6411 }
6412 if (err) {
6413 index = null;
6414 iterate = noop;
6415 callback = once(callback);
6416 arrayEachSync(result, function(array, index) {
6417 if (array === undefined) {
6418 result[index] = noop;
6419 }
6420 });
6421 callback(err, makeConcatResult(result));
6422 return;
6423 }
6424 switch (arguments.length) {
6425 case 0:
6426 case 1:
6427 result[index] = noop;
6428 break;
6429 case 2:
6430 result[index] = res;
6431 break;
6432 default:
6433 result[index] = slice(arguments, 1);
6434 break;
6435 }
6436 index = null;
6437 if (++completed === size) {
6438 iterate = throwError;
6439 callback(null, makeConcatResult(result));
6440 callback = throwError;
6441 } else if (sync) {
6442 nextTick(iterate);
6443 } else {
6444 sync = true;
6445 iterate();
6446 }
6447 sync = false;
6448 };
6449 }
6450 }
6451
6452 /**
6453 * @private
6454 * @param {Function} arrayEach
6455 * @param {Function} baseEach
6456 * @param {Function} symbolEach
6457 */
6458 function createGroupBy(arrayEach, baseEach, symbolEach) {
6459 return function groupBy(collection, iterator, callback) {
6460 callback = callback || noop;
6461 var size;
6462 var completed = 0;
6463 var result = {};
6464
6465 if (isArray(collection)) {
6466 size = collection.length;
6467 arrayEach(collection, iterator, createCallback);
6468 } else if (!collection) {
6469 } else if (iteratorSymbol && collection[iteratorSymbol]) {
6470 size = symbolEach(collection, iterator, createCallback);
6471 size && size === completed && callback(null, result);
6472 } else if (typeof collection === obj) {
6473 var keys = nativeKeys(collection);
6474 size = keys.length;
6475 baseEach(collection, iterator, createCallback, keys);
6476 }
6477 if (!size) {
6478 callback(null, {});
6479 }
6480
6481 function createCallback(value) {
6482 var called = false;
6483 return function done(err, key) {
6484 if (called) {
6485 throwError();
6486 }
6487 called = true;
6488 if (err) {
6489 callback = once(callback);
6490 callback(err, objectClone(result));
6491 return;
6492 }
6493 var array = result[key];
6494 if (!array) {
6495 result[key] = [value];
6496 } else {
6497 array.push(value);
6498 }
6499 if (++completed === size) {
6500 callback(null, result);
6501 }
6502 };
6503 }
6504 };
6505 }
6506
6507 /**
6508 * @memberof async
6509 * @namespace groupBySeries
6510 * @param {Array|Object} collection
6511 * @param {Function} iterator
6512 * @param {Function} callback
6513 * @example
6514 *
6515 * // array
6516 * var order = [];
6517 * var array = [4.2, 6.4, 6.1];
6518 * var iterator = function(num, done) {
6519 * setTimeout(function() {
6520 * order.push(num);
6521 * done(null, Math.floor(num));
6522 * }, num * 10);
6523 * };
6524 * async.groupBySeries(array, iterator, function(err, res) {
6525 * console.log(res); // { '4': [4.2], '6': [6.4, 6.1] }
6526 * console.log(order); // [4.2, 6.4, 6.1]
6527 * });
6528 *
6529 * @example
6530 *
6531 * // array with index
6532 * var order = [];
6533 * var array = [4.2, 6.4, 6.1];
6534 * var iterator = function(num, index, done) {
6535 * setTimeout(function() {
6536 * order.push([num, index]);
6537 * done(null, Math.floor(num));
6538 * }, num * 10);
6539 * };
6540 * async.groupBySeries(array, iterator, function(err, res) {
6541 * console.log(res); // { '4': [4.2], '6': [6.4, 6.1] }
6542 * console.log(order); // [[4.2, 0], [6.4, 1], [6.1, 2]]
6543 * });
6544 *
6545 * @example
6546 *
6547 * // object
6548 * var order = [];
6549 * var object = { a: 4.2, b: 6.4, c: 6.1 };
6550 * var iterator = function(num, done) {
6551 * setTimeout(function() {
6552 * order.push(num);
6553 * done(null, Math.floor(num));
6554 * }, num * 10);
6555 * };
6556 * async.groupBySeries(object, iterator, function(err, res) {
6557 * console.log(res); // { '4': [4.2], '6': [6.4, 6.1] }
6558 * console.log(order); // [4.2, 6.4, 6.1]
6559 * });
6560 *
6561 * @example
6562 *
6563 * // object with key
6564 * var order = [];
6565 * var object = { a: 4.2, b: 6.4, c: 6.1 };
6566 * var iterator = function(num, key, done) {
6567 * setTimeout(function() {
6568 * order.push([num, key]);
6569 * done(null, Math.floor(num));
6570 * }, num * 10);
6571 * };
6572 * async.groupBySeries(object, iterator, function(err, res) {
6573 * console.log(res); // { '4': [4.2], '6': [6.4, 6.1] }
6574 * console.log(order); // [[4.2, 'a'], [6.4, 'b'], [6.1, 'c']]
6575 * });
6576 *
6577 */
6578 function groupBySeries(collection, iterator, callback) {
6579 callback = onlyOnce(callback || noop);
6580 var size, key, value, keys, iter, item, iterate;
6581 var sync = false;
6582 var completed = 0;
6583 var result = {};
6584
6585 if (isArray(collection)) {
6586 size = collection.length;
6587 iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
6588 } else if (!collection) {
6589 } else if (iteratorSymbol && collection[iteratorSymbol]) {
6590 size = Infinity;
6591 iter = collection[iteratorSymbol]();
6592 iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
6593 } else if (typeof collection === obj) {
6594 keys = nativeKeys(collection);
6595 size = keys.length;
6596 iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
6597 }
6598 if (!size) {
6599 return callback(null, result);
6600 }
6601 iterate();
6602
6603 function arrayIterator() {
6604 value = collection[completed];
6605 iterator(value, done);
6606 }
6607
6608 function arrayIteratorWithIndex() {
6609 value = collection[completed];
6610 iterator(value, completed, done);
6611 }
6612
6613 function symbolIterator() {
6614 item = iter.next();
6615 value = item.value;
6616 item.done ? callback(null, result) : iterator(value, done);
6617 }
6618
6619 function symbolIteratorWithKey() {
6620 item = iter.next();
6621 value = item.value;
6622 item.done ? callback(null, result) : iterator(value, completed, done);
6623 }
6624
6625 function objectIterator() {
6626 value = collection[keys[completed]];
6627 iterator(value, done);
6628 }
6629
6630 function objectIteratorWithKey() {
6631 key = keys[completed];
6632 value = collection[key];
6633 iterator(value, key, done);
6634 }
6635
6636 function done(err, key) {
6637 if (err) {
6638 iterate = throwError;
6639 callback = onlyOnce(callback);
6640 callback(err, objectClone(result));
6641 return;
6642 }
6643 var array = result[key];
6644 if (!array) {
6645 result[key] = [value];
6646 } else {
6647 array.push(value);
6648 }
6649 if (++completed === size) {
6650 iterate = throwError;
6651 callback(null, result);
6652 } else if (sync) {
6653 nextTick(iterate);
6654 } else {
6655 sync = true;
6656 iterate();
6657 }
6658 sync = false;
6659 }
6660 }
6661
6662 /**
6663 * @memberof async
6664 * @namespace groupByLimit
6665 * @param {Array|Object} collection
6666 * @param {Function} iterator
6667 * @param {Function} callback
6668 * @example
6669 *
6670 * // array
6671 * var order = [];
6672 * var array = [1.1, 5.9, 3.2, 3.9, 2.1];
6673 * var iterator = function(num, done) {
6674 * setTimeout(function() {
6675 * order.push(num);
6676 * done(null, Math.floor(num));
6677 * }, num * 10);
6678 * };
6679 * async.groupByLimit(array, 2, iterator, function(err, res) {
6680 * console.log(res); // { '1': [1.1], '3': [3.2, 3.9], '5': [5.9], '2': [2.1] }
6681 * console.log(order); // [1.1, 3.2, 5.9, 2.1, 3.9]
6682 * });
6683 *
6684 * @example
6685 *
6686 * // array with index
6687 * var order = [];
6688 * var array = [1.1, 5.9, 3.2, 3.9, 2.1];
6689 * var iterator = function(num, index, done) {
6690 * setTimeout(function() {
6691 * order.push([num, index]);
6692 * done(null, Math.floor(num));
6693 * }, num * 10);
6694 * };
6695 * async.groupByLimit(array, 2, iterator, function(err, res) {
6696 * console.log(res); // { '1': [1.1], '3': [3.2, 3.9], '5': [5.9], '2': [2.1] }
6697 * console.log(order); // [[1.1, 0], [3.2, 2], [5.9, 1], [2.1, 4], [3.9, 3]]
6698 * });
6699 *
6700 * @example
6701 *
6702 * // object
6703 * var order = [];
6704 * var object = { a: 1.1, b: 5.9, c: 3.2, d: 3.9, e: 2.1 }
6705 * var iterator = function(num, done) {
6706 * setTimeout(function() {
6707 * order.push(num);
6708 * done(null, Math.floor(num));
6709 * }, num * 10);
6710 * };
6711 * async.groupByLimit(object, 2, iterator, function(err, res) {
6712 * console.log(res); // { '1': [1.1], '3': [3.2, 3.9], '5': [5.9], '2': [2.1] }
6713 * console.log(order); // [1.1, 3.2, 5.9, 2.1, 3.9]
6714 * });
6715 *
6716 * @example
6717 *
6718 * // object with key
6719 * var order = [];
6720 * var object = { a: 1.1, b: 5.9, c: 3.2, d: 3.9, e: 2.1 }
6721 * var iterator = function(num, key, done) {
6722 * setTimeout(function() {
6723 * order.push([num, key]);
6724 * done(null, Math.floor(num));
6725 * }, num * 10);
6726 * };
6727 * async.groupByLimit(object, 2, iterator, function(err, res) {
6728 * console.log(res); // { '1': [1.1], '3': [3.2, 3.9], '5': [5.9], '2': [2.1] }
6729 * console.log(order); // [[1.1, 'a'], [3.2, 'c'], [5.9, 'b'], [2.1, 'e'], [3.9, 'd']]
6730 * });
6731 *
6732 */
6733 function groupByLimit(collection, limit, iterator, callback) {
6734 callback = callback || noop;
6735 var size, index, key, value, keys, iter, item, iterate;
6736 var sync = false;
6737 var started = 0;
6738 var completed = 0;
6739 var result = {};
6740
6741 if (isArray(collection)) {
6742 size = collection.length;
6743 iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;
6744 } else if (!collection) {
6745 } else if (iteratorSymbol && collection[iteratorSymbol]) {
6746 size = Infinity;
6747 iter = collection[iteratorSymbol]();
6748 iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;
6749 } else if (typeof collection === obj) {
6750 keys = nativeKeys(collection);
6751 size = keys.length;
6752 iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;
6753 }
6754 if (!size || isNaN(limit) || limit < 1) {
6755 return callback(null, result);
6756 }
6757 timesSync(limit > size ? size : limit, iterate);
6758
6759 function arrayIterator() {
6760 if (started < size) {
6761 value = collection[started++];
6762 iterator(value, createCallback(value));
6763 }
6764 }
6765
6766 function arrayIteratorWithIndex() {
6767 index = started++;
6768 if (index < size) {
6769 value = collection[index];
6770 iterator(value, index, createCallback(value));
6771 }
6772 }
6773
6774 function symbolIterator() {
6775 item = iter.next();
6776 if (item.done === false) {
6777 started++;
6778 value = item.value;
6779 iterator(value, createCallback(value));
6780 } else if (completed === started && iterator !== noop) {
6781 iterator = noop;
6782 callback(null, result);
6783 }
6784 }
6785
6786 function symbolIteratorWithKey() {
6787 item = iter.next();
6788 if (item.done === false) {
6789 value = item.value;
6790 iterator(value, started++, createCallback(value));
6791 } else if (completed === started && iterator !== noop) {
6792 iterator = noop;
6793 callback(null, result);
6794 }
6795 }
6796
6797 function objectIterator() {
6798 if (started < size) {
6799 value = collection[keys[started++]];
6800 iterator(value, createCallback(value));
6801 }
6802 }
6803
6804 function objectIteratorWithKey() {
6805 if (started < size) {
6806 key = keys[started++];
6807 value = collection[key];
6808 iterator(value, key, createCallback(value));
6809 }
6810 }
6811
6812 function createCallback(value) {
6813 var called = false;
6814 return function(err, key) {
6815 if (called) {
6816 throwError();
6817 }
6818 called = true;
6819 if (err) {
6820 iterate = noop;
6821 callback = once(callback);
6822 callback(err, objectClone(result));
6823 return;
6824 }
6825 var array = result[key];
6826 if (!array) {
6827 result[key] = [value];
6828 } else {
6829 array.push(value);
6830 }
6831 if (++completed === size) {
6832 callback(null, result);
6833 } else if (sync) {
6834 nextTick(iterate);
6835 } else {
6836 sync = true;
6837 iterate();
6838 }
6839 sync = false;
6840 };
6841 }
6842 }
6843
6844 /**
6845 * @private
6846 * @param {Function} arrayEach
6847 * @param {Function} baseEach
6848 */
6849 function createParallel(arrayEach, baseEach) {
6850 return function parallel(tasks, callback) {
6851 callback = callback || noop;
6852 var size, keys, result;
6853 var completed = 0;
6854
6855 if (isArray(tasks)) {
6856 size = tasks.length;
6857 result = Array(size);
6858 arrayEach(tasks, createCallback);
6859 } else if (tasks && typeof tasks === obj) {
6860 keys = nativeKeys(tasks);
6861 size = keys.length;
6862 result = {};
6863 baseEach(tasks, createCallback, keys);
6864 }
6865 if (!size) {
6866 callback(null, result);
6867 }
6868
6869 function createCallback(key) {
6870 return function(err, res) {
6871 if (key === null) {
6872 throwError();
6873 }
6874 if (err) {
6875 key = null;
6876 callback = once(callback);
6877 callback(err, result);
6878 return;
6879 }
6880 result[key] = arguments.length <= 2 ? res : slice(arguments, 1);
6881 key = null;
6882 if (++completed === size) {
6883 callback(null, result);
6884 }
6885 };
6886 }
6887 };
6888 }
6889
6890 /**
6891 * @memberof async
6892 * @namespace series
6893 * @param {Array|Object} tasks - functions
6894 * @param {Function} callback
6895 * @example
6896 *
6897 * var order = [];
6898 * var tasks = [
6899 * function(done) {
6900 * setTimeout(function() {
6901 * order.push(1);
6902 * done(null, 1);
6903 * }, 10);
6904 * },
6905 * function(done) {
6906 * setTimeout(function() {
6907 * order.push(2);
6908 * done(null, 2);
6909 * }, 30);
6910 * },
6911 * function(done) {
6912 * setTimeout(function() {
6913 * order.push(3);
6914 * done(null, 3);
6915 * }, 40);
6916 * },
6917 * function(done) {
6918 * setTimeout(function() {
6919 * order.push(4);
6920 * done(null, 4);
6921 * }, 20);
6922 * }
6923 * ];
6924 * async.series(tasks, function(err, res) {
6925 * console.log(res); // [1, 2, 3, 4];
6926 * console.log(order); // [1, 2, 3, 4]
6927 * });
6928 *
6929 * @example
6930 *
6931 * var order = [];
6932 * var tasks = {
6933 * 'a': function(done) {
6934 * setTimeout(function() {
6935 * order.push(1);
6936 * done(null, 1);
6937 * }, 10);
6938 * },
6939 * 'b': function(done) {
6940 * setTimeout(function() {
6941 * order.push(2);
6942 * done(null, 2);
6943 * }, 30);
6944 * },
6945 * 'c': function(done) {
6946 * setTimeout(function() {
6947 * order.push(3);
6948 * done(null, 3);
6949 * }, 40);
6950 * },
6951 * 'd': function(done) {
6952 * setTimeout(function() {
6953 * order.push(4);
6954 * done(null, 4);
6955 * }, 20);
6956 * }
6957 * };
6958 * async.series(tasks, function(err, res) {
6959 * console.log(res); // { a: 1, b: 2, c: 3, d:4 }
6960 * console.log(order); // [1, 4, 2, 3]
6961 * });
6962 *
6963 */
6964 function series(tasks, callback) {
6965 callback = callback || noop;
6966 var size, key, keys, result, iterate;
6967 var sync = false;
6968 var completed = 0;
6969
6970 if (isArray(tasks)) {
6971 size = tasks.length;
6972 result = Array(size);
6973 iterate = arrayIterator;
6974 } else if (tasks && typeof tasks === obj) {
6975 keys = nativeKeys(tasks);
6976 size = keys.length;
6977 result = {};
6978 iterate = objectIterator;
6979 } else {
6980 return callback(null);
6981 }
6982 if (!size) {
6983 return callback(null, result);
6984 }
6985 iterate();
6986
6987 function arrayIterator() {
6988 key = completed;
6989 tasks[completed](done);
6990 }
6991
6992 function objectIterator() {
6993 key = keys[completed];
6994 tasks[key](done);
6995 }
6996
6997 function done(err, res) {
6998 if (err) {
6999 iterate = throwError;
7000 callback = onlyOnce(callback);
7001 callback(err, result);
7002 return;
7003 }
7004 result[key] = arguments.length <= 2 ? res : slice(arguments, 1);
7005 if (++completed === size) {
7006 iterate = throwError;
7007 callback(null, result);
7008 } else if (sync) {
7009 nextTick(iterate);
7010 } else {
7011 sync = true;
7012 iterate();
7013 }
7014 sync = false;
7015 }
7016 }
7017
7018 /**
7019 * @memberof async
7020 * @namespace parallelLimit
7021 * @param {Array|Object} tasks - functions
7022 * @param {number} limit - limit >= 1
7023 * @param {Function} callback
7024 * @example
7025 *
7026 * var order = [];
7027 * var tasks = [
7028 * function(done) {
7029 * setTimeout(function() {
7030 * order.push(1);
7031 * done(null, 1);
7032 * }, 10);
7033 * },
7034 * function(done) {
7035 * setTimeout(function() {
7036 * order.push(2);
7037 * done(null, 2);
7038 * }, 50);
7039 * },
7040 * function(done) {
7041 * setTimeout(function() {
7042 * order.push(3);
7043 * done(null, 3);
7044 * }, 30);
7045 * },
7046 * function(done) {
7047 * setTimeout(function() {
7048 * order.push(4);
7049 * done(null, 4);
7050 * }, 40);
7051 * }
7052 * ];
7053 * async.parallelLimit(tasks, 2, function(err, res) {
7054 * console.log(res); // [1, 2, 3, 4];
7055 * console.log(order); // [1, 3, 2, 4]
7056 * });
7057 *
7058 * @example
7059 *
7060 * var order = [];
7061 * var tasks = {
7062 * 'a': function(done) {
7063 * setTimeout(function() {
7064 * order.push(1);
7065 * done(null, 1);
7066 * }, 10);
7067 * },
7068 * 'b': function(done) {
7069 * setTimeout(function() {
7070 * order.push(2);
7071 * done(null, 2);
7072 * }, 50);
7073 * },
7074 * 'c': function(done) {
7075 * setTimeout(function() {
7076 * order.push(3);
7077 * done(null, 3);
7078 * }, 20);
7079 * },
7080 * 'd': function(done) {
7081 * setTimeout(function() {
7082 * order.push(4);
7083 * done(null, 4);
7084 * }, 40);
7085 * }
7086 * };
7087 * async.parallelLimit(tasks, 2, function(err, res) {
7088 * console.log(res); // { a: 1, b: 2, c: 3, d:4 }
7089 * console.log(order); // [1, 3, 2, 4]
7090 * });
7091 *
7092 */
7093 function parallelLimit(tasks, limit, callback) {
7094 callback = callback || noop;
7095 var size, index, key, keys, result, iterate;
7096 var sync = false;
7097 var started = 0;
7098 var completed = 0;
7099
7100 if (isArray(tasks)) {
7101 size = tasks.length;
7102 result = Array(size);
7103 iterate = arrayIterator;
7104 } else if (tasks && typeof tasks === obj) {
7105 keys = nativeKeys(tasks);
7106 size = keys.length;
7107 result = {};
7108 iterate = objectIterator;
7109 }
7110 if (!size || isNaN(limit) || limit < 1) {
7111 return callback(null, result);
7112 }
7113 timesSync(limit > size ? size : limit, iterate);
7114
7115 function arrayIterator() {
7116 index = started++;
7117 if (index < size) {
7118 tasks[index](createCallback(index));
7119 }
7120 }
7121
7122 function objectIterator() {
7123 if (started < size) {
7124 key = keys[started++];
7125 tasks[key](createCallback(key));
7126 }
7127 }
7128
7129 function createCallback(key) {
7130 return function(err, res) {
7131 if (key === null) {
7132 throwError();
7133 }
7134 if (err) {
7135 key = null;
7136 iterate = noop;
7137 callback = once(callback);
7138 callback(err, result);
7139 return;
7140 }
7141 result[key] = arguments.length <= 2 ? res : slice(arguments, 1);
7142 key = null;
7143 if (++completed === size) {
7144 callback(null, result);
7145 } else if (sync) {
7146 nextTick(iterate);
7147 } else {
7148 sync = true;
7149 iterate();
7150 }
7151 sync = false;
7152 };
7153 }
7154 }
7155
7156 /**
7157 * @memberof async
7158 * @namespace tryEach
7159 * @param {Array|Object} tasks - functions
7160 * @param {Function} callback
7161 * @example
7162 *
7163 * var tasks = [
7164 * function(done) {
7165 * setTimeout(function() {
7166 * done(new Error('error'));
7167 * }, 10);
7168 * },
7169 * function(done) {
7170 * setTimeout(function() {
7171 * done(null, 2);
7172 * }, 10);
7173 * }
7174 * ];
7175 * async.tryEach(tasks, function(err, res) {
7176 * console.log(res); // 2
7177 * });
7178 *
7179 * @example
7180 *
7181 * var tasks = [
7182 * function(done) {
7183 * setTimeout(function() {
7184 * done(new Error('error1'));
7185 * }, 10);
7186 * },
7187 * function(done) {
7188 * setTimeout(function() {
7189 * done(new Error('error2');
7190 * }, 10);
7191 * }
7192 * ];
7193 * async.tryEach(tasks, function(err, res) {
7194 * console.log(err); // error2
7195 * console.log(res); // undefined
7196 * });
7197 *
7198 */
7199 function tryEach(tasks, callback) {
7200 callback = callback || noop;
7201 var size, keys, iterate;
7202 var sync = false;
7203 var completed = 0;
7204
7205 if (isArray(tasks)) {
7206 size = tasks.length;
7207 iterate = arrayIterator;
7208 } else if (tasks && typeof tasks === obj) {
7209 keys = nativeKeys(tasks);
7210 size = keys.length;
7211 iterate = objectIterator;
7212 }
7213 if (!size) {
7214 return callback(null);
7215 }
7216 iterate();
7217
7218 function arrayIterator() {
7219 tasks[completed](done);
7220 }
7221
7222 function objectIterator() {
7223 tasks[keys[completed]](done);
7224 }
7225
7226 function done(err, res) {
7227 if (!err) {
7228 if (arguments.length <= 2) {
7229 callback(null, res);
7230 } else {
7231 callback(null, slice(arguments, 1));
7232 }
7233 } else if (++completed === size) {
7234 callback(err);
7235 } else {
7236 sync = true;
7237 iterate();
7238 }
7239 sync = false;
7240 }
7241 }
7242
7243 /**
7244 * check for waterfall tasks
7245 * @private
7246 * @param {Array} tasks
7247 * @param {Function} callback
7248 * @return {boolean}
7249 */
7250 function checkWaterfallTasks(tasks, callback) {
7251 if (!isArray(tasks)) {
7252 callback(new Error('First argument to waterfall must be an array of functions'));
7253 return false;
7254 }
7255 if (tasks.length === 0) {
7256 callback(null);
7257 return false;
7258 }
7259 return true;
7260 }
7261
7262 /**
7263 * check for waterfall tasks
7264 * @private
7265 * @param {function} func
7266 * @param {Array|Object} args - arguments
7267 * @return {function} next
7268 */
7269 function waterfallIterator(func, args, next) {
7270 switch (args.length) {
7271 case 0:
7272 case 1:
7273 return func(next);
7274 case 2:
7275 return func(args[1], next);
7276 case 3:
7277 return func(args[1], args[2], next);
7278 case 4:
7279 return func(args[1], args[2], args[3], next);
7280 case 5:
7281 return func(args[1], args[2], args[3], args[4], next);
7282 case 6:
7283 return func(args[1], args[2], args[3], args[4], args[5], next);
7284 default:
7285 args = slice(args, 1);
7286 args.push(next);
7287 return func.apply(null, args);
7288 }
7289 }
7290
7291 /**
7292 * @memberof async
7293 * @namespace waterfall
7294 * @param {Array} tasks - functions
7295 * @param {Function} callback
7296 * @example
7297 *
7298 * var order = [];
7299 * var tasks = [
7300 * function(next) {
7301 * setTimeout(function() {
7302 * order.push(1);
7303 * next(null, 1);
7304 * }, 10);
7305 * },
7306 * function(arg1, next) {
7307 * setTimeout(function() {
7308 * order.push(2);
7309 * next(null, 1, 2);
7310 * }, 30);
7311 * },
7312 * function(arg1, arg2, next) {
7313 * setTimeout(function() {
7314 * order.push(3);
7315 * next(null, 3);
7316 * }, 20);
7317 * },
7318 * function(arg1, next) {
7319 * setTimeout(function() {
7320 * order.push(4);
7321 * next(null, 1, 2, 3, 4);
7322 * }, 40);
7323 * }
7324 * ];
7325 * async.waterfall(tasks, function(err, arg1, arg2, arg3, arg4) {
7326 * console.log(arg1, arg2, arg3, arg4); // 1 2 3 4
7327 * });
7328 *
7329 */
7330 function waterfall(tasks, callback) {
7331 callback = callback || noop;
7332 if (!checkWaterfallTasks(tasks, callback)) {
7333 return;
7334 }
7335 var func, args, done, sync;
7336 var completed = 0;
7337 var size = tasks.length;
7338 waterfallIterator(tasks[0], [], createCallback(0));
7339
7340 function iterate() {
7341 waterfallIterator(func, args, createCallback(func));
7342 }
7343
7344 function createCallback(index) {
7345 return function next(err, res) {
7346 if (index === undefined) {
7347 callback = noop;
7348 throwError();
7349 }
7350 index = undefined;
7351 if (err) {
7352 done = callback;
7353 callback = throwError;
7354 done(err);
7355 return;
7356 }
7357 if (++completed === size) {
7358 done = callback;
7359 callback = throwError;
7360 if (arguments.length <= 2) {
7361 done(err, res);
7362 } else {
7363 done.apply(null, createArray(arguments));
7364 }
7365 return;
7366 }
7367 if (sync) {
7368 args = arguments;
7369 func = tasks[completed] || throwError;
7370 nextTick(iterate);
7371 } else {
7372 sync = true;
7373 waterfallIterator(tasks[completed] || throwError, arguments, createCallback(completed));
7374 }
7375 sync = false;
7376 };
7377 }
7378 }
7379
7380 /**
7381 * `angelFall` is like `waterfall` and inject callback to last argument of next task.
7382 *
7383 * @memberof async
7384 * @namespace angelFall
7385 * @param {Array} tasks - functions
7386 * @param {Function} callback
7387 * @example
7388 *
7389 * var order = [];
7390 * var tasks = [
7391 * function(next) {
7392 * setTimeout(function() {
7393 * order.push(1);
7394 * next(null, 1);
7395 * }, 10);
7396 * },
7397 * function(arg1, empty, next) {
7398 * setTimeout(function() {
7399 * order.push(2);
7400 * next(null, 1, 2);
7401 * }, 30);
7402 * },
7403 * function(next) {
7404 * setTimeout(function() {
7405 * order.push(3);
7406 * next(null, 3);
7407 * }, 20);
7408 * },
7409 * function(arg1, empty1, empty2, empty3, next) {
7410 * setTimeout(function() {
7411 * order.push(4);
7412 * next(null, 1, 2, 3, 4);
7413 * }, 40);
7414 * }
7415 * ];
7416 * async.angelFall(tasks, function(err, arg1, arg2, arg3, arg4) {
7417 * console.log(arg1, arg2, arg3, arg4); // 1 2 3 4
7418 * });
7419 *
7420 */
7421 function angelFall(tasks, callback) {
7422 callback = callback || noop;
7423 if (!checkWaterfallTasks(tasks, callback)) {
7424 return;
7425 }
7426 var completed = 0;
7427 var sync = false;
7428 var size = tasks.length;
7429 var func = tasks[completed];
7430 var args = [];
7431 var iterate = function() {
7432 switch (func.length) {
7433 case 0:
7434 try {
7435 next(null, func());
7436 } catch (e) {
7437 next(e);
7438 }
7439 return;
7440 case 1:
7441 return func(next);
7442 case 2:
7443 return func(args[1], next);
7444 case 3:
7445 return func(args[1], args[2], next);
7446 case 4:
7447 return func(args[1], args[2], args[3], next);
7448 case 5:
7449 return func(args[1], args[2], args[3], args[4], next);
7450 default:
7451 args = slice(args, 1);
7452 args[func.length - 1] = next;
7453 return func.apply(null, args);
7454 }
7455 };
7456 iterate();
7457
7458 function next(err, res) {
7459 if (err) {
7460 iterate = throwError;
7461 callback = onlyOnce(callback);
7462 callback(err);
7463 return;
7464 }
7465 if (++completed === size) {
7466 iterate = throwError;
7467 var done = callback;
7468 callback = throwError;
7469 if (arguments.length === 2) {
7470 done(err, res);
7471 } else {
7472 done.apply(null, createArray(arguments));
7473 }
7474 return;
7475 }
7476 func = tasks[completed];
7477 args = arguments;
7478 if (sync) {
7479 nextTick(iterate);
7480 } else {
7481 sync = true;
7482 iterate();
7483 }
7484 sync = false;
7485 }
7486 }
7487
7488 /**
7489 * @memberof async
7490 * @namespace whilst
7491 * @param {Function} test
7492 * @param {Function} iterator
7493 * @param {Function} callback
7494 */
7495 function whilst(test, iterator, callback) {
7496 callback = callback || noop;
7497 var sync = false;
7498 if (test()) {
7499 iterate();
7500 } else {
7501 callback(null);
7502 }
7503
7504 function iterate() {
7505 if (sync) {
7506 nextTick(next);
7507 } else {
7508 sync = true;
7509 iterator(done);
7510 }
7511 sync = false;
7512 }
7513
7514 function next() {
7515 iterator(done);
7516 }
7517
7518 function done(err, arg) {
7519 if (err) {
7520 return callback(err);
7521 }
7522 if (arguments.length <= 2) {
7523 if (test(arg)) {
7524 iterate();
7525 } else {
7526 callback(null, arg);
7527 }
7528 return;
7529 }
7530 arg = slice(arguments, 1);
7531 if (test.apply(null, arg)) {
7532 iterate();
7533 } else {
7534 callback.apply(null, [null].concat(arg));
7535 }
7536 }
7537 }
7538
7539 /**
7540 * @memberof async
7541 * @namespace doWhilst
7542 * @param {Function} iterator
7543 * @param {Function} test
7544 * @param {Function} callback
7545 */
7546 function doWhilst(iterator, test, callback) {
7547 callback = callback || noop;
7548 var sync = false;
7549 next();
7550
7551 function iterate() {
7552 if (sync) {
7553 nextTick(next);
7554 } else {
7555 sync = true;
7556 iterator(done);
7557 }
7558 sync = false;
7559 }
7560
7561 function next() {
7562 iterator(done);
7563 }
7564
7565 function done(err, arg) {
7566 if (err) {
7567 return callback(err);
7568 }
7569 if (arguments.length <= 2) {
7570 if (test(arg)) {
7571 iterate();
7572 } else {
7573 callback(null, arg);
7574 }
7575 return;
7576 }
7577 arg = slice(arguments, 1);
7578 if (test.apply(null, arg)) {
7579 iterate();
7580 } else {
7581 callback.apply(null, [null].concat(arg));
7582 }
7583 }
7584 }
7585
7586 /**
7587 * @memberof async
7588 * @namespace until
7589 * @param {Function} test
7590 * @param {Function} iterator
7591 * @param {Function} callback
7592 */
7593 function until(test, iterator, callback) {
7594 callback = callback || noop;
7595 var sync = false;
7596 if (!test()) {
7597 iterate();
7598 } else {
7599 callback(null);
7600 }
7601
7602 function iterate() {
7603 if (sync) {
7604 nextTick(next);
7605 } else {
7606 sync = true;
7607 iterator(done);
7608 }
7609 sync = false;
7610 }
7611
7612 function next() {
7613 iterator(done);
7614 }
7615
7616 function done(err, arg) {
7617 if (err) {
7618 return callback(err);
7619 }
7620 if (arguments.length <= 2) {
7621 if (!test(arg)) {
7622 iterate();
7623 } else {
7624 callback(null, arg);
7625 }
7626 return;
7627 }
7628 arg = slice(arguments, 1);
7629 if (!test.apply(null, arg)) {
7630 iterate();
7631 } else {
7632 callback.apply(null, [null].concat(arg));
7633 }
7634 }
7635 }
7636
7637 /**
7638 * @memberof async
7639 * @namespace doUntil
7640 * @param {Function} iterator
7641 * @param {Function} test
7642 * @param {Function} callback
7643 */
7644 function doUntil(iterator, test, callback) {
7645 callback = callback || noop;
7646 var sync = false;
7647 next();
7648
7649 function iterate() {
7650 if (sync) {
7651 nextTick(next);
7652 } else {
7653 sync = true;
7654 iterator(done);
7655 }
7656 sync = false;
7657 }
7658
7659 function next() {
7660 iterator(done);
7661 }
7662
7663 function done(err, arg) {
7664 if (err) {
7665 return callback(err);
7666 }
7667 if (arguments.length <= 2) {
7668 if (!test(arg)) {
7669 iterate();
7670 } else {
7671 callback(null, arg);
7672 }
7673 return;
7674 }
7675 arg = slice(arguments, 1);
7676 if (!test.apply(null, arg)) {
7677 iterate();
7678 } else {
7679 callback.apply(null, [null].concat(arg));
7680 }
7681 }
7682 }
7683
7684 /**
7685 * @memberof async
7686 * @namespace during
7687 * @param {Function} test
7688 * @param {Function} iterator
7689 * @param {Function} callback
7690 */
7691 function during(test, iterator, callback) {
7692 callback = callback || noop;
7693 _test();
7694
7695 function _test() {
7696 test(iterate);
7697 }
7698
7699 function iterate(err, truth) {
7700 if (err) {
7701 return callback(err);
7702 }
7703 if (truth) {
7704 iterator(done);
7705 } else {
7706 callback(null);
7707 }
7708 }
7709
7710 function done(err) {
7711 if (err) {
7712 return callback(err);
7713 }
7714 _test();
7715 }
7716 }
7717
7718 /**
7719 * @memberof async
7720 * @namespace doDuring
7721 * @param {Function} test
7722 * @param {Function} iterator
7723 * @param {Function} callback
7724 */
7725 function doDuring(iterator, test, callback) {
7726 callback = callback || noop;
7727 iterate(null, true);
7728
7729 function iterate(err, truth) {
7730 if (err) {
7731 return callback(err);
7732 }
7733 if (truth) {
7734 iterator(done);
7735 } else {
7736 callback(null);
7737 }
7738 }
7739
7740 function done(err, res) {
7741 if (err) {
7742 return callback(err);
7743 }
7744 switch (arguments.length) {
7745 case 0:
7746 case 1:
7747 test(iterate);
7748 break;
7749 case 2:
7750 test(res, iterate);
7751 break;
7752 default:
7753 var args = slice(arguments, 1);
7754 args.push(iterate);
7755 test.apply(null, args);
7756 break;
7757 }
7758 }
7759 }
7760
7761 /**
7762 * @memberof async
7763 * @namespace forever
7764 */
7765 function forever(iterator, callback) {
7766 var sync = false;
7767 iterate();
7768
7769 function iterate() {
7770 iterator(next);
7771 }
7772
7773 function next(err) {
7774 if (err) {
7775 if (callback) {
7776 return callback(err);
7777 }
7778 throw err;
7779 }
7780 if (sync) {
7781 nextTick(iterate);
7782 } else {
7783 sync = true;
7784 iterate();
7785 }
7786 sync = false;
7787 }
7788 }
7789
7790 /**
7791 * @memberof async
7792 * @namespace compose
7793 */
7794 function compose() {
7795 return seq.apply(null, reverse(arguments));
7796 }
7797
7798 /**
7799 * @memberof async
7800 * @namespace seq
7801 */
7802 function seq(/* functions... */) {
7803 var fns = createArray(arguments);
7804
7805 return function() {
7806 var self = this;
7807 var args = createArray(arguments);
7808 var callback = args[args.length - 1];
7809 if (typeof callback === func) {
7810 args.pop();
7811 } else {
7812 callback = noop;
7813 }
7814 reduce(fns, args, iterator, done);
7815
7816 function iterator(newargs, fn, callback) {
7817 var func = function(err) {
7818 var nextargs = slice(arguments, 1);
7819 callback(err, nextargs);
7820 };
7821 newargs.push(func);
7822 fn.apply(self, newargs);
7823 }
7824
7825 function done(err, res) {
7826 res = isArray(res) ? res : [res];
7827 res.unshift(err);
7828 callback.apply(self, res);
7829 }
7830 };
7831 }
7832
7833 function createApplyEach(func) {
7834 return function applyEach(fns /* arguments */) {
7835 var go = function() {
7836 var self = this;
7837 var args = createArray(arguments);
7838 var callback = args.pop() || noop;
7839 return func(fns, iterator, callback);
7840
7841 function iterator(fn, done) {
7842 fn.apply(self, args.concat([done]));
7843 }
7844 };
7845 if (arguments.length > 1) {
7846 var args = slice(arguments, 1);
7847 return go.apply(this, args);
7848 } else {
7849 return go;
7850 }
7851 };
7852 }
7853
7854 /**
7855 * @see https://github.com/caolan/async/blob/master/lib/internal/DoublyLinkedList.js
7856 */
7857 function DLL() {
7858 this.head = null;
7859 this.tail = null;
7860 this.length = 0;
7861 }
7862
7863 DLL.prototype._removeLink = function(node) {
7864 var prev = node.prev;
7865 var next = node.next;
7866 if (prev) {
7867 prev.next = next;
7868 } else {
7869 this.head = next;
7870 }
7871 if (next) {
7872 next.prev = prev;
7873 } else {
7874 this.tail = prev;
7875 }
7876 node.prev = null;
7877 node.next = null;
7878 this.length--;
7879 return node;
7880 };
7881
7882 DLL.prototype.empty = DLL;
7883
7884 DLL.prototype._setInitial = function(node) {
7885 this.length = 1;
7886 this.head = this.tail = node;
7887 };
7888
7889 DLL.prototype.insertBefore = function(node, newNode) {
7890 newNode.prev = node.prev;
7891 newNode.next = node;
7892 if (node.prev) {
7893 node.prev.next = newNode;
7894 } else {
7895 this.head = newNode;
7896 }
7897 node.prev = newNode;
7898 this.length++;
7899 };
7900
7901 DLL.prototype.unshift = function(node) {
7902 if (this.head) {
7903 this.insertBefore(this.head, node);
7904 } else {
7905 this._setInitial(node);
7906 }
7907 };
7908
7909 DLL.prototype.push = function(node) {
7910 var tail = this.tail;
7911 if (tail) {
7912 node.prev = tail;
7913 node.next = tail.next;
7914 this.tail = node;
7915 tail.next = node;
7916 this.length++;
7917 } else {
7918 this._setInitial(node);
7919 }
7920 };
7921
7922 DLL.prototype.shift = function() {
7923 return this.head && this._removeLink(this.head);
7924 };
7925
7926 DLL.prototype.splice = function(end) {
7927 var task;
7928 var tasks = [];
7929 while (end-- && (task = this.shift())) {
7930 tasks.push(task);
7931 }
7932 return tasks;
7933 };
7934
7935 DLL.prototype.remove = function(test) {
7936 var node = this.head;
7937 while (node) {
7938 if (test(node)) {
7939 this._removeLink(node);
7940 }
7941 node = node.next;
7942 }
7943 return this;
7944 };
7945
7946 /**
7947 * @private
7948 */
7949 function baseQueue(isQueue, worker, concurrency, payload) {
7950 if (concurrency === undefined) {
7951 concurrency = 1;
7952 } else if (isNaN(concurrency) || concurrency < 1) {
7953 throw new Error('Concurrency must not be zero');
7954 }
7955
7956 var workers = 0;
7957 var workersList = [];
7958 var _callback, _unshift;
7959
7960 var q = {
7961 _tasks: new DLL(),
7962 concurrency: concurrency,
7963 payload: payload,
7964 saturated: noop,
7965 unsaturated: noop,
7966 buffer: concurrency / 4,
7967 empty: noop,
7968 drain: noop,
7969 error: noop,
7970 started: false,
7971 paused: false,
7972 push: push,
7973 kill: kill,
7974 unshift: unshift,
7975 remove: remove,
7976 process: isQueue ? runQueue : runCargo,
7977 length: getLength,
7978 running: running,
7979 workersList: getWorkersList,
7980 idle: idle,
7981 pause: pause,
7982 resume: resume,
7983 _worker: worker
7984 };
7985 return q;
7986
7987 function push(tasks, callback) {
7988 _insert(tasks, callback);
7989 }
7990
7991 function unshift(tasks, callback) {
7992 _insert(tasks, callback, true);
7993 }
7994
7995 function _exec(task) {
7996 var item = {
7997 data: task,
7998 callback: _callback
7999 };
8000 if (_unshift) {
8001 q._tasks.unshift(item);
8002 } else {
8003 q._tasks.push(item);
8004 }
8005 nextTick(q.process);
8006 }
8007
8008 function _insert(tasks, callback, unshift) {
8009 if (callback == null) {
8010 callback = noop;
8011 } else if (typeof callback !== 'function') {
8012 throw new Error('task callback must be a function');
8013 }
8014 q.started = true;
8015 var _tasks = isArray(tasks) ? tasks : [tasks];
8016
8017 if (tasks === undefined || !_tasks.length) {
8018 if (q.idle()) {
8019 nextTick(q.drain);
8020 }
8021 return;
8022 }
8023
8024 _unshift = unshift;
8025 _callback = callback;
8026 arrayEachSync(_tasks, _exec);
8027 // Avoid leaking the callback
8028 _callback = undefined;
8029 }
8030
8031 function kill() {
8032 q.drain = noop;
8033 q._tasks.empty();
8034 }
8035
8036 function _next(q, tasks) {
8037 var called = false;
8038 return function done(err, res) {
8039 if (called) {
8040 throwError();
8041 }
8042 called = true;
8043
8044 workers--;
8045 var task;
8046 var index = -1;
8047 var size = workersList.length;
8048 var taskIndex = -1;
8049 var taskSize = tasks.length;
8050 var useApply = arguments.length > 2;
8051 var args = useApply && createArray(arguments);
8052 while (++taskIndex < taskSize) {
8053 task = tasks[taskIndex];
8054 while (++index < size) {
8055 if (workersList[index] === task) {
8056 if (index === 0) {
8057 workersList.shift();
8058 } else {
8059 workersList.splice(index, 1);
8060 }
8061 index = size;
8062 size--;
8063 }
8064 }
8065 index = -1;
8066 if (useApply) {
8067 task.callback.apply(task, args);
8068 } else {
8069 task.callback(err, res);
8070 }
8071 if (err) {
8072 q.error(err, task.data);
8073 }
8074 }
8075
8076 if (workers <= q.concurrency - q.buffer) {
8077 q.unsaturated();
8078 }
8079
8080 if (q._tasks.length + workers === 0) {
8081 q.drain();
8082 }
8083 q.process();
8084 };
8085 }
8086
8087 function runQueue() {
8088 while (!q.paused && workers < q.concurrency && q._tasks.length) {
8089 var task = q._tasks.shift();
8090 workers++;
8091 workersList.push(task);
8092 if (q._tasks.length === 0) {
8093 q.empty();
8094 }
8095 if (workers === q.concurrency) {
8096 q.saturated();
8097 }
8098 var done = _next(q, [task]);
8099 worker(task.data, done);
8100 }
8101 }
8102
8103 function runCargo() {
8104 while (!q.paused && workers < q.concurrency && q._tasks.length) {
8105 var tasks = q._tasks.splice(q.payload || q._tasks.length);
8106 var index = -1;
8107 var size = tasks.length;
8108 var data = Array(size);
8109 while (++index < size) {
8110 data[index] = tasks[index].data;
8111 }
8112 workers++;
8113 nativePush.apply(workersList, tasks);
8114 if (q._tasks.length === 0) {
8115 q.empty();
8116 }
8117 if (workers === q.concurrency) {
8118 q.saturated();
8119 }
8120 var done = _next(q, tasks);
8121 worker(data, done);
8122 }
8123 }
8124
8125 function getLength() {
8126 return q._tasks.length;
8127 }
8128
8129 function running() {
8130 return workers;
8131 }
8132
8133 function getWorkersList() {
8134 return workersList;
8135 }
8136
8137 function idle() {
8138 return q.length() + workers === 0;
8139 }
8140
8141 function pause() {
8142 q.paused = true;
8143 }
8144
8145 function _resume() {
8146 nextTick(q.process);
8147 }
8148
8149 function resume() {
8150 if (q.paused === false) {
8151 return;
8152 }
8153 q.paused = false;
8154 var count = q.concurrency < q._tasks.length ? q.concurrency : q._tasks.length;
8155 timesSync(count, _resume);
8156 }
8157
8158 /**
8159 * @param {Function} test
8160 */
8161 function remove(test) {
8162 q._tasks.remove(test);
8163 }
8164 }
8165
8166 /**
8167 * @memberof async
8168 * @namespace queue
8169 */
8170 function queue(worker, concurrency) {
8171 return baseQueue(true, worker, concurrency);
8172 }
8173
8174 /**
8175 * @memberof async
8176 * @namespace priorityQueue
8177 */
8178 function priorityQueue(worker, concurrency) {
8179 var q = baseQueue(true, worker, concurrency);
8180 q.push = push;
8181 delete q.unshift;
8182 return q;
8183
8184 function push(tasks, priority, callback) {
8185 q.started = true;
8186 priority = priority || 0;
8187 var _tasks = isArray(tasks) ? tasks : [tasks];
8188 var taskSize = _tasks.length;
8189
8190 if (tasks === undefined || taskSize === 0) {
8191 if (q.idle()) {
8192 nextTick(q.drain);
8193 }
8194 return;
8195 }
8196
8197 callback = typeof callback === func ? callback : noop;
8198 var nextNode = q._tasks.head;
8199 while (nextNode && priority >= nextNode.priority) {
8200 nextNode = nextNode.next;
8201 }
8202 while (taskSize--) {
8203 var item = {
8204 data: _tasks[taskSize],
8205 priority: priority,
8206 callback: callback
8207 };
8208 if (nextNode) {
8209 q._tasks.insertBefore(nextNode, item);
8210 } else {
8211 q._tasks.push(item);
8212 }
8213 nextTick(q.process);
8214 }
8215 }
8216 }
8217
8218 /**
8219 * @memberof async
8220 * @namespace cargo
8221 */
8222 function cargo(worker, payload) {
8223 return baseQueue(false, worker, 1, payload);
8224 }
8225
8226 /**
8227 * @memberof async
8228 * @namespace auto
8229 * @param {Object} tasks
8230 * @param {number} [concurrency]
8231 * @param {Function} [callback]
8232 */
8233 function auto(tasks, concurrency, callback) {
8234 if (typeof concurrency === func) {
8235 callback = concurrency;
8236 concurrency = null;
8237 }
8238 var keys = nativeKeys(tasks);
8239 var rest = keys.length;
8240 var results = {};
8241 if (rest === 0) {
8242 return callback(null, results);
8243 }
8244 var runningTasks = 0;
8245 var readyTasks = new DLL();
8246 var listeners = Object.create(null);
8247 callback = onlyOnce(callback || noop);
8248 concurrency = concurrency || rest;
8249
8250 baseEachSync(tasks, iterator, keys);
8251 proceedQueue();
8252
8253 function iterator(task, key) {
8254 // no dependencies
8255 var _task, _taskSize;
8256 if (!isArray(task)) {
8257 _task = task;
8258 _taskSize = 0;
8259 readyTasks.push([_task, _taskSize, done]);
8260 return;
8261 }
8262 var dependencySize = task.length - 1;
8263 _task = task[dependencySize];
8264 _taskSize = dependencySize;
8265 if (dependencySize === 0) {
8266 readyTasks.push([_task, _taskSize, done]);
8267 return;
8268 }
8269 // dependencies
8270 var index = -1;
8271 while (++index < dependencySize) {
8272 var dependencyName = task[index];
8273 if (notInclude(keys, dependencyName)) {
8274 var msg =
8275 'async.auto task `' +
8276 key +
8277 '` has non-existent dependency `' +
8278 dependencyName +
8279 '` in ' +
8280 task.join(', ');
8281 throw new Error(msg);
8282 }
8283 var taskListeners = listeners[dependencyName];
8284 if (!taskListeners) {
8285 taskListeners = listeners[dependencyName] = [];
8286 }
8287 taskListeners.push(taskListener);
8288 }
8289
8290 function done(err, arg) {
8291 if (key === null) {
8292 throwError();
8293 }
8294 arg = arguments.length <= 2 ? arg : slice(arguments, 1);
8295 if (err) {
8296 rest = 0;
8297 runningTasks = 0;
8298 readyTasks.length = 0;
8299 var safeResults = objectClone(results);
8300 safeResults[key] = arg;
8301 key = null;
8302 var _callback = callback;
8303 callback = noop;
8304 _callback(err, safeResults);
8305 return;
8306 }
8307 runningTasks--;
8308 rest--;
8309 results[key] = arg;
8310 taskComplete(key);
8311 key = null;
8312 }
8313
8314 function taskListener() {
8315 if (--dependencySize === 0) {
8316 readyTasks.push([_task, _taskSize, done]);
8317 }
8318 }
8319 }
8320
8321 function proceedQueue() {
8322 if (readyTasks.length === 0 && runningTasks === 0) {
8323 if (rest !== 0) {
8324 throw new Error('async.auto task has cyclic dependencies');
8325 }
8326 return callback(null, results);
8327 }
8328 while (readyTasks.length && runningTasks < concurrency && callback !== noop) {
8329 runningTasks++;
8330 var array = readyTasks.shift();
8331 if (array[1] === 0) {
8332 array[0](array[2]);
8333 } else {
8334 array[0](results, array[2]);
8335 }
8336 }
8337 }
8338
8339 function taskComplete(key) {
8340 var taskListeners = listeners[key] || [];
8341 arrayEachSync(taskListeners, function(task) {
8342 task();
8343 });
8344 proceedQueue();
8345 }
8346 }
8347
8348 var FN_ARGS = /^(function)?\s*[^\(]*\(\s*([^\)]*)\)/m;
8349 var FN_ARG_SPLIT = /,/;
8350 var FN_ARG = /(=.+)?(\s*)$/;
8351 var STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm;
8352
8353 /**
8354 * parse function arguments for `autoInject`
8355 *
8356 * @private
8357 */
8358 function parseParams(func) {
8359 func = func.toString().replace(STRIP_COMMENTS, '');
8360 func = func.match(FN_ARGS)[2].replace(' ', '');
8361 func = func ? func.split(FN_ARG_SPLIT) : [];
8362 func = func.map(function(arg) {
8363 return arg.replace(FN_ARG, '').trim();
8364 });
8365 return func;
8366 }
8367
8368 /**
8369 * @memberof async
8370 * @namespace autoInject
8371 * @param {Object} tasks
8372 * @param {number} [concurrency]
8373 * @param {Function} [callback]
8374 */
8375 function autoInject(tasks, concurrency, callback) {
8376 var newTasks = {};
8377 baseEachSync(tasks, iterator, nativeKeys(tasks));
8378 auto(newTasks, concurrency, callback);
8379
8380 function iterator(task, key) {
8381 var params;
8382 var taskLength = task.length;
8383
8384 if (isArray(task)) {
8385 if (taskLength === 0) {
8386 throw new Error('autoInject task functions require explicit parameters.');
8387 }
8388 params = createArray(task);
8389 taskLength = params.length - 1;
8390 task = params[taskLength];
8391 if (taskLength === 0) {
8392 newTasks[key] = task;
8393 return;
8394 }
8395 } else if (taskLength === 1) {
8396 newTasks[key] = task;
8397 return;
8398 } else {
8399 params = parseParams(task);
8400 if (taskLength === 0 && params.length === 0) {
8401 throw new Error('autoInject task functions require explicit parameters.');
8402 }
8403 taskLength = params.length - 1;
8404 }
8405 params[taskLength] = newTask;
8406 newTasks[key] = params;
8407
8408 function newTask(results, done) {
8409 switch (taskLength) {
8410 case 1:
8411 task(results[params[0]], done);
8412 break;
8413 case 2:
8414 task(results[params[0]], results[params[1]], done);
8415 break;
8416 case 3:
8417 task(results[params[0]], results[params[1]], results[params[2]], done);
8418 break;
8419 default:
8420 var i = -1;
8421 while (++i < taskLength) {
8422 params[i] = results[params[i]];
8423 }
8424 params[i] = done;
8425 task.apply(null, params);
8426 break;
8427 }
8428 }
8429 }
8430 }
8431
8432 /**
8433 * @memberof async
8434 * @namespace retry
8435 * @param {integer|Object|Function} opts
8436 * @param {Function} [task]
8437 * @param {Function} [callback]
8438 */
8439 function retry(opts, task, callback) {
8440 var times, intervalFunc, errorFilter;
8441 var count = 0;
8442 if (arguments.length < 3 && typeof opts === func) {
8443 callback = task || noop;
8444 task = opts;
8445 opts = null;
8446 times = DEFAULT_TIMES;
8447 } else {
8448 callback = callback || noop;
8449 switch (typeof opts) {
8450 case 'object':
8451 if (typeof opts.errorFilter === func) {
8452 errorFilter = opts.errorFilter;
8453 }
8454 var interval = opts.interval;
8455 switch (typeof interval) {
8456 case func:
8457 intervalFunc = interval;
8458 break;
8459 case 'string':
8460 case 'number':
8461 interval = +interval;
8462 intervalFunc = interval
8463 ? function() {
8464 return interval;
8465 }
8466 : function() {
8467 return DEFAULT_INTERVAL;
8468 };
8469 break;
8470 }
8471 times = +opts.times || DEFAULT_TIMES;
8472 break;
8473 case 'number':
8474 times = opts || DEFAULT_TIMES;
8475 break;
8476 case 'string':
8477 times = +opts || DEFAULT_TIMES;
8478 break;
8479 default:
8480 throw new Error('Invalid arguments for async.retry');
8481 }
8482 }
8483 if (typeof task !== 'function') {
8484 throw new Error('Invalid arguments for async.retry');
8485 }
8486
8487 if (intervalFunc) {
8488 task(intervalCallback);
8489 } else {
8490 task(simpleCallback);
8491 }
8492
8493 function simpleIterator() {
8494 task(simpleCallback);
8495 }
8496
8497 function simpleCallback(err, res) {
8498 if (++count === times || !err || (errorFilter && !errorFilter(err))) {
8499 if (arguments.length <= 2) {
8500 return callback(err, res);
8501 }
8502 var args = createArray(arguments);
8503 return callback.apply(null, args);
8504 }
8505 simpleIterator();
8506 }
8507
8508 function intervalIterator() {
8509 task(intervalCallback);
8510 }
8511
8512 function intervalCallback(err, res) {
8513 if (++count === times || !err || (errorFilter && !errorFilter(err))) {
8514 if (arguments.length <= 2) {
8515 return callback(err, res);
8516 }
8517 var args = createArray(arguments);
8518 return callback.apply(null, args);
8519 }
8520 setTimeout(intervalIterator, intervalFunc(count));
8521 }
8522 }
8523
8524 function retryable(opts, task) {
8525 if (!task) {
8526 task = opts;
8527 opts = null;
8528 }
8529 return done;
8530
8531 function done() {
8532 var taskFn;
8533 var args = createArray(arguments);
8534 var lastIndex = args.length - 1;
8535 var callback = args[lastIndex];
8536 switch (task.length) {
8537 case 1:
8538 taskFn = task1;
8539 break;
8540 case 2:
8541 taskFn = task2;
8542 break;
8543 case 3:
8544 taskFn = task3;
8545 break;
8546 default:
8547 taskFn = task4;
8548 }
8549 if (opts) {
8550 retry(opts, taskFn, callback);
8551 } else {
8552 retry(taskFn, callback);
8553 }
8554
8555 function task1(done) {
8556 task(done);
8557 }
8558
8559 function task2(done) {
8560 task(args[0], done);
8561 }
8562
8563 function task3(done) {
8564 task(args[0], args[1], done);
8565 }
8566
8567 function task4(callback) {
8568 args[lastIndex] = callback;
8569 task.apply(null, args);
8570 }
8571 }
8572 }
8573
8574 /**
8575 * @memberof async
8576 * @namespace iterator
8577 */
8578 function iterator(tasks) {
8579 var size = 0;
8580 var keys = [];
8581 if (isArray(tasks)) {
8582 size = tasks.length;
8583 } else {
8584 keys = nativeKeys(tasks);
8585 size = keys.length;
8586 }
8587 return makeCallback(0);
8588
8589 function makeCallback(index) {
8590 var fn = function() {
8591 if (size) {
8592 var key = keys[index] || index;
8593 tasks[key].apply(null, createArray(arguments));
8594 }
8595 return fn.next();
8596 };
8597 fn.next = function() {
8598 return index < size - 1 ? makeCallback(index + 1) : null;
8599 };
8600 return fn;
8601 }
8602 }
8603
8604 /**
8605 * @memberof async
8606 * @namespace apply
8607 */
8608 function apply(func) {
8609 switch (arguments.length) {
8610 case 0:
8611 case 1:
8612 return func;
8613 case 2:
8614 return func.bind(null, arguments[1]);
8615 case 3:
8616 return func.bind(null, arguments[1], arguments[2]);
8617 case 4:
8618 return func.bind(null, arguments[1], arguments[2], arguments[3]);
8619 case 5:
8620 return func.bind(null, arguments[1], arguments[2], arguments[3], arguments[4]);
8621 default:
8622 var size = arguments.length;
8623 var index = 0;
8624 var args = Array(size);
8625 args[index] = null;
8626 while (++index < size) {
8627 args[index] = arguments[index];
8628 }
8629 return func.bind.apply(func, args);
8630 }
8631 }
8632
8633 /**
8634 * @memberof async
8635 * @namespace timeout
8636 * @param {Function} func
8637 * @param {number} millisec
8638 * @param {*} info
8639 */
8640 function timeout(func, millisec, info) {
8641 var callback, timer;
8642 return wrappedFunc;
8643
8644 function wrappedFunc() {
8645 timer = setTimeout(timeoutCallback, millisec);
8646 var args = createArray(arguments);
8647 var lastIndex = args.length - 1;
8648 callback = args[lastIndex];
8649 args[lastIndex] = injectedCallback;
8650 simpleApply(func, args);
8651 }
8652
8653 function timeoutCallback() {
8654 var name = func.name || 'anonymous';
8655 var err = new Error('Callback function "' + name + '" timed out.');
8656 err.code = 'ETIMEDOUT';
8657 if (info) {
8658 err.info = info;
8659 }
8660 timer = null;
8661 callback(err);
8662 }
8663
8664 function injectedCallback() {
8665 if (timer !== null) {
8666 simpleApply(callback, createArray(arguments));
8667 clearTimeout(timer);
8668 }
8669 }
8670
8671 function simpleApply(func, args) {
8672 switch (args.length) {
8673 case 0:
8674 func();
8675 break;
8676 case 1:
8677 func(args[0]);
8678 break;
8679 case 2:
8680 func(args[0], args[1]);
8681 break;
8682 default:
8683 func.apply(null, args);
8684 break;
8685 }
8686 }
8687 }
8688
8689 /**
8690 * @memberof async
8691 * @namespace times
8692 * @param {number} n - n >= 1
8693 * @param {Function} iterator
8694 * @param {Function} callback
8695 * @example
8696 *
8697 * var iterator = function(n, done) {
8698 * done(null, n);
8699 * };
8700 * async.times(4, iterator, function(err, res) {
8701 * console.log(res); // [0, 1, 2, 3];
8702 * });
8703 *
8704 */
8705 function times(n, iterator, callback) {
8706 callback = callback || noop;
8707 n = +n;
8708 if (isNaN(n) || n < 1) {
8709 return callback(null, []);
8710 }
8711 var result = Array(n);
8712 timesSync(n, iterate);
8713
8714 function iterate(num) {
8715 iterator(num, createCallback(num));
8716 }
8717
8718 function createCallback(index) {
8719 return function(err, res) {
8720 if (index === null) {
8721 throwError();
8722 }
8723 result[index] = res;
8724 index = null;
8725 if (err) {
8726 callback(err);
8727 callback = noop;
8728 } else if (--n === 0) {
8729 callback(null, result);
8730 }
8731 };
8732 }
8733 }
8734
8735 /**
8736 * @memberof async
8737 * @namespace timesSeries
8738 * @param {number} n - n >= 1
8739 * @param {Function} iterator
8740 * @param {Function} callback
8741 * @example
8742 *
8743 * var iterator = function(n, done) {
8744 * done(null, n);
8745 * };
8746 * async.timesSeries(4, iterator, function(err, res) {
8747 * console.log(res); // [0, 1, 2, 3];
8748 * });
8749 *
8750 */
8751 function timesSeries(n, iterator, callback) {
8752 callback = callback || noop;
8753 n = +n;
8754 if (isNaN(n) || n < 1) {
8755 return callback(null, []);
8756 }
8757 var result = Array(n);
8758 var sync = false;
8759 var completed = 0;
8760 iterate();
8761
8762 function iterate() {
8763 iterator(completed, done);
8764 }
8765
8766 function done(err, res) {
8767 result[completed] = res;
8768 if (err) {
8769 callback(err);
8770 callback = throwError;
8771 } else if (++completed >= n) {
8772 callback(null, result);
8773 callback = throwError;
8774 } else if (sync) {
8775 nextTick(iterate);
8776 } else {
8777 sync = true;
8778 iterate();
8779 }
8780 sync = false;
8781 }
8782 }
8783
8784 /**
8785 * @memberof async
8786 * @namespace timesLimit
8787 * @param {number} n - n >= 1
8788 * @param {number} limit - n >= 1
8789 * @param {Function} iterator
8790 * @param {Function} callback
8791 * @example
8792 *
8793 * var iterator = function(n, done) {
8794 * done(null, n);
8795 * };
8796 * async.timesLimit(4, 2, iterator, function(err, res) {
8797 * console.log(res); // [0, 1, 2, 3];
8798 * });
8799 *
8800 */
8801 function timesLimit(n, limit, iterator, callback) {
8802 callback = callback || noop;
8803 n = +n;
8804 if (isNaN(n) || n < 1 || isNaN(limit) || limit < 1) {
8805 return callback(null, []);
8806 }
8807 var result = Array(n);
8808 var sync = false;
8809 var started = 0;
8810 var completed = 0;
8811 timesSync(limit > n ? n : limit, iterate);
8812
8813 function iterate() {
8814 var index = started++;
8815 if (index < n) {
8816 iterator(index, createCallback(index));
8817 }
8818 }
8819
8820 function createCallback(index) {
8821 return function(err, res) {
8822 if (index === null) {
8823 throwError();
8824 }
8825 result[index] = res;
8826 index = null;
8827 if (err) {
8828 callback(err);
8829 callback = noop;
8830 } else if (++completed >= n) {
8831 callback(null, result);
8832 callback = throwError;
8833 } else if (sync) {
8834 nextTick(iterate);
8835 } else {
8836 sync = true;
8837 iterate();
8838 }
8839 sync = false;
8840 };
8841 }
8842 }
8843
8844 /**
8845 * @memberof async
8846 * @namespace race
8847 * @param {Array|Object} tasks - functions
8848 * @param {Function} callback
8849 * @example
8850 *
8851 * // array
8852 * var called = 0;
8853 * var tasks = [
8854 * function(done) {
8855 * setTimeout(function() {
8856 * called++;
8857 * done(null, '1');
8858 * }, 30);
8859 * },
8860 * function(done) {
8861 * setTimeout(function() {
8862 * called++;
8863 * done(null, '2');
8864 * }, 20);
8865 * },
8866 * function(done) {
8867 * setTimeout(function() {
8868 * called++;
8869 * done(null, '3');
8870 * }, 10);
8871 * }
8872 * ];
8873 * async.race(tasks, function(err, res) {
8874 * console.log(res); // '3'
8875 * console.log(called); // 1
8876 * setTimeout(function() {
8877 * console.log(called); // 3
8878 * }, 50);
8879 * });
8880 *
8881 * @example
8882 *
8883 * // object
8884 * var called = 0;
8885 * var tasks = {
8886 * 'test1': function(done) {
8887 * setTimeout(function() {
8888 * called++;
8889 * done(null, '1');
8890 * }, 30);
8891 * },
8892 * 'test2': function(done) {
8893 * setTimeout(function() {
8894 * called++;
8895 * done(null, '2');
8896 * }, 20);
8897 * },
8898 * 'test3': function(done) {
8899 * setTimeout(function() {
8900 * called++;
8901 * done(null, '3');
8902 * }, 10);
8903 * }
8904 * };
8905 * async.race(tasks, function(err, res) {
8906 * console.log(res); // '3'
8907 * console.log(called); // 1
8908 * setTimeout(function() {
8909 * console.log(called); // 3
8910 * done();
8911 * }, 50);
8912 * });
8913 *
8914 */
8915 function race(tasks, callback) {
8916 callback = once(callback || noop);
8917 var size, keys;
8918 var index = -1;
8919 if (isArray(tasks)) {
8920 size = tasks.length;
8921 while (++index < size) {
8922 tasks[index](callback);
8923 }
8924 } else if (tasks && typeof tasks === obj) {
8925 keys = nativeKeys(tasks);
8926 size = keys.length;
8927 while (++index < size) {
8928 tasks[keys[index]](callback);
8929 }
8930 } else {
8931 return callback(new TypeError('First argument to race must be a collection of functions'));
8932 }
8933 if (!size) {
8934 callback(null);
8935 }
8936 }
8937
8938 /**
8939 * @memberof async
8940 * @namespace memoize
8941 */
8942 function memoize(fn, hasher) {
8943 hasher =
8944 hasher ||
8945 function(hash) {
8946 return hash;
8947 };
8948
8949 var memo = {};
8950 var queues = {};
8951 var memoized = function() {
8952 var args = createArray(arguments);
8953 var callback = args.pop();
8954 var key = hasher.apply(null, args);
8955 if (has(memo, key)) {
8956 nextTick(function() {
8957 callback.apply(null, memo[key]);
8958 });
8959 return;
8960 }
8961 if (has(queues, key)) {
8962 return queues[key].push(callback);
8963 }
8964
8965 queues[key] = [callback];
8966 args.push(done);
8967 fn.apply(null, args);
8968
8969 function done(err) {
8970 var args = createArray(arguments);
8971 if (!err) {
8972 memo[key] = args;
8973 }
8974 var q = queues[key];
8975 delete queues[key];
8976
8977 var i = -1;
8978 var size = q.length;
8979 while (++i < size) {
8980 q[i].apply(null, args);
8981 }
8982 }
8983 };
8984 memoized.memo = memo;
8985 memoized.unmemoized = fn;
8986 return memoized;
8987 }
8988
8989 /**
8990 * @memberof async
8991 * @namespace unmemoize
8992 */
8993 function unmemoize(fn) {
8994 return function() {
8995 return (fn.unmemoized || fn).apply(null, arguments);
8996 };
8997 }
8998
8999 /**
9000 * @memberof async
9001 * @namespace ensureAsync
9002 */
9003 function ensureAsync(fn) {
9004 return function(/* ...args, callback */) {
9005 var args = createArray(arguments);
9006 var lastIndex = args.length - 1;
9007 var callback = args[lastIndex];
9008 var sync = true;
9009 args[lastIndex] = done;
9010 fn.apply(this, args);
9011 sync = false;
9012
9013 function done() {
9014 var innerArgs = createArray(arguments);
9015 if (sync) {
9016 nextTick(function() {
9017 callback.apply(null, innerArgs);
9018 });
9019 } else {
9020 callback.apply(null, innerArgs);
9021 }
9022 }
9023 };
9024 }
9025
9026 /**
9027 * @memberof async
9028 * @namespace constant
9029 */
9030 function constant(/* values... */) {
9031 var args = [null].concat(createArray(arguments));
9032 return function(callback) {
9033 callback = arguments[arguments.length - 1];
9034 callback.apply(this, args);
9035 };
9036 }
9037
9038 function asyncify(fn) {
9039 return function(/* args..., callback */) {
9040 var args = createArray(arguments);
9041 var callback = args.pop();
9042 var result;
9043 try {
9044 result = fn.apply(this, args);
9045 } catch (e) {
9046 return callback(e);
9047 }
9048 if (result && typeof result.then === func) {
9049 result.then(
9050 function(value) {
9051 invokeCallback(callback, null, value);
9052 },
9053 function(err) {
9054 invokeCallback(callback, err && err.message ? err : new Error(err));
9055 }
9056 );
9057 } else {
9058 callback(null, result);
9059 }
9060 };
9061 }
9062
9063 function invokeCallback(callback, err, value) {
9064 try {
9065 callback(err, value);
9066 } catch (e) {
9067 nextTick(rethrow, e);
9068 }
9069 }
9070
9071 function rethrow(error) {
9072 throw error;
9073 }
9074
9075 /**
9076 * @memberof async
9077 * @namespace reflect
9078 * @param {Function} func
9079 * @return {Function}
9080 */
9081 function reflect(func) {
9082 return function(/* args..., callback */) {
9083 var callback;
9084 switch (arguments.length) {
9085 case 1:
9086 callback = arguments[0];
9087 return func(done);
9088 case 2:
9089 callback = arguments[1];
9090 return func(arguments[0], done);
9091 default:
9092 var args = createArray(arguments);
9093 var lastIndex = args.length - 1;
9094 callback = args[lastIndex];
9095 args[lastIndex] = done;
9096 func.apply(this, args);
9097 }
9098
9099 function done(err, res) {
9100 if (err) {
9101 return callback(null, {
9102 error: err
9103 });
9104 }
9105 if (arguments.length > 2) {
9106 res = slice(arguments, 1);
9107 }
9108 callback(null, {
9109 value: res
9110 });
9111 }
9112 };
9113 }
9114
9115 /**
9116 * @memberof async
9117 * @namespace reflectAll
9118 * @param {Array[]|Object} tasks
9119 * @return {Function}
9120 */
9121 function reflectAll(tasks) {
9122 var newTasks, keys;
9123 if (isArray(tasks)) {
9124 newTasks = Array(tasks.length);
9125 arrayEachSync(tasks, iterate);
9126 } else if (tasks && typeof tasks === obj) {
9127 keys = nativeKeys(tasks);
9128 newTasks = {};
9129 baseEachSync(tasks, iterate, keys);
9130 }
9131 return newTasks;
9132
9133 function iterate(func, key) {
9134 newTasks[key] = reflect(func);
9135 }
9136 }
9137
9138 /**
9139 * @memberof async
9140 * @namespace createLogger
9141 */
9142 function createLogger(name) {
9143 return function(fn) {
9144 var args = slice(arguments, 1);
9145 args.push(done);
9146 fn.apply(null, args);
9147 };
9148
9149 function done(err) {
9150 if (typeof console === obj) {
9151 if (err) {
9152 if (console.error) {
9153 console.error(err);
9154 }
9155 return;
9156 }
9157 if (console[name]) {
9158 var args = slice(arguments, 1);
9159 arrayEachSync(args, function(arg) {
9160 console[name](arg);
9161 });
9162 }
9163 }
9164 }
9165 }
9166
9167 /**
9168 * @memberof async
9169 * @namespace safe
9170 */
9171 function safe() {
9172 createImmediate();
9173 return exports;
9174 }
9175
9176 /**
9177 * @memberof async
9178 * @namespace fast
9179 */
9180 function fast() {
9181 createImmediate(false);
9182 return exports;
9183 }
9184});
Note: See TracBrowser for help on using the repository browser.