@dereekb/util 10.0.19 → 10.0.21

package/index.cjs.js

@@ -1774,6 +1774,84 @@ var addToUnscopables = addToUnscopables$2;
 // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
 addToUnscopables('flat');
 
+var aCallable$6 = aCallable$a;
+var toObject$3 = toObject$7;
+var IndexedObject$1 = indexedObject;
+var lengthOfArrayLike$2 = lengthOfArrayLike$6;
+
+var $TypeError$9 = TypeError;
+
+// `Array.prototype.{ reduce, reduceRight }` methods implementation
+var createMethod$2 = function (IS_RIGHT) {
+  return function (that, callbackfn, argumentsLength, memo) {
+    var O = toObject$3(that);
+    var self = IndexedObject$1(O);
+    var length = lengthOfArrayLike$2(O);
+    aCallable$6(callbackfn);
+    var index = IS_RIGHT ? length - 1 : 0;
+    var i = IS_RIGHT ? -1 : 1;
+    if (argumentsLength < 2) while (true) {
+      if (index in self) {
+        memo = self[index];
+        index += i;
+        break;
+      }
+      index += i;
+      if (IS_RIGHT ? index < 0 : length <= index) {
+        throw new $TypeError$9('Reduce of empty array with no initial value');
+      }
+    }
+    for (;IS_RIGHT ? index >= 0 : length > index; index += i) if (index in self) {
+      memo = callbackfn(memo, self[index], index, O);
+    }
+    return memo;
+  };
+};
+
+var arrayReduce = {
+  // `Array.prototype.reduce` method
+  // https://tc39.es/ecma262/#sec-array.prototype.reduce
+  left: createMethod$2(false),
+  // `Array.prototype.reduceRight` method
+  // https://tc39.es/ecma262/#sec-array.prototype.reduceright
+  right: createMethod$2(true)
+};
+
+var fails$d = fails$p;
+
+var arrayMethodIsStrict$2 = function (METHOD_NAME, argument) {
+  var method = [][METHOD_NAME];
+  return !!method && fails$d(function () {
+    // eslint-disable-next-line no-useless-call -- required for testing
+    method.call(null, argument || function () { return 1; }, 1);
+  });
+};
+
+var global$c = global$o;
+var classof$4 = classofRaw$2;
+
+var engineIsNode = classof$4(global$c.process) === 'process';
+
+var $$f = _export;
+var $reduce = arrayReduce.left;
+var arrayMethodIsStrict$1 = arrayMethodIsStrict$2;
+var CHROME_VERSION = engineV8Version;
+var IS_NODE$4 = engineIsNode;
+
+// Chrome 80-82 has a critical bug
+// https://bugs.chromium.org/p/chromium/issues/detail?id=1049982
+var CHROME_BUG = !IS_NODE$4 && CHROME_VERSION > 79 && CHROME_VERSION < 83;
+var FORCED$2 = CHROME_BUG || !arrayMethodIsStrict$1('reduce');
+
+// `Array.prototype.reduce` method
+// https://tc39.es/ecma262/#sec-array.prototype.reduce
+$$f({ target: 'Array', proto: true, forced: FORCED$2 }, {
+  reduce: function reduce(callbackfn /* , initialValue */) {
+    var length = arguments.length;
+    return $reduce(this, callbackfn, length, length > 1 ? arguments[1] : undefined);
+  }
+});
+
 // MARK: Functions
 /**
  * Converts the input value to an array containing itself, or returns itself if it is an array.
@@ -1969,6 +2047,15 @@ function forEachWithArray(array, forEach) {
   }
   return array;
 }
+/**
+ * Counts all the values in a nested array.
+ *
+ * @param array
+ * @returns
+ */
+function countAllInNestedArray(array) {
+  return array.reduce((acc, curr) => acc + curr.length, 0);
+}
 // MARK: Compat
 /**
  * @deprecated Use mergeArraysIntoArray() instead. Will be removed in v10.1.
@@ -1983,12 +2070,12 @@ const mergeArrayIntoArray = pushArrayItemsIntoArray;
  */
 const mergeArrayOrValueIntoArray = pushItemOrArrayItemsIntoArray;
 
-var classof$4 = classof$6;
+var classof$3 = classof$6;
 
 var $String$1 = String;
 
 var toString$c = function (argument) {
-  if (classof$4(argument) === 'Symbol') throw new TypeError('Cannot convert a Symbol value to a string');
+  if (classof$3(argument) === 'Symbol') throw new TypeError('Cannot convert a Symbol value to a string');
   return $String$1(argument);
 };
 
@@ -2001,9 +2088,9 @@ var defineBuiltInAccessor$2 = function (target, name, descriptor) {
   return defineProperty$2.f(target, name, descriptor);
 };
 
-var $$f = _export;
+var $$e = _export;
 var DESCRIPTORS$4 = descriptors;
-var global$c = global$o;
+var global$b = global$o;
 var uncurryThis$f = functionUncurryThis;
 var hasOwn$3 = hasOwnProperty_1;
 var isCallable$7 = isCallable$n;
@@ -2012,7 +2099,7 @@ var toString$b = toString$c;
 var defineBuiltInAccessor$1 = defineBuiltInAccessor$2;
 var copyConstructorProperties = copyConstructorProperties$2;
 
-var NativeSymbol = global$c.Symbol;
+var NativeSymbol = global$b.Symbol;
 var SymbolPrototype = NativeSymbol && NativeSymbol.prototype;
 
 if (DESCRIPTORS$4 && isCallable$7(NativeSymbol) && (!('description' in SymbolPrototype) ||
@@ -2053,7 +2140,7 @@ if (DESCRIPTORS$4 && isCallable$7(NativeSymbol) && (!('description' in SymbolPro
     }
   });
 
-  $$f({ global: true, constructor: true, forced: true }, {
+  $$e({ global: true, constructor: true, forced: true }, {
     Symbol: SymbolWrapper
   });
 }
@@ -2658,12 +2745,12 @@ function setsAreEquivalent(a, b) {
 var DESCRIPTORS$3 = descriptors;
 var uncurryThis$e = functionUncurryThis;
 var call$e = functionCall;
-var fails$d = fails$p;
+var fails$c = fails$p;
 var objectKeys = objectKeys$2;
 var getOwnPropertySymbolsModule = objectGetOwnPropertySymbols;
 var propertyIsEnumerableModule = objectPropertyIsEnumerable;
-var toObject$3 = toObject$7;
-var IndexedObject$1 = indexedObject;
+var toObject$2 = toObject$7;
+var IndexedObject = indexedObject;
 
 // eslint-disable-next-line es/no-object-assign -- safe
 var $assign = Object.assign;
@@ -2673,7 +2760,7 @@ var concat$1 = uncurryThis$e([].concat);
 
 // `Object.assign` method
 // https://tc39.es/ecma262/#sec-object.assign
-var objectAssign = !$assign || fails$d(function () {
+var objectAssign = !$assign || fails$c(function () {
   // should have correct order of operations (Edge bug)
   if (DESCRIPTORS$3 && $assign({ b: 1 }, $assign(defineProperty$1({}, 'a', {
     enumerable: true,
@@ -2694,13 +2781,13 @@ var objectAssign = !$assign || fails$d(function () {
   alphabet.split('').forEach(function (chr) { B[chr] = chr; });
   return $assign({}, A)[symbol] !== 7 || objectKeys($assign({}, B)).join('') !== alphabet;
 }) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length`
-  var T = toObject$3(target);
+  var T = toObject$2(target);
   var argumentsLength = arguments.length;
   var index = 1;
   var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
   var propertyIsEnumerable = propertyIsEnumerableModule.f;
   while (argumentsLength > index) {
-    var S = IndexedObject$1(arguments[index++]);
+    var S = IndexedObject(arguments[index++]);
     var keys = getOwnPropertySymbols ? concat$1(objectKeys(S), getOwnPropertySymbols(S)) : objectKeys(S);
     var length = keys.length;
     var j = 0;
@@ -2712,13 +2799,13 @@ var objectAssign = !$assign || fails$d(function () {
   } return T;
 } : $assign;
 
-var $$e = _export;
+var $$d = _export;
 var assign = objectAssign;
 
 // `Object.assign` method
 // https://tc39.es/ecma262/#sec-object.assign
 // eslint-disable-next-line es/no-object-assign -- required for testing
-$$e({ target: 'Object', stat: true, arity: 2, forced: Object.assign !== assign }, {
+$$d({ target: 'Object', stat: true, arity: 2, forced: Object.assign !== assign }, {
   assign: assign
 });
 
@@ -3210,10 +3297,10 @@ const BooleanStringKeyArrayUtilityInstance = new BooleanKeyArrayUtilityInstance(
 
 var tryToString$3 = tryToString$5;
 
-var $TypeError$9 = TypeError;
+var $TypeError$8 = TypeError;
 
 var deletePropertyOrThrow$1 = function (O, P) {
-  if (!delete O[P]) throw new $TypeError$9('Cannot delete property ' + tryToString$3(P) + ' of ' + tryToString$3(O));
+  if (!delete O[P]) throw new $TypeError$8('Cannot delete property ' + tryToString$3(P) + ' of ' + tryToString$3(O));
 };
 
 var uncurryThis$d = functionUncurryThis;
@@ -3262,16 +3349,6 @@ var sort = function (array, comparefn) {
 
 var arraySort = sort;
 
-var fails$c = fails$p;
-
-var arrayMethodIsStrict$2 = function (METHOD_NAME, argument) {
-  var method = [][METHOD_NAME];
-  return !!method && fails$c(function () {
-    // eslint-disable-next-line no-useless-call -- required for testing
-    method.call(null, argument || function () { return 1; }, 1);
-  });
-};
-
 var userAgent$4 = engineUserAgent;
 
 var firefox = userAgent$4.match(/firefox\/(\d+)/i);
@@ -3288,16 +3365,16 @@ var webkit = userAgent$3.match(/AppleWebKit\/(\d+)\./);
 
 var engineWebkitVersion = !!webkit && +webkit[1];
 
-var $$d = _export;
+var $$c = _export;
 var uncurryThis$c = functionUncurryThis;
-var aCallable$6 = aCallable$a;
-var toObject$2 = toObject$7;
-var lengthOfArrayLike$2 = lengthOfArrayLike$6;
+var aCallable$5 = aCallable$a;
+var toObject$1 = toObject$7;
+var lengthOfArrayLike$1 = lengthOfArrayLike$6;
 var deletePropertyOrThrow = deletePropertyOrThrow$1;
 var toString$a = toString$c;
 var fails$b = fails$p;
 var internalSort = arraySort;
-var arrayMethodIsStrict$1 = arrayMethodIsStrict$2;
+var arrayMethodIsStrict = arrayMethodIsStrict$2;
 var FF = engineFfVersion;
 var IE_OR_EDGE = engineIsIeOrEdge;
 var V8 = engineV8Version;
@@ -3316,7 +3393,7 @@ var FAILS_ON_NULL = fails$b(function () {
   test$1.sort(null);
 });
 // Old WebKit
-var STRICT_METHOD = arrayMethodIsStrict$1('sort');
+var STRICT_METHOD = arrayMethodIsStrict('sort');
 
 var STABLE_SORT = !fails$b(function () {
   // feature detection can be too slow, so check engines versions
@@ -3353,7 +3430,7 @@ var STABLE_SORT = !fails$b(function () {
   return result !== 'DGBEFHACIJK';
 });
 
-var FORCED$2 = FAILS_ON_UNDEFINED || !FAILS_ON_NULL || !STRICT_METHOD || !STABLE_SORT;
+var FORCED$1 = FAILS_ON_UNDEFINED || !FAILS_ON_NULL || !STRICT_METHOD || !STABLE_SORT;
 
 var getSortCompare = function (comparefn) {
   return function (x, y) {
@@ -3366,16 +3443,16 @@ var getSortCompare = function (comparefn) {
 
 // `Array.prototype.sort` method
 // https://tc39.es/ecma262/#sec-array.prototype.sort
-$$d({ target: 'Array', proto: true, forced: FORCED$2 }, {
+$$c({ target: 'Array', proto: true, forced: FORCED$1 }, {
   sort: function sort(comparefn) {
-    if (comparefn !== undefined) aCallable$6(comparefn);
+    if (comparefn !== undefined) aCallable$5(comparefn);
 
-    var array = toObject$2(this);
+    var array = toObject$1(this);
 
     if (STABLE_SORT) return comparefn === undefined ? nativeSort(array) : nativeSort(array, comparefn);
 
     var items = [];
-    var arrayLength = lengthOfArrayLike$2(array);
+    var arrayLength = lengthOfArrayLike$1(array);
     var itemsLength, index;
 
     for (index = 0; index < arrayLength; index++) {
@@ -3384,7 +3461,7 @@ $$d({ target: 'Array', proto: true, forced: FORCED$2 }, {
 
     internalSort(items, getSortCompare(comparefn));
 
-    itemsLength = lengthOfArrayLike$2(items);
+    itemsLength = lengthOfArrayLike$1(items);
     index = 0;
 
     while (index < itemsLength) array[index] = items[index++];
@@ -4390,10 +4467,10 @@ function boundNumber(input, min, max) {
 }
 
 var fails$9 = fails$p;
-var global$b = global$o;
+var global$a = global$o;
 
 // babel-minify and Closure Compiler transpiles RegExp('a', 'y') -> /a/y and it causes SyntaxError
-var $RegExp$2 = global$b.RegExp;
+var $RegExp$2 = global$a.RegExp;
 
 var UNSUPPORTED_Y$3 = fails$9(function () {
   var re = $RegExp$2('a', 'y');
@@ -4421,10 +4498,10 @@ var regexpStickyHelpers = {
 };
 
 var fails$8 = fails$p;
-var global$a = global$o;
+var global$9 = global$o;
 
 // babel-minify and Closure Compiler transpiles RegExp('.', 's') -> /./s and it causes SyntaxError
-var $RegExp$1 = global$a.RegExp;
+var $RegExp$1 = global$9.RegExp;
 
 var regexpUnsupportedDotAll = fails$8(function () {
   var re = $RegExp$1('.', 's');
@@ -4432,10 +4509,10 @@ var regexpUnsupportedDotAll = fails$8(function () {
 });
 
 var fails$7 = fails$p;
-var global$9 = global$o;
+var global$8 = global$o;
 
 // babel-minify and Closure Compiler transpiles RegExp('(?<a>b)', 'g') -> /(?<a>b)/g and it causes SyntaxError
-var $RegExp = global$9.RegExp;
+var $RegExp = global$8.RegExp;
 
 var regexpUnsupportedNcg = fails$7(function () {
   var re = $RegExp('(?<a>b)', 'g');
@@ -4560,12 +4637,12 @@ if (PATCH) {
 
 var regexpExec$2 = patchedExec;
 
-var $$c = _export;
+var $$b = _export;
 var exec$1 = regexpExec$2;
 
 // `RegExp.prototype.exec` method
 // https://tc39.es/ecma262/#sec-regexp.prototype.exec
-$$c({ target: 'RegExp', proto: true, forced: /./.exec !== exec$1 }, {
+$$b({ target: 'RegExp', proto: true, forced: /./.exec !== exec$1 }, {
   exec: exec$1
 });
 
@@ -4592,7 +4669,7 @@ var stringRepeat = function repeat(count) {
   return result;
 };
 
-var $$b = _export;
+var $$a = _export;
 var uncurryThis$9 = functionUncurryThis;
 var toIntegerOrInfinity$2 = toIntegerOrInfinity$7;
 var thisNumberValue = thisNumberValue$1;
@@ -4654,7 +4731,7 @@ var dataToString = function (data) {
   } return s;
 };
 
-var FORCED$1 = fails$6(function () {
+var FORCED = fails$6(function () {
   return nativeToFixed(0.00008, 3) !== '0.000' ||
     nativeToFixed(0.9, 0) !== '1' ||
     nativeToFixed(1.255, 2) !== '1.25' ||
@@ -4666,7 +4743,7 @@ var FORCED$1 = fails$6(function () {
 
 // `Number.prototype.toFixed` method
 // https://tc39.es/ecma262/#sec-number.prototype.tofixed
-$$b({ target: 'Number', proto: true, forced: FORCED$1 }, {
+$$a({ target: 'Number', proto: true, forced: FORCED }, {
   toFixed: function toFixed(fractionDigits) {
     var number = thisNumberValue(this);
     var fractDigits = toIntegerOrInfinity$2(fractionDigits);
@@ -5054,74 +5131,6 @@ function transformNumberFunction(config) {
   return chainMapSameFunctions(transformFunctions);
 }
 
-var aCallable$5 = aCallable$a;
-var toObject$1 = toObject$7;
-var IndexedObject = indexedObject;
-var lengthOfArrayLike$1 = lengthOfArrayLike$6;
-
-var $TypeError$8 = TypeError;
-
-// `Array.prototype.{ reduce, reduceRight }` methods implementation
-var createMethod$2 = function (IS_RIGHT) {
-  return function (that, callbackfn, argumentsLength, memo) {
-    var O = toObject$1(that);
-    var self = IndexedObject(O);
-    var length = lengthOfArrayLike$1(O);
-    aCallable$5(callbackfn);
-    var index = IS_RIGHT ? length - 1 : 0;
-    var i = IS_RIGHT ? -1 : 1;
-    if (argumentsLength < 2) while (true) {
-      if (index in self) {
-        memo = self[index];
-        index += i;
-        break;
-      }
-      index += i;
-      if (IS_RIGHT ? index < 0 : length <= index) {
-        throw new $TypeError$8('Reduce of empty array with no initial value');
-      }
-    }
-    for (;IS_RIGHT ? index >= 0 : length > index; index += i) if (index in self) {
-      memo = callbackfn(memo, self[index], index, O);
-    }
-    return memo;
-  };
-};
-
-var arrayReduce = {
-  // `Array.prototype.reduce` method
-  // https://tc39.es/ecma262/#sec-array.prototype.reduce
-  left: createMethod$2(false),
-  // `Array.prototype.reduceRight` method
-  // https://tc39.es/ecma262/#sec-array.prototype.reduceright
-  right: createMethod$2(true)
-};
-
-var global$8 = global$o;
-var classof$3 = classofRaw$2;
-
-var engineIsNode = classof$3(global$8.process) === 'process';
-
-var $$a = _export;
-var $reduce = arrayReduce.left;
-var arrayMethodIsStrict = arrayMethodIsStrict$2;
-var CHROME_VERSION = engineV8Version;
-var IS_NODE$4 = engineIsNode;
-
-// Chrome 80-82 has a critical bug
-// https://bugs.chromium.org/p/chromium/issues/detail?id=1049982
-var CHROME_BUG = !IS_NODE$4 && CHROME_VERSION > 79 && CHROME_VERSION < 83;
-var FORCED = CHROME_BUG || !arrayMethodIsStrict('reduce');
-
-// `Array.prototype.reduce` method
-// https://tc39.es/ecma262/#sec-array.prototype.reduce
-$$a({ target: 'Array', proto: true, forced: FORCED }, {
-  reduce: function reduce(callbackfn /* , initialValue */) {
-    var length = arguments.length;
-    return $reduce(this, callbackfn, length, length > 1 ? arguments[1] : undefined);
-  }
-});
-
 function reduceNumbersWithMax(array, emptyArrayValue) {
   return reduceNumbersWithMaxFn(emptyArrayValue)(array);
 }
@@ -5813,6 +5822,22 @@ function arrayFactory(factory) {
 function arrayInputFactory(factory) {
   return input => makeWithFactoryInput(factory, input);
 }
+function terminatingFactoryFromArray(array, terminatingValue) {
+  if (arguments.length === 1) {
+    terminatingValue = null;
+  }
+  let index = 0;
+  return () => {
+    let result;
+    if (array.length > index) {
+      result = array[index];
+      index += 1;
+    } else {
+      result = terminatingValue;
+    }
+    return result;
+  };
+}
 
 // TODO: Remove from `core-js@4` since it's moved to entry points
 
@@ -10917,7 +10942,7 @@ function performTaskLoop(config) {
   return __awaiter(this, void 0, void 0, function* () {
     let result;
     const initValue = config.initValue;
-    const startLoop = initValue == null || config.checkContinue(initValue, -1);
+    const startLoop = initValue == null || (yield config.checkContinue(initValue, -1));
     if (startLoop) {
       let i = 0;
       let prevValue = initValue;
@@ -10925,7 +10950,7 @@ function performTaskLoop(config) {
       do {
         prevValue = yield config.next(i, prevValue);
         i += 1;
-        check = config.checkContinue(prevValue, i);
+        check = yield config.checkContinue(prevValue, i);
       } while (check);
       result = prevValue;
     } else {
@@ -12093,6 +12118,31 @@ function stringFactoryFromFactory(factory, toStringFunction) {
   return () => toStringFunction(factory());
 }
 
+/**
+ * Convenience function for calling Promise.resolve
+ *
+ * @param input
+ * @returns
+ */
+function asPromise(input) {
+  return Promise.resolve(input);
+}
+
+let PROMISE_REF_NUMBER = 0;
+/**
+ * Creates a new promise and returns the full ref for it.
+ */
+function promiseReference(executor) {
+  const ref = {};
+  ref.promise = new Promise((resolve, reject) => {
+    ref.resolve = resolve;
+    ref.reject = reject;
+    executor === null || executor === void 0 ? void 0 : executor(resolve, reject);
+  });
+  ref.number = PROMISE_REF_NUMBER += 1; // added for debugging
+  return ref;
+}
+
 /**
  * Runs the task using the input config, and returns the value. Is always configured to throw the error if it fails.
  */
@@ -12246,7 +12296,6 @@ function performTasksInParallel(input, config) {
  * @param config
  */
 function performTasksInParallelFunction(config) {
-  const defaultNonConcurrentTaskKeyFactory = stringFactoryFromFactory(incrementingNumberFactory(), x => x.toString());
   const {
     taskFactory,
     sequential,
@@ -12256,32 +12305,110 @@ function performTasksInParallelFunction(config) {
   } = config;
   const maxParallelTasks = inputMaxParallelTasks !== null && inputMaxParallelTasks !== void 0 ? inputMaxParallelTasks : sequential ? 1 : undefined;
   if (!maxParallelTasks && !nonConcurrentTaskKeyFactory) {
+    const defaultNonConcurrentTaskKeyFactory = stringFactoryFromFactory(incrementingNumberFactory(), x => x.toString());
     // if the max number of parallel tasks is not defined, then run all tasks at once, unless there is a nonConcurrentTaskKeyFactory
     return input => __awaiter(this, void 0, void 0, function* () {
       yield Promise.all(input.map((value, i) => taskFactory(value, i, defaultNonConcurrentTaskKeyFactory())));
     });
   } else {
-    return input => {
-      if (input.length === 0) {
-        return Promise.resolve();
+    const performTasks = performTasksFromFactoryInParallelFunction(config);
+    return input => __awaiter(this, void 0, void 0, function* () {
+      const taskInputFactory = terminatingFactoryFromArray([input],
+      // all in a single task array to run concurrently
+      null);
+      return performTasks(taskInputFactory);
+    });
+  }
+}
+/**
+ * Creates a function that performs tasks from the task factory in parallel.
+ *
+ * @param config
+ */
+function performTasksFromFactoryInParallelFunction(config) {
+  const defaultNonConcurrentTaskKeyFactory = stringFactoryFromFactory(incrementingNumberFactory(), x => x.toString());
+  const {
+    taskFactory,
+    sequential,
+    waitBetweenTaskInputRequests,
+    nonConcurrentTaskKeyFactory,
+    maxParallelTasks: inputMaxParallelTasks,
+    waitBetweenTasks
+  } = config;
+  const maxParallelTasks = inputMaxParallelTasks !== null && inputMaxParallelTasks !== void 0 ? inputMaxParallelTasks : sequential ? 1 : undefined;
+  const maxPromisesToRunAtOneTime = Math.max(1, maxParallelTasks !== null && maxParallelTasks !== void 0 ? maxParallelTasks : 1);
+  return taskInputFactory => {
+    return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+      const taskKeyFactory = nonConcurrentTaskKeyFactory !== null && nonConcurrentTaskKeyFactory !== void 0 ? nonConcurrentTaskKeyFactory : defaultNonConcurrentTaskKeyFactory;
+      let incompleteTasks = [];
+      let baseI = 0;
+      let isOutOfTasks = false;
+      let isFulfillingTask = false;
+      const requestTasksQueue = [];
+      function fulfillRequestMoreTasks(parallelIndex, promiseReference) {
+        return __awaiter(this, void 0, void 0, function* () {
+          if (incompleteTasks.length === 0) {
+            isFulfillingTask = true;
+            const newTasks = yield asPromise(taskInputFactory());
+            if (newTasks === null) {
+              isOutOfTasks = true;
+            } else {
+              const newTaskEntries = asArray(newTasks).map((x, i) => [x, asArray(taskKeyFactory(x)), baseI + i]).reverse(); // reverse to use push/pop
+              baseI += newTaskEntries.length;
+              incompleteTasks = [...newTaskEntries, ...incompleteTasks]; // new tasks go to the front of the stack
+            }
+          }
+
+          const nextTask = incompleteTasks.pop();
+          promiseReference.resolve(nextTask); // resolve that promise
+          isFulfillingTask = false;
+          // wait before popping off the next task in the queue, if applicable
+          if (waitBetweenTaskInputRequests) {
+            yield waitForMs(waitBetweenTaskInputRequests);
+          }
+          if (!isFulfillingTask && requestTasksQueue.length) {
+            const nextItemInQueue = requestTasksQueue.pop();
+            if (nextItemInQueue) {
+              fulfillRequestMoreTasks(nextItemInQueue[0], nextItemInQueue[1]);
+            }
+          }
+        });
       }
-      return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
-        const taskKeyFactory = nonConcurrentTaskKeyFactory !== null && nonConcurrentTaskKeyFactory !== void 0 ? nonConcurrentTaskKeyFactory : defaultNonConcurrentTaskKeyFactory;
-        const maxPromisesToRunAtOneTime = Math.min(maxParallelTasks !== null && maxParallelTasks !== void 0 ? maxParallelTasks : 100, input.length);
-        const incompleteTasks = input.map((x, i) => [x, asArray(taskKeyFactory(x)), i]).reverse(); // reverse to use push/pop
-        let currentRunIndex = 0;
-        let finishedParallels = 0;
-        let hasEncounteredFailure = false;
-        /**
-         * Set of tasks keys that are currently running.
-         */
-        const currentParellelTaskKeys = new Set();
-        const visitedTaskIndexes = new Set();
-        const waitingConcurrentTasks = multiValueMapBuilder();
-        function getNextTask() {
+      function requestMoreTasks(parallelIndex) {
+        return __awaiter(this, void 0, void 0, function* () {
+          if (isOutOfTasks) {
+            return;
+          } else {
+            const promiseRef = promiseReference();
+            if (isFulfillingTask) {
+              requestTasksQueue.push([parallelIndex, promiseRef]);
+              const waited = yield promiseRef.promise;
+              return waited;
+            } else {
+              fulfillRequestMoreTasks(parallelIndex, promiseRef);
+            }
+            return promiseRef.promise;
+          }
+        });
+      }
+      let currentRunIndex = 0;
+      let finishedParallels = 0;
+      let hasEncounteredFailure = false;
+      /**
+       * Set of tasks keys that are currently running.
+       */
+      const currentParellelTaskKeys = new Set();
+      const visitedTaskIndexes = new Set();
+      const waitingConcurrentTasks = multiValueMapBuilder();
+      function getNextTask(parallelIndex) {
+        return __awaiter(this, void 0, void 0, function* () {
           let nextTask = undefined;
           while (!nextTask) {
-            nextTask = incompleteTasks.pop();
+            // request more tasks if the tasks list is empty
+            if (!isOutOfTasks && incompleteTasks.length === 0) {
+              nextTask = yield requestMoreTasks(parallelIndex);
+            }
+            nextTask = nextTask !== null && nextTask !== void 0 ? nextTask : incompleteTasks.pop();
             if (nextTask != null) {
               const nextTaskTuple = nextTask;
               const nextTaskTupleIndex = nextTaskTuple[2];
@@ -12309,46 +12436,48 @@ function performTasksInParallelFunction(config) {
             visitedTaskIndexes.add(nextTask[2]);
           }
           return nextTask;
-        }
-        function onTaskCompleted(task) {
-          const keys = task[1];
-          const indexesPushed = new Set();
-          keys.forEach(key => {
-            // un-reserve the key from each parallel task
-            currentParellelTaskKeys.delete(key);
-            const waitingForKey = waitingConcurrentTasks.get(key);
-            while (true) {
-              const nextWaitingTask = waitingForKey.shift(); // take from the front to retain unique task order
-              if (nextWaitingTask) {
-                const nextWaitingTaskIndex = nextWaitingTask[2];
-                if (visitedTaskIndexes.has(nextWaitingTaskIndex) || indexesPushed.has(nextWaitingTaskIndex)) {
-                  // if the task has already been visited, then don't push back onto incomplete tasks.
-                  continue;
-                } else {
-                  // push to front for the next dispatch to take for this key
-                  incompleteTasks.push(nextWaitingTask);
-                  // mark to prevent pushing this one again since it will not get run
-                  indexesPushed.add(nextWaitingTaskIndex);
-                  break;
-                }
+        });
+      }
+      function onTaskCompleted(task, parallelIndex) {
+        const keys = task[1];
+        const indexesPushed = new Set();
+        keys.forEach(key => {
+          // un-reserve the key from each parallel task
+          currentParellelTaskKeys.delete(key);
+          const waitingForKey = waitingConcurrentTasks.get(key);
+          while (true) {
+            const nextWaitingTask = waitingForKey.shift(); // take from the front to retain unique task order
+            if (nextWaitingTask) {
+              const nextWaitingTaskIndex = nextWaitingTask[2];
+              if (visitedTaskIndexes.has(nextWaitingTaskIndex) || indexesPushed.has(nextWaitingTaskIndex)) {
+                // if the task has already been visited, then don't push back onto incomplete tasks.
+                continue;
               } else {
+                // push to front for the next dispatch to take for this key
+                incompleteTasks.push(nextWaitingTask);
+                // mark to prevent pushing this one again since it will not get run
+                indexesPushed.add(nextWaitingTaskIndex);
                 break;
               }
+            } else {
+              break;
             }
-          });
-        }
-        // start initial promises
-        function dispatchNextPromise() {
+          }
+        });
+      }
+      // start initial promises
+      function dispatchNextPromise(parallelIndex) {
+        return __awaiter(this, void 0, void 0, function* () {
           // if a failure has been encountered then the promise has already been rejected.
           if (!hasEncounteredFailure) {
-            const nextTask = getNextTask();
+            const nextTask = yield getNextTask(parallelIndex);
             if (nextTask) {
               // build/start promise
               const promise = taskFactory(nextTask[0], currentRunIndex, nextTask[1]);
               currentRunIndex += 1;
               promise.then(() => {
                 onTaskCompleted(nextTask);
-                setTimeout(dispatchNextPromise, waitBetweenTasks);
+                setTimeout(() => dispatchNextPromise(parallelIndex), waitBetweenTasks);
               }, e => {
                 hasEncounteredFailure = true;
                 reject(e);
@@ -12361,39 +12490,14 @@ function performTasksInParallelFunction(config) {
               }
             }
           }
-        }
-        // run the initial promises
-        range(0, maxPromisesToRunAtOneTime).forEach(() => {
-          dispatchNextPromise();
         });
-      }));
-    };
-  }
-}
-
-let PROMISE_REF_NUMBER = 0;
-/**
- * Creates a new promise and returns the full ref for it.
- */
-function promiseReference(executor) {
-  const ref = {};
-  ref.promise = new Promise((resolve, reject) => {
-    ref.resolve = resolve;
-    ref.reject = reject;
-    executor === null || executor === void 0 ? void 0 : executor(resolve, reject);
-  });
-  ref.number = PROMISE_REF_NUMBER += 1; // added for debugging
-  return ref;
-}
-
-/**
- * Convenience function for calling Promise.resolve
- *
- * @param input
- * @returns
- */
-function asPromise(input) {
-  return Promise.resolve(input);
+      }
+      // run the initial promises
+      range(0, maxPromisesToRunAtOneTime).forEach(parallelIndex => {
+        dispatchNextPromise(parallelIndex);
+      });
+    }));
+  };
 }
 
 /**
@@ -13903,6 +14007,7 @@ exports.copyLatLngBound = copyLatLngBound;
 exports.copyLatLngPoint = copyLatLngPoint;
 exports.copyObject = copyObject;
 exports.copySetAndDo = copySetAndDo;
+exports.countAllInNestedArray = countAllInNestedArray;
 exports.countPOJOKeys = countPOJOKeys;
 exports.countPOJOKeysFunction = countPOJOKeysFunction;
 exports.cronExpressionRepeatingEveryNMinutes = cronExpressionRepeatingEveryNMinutes;
@@ -14275,6 +14380,7 @@ exports.performBatchLoop = performBatchLoop;
 exports.performMakeLoop = performMakeLoop;
 exports.performTaskCountLoop = performTaskCountLoop;
 exports.performTaskLoop = performTaskLoop;
+exports.performTasksFromFactoryInParallelFunction = performTasksFromFactoryInParallelFunction;
 exports.performTasksInParallel = performTasksInParallel;
 exports.performTasksInParallelFunction = performTasksInParallelFunction;
 exports.pickOneRandomly = pickOneRandomly;
@@ -14434,6 +14540,7 @@ exports.takeLast = takeLast;
 exports.takeValuesFromIterable = takeValuesFromIterable;
 exports.telUrlString = telUrlString;
 exports.telUrlStringForE164PhoneNumberPair = telUrlStringForE164PhoneNumberPair;
+exports.terminatingFactoryFromArray = terminatingFactoryFromArray;
 exports.throwKeyIsRequired = throwKeyIsRequired;
 exports.toAbsoluteSlashPathStartType = toAbsoluteSlashPathStartType;
 exports.toCaseInsensitiveStringArray = toCaseInsensitiveStringArray;