extra-game-loop 0.1.3 → 0.2.0

package/dist/es2015/index.mjs

@@ -1,6 +1,6 @@
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
-var es2018$f = {};
+var es2018$h = {};
 
 var box = {};
 
@@ -23,227 +23,227 @@ box.Box = Box;
 
 var cons = {};
 
-var es2018$e = {};
+var es2018$g = {};
 
-var array$2 = {};
+var array$5 = {};
 
-array$2.isntEmptyArray = array$2.isEmptyArray = array$2.isntArray = array$2.isArray = void 0;
-function isArray$5(val) {
+array$5.isntEmptyArray = array$5.isEmptyArray = array$5.isntArray = array$5.isArray = void 0;
+function isArray$7(val) {
     return Array.isArray(val);
 }
-array$2.isArray = isArray$5;
-function isntArray$2(val) {
-    return !isArray$5(val);
+array$5.isArray = isArray$7;
+function isntArray$4(val) {
+    return !isArray$7(val);
 }
-array$2.isntArray = isntArray$2;
-function isEmptyArray$2(val) {
+array$5.isntArray = isntArray$4;
+function isEmptyArray$4(val) {
     return val.length === 0;
 }
-array$2.isEmptyArray = isEmptyArray$2;
-function isntEmptyArray$2(val) {
+array$5.isEmptyArray = isEmptyArray$4;
+function isntEmptyArray$4(val) {
     return val.length !== 0;
 }
-array$2.isntEmptyArray = isntEmptyArray$2;
+array$5.isntEmptyArray = isntEmptyArray$4;
 
-var asyncIterable$2 = {};
+var asyncIterable$4 = {};
 
-var _null$2 = {};
+var _null$4 = {};
 
-_null$2.isntNull = _null$2.isNull = void 0;
-function isNull$2(val) {
+_null$4.isntNull = _null$4.isNull = void 0;
+function isNull$4(val) {
     return val === null;
 }
-_null$2.isNull = isNull$2;
-function isntNull$2(val) {
-    return !isNull$2(val);
+_null$4.isNull = isNull$4;
+function isntNull$4(val) {
+    return !isNull$4(val);
 }
-_null$2.isntNull = isntNull$2;
+_null$4.isntNull = isntNull$4;
 
-var _undefined$2 = {};
+var _undefined$4 = {};
 
-_undefined$2.isntUndefined = _undefined$2.isUndefined = void 0;
-function isUndefined$2(val) {
+_undefined$4.isntUndefined = _undefined$4.isUndefined = void 0;
+function isUndefined$4(val) {
     return val === undefined;
 }
-_undefined$2.isUndefined = isUndefined$2;
-function isntUndefined$2(val) {
-    return !isUndefined$2(val);
+_undefined$4.isUndefined = isUndefined$4;
+function isntUndefined$4(val) {
+    return !isUndefined$4(val);
 }
-_undefined$2.isntUndefined = isntUndefined$2;
+_undefined$4.isntUndefined = isntUndefined$4;
 
-var _function$2 = {};
+var _function$4 = {};
 
-_function$2.isntFunction = _function$2.isFunction = void 0;
-function isFunction$4(val) {
+_function$4.isntFunction = _function$4.isFunction = void 0;
+function isFunction$6(val) {
     return typeof val === 'function';
 }
-_function$2.isFunction = isFunction$4;
-function isntFunction$2(val) {
-    return !isFunction$4(val);
+_function$4.isFunction = isFunction$6;
+function isntFunction$4(val) {
+    return !isFunction$6(val);
 }
-_function$2.isntFunction = isntFunction$2;
+_function$4.isntFunction = isntFunction$4;
 
-asyncIterable$2.isntAsyncIterable = asyncIterable$2.isAsyncIterable = void 0;
-const null_1$8 = _null$2;
-const undefined_1$5 = _undefined$2;
-const function_1$8 = _function$2;
-function isAsyncIterable$4(val) {
-    return (0, null_1$8.isntNull)(val)
-        && (0, undefined_1$5.isntUndefined)(val)
-        && (0, function_1$8.isFunction)(val[Symbol.asyncIterator]);
+asyncIterable$4.isntAsyncIterable = asyncIterable$4.isAsyncIterable = void 0;
+const null_1$e = _null$4;
+const undefined_1$9 = _undefined$4;
+const function_1$e = _function$4;
+function isAsyncIterable$6(val) {
+    return (0, null_1$e.isntNull)(val)
+        && (0, undefined_1$9.isntUndefined)(val)
+        && (0, function_1$e.isFunction)(val[Symbol.asyncIterator]);
 }
-asyncIterable$2.isAsyncIterable = isAsyncIterable$4;
-function isntAsyncIterable$2(val) {
-    return !isAsyncIterable$4(val);
+asyncIterable$4.isAsyncIterable = isAsyncIterable$6;
+function isntAsyncIterable$4(val) {
+    return !isAsyncIterable$6(val);
 }
-asyncIterable$2.isntAsyncIterable = isntAsyncIterable$2;
+asyncIterable$4.isntAsyncIterable = isntAsyncIterable$4;
 
-var bigint$2 = {};
+var bigint$4 = {};
 
-bigint$2.isntBigInt = bigint$2.isBigInt = void 0;
-function isBigInt$2(val) {
+bigint$4.isntBigInt = bigint$4.isBigInt = void 0;
+function isBigInt$4(val) {
     return typeof val === 'bigint';
 }
-bigint$2.isBigInt = isBigInt$2;
-function isntBigInt$2(val) {
-    return !isBigInt$2(val);
+bigint$4.isBigInt = isBigInt$4;
+function isntBigInt$4(val) {
+    return !isBigInt$4(val);
 }
-bigint$2.isntBigInt = isntBigInt$2;
+bigint$4.isntBigInt = isntBigInt$4;
 
-var boolean$2 = {};
+var boolean$4 = {};
 
-boolean$2.isntBoolean = boolean$2.isBoolean = void 0;
-function isBoolean$2(val) {
+boolean$4.isntBoolean = boolean$4.isBoolean = void 0;
+function isBoolean$4(val) {
     return typeof val === 'boolean';
 }
-boolean$2.isBoolean = isBoolean$2;
-function isntBoolean$2(val) {
-    return !isBoolean$2(val);
+boolean$4.isBoolean = isBoolean$4;
+function isntBoolean$4(val) {
+    return !isBoolean$4(val);
 }
-boolean$2.isntBoolean = isntBoolean$2;
+boolean$4.isntBoolean = isntBoolean$4;
 
-var char$2 = {};
+var char$4 = {};
 
-var string$2 = {};
+var string$4 = {};
 
-string$2.isntString = string$2.isString = void 0;
-function isString$2(val) {
+string$4.isntString = string$4.isString = void 0;
+function isString$4(val) {
     return typeof val === 'string';
 }
-string$2.isString = isString$2;
-function isntString$2(val) {
-    return !isString$2(val);
+string$4.isString = isString$4;
+function isntString$4(val) {
+    return !isString$4(val);
 }
-string$2.isntString = isntString$2;
+string$4.isntString = isntString$4;
 
-char$2.isntChar = char$2.isChar = void 0;
-const string_1$5 = string$2;
-function isChar$2(val) {
-    return (0, string_1$5.isString)(val)
+char$4.isntChar = char$4.isChar = void 0;
+const string_1$9 = string$4;
+function isChar$4(val) {
+    return (0, string_1$9.isString)(val)
         && val.length === 1;
 }
-char$2.isChar = isChar$2;
-function isntChar$2(val) {
-    return !isChar$2(val);
+char$4.isChar = isChar$4;
+function isntChar$4(val) {
+    return !isChar$4(val);
 }
-char$2.isntChar = isntChar$2;
+char$4.isntChar = isntChar$4;
 
-var date$2 = {};
+var date$4 = {};
 
-date$2.isntDate = date$2.isDate = void 0;
-function isDate$3(val) {
+date$4.isntDate = date$4.isDate = void 0;
+function isDate$5(val) {
     return val instanceof Date;
 }
-date$2.isDate = isDate$3;
-function isntDate$2(val) {
-    return !isDate$3(val);
+date$4.isDate = isDate$5;
+function isntDate$4(val) {
+    return !isDate$5(val);
 }
-date$2.isntDate = isntDate$2;
+date$4.isntDate = isntDate$4;
 
-var _enum$2 = {};
+var _enum$4 = {};
 
-_enum$2.inEnum = void 0;
-function inEnum$2(val, _enum) {
+_enum$4.inEnum = void 0;
+function inEnum$4(val, _enum) {
     return Object.values(_enum).includes(val);
 }
-_enum$2.inEnum = inEnum$2;
+_enum$4.inEnum = inEnum$4;
 
-var error$2 = {};
+var error$4 = {};
 
-error$2.isntError = error$2.isError = void 0;
-function isError$2(val) {
+error$4.isntError = error$4.isError = void 0;
+function isError$4(val) {
     return val instanceof Error;
 }
-error$2.isError = isError$2;
-function isntError$2(val) {
-    return !isError$2(val);
+error$4.isError = isError$4;
+function isntError$4(val) {
+    return !isError$4(val);
 }
-error$2.isntError = isntError$2;
+error$4.isntError = isntError$4;
 
-var falsy$2 = {};
+var falsy$4 = {};
 
-falsy$2.isntFalsy = falsy$2.isFalsy = void 0;
-function isFalsy$2(val) {
+falsy$4.isntFalsy = falsy$4.isFalsy = void 0;
+function isFalsy$4(val) {
     return !val;
 }
-falsy$2.isFalsy = isFalsy$2;
-function isntFalsy$2(val) {
-    return !isFalsy$2(val);
+falsy$4.isFalsy = isFalsy$4;
+function isntFalsy$4(val) {
+    return !isFalsy$4(val);
 }
-falsy$2.isntFalsy = isntFalsy$2;
+falsy$4.isntFalsy = isntFalsy$4;
 
-var iterable$2 = {};
+var iterable$4 = {};
 
-iterable$2.isntIterable = iterable$2.isIterable = void 0;
-const null_1$7 = _null$2;
-const undefined_1$4 = _undefined$2;
-const function_1$7 = _function$2;
-function isIterable$4(val) {
-    return (0, null_1$7.isntNull)(val)
-        && (0, undefined_1$4.isntUndefined)(val)
-        && (0, function_1$7.isFunction)(val[Symbol.iterator]);
+iterable$4.isntIterable = iterable$4.isIterable = void 0;
+const null_1$d = _null$4;
+const undefined_1$8 = _undefined$4;
+const function_1$d = _function$4;
+function isIterable$6(val) {
+    return (0, null_1$d.isntNull)(val)
+        && (0, undefined_1$8.isntUndefined)(val)
+        && (0, function_1$d.isFunction)(val[Symbol.iterator]);
 }
-iterable$2.isIterable = isIterable$4;
-function isntIterable$2(val) {
-    return !isIterable$4(val);
+iterable$4.isIterable = isIterable$6;
+function isntIterable$4(val) {
+    return !isIterable$6(val);
 }
-iterable$2.isntIterable = isntIterable$2;
+iterable$4.isntIterable = isntIterable$4;
 
-var json$2 = {};
+var json$4 = {};
 
-var number$2 = {};
+var number$4 = {};
 
-number$2.isntNaN = number$2.isNaN = number$2.isNegativeInfinity = number$2.isPositiveInfinity = number$2.isFinite = number$2.isntNumber = number$2.isNumber = void 0;
-function isNumber$2(val) {
+number$4.isntNaN = number$4.isNaN = number$4.isNegativeInfinity = number$4.isPositiveInfinity = number$4.isFinite = number$4.isntNumber = number$4.isNumber = void 0;
+function isNumber$4(val) {
     return typeof val === 'number';
 }
-number$2.isNumber = isNumber$2;
-function isntNumber$2(val) {
-    return !isNumber$2(val);
+number$4.isNumber = isNumber$4;
+function isntNumber$4(val) {
+    return !isNumber$4(val);
 }
-number$2.isntNumber = isntNumber$2;
-function isFinite$2(val) {
+number$4.isntNumber = isntNumber$4;
+function isFinite$4(val) {
     return Number.isFinite(val);
 }
-number$2.isFinite = isFinite$2;
-function isPositiveInfinity$2(val) {
+number$4.isFinite = isFinite$4;
+function isPositiveInfinity$4(val) {
     return val === Infinity;
 }
-number$2.isPositiveInfinity = isPositiveInfinity$2;
-function isNegativeInfinity$2(val) {
+number$4.isPositiveInfinity = isPositiveInfinity$4;
+function isNegativeInfinity$4(val) {
     return val === -Infinity;
 }
-number$2.isNegativeInfinity = isNegativeInfinity$2;
-function isNaN$3(val) {
+number$4.isNegativeInfinity = isNegativeInfinity$4;
+function isNaN$5(val) {
     return Number.isNaN(val);
 }
-number$2.isNaN = isNaN$3;
-function isntNaN$2(val) {
-    return !isNaN$3(val);
+number$4.isNaN = isNaN$5;
+function isntNaN$4(val) {
+    return !isNaN$5(val);
 }
-number$2.isntNaN = isntNaN$2;
+number$4.isntNaN = isntNaN$4;
 
-var object$2 = {};
+var object$4 = {};
 
 /** Detect free variable `global` from Node.js. */
 
@@ -471,7 +471,7 @@ var objectCtorString = funcToString.call(Object);
  * _.isPlainObject(Object.create(null));
  * // => true
  */
-function isPlainObject$3(value) {
+function isPlainObject$5(value) {
   if (!isObjectLike(value) || baseGetTag(value) != objectTag) {
     return false;
   }
@@ -484,59 +484,59 @@ function isPlainObject$3(value) {
     funcToString.call(Ctor) == objectCtorString;
 }
 
-var isPlainObject_1$3 = isPlainObject$3;
+var isPlainObject_1$5 = isPlainObject$5;
 
-var __importDefault$2 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+var __importDefault$4 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
-};object$2.isntEmptyObject = object$2.isEmptyObject = object$2.isntPlainObject = object$2.isPlainObject = object$2.isntObject = object$2.isObject = void 0;
-const isPlainObject_1$2 = __importDefault$2(isPlainObject_1$3);
-function isObject$2(val) {
+};object$4.isntEmptyObject = object$4.isEmptyObject = object$4.isntPlainObject = object$4.isPlainObject = object$4.isntObject = object$4.isObject = void 0;
+const isPlainObject_1$4 = __importDefault$4(isPlainObject_1$5);
+function isObject$4(val) {
     return val !== null
         && typeof val === 'object';
 }
-object$2.isObject = isObject$2;
-function isntObject$2(val) {
-    return !isObject$2(val);
+object$4.isObject = isObject$4;
+function isntObject$4(val) {
+    return !isObject$4(val);
 }
-object$2.isntObject = isntObject$2;
-function isPlainObject$2(val) {
-    return (0, isPlainObject_1$2.default)(val);
+object$4.isntObject = isntObject$4;
+function isPlainObject$4(val) {
+    return (0, isPlainObject_1$4.default)(val);
 }
-object$2.isPlainObject = isPlainObject$2;
-function isntPlainObject$2(val) {
-    return !isPlainObject$2(val);
+object$4.isPlainObject = isPlainObject$4;
+function isntPlainObject$4(val) {
+    return !isPlainObject$4(val);
 }
-object$2.isntPlainObject = isntPlainObject$2;
-function isEmptyObject$2(val) {
+object$4.isntPlainObject = isntPlainObject$4;
+function isEmptyObject$4(val) {
     return Object.keys(val).length === 0;
 }
-object$2.isEmptyObject = isEmptyObject$2;
-function isntEmptyObject$2(val) {
+object$4.isEmptyObject = isEmptyObject$4;
+function isntEmptyObject$4(val) {
     return Object.keys(val).length !== 0;
 }
-object$2.isntEmptyObject = isntEmptyObject$2;
-
-json$2.isntJsonable = json$2.isJsonable = json$2.isntJson = json$2.isJson = void 0;
-const null_1$6 = _null$2;
-const boolean_1$2 = boolean$2;
-const string_1$4 = string$2;
-const number_1$2 = number$2;
-const array_1$2 = array$2;
-const object_1$5 = object$2;
-function isJson$2(val) {
-    return (0, null_1$6.isNull)(val)
-        || (0, boolean_1$2.isBoolean)(val)
-        || (0, string_1$4.isString)(val)
-        || (0, number_1$2.isNumber)(val)
-        || ((0, array_1$2.isArray)(val) && val.every(isJson$2))
-        || ((0, object_1$5.isPlainObject)(val) && Object.values(val).every(isJson$2));
-}
-json$2.isJson = isJson$2;
-function isntJson$2(val) {
-    return !isJson$2(val);
-}
-json$2.isntJson = isntJson$2;
-function isJsonable$2(val) {
+object$4.isntEmptyObject = isntEmptyObject$4;
+
+json$4.isntJsonable = json$4.isJsonable = json$4.isntJson = json$4.isJson = void 0;
+const null_1$c = _null$4;
+const boolean_1$4 = boolean$4;
+const string_1$8 = string$4;
+const number_1$4 = number$4;
+const array_1$4 = array$5;
+const object_1$9 = object$4;
+function isJson$4(val) {
+    return (0, null_1$c.isNull)(val)
+        || (0, boolean_1$4.isBoolean)(val)
+        || (0, string_1$8.isString)(val)
+        || (0, number_1$4.isNumber)(val)
+        || ((0, array_1$4.isArray)(val) && val.every(isJson$4))
+        || ((0, object_1$9.isPlainObject)(val) && Object.values(val).every(isJson$4));
+}
+json$4.isJson = isJson$4;
+function isntJson$4(val) {
+    return !isJson$4(val);
+}
+json$4.isntJson = isntJson$4;
+function isJsonable$4(val) {
     try {
         JSON.stringify(val);
         return true;
@@ -545,39 +545,39 @@ function isJsonable$2(val) {
         return false;
     }
 }
-json$2.isJsonable = isJsonable$2;
-function isntJsonable$2(val) {
-    return !isntJsonable$2();
+json$4.isJsonable = isJsonable$4;
+function isntJsonable$4(val) {
+    return !isntJsonable$4();
 }
-json$2.isntJsonable = isntJsonable$2;
+json$4.isntJsonable = isntJsonable$4;
 
-var promise$2 = {};
+var promise$4 = {};
 
-promise$2.isPromiseLike = promise$2.isntPromiseLike = promise$2.isntPromise = promise$2.isPromise = void 0;
-const object_1$4 = object$2;
-const function_1$6 = _function$2;
-function isPromise$4(val) {
+promise$4.isPromiseLike = promise$4.isntPromiseLike = promise$4.isntPromise = promise$4.isPromise = void 0;
+const object_1$8 = object$4;
+const function_1$c = _function$4;
+function isPromise$6(val) {
     return val instanceof Promise;
 }
-promise$2.isPromise = isPromise$4;
-function isntPromise$2(val) {
-    return !isPromise$4(val);
+promise$4.isPromise = isPromise$6;
+function isntPromise$4(val) {
+    return !isPromise$6(val);
 }
-promise$2.isntPromise = isntPromise$2;
-function isntPromiseLike$2(val) {
-    return !isPromiseLike$2(val);
+promise$4.isntPromise = isntPromise$4;
+function isntPromiseLike$4(val) {
+    return !isPromiseLike$4(val);
 }
-promise$2.isntPromiseLike = isntPromiseLike$2;
-function isPromiseLike$2(val) {
-    return (0, object_1$4.isObject)(val)
-        && (0, function_1$6.isFunction)(val.then);
+promise$4.isntPromiseLike = isntPromiseLike$4;
+function isPromiseLike$4(val) {
+    return (0, object_1$8.isObject)(val)
+        && (0, function_1$c.isFunction)(val.then);
 }
-promise$2.isPromiseLike = isPromiseLike$2;
+promise$4.isPromiseLike = isPromiseLike$4;
 
-var url$2 = {};
+var url$4 = {};
 
-url$2.isAbsoluteURL = void 0;
-function isAbsoluteURL$2(str) {
+url$4.isAbsoluteURL = void 0;
+function isAbsoluteURL$4(str) {
     try {
         new URL(str);
         return true;
@@ -586,19 +586,31 @@ function isAbsoluteURL$2(str) {
         return false;
     }
 }
-url$2.isAbsoluteURL = isAbsoluteURL$2;
+url$4.isAbsoluteURL = isAbsoluteURL$4;
 
-var regexp$2 = {};
+var regexp$4 = {};
 
-regexp$2.isntRegExp = regexp$2.isRegExp = void 0;
-function isRegExp$2(val) {
+regexp$4.isntRegExp = regexp$4.isRegExp = void 0;
+function isRegExp$4(val) {
     return val instanceof RegExp;
 }
-regexp$2.isRegExp = isRegExp$2;
-function isntRegExp$2(val) {
-    return !isRegExp$2(val);
+regexp$4.isRegExp = isRegExp$4;
+function isntRegExp$4(val) {
+    return !isRegExp$4(val);
 }
-regexp$2.isntRegExp = isntRegExp$2;
+regexp$4.isntRegExp = isntRegExp$4;
+
+var symbol$1 = {};
+
+symbol$1.isntSymbol = symbol$1.isSymbol = void 0;
+function isSymbol$1(val) {
+    return typeof val === 'symbol';
+}
+symbol$1.isSymbol = isSymbol$1;
+function isntSymbol$1(val) {
+    return !isSymbol$1(val);
+}
+symbol$1.isntSymbol = isntSymbol$1;
 
 (function (exports) {
 	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -614,31 +626,32 @@ regexp$2.isntRegExp = isntRegExp$2;
 	}));
 	var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
 	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-	};__exportStar(array$2, exports);
-	__exportStar(asyncIterable$2, exports);
-	__exportStar(bigint$2, exports);
-	__exportStar(boolean$2, exports);
-	__exportStar(char$2, exports);
-	__exportStar(date$2, exports);
-	__exportStar(_enum$2, exports);
-	__exportStar(error$2, exports);
-	__exportStar(falsy$2, exports);
-	__exportStar(_function$2, exports);
-	__exportStar(iterable$2, exports);
-	__exportStar(json$2, exports);
-	__exportStar(_null$2, exports);
-	__exportStar(number$2, exports);
-	__exportStar(object$2, exports);
-	__exportStar(promise$2, exports);
-	__exportStar(string$2, exports);
-	__exportStar(_undefined$2, exports);
-	__exportStar(url$2, exports);
-	__exportStar(regexp$2, exports);
+	};__exportStar(array$5, exports);
+	__exportStar(asyncIterable$4, exports);
+	__exportStar(bigint$4, exports);
+	__exportStar(boolean$4, exports);
+	__exportStar(char$4, exports);
+	__exportStar(date$4, exports);
+	__exportStar(_enum$4, exports);
+	__exportStar(error$4, exports);
+	__exportStar(falsy$4, exports);
+	__exportStar(_function$4, exports);
+	__exportStar(iterable$4, exports);
+	__exportStar(json$4, exports);
+	__exportStar(_null$4, exports);
+	__exportStar(number$4, exports);
+	__exportStar(object$4, exports);
+	__exportStar(promise$4, exports);
+	__exportStar(string$4, exports);
+	__exportStar(_undefined$4, exports);
+	__exportStar(url$4, exports);
+	__exportStar(regexp$4, exports);
+	__exportStar(symbol$1, exports);
 	
-} (es2018$e));
+} (es2018$g));
 
 cons.convertArrayToCons = cons.convertConsToArray = void 0;
-const types_1$X = es2018$e;
+const types_1$X = es2018$g;
 function convertConsToArray([value, next]) {
     if ((0, types_1$X.isNull)(next)) {
         return [value];
@@ -653,6 +666,30 @@ function convertArrayToCons([value, ...next]) {
 }
 cons.convertArrayToCons = convertArrayToCons;
 
+var array$4 = {};
+
+array$4.truncateArrayRight = array$4.truncateArrayLeft = array$4.sliceArrayRight = array$4.sliceArrayLeft = void 0;
+function sliceArrayLeft(arr, num) {
+    return arr.slice(0, num);
+}
+array$4.sliceArrayLeft = sliceArrayLeft;
+function sliceArrayRight(arr, num) {
+    const startIndex = arr.length - num;
+    return arr.slice(startIndex >= 0 ? startIndex : 0);
+}
+array$4.sliceArrayRight = sliceArrayRight;
+function truncateArrayLeft(arr, num) {
+    if (arr.length > num) {
+        arr.length = num;
+    }
+}
+array$4.truncateArrayLeft = truncateArrayLeft;
+function truncateArrayRight(arr, num) {
+    const startIndex = arr.length - num;
+    arr.splice(0, startIndex);
+}
+array$4.truncateArrayRight = truncateArrayRight;
+
 var emitter = {};
 
 emitter.Emitter = void 0;
@@ -799,17 +836,17 @@ queue$1.Queue = Queue;
 
 var lruMap = {};
 
-var es2018$d = {};
+var es2018$f = {};
 
 var customError = {};
 
-var es2018$c = {};
+var es2018$e = {};
 
 var middleware$2 = {};
 
 var chunkAsync$4 = {};
 
-var es2018$b = {};
+var es2018$d = {};
 
 var go$1 = {};
 
@@ -838,11 +875,11 @@ goMicrotask$1.goMicrotask = goMicrotask;
 
 var goMacrotask$1 = {};
 
-var es2018$a = {};
+var es2018$c = {};
 
 var exponentialBackoff = {};
 
-var es2018$9 = {};
+var es2018$b = {};
 
 var random$1 = {};
 
@@ -886,10 +923,10 @@ randomIntInclusive$1.randomIntInclusive = randomIntInclusive;
 	__exportStar(randomInt$1, exports);
 	__exportStar(randomIntInclusive$1, exports);
 	
-} (es2018$9));
+} (es2018$b));
 
 exponentialBackoff.calculateExponentialBackoffTimeout = void 0;
-const extra_rand_1 = es2018$9;
+const extra_rand_1 = es2018$b;
 function calculateExponentialBackoffTimeout({ baseTimeout, retries, maxTimeout = Infinity, factor = 2, jitter = true }) {
     const timeout = Math.min(factor ** retries * baseTimeout, maxTimeout);
     if (jitter) {
@@ -1004,10 +1041,10 @@ setDynamicTimeoutLoop$1.setDynamicTimeoutLoop = setDynamicTimeoutLoop;
 	__exportStar(setTimeoutLoop$1, exports);
 	__exportStar(setDynamicTimeoutLoop$1, exports);
 	
-} (es2018$a));
+} (es2018$c));
 
 goMacrotask$1.goMacrotask = void 0;
-const extra_timers_1$2 = es2018$a;
+const extra_timers_1$2 = es2018$c;
 function goMacrotask(fn) {
     return new Promise((resolve, reject) => {
         (0, extra_timers_1$2.setImmediate)(async () => {
@@ -1040,7 +1077,7 @@ goMacrotask$1.goMacrotask = goMacrotask;
 	__exportStar(goMicrotask$1, exports);
 	__exportStar(goMacrotask$1, exports);
 	
-} (es2018$b));
+} (es2018$d));
 
 var hasRequiredChunkAsync;
 
@@ -1048,7 +1085,7 @@ function requireChunkAsync () {
 	if (hasRequiredChunkAsync) return chunkAsync$4;
 	hasRequiredChunkAsync = 1;
 chunkAsync$4.chunkAsync = void 0;
-	const go_1 = es2018$b;
+	const go_1 = es2018$d;
 	const errors_1 = requireEs2018();
 	function chunkAsync(iterable, size) {
 	    (0, errors_1.assert)(Number.isInteger(size), 'The parameter size must be an integer');
@@ -1073,9 +1110,382 @@ chunkAsync$4.chunkAsync = void 0;
 
 var chunkByAsync$5 = {};
 
-chunkByAsync$5.chunkByAsync = void 0;
-const types_1$W = es2018$e;
-function chunkByAsync$4(iterable, predicate) {
+var es2018$a = {};
+
+var array$3 = {};
+
+array$3.isntEmptyArray = array$3.isEmptyArray = array$3.isntArray = array$3.isArray = void 0;
+function isArray$6(val) {
+    return Array.isArray(val);
+}
+array$3.isArray = isArray$6;
+function isntArray$3(val) {
+    return !isArray$6(val);
+}
+array$3.isntArray = isntArray$3;
+function isEmptyArray$3(val) {
+    return val.length === 0;
+}
+array$3.isEmptyArray = isEmptyArray$3;
+function isntEmptyArray$3(val) {
+    return val.length !== 0;
+}
+array$3.isntEmptyArray = isntEmptyArray$3;
+
+var asyncIterable$3 = {};
+
+var _null$3 = {};
+
+_null$3.isntNull = _null$3.isNull = void 0;
+function isNull$3(val) {
+    return val === null;
+}
+_null$3.isNull = isNull$3;
+function isntNull$3(val) {
+    return !isNull$3(val);
+}
+_null$3.isntNull = isntNull$3;
+
+var _undefined$3 = {};
+
+_undefined$3.isntUndefined = _undefined$3.isUndefined = void 0;
+function isUndefined$3(val) {
+    return val === undefined;
+}
+_undefined$3.isUndefined = isUndefined$3;
+function isntUndefined$3(val) {
+    return !isUndefined$3(val);
+}
+_undefined$3.isntUndefined = isntUndefined$3;
+
+var _function$3 = {};
+
+_function$3.isntFunction = _function$3.isFunction = void 0;
+function isFunction$5(val) {
+    return typeof val === 'function';
+}
+_function$3.isFunction = isFunction$5;
+function isntFunction$3(val) {
+    return !isFunction$5(val);
+}
+_function$3.isntFunction = isntFunction$3;
+
+asyncIterable$3.isntAsyncIterable = asyncIterable$3.isAsyncIterable = void 0;
+const null_1$b = _null$3;
+const undefined_1$7 = _undefined$3;
+const function_1$b = _function$3;
+function isAsyncIterable$5(val) {
+    return (0, null_1$b.isntNull)(val)
+        && (0, undefined_1$7.isntUndefined)(val)
+        && (0, function_1$b.isFunction)(val[Symbol.asyncIterator]);
+}
+asyncIterable$3.isAsyncIterable = isAsyncIterable$5;
+function isntAsyncIterable$3(val) {
+    return !isAsyncIterable$5(val);
+}
+asyncIterable$3.isntAsyncIterable = isntAsyncIterable$3;
+
+var bigint$3 = {};
+
+bigint$3.isntBigInt = bigint$3.isBigInt = void 0;
+function isBigInt$3(val) {
+    return typeof val === 'bigint';
+}
+bigint$3.isBigInt = isBigInt$3;
+function isntBigInt$3(val) {
+    return !isBigInt$3(val);
+}
+bigint$3.isntBigInt = isntBigInt$3;
+
+var boolean$3 = {};
+
+boolean$3.isntBoolean = boolean$3.isBoolean = void 0;
+function isBoolean$3(val) {
+    return typeof val === 'boolean';
+}
+boolean$3.isBoolean = isBoolean$3;
+function isntBoolean$3(val) {
+    return !isBoolean$3(val);
+}
+boolean$3.isntBoolean = isntBoolean$3;
+
+var char$3 = {};
+
+var string$3 = {};
+
+string$3.isntString = string$3.isString = void 0;
+function isString$3(val) {
+    return typeof val === 'string';
+}
+string$3.isString = isString$3;
+function isntString$3(val) {
+    return !isString$3(val);
+}
+string$3.isntString = isntString$3;
+
+char$3.isntChar = char$3.isChar = void 0;
+const string_1$7 = string$3;
+function isChar$3(val) {
+    return (0, string_1$7.isString)(val)
+        && val.length === 1;
+}
+char$3.isChar = isChar$3;
+function isntChar$3(val) {
+    return !isChar$3(val);
+}
+char$3.isntChar = isntChar$3;
+
+var date$3 = {};
+
+date$3.isntDate = date$3.isDate = void 0;
+function isDate$4(val) {
+    return val instanceof Date;
+}
+date$3.isDate = isDate$4;
+function isntDate$3(val) {
+    return !isDate$4(val);
+}
+date$3.isntDate = isntDate$3;
+
+var _enum$3 = {};
+
+_enum$3.inEnum = void 0;
+function inEnum$3(val, _enum) {
+    return Object.values(_enum).includes(val);
+}
+_enum$3.inEnum = inEnum$3;
+
+var error$3 = {};
+
+error$3.isntError = error$3.isError = void 0;
+function isError$3(val) {
+    return val instanceof Error;
+}
+error$3.isError = isError$3;
+function isntError$3(val) {
+    return !isError$3(val);
+}
+error$3.isntError = isntError$3;
+
+var falsy$3 = {};
+
+falsy$3.isntFalsy = falsy$3.isFalsy = void 0;
+function isFalsy$3(val) {
+    return !val;
+}
+falsy$3.isFalsy = isFalsy$3;
+function isntFalsy$3(val) {
+    return !isFalsy$3(val);
+}
+falsy$3.isntFalsy = isntFalsy$3;
+
+var iterable$3 = {};
+
+iterable$3.isntIterable = iterable$3.isIterable = void 0;
+const null_1$a = _null$3;
+const undefined_1$6 = _undefined$3;
+const function_1$a = _function$3;
+function isIterable$5(val) {
+    return (0, null_1$a.isntNull)(val)
+        && (0, undefined_1$6.isntUndefined)(val)
+        && (0, function_1$a.isFunction)(val[Symbol.iterator]);
+}
+iterable$3.isIterable = isIterable$5;
+function isntIterable$3(val) {
+    return !isIterable$5(val);
+}
+iterable$3.isntIterable = isntIterable$3;
+
+var json$3 = {};
+
+var number$3 = {};
+
+number$3.isntNaN = number$3.isNaN = number$3.isNegativeInfinity = number$3.isPositiveInfinity = number$3.isFinite = number$3.isntNumber = number$3.isNumber = void 0;
+function isNumber$3(val) {
+    return typeof val === 'number';
+}
+number$3.isNumber = isNumber$3;
+function isntNumber$3(val) {
+    return !isNumber$3(val);
+}
+number$3.isntNumber = isntNumber$3;
+function isFinite$3(val) {
+    return Number.isFinite(val);
+}
+number$3.isFinite = isFinite$3;
+function isPositiveInfinity$3(val) {
+    return val === Infinity;
+}
+number$3.isPositiveInfinity = isPositiveInfinity$3;
+function isNegativeInfinity$3(val) {
+    return val === -Infinity;
+}
+number$3.isNegativeInfinity = isNegativeInfinity$3;
+function isNaN$4(val) {
+    return Number.isNaN(val);
+}
+number$3.isNaN = isNaN$4;
+function isntNaN$3(val) {
+    return !isNaN$4(val);
+}
+number$3.isntNaN = isntNaN$3;
+
+var object$3 = {};
+
+var __importDefault$3 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};object$3.isntEmptyObject = object$3.isEmptyObject = object$3.isntPlainObject = object$3.isPlainObject = object$3.isntObject = object$3.isObject = void 0;
+const isPlainObject_1$3 = __importDefault$3(isPlainObject_1$5);
+function isObject$3(val) {
+    return val !== null
+        && typeof val === 'object';
+}
+object$3.isObject = isObject$3;
+function isntObject$3(val) {
+    return !isObject$3(val);
+}
+object$3.isntObject = isntObject$3;
+function isPlainObject$3(val) {
+    return (0, isPlainObject_1$3.default)(val);
+}
+object$3.isPlainObject = isPlainObject$3;
+function isntPlainObject$3(val) {
+    return !isPlainObject$3(val);
+}
+object$3.isntPlainObject = isntPlainObject$3;
+function isEmptyObject$3(val) {
+    return Object.keys(val).length === 0;
+}
+object$3.isEmptyObject = isEmptyObject$3;
+function isntEmptyObject$3(val) {
+    return Object.keys(val).length !== 0;
+}
+object$3.isntEmptyObject = isntEmptyObject$3;
+
+json$3.isntJsonable = json$3.isJsonable = json$3.isntJson = json$3.isJson = void 0;
+const null_1$9 = _null$3;
+const boolean_1$3 = boolean$3;
+const string_1$6 = string$3;
+const number_1$3 = number$3;
+const array_1$3 = array$3;
+const object_1$7 = object$3;
+function isJson$3(val) {
+    return (0, null_1$9.isNull)(val)
+        || (0, boolean_1$3.isBoolean)(val)
+        || (0, string_1$6.isString)(val)
+        || (0, number_1$3.isNumber)(val)
+        || ((0, array_1$3.isArray)(val) && val.every(isJson$3))
+        || ((0, object_1$7.isPlainObject)(val) && Object.values(val).every(isJson$3));
+}
+json$3.isJson = isJson$3;
+function isntJson$3(val) {
+    return !isJson$3(val);
+}
+json$3.isntJson = isntJson$3;
+function isJsonable$3(val) {
+    try {
+        JSON.stringify(val);
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+json$3.isJsonable = isJsonable$3;
+function isntJsonable$3(val) {
+    return !isntJsonable$3();
+}
+json$3.isntJsonable = isntJsonable$3;
+
+var promise$3 = {};
+
+promise$3.isPromiseLike = promise$3.isntPromiseLike = promise$3.isntPromise = promise$3.isPromise = void 0;
+const object_1$6 = object$3;
+const function_1$9 = _function$3;
+function isPromise$5(val) {
+    return val instanceof Promise;
+}
+promise$3.isPromise = isPromise$5;
+function isntPromise$3(val) {
+    return !isPromise$5(val);
+}
+promise$3.isntPromise = isntPromise$3;
+function isntPromiseLike$3(val) {
+    return !isPromiseLike$3(val);
+}
+promise$3.isntPromiseLike = isntPromiseLike$3;
+function isPromiseLike$3(val) {
+    return (0, object_1$6.isObject)(val)
+        && (0, function_1$9.isFunction)(val.then);
+}
+promise$3.isPromiseLike = isPromiseLike$3;
+
+var url$3 = {};
+
+url$3.isAbsoluteURL = void 0;
+function isAbsoluteURL$3(str) {
+    try {
+        new URL(str);
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+url$3.isAbsoluteURL = isAbsoluteURL$3;
+
+var regexp$3 = {};
+
+regexp$3.isntRegExp = regexp$3.isRegExp = void 0;
+function isRegExp$3(val) {
+    return val instanceof RegExp;
+}
+regexp$3.isRegExp = isRegExp$3;
+function isntRegExp$3(val) {
+    return !isRegExp$3(val);
+}
+regexp$3.isntRegExp = isntRegExp$3;
+
+(function (exports) {
+	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    var desc = Object.getOwnPropertyDescriptor(m, k);
+	    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+	      desc = { enumerable: true, get: function() { return m[k]; } };
+	    }
+	    Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    o[k2] = m[k];
+	}));
+	var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
+	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+	};__exportStar(array$3, exports);
+	__exportStar(asyncIterable$3, exports);
+	__exportStar(bigint$3, exports);
+	__exportStar(boolean$3, exports);
+	__exportStar(char$3, exports);
+	__exportStar(date$3, exports);
+	__exportStar(_enum$3, exports);
+	__exportStar(error$3, exports);
+	__exportStar(falsy$3, exports);
+	__exportStar(_function$3, exports);
+	__exportStar(iterable$3, exports);
+	__exportStar(json$3, exports);
+	__exportStar(_null$3, exports);
+	__exportStar(number$3, exports);
+	__exportStar(object$3, exports);
+	__exportStar(promise$3, exports);
+	__exportStar(string$3, exports);
+	__exportStar(_undefined$3, exports);
+	__exportStar(url$3, exports);
+	__exportStar(regexp$3, exports);
+	
+} (es2018$a));
+
+chunkByAsync$5.chunkByAsync = void 0;
+const types_1$W = es2018$a;
+function chunkByAsync$4(iterable, predicate) {
     if ((0, types_1$W.isAsyncIterable)(iterable)) {
         return chunkByAsyncIterable$2(iterable, predicate);
     }
@@ -1140,7 +1550,7 @@ function requireChunk () {
 	if (hasRequiredChunk) return chunk$4;
 	hasRequiredChunk = 1;
 chunk$4.chunk = void 0;
-	const go_1 = es2018$b;
+	const go_1 = es2018$d;
 	const errors_1 = requireEs2018();
 	function chunk(iterable, size) {
 	    (0, errors_1.assert)(Number.isInteger(size), 'The parameter size must be an integer');
@@ -1166,8 +1576,8 @@ chunk$4.chunk = void 0;
 var concatAsync$5 = {};
 
 concatAsync$5.concatAsync = void 0;
-const types_1$V = es2018$e;
-const go_1$x = es2018$b;
+const types_1$V = es2018$a;
+const go_1$x = es2018$d;
 function concatAsync$4(iterable, ...otherIterables) {
     return (0, go_1$x.go)(async function* () {
         for (const iter of [iterable, ...otherIterables]) {
@@ -1189,7 +1599,7 @@ concatAsync$5.concatAsync = concatAsync$4;
 var concat$9 = {};
 
 concat$9.concat = void 0;
-const go_1$w = es2018$b;
+const go_1$w = es2018$d;
 function concat$8(iterable, ...otherIterables) {
     return (0, go_1$w.go)(function* () {
         for (const iter of [iterable, ...otherIterables]) {
@@ -1223,7 +1633,7 @@ function requireDropAsync () {
 	if (hasRequiredDropAsync) return dropAsync$4;
 	hasRequiredDropAsync = 1;
 dropAsync$4.dropAsync = void 0;
-	const go_1 = es2018$b;
+	const go_1 = es2018$d;
 	const utils_1 = utils$2;
 	const errors_1 = requireEs2018();
 	function dropAsync(iterable, count) {
@@ -1266,7 +1676,7 @@ function requireDropRightAsync () {
 	if (hasRequiredDropRightAsync) return dropRightAsync$4;
 	hasRequiredDropRightAsync = 1;
 dropRightAsync$4.dropRightAsync = void 0;
-	const go_1 = es2018$b;
+	const go_1 = es2018$d;
 	const utils_1 = utils$2;
 	const errors_1 = requireEs2018();
 	function dropRightAsync(iterable, count) {
@@ -1302,7 +1712,7 @@ function requireDropRight () {
 	if (hasRequiredDropRight) return dropRight$4;
 	hasRequiredDropRight = 1;
 dropRight$4.dropRight = void 0;
-	const go_1 = es2018$b;
+	const go_1 = es2018$d;
 	const utils_1 = utils$2;
 	const errors_1 = requireEs2018();
 	function dropRight(iterable, count) {
@@ -1323,7 +1733,7 @@ dropRight$4.dropRight = void 0;
 var dropUntilAsync$5 = {};
 
 dropUntilAsync$5.dropUntilAsync = void 0;
-const types_1$U = es2018$e;
+const types_1$U = es2018$a;
 function dropUntilAsync$4(iterable, predicate) {
     if ((0, types_1$U.isAsyncIterable)(iterable)) {
         return dropUntilAsyncIterable$2(iterable, predicate);
@@ -1410,7 +1820,7 @@ function requireDrop () {
 	if (hasRequiredDrop) return drop$4;
 	hasRequiredDrop = 1;
 drop$4.drop = void 0;
-	const go_1 = es2018$b;
+	const go_1 = es2018$d;
 	const utils_1 = utils$2;
 	const errors_1 = requireEs2018();
 	function drop(iterable, count) {
@@ -1448,7 +1858,7 @@ drop$4.drop = void 0;
 var filterAsync$5 = {};
 
 filterAsync$5.filterAsync = void 0;
-const types_1$T = es2018$e;
+const types_1$T = es2018$a;
 function filterAsync$4(iterable, predicate) {
     if ((0, types_1$T.isAsyncIterable)(iterable)) {
         return filterAsyncIterable$2(iterable, predicate);
@@ -1495,7 +1905,7 @@ var flattenDeepAsync$4 = {};
 var flattenByAsync$5 = {};
 
 flattenByAsync$5.flattenByAsync = void 0;
-const types_1$S = es2018$e;
+const types_1$S = es2018$a;
 function flattenByAsync$4(iterable, predicate) {
     if ((0, types_1$S.isAsyncIterable)(iterable)) {
         return flattenByAsyncIterable$2(iterable, predicate);
@@ -1569,7 +1979,7 @@ flattenAsync$4.flattenAsync = void 0;
 var flattenBy$5 = {};
 
 flattenBy$5.flattenBy = void 0;
-const types_1$R = es2018$e;
+const types_1$R = es2018$a;
 function flattenBy$4(iterable, predicate) {
     return flatten$9(iterable, predicate, 1);
 }
@@ -1628,7 +2038,7 @@ flatten$8.flatten = void 0;
 var mapAsync$5 = {};
 
 mapAsync$5.mapAsync = void 0;
-const types_1$Q = es2018$e;
+const types_1$Q = es2018$a;
 function mapAsync$4(iterable, fn) {
     if ((0, types_1$Q.isAsyncIterable)(iterable)) {
         return mapAsyncIterable$2(iterable, fn);
@@ -1673,7 +2083,7 @@ function requireRepeatAsync () {
 	if (hasRequiredRepeatAsync) return repeatAsync$4;
 	hasRequiredRepeatAsync = 1;
 repeatAsync$4.repeatAsync = void 0;
-	const go_1 = es2018$b;
+	const go_1 = es2018$d;
 	const errors_1 = requireEs2018();
 	function repeatAsync(iterable, times) {
 	    (0, errors_1.assert)(times === Infinity || Number.isInteger(times), 'The parameter times must be an integer');
@@ -1716,7 +2126,7 @@ function requireRepeat () {
 	if (hasRequiredRepeat) return repeat$6;
 	hasRequiredRepeat = 1;
 repeat$6.repeat = void 0;
-	const go_1 = es2018$b;
+	const go_1 = es2018$d;
 	const errors_1 = requireEs2018();
 	function repeat(iterable, times) {
 	    (0, errors_1.assert)(times === Infinity || Number.isInteger(times), 'The parameter times must be an integer');
@@ -1759,7 +2169,7 @@ function requireSliceAsync () {
 	if (hasRequiredSliceAsync) return sliceAsync$4;
 	hasRequiredSliceAsync = 1;
 sliceAsync$4.sliceAsync = void 0;
-	const go_1 = es2018$b;
+	const go_1 = es2018$d;
 	const errors_1 = requireEs2018();
 	function sliceAsync(iterable, start, end = Infinity) {
 	    (0, errors_1.assert)(Number.isInteger(start), 'The parameter start must be an integer');
@@ -1790,7 +2200,7 @@ function requireSlice () {
 	if (hasRequiredSlice) return slice$4;
 	hasRequiredSlice = 1;
 slice$4.slice = void 0;
-	const go_1 = es2018$b;
+	const go_1 = es2018$d;
 	const errors_1 = requireEs2018();
 	function slice(iterable, start, end = Infinity) {
 	    (0, errors_1.assert)(Number.isInteger(start), 'The parameter start must be an integer');
@@ -1834,7 +2244,7 @@ splitAsync$5.splitAsync = splitAsync$4;
 var splitByAsync$5 = {};
 
 splitByAsync$5.splitByAsync = void 0;
-const types_1$P = es2018$e;
+const types_1$P = es2018$a;
 function splitByAsync$4(iterable, predicate) {
     if ((0, types_1$P.isAsyncIterable)(iterable)) {
         return splitByAsyncIterable$2(iterable, predicate);
@@ -1921,7 +2331,7 @@ function requireTakeAsync () {
 	if (hasRequiredTakeAsync) return takeAsync$4;
 	hasRequiredTakeAsync = 1;
 takeAsync$4.takeAsync = void 0;
-	const go_1 = es2018$b;
+	const go_1 = es2018$d;
 	const errors_1 = requireEs2018();
 	function takeAsync(iterable, count) {
 	    (0, errors_1.assert)(Number.isInteger(count), 'The parameter count must be an integer');
@@ -1950,7 +2360,7 @@ function requireTakeRightAsync () {
 	if (hasRequiredTakeRightAsync) return takeRightAsync$4;
 	hasRequiredTakeRightAsync = 1;
 takeRightAsync$4.takeRightAsync = void 0;
-	const go_1 = es2018$b;
+	const go_1 = es2018$d;
 	const errors_1 = requireEs2018();
 	function takeRightAsync(iterable, count) {
 	    (0, errors_1.assert)(Number.isInteger(count), 'The parameter count must be an integer');
@@ -1988,7 +2398,7 @@ function requireTakeRight () {
 	if (hasRequiredTakeRight) return takeRight$4;
 	hasRequiredTakeRight = 1;
 takeRight$4.takeRight = void 0;
-	const go_1 = es2018$b;
+	const go_1 = es2018$d;
 	const errors_1 = requireEs2018();
 	function takeRight(iterable, count) {
 	    (0, errors_1.assert)(Number.isInteger(count), 'The parameter count must be an integer');
@@ -2021,7 +2431,7 @@ takeRight$4.takeRight = void 0;
 var takeUntilAsync$5 = {};
 
 takeUntilAsync$5.takeUntilAsync = void 0;
-const types_1$O = es2018$e;
+const types_1$O = es2018$a;
 function takeUntilAsync$4(iterable, predicate) {
     if ((0, types_1$O.isAsyncIterable)(iterable)) {
         return takeUntilAsyncIterable$2(iterable, predicate);
@@ -2072,7 +2482,7 @@ function requireTake () {
 	if (hasRequiredTake) return take$6;
 	hasRequiredTake = 1;
 take$6.take = void 0;
-	const go_1 = es2018$b;
+	const go_1 = es2018$d;
 	const errors_1 = requireEs2018();
 	function take(iterable, count) {
 	    (0, errors_1.assert)(Number.isInteger(count), 'The parameter count must be an integer');
@@ -2096,7 +2506,7 @@ take$6.take = void 0;
 var tapAsync$5 = {};
 
 tapAsync$5.tapAsync = void 0;
-const types_1$N = es2018$e;
+const types_1$N = es2018$a;
 function tapAsync$4(iterable, fn) {
     if ((0, types_1$N.isAsyncIterable)(iterable)) {
         return tapAsyncIterable$2(iterable, fn);
@@ -2179,7 +2589,7 @@ uniqAsync$5.uniqAsync = uniqAsync$4;
 var uniqByAsync$5 = {};
 
 uniqByAsync$5.uniqByAsync = void 0;
-const types_1$M = es2018$e;
+const types_1$M = es2018$a;
 function uniqByAsync$4(iterable, fn) {
     if ((0, types_1$M.isAsyncIterable)(iterable)) {
         return uniqByAsyncIterable$2(iterable, fn);
@@ -2248,7 +2658,7 @@ uniq$5.uniq = uniq$4;
 var zipAsync$5 = {};
 
 zipAsync$5.zipAsync = void 0;
-const types_1$L = es2018$e;
+const types_1$L = es2018$a;
 var Kind$2;
 (function (Kind) {
     Kind[Kind["Sync"] = 0] = "Sync";
@@ -2419,7 +2829,7 @@ consume$5.consume = consume$4;
 var eachAsync$5 = {};
 
 eachAsync$5.eachAsync = void 0;
-const types_1$K = es2018$e;
+const types_1$K = es2018$a;
 function eachAsync$4(iterable, fn) {
     if ((0, types_1$K.isAsyncIterable)(iterable)) {
         return eachAsyncIterable$2(iterable, fn);
@@ -2459,7 +2869,7 @@ each$5.each = each$4;
 var everyAsync$5 = {};
 
 everyAsync$5.everyAsync = void 0;
-const types_1$J = es2018$e;
+const types_1$J = es2018$a;
 function everyAsync$4(iterable, predicate) {
     if ((0, types_1$J.isAsyncIterable)(iterable)) {
         return everyAsyncIterable$2(iterable, predicate);
@@ -2505,7 +2915,7 @@ every$7.every = every$6;
 var findAsync$5 = {};
 
 findAsync$5.findAsync = void 0;
-const types_1$I = es2018$e;
+const types_1$I = es2018$a;
 function findAsync$4(iterable, predicate) {
     if ((0, types_1$I.isAsyncIterable)(iterable)) {
         return findAsyncIterable$2(iterable, predicate);
@@ -2629,7 +3039,7 @@ match$5.match = match$4;
 var reduceAsync$5 = {};
 
 reduceAsync$5.reduceAsync = void 0;
-const types_1$H = es2018$e;
+const types_1$H = es2018$a;
 function reduceAsync$4(iterable, fn, initialValue) {
     if ((0, types_1$H.isUndefined)(initialValue)) {
         return reduceAsyncWithoutInitialValue$2(iterable, fn);
@@ -2725,7 +3135,7 @@ function reduceAsyncWithoutInitialValue$2(iterable, fn) {
 var reduce$7 = {};
 
 reduce$7.reduce = void 0;
-const types_1$G = es2018$e;
+const types_1$G = es2018$a;
 function reduce$6(iterable, fn, initialValue) {
     if ((0, types_1$G.isUndefined)(initialValue)) {
         return reduceWithoutInitialValue$2(iterable, fn);
@@ -2772,7 +3182,7 @@ function reduceWithoutInitialValue$2(iterable, fn) {
 var someAsync$5 = {};
 
 someAsync$5.someAsync = void 0;
-const types_1$F = es2018$e;
+const types_1$F = es2018$a;
 function someAsync$4(iterable, predicate) {
     if ((0, types_1$F.isAsyncIterable)(iterable)) {
         return someAsyncIterable$2(iterable, predicate);
@@ -3012,7 +3422,7 @@ groupByAsync$5.groupByAsync = groupByAsync$4;
 var hasRequiredEs2018$1;
 
 function requireEs2018$1 () {
-	if (hasRequiredEs2018$1) return es2018$c;
+	if (hasRequiredEs2018$1) return es2018$e;
 	hasRequiredEs2018$1 = 1;
 	(function (exports) {
 		var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -3031,8 +3441,8 @@ function requireEs2018$1 () {
 		};__exportStar(requireMiddleware(), exports);
 		__exportStar(output$2, exports);
 		
-} (es2018$c));
-	return es2018$c;
+} (es2018$e));
+	return es2018$e;
 }
 
 var getErrorNames$1 = {};
@@ -3051,7 +3461,7 @@ function* traverseErrorPrototypeChain(err) {
 traverseErrorPrototypeChain$1.traverseErrorPrototypeChain = traverseErrorPrototypeChain;
 
 getErrorNames$1.getErrorNames = void 0;
-const types_1$E = es2018$e;
+const types_1$E = es2018$a;
 const traverse_error_prototype_chain_1 = traverseErrorPrototypeChain$1;
 function* getErrorNames(err) {
     var _a;
@@ -3072,7 +3482,7 @@ getErrorNames$1.getErrorNames = getErrorNames;
 var serializableError = {};
 
 serializableError.isSerializableError = void 0;
-const types_1$D = es2018$e;
+const types_1$D = es2018$a;
 function isSerializableError(val) {
     return (0, types_1$D.isObject)(val)
         && (0, types_1$D.isString)(val.name)
@@ -3090,7 +3500,7 @@ function requireCustomError () {
 customError.CustomError = void 0;
 	const iterable_operator_1 = requireEs2018$1();
 	const get_error_names_1 = getErrorNames$1;
-	const types_1 = es2018$e;
+	const types_1 = es2018$a;
 	const serializable_error_1 = serializableError;
 	class CustomError extends Error {
 	    get name() {
@@ -3116,179 +3526,552 @@ customError.CustomError = void 0;
 	
 	return customError;
 }
-
-var assertionError = {};
-
-var hasRequiredAssertionError;
-
-function requireAssertionError () {
-	if (hasRequiredAssertionError) return assertionError;
-	hasRequiredAssertionError = 1;
-assertionError.AssertionError = void 0;
-	const custom_error_1 = requireCustomError();
-	class AssertionError extends custom_error_1.CustomError {
-	}
-	assertionError.AssertionError = AssertionError;
-	
-	return assertionError;
+
+var assertionError = {};
+
+var hasRequiredAssertionError;
+
+function requireAssertionError () {
+	if (hasRequiredAssertionError) return assertionError;
+	hasRequiredAssertionError = 1;
+assertionError.AssertionError = void 0;
+	const custom_error_1 = requireCustomError();
+	class AssertionError extends custom_error_1.CustomError {
+	}
+	assertionError.AssertionError = AssertionError;
+	
+	return assertionError;
+}
+
+var normalize = {};
+
+var hasRequiredNormalize;
+
+function requireNormalize () {
+	if (hasRequiredNormalize) return normalize;
+	hasRequiredNormalize = 1;
+normalize.normalize = void 0;
+	const get_error_names_1 = getErrorNames$1;
+	const iterable_operator_1 = requireEs2018$1();
+	function normalize$1(err) {
+	    var _a;
+	    const [name, ...ancestors] = (0, iterable_operator_1.toArray)((0, get_error_names_1.getErrorNames)(err));
+	    return {
+	        name,
+	        ancestors,
+	        message: err.message,
+	        stack: (_a = err.stack) !== null && _a !== void 0 ? _a : null
+	    };
+	}
+	normalize.normalize = normalize$1;
+	
+	return normalize;
+}
+
+var hydrate$1 = {};
+
+var es2018$9 = {};
+
+var pass$3 = {};
+
+pass$3.pass = void 0;
+function pass$2() { }
+pass$3.pass = pass$2;
+
+(function (exports) {
+	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+	}) : (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    o[k2] = m[k];
+	}));
+	var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
+	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+	};__exportStar(pass$3, exports);
+	
+} (es2018$9));
+
+hydrate$1.hydrate = void 0;
+const pass_1 = es2018$9;
+function hydrate(err) {
+    var _a;
+    const errorNames = [err.name, ...err.ancestors]
+        .slice(0, -1)
+        .reverse();
+    let errorConstructor = Error;
+    for (const name of errorNames) {
+        errorConstructor = createChildErrorConstructor(errorConstructor, name);
+    }
+    const result = new errorConstructor();
+    result.name = err.name;
+    result.message = err.message;
+    result.stack = (_a = err.stack) !== null && _a !== void 0 ? _a : undefined;
+    return result;
+}
+hydrate$1.hydrate = hydrate;
+function createChildErrorConstructor(parentErrorConstructor, name) {
+    const constructor = function () { (0, pass_1.pass)(); };
+    constructor.prototype = Object.create(parentErrorConstructor.prototype);
+    constructor.prototype.constructor = constructor;
+    Object.defineProperty(constructor, 'name', { value: name });
+    return constructor;
+}
+
+var assert = {};
+
+var hasRequiredAssert;
+
+function requireAssert () {
+	if (hasRequiredAssert) return assert;
+	hasRequiredAssert = 1;
+assert.assert = void 0;
+	const assertion_error_1 = requireAssertionError();
+	function assert$1(condition, message) {
+	    if (!condition)
+	        throw new assertion_error_1.AssertionError(message);
+	}
+	assert.assert = assert$1;
+	
+	return assert;
+}
+
+var hasRequiredEs2018;
+
+function requireEs2018 () {
+	if (hasRequiredEs2018) return es2018$f;
+	hasRequiredEs2018 = 1;
+	(function (exports) {
+		var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    var desc = Object.getOwnPropertyDescriptor(m, k);
+		    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+		      desc = { enumerable: true, get: function() { return m[k]; } };
+		    }
+		    Object.defineProperty(o, k2, desc);
+		}) : (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    o[k2] = m[k];
+		}));
+		var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
+		    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+		};__exportStar(requireCustomError(), exports);
+		__exportStar(requireAssertionError(), exports);
+		__exportStar(serializableError, exports);
+		__exportStar(requireNormalize(), exports);
+		__exportStar(hydrate$1, exports);
+		__exportStar(requireAssert(), exports);
+		__exportStar(getErrorNames$1, exports);
+		__exportStar(traverseErrorPrototypeChain$1, exports);
+		
+} (es2018$f));
+	return es2018$f;
+}
+
+var es2018$8 = {};
+
+var middleware$1 = {};
+
+var chunkAsync$3 = {};
+
+chunkAsync$3.chunkAsync = void 0;
+const go_1$v = es2018$d;
+const errors_1$C = requireEs2018();
+function chunkAsync$2(iterable, size) {
+    (0, errors_1$C.assert)(Number.isInteger(size), 'The parameter size must be an integer');
+    (0, errors_1$C.assert)(size > 0, 'The parameter size must be greater than 0');
+    return (0, go_1$v.go)(async function* () {
+        let buffer = [];
+        for await (const element of iterable) {
+            buffer.push(element);
+            if (buffer.length >= size) {
+                yield buffer;
+                buffer = [];
+            }
+        }
+        if (buffer.length)
+            yield buffer;
+    });
+}
+chunkAsync$3.chunkAsync = chunkAsync$2;
+
+var chunkByAsync$3 = {};
+
+var es2018$7 = {};
+
+var array$2 = {};
+
+array$2.isntEmptyArray = array$2.isEmptyArray = array$2.isntArray = array$2.isArray = void 0;
+function isArray$5(val) {
+    return Array.isArray(val);
+}
+array$2.isArray = isArray$5;
+function isntArray$2(val) {
+    return !isArray$5(val);
+}
+array$2.isntArray = isntArray$2;
+function isEmptyArray$2(val) {
+    return val.length === 0;
+}
+array$2.isEmptyArray = isEmptyArray$2;
+function isntEmptyArray$2(val) {
+    return val.length !== 0;
+}
+array$2.isntEmptyArray = isntEmptyArray$2;
+
+var asyncIterable$2 = {};
+
+var _null$2 = {};
+
+_null$2.isntNull = _null$2.isNull = void 0;
+function isNull$2(val) {
+    return val === null;
+}
+_null$2.isNull = isNull$2;
+function isntNull$2(val) {
+    return !isNull$2(val);
+}
+_null$2.isntNull = isntNull$2;
+
+var _undefined$2 = {};
+
+_undefined$2.isntUndefined = _undefined$2.isUndefined = void 0;
+function isUndefined$2(val) {
+    return val === undefined;
+}
+_undefined$2.isUndefined = isUndefined$2;
+function isntUndefined$2(val) {
+    return !isUndefined$2(val);
+}
+_undefined$2.isntUndefined = isntUndefined$2;
+
+var _function$2 = {};
+
+_function$2.isntFunction = _function$2.isFunction = void 0;
+function isFunction$4(val) {
+    return typeof val === 'function';
+}
+_function$2.isFunction = isFunction$4;
+function isntFunction$2(val) {
+    return !isFunction$4(val);
+}
+_function$2.isntFunction = isntFunction$2;
+
+asyncIterable$2.isntAsyncIterable = asyncIterable$2.isAsyncIterable = void 0;
+const null_1$8 = _null$2;
+const undefined_1$5 = _undefined$2;
+const function_1$8 = _function$2;
+function isAsyncIterable$4(val) {
+    return (0, null_1$8.isntNull)(val)
+        && (0, undefined_1$5.isntUndefined)(val)
+        && (0, function_1$8.isFunction)(val[Symbol.asyncIterator]);
+}
+asyncIterable$2.isAsyncIterable = isAsyncIterable$4;
+function isntAsyncIterable$2(val) {
+    return !isAsyncIterable$4(val);
+}
+asyncIterable$2.isntAsyncIterable = isntAsyncIterable$2;
+
+var bigint$2 = {};
+
+bigint$2.isntBigInt = bigint$2.isBigInt = void 0;
+function isBigInt$2(val) {
+    return typeof val === 'bigint';
+}
+bigint$2.isBigInt = isBigInt$2;
+function isntBigInt$2(val) {
+    return !isBigInt$2(val);
+}
+bigint$2.isntBigInt = isntBigInt$2;
+
+var boolean$2 = {};
+
+boolean$2.isntBoolean = boolean$2.isBoolean = void 0;
+function isBoolean$2(val) {
+    return typeof val === 'boolean';
+}
+boolean$2.isBoolean = isBoolean$2;
+function isntBoolean$2(val) {
+    return !isBoolean$2(val);
+}
+boolean$2.isntBoolean = isntBoolean$2;
+
+var char$2 = {};
+
+var string$2 = {};
+
+string$2.isntString = string$2.isString = void 0;
+function isString$2(val) {
+    return typeof val === 'string';
+}
+string$2.isString = isString$2;
+function isntString$2(val) {
+    return !isString$2(val);
+}
+string$2.isntString = isntString$2;
+
+char$2.isntChar = char$2.isChar = void 0;
+const string_1$5 = string$2;
+function isChar$2(val) {
+    return (0, string_1$5.isString)(val)
+        && val.length === 1;
+}
+char$2.isChar = isChar$2;
+function isntChar$2(val) {
+    return !isChar$2(val);
+}
+char$2.isntChar = isntChar$2;
+
+var date$2 = {};
+
+date$2.isntDate = date$2.isDate = void 0;
+function isDate$3(val) {
+    return val instanceof Date;
+}
+date$2.isDate = isDate$3;
+function isntDate$2(val) {
+    return !isDate$3(val);
+}
+date$2.isntDate = isntDate$2;
+
+var _enum$2 = {};
+
+_enum$2.inEnum = void 0;
+function inEnum$2(val, _enum) {
+    return Object.values(_enum).includes(val);
+}
+_enum$2.inEnum = inEnum$2;
+
+var error$2 = {};
+
+error$2.isntError = error$2.isError = void 0;
+function isError$2(val) {
+    return val instanceof Error;
+}
+error$2.isError = isError$2;
+function isntError$2(val) {
+    return !isError$2(val);
+}
+error$2.isntError = isntError$2;
+
+var falsy$2 = {};
+
+falsy$2.isntFalsy = falsy$2.isFalsy = void 0;
+function isFalsy$2(val) {
+    return !val;
+}
+falsy$2.isFalsy = isFalsy$2;
+function isntFalsy$2(val) {
+    return !isFalsy$2(val);
+}
+falsy$2.isntFalsy = isntFalsy$2;
+
+var iterable$2 = {};
+
+iterable$2.isntIterable = iterable$2.isIterable = void 0;
+const null_1$7 = _null$2;
+const undefined_1$4 = _undefined$2;
+const function_1$7 = _function$2;
+function isIterable$4(val) {
+    return (0, null_1$7.isntNull)(val)
+        && (0, undefined_1$4.isntUndefined)(val)
+        && (0, function_1$7.isFunction)(val[Symbol.iterator]);
+}
+iterable$2.isIterable = isIterable$4;
+function isntIterable$2(val) {
+    return !isIterable$4(val);
+}
+iterable$2.isntIterable = isntIterable$2;
+
+var json$2 = {};
+
+var number$2 = {};
+
+number$2.isntNaN = number$2.isNaN = number$2.isNegativeInfinity = number$2.isPositiveInfinity = number$2.isFinite = number$2.isntNumber = number$2.isNumber = void 0;
+function isNumber$2(val) {
+    return typeof val === 'number';
+}
+number$2.isNumber = isNumber$2;
+function isntNumber$2(val) {
+    return !isNumber$2(val);
+}
+number$2.isntNumber = isntNumber$2;
+function isFinite$2(val) {
+    return Number.isFinite(val);
+}
+number$2.isFinite = isFinite$2;
+function isPositiveInfinity$2(val) {
+    return val === Infinity;
+}
+number$2.isPositiveInfinity = isPositiveInfinity$2;
+function isNegativeInfinity$2(val) {
+    return val === -Infinity;
+}
+number$2.isNegativeInfinity = isNegativeInfinity$2;
+function isNaN$3(val) {
+    return Number.isNaN(val);
+}
+number$2.isNaN = isNaN$3;
+function isntNaN$2(val) {
+    return !isNaN$3(val);
+}
+number$2.isntNaN = isntNaN$2;
+
+var object$2 = {};
+
+var __importDefault$2 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};object$2.isntEmptyObject = object$2.isEmptyObject = object$2.isntPlainObject = object$2.isPlainObject = object$2.isntObject = object$2.isObject = void 0;
+const isPlainObject_1$2 = __importDefault$2(isPlainObject_1$5);
+function isObject$2(val) {
+    return val !== null
+        && typeof val === 'object';
+}
+object$2.isObject = isObject$2;
+function isntObject$2(val) {
+    return !isObject$2(val);
+}
+object$2.isntObject = isntObject$2;
+function isPlainObject$2(val) {
+    return (0, isPlainObject_1$2.default)(val);
+}
+object$2.isPlainObject = isPlainObject$2;
+function isntPlainObject$2(val) {
+    return !isPlainObject$2(val);
+}
+object$2.isntPlainObject = isntPlainObject$2;
+function isEmptyObject$2(val) {
+    return Object.keys(val).length === 0;
+}
+object$2.isEmptyObject = isEmptyObject$2;
+function isntEmptyObject$2(val) {
+    return Object.keys(val).length !== 0;
+}
+object$2.isntEmptyObject = isntEmptyObject$2;
+
+json$2.isntJsonable = json$2.isJsonable = json$2.isntJson = json$2.isJson = void 0;
+const null_1$6 = _null$2;
+const boolean_1$2 = boolean$2;
+const string_1$4 = string$2;
+const number_1$2 = number$2;
+const array_1$2 = array$2;
+const object_1$5 = object$2;
+function isJson$2(val) {
+    return (0, null_1$6.isNull)(val)
+        || (0, boolean_1$2.isBoolean)(val)
+        || (0, string_1$4.isString)(val)
+        || (0, number_1$2.isNumber)(val)
+        || ((0, array_1$2.isArray)(val) && val.every(isJson$2))
+        || ((0, object_1$5.isPlainObject)(val) && Object.values(val).every(isJson$2));
+}
+json$2.isJson = isJson$2;
+function isntJson$2(val) {
+    return !isJson$2(val);
+}
+json$2.isntJson = isntJson$2;
+function isJsonable$2(val) {
+    try {
+        JSON.stringify(val);
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+json$2.isJsonable = isJsonable$2;
+function isntJsonable$2(val) {
+    return !isntJsonable$2();
 }
+json$2.isntJsonable = isntJsonable$2;
 
-var normalize = {};
-
-var hasRequiredNormalize;
+var promise$2 = {};
 
-function requireNormalize () {
-	if (hasRequiredNormalize) return normalize;
-	hasRequiredNormalize = 1;
-normalize.normalize = void 0;
-	const get_error_names_1 = getErrorNames$1;
-	const iterable_operator_1 = requireEs2018$1();
-	function normalize$1(err) {
-	    var _a;
-	    const [name, ...ancestors] = (0, iterable_operator_1.toArray)((0, get_error_names_1.getErrorNames)(err));
-	    return {
-	        name,
-	        ancestors,
-	        message: err.message,
-	        stack: (_a = err.stack) !== null && _a !== void 0 ? _a : null
-	    };
-	}
-	normalize.normalize = normalize$1;
-	
-	return normalize;
+promise$2.isPromiseLike = promise$2.isntPromiseLike = promise$2.isntPromise = promise$2.isPromise = void 0;
+const object_1$4 = object$2;
+const function_1$6 = _function$2;
+function isPromise$4(val) {
+    return val instanceof Promise;
+}
+promise$2.isPromise = isPromise$4;
+function isntPromise$2(val) {
+    return !isPromise$4(val);
+}
+promise$2.isntPromise = isntPromise$2;
+function isntPromiseLike$2(val) {
+    return !isPromiseLike$2(val);
+}
+promise$2.isntPromiseLike = isntPromiseLike$2;
+function isPromiseLike$2(val) {
+    return (0, object_1$4.isObject)(val)
+        && (0, function_1$6.isFunction)(val.then);
 }
+promise$2.isPromiseLike = isPromiseLike$2;
 
-var hydrate$1 = {};
+var url$2 = {};
 
-var es2018$8 = {};
+url$2.isAbsoluteURL = void 0;
+function isAbsoluteURL$2(str) {
+    try {
+        new URL(str);
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+url$2.isAbsoluteURL = isAbsoluteURL$2;
 
-var pass$3 = {};
+var regexp$2 = {};
 
-pass$3.pass = void 0;
-function pass$2() { }
-pass$3.pass = pass$2;
+regexp$2.isntRegExp = regexp$2.isRegExp = void 0;
+function isRegExp$2(val) {
+    return val instanceof RegExp;
+}
+regexp$2.isRegExp = isRegExp$2;
+function isntRegExp$2(val) {
+    return !isRegExp$2(val);
+}
+regexp$2.isntRegExp = isntRegExp$2;
 
 (function (exports) {
 	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
 	    if (k2 === undefined) k2 = k;
-	    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+	    var desc = Object.getOwnPropertyDescriptor(m, k);
+	    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+	      desc = { enumerable: true, get: function() { return m[k]; } };
+	    }
+	    Object.defineProperty(o, k2, desc);
 	}) : (function(o, m, k, k2) {
 	    if (k2 === undefined) k2 = k;
 	    o[k2] = m[k];
 	}));
 	var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
 	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-	};__exportStar(pass$3, exports);
-	
-} (es2018$8));
-
-hydrate$1.hydrate = void 0;
-const pass_1 = es2018$8;
-function hydrate(err) {
-    var _a;
-    const errorNames = [err.name, ...err.ancestors]
-        .slice(0, -1)
-        .reverse();
-    let errorConstructor = Error;
-    for (const name of errorNames) {
-        errorConstructor = createChildErrorConstructor(errorConstructor, name);
-    }
-    const result = new errorConstructor();
-    result.name = err.name;
-    result.message = err.message;
-    result.stack = (_a = err.stack) !== null && _a !== void 0 ? _a : undefined;
-    return result;
-}
-hydrate$1.hydrate = hydrate;
-function createChildErrorConstructor(parentErrorConstructor, name) {
-    const constructor = function () { (0, pass_1.pass)(); };
-    constructor.prototype = Object.create(parentErrorConstructor.prototype);
-    constructor.prototype.constructor = constructor;
-    Object.defineProperty(constructor, 'name', { value: name });
-    return constructor;
-}
-
-var assert = {};
-
-var hasRequiredAssert;
-
-function requireAssert () {
-	if (hasRequiredAssert) return assert;
-	hasRequiredAssert = 1;
-assert.assert = void 0;
-	const assertion_error_1 = requireAssertionError();
-	function assert$1(condition, message) {
-	    if (!condition)
-	        throw new assertion_error_1.AssertionError(message);
-	}
-	assert.assert = assert$1;
+	};__exportStar(array$2, exports);
+	__exportStar(asyncIterable$2, exports);
+	__exportStar(bigint$2, exports);
+	__exportStar(boolean$2, exports);
+	__exportStar(char$2, exports);
+	__exportStar(date$2, exports);
+	__exportStar(_enum$2, exports);
+	__exportStar(error$2, exports);
+	__exportStar(falsy$2, exports);
+	__exportStar(_function$2, exports);
+	__exportStar(iterable$2, exports);
+	__exportStar(json$2, exports);
+	__exportStar(_null$2, exports);
+	__exportStar(number$2, exports);
+	__exportStar(object$2, exports);
+	__exportStar(promise$2, exports);
+	__exportStar(string$2, exports);
+	__exportStar(_undefined$2, exports);
+	__exportStar(url$2, exports);
+	__exportStar(regexp$2, exports);
 	
-	return assert;
-}
-
-var hasRequiredEs2018;
-
-function requireEs2018 () {
-	if (hasRequiredEs2018) return es2018$d;
-	hasRequiredEs2018 = 1;
-	(function (exports) {
-		var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-		    if (k2 === undefined) k2 = k;
-		    var desc = Object.getOwnPropertyDescriptor(m, k);
-		    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-		      desc = { enumerable: true, get: function() { return m[k]; } };
-		    }
-		    Object.defineProperty(o, k2, desc);
-		}) : (function(o, m, k, k2) {
-		    if (k2 === undefined) k2 = k;
-		    o[k2] = m[k];
-		}));
-		var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
-		    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-		};__exportStar(requireCustomError(), exports);
-		__exportStar(requireAssertionError(), exports);
-		__exportStar(serializableError, exports);
-		__exportStar(requireNormalize(), exports);
-		__exportStar(hydrate$1, exports);
-		__exportStar(requireAssert(), exports);
-		__exportStar(getErrorNames$1, exports);
-		__exportStar(traverseErrorPrototypeChain$1, exports);
-		
-} (es2018$d));
-	return es2018$d;
-}
-
-var es2018$7 = {};
-
-var middleware$1 = {};
-
-var chunkAsync$3 = {};
-
-chunkAsync$3.chunkAsync = void 0;
-const go_1$v = es2018$b;
-const errors_1$C = requireEs2018();
-function chunkAsync$2(iterable, size) {
-    (0, errors_1$C.assert)(Number.isInteger(size), 'The parameter size must be an integer');
-    (0, errors_1$C.assert)(size > 0, 'The parameter size must be greater than 0');
-    return (0, go_1$v.go)(async function* () {
-        let buffer = [];
-        for await (const element of iterable) {
-            buffer.push(element);
-            if (buffer.length >= size) {
-                yield buffer;
-                buffer = [];
-            }
-        }
-        if (buffer.length)
-            yield buffer;
-    });
-}
-chunkAsync$3.chunkAsync = chunkAsync$2;
-
-var chunkByAsync$3 = {};
+} (es2018$7));
 
 chunkByAsync$3.chunkByAsync = void 0;
-const types_1$C = es2018$e;
+const types_1$C = es2018$7;
 function chunkByAsync$2(iterable, predicate) {
     if ((0, types_1$C.isAsyncIterable)(iterable)) {
         return chunkByAsyncIterable$1(iterable, predicate);
@@ -3349,7 +4132,7 @@ chunkBy$3.chunkBy = chunkBy$2;
 var chunk$3 = {};
 
 chunk$3.chunk = void 0;
-const go_1$u = es2018$b;
+const go_1$u = es2018$d;
 const errors_1$B = requireEs2018();
 function chunk$2(iterable, size) {
     (0, errors_1$B.assert)(Number.isInteger(size), 'The parameter size must be an integer');
@@ -3372,8 +4155,8 @@ chunk$3.chunk = chunk$2;
 var concatAsync$3 = {};
 
 concatAsync$3.concatAsync = void 0;
-const types_1$B = es2018$e;
-const go_1$t = es2018$b;
+const types_1$B = es2018$7;
+const go_1$t = es2018$d;
 function concatAsync$2(iterable, ...otherIterables) {
     return (0, go_1$t.go)(async function* () {
         for (const iter of [iterable, ...otherIterables]) {
@@ -3395,7 +4178,7 @@ concatAsync$3.concatAsync = concatAsync$2;
 var concat$7 = {};
 
 concat$7.concat = void 0;
-const go_1$s = es2018$b;
+const go_1$s = es2018$d;
 function concat$6(iterable, ...otherIterables) {
     return (0, go_1$s.go)(function* () {
         for (const iter of [iterable, ...otherIterables]) {
@@ -3424,7 +4207,7 @@ function* copyIterable$1(iterable) {
 utils$1.copyIterable = copyIterable$1;
 
 dropAsync$3.dropAsync = void 0;
-const go_1$r = es2018$b;
+const go_1$r = es2018$d;
 const utils_1$7 = utils$1;
 const errors_1$A = requireEs2018();
 function dropAsync$2(iterable, count) {
@@ -3459,7 +4242,7 @@ dropAsync$3.dropAsync = dropAsync$2;
 var dropRightAsync$3 = {};
 
 dropRightAsync$3.dropRightAsync = void 0;
-const go_1$q = es2018$b;
+const go_1$q = es2018$d;
 const utils_1$6 = utils$1;
 const errors_1$z = requireEs2018();
 function dropRightAsync$2(iterable, count) {
@@ -3487,7 +4270,7 @@ async function toArrayAsync$5(iterable) {
 var dropRight$3 = {};
 
 dropRight$3.dropRight = void 0;
-const go_1$p = es2018$b;
+const go_1$p = es2018$d;
 const utils_1$5 = utils$1;
 const errors_1$y = requireEs2018();
 function dropRight$2(iterable, count) {
@@ -3505,7 +4288,7 @@ dropRight$3.dropRight = dropRight$2;
 var dropUntilAsync$3 = {};
 
 dropUntilAsync$3.dropUntilAsync = void 0;
-const types_1$A = es2018$e;
+const types_1$A = es2018$7;
 function dropUntilAsync$2(iterable, predicate) {
     if ((0, types_1$A.isAsyncIterable)(iterable)) {
         return dropUntilAsyncIterable$1(iterable, predicate);
@@ -3587,7 +4370,7 @@ dropUntil$3.dropUntil = dropUntil$2;
 var drop$3 = {};
 
 drop$3.drop = void 0;
-const go_1$o = es2018$b;
+const go_1$o = es2018$d;
 const utils_1$4 = utils$1;
 const errors_1$x = requireEs2018();
 function drop$2(iterable, count) {
@@ -3622,7 +4405,7 @@ drop$3.drop = drop$2;
 var filterAsync$3 = {};
 
 filterAsync$3.filterAsync = void 0;
-const types_1$z = es2018$e;
+const types_1$z = es2018$7;
 function filterAsync$2(iterable, predicate) {
     if ((0, types_1$z.isAsyncIterable)(iterable)) {
         return filterAsyncIterable$1(iterable, predicate);
@@ -3669,7 +4452,7 @@ var flattenDeepAsync$3 = {};
 var flattenByAsync$3 = {};
 
 flattenByAsync$3.flattenByAsync = void 0;
-const types_1$y = es2018$e;
+const types_1$y = es2018$7;
 function flattenByAsync$2(iterable, predicate) {
     if ((0, types_1$y.isAsyncIterable)(iterable)) {
         return flattenByAsyncIterable$1(iterable, predicate);
@@ -3727,7 +4510,7 @@ flattenAsync$3.flattenAsync = flattenAsync$2;
 var flattenBy$3 = {};
 
 flattenBy$3.flattenBy = void 0;
-const types_1$x = es2018$e;
+const types_1$x = es2018$7;
 function flattenBy$2(iterable, predicate) {
     return flatten$6(iterable, predicate, 1);
 }
@@ -3770,7 +4553,7 @@ flatten$5.flatten = flatten$4;
 var mapAsync$3 = {};
 
 mapAsync$3.mapAsync = void 0;
-const types_1$w = es2018$e;
+const types_1$w = es2018$7;
 function mapAsync$2(iterable, fn) {
     if ((0, types_1$w.isAsyncIterable)(iterable)) {
         return mapAsyncIterable$1(iterable, fn);
@@ -3810,7 +4593,7 @@ map$5.map = map$4;
 var repeatAsync$3 = {};
 
 repeatAsync$3.repeatAsync = void 0;
-const go_1$n = es2018$b;
+const go_1$n = es2018$d;
 const errors_1$u = requireEs2018();
 function repeatAsync$2(iterable, times) {
     (0, errors_1$u.assert)(times === Infinity || Number.isInteger(times), 'The parameter times must be an integer');
@@ -3845,7 +4628,7 @@ function isProduction$3() {
 var repeat$5 = {};
 
 repeat$5.repeat = void 0;
-const go_1$m = es2018$b;
+const go_1$m = es2018$d;
 const errors_1$t = requireEs2018();
 function repeat$4(iterable, times) {
     (0, errors_1$t.assert)(times === Infinity || Number.isInteger(times), 'The parameter times must be an integer');
@@ -3880,7 +4663,7 @@ function isProduction$2() {
 var sliceAsync$3 = {};
 
 sliceAsync$3.sliceAsync = void 0;
-const go_1$l = es2018$b;
+const go_1$l = es2018$d;
 const errors_1$s = requireEs2018();
 function sliceAsync$2(iterable, start, end = Infinity) {
     (0, errors_1$s.assert)(Number.isInteger(start), 'The parameter start must be an integer');
@@ -3903,7 +4686,7 @@ sliceAsync$3.sliceAsync = sliceAsync$2;
 var slice$3 = {};
 
 slice$3.slice = void 0;
-const go_1$k = es2018$b;
+const go_1$k = es2018$d;
 const errors_1$r = requireEs2018();
 function slice$2(iterable, start, end = Infinity) {
     (0, errors_1$r.assert)(Number.isInteger(start), 'The parameter start must be an integer');
@@ -3944,7 +4727,7 @@ splitAsync$3.splitAsync = splitAsync$2;
 var splitByAsync$3 = {};
 
 splitByAsync$3.splitByAsync = void 0;
-const types_1$v = es2018$e;
+const types_1$v = es2018$7;
 function splitByAsync$2(iterable, predicate) {
     if ((0, types_1$v.isAsyncIterable)(iterable)) {
         return splitByAsyncIterable$1(iterable, predicate);
@@ -4026,7 +4809,7 @@ split$3.split = split$2;
 var takeAsync$3 = {};
 
 takeAsync$3.takeAsync = void 0;
-const go_1$j = es2018$b;
+const go_1$j = es2018$d;
 const errors_1$q = requireEs2018();
 function takeAsync$2(iterable, count) {
     (0, errors_1$q.assert)(Number.isInteger(count), 'The parameter count must be an integer');
@@ -4047,7 +4830,7 @@ takeAsync$3.takeAsync = takeAsync$2;
 var takeRightAsync$3 = {};
 
 takeRightAsync$3.takeRightAsync = void 0;
-const go_1$i = es2018$b;
+const go_1$i = es2018$d;
 const errors_1$p = requireEs2018();
 function takeRightAsync$2(iterable, count) {
     (0, errors_1$p.assert)(Number.isInteger(count), 'The parameter count must be an integer');
@@ -4077,7 +4860,7 @@ takeRightAsync$3.takeRightAsync = takeRightAsync$2;
 var takeRight$3 = {};
 
 takeRight$3.takeRight = void 0;
-const go_1$h = es2018$b;
+const go_1$h = es2018$d;
 const errors_1$o = requireEs2018();
 function takeRight$2(iterable, count) {
     (0, errors_1$o.assert)(Number.isInteger(count), 'The parameter count must be an integer');
@@ -4107,7 +4890,7 @@ takeRight$3.takeRight = takeRight$2;
 var takeUntilAsync$3 = {};
 
 takeUntilAsync$3.takeUntilAsync = void 0;
-const types_1$u = es2018$e;
+const types_1$u = es2018$7;
 function takeUntilAsync$2(iterable, predicate) {
     if ((0, types_1$u.isAsyncIterable)(iterable)) {
         return takeUntilAsyncIterable$1(iterable, predicate);
@@ -4153,7 +4936,7 @@ takeUntil$5.takeUntil = takeUntil$4;
 var take$5 = {};
 
 take$5.take = void 0;
-const go_1$g = es2018$b;
+const go_1$g = es2018$d;
 const errors_1$n = requireEs2018();
 function take$4(iterable, count) {
     (0, errors_1$n.assert)(Number.isInteger(count), 'The parameter count must be an integer');
@@ -4174,7 +4957,7 @@ take$5.take = take$4;
 var tapAsync$3 = {};
 
 tapAsync$3.tapAsync = void 0;
-const types_1$t = es2018$e;
+const types_1$t = es2018$7;
 function tapAsync$2(iterable, fn) {
     if ((0, types_1$t.isAsyncIterable)(iterable)) {
         return tapAsyncIterable$1(iterable, fn);
@@ -4257,7 +5040,7 @@ uniqAsync$3.uniqAsync = uniqAsync$2;
 var uniqByAsync$3 = {};
 
 uniqByAsync$3.uniqByAsync = void 0;
-const types_1$s = es2018$e;
+const types_1$s = es2018$7;
 function uniqByAsync$2(iterable, fn) {
     if ((0, types_1$s.isAsyncIterable)(iterable)) {
         return uniqByAsyncIterable$1(iterable, fn);
@@ -4326,7 +5109,7 @@ uniq$3.uniq = uniq$2;
 var zipAsync$3 = {};
 
 zipAsync$3.zipAsync = void 0;
-const types_1$r = es2018$e;
+const types_1$r = es2018$7;
 var Kind$1;
 (function (Kind) {
     Kind[Kind["Sync"] = 0] = "Sync";
@@ -4490,7 +5273,7 @@ consume$3.consume = consume$2;
 var eachAsync$3 = {};
 
 eachAsync$3.eachAsync = void 0;
-const types_1$q = es2018$e;
+const types_1$q = es2018$7;
 function eachAsync$2(iterable, fn) {
     if ((0, types_1$q.isAsyncIterable)(iterable)) {
         return eachAsyncIterable$1(iterable, fn);
@@ -4530,7 +5313,7 @@ each$3.each = each$2;
 var everyAsync$3 = {};
 
 everyAsync$3.everyAsync = void 0;
-const types_1$p = es2018$e;
+const types_1$p = es2018$7;
 function everyAsync$2(iterable, predicate) {
     if ((0, types_1$p.isAsyncIterable)(iterable)) {
         return everyAsyncIterable$1(iterable, predicate);
@@ -4576,7 +5359,7 @@ every$5.every = every$4;
 var findAsync$3 = {};
 
 findAsync$3.findAsync = void 0;
-const types_1$o = es2018$e;
+const types_1$o = es2018$7;
 function findAsync$2(iterable, predicate) {
     if ((0, types_1$o.isAsyncIterable)(iterable)) {
         return findAsyncIterable$1(iterable, predicate);
@@ -4700,7 +5483,7 @@ match$3.match = match$2;
 var reduceAsync$3 = {};
 
 reduceAsync$3.reduceAsync = void 0;
-const types_1$n = es2018$e;
+const types_1$n = es2018$7;
 function reduceAsync$2(iterable, fn, initialValue) {
     if ((0, types_1$n.isUndefined)(initialValue)) {
         return reduceAsyncWithoutInitialValue$1(iterable, fn);
@@ -4796,7 +5579,7 @@ function reduceAsyncWithoutInitialValue$1(iterable, fn) {
 var reduce$5 = {};
 
 reduce$5.reduce = void 0;
-const types_1$m = es2018$e;
+const types_1$m = es2018$7;
 function reduce$4(iterable, fn, initialValue) {
     if ((0, types_1$m.isUndefined)(initialValue)) {
         return reduceWithoutInitialValue$1(iterable, fn);
@@ -4843,7 +5626,7 @@ function reduceWithoutInitialValue$1(iterable, fn) {
 var someAsync$3 = {};
 
 someAsync$3.someAsync = void 0;
-const types_1$l = es2018$e;
+const types_1$l = es2018$7;
 function someAsync$2(iterable, predicate) {
     if ((0, types_1$l.isAsyncIterable)(iterable)) {
         return someAsyncIterable$1(iterable, predicate);
@@ -5097,11 +5880,11 @@ groupByAsync$3.groupByAsync = groupByAsync$2;
 	};__exportStar(middleware$1, exports);
 	__exportStar(output$1, exports);
 	
-} (es2018$7));
+} (es2018$8));
 
 lruMap.LRUMap = void 0;
 const errors_1$m = requireEs2018();
-const iterable_operator_1$3 = es2018$7;
+const iterable_operator_1$3 = es2018$8;
 class LRUMap {
     constructor(limit) {
         this.map = new Map();
@@ -5156,7 +5939,7 @@ lruMap.LRUMap = LRUMap;
 var expirableMap = {};
 
 expirableMap.ExpirableMap = void 0;
-const extra_timers_1$1 = es2018$a;
+const extra_timers_1$1 = es2018$c;
 class ExpirableMap {
     constructor() {
         this.map = new Map();
@@ -5253,8 +6036,8 @@ var tlruMap = {};
 
 tlruMap.TLRUMap = void 0;
 const errors_1$l = requireEs2018();
-const iterable_operator_1$2 = es2018$7;
-const extra_timers_1 = es2018$a;
+const iterable_operator_1$2 = es2018$8;
+const extra_timers_1 = es2018$c;
 class TLRUMap {
     constructor(limit) {
         this.map = new Map();
@@ -5376,8 +6159,8 @@ tlruMap.TLRUMap = TLRUMap;
 var trieMap = {};
 
 trieMap.TrieMap = void 0;
-const iterable_operator_1$1 = es2018$7;
-const types_1$k = es2018$e;
+const iterable_operator_1$1 = es2018$8;
+const types_1$k = es2018$g;
 class TrieNode {
     constructor(value) {
         this.value = value;
@@ -12910,7 +13693,7 @@ zipWith$1.zipWith = zipWith;
 exports.BadEventError = exports.ObservableFiniteStateMachine = void 0;
 	const finite_state_machine_1 = finiteStateMachine;
 	const rxjs_1 = cjs;
-	const types_1 = es2018$e;
+	const types_1 = es2018$g;
 	class ObservableFiniteStateMachine extends finite_state_machine_1.FiniteStateMachine {
 	    constructor() {
 	        super(...arguments);
@@ -13219,6 +14002,9 @@ class DynamicTypedArray {
     get [Symbol.toStringTag]() {
         return this.constructor.name;
     }
+    get BYTES_PER_ELEMENT() {
+        return this.typedArrayConstructor.BYTES_PER_ELEMENT;
+    }
     get capacity() {
         return this.array.length;
     }
@@ -13329,7 +14115,7 @@ var sortedSet = {};
 var skipList = {};
 
 skipList.SkipList = skipList.SkipListNode = void 0;
-const types_1$j = es2018$e;
+const types_1$j = es2018$g;
 class SkipListNode {
     constructor(value) {
         this.value = value;
@@ -13483,7 +14269,7 @@ skipList.SkipList = SkipList;
 
 sortedSet.SortedSet = void 0;
 const skip_list_1 = skipList;
-const iterable_operator_1 = es2018$7;
+const iterable_operator_1 = es2018$8;
 class SortedSet {
     constructor(compare) {
         this.skipList = new skip_list_1.SkipList(compare);
@@ -13511,43 +14297,53 @@ sortedSet.SortedSet = SortedSet;
 
 var bitSet = {};
 
+var trailingZeros$1 = {};
+
+trailingZeros$1.trailingZeros = void 0;
+const mod37BitPositions = [
+    32, 0, 1, 26, 2, 23, 27, 0, 3, 16,
+    24, 30, 28, 11, 0, 13, 4, 7, 17, 0,
+    25, 22, 31, 15, 29, 10, 12, 6, 0, 21,
+    14, 9, 5, 20, 8, 19, 18
+];
+function trailingZeros(value) {
+    return mod37BitPositions[(-value & value) % 37];
+}
+trailingZeros$1.trailingZeros = trailingZeros;
+
 bitSet.BitSet = void 0;
 const errors_1$h = requireEs2018();
+const trailing_zeros_1$1 = trailingZeros$1;
 class BitSet {
     constructor(bitsPerElement = 8) {
         this.bitsPerElement = bitsPerElement;
         this.array = [];
         this.length = 0;
+        this._size = 0;
+        (0, errors_1$h.assert)(Number.isInteger(bitsPerElement), 'The parameter bitsPerElement must be an integer');
+        (0, errors_1$h.assert)(bitsPerElement > 0, 'The parameter bitsPerElement must be greater than 0');
+        (0, errors_1$h.assert)(bitsPerElement <= 31, 'The mask of bitsPerElement must be less than or equal to 31');
     }
     get [Symbol.toStringTag]() {
         return this.constructor.name;
     }
     get size() {
-        return this.length;
+        return this._size;
     }
     [Symbol.iterator]() {
         return this.values();
     }
     *values() {
         if (this.length > 0) {
-            const maxArrayLength = Math.ceil(this.length / this.bitsPerElement);
-            const remainder = this.bitsPerElement
-                - (maxArrayLength * this.bitsPerElement - this.length);
-            const lastIndex = maxArrayLength - 1;
-            for (let index = 0; index < lastIndex; index++) {
-                const element = this.array[index];
-                for (let bit = 0; bit < this.bitsPerElement; bit++) {
-                    const mask = this.getMask(bit);
-                    if ((element & mask) === mask) {
-                        yield index * this.bitsPerElement + bit;
-                    }
-                }
-            }
-            const lastElement = this.array[maxArrayLength - 1];
-            for (let bit = 0; bit < remainder; bit++) {
-                const mask = this.getMask(bit);
-                if ((lastElement & mask) === mask) {
-                    yield lastIndex * this.bitsPerElement + bit;
+            const maxArrayLength = ~~(this.length / this.bitsPerElement) + 1;
+            for (let index = 0; index < maxArrayLength; index++) {
+                let element = this.array[index];
+                let offset = 0;
+                let indexOfBit;
+                while ((indexOfBit = (0, trailing_zeros_1$1.trailingZeros)(element)) !== 32) {
+                    yield index * this.bitsPerElement + offset + indexOfBit;
+                    offset += indexOfBit + 1;
+                    element >>= indexOfBit + 1;
                 }
             }
         }
@@ -13577,14 +14373,23 @@ class BitSet {
             this.length = value + 1;
         }
         const [index, mask] = this.getPosition(value);
-        this.array[index] = ((_a = this.array[index]) !== null && _a !== void 0 ? _a : 0) | mask;
+        const element = (_a = this.array[index]) !== null && _a !== void 0 ? _a : 0;
+        this.array[index] = element | mask;
+        const added = (element & mask) !== mask;
+        if (added) {
+            this._size++;
+        }
     }
     delete(value) {
         var _a;
         const [index, mask] = this.getPosition(value);
         const element = ((_a = this.array[index]) !== null && _a !== void 0 ? _a : 0);
         this.array[index] = element & ~mask;
-        return (element & mask) === mask;
+        const deleted = (element & mask) === mask;
+        if (deleted) {
+            this._size--;
+        }
+        return deleted;
     }
     clear() {
         for (let i = this.array.length; i--;) {
@@ -13599,7 +14404,7 @@ class BitSet {
         return [index, mask];
     }
     getMask(value) {
-        return 2 ** value;
+        return 1 << value;
     }
 }
 bitSet.BitSet = BitSet;
@@ -13608,41 +14413,38 @@ var typedBitSet = {};
 
 typedBitSet.TypedBitSet = void 0;
 const errors_1$g = requireEs2018();
+const trailing_zeros_1 = trailingZeros$1;
 class TypedBitSet {
     constructor(array) {
         this.array = array;
-        this.bitsPerElement = this.array.internalTypedArray.BYTES_PER_ELEMENT * 8;
         this.length = 0;
+        this._size = 0;
+        const bitsPerElement = array.BYTES_PER_ELEMENT * 8;
+        (0, errors_1$g.assert)(Number.isInteger(bitsPerElement), 'The parameter bitsPerElement must be an integer');
+        (0, errors_1$g.assert)(bitsPerElement > 0, 'The parameter bitsPerElement must be greater than 0');
+        (0, errors_1$g.assert)(bitsPerElement <= 31, 'The mask of bitsPerElement must be less than or equal to 31');
+        this.bitsPerElement = bitsPerElement;
     }
     get [Symbol.toStringTag]() {
         return this.constructor.name;
     }
     get size() {
-        return this.length;
+        return this._size;
     }
     [Symbol.iterator]() {
         return this.values();
     }
     *values() {
         if (this.length > 0) {
-            const maxArrayLength = Math.ceil(this.length / this.bitsPerElement);
-            const remainder = this.bitsPerElement
-                - (maxArrayLength * this.bitsPerElement - this.length);
-            const lastIndex = maxArrayLength - 1;
-            for (let index = 0; index < lastIndex; index++) {
-                const element = this.array.internalTypedArray[index];
-                for (let bit = 0; bit < this.bitsPerElement; bit++) {
-                    const mask = this.getMask(bit);
-                    if ((element & mask) === mask) {
-                        yield index * this.bitsPerElement + bit;
-                    }
-                }
-            }
-            const lastElement = this.array.internalTypedArray[maxArrayLength - 1];
-            for (let bit = 0; bit < remainder; bit++) {
-                const mask = this.getMask(bit);
-                if ((lastElement & mask) === mask) {
-                    yield lastIndex * this.bitsPerElement + bit;
+            const maxArrayLength = ~~(this.length / this.bitsPerElement) + 1;
+            for (let index = 0; index < maxArrayLength; index++) {
+                let element = this.array.internalTypedArray[index];
+                let offset = 0;
+                let indexOfBit;
+                while ((indexOfBit = (0, trailing_zeros_1.trailingZeros)(element)) !== 32) {
+                    yield index * this.bitsPerElement + offset + indexOfBit;
+                    offset += indexOfBit + 1;
+                    element >>= indexOfBit + 1;
                 }
             }
         }
@@ -13672,14 +14474,23 @@ class TypedBitSet {
             this.length = value + 1;
         }
         const [index, mask] = this.getPosition(value);
-        this.array.set(index, ((_a = this.array.get(index)) !== null && _a !== void 0 ? _a : 0) | mask);
+        const element = (_a = this.array.get(index)) !== null && _a !== void 0 ? _a : 0;
+        this.array.set(index, element | mask);
+        const added = (element & mask) !== mask;
+        if (added) {
+            this._size++;
+        }
     }
     delete(value) {
         var _a;
         const [index, mask] = this.getPosition(value);
         const element = ((_a = this.array.get(index)) !== null && _a !== void 0 ? _a : 0);
         this.array.set(index, element & ~mask);
-        return (element & mask) === mask;
+        const deleted = (element & mask) === mask;
+        if (deleted) {
+            this._size--;
+        }
+        return deleted;
     }
     clear() {
         for (let i = this.array.length; i--;) {
@@ -13694,7 +14505,7 @@ class TypedBitSet {
         return [index, mask];
     }
     getMask(value) {
-        return 2 ** value;
+        return 1 << value;
     }
 }
 typedBitSet.TypedBitSet = TypedBitSet;
@@ -13716,6 +14527,7 @@ typedBitSet.TypedBitSet = TypedBitSet;
 	};exports.DynamicTypedArray = void 0;
 	__exportStar(box, exports);
 	__exportStar(cons, exports);
+	__exportStar(array$4, exports);
 	__exportStar(emitter, exports);
 	__exportStar(hashMap, exports);
 	__exportStar(hashSet, exports);
@@ -13736,7 +14548,7 @@ typedBitSet.TypedBitSet = TypedBitSet;
 	__exportStar(bitSet, exports);
 	__exportStar(typedBitSet, exports);
 	
-} (es2018$f));
+} (es2018$h));
 
 var es2018$6 = {};
 
@@ -13767,7 +14579,7 @@ highResolutionTimestamp_browser.elapsed = elapsed;
 
 time$1.time = void 0;
 const high_resolution_timestamp_1$2 = highResolutionTimestamp_browser;
-const types_1$i = es2018$e;
+const types_1$i = es2018$a;
 function time(message, fn) {
     const startTime = (0, high_resolution_timestamp_1$2.now)();
     const result = fn();
@@ -13987,7 +14799,7 @@ var middleware = {};
 var chunkAsync$1 = {};
 
 chunkAsync$1.chunkAsync = void 0;
-const go_1$f = es2018$b;
+const go_1$f = es2018$d;
 const errors_1$f = requireEs2018();
 function chunkAsync(iterable, size) {
     (0, errors_1$f.assert)(Number.isInteger(size), 'The parameter size must be an integer');
@@ -14234,7 +15046,7 @@ var object$1 = {};
 var __importDefault$1 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };object$1.isntEmptyObject = object$1.isEmptyObject = object$1.isntPlainObject = object$1.isPlainObject = object$1.isntObject = object$1.isObject = void 0;
-const isPlainObject_1$1 = __importDefault$1(isPlainObject_1$3);
+const isPlainObject_1$1 = __importDefault$1(isPlainObject_1$5);
 function isObject$1(val) {
     return val !== null
         && typeof val === 'object';
@@ -14444,7 +15256,7 @@ chunkBy$1.chunkBy = chunkBy;
 var chunk$1 = {};
 
 chunk$1.chunk = void 0;
-const go_1$e = es2018$b;
+const go_1$e = es2018$d;
 const errors_1$e = requireEs2018();
 function chunk(iterable, size) {
     (0, errors_1$e.assert)(Number.isInteger(size), 'The parameter size must be an integer');
@@ -14468,7 +15280,7 @@ var concatAsync$1 = {};
 
 concatAsync$1.concatAsync = void 0;
 const types_1$g = es2018$1;
-const go_1$d = es2018$b;
+const go_1$d = es2018$d;
 function concatAsync(iterable, ...otherIterables) {
     return (0, go_1$d.go)(async function* () {
         for (const iter of [iterable, ...otherIterables]) {
@@ -14490,7 +15302,7 @@ concatAsync$1.concatAsync = concatAsync;
 var concat$1 = {};
 
 concat$1.concat = void 0;
-const go_1$c = es2018$b;
+const go_1$c = es2018$d;
 function concat(iterable, ...otherIterables) {
     return (0, go_1$c.go)(function* () {
         for (const iter of [iterable, ...otherIterables]) {
@@ -14519,7 +15331,7 @@ function* copyIterable(iterable) {
 utils.copyIterable = copyIterable;
 
 dropAsync$1.dropAsync = void 0;
-const go_1$b = es2018$b;
+const go_1$b = es2018$d;
 const utils_1$3 = utils;
 const errors_1$d = requireEs2018();
 function dropAsync(iterable, count) {
@@ -14554,7 +15366,7 @@ dropAsync$1.dropAsync = dropAsync;
 var dropRightAsync$1 = {};
 
 dropRightAsync$1.dropRightAsync = void 0;
-const go_1$a = es2018$b;
+const go_1$a = es2018$d;
 const utils_1$2 = utils;
 const errors_1$c = requireEs2018();
 function dropRightAsync(iterable, count) {
@@ -14582,7 +15394,7 @@ async function toArrayAsync$2(iterable) {
 var dropRight$1 = {};
 
 dropRight$1.dropRight = void 0;
-const go_1$9 = es2018$b;
+const go_1$9 = es2018$d;
 const utils_1$1 = utils;
 const errors_1$b = requireEs2018();
 function dropRight(iterable, count) {
@@ -14682,7 +15494,7 @@ dropUntil$1.dropUntil = dropUntil;
 var drop$1 = {};
 
 drop$1.drop = void 0;
-const go_1$8 = es2018$b;
+const go_1$8 = es2018$d;
 const utils_1 = utils;
 const errors_1$a = requireEs2018();
 function drop(iterable, count) {
@@ -14905,7 +15717,7 @@ map$1.map = map;
 var repeatAsync$1 = {};
 
 repeatAsync$1.repeatAsync = void 0;
-const go_1$7 = es2018$b;
+const go_1$7 = es2018$d;
 const errors_1$7 = requireEs2018();
 function repeatAsync(iterable, times) {
     (0, errors_1$7.assert)(times === Infinity || Number.isInteger(times), 'The parameter times must be an integer');
@@ -14940,7 +15752,7 @@ function isProduction$1() {
 var repeat$1 = {};
 
 repeat$1.repeat = void 0;
-const go_1$6 = es2018$b;
+const go_1$6 = es2018$d;
 const errors_1$6 = requireEs2018();
 function repeat(iterable, times) {
     (0, errors_1$6.assert)(times === Infinity || Number.isInteger(times), 'The parameter times must be an integer');
@@ -14975,7 +15787,7 @@ function isProduction() {
 var sliceAsync$1 = {};
 
 sliceAsync$1.sliceAsync = void 0;
-const go_1$5 = es2018$b;
+const go_1$5 = es2018$d;
 const errors_1$5 = requireEs2018();
 function sliceAsync(iterable, start, end = Infinity) {
     (0, errors_1$5.assert)(Number.isInteger(start), 'The parameter start must be an integer');
@@ -14998,7 +15810,7 @@ sliceAsync$1.sliceAsync = sliceAsync;
 var slice$1 = {};
 
 slice$1.slice = void 0;
-const go_1$4 = es2018$b;
+const go_1$4 = es2018$d;
 const errors_1$4 = requireEs2018();
 function slice(iterable, start, end = Infinity) {
     (0, errors_1$4.assert)(Number.isInteger(start), 'The parameter start must be an integer');
@@ -15121,7 +15933,7 @@ split$1.split = split;
 var takeAsync$1 = {};
 
 takeAsync$1.takeAsync = void 0;
-const go_1$3 = es2018$b;
+const go_1$3 = es2018$d;
 const errors_1$3 = requireEs2018();
 function takeAsync(iterable, count) {
     (0, errors_1$3.assert)(Number.isInteger(count), 'The parameter count must be an integer');
@@ -15142,7 +15954,7 @@ takeAsync$1.takeAsync = takeAsync;
 var takeRightAsync$1 = {};
 
 takeRightAsync$1.takeRightAsync = void 0;
-const go_1$2 = es2018$b;
+const go_1$2 = es2018$d;
 const errors_1$2 = requireEs2018();
 function takeRightAsync(iterable, count) {
     (0, errors_1$2.assert)(Number.isInteger(count), 'The parameter count must be an integer');
@@ -15172,7 +15984,7 @@ takeRightAsync$1.takeRightAsync = takeRightAsync;
 var takeRight$1 = {};
 
 takeRight$1.takeRight = void 0;
-const go_1$1 = es2018$b;
+const go_1$1 = es2018$d;
 const errors_1$1 = requireEs2018();
 function takeRight(iterable, count) {
     (0, errors_1$1.assert)(Number.isInteger(count), 'The parameter count must be an integer');
@@ -15248,7 +16060,7 @@ takeUntil$1.takeUntil = takeUntil;
 var take$1 = {};
 
 take$1.take = void 0;
-const go_1 = es2018$b;
+const go_1 = es2018$d;
 const errors_1 = requireEs2018();
 function take(iterable, count) {
     (0, errors_1.assert)(Number.isInteger(count), 'The parameter count must be an integer');
@@ -16419,7 +17231,7 @@ var object = {};
 var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };object.isntEmptyObject = object.isEmptyObject = object.isntPlainObject = object.isPlainObject = object.isntObject = object.isObject = void 0;
-const isPlainObject_1 = __importDefault(isPlainObject_1$3);
+const isPlainObject_1 = __importDefault(isPlainObject_1$5);
 function isObject(val) {
     return val !== null
         && typeof val === 'object';
@@ -16585,7 +17397,7 @@ exports.isntNumber = exports.isntNull = exports.isntJson = exports.isntIterable
 	exports.isntSymbol = exports.isntRegExp = exports.isntUndefined = exports.isntString = exports.isntPromiseLike = exports.isntPromise = exports.isntPlainObject = exports.isntObject = void 0;
 	var errors_1 = requireEs2018();
 	Object.defineProperty(exports, "assert", { enumerable: true, get: function () { return errors_1.assert; } });
-	var go_1 = es2018$b;
+	var go_1 = es2018$d;
 	Object.defineProperty(exports, "go", { enumerable: true, get: function () { return go_1.go; } });
 	var log_1 = es2018$5;
 	Object.defineProperty(exports, "log", { enumerable: true, get: function () { return log_1.log; } });
@@ -16651,6 +17463,11 @@ exports.isntNumber = exports.isntNull = exports.isntJson = exports.isntIterable
 	
 } (es2018$6));
 
+var Mode;
+(function (Mode) {
+    Mode[Mode["UpdateFirst"] = 0] = "UpdateFirst";
+    Mode[Mode["FixedUpdateFirst"] = 1] = "FixedUpdateFirst";
+})(Mode || (Mode = {}));
 var State;
 (function (State) {
     State["Stopped"] = "stopped";
@@ -16662,7 +17479,7 @@ const schema = {
 };
 class GameLoop {
     constructor(options) {
-        this.fsm = new es2018$f.FiniteStateMachine(schema, State.Stopped);
+        this.fsm = new es2018$h.FiniteStateMachine(schema, State.Stopped);
         this.deltaTimeAccumulator = 0;
         this.lastDeltaTime = 0;
         this.loop = () => {
@@ -16682,6 +17499,13 @@ class GameLoop {
         this.fixedUpdate = options.fixedUpdate;
         this.update = options.update;
         this.render = options.render;
+        this.nextFrame = es2018$6.go(() => {
+            switch (options.mode) {
+                case Mode.UpdateFirst: return this.nextFrameUpdateFirst.bind(this);
+                case Mode.FixedUpdateFirst: return this.nextFrameFixedUpdateFirst.bind(this);
+                default: throw new Error('Unknown mode');
+            }
+        });
     }
     start() {
         this.fsm.send('start');
@@ -16706,22 +17530,40 @@ class GameLoop {
         }
     }
     /**
-     * nextFrame依序做以下几件事:
+     * nextFrameUpdateFirst依序做以下几件事:
+     * 1. 响应用户输入, 为这一帧的游戏世界做出非物理方面的更新, 例如角色转向, 改变武器瞄准角度等.
+     * 2. 响应游戏世界从上一帧更新后到这一帧更新之前发生的物理变化.
+     *    注意, 如果渲染帧率比物理帧率快, 且运行性能良好, 则物理帧不一定会在此帧更新.
+     * 3. 渲染经过更新后的最新状态, 渲染器可以根据alpha参数执行插值渲染.
+     */
+    nextFrameUpdateFirst(deltaTime) {
+        this.deltaTimeAccumulator = Math.min(this.deltaTimeAccumulator + deltaTime, this.maximumDeltaTime);
+        this.update(deltaTime);
+        while (this.deltaTimeAccumulator >= this.fixedDeltaTime) {
+            this.fixedUpdate(this.fixedDeltaTime);
+            this.deltaTimeAccumulator -= this.fixedDeltaTime;
+        }
+        const alpha = this.deltaTimeAccumulator / this.fixedDeltaTime;
+        this.render(alpha);
+    }
+    /**
+     * nextFrameFixedUpdateFirst依序做以下几件事:
      * 1. 响应游戏世界从上一帧更新后到这一帧更新之前发生的物理变化.
      *    注意, 如果渲染帧率比物理帧率快, 且运行性能良好, 则物理帧不一定会在此帧更新.
      * 2. 响应用户输入, 为这一帧的游戏世界做出非物理方面的更新, 例如角色转向, 改变武器瞄准角度等.
-     * 3. 渲染经过更新后的最新状态.
+     * 3. 渲染经过更新后的最新状态, 渲染器可以根据alpha参数执行插值渲染.
      */
-    nextFrame(deltaTime) {
+    nextFrameFixedUpdateFirst(deltaTime) {
         this.deltaTimeAccumulator = Math.min(this.deltaTimeAccumulator + deltaTime, this.maximumDeltaTime);
         while (this.deltaTimeAccumulator >= this.fixedDeltaTime) {
             this.fixedUpdate(this.fixedDeltaTime);
             this.deltaTimeAccumulator -= this.fixedDeltaTime;
         }
         this.update(deltaTime);
-        this.render();
+        const alpha = this.deltaTimeAccumulator / this.fixedDeltaTime;
+        this.render(alpha);
     }
 }
 
-export { GameLoop };
+export { GameLoop, Mode };
 //# sourceMappingURL=index.mjs.map