@lowentry/utils 1.13.5 → 1.15.1

package/index.js

@@ -1,6 +1,7 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import _asyncToGenerator from '@babel/runtime/helpers/asyncToGenerator';
+import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
 import _typeof from '@babel/runtime/helpers/typeof';
 import '@babel/runtime/helpers/awaitAsyncGenerator';
 import _wrapAsyncGenerator from '@babel/runtime/helpers/wrapAsyncGenerator';
@@ -207,9 +208,12 @@ var FLOAT_LAX_ANY = function FLOAT_LAX_ANY() {
 
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
 
 /**
- * @param {LeUtils~TransactionalValue} transactionalValue
+ * @param {LeUtils_TransactionalValue} transactionalValue
  */
 var checkTransactionalValue = function checkTransactionalValue(transactionalValue) {
   if (!LeUtils.isTransactionalValueValid(transactionalValue)) {
@@ -220,7 +224,7 @@ var checkTransactionalValue = function checkTransactionalValue(transactionalValu
 };
 
 /**
- * @param {LeUtils~TransactionalValue} transactionalValue
+ * @param {LeUtils_TransactionalValue} transactionalValue
  * @param {string} changeId
  * @returns {{index:number, value:*}|null}
  */
@@ -268,7 +272,9 @@ var LeUtils = {
       };
     }
     if (document.readyState === 'interactive' || document.readyState === 'complete') {
-      return LeUtils.setTimeout(callback, 0);
+      return LeUtils.setTimeout(function () {
+        return callback();
+      }, 0);
     } else {
       var listening = true;
       var _callbackWrapper = function callbackWrapper() {
@@ -542,21 +548,16 @@ var LeUtils = {
     });
     return result;
   },
-  /**
-   * @callback LeUtils~__findIndexValueCallback
-   * @param {*} value
-   * @param {*} index
-   * @returns {boolean|undefined}
-   */
   /**
    * Finds the first element in the given array or object that returns true from the callback, and returns an object with the index and value.
    *
    * @param {*[]|object|Function} elements
-   * @param {LeUtils~__findIndexValueCallback} callback
+   * @param {(value:*, index:*) => boolean|void} callback
    * @param {boolean} [optionalSkipHasOwnPropertyCheck]
    * @returns {{index:*, value:*}|null}
    */
   findIndexValue: function findIndexValue(elements, callback) {
+    var optionalSkipHasOwnPropertyCheck = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
     var result = null;
     LeUtils.each(elements, function (value, index) {
       if (callback.call(elements[index], elements[index], index)) {
@@ -566,14 +567,14 @@ var LeUtils = {
         };
         return false;
       }
-    });
+    }, optionalSkipHasOwnPropertyCheck);
     return result;
   },
   /**
    * Finds the first element in the given array or object that returns true from the callback, and returns the index.
    *
    * @param {*[]|object|Function} elements
-   * @param {LeUtils~__findIndexValueCallback} callback
+   * @param {(value:*, index:*) => boolean|void} callback
    * @param {boolean} [optionalSkipHasOwnPropertyCheck]
    * @returns {*|null}
    */
@@ -586,7 +587,7 @@ var LeUtils = {
    * Finds the first element in the given array or object that returns true from the callback, and returns the value.
    *
    * @param {*[]|object|Function} elements
-   * @param {LeUtils~__findIndexValueCallback} callback
+   * @param {(value:*, index:*) => boolean|void} callback
    * @param {boolean} [optionalSkipHasOwnPropertyCheck]
    * @returns {*|null}
    */
@@ -596,246 +597,525 @@ var LeUtils = {
     return (_LeUtils$findIndexVal3 = (_LeUtils$findIndexVal4 = LeUtils.findIndexValue(elements, callback, optionalSkipHasOwnPropertyCheck)) === null || _LeUtils$findIndexVal4 === void 0 ? void 0 : _LeUtils$findIndexVal4.value) !== null && _LeUtils$findIndexVal3 !== void 0 ? _LeUtils$findIndexVal3 : null;
   },
   /**
-   * @callback LeUtils~__eachCallback
-   * @param {*} value
+   * Returns the value at the given index in the given elements.
+   *
+   * @param {*} elements
    * @param {*} index
-   * @returns {boolean|undefined}
+   * @param {boolean} [optionalSkipHasOwnPropertyCheck]
+   * @returns {*}
+   */
+  getValueAtIndex: function getValueAtIndex(elements, index) {
+    var optionalSkipHasOwnPropertyCheck = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    if (elements === null || typeof elements === 'undefined') {
+      return undefined;
+    }
+    if (Array.isArray(elements)) {
+      return elements[index];
+    }
+    if (_typeof(elements) === 'object' && (elements === null || elements === void 0 ? void 0 : elements.constructor) === Object) {
+      if (optionalSkipHasOwnPropertyCheck === true || Object.prototype.hasOwnProperty.call(elements, index)) {
+        return elements[index];
+      }
+      return undefined;
+    }
+    if (elements instanceof Map) {
+      return elements.get(index);
+    }
+    if (elements instanceof Set) {
+      return index;
+    }
+    if (ArrayBuffer.isView(elements) && !(elements instanceof DataView)) {
+      return elements[index];
+    }
+    if (typeof elements === 'string') {
+      return elements.charAt(index);
+    }
+    if (typeof (elements === null || elements === void 0 ? void 0 : elements[Symbol.iterator]) === 'function') {
+      var i = 0;
+      var _iterator = _createForOfIteratorHelper(elements),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var value = _step.value;
+          if (i === index) {
+            return value;
+          }
+          i++;
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      return undefined;
+    }
+    if (typeof (elements === null || elements === void 0 ? void 0 : elements.forEach) === 'function') {
+      var result = undefined;
+      var shouldContinue = true;
+      elements.forEach(function (value, i) {
+        if (shouldContinue) {
+          if (i === index) {
+            result = value;
+            shouldContinue = false;
+          }
+        }
+      });
+      return result;
+    }
+    if (_typeof(elements) === 'object' || typeof elements === 'function') {
+      if (optionalSkipHasOwnPropertyCheck === true || Object.prototype.hasOwnProperty.call(elements, index)) {
+        return elements[index];
+      }
+      return undefined;
+    }
+    return undefined;
+  },
+  /**
+   * Checks if the given elements can be iterated over using LeUtils.each().
+   *
+   * @param {*} elements
+   * @returns {boolean}
    */
+  supportsEach: function supportsEach(elements) {
+    if (elements === null || typeof elements === 'undefined') {
+      return false;
+    }
+    return !!(Array.isArray(elements) || _typeof(elements) === 'object' && (elements === null || elements === void 0 ? void 0 : elements.constructor) === Object || typeof elements === 'string' || typeof (elements === null || elements === void 0 ? void 0 : elements[Symbol.iterator]) === 'function' || typeof (elements === null || elements === void 0 ? void 0 : elements.forEach) === 'function' || _typeof(elements) === 'object' || typeof elements === 'function');
+  },
   /**
-   * Loops through each element in the given array or object, and calls the callback for each element.
+   * Returns an iterator that iterates over each element in the given array or object, yielding an array with the value and the index/key.
    *
-   * @param {*[]|object|Function} elements
-   * @param {LeUtils~__eachCallback} callback
+   * @param {*} elements
    * @param {boolean} [optionalSkipHasOwnPropertyCheck]
-   * @returns {*[]|object|Function}
+   * @returns {Generator<*, void, *>}
    */
-  each: function each(elements, callback) {
-    var optionalSkipHasOwnPropertyCheck = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-    if (elements !== null && typeof elements !== 'undefined') {
-      if (Array.isArray(elements)) {
-        for (var index = 0; index < elements.length; index++) {
-          if (callback.call(elements[index], elements[index], index) === false) {
+  eachIterator: function eachIterator(elements) {
+    var optionalSkipHasOwnPropertyCheck = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    return /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+      var i, _i, _iterator2, _step2, _step2$value, _i2, value, _iterator3, _step3, _value, _i3, _i4, _iterator4, _step4, _value2, buffer, _i5, _buffer, entry, _i6, _t, _t2, _t3, _t4, _t5, _t6, _t7;
+      return _regeneratorRuntime.wrap(function (_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            if (!(elements === null || typeof elements === 'undefined')) {
+              _context.next = 1;
+              break;
+            }
+            return _context.abrupt("return");
+          case 1:
+            if (!Array.isArray(elements)) {
+              _context.next = 5;
+              break;
+            }
+            i = 0;
+          case 2:
+            if (!(i < elements.length)) {
+              _context.next = 4;
+              break;
+            }
+            _context.next = 3;
+            return [elements[i], i];
+          case 3:
+            i++;
+            _context.next = 2;
             break;
-          }
-        }
-      } else if (_typeof(elements) === 'object' || typeof elements === 'function') {
-        for (var _index in elements) {
-          if (optionalSkipHasOwnPropertyCheck === true || Object.prototype.hasOwnProperty.call(elements, _index)) {
-            if (callback.call(elements[_index], elements[_index], _index) === false) {
+          case 4:
+            return _context.abrupt("return");
+          case 5:
+            if (!(_typeof(elements) === 'object' && (elements === null || elements === void 0 ? void 0 : elements.constructor) === Object)) {
+              _context.next = 9;
               break;
             }
-          }
+            _t = _regeneratorRuntime.keys(elements);
+          case 6:
+            if ((_t2 = _t()).done) {
+              _context.next = 8;
+              break;
+            }
+            _i = _t2.value;
+            if (!(optionalSkipHasOwnPropertyCheck === true || Object.prototype.hasOwnProperty.call(elements, _i))) {
+              _context.next = 7;
+              break;
+            }
+            _context.next = 7;
+            return [elements[_i], _i];
+          case 7:
+            _context.next = 6;
+            break;
+          case 8:
+            return _context.abrupt("return");
+          case 9:
+            if (!(elements instanceof Map)) {
+              _context.next = 17;
+              break;
+            }
+            _iterator2 = _createForOfIteratorHelper(elements);
+            _context.prev = 10;
+            _iterator2.s();
+          case 11:
+            if ((_step2 = _iterator2.n()).done) {
+              _context.next = 13;
+              break;
+            }
+            _step2$value = _slicedToArray(_step2.value, 2), _i2 = _step2$value[0], value = _step2$value[1];
+            _context.next = 12;
+            return [value, _i2];
+          case 12:
+            _context.next = 11;
+            break;
+          case 13:
+            _context.next = 15;
+            break;
+          case 14:
+            _context.prev = 14;
+            _t3 = _context["catch"](10);
+            _iterator2.e(_t3);
+          case 15:
+            _context.prev = 15;
+            _iterator2.f();
+            return _context.finish(15);
+          case 16:
+            return _context.abrupt("return");
+          case 17:
+            if (!(elements instanceof Set)) {
+              _context.next = 25;
+              break;
+            }
+            _iterator3 = _createForOfIteratorHelper(elements);
+            _context.prev = 18;
+            _iterator3.s();
+          case 19:
+            if ((_step3 = _iterator3.n()).done) {
+              _context.next = 21;
+              break;
+            }
+            _value = _step3.value;
+            _context.next = 20;
+            return [_value, _value];
+          case 20:
+            _context.next = 19;
+            break;
+          case 21:
+            _context.next = 23;
+            break;
+          case 22:
+            _context.prev = 22;
+            _t4 = _context["catch"](18);
+            _iterator3.e(_t4);
+          case 23:
+            _context.prev = 23;
+            _iterator3.f();
+            return _context.finish(23);
+          case 24:
+            return _context.abrupt("return");
+          case 25:
+            if (!(typeof elements === 'string')) {
+              _context.next = 29;
+              break;
+            }
+            _i3 = 0;
+          case 26:
+            if (!(_i3 < elements.length)) {
+              _context.next = 28;
+              break;
+            }
+            _context.next = 27;
+            return [elements.charAt(_i3), _i3];
+          case 27:
+            _i3++;
+            _context.next = 26;
+            break;
+          case 28:
+            return _context.abrupt("return");
+          case 29:
+            if (!(typeof (elements === null || elements === void 0 ? void 0 : elements[Symbol.iterator]) === 'function')) {
+              _context.next = 38;
+              break;
+            }
+            _i4 = 0;
+            _iterator4 = _createForOfIteratorHelper(elements);
+            _context.prev = 30;
+            _iterator4.s();
+          case 31:
+            if ((_step4 = _iterator4.n()).done) {
+              _context.next = 34;
+              break;
+            }
+            _value2 = _step4.value;
+            _context.next = 32;
+            return [_value2, _i4];
+          case 32:
+            _i4++;
+          case 33:
+            _context.next = 31;
+            break;
+          case 34:
+            _context.next = 36;
+            break;
+          case 35:
+            _context.prev = 35;
+            _t5 = _context["catch"](30);
+            _iterator4.e(_t5);
+          case 36:
+            _context.prev = 36;
+            _iterator4.f();
+            return _context.finish(36);
+          case 37:
+            return _context.abrupt("return");
+          case 38:
+            if (!(typeof (elements === null || elements === void 0 ? void 0 : elements.forEach) === 'function')) {
+              _context.next = 42;
+              break;
+            }
+            buffer = [];
+            elements.forEach(function (value, i) {
+              buffer.push([value, i]);
+            });
+            _i5 = 0, _buffer = buffer;
+          case 39:
+            if (!(_i5 < _buffer.length)) {
+              _context.next = 41;
+              break;
+            }
+            entry = _buffer[_i5];
+            _context.next = 40;
+            return entry;
+          case 40:
+            _i5++;
+            _context.next = 39;
+            break;
+          case 41:
+            return _context.abrupt("return");
+          case 42:
+            if (!(_typeof(elements) === 'object' || typeof elements === 'function')) {
+              _context.next = 46;
+              break;
+            }
+            _t6 = _regeneratorRuntime.keys(elements);
+          case 43:
+            if ((_t7 = _t6()).done) {
+              _context.next = 45;
+              break;
+            }
+            _i6 = _t7.value;
+            if (!(optionalSkipHasOwnPropertyCheck === true || Object.prototype.hasOwnProperty.call(elements, _i6))) {
+              _context.next = 44;
+              break;
+            }
+            _context.next = 44;
+            return [elements[_i6], _i6];
+          case 44:
+            _context.next = 43;
+            break;
+          case 45:
+            return _context.abrupt("return");
+          case 46:
+            console.warn('Executed LeUtils.eachIterator() on an invalid type: [' + _typeof(elements) + ']', elements);
+          case 47:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, null, [[10, 14, 15, 16], [18, 22, 23, 24], [30, 35, 36, 37]]);
+    })();
+  },
+  /**
+   * Loops through each element in the given array or object, and calls the callback for each element.
+   *
+   * @param {*} elements
+   * @param {(value:*, index?:*) => boolean|void} callback
+   * @param {boolean} [optionalSkipHasOwnPropertyCheck]
+   * @returns {*}
+   */
+  each: function each(elements, callback) {
+    var optionalSkipHasOwnPropertyCheck = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    var _iterator5 = _createForOfIteratorHelper(LeUtils.eachIterator(elements, optionalSkipHasOwnPropertyCheck)),
+      _step5;
+    try {
+      for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+        var _step5$value = _slicedToArray(_step5.value, 2),
+          value = _step5$value[0],
+          key = _step5$value[1];
+        if (callback.call(value, value, key) === false) {
+          break;
         }
-      } else {
-        console.warn('Executed LeUtils.each() on an invalid type: [' + _typeof(elements) + ']', elements);
       }
+    } catch (err) {
+      _iterator5.e(err);
+    } finally {
+      _iterator5.f();
     }
     return elements;
   },
   /**
    * Like LeUtils.each(), except that it expects an async callback.
    *
-   * @param {*[]|object|function} elements
-   * @param {LeUtils~__eachCallback} asyncCallback
+   * @param {*} elements
+   * @param {(value:*, index?:*) => Promise<boolean|undefined>} asyncCallback
    * @param {number} [optionalParallelCount]
    * @param {boolean} [optionalSkipHasOwnPropertyCheck]
-   * @returns {*[]|object|function}
+   * @returns {Promise<*>}
    */
   eachAsync: function () {
+    /**
+     * Instead of waiting for every promise individually, this function will queue up multiple promises at once, then wait for any of them to finish, before adding more, until it has looped through all elements.
+     * Then, at the end, it will wait for the remaining promises to finish.
+     */
     var eachAsyncParallel = /*#__PURE__*/function () {
-      var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3(elements, asyncCallback, optionalParallelCount, optionalSkipHasOwnPropertyCheck) {
-        var promises, doBreak;
-        return _regeneratorRuntime.wrap(function _callee3$(_context4) {
+      var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4(elements, asyncCallback, optionalParallelCount, optionalSkipHasOwnPropertyCheck) {
+        var runningPromises, doBreak;
+        return _regeneratorRuntime.wrap(function (_context4) {
           while (1) switch (_context4.prev = _context4.next) {
             case 0:
-              promises = [];
+              runningPromises = new Set();
               doBreak = false;
-              _context4.next = 4;
+              _context4.next = 1;
               return LeUtils.eachAsync(elements, /*#__PURE__*/function () {
-                var _ref3 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2(element, index) {
-                  var _loop, promise;
-                  return _regeneratorRuntime.wrap(function _callee2$(_context3) {
+                var _ref3 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3(value, index) {
+                  var promise;
+                  return _regeneratorRuntime.wrap(function (_context3) {
                     while (1) switch (_context3.prev = _context3.next) {
                       case 0:
-                        _loop = /*#__PURE__*/_regeneratorRuntime.mark(function _loop() {
-                          var newPromises;
-                          return _regeneratorRuntime.wrap(function _loop$(_context2) {
-                            while (1) switch (_context2.prev = _context2.next) {
-                              case 0:
-                                newPromises = [];
-                                LeUtils.each(promises, function (promise) {
-                                  if (!promise.__lowentry_utils__promise_is_done__) {
-                                    newPromises.push(promise);
-                                  }
-                                });
-                                promises = newPromises;
-                                if (!(promises.length > optionalParallelCount)) {
-                                  _context2.next = 6;
-                                  break;
-                                }
-                                _context2.next = 6;
-                                return Promise.any(promises);
-                              case 6:
-                              case "end":
-                                return _context2.stop();
-                            }
-                          }, _loop);
-                        });
+                        if (!doBreak) {
+                          _context3.next = 1;
+                          break;
+                        }
+                        return _context3.abrupt("return", false);
                       case 1:
-                        if (!(promises.length > optionalParallelCount)) {
-                          _context3.next = 5;
+                        if (!(runningPromises.size >= optionalParallelCount)) {
+                          _context3.next = 4;
                           break;
                         }
-                        return _context3.delegateYield(_loop(), "t0", 3);
-                      case 3:
-                        _context3.next = 1;
-                        break;
-                      case 5:
+                        _context3.next = 2;
+                        return Promise.race(runningPromises);
+                      case 2:
                         if (!doBreak) {
-                          _context3.next = 7;
+                          _context3.next = 3;
                           break;
                         }
                         return _context3.abrupt("return", false);
-                      case 7:
-                        promise = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
-                          return _regeneratorRuntime.wrap(function _callee$(_context) {
-                            while (1) switch (_context.prev = _context.next) {
+                      case 3:
+                        _context3.next = 1;
+                        break;
+                      case 4:
+                        // process this element, by creating a promise, and adding it to the queue
+                        promise = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
+                          var _t8;
+                          return _regeneratorRuntime.wrap(function (_context2) {
+                            while (1) switch (_context2.prev = _context2.next) {
                               case 0:
-                                _context.next = 2;
-                                return asyncCallback.call(element, element, index);
-                              case 2:
-                                _context.t0 = _context.sent;
-                                if (!(_context.t0 === false)) {
-                                  _context.next = 5;
+                                _context2.next = 1;
+                                return asyncCallback.call(value, value, index);
+                              case 1:
+                                _t8 = _context2.sent;
+                                if (!(_t8 === false)) {
+                                  _context2.next = 2;
                                   break;
                                 }
                                 doBreak = true;
-                              case 5:
-                                promise.__lowentry_utils__promise_is_done__ = true;
-                              case 6:
+                              case 2:
                               case "end":
-                                return _context.stop();
+                                return _context2.stop();
                             }
-                          }, _callee);
+                          }, _callee2);
                         }))();
-                        promises.push(promise);
-                      case 9:
+                        runningPromises.add(promise);
+                        promise["finally"](function () {
+                          runningPromises["delete"](promise);
+                        });
+                      case 5:
                       case "end":
                         return _context3.stop();
                     }
-                  }, _callee2);
+                  }, _callee3);
                 }));
                 return function (_x5, _x6) {
                   return _ref3.apply(this, arguments);
                 };
-              }(), optionalSkipHasOwnPropertyCheck);
-            case 4:
-              _context4.next = 6;
-              return Promise.all(promises);
-            case 6:
+              }(), 1, optionalSkipHasOwnPropertyCheck);
+            case 1:
+              _context4.next = 2;
+              return Promise.all(runningPromises);
+            case 2:
               return _context4.abrupt("return", elements);
-            case 7:
+            case 3:
             case "end":
               return _context4.stop();
           }
-        }, _callee3);
+        }, _callee4);
       }));
       return function eachAsyncParallel(_x, _x2, _x3, _x4) {
         return _ref2.apply(this, arguments);
       };
     }();
     return /*#__PURE__*/function () {
-      var _ref5 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4(elements, asyncCallback) {
+      var _ref5 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee5(elements, asyncCallback) {
         var parallelCount,
           optionalSkipHasOwnPropertyCheck,
-          index,
-          _index2,
-          _args5 = arguments;
-        return _regeneratorRuntime.wrap(function _callee4$(_context5) {
+          _iterator6,
+          _step6,
+          _step6$value,
+          value,
+          key,
+          _args5 = arguments,
+          _t9,
+          _t0;
+        return _regeneratorRuntime.wrap(function (_context5) {
           while (1) switch (_context5.prev = _context5.next) {
             case 0:
               parallelCount = _args5.length > 2 && _args5[2] !== undefined ? _args5[2] : 1;
               optionalSkipHasOwnPropertyCheck = _args5.length > 3 && _args5[3] !== undefined ? _args5[3] : false;
               if (!(elements !== null && typeof elements !== 'undefined')) {
-                _context5.next = 36;
+                _context5.next = 10;
                 break;
               }
               parallelCount = INT_LAX(parallelCount);
               if (!(parallelCount > 1)) {
-                _context5.next = 8;
+                _context5.next = 2;
                 break;
               }
-              _context5.next = 7;
+              _context5.next = 1;
               return eachAsyncParallel(elements, asyncCallback, parallelCount, optionalSkipHasOwnPropertyCheck);
-            case 7:
+            case 1:
               return _context5.abrupt("return", _context5.sent);
-            case 8:
-              if (!Array.isArray(elements)) {
-                _context5.next = 21;
-                break;
-              }
-              index = 0;
-            case 10:
-              if (!(index < elements.length)) {
-                _context5.next = 19;
-                break;
-              }
-              _context5.next = 13;
-              return asyncCallback.call(elements[index], elements[index], index);
-            case 13:
-              _context5.t0 = _context5.sent;
-              if (!(_context5.t0 === false)) {
-                _context5.next = 16;
-                break;
-              }
-              return _context5.abrupt("break", 19);
-            case 16:
-              index++;
-              _context5.next = 10;
-              break;
-            case 19:
-              _context5.next = 36;
-              break;
-            case 21:
-              if (!(_typeof(elements) === 'object' || typeof elements === 'function')) {
-                _context5.next = 35;
-                break;
-              }
-              _context5.t1 = _regeneratorRuntime.keys(elements);
-            case 23:
-              if ((_context5.t2 = _context5.t1()).done) {
-                _context5.next = 33;
-                break;
-              }
-              _index2 = _context5.t2.value;
-              if (!(optionalSkipHasOwnPropertyCheck === true || Object.prototype.hasOwnProperty.call(elements, _index2))) {
-                _context5.next = 31;
+            case 2:
+              _iterator6 = _createForOfIteratorHelper(LeUtils.eachIterator(elements, optionalSkipHasOwnPropertyCheck));
+              _context5.prev = 3;
+              _iterator6.s();
+            case 4:
+              if ((_step6 = _iterator6.n()).done) {
+                _context5.next = 7;
                 break;
               }
-              _context5.next = 28;
-              return asyncCallback.call(elements[_index2], elements[_index2], _index2);
-            case 28:
-              _context5.t3 = _context5.sent;
-              if (!(_context5.t3 === false)) {
-                _context5.next = 31;
+              _step6$value = _slicedToArray(_step6.value, 2), value = _step6$value[0], key = _step6$value[1];
+              _context5.next = 5;
+              return asyncCallback.call(value, value, key);
+            case 5:
+              _t9 = _context5.sent;
+              if (!(_t9 === false)) {
+                _context5.next = 6;
                 break;
               }
-              return _context5.abrupt("break", 33);
-            case 31:
-              _context5.next = 23;
+              return _context5.abrupt("continue", 7);
+            case 6:
+              _context5.next = 4;
               break;
-            case 33:
-              _context5.next = 36;
+            case 7:
+              _context5.next = 9;
               break;
-            case 35:
-              console.warn('Executed LeUtils.eachAsync() on an invalid type: [' + _typeof(elements) + ']', elements);
-            case 36:
+            case 8:
+              _context5.prev = 8;
+              _t0 = _context5["catch"](3);
+              _iterator6.e(_t0);
+            case 9:
+              _context5.prev = 9;
+              _iterator6.f();
+              return _context5.finish(9);
+            case 10:
               return _context5.abrupt("return", elements);
-            case 37:
+            case 11:
             case "end":
               return _context5.stop();
           }
-        }, _callee4);
+        }, _callee5, null, [[3, 8, 9, 10]]);
       }));
       return function (_x7, _x8) {
         return _ref5.apply(this, arguments);
@@ -843,146 +1123,137 @@ var LeUtils = {
     }();
   }(),
   /**
-   * @callback LeUtils~__filterCallback
-   * @param {*} value
-   * @param {*} index
-   * @returns {boolean|undefined}
+   * Returns an empty simplified collection (array, object, or Map), based on the given elements.
+   *
+   * Usage:
+   *
+   * ```js
+   * const [success, collection, add] = LeUtils.getEmptySimplifiedCollection(elements);
+   * ```
+   *
+   * @param {*} elements
+   * @returns {[boolean, *[]|object|Map, (value:*,index:*)=>void]}
    */
+  getEmptySimplifiedCollection: function getEmptySimplifiedCollection(elements) {
+    if (elements === null || typeof elements === 'undefined') {
+      return [false, [], function (value, index) {}];
+    }
+    var collection = null;
+    var add = null;
+    if (Array.isArray(elements)) {
+      collection = [];
+      add = function add(value, index) {
+        collection.push(value);
+      };
+    } else if (_typeof(elements) === 'object' && (elements === null || elements === void 0 ? void 0 : elements.constructor) === Object) {
+      collection = {};
+      add = function add(value, index) {
+        collection[index] = value;
+      };
+    } else if (elements instanceof Map) {
+      collection = new Map();
+      add = function add(value, index) {
+        collection.set(index, value);
+      };
+    } else if (typeof elements === 'string' || typeof (elements === null || elements === void 0 ? void 0 : elements[Symbol.iterator]) === 'function' || typeof (elements === null || elements === void 0 ? void 0 : elements.forEach) === 'function') {
+      collection = [];
+      add = function add(value, index) {
+        collection.push(value);
+      };
+    } else if (_typeof(elements) === 'object' || typeof elements === 'function') {
+      collection = {};
+      add = function add(value, index) {
+        collection[index] = value;
+      };
+    } else {
+      console.warn('Executed LeUtils.getEmptySimplifiedCollection() on an invalid type: [' + _typeof(elements) + ']', elements);
+      return [false, [], function (value, index) {}];
+    }
+    return [true, collection, add];
+  },
   /**
-   * Loops through the given elements, and returns a new array or object, with only the elements that returned true (or a value equals to true) from the callback.
+   * Loops through the given elements, and returns a new collection, with only the elements that returned true (or a value equals to true) from the callback.
    * If no callback is given, it will return all elements that are of a true value (for example, values that are: not null, not undefined, not false, not 0, not an empty string, not an empty array, not an empty object).
    *
-   * @param {*[]|object|Function} elements
-   * @param {LeUtils~__filterCallback} [callback]
+   * @param {*} elements
+   * @param {(value:*, index:*) => boolean|undefined} [callback]
    * @param {boolean} [optionalSkipHasOwnPropertyCheck]
-   * @returns {*[]|object|Function}
+   * @returns {*}
    */
   filter: function filter(elements, callback) {
     var optionalSkipHasOwnPropertyCheck = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-    if (elements !== null && typeof elements !== 'undefined') {
-      if (Array.isArray(elements)) {
-        var result = [];
-        for (var index = 0; index < elements.length; index++) {
-          if (!callback && elements[index] || callback && callback.call(elements[index], elements[index], index)) {
-            result.push(elements[index]);
-          }
-        }
-        return result;
-      } else if (_typeof(elements) === 'object' || typeof elements === 'function') {
-        var _result = {};
-        for (var _index3 in elements) {
-          if (optionalSkipHasOwnPropertyCheck === true || Object.prototype.hasOwnProperty.call(elements, _index3)) {
-            if (!callback && elements[_index3] || callback && callback.call(elements[_index3], elements[_index3], _index3)) {
-              _result[_index3] = elements[_index3];
-            }
-          }
+    var _LeUtils$getEmptySimp = LeUtils.getEmptySimplifiedCollection(elements),
+      _LeUtils$getEmptySimp2 = _slicedToArray(_LeUtils$getEmptySimp, 3),
+      success = _LeUtils$getEmptySimp2[0],
+      collection = _LeUtils$getEmptySimp2[1],
+      add = _LeUtils$getEmptySimp2[2];
+    if (!success) {
+      return elements;
+    }
+    LeUtils.each(elements, function (value, index) {
+      if (!callback) {
+        if (value) {
+          add(value, index);
         }
-        return _result;
-      } else {
-        console.warn('Executed LeUtils.filter() on an invalid type: [' + _typeof(elements) + ']', elements);
+      } else if (callback.call(value, value, index)) {
+        add(value, index);
       }
-    }
-    return elements;
+    }, optionalSkipHasOwnPropertyCheck);
+    return collection;
   },
   /**
-   * @callback LeUtils~__mapCallback
-   * @param {*} value
-   * @param {*} index
-   * @returns {*}
-   */
-  /**
-   * Loops through the given elements, and returns a new array or object, with the elements that were returned from the callback.
+   * Loops through the given elements, and returns a new collection, with the elements that were returned from the callback.
    *
-   * @param {*[]|object|Function} elements
-   * @param {LeUtils~__mapCallback} [callback]
+   * @param {*} elements
+   * @param {(value:*, index:*) => *} [callback]
    * @param {boolean} [optionalSkipHasOwnPropertyCheck]
-   * @returns {*[]|object|Function}
+   * @returns {*}
    */
   map: function map(elements, callback) {
     var optionalSkipHasOwnPropertyCheck = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-    if (elements !== null && typeof elements !== 'undefined') {
-      if (Array.isArray(elements)) {
-        var result = [];
-        for (var index = 0; index < elements.length; index++) {
-          if (!callback) {
-            result[index] = elements[index];
-          } else {
-            result[index] = callback.call(elements[index], elements[index], index);
-          }
-        }
-        return result;
-      } else if (_typeof(elements) === 'object' || typeof elements === 'function') {
-        var _result2 = {};
-        for (var _index4 in elements) {
-          if (optionalSkipHasOwnPropertyCheck === true || Object.prototype.hasOwnProperty.call(elements, _index4)) {
-            if (!callback) {
-              _result2[_index4] = elements[_index4];
-            } else {
-              _result2[_index4] = callback.call(elements[_index4], elements[_index4], _index4);
-            }
-          }
-        }
-        return _result2;
+    var _LeUtils$getEmptySimp3 = LeUtils.getEmptySimplifiedCollection(elements),
+      _LeUtils$getEmptySimp4 = _slicedToArray(_LeUtils$getEmptySimp3, 3),
+      success = _LeUtils$getEmptySimp4[0],
+      collection = _LeUtils$getEmptySimp4[1],
+      add = _LeUtils$getEmptySimp4[2];
+    if (!success) {
+      return elements;
+    }
+    LeUtils.each(elements, function (value, index) {
+      if (!callback) {
+        add(value, index);
       } else {
-        console.warn('Executed LeUtils.map() on an invalid type: [' + _typeof(elements) + ']', elements);
+        add(callback.call(value, value, index), index);
       }
-    }
-    return elements;
+    }, optionalSkipHasOwnPropertyCheck);
+    return collection;
   },
-  /**
-   * @callback LeUtils~__mapToArrayCallback
-   * @param {*} value
-   * @param {*} index
-   * @returns {*}
-   */
   /**
    * Loops through the given elements, and returns a new array, with the elements that were returned from the callback. Always returns an array.
    *
-   * @param {*[]|object|Function} elements
-   * @param {LeUtils~__mapToArrayCallback} [callback]
+   * @param {*} elements
+   * @param {(value:*, index:*) => *} [callback]
    * @param {boolean} [optionalSkipHasOwnPropertyCheck]
    * @returns {*[]}
    */
   mapToArray: function mapToArray(elements, callback) {
     var optionalSkipHasOwnPropertyCheck = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
     var result = [];
-    if (elements !== null && typeof elements !== 'undefined') {
-      if (Array.isArray(elements)) {
-        for (var index = 0; index < elements.length; index++) {
-          if (!callback) {
-            result.push(elements[index]);
-          } else {
-            result.push(callback.call(elements[index], elements[index], index));
-          }
-        }
-      } else if (_typeof(elements) === 'object' || typeof elements === 'function') {
-        for (var _index5 in elements) {
-          if (optionalSkipHasOwnPropertyCheck === true || Object.prototype.hasOwnProperty.call(elements, _index5)) {
-            if (!callback) {
-              result.push(elements[_index5]);
-            } else {
-              result.push(callback.call(elements[_index5], elements[_index5], _index5));
-            }
-          }
-        }
+    LeUtils.each(elements, function (value, index) {
+      if (!callback) {
+        result.push(value);
       } else {
-        console.warn('Executed LeUtils.mapToArray() on an invalid type: [' + _typeof(elements) + ']', elements);
+        result.push(callback.call(value, value, index));
       }
-    }
+    }, optionalSkipHasOwnPropertyCheck);
     return result;
   },
-  /**
-   * @callback LeUtils~__mapToArraySortedCallback
-   * @param {*} value
-   * @param {*} index
-   * @returns {*}
-   */
   /**
    * Loops through the given elements, and returns a new array, with the elements that were returned from the callback. The elements will be sorted by the result from the given comparator. Always returns an array.
    *
-   * @param {*[]|object|Function} elements
-   * @param {LeUtils~__sortKeysComparatorCallback} comparator
-   * @param {LeUtils~__mapToArraySortedCallback} [callback]
+   * @param {*} elements
+   * @param {(valueA:*, valueB:*) => number} comparator
+   * @param {(value:*, index:*) => *} [callback]
    * @param {boolean} [optionalSkipHasOwnPropertyCheck]
    * @returns {*[]}
    */
@@ -990,49 +1261,41 @@ var LeUtils = {
     var optionalSkipHasOwnPropertyCheck = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
     var keys = LeUtils.sortKeys(elements, comparator, optionalSkipHasOwnPropertyCheck);
     var result = [];
-    for (var i = 0; i < keys.length; i++) {
-      if (!callback) {
-        result.push(elements[keys[i]]);
-      } else {
-        result.push(callback.call(elements[keys[i]], elements[keys[i]], keys[i]));
+    var _iterator7 = _createForOfIteratorHelper(keys),
+      _step7;
+    try {
+      for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+        var key = _step7.value;
+        var value = LeUtils.getValueAtIndex(elements, key, optionalSkipHasOwnPropertyCheck);
+        if (!callback) {
+          result.push(value);
+        } else {
+          result.push(callback.call(value, value, key));
+        }
       }
+    } catch (err) {
+      _iterator7.e(err);
+    } finally {
+      _iterator7.f();
     }
     return result;
   },
-  /**
-   * @callback LeUtils~__sortKeysComparatorCallback
-   * @param {*} elementA
-   * @param {*} elementB
-   * @returns {number}
-   */
   /**
    * Loops through the given elements, and returns a new array, with the keys from the given elements, sorted by the result from the given comparator. Always returns an array.
    *
-   * @param {*[]|object|Function} elements
-   * @param {LeUtils~__sortKeysComparatorCallback} comparator
+   * @param {*} elements
+   * @param {(valueA:*, valueB:*) => number} comparator
    * @param {boolean} [optionalSkipHasOwnPropertyCheck]
    * @returns {*[]}
    */
   sortKeys: function sortKeys(elements, comparator) {
     var optionalSkipHasOwnPropertyCheck = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
     var keys = [];
-    if (elements !== null && typeof elements !== 'undefined') {
-      if (Array.isArray(elements)) {
-        for (var index = 0; index < elements.length; index++) {
-          keys.push(index);
-        }
-      } else if (_typeof(elements) === 'object' || typeof elements === 'function') {
-        for (var _index6 in elements) {
-          if (optionalSkipHasOwnPropertyCheck === true || Object.prototype.hasOwnProperty.call(elements, _index6)) {
-            keys.push(_index6);
-          }
-        }
-      } else {
-        console.warn('Executed LeUtils.sortKeys() on an invalid type: [' + _typeof(elements) + ']', elements);
-      }
-    }
+    LeUtils.each(elements, function (value, index) {
+      keys.push(index);
+    }, optionalSkipHasOwnPropertyCheck);
     keys.sort(function (a, b) {
-      return comparator(elements[a], elements[b]);
+      return comparator(LeUtils.getValueAtIndex(elements, a, optionalSkipHasOwnPropertyCheck), LeUtils.getValueAtIndex(elements, b, optionalSkipHasOwnPropertyCheck));
     });
     return keys;
   },
@@ -1065,6 +1328,37 @@ var LeUtils = {
       return result;
     };
   }(),
+  /**
+   * Turns the given value(s) into a 1 dimensional array.
+   *
+   * Compared to LeUtils.flattenArray(), this function also supports objects, Maps, Sets, and other iterable objects.
+   *
+   * @param {*} elements
+   * @param {boolean} [optionalSkipHasOwnPropertyCheck]
+   * @returns {*[]}
+   */
+  flattenToArray: function () {
+    var _flattenToArrayRecursive = function flattenToArrayRecursive(result, elements, optionalSkipHasOwnPropertyCheck) {
+      if (!LeUtils.supportsEach(elements)) {
+        result.push(elements);
+        return;
+      }
+      LeUtils.each(elements, function (entry) {
+        _flattenToArrayRecursive(result, entry, optionalSkipHasOwnPropertyCheck);
+      }, optionalSkipHasOwnPropertyCheck);
+    };
+    return function (elements) {
+      var optionalSkipHasOwnPropertyCheck = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      if (!LeUtils.supportsEach(elements)) {
+        return [elements];
+      }
+      var result = [];
+      LeUtils.each(elements, function (entry) {
+        _flattenToArrayRecursive(result, entry, optionalSkipHasOwnPropertyCheck);
+      }, optionalSkipHasOwnPropertyCheck);
+      return result;
+    };
+  }(),
   /**
    * Compares two values. Primarily used for sorting.
    *
@@ -1093,12 +1387,22 @@ var LeUtils = {
    * @returns {number}
    */
   compareNumericStrings: function compareNumericStrings(a, b) {
-    a = STRING(a).trim();
-    b = STRING(b).trim();
-    if (a.length === b.length) {
-      return a < b ? -1 : a > b ? 1 : 0;
+    var aParts = STRING(a).split('.');
+    var bParts = STRING(b).split('.');
+    for (var i = 0; i < Math.min(aParts.length, bParts.length); i++) {
+      a = aParts[i].trim();
+      b = bParts[i].trim();
+      if (a.length !== b.length) {
+        return a.length < b.length ? -1 : 1;
+      }
+      if (a !== b) {
+        return a < b ? -1 : 1;
+      }
     }
-    return a.length < b.length ? -1 : 1;
+    if (aParts.length !== bParts.length) {
+      return aParts.length < bParts.length ? -1 : 1;
+    }
+    return 0;
   },
   /**
    * Compares two strings generated by LeUtils.timestamp(). Primarily used for sorting.
@@ -1152,27 +1456,27 @@ var LeUtils = {
    * @returns {boolean}
    */
   isGeneratorFunction: function () {
-    var GeneratorFunction = _regeneratorRuntime.mark(function _callee5() {
-      return _regeneratorRuntime.wrap(function _callee5$(_context6) {
+    var GeneratorFunction = _regeneratorRuntime.mark(function _callee6() {
+      return _regeneratorRuntime.wrap(function (_context6) {
         while (1) switch (_context6.prev = _context6.next) {
           case 0:
           case "end":
             return _context6.stop();
         }
-      }, _callee5);
+      }, _callee6);
     }).constructor;
-    var AsyncGeneratorFunction = _wrapAsyncGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee6() {
-      return _regeneratorRuntime.wrap(function _callee6$(_context7) {
+    var AsyncGeneratorFunction = _wrapAsyncGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee7() {
+      return _regeneratorRuntime.wrap(function (_context7) {
         while (1) switch (_context7.prev = _context7.next) {
           case 0:
           case "end":
             return _context7.stop();
         }
-      }, _callee6);
+      }, _callee7);
     })).constructor;
     var RegularFunction = function () {}.constructor;
-    var PossibleGeneratorFunctionNames = Array.from(new Set(['GeneratorFunction', 'AsyncFunction', 'AsyncGeneratorFunction', GeneratorFunction.name, GeneratorFunction.displayName, AsyncGeneratorFunction.name, AsyncGeneratorFunction.displayName])).filter(function (element) {
-      return element && element !== RegularFunction.name && element !== RegularFunction.displayName;
+    var PossibleGeneratorFunctionNames = Array.from(new Set(['GeneratorFunction', 'AsyncFunction', 'AsyncGeneratorFunction', GeneratorFunction.name, AsyncGeneratorFunction.name])).filter(function (element) {
+      return element && element !== RegularFunction.name;
     });
     return function (func) {
       if (!func) {
@@ -1182,19 +1486,16 @@ var LeUtils = {
       if (!constructor) {
         return false;
       }
+      // noinspection JSUnresolvedVariable
       return constructor.name && PossibleGeneratorFunctionNames.includes(constructor.name) || constructor.displayName && PossibleGeneratorFunctionNames.includes(constructor.displayName);
     };
   }(),
-  /**
-   * @callback LeUtils~__setTimeoutCallback
-   * @param {number} deltaTime
-   */
   /**
    * Executes the callback after the given number of milliseconds. Passes the elapsed time in seconds to the callback.
    *
    * To cancel the timeout, call remove() on the result of this function (example: "const timeoutHandler = LeUtils.setTimeout((deltaTime)=>{}, 1000); timeoutHandler.remove();")
    *
-   * @param {LeUtils~__setTimeoutCallback} callback ([number] deltaTime)
+   * @param {(deltaTime:number) => *} callback
    * @param {number} ms
    * @returns {{remove:Function}}
    */
@@ -1206,6 +1507,7 @@ var LeUtils = {
     }
     ms = FLOAT_LAX(ms);
     var lastTime = performance.now();
+    /** @type {number|null} */
     var handler = window.setTimeout(function () {
       var currentTime = performance.now();
       try {
@@ -1224,16 +1526,12 @@ var LeUtils = {
       }
     };
   },
-  /**
-   * @callback LeUtils~__setIntervalCallback
-   * @param {number} deltaTime
-   */
   /**
    * Executes the callback every given number of milliseconds. Passes the time difference in seconds between the last frame and now to it.
    *
    * To remove the interval, call remove() on the result of this function (example: "const intervalHandler = LeUtils.setInterval((deltaTime)=>{}, 1000); intervalHandler.remove();")
    *
-   * @param {LeUtils~__setIntervalCallback} callback ([number] deltaTime)
+   * @param {(deltaTime:number) => *} callback
    * @param {number} [intervalMs]
    * @param {boolean} [fireImmediately]
    * @returns {{remove:Function}}
@@ -1255,6 +1553,7 @@ var LeUtils = {
       };
     }
     var lastTime = performance.now();
+    /** @type {number|null} */
     var handler = window.setInterval(function () {
       var currentTime = performance.now();
       try {
@@ -1273,16 +1572,12 @@ var LeUtils = {
       }
     };
   },
-  /**
-   * @callback LeUtils~__setAnimationFrameTimeoutCallback
-   * @param {number} deltaTime
-   */
   /**
    * Executes the callback after the given number of frames. Passes the elapsed time in seconds to the callback.
    *
    * To cancel the timeout, call remove() on the result of this function (example: "const timeoutHandler = LeUtils.setAnimationFrameTimeout((deltaTime){}, 5); timeoutHandler.remove();")
    *
-   * @param {LeUtils~__setAnimationFrameTimeoutCallback} callback ([number] deltaTime)
+   * @param {(deltaTime:number) => *} callback
    * @param {number} [frames]
    * @returns {{remove:Function}}
    */
@@ -1326,16 +1621,12 @@ var LeUtils = {
       }
     };
   },
-  /**
-   * @callback LeUtils~__setAnimationFrameIntervalCallback
-   * @param {number} deltaTime
-   */
   /**
    * Executes the callback every given number of frames. Passes the time difference in seconds between the last frame and now to it.
    *
    * To remove the interval, call remove() on the result of this function (example: "const intervalHandler = LeUtils.setAnimationFrameInterval((deltaTime)=>{}, 5); intervalHandler.remove();")
    *
-   * @param {LeUtils~__setAnimationFrameIntervalCallback} callback ([number] deltaTime)
+   * @param {(deltaTime:number) => *} callback
    * @param {number} [intervalFrames]
    * @param {boolean} [fireImmediately]
    * @returns {{remove:Function}}
@@ -1393,13 +1684,13 @@ var LeUtils = {
    * Returns a promise, which will be resolved after the given number of milliseconds.
    *
    * @param {number} ms
-   * @returns {Promise}
+   * @returns {Promise<number>}
    */
   promiseTimeout: function promiseTimeout(ms) {
     ms = FLOAT_LAX(ms);
     if (ms <= 0) {
       return new Promise(function (resolve) {
-        return resolve(undefined);
+        return resolve(0);
       });
     }
     return new Promise(function (resolve) {
@@ -1410,13 +1701,13 @@ var LeUtils = {
    * Returns a promise, which will be resolved after the given number of frames.
    *
    * @param {number} frames
-   * @returns {Promise}
+   * @returns {Promise<number>}
    */
   promiseAnimationFrameTimeout: function promiseAnimationFrameTimeout(frames) {
     frames = INT_LAX(frames);
     if (frames <= 0) {
       return new Promise(function (resolve) {
-        return resolve(undefined);
+        return resolve(0);
       });
     }
     return new Promise(function (resolve) {
@@ -1427,11 +1718,11 @@ var LeUtils = {
    * Allows you to do a fetch, with built-in retry and abort functionality.
    *
    * @param {string} url
-   * @param {Object} [options]
+   * @param {{retries?:number|null, delay?:number|((attempt:number)=>number)|null}|object|null} [options]
    * @returns {{then:Function, catch:Function, finally:Function, remove:Function, isRemoved:Function}}
    */
   fetch: function (_fetch) {
-    function fetch(_x9, _x10) {
+    function fetch(_x9, _x0) {
       return _fetch.apply(this, arguments);
     }
     fetch.toString = function () {
@@ -1446,83 +1737,83 @@ var LeUtils = {
     if (typeof window !== 'undefined' && typeof window.AbortController !== 'undefined') {
       controller = new AbortController();
     }
-    var promise = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee8() {
+    var promise = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee9() {
       var _attemptFetch;
-      return _regeneratorRuntime.wrap(function _callee8$(_context9) {
+      return _regeneratorRuntime.wrap(function (_context9) {
         while (1) switch (_context9.prev = _context9.next) {
           case 0:
             _attemptFetch = /*#__PURE__*/function () {
-              var _ref7 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee7() {
+              var _ref7 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee8() {
                 var _controller;
-                var _controller2, response, _controller3;
-                return _regeneratorRuntime.wrap(function _callee7$(_context8) {
+                var _controller2, response, _controller3, _t1;
+                return _regeneratorRuntime.wrap(function (_context8) {
                   while (1) switch (_context8.prev = _context8.next) {
                     case 0:
                       if (!(controllerAborted || (_controller = controller) !== null && _controller !== void 0 && (_controller = _controller.signal) !== null && _controller !== void 0 && _controller.aborted)) {
-                        _context8.next = 2;
+                        _context8.next = 1;
                         break;
                       }
                       throw new Error('Aborted');
-                    case 2:
-                      _context8.prev = 2;
-                      _context8.next = 5;
+                    case 1:
+                      _context8.prev = 1;
+                      _context8.next = 2;
                       return fetch(url, _objectSpread(_objectSpread({
                         signal: (_controller2 = controller) === null || _controller2 === void 0 ? void 0 : _controller2.signal
                       }, options !== null && options !== void 0 ? options : {}), {}, {
                         retries: undefined,
                         delay: undefined
                       }));
-                    case 5:
+                    case 2:
                       response = _context8.sent;
                       if (response.ok) {
-                        _context8.next = 8;
+                        _context8.next = 3;
                         break;
                       }
                       throw new Error('Network request failed: ' + response.status + ' ' + response.statusText);
-                    case 8:
+                    case 3:
                       return _context8.abrupt("return", response);
-                    case 11:
-                      _context8.prev = 11;
-                      _context8.t0 = _context8["catch"](2);
+                    case 4:
+                      _context8.prev = 4;
+                      _t1 = _context8["catch"](1);
                       if (!(controllerAborted || (_controller3 = controller) !== null && _controller3 !== void 0 && (_controller3 = _controller3.signal) !== null && _controller3 !== void 0 && _controller3.aborted)) {
-                        _context8.next = 15;
+                        _context8.next = 5;
                         break;
                       }
                       throw new Error('Aborted');
-                    case 15:
+                    case 5:
                       if (!(currentRetries >= retries)) {
-                        _context8.next = 17;
+                        _context8.next = 6;
                         break;
                       }
-                      throw _context8.t0;
-                    case 17:
+                      throw _t1;
+                    case 6:
                       currentRetries++;
-                      _context8.next = 20;
+                      _context8.next = 7;
                       return LeUtils.promiseTimeout(typeof (options === null || options === void 0 ? void 0 : options.delay) === 'function' ? INT_LAX_ANY(options === null || options === void 0 ? void 0 : options.delay(currentRetries), 500) : INT_LAX_ANY(options === null || options === void 0 ? void 0 : options.delay, 500));
-                    case 20:
-                      _context8.next = 22;
+                    case 7:
+                      _context8.next = 8;
                       return _attemptFetch();
-                    case 22:
+                    case 8:
                       return _context8.abrupt("return", _context8.sent);
-                    case 23:
+                    case 9:
                     case "end":
                       return _context8.stop();
                   }
-                }, _callee7, null, [[2, 11]]);
+                }, _callee8, null, [[1, 4]]);
               }));
               return function attemptFetch() {
                 return _ref7.apply(this, arguments);
               };
             }();
-            _context9.next = 3;
+            _context9.next = 1;
             return _attemptFetch();
-          case 3:
+          case 1:
             return _context9.abrupt("return", _context9.sent);
-          case 4:
+          case 2:
           case "end":
             return _context9.stop();
         }
-      }, _callee8);
+      }, _callee9);
     }))();
     var result = {};
     result.then = function () {
@@ -1554,6 +1845,120 @@ var LeUtils = {
     };
     return result;
   }),
+  /**
+   * Allows you to do a fetch, with built-in retry functionality. Caches on the requested URL, so that the same URL will not be fetched multiple times.
+   *
+   * @param {string} url
+   * @param {{retries?:number|null, delay?:number|((attempt:number)=>number)|null, [verify]:((data:*,response:*)=>void)|null}|null} [options]
+   * @param {((response:*)=>*)|null} [responseFunction] A function that will be called with the response object, and should return the data to be cached.
+   * @returns {Promise<*>}
+   */
+  cachedFetch: function () {
+    var cache = new Map();
+    return /*#__PURE__*/function () {
+      var _ref8 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee1(url, options, responseFunction) {
+        var result, promise;
+        return _regeneratorRuntime.wrap(function (_context1) {
+          while (1) switch (_context1.prev = _context1.next) {
+            case 0:
+              if (!cache.has(url)) {
+                _context1.next = 5;
+                break;
+              }
+              result = cache.get(url);
+              if (!result.data) {
+                _context1.next = 1;
+                break;
+              }
+              return _context1.abrupt("return", result.data);
+            case 1:
+              if (!result.promise) {
+                _context1.next = 3;
+                break;
+              }
+              _context1.next = 2;
+              return result.promise;
+            case 2:
+              return _context1.abrupt("return", _context1.sent);
+            case 3:
+              if (!result.error) {
+                _context1.next = 4;
+                break;
+              }
+              throw result.error;
+            case 4:
+              console.warn('Failed to use the cachedFetch cache, for URL: ', url, ', it is in an unexpected state: ', result);
+              return _context1.abrupt("return", null);
+            case 5:
+              promise = LeUtils.fetch(url, options).then(/*#__PURE__*/function () {
+                var _ref9 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee0(response) {
+                  var data, _t10;
+                  return _regeneratorRuntime.wrap(function (_context0) {
+                    while (1) switch (_context0.prev = _context0.next) {
+                      case 0:
+                        if (!responseFunction) {
+                          _context0.next = 2;
+                          break;
+                        }
+                        _context0.next = 1;
+                        return responseFunction(response);
+                      case 1:
+                        _t10 = _context0.sent;
+                        _context0.next = 3;
+                        break;
+                      case 2:
+                        _t10 = response;
+                      case 3:
+                        data = _t10;
+                        if (!(typeof (options === null || options === void 0 ? void 0 : options.verify) === 'function')) {
+                          _context0.next = 4;
+                          break;
+                        }
+                        _context0.next = 4;
+                        return options.verify(data, response);
+                      case 4:
+                        return _context0.abrupt("return", data);
+                      case 5:
+                      case "end":
+                        return _context0.stop();
+                    }
+                  }, _callee0);
+                }));
+                return function (_x12) {
+                  return _ref9.apply(this, arguments);
+                };
+              }()).then(function (data) {
+                cache.set(url, {
+                  data: data
+                });
+                return data;
+              })["catch"](function (error) {
+                cache.set(url, {
+                  error: error
+                });
+                console.error('Failed to fetch: ', error);
+                throw error;
+              });
+              if (!cache.has(url)) {
+                cache.set(url, {
+                  promise: promise
+                });
+              }
+              _context1.next = 6;
+              return promise;
+            case 6:
+              return _context1.abrupt("return", _context1.sent);
+            case 7:
+            case "end":
+              return _context1.stop();
+          }
+        }, _callee1);
+      }));
+      return function (_x1, _x10, _x11) {
+        return _ref8.apply(this, arguments);
+      };
+    }();
+  }(),
   /**
    * Returns true if the user is on a smartphone device (mobile).
    * Will return false if the user is on a tablet or on a desktop.
@@ -1759,7 +2164,7 @@ var LeUtils = {
    * - foo-bar
    * - foo_bar
    *
-   * @param {string} names
+   * @param {string[]} names
    * @returns {string[]}
    */
   generateNamePermutations: function generateNamePermutations() {
@@ -1802,17 +2207,17 @@ var LeUtils = {
     if (string === '') {
       return '1';
     }
-    for (var _i = string.length - 1; _i >= 0; _i--) {
-      var _c = string.charAt(_i);
+    for (var _i7 = string.length - 1; _i7 >= 0; _i7--) {
+      var _c = string.charAt(_i7);
       if (_c < '0' || _c > '9') {
         return '1';
       }
       if (_c < '9') {
-        _c++;
-        string = string.substring(0, _i) + _c + string.substring(_i + 1); // string[i] = (char + 1);
+        _c = String.fromCharCode(_c.charCodeAt(0) + 1);
+        string = string.substring(0, _i7) + _c + string.substring(_i7 + 1); // string[i] = (char + 1);
         break;
       }
-      string = string.substring(0, _i) + '0' + string.substring(_i + 1); // string[i] = '0';
+      string = string.substring(0, _i7) + '0' + string.substring(_i7 + 1); // string[i] = '0';
     }
     if (string.charAt(0) === '0') {
       string = '1' + string;
@@ -1826,7 +2231,7 @@ var LeUtils = {
    */
   uniqueId: function () {
     var previousUniqueIdsTime = null;
-    var previousUniqueIds = {};
+    var previousUniqueIds = new Map();
     var numberToBytes = function numberToBytes(number) {
       var size = number === 0 ? 0 : Math.ceil((Math.floor(Math.log2(number)) + 1) / 8);
       var bytes = new Uint8ClampedArray(size);
@@ -1886,10 +2291,11 @@ var LeUtils = {
         var result = generateUniqueId();
         if (previousUniqueIdsTime !== result.time) {
           previousUniqueIdsTime = result.time;
-          previousUniqueIds = _defineProperty({}, result.id, true);
+          previousUniqueIds.clear();
+          previousUniqueIds.set(result.id, true);
           return result.id;
-        } else if (previousUniqueIds[result.id] !== true) {
-          previousUniqueIds[result.id] = true;
+        } else if (previousUniqueIds.get(result.id) !== true) {
+          previousUniqueIds.set(result.id, true);
           return result.id;
         }
       }
@@ -1955,7 +2361,7 @@ var LeUtils = {
   getPercentage: function getPercentage(part, total) {
     part = FLOAT_LAX(part);
     total = FLOAT_LAX(total);
-    if (total <= 0) {
+    if (total === 0) {
       return 100;
     }
     return Math.max(0, Math.min(100, part / total * 100));
@@ -1976,17 +2382,16 @@ var LeUtils = {
       var ctx = canvas.getContext('2d');
       var width = Math.floor(image.width);
       var height = Math.floor(image.height);
-      if (width <= 0 || height <= 0) {
-        canvas.width = 1;
-        canvas.height = 1;
-      } else {
-        canvas.width = width;
-        canvas.height = height;
-        ctx.drawImage(image, 0, 0, canvas.width, canvas.height);
+      if (!ctx || width <= 0 || height <= 0) {
+        return new Uint8ClampedArray();
       }
+      canvas.width = width;
+      canvas.height = height;
+      ctx.drawImage(image, 0, 0, canvas.width, canvas.height);
       return ctx.getImageData(0, 0, canvas.width, canvas.height).data;
     } finally {
-      canvas.parentNode.removeChild(canvas);
+      var _canvas$parentNode;
+      canvas === null || canvas === void 0 || (_canvas$parentNode = canvas.parentNode) === null || _canvas$parentNode === void 0 || _canvas$parentNode.removeChild(canvas);
     }
   },
   /**
@@ -2006,20 +2411,19 @@ var LeUtils = {
       var ctx = canvas.getContext('2d');
       var width = Math.floor(image.width);
       var height = Math.floor(image.height);
-      if (width <= 0 || height <= 0) {
-        canvas.width = 1;
-        canvas.height = 1;
-      } else {
-        canvas.width = width;
-        canvas.height = height;
-        ctx.drawImage(image, 0, 0, canvas.width, canvas.height);
+      if (!ctx || width <= 0 || height <= 0) {
+        return LeUtils.getEmptyImageSrc();
       }
+      canvas.width = width;
+      canvas.height = height;
+      ctx.drawImage(image, 0, 0, canvas.width, canvas.height);
       ctx.globalCompositeOperation = 'source-in';
       ctx.fillStyle = color;
       ctx.fillRect(0, 0, canvas.width, canvas.height);
       return canvas.toDataURL('image/png');
     } finally {
-      canvas.parentNode.removeChild(canvas);
+      var _canvas$parentNode2;
+      canvas === null || canvas === void 0 || (_canvas$parentNode2 = canvas.parentNode) === null || _canvas$parentNode2 === void 0 || _canvas$parentNode2.removeChild(canvas);
     }
   },
   /**
@@ -2041,14 +2445,19 @@ var LeUtils = {
    * @returns {number[]}
    */
   hexToRgb: function hexToRgb(hexstring) {
+    var _hexstring$match;
+    var initialHexstring = hexstring;
     hexstring = hexstring.replace(/[^0-9A-F]/gi, '');
     var hasAlpha = hexstring.length === 4 || hexstring.length === 8;
     while (hexstring.length < 6) {
       hexstring = hexstring.replace(/(.)/g, '$1$1');
     }
-    var result = hexstring.match(/\w{2}/g).map(function (a) {
+    var result = (_hexstring$match = hexstring.match(/\w{2}/g)) === null || _hexstring$match === void 0 ? void 0 : _hexstring$match.map(function (a) {
       return parseInt(a, 16);
     });
+    if (!result || result.length < 3) {
+      throw new Error('Invalid hex color: "' + hexstring + '"  (was given "' + initialHexstring + '")');
+    }
     return [result[0], result[1], result[2]].concat(_toConsumableArray(hasAlpha ? [result[3]] : []));
   },
   /**
@@ -2063,12 +2472,10 @@ var LeUtils = {
     var b = rgb[2] / 255;
     var max = Math.max(r, g, b);
     var min = Math.min(r, g, b);
-    var h,
-      s,
-      l = (max + min) / 2;
-    if (max === min) {
-      h = s = 0;
-    } else {
+    var h = 0;
+    var s = 0;
+    var l = (max + min) / 2;
+    if (max !== min) {
       var d = max - min;
       s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
       switch (max) {
@@ -2115,10 +2522,10 @@ var LeUtils = {
       var h = hsl[0];
       var s = hsl[1];
       var l = hsl[2];
-      var r, g, b;
-      if (s === 0) {
-        r = g = b = l;
-      } else {
+      var r = 1;
+      var g = 1;
+      var b = 1;
+      if (s !== 0) {
         var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
         var p = 2 * l - q;
         r = hue2rgb(p, q, h + 1 / 3);
@@ -2156,13 +2563,13 @@ var LeUtils = {
    *
    * Returns a number:
    *
-   * <pre>
-   *   < 1.0    is not perceptible by human eyes
+   * ```js
+   *   < 1      is not perceptible by human eyes
    *     1-2    is perceptible through close observation
    *     2-10   is perceptible at a glance
    *     11-49  is more similar than opposite
    *     100    is exactly the opposite color
-   * </pre>
+   * ```
    *
    * @param {number[]} rgbA
    * @param {number[]} rgbB
@@ -2178,13 +2585,13 @@ var LeUtils = {
    *
    * Returns a number:
    *
-   * <pre>
-   *   < 1.0    is not perceptible by human eyes
+   * ```js
+   *   < 1      is not perceptible by human eyes
    *     1-2    is perceptible through close observation
    *     2-10   is perceptible at a glance
    *     11-49  is more similar than opposite
    *     100    is exactly the opposite color
-   * </pre>
+   * ```
    *
    * @param {number[]} labA
    * @param {number[]} labB
@@ -2213,16 +2620,16 @@ var LeUtils = {
    *
    * Usage:
    *
-   * <pre>
+   * ```js
    * LeUtils.getRgbOfGradient({
    *   0:  [255, 0,   0],
    *   33: [255, 255, 0],
    *   66: [0,   255, 0],
    *   100:[0,   255, 255],
    * }, 45.1234);
-   * </pre>
+   * ```
    *
-   * @param {{[percentage]: number[]}} gradient
+   * @param {{percentage?:number[]}} gradient
    * @param {number} percentage
    * @returns {number[]}
    */
@@ -2241,11 +2648,13 @@ var LeUtils = {
       }
     });
     if (closest === null) {
-      return null;
+      return [0, 0, 0];
     }
     closest = closest[0];
-    var higher = 99999;
-    var lower = -99999;
+    var HIGHER = 99999;
+    var LOWER = -99999;
+    var higher = HIGHER;
+    var lower = LOWER;
     LeUtils.each(gradient, function (color, percent) {
       percent = INT_LAX(percent);
       if (percent < closest) {
@@ -2259,15 +2668,9 @@ var LeUtils = {
         }
       }
     });
-    if (higher === 99999) {
-      higher = null;
-    }
-    if (lower === -99999) {
-      lower = null;
-    }
-    if (higher === null && lower === null || higher === lower) {
+    if (higher === HIGHER && lower === LOWER || higher === lower) {
       return gradient[closest];
-    } else if (higher !== null && lower !== null) {
+    } else if (higher !== HIGHER && lower !== LOWER) {
       var higherDifference = Math.abs(higher - percentage);
       var lowerDifference = Math.abs(percentage - lower);
       if (higherDifference > lowerDifference) {
@@ -2275,7 +2678,7 @@ var LeUtils = {
       } else {
         lower = closest;
       }
-    } else if (lower === null) {
+    } else if (lower === LOWER) {
       lower = closest;
     } else {
       higher = closest;
@@ -2315,7 +2718,7 @@ var LeUtils = {
    * @returns {string}
    */
   btoa: function (_btoa) {
-    function btoa(_x11) {
+    function btoa(_x13) {
       return _btoa.apply(this, arguments);
     }
     btoa.toString = function () {
@@ -2335,7 +2738,7 @@ var LeUtils = {
    * @returns {string}
    */
   atob: function (_atob) {
-    function atob(_x12) {
+    function atob(_x14) {
       return _atob.apply(this, arguments);
     }
     atob.toString = function () {
@@ -2388,9 +2791,14 @@ var LeUtils = {
    * @returns {string}
    */
   hexToBase64: function hexToBase64(hexstring) {
-    return LeUtils.btoa(hexstring.replace(/[^0-9A-F]/gi, '').match(/\w{2}/g).map(function (a) {
+    var _hexstring$replace$ma;
+    var hexResult = (_hexstring$replace$ma = hexstring.replace(/[^0-9A-F]/gi, '').match(/\w{2}/g)) === null || _hexstring$replace$ma === void 0 || (_hexstring$replace$ma = _hexstring$replace$ma.map(function (a) {
       return String.fromCharCode(parseInt(a, 16));
-    }).join(''));
+    })) === null || _hexstring$replace$ma === void 0 ? void 0 : _hexstring$replace$ma.join('');
+    if (!hexResult) {
+      throw new Error('Invalid hex string: "' + hexstring + '"');
+    }
+    return LeUtils.btoa(hexResult);
   },
   /**
    * Converts a base64 string into bytes (Uint8Array).
@@ -2410,7 +2818,7 @@ var LeUtils = {
   /**
    * Converts bytes into a base64 string.
    *
-   * @param {ArrayLike<number>|ArrayBufferLike} arraybuffer
+   * @param {ArrayLike<number>|ArrayBuffer} arraybuffer
    * @returns {string}
    */
   bytesToBase64: function bytesToBase64(arraybuffer) {
@@ -2454,10 +2862,8 @@ var LeUtils = {
       return;
     }
     try {
-      result = JSON.parse(result);
-      if (typeof result['-'] !== 'undefined') {
-        return result['-'];
-      }
+      var _JSON$parse;
+      return (_JSON$parse = JSON.parse(result)) === null || _JSON$parse === void 0 ? void 0 : _JSON$parse['-'];
     } catch (e) {}
   },
   /**
@@ -2545,8 +2951,8 @@ var LeUtils = {
    * This way, you can have values that aren't the same be treated as if they are. This can be used to deal with issues such as floating point errors for example.
    *
    * @param {*[]} elements
-   * @param {Function} comparator
-   * @returns {{getElements: (function(): *[]),  getComparator: (function(): Function),  size: (function(): number),  isEmpty: (function(): boolean),  contains: (function(*): boolean),  first: (function(): *|undefined),  last: (function(): *|undefined),  pollFirst: (function(): *|undefined),  pollLast: (function(): *|undefined),  add: function(*),  addAll: function(*[]|object),  getEqualValue: (function(*): (*)),  getEqualValueOrAdd: (function(*): (*))}}
+   * @param {(valueA:*, valueB:*) => number} comparator
+   * @returns {{getElements:(()=>*[]), getComparator:(()=>((valueA:*,valueB:*)=>number)), size:(()=>number), isEmpty:(()=>boolean), contains:((value:*)=>boolean), first:(()=>*|undefined), last:(()=>*|undefined), pollFirst:(()=>*|undefined), pollLast:(()=>*|undefined), add:((value:*)=>void), addAll:((values:*)=>void), getEqualValue:((value:*)=>*), getEqualValueOrAdd:((value:*)=>*)}}
    */
   createTreeSet: function createTreeSet(elements, comparator) {
     comparator = comparator || LeUtils.compare;
@@ -2596,7 +3002,7 @@ var LeUtils = {
       /**
        * Returns the comparator of the set.
        *
-       * @returns {Function}
+       * @returns {(valueA:*, valueB:*) => number}
        */
       getComparator: function getComparator() {
         return comparator;
@@ -2673,7 +3079,7 @@ var LeUtils = {
       /**
        * Adds all the given values to the set. Will only do so if no equal value already exists.
        *
-       * @param {*[]|object} values
+       * @param {*} values
        */
       addAll: function addAll(values) {
         LeUtils.each(values, treeSet.add);
@@ -2709,7 +3115,7 @@ var LeUtils = {
     return treeSet;
   },
   /**
-   * @typedef {Object} LeUtils~TransactionalValue
+   * @typedef {Object} LeUtils_TransactionalValue
    * @property {*} value
    * @property {{id:string, value:*}[]} changes
    */
@@ -2722,7 +3128,7 @@ var LeUtils = {
    * This allows you to make multiple unconfirmed changes, and confirm or cancel each of them individually at any time.
    *
    * @param {*} [value]
-   * @returns {LeUtils~TransactionalValue}
+   * @returns {LeUtils_TransactionalValue}
    */
   createTransactionalValue: function createTransactionalValue(value) {
     if (typeof value === 'undefined') {
@@ -2736,7 +3142,7 @@ var LeUtils = {
   /**
    * Returns true if the given value is a valid TransactionalValue, returns false if it isn't.
    *
-   * @param {LeUtils~TransactionalValue} transactionalValue
+   * @param {LeUtils_TransactionalValue} transactionalValue
    * @returns {boolean}
    */
   isTransactionalValueValid: function isTransactionalValueValid(transactionalValue) {
@@ -2745,7 +3151,7 @@ var LeUtils = {
   /**
    * Returns true if the given value is a TransactionalValue, false otherwise.
    *
-   * @param {LeUtils~TransactionalValue} transactionalValue
+   * @param {LeUtils_TransactionalValue} transactionalValue
    * @returns {string}
    */
   transactionalValueToString: function transactionalValueToString(transactionalValue) {
@@ -2764,7 +3170,7 @@ var LeUtils = {
   /**
    * Sets the committed value of the given TransactionalValue to the given value. Clears out the previously uncommitted changes.
    *
-   * @param {LeUtils~TransactionalValue} transactionalValue
+   * @param {LeUtils_TransactionalValue} transactionalValue
    * @param {*} value
    */
   transactionSetAndCommit: function transactionSetAndCommit(transactionalValue, value) {
@@ -2779,7 +3185,7 @@ var LeUtils = {
    * Sets the value of the given TransactionalValue to the given value, without yet committing it, meaning it can be committed or cancelled later.
    * It returns the ID of the change, which can be used to commit or cancel the change later.
    *
-   * @param {LeUtils~TransactionalValue} transactionalValue
+   * @param {LeUtils_TransactionalValue} transactionalValue
    * @param {*} value
    * @returns {string}
    */
@@ -2799,7 +3205,7 @@ var LeUtils = {
    * Commits the change with the given ID, making it the new committed value.
    * Returns true if the change was found and committed, returns false if it was already overwritten by a newer committed change.
    *
-   * @param {LeUtils~TransactionalValue} transactionalValue
+   * @param {LeUtils_TransactionalValue} transactionalValue
    * @param {string} changeId
    * @returns {boolean}
    */
@@ -2817,7 +3223,7 @@ var LeUtils = {
    * Cancels the change with the given ID, removing it from the uncommitted changes.
    * Returns true if the change was found and removed, returns false if it was already overwritten by a newer committed change.
    *
-   * @param {LeUtils~TransactionalValue} transactionalValue
+   * @param {LeUtils_TransactionalValue} transactionalValue
    * @param {string} changeId
    * @returns {boolean}
    */
@@ -2834,7 +3240,7 @@ var LeUtils = {
    * Returns true if the change was found, meaning it can still make a difference to the final committed value of this TransactionalValue.
    * Returns false if it was already overwritten by a newer committed change, meaning that this change can no longer make a difference to the final committed value of this TransactionalValue.
    *
-   * @param {LeUtils~TransactionalValue} transactionalValue
+   * @param {LeUtils_TransactionalValue} transactionalValue
    * @param {string} changeId
    * @returns {boolean}
    */
@@ -2845,7 +3251,7 @@ var LeUtils = {
   /**
    * Returns the committed value of the given TransactionalValue.
    *
-   * @param {LeUtils~TransactionalValue} transactionalValue
+   * @param {LeUtils_TransactionalValue} transactionalValue
    * @returns {*}
    */
   transactionGetCommittedValue: function transactionGetCommittedValue(transactionalValue) {
@@ -2855,7 +3261,7 @@ var LeUtils = {
   /**
    * Returns the value (including any uncommitted changes made to it) of the given TransactionalValue.
    *
-   * @param {LeUtils~TransactionalValue} transactionalValue
+   * @param {LeUtils_TransactionalValue} transactionalValue
    * @returns {*}
    */
   transactionGetValue: function transactionGetValue(transactionalValue) {
@@ -2917,24 +3323,26 @@ var LeUtils = {
    * ```
    *
    * @param {string} name
-   * @returns {{worker: Worker,  sendMessage: function(Object, {timeout: number|undefined}|undefined): Promise<Object>}}
+   * @returns {{worker:Worker|null, sendMessage:(data:Object,options:{timeout:number|undefined}|undefined)=>Promise<Object>}}
    */
   createWorkerThread: function createWorkerThread(name) {
     if (typeof window === 'undefined' || typeof Worker === 'undefined') {
       return {
         worker: null,
-        sendMessage: new Promise(function (resolve, reject) {
-          reject('Workers are not supported in this environment');
-        })
+        sendMessage: function sendMessage(data, options) {
+          return new Promise(function (resolve, reject) {
+            reject('Workers are not supported in this environment');
+          });
+        }
       };
     }
     var worker = new Worker('/workers/' + name + '.worker.js');
-    var listeners = {};
+    var listeners = new Map();
     var addListener = function addListener(id, callback) {
-      listeners[id] = callback;
+      listeners.set(id, callback);
     };
     var removeListener = function removeListener(id) {
-      delete listeners[id];
+      listeners["delete"](id);
     };
     var sendMessage = function sendMessage(data, options) {
       return new Promise(function (resolve, reject) {
@@ -2956,7 +3364,7 @@ var LeUtils = {
     worker.onmessage = function (message) {
       var data = message.data;
       if (data !== null && data !== void 0 && data.id) {
-        var callback = listeners[data.id];
+        var callback = listeners.get(data.id);
         if (callback) {
           removeListener(data.id);
           callback(data);
@@ -2975,16 +3383,16 @@ var LeUtils = {
    *
    * @param {string} workerName
    * @param {Object} data
-   * @param {{timeout: number|undefined}} [options]
+   * @param {{timeout:number|undefined}} [options]
    * @returns {Promise<Object>}
    */
   sendWorkerMessage: function () {
-    var workers = {};
+    var workers = new Map();
     return function (workerName, data, options) {
-      if (!workers[workerName]) {
-        workers[workerName] = LeUtils.createWorkerThread(workerName);
+      if (!workers.has(workerName)) {
+        workers.set(workerName, LeUtils.createWorkerThread(workerName));
       }
-      return workers[workerName].sendMessage(data, options);
+      return workers.get(workerName).sendMessage(data, options);
     };
   }(),
   /**
@@ -3013,8 +3421,8 @@ var LeUtils = {
     }
     var inputTypes = ['text', 'search', 'email', 'number', 'password', 'tel', 'time', 'url', 'week', 'month', 'date', 'datetime-local'];
     return function () {
-      var _document, _document2;
-      return !(((_document = document) === null || _document === void 0 || (_document = _document.activeElement) === null || _document === void 0 || (_document = _document.tagName) === null || _document === void 0 ? void 0 : _document.toLowerCase()) === 'input' && inputTypes.includes((_document2 = document) === null || _document2 === void 0 || (_document2 = _document2.activeElement) === null || _document2 === void 0 || (_document2 = _document2.type) === null || _document2 === void 0 ? void 0 : _document2.toLowerCase()));
+      var _document, _document$activeEleme, _document2;
+      return !(((_document = document) === null || _document === void 0 || (_document = _document.activeElement) === null || _document === void 0 || (_document = _document.tagName) === null || _document === void 0 ? void 0 : _document.toLowerCase()) === 'input' && inputTypes.includes((_document$activeEleme = (_document2 = document) === null || _document2 === void 0 || (_document2 = _document2.activeElement) === null || _document2 === void 0 || (_document2 = _document2.getAttribute('type')) === null || _document2 === void 0 ? void 0 : _document2.toLowerCase()) !== null && _document$activeEleme !== void 0 ? _document$activeEleme : ''));
     };
   }(),
   /**