extra-game-loop 0.1.4 → 0.3.0

package/dist/es2015/index.umd.js

@@ -6,7 +6,7 @@
 
 	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 = {};
 
@@ -29,227 +29,227 @@
 
 	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. */
 
@@ -477,7 +477,7 @@
 	 * _.isPlainObject(Object.create(null));
 	 * // => true
 	 */
-	function isPlainObject$3(value) {
+	function isPlainObject$5(value) {
 	  if (!isObjectLike(value) || baseGetTag(value) != objectTag) {
 	    return false;
 	  }
@@ -490,59 +490,59 @@
 	    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;
@@ -551,39 +551,39 @@
 	        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;
@@ -592,19 +592,31 @@
 	        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) {
@@ -620,31 +632,32 @@
 		}));
 		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];
@@ -659,6 +672,30 @@
 	}
 	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;
@@ -805,17 +842,17 @@
 
 	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 = {};
 
@@ -844,11 +881,11 @@
 
 	var goMacrotask$1 = {};
 
-	var es2018$a = {};
+	var es2018$c = {};
 
 	var exponentialBackoff = {};
 
-	var es2018$9 = {};
+	var es2018$b = {};
 
 	var random$1 = {};
 
@@ -892,10 +929,10 @@
 		__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) {
@@ -1010,10 +1047,10 @@
 		__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 () => {
@@ -1046,7 +1083,7 @@
 		__exportStar(goMicrotask$1, exports);
 		__exportStar(goMacrotask$1, exports);
 		
-	} (es2018$b));
+	} (es2018$d));
 
 	var hasRequiredChunkAsync;
 
@@ -1054,7 +1091,7 @@
 		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');
@@ -1079,9 +1116,382 @@
 
 	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);
 	    }
@@ -1146,7 +1556,7 @@
 		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');
@@ -1172,8 +1582,8 @@
 	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]) {
@@ -1195,7 +1605,7 @@
 	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]) {
@@ -1229,7 +1639,7 @@
 		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) {
@@ -1272,7 +1682,7 @@
 		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) {
@@ -1308,7 +1718,7 @@
 		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) {
@@ -1329,7 +1739,7 @@
 	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);
@@ -1416,7 +1826,7 @@
 		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) {
@@ -1454,7 +1864,7 @@
 	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);
@@ -1501,7 +1911,7 @@
 	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);
@@ -1575,7 +1985,7 @@
 	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);
 	}
@@ -1634,7 +2044,7 @@
 	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);
@@ -1679,7 +2089,7 @@
 		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');
@@ -1722,7 +2132,7 @@
 		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');
@@ -1765,7 +2175,7 @@
 		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');
@@ -1796,7 +2206,7 @@
 		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');
@@ -1840,7 +2250,7 @@
 	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);
@@ -1927,7 +2337,7 @@
 		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');
@@ -1956,7 +2366,7 @@
 		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');
@@ -1994,7 +2404,7 @@
 		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');
@@ -2027,7 +2437,7 @@
 	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);
@@ -2078,7 +2488,7 @@
 		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');
@@ -2102,7 +2512,7 @@
 	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);
@@ -2185,7 +2595,7 @@
 	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);
@@ -2254,7 +2664,7 @@
 	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";
@@ -2425,7 +2835,7 @@
 	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);
@@ -2465,7 +2875,7 @@
 	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);
@@ -2511,7 +2921,7 @@
 	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);
@@ -2635,7 +3045,7 @@
 	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);
@@ -2731,7 +3141,7 @@
 	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);
@@ -2778,7 +3188,7 @@
 	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);
@@ -3018,7 +3428,7 @@
 	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) {
@@ -3037,8 +3447,8 @@
 			};__exportStar(requireMiddleware(), exports);
 			__exportStar(output$2, exports);
 			
-	} (es2018$c));
-		return es2018$c;
+	} (es2018$e));
+		return es2018$e;
 	}
 
 	var getErrorNames$1 = {};
@@ -3057,7 +3467,7 @@
 	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;
@@ -3078,7 +3488,7 @@
 	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)
@@ -3096,7 +3506,7 @@
 	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() {
@@ -3122,179 +3532,552 @@
 		
 		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);
@@ -3355,7 +4138,7 @@
 	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');
@@ -3378,8 +4161,8 @@
 	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]) {
@@ -3401,7 +4184,7 @@
 	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]) {
@@ -3430,7 +4213,7 @@
 	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) {
@@ -3465,7 +4248,7 @@
 	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) {
@@ -3493,7 +4276,7 @@
 	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) {
@@ -3511,7 +4294,7 @@
 	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);
@@ -3593,7 +4376,7 @@
 	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) {
@@ -3628,7 +4411,7 @@
 	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);
@@ -3675,7 +4458,7 @@
 	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);
@@ -3733,7 +4516,7 @@
 	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);
 	}
@@ -3776,7 +4559,7 @@
 	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);
@@ -3816,7 +4599,7 @@
 	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');
@@ -3851,7 +4634,7 @@
 	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');
@@ -3886,7 +4669,7 @@
 	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');
@@ -3909,7 +4692,7 @@
 	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');
@@ -3950,7 +4733,7 @@
 	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);
@@ -4032,7 +4815,7 @@
 	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');
@@ -4053,7 +4836,7 @@
 	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');
@@ -4083,7 +4866,7 @@
 	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');
@@ -4113,7 +4896,7 @@
 	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);
@@ -4159,7 +4942,7 @@
 	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');
@@ -4180,7 +4963,7 @@
 	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);
@@ -4263,7 +5046,7 @@
 	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);
@@ -4332,7 +5115,7 @@
 	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";
@@ -4496,7 +5279,7 @@
 	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);
@@ -4536,7 +5319,7 @@
 	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);
@@ -4582,7 +5365,7 @@
 	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);
@@ -4706,7 +5489,7 @@
 	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);
@@ -4802,7 +5585,7 @@
 	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);
@@ -4849,7 +5632,7 @@
 	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);
@@ -5103,11 +5886,11 @@
 		};__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();
@@ -5162,7 +5945,7 @@
 	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();
@@ -5259,8 +6042,8 @@
 
 	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();
@@ -5382,8 +6165,8 @@
 	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;
@@ -12916,7 +13699,7 @@
 	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);
@@ -13225,6 +14008,9 @@
 	    get [Symbol.toStringTag]() {
 	        return this.constructor.name;
 	    }
+	    get BYTES_PER_ELEMENT() {
+	        return this.typedArrayConstructor.BYTES_PER_ELEMENT;
+	    }
 	    get capacity() {
 	        return this.array.length;
 	    }
@@ -13335,7 +14121,7 @@
 	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;
@@ -13489,7 +14275,7 @@
 
 	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);
@@ -13517,43 +14303,53 @@
 
 	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;
 	                }
 	            }
 	        }
@@ -13583,14 +14379,23 @@
 	            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--;) {
@@ -13605,7 +14410,7 @@
 	        return [index, mask];
 	    }
 	    getMask(value) {
-	        return 2 ** value;
+	        return 1 << value;
 	    }
 	}
 	bitSet.BitSet = BitSet;
@@ -13614,41 +14419,38 @@
 
 	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;
 	                }
 	            }
 	        }
@@ -13678,14 +14480,23 @@
 	            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--;) {
@@ -13700,7 +14511,7 @@
 	        return [index, mask];
 	    }
 	    getMask(value) {
-	        return 2 ** value;
+	        return 1 << value;
 	    }
 	}
 	typedBitSet.TypedBitSet = TypedBitSet;
@@ -13722,6 +14533,7 @@
 		};exports.DynamicTypedArray = void 0;
 		__exportStar(box, exports);
 		__exportStar(cons, exports);
+		__exportStar(array$4, exports);
 		__exportStar(emitter, exports);
 		__exportStar(hashMap, exports);
 		__exportStar(hashSet, exports);
@@ -13742,7 +14554,7 @@
 		__exportStar(bitSet, exports);
 		__exportStar(typedBitSet, exports);
 		
-	} (es2018$f));
+	} (es2018$h));
 
 	var es2018$6 = {};
 
@@ -13773,7 +14585,7 @@
 
 	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();
@@ -13993,7 +14805,7 @@
 	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');
@@ -14240,7 +15052,7 @@
 	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';
@@ -14450,7 +15262,7 @@
 	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');
@@ -14474,7 +15286,7 @@
 
 	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]) {
@@ -14496,7 +15308,7 @@
 	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]) {
@@ -14525,7 +15337,7 @@
 	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) {
@@ -14560,7 +15372,7 @@
 	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) {
@@ -14588,7 +15400,7 @@
 	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) {
@@ -14688,7 +15500,7 @@
 	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) {
@@ -14911,7 +15723,7 @@
 	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');
@@ -14946,7 +15758,7 @@
 	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');
@@ -14981,7 +15793,7 @@
 	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');
@@ -15004,7 +15816,7 @@
 	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');
@@ -15127,7 +15939,7 @@
 	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');
@@ -15148,7 +15960,7 @@
 	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');
@@ -15178,7 +15990,7 @@
 	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');
@@ -15254,7 +16066,7 @@
 	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');
@@ -16425,7 +17237,7 @@
 	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';
@@ -16591,7 +17403,7 @@
 		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; } });
@@ -16668,7 +17480,7 @@
 	};
 	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 = () => {
@@ -16685,8 +17497,9 @@
 	        this.fixedDeltaTime = options.fixedDeltaTime;
 	        this.maximumDeltaTime = options.maximumDeltaTime;
 	        es2018$6.assert(this.maximumDeltaTime >= this.fixedDeltaTime, 'maximumDeltaTime must be greater than or equal to fixedDeltaTime');
-	        this.fixedUpdate = options.fixedUpdate;
 	        this.update = options.update;
+	        this.fixedUpdate = options.fixedUpdate;
+	        this.lateUpdate = options.lateUpdate;
 	        this.render = options.render;
 	    }
 	    start() {
@@ -16712,19 +17525,20 @@
 	        }
 	    }
 	    /**
-	     * nextFrame依序做以下几件事:
-	     * 1. 响应游戏世界从上一帧更新后到这一帧更新之前发生的物理变化.
+	     * nextFrameUpdateFirst依序做以下几件事:
+	     * 1. 响应用户输入, 为这一帧的游戏世界做出非物理方面的更新, 例如角色转向, 改变武器瞄准角度等.
+	     * 2. 响应游戏世界从上一帧更新后到这一帧更新之前发生的物理变化.
 	     *    注意, 如果渲染帧率比物理帧率快, 且运行性能良好, 则物理帧不一定会在此帧更新.
-	     * 2. 响应用户输入, 为这一帧的游戏世界做出非物理方面的更新, 例如角色转向, 改变武器瞄准角度等.
 	     * 3. 渲染经过更新后的最新状态, 渲染器可以根据alpha参数执行插值渲染.
 	     */
 	    nextFrame(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;
 	        }
-	        this.update(deltaTime);
+	        this.lateUpdate(deltaTime);
 	        const alpha = this.deltaTimeAccumulator / this.fixedDeltaTime;
 	        this.render(alpha);
 	    }