@blackglory/structures 0.6.5 → 0.6.6

package/dist/es2018/index.mjs

@@ -15,227 +15,227 @@ class Box {
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
-var es2018$d = {};
+var es2018$e = {};
 
-var array$1 = {};
+var array$2 = {};
 
-array$1.isntEmptyArray = array$1.isEmptyArray = array$1.isntArray = array$1.isArray = void 0;
-function isArray$1(val) {
+array$2.isntEmptyArray = array$2.isEmptyArray = array$2.isntArray = array$2.isArray = void 0;
+function isArray$2(val) {
     return Array.isArray(val);
 }
-array$1.isArray = isArray$1;
-function isntArray$1(val) {
-    return !isArray$1(val);
+array$2.isArray = isArray$2;
+function isntArray$2(val) {
+    return !isArray$2(val);
 }
-array$1.isntArray = isntArray$1;
-function isEmptyArray$1(val) {
+array$2.isntArray = isntArray$2;
+function isEmptyArray$2(val) {
     return val.length === 0;
 }
-array$1.isEmptyArray = isEmptyArray$1;
-function isntEmptyArray$1(val) {
+array$2.isEmptyArray = isEmptyArray$2;
+function isntEmptyArray$2(val) {
     return val.length !== 0;
 }
-array$1.isntEmptyArray = isntEmptyArray$1;
+array$2.isntEmptyArray = isntEmptyArray$2;
 
-var asyncIterable$1 = {};
+var asyncIterable$2 = {};
 
-var _null$1 = {};
+var _null$2 = {};
 
-_null$1.isntNull = _null$1.isNull = void 0;
-function isNull$1(val) {
+_null$2.isntNull = _null$2.isNull = void 0;
+function isNull$2(val) {
     return val === null;
 }
-_null$1.isNull = isNull$1;
-function isntNull$1(val) {
-    return !isNull$1(val);
+_null$2.isNull = isNull$2;
+function isntNull$2(val) {
+    return !isNull$2(val);
 }
-_null$1.isntNull = isntNull$1;
+_null$2.isntNull = isntNull$2;
 
-var _undefined$1 = {};
+var _undefined$2 = {};
 
-_undefined$1.isntUndefined = _undefined$1.isUndefined = void 0;
-function isUndefined$1(val) {
+_undefined$2.isntUndefined = _undefined$2.isUndefined = void 0;
+function isUndefined$2(val) {
     return val === undefined;
 }
-_undefined$1.isUndefined = isUndefined$1;
-function isntUndefined$1(val) {
-    return !isUndefined$1(val);
+_undefined$2.isUndefined = isUndefined$2;
+function isntUndefined$2(val) {
+    return !isUndefined$2(val);
 }
-_undefined$1.isntUndefined = isntUndefined$1;
+_undefined$2.isntUndefined = isntUndefined$2;
 
-var _function$1 = {};
+var _function$2 = {};
 
-_function$1.isntFunction = _function$1.isFunction = void 0;
-function isFunction$2(val) {
+_function$2.isntFunction = _function$2.isFunction = void 0;
+function isFunction$3(val) {
     return typeof val === 'function';
 }
-_function$1.isFunction = isFunction$2;
-function isntFunction$1(val) {
-    return !isFunction$2(val);
+_function$2.isFunction = isFunction$3;
+function isntFunction$2(val) {
+    return !isFunction$3(val);
 }
-_function$1.isntFunction = isntFunction$1;
+_function$2.isntFunction = isntFunction$2;
 
-asyncIterable$1.isntAsyncIterable = asyncIterable$1.isAsyncIterable = void 0;
-const null_1$4 = _null$1;
-const undefined_1$4 = _undefined$1;
-const function_1$2 = _function$1;
-function isAsyncIterable$1(val) {
-    return (0, null_1$4.isntNull)(val)
-        && (0, undefined_1$4.isntUndefined)(val)
-        && (0, function_1$2.isFunction)(val[Symbol.asyncIterator]);
+asyncIterable$2.isntAsyncIterable = asyncIterable$2.isAsyncIterable = void 0;
+const null_1$7 = _null$2;
+const undefined_1$6 = _undefined$2;
+const function_1$5 = _function$2;
+function isAsyncIterable$2(val) {
+    return (0, null_1$7.isntNull)(val)
+        && (0, undefined_1$6.isntUndefined)(val)
+        && (0, function_1$5.isFunction)(val[Symbol.asyncIterator]);
 }
-asyncIterable$1.isAsyncIterable = isAsyncIterable$1;
-function isntAsyncIterable$1(val) {
-    return !isAsyncIterable$1(val);
+asyncIterable$2.isAsyncIterable = isAsyncIterable$2;
+function isntAsyncIterable$2(val) {
+    return !isAsyncIterable$2(val);
 }
-asyncIterable$1.isntAsyncIterable = isntAsyncIterable$1;
+asyncIterable$2.isntAsyncIterable = isntAsyncIterable$2;
 
-var bigint$1 = {};
+var bigint$2 = {};
 
-bigint$1.isntBigInt = bigint$1.isBigInt = void 0;
-function isBigInt$1(val) {
+bigint$2.isntBigInt = bigint$2.isBigInt = void 0;
+function isBigInt$2(val) {
     return typeof val === 'bigint';
 }
-bigint$1.isBigInt = isBigInt$1;
-function isntBigInt$1(val) {
-    return !isBigInt$1(val);
+bigint$2.isBigInt = isBigInt$2;
+function isntBigInt$2(val) {
+    return !isBigInt$2(val);
 }
-bigint$1.isntBigInt = isntBigInt$1;
+bigint$2.isntBigInt = isntBigInt$2;
 
-var boolean$1 = {};
+var boolean$2 = {};
 
-boolean$1.isntBoolean = boolean$1.isBoolean = void 0;
-function isBoolean$1(val) {
+boolean$2.isntBoolean = boolean$2.isBoolean = void 0;
+function isBoolean$2(val) {
     return typeof val === 'boolean';
 }
-boolean$1.isBoolean = isBoolean$1;
-function isntBoolean$1(val) {
-    return !isBoolean$1(val);
+boolean$2.isBoolean = isBoolean$2;
+function isntBoolean$2(val) {
+    return !isBoolean$2(val);
 }
-boolean$1.isntBoolean = isntBoolean$1;
+boolean$2.isntBoolean = isntBoolean$2;
 
-var char$1 = {};
+var char$2 = {};
 
-var string$1 = {};
+var string$2 = {};
 
-string$1.isntString = string$1.isString = void 0;
-function isString$1(val) {
+string$2.isntString = string$2.isString = void 0;
+function isString$2(val) {
     return typeof val === 'string';
 }
-string$1.isString = isString$1;
-function isntString$1(val) {
-    return !isString$1(val);
+string$2.isString = isString$2;
+function isntString$2(val) {
+    return !isString$2(val);
 }
-string$1.isntString = isntString$1;
+string$2.isntString = isntString$2;
 
-char$1.isntChar = char$1.isChar = void 0;
-const string_1$3 = string$1;
-function isChar$1(val) {
-    return (0, string_1$3.isString)(val)
+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$1.isChar = isChar$1;
-function isntChar$1(val) {
-    return !isChar$1(val);
+char$2.isChar = isChar$2;
+function isntChar$2(val) {
+    return !isChar$2(val);
 }
-char$1.isntChar = isntChar$1;
+char$2.isntChar = isntChar$2;
 
-var date$1 = {};
+var date$2 = {};
 
-date$1.isntDate = date$1.isDate = void 0;
-function isDate$1(val) {
+date$2.isntDate = date$2.isDate = void 0;
+function isDate$2(val) {
     return val instanceof Date;
 }
-date$1.isDate = isDate$1;
-function isntDate$1(val) {
-    return !isDate$1(val);
+date$2.isDate = isDate$2;
+function isntDate$2(val) {
+    return !isDate$2(val);
 }
-date$1.isntDate = isntDate$1;
+date$2.isntDate = isntDate$2;
 
-var _enum$1 = {};
+var _enum$2 = {};
 
-_enum$1.inEnum = void 0;
-function inEnum$1(val, _enum) {
+_enum$2.inEnum = void 0;
+function inEnum$2(val, _enum) {
     return Object.values(_enum).includes(val);
 }
-_enum$1.inEnum = inEnum$1;
+_enum$2.inEnum = inEnum$2;
 
-var error$1 = {};
+var error$2 = {};
 
-error$1.isntError = error$1.isError = void 0;
-function isError$1(val) {
+error$2.isntError = error$2.isError = void 0;
+function isError$2(val) {
     return val instanceof Error;
 }
-error$1.isError = isError$1;
-function isntError$1(val) {
-    return !isError$1(val);
+error$2.isError = isError$2;
+function isntError$2(val) {
+    return !isError$2(val);
 }
-error$1.isntError = isntError$1;
+error$2.isntError = isntError$2;
 
-var falsy$1 = {};
+var falsy$2 = {};
 
-falsy$1.isntFalsy = falsy$1.isFalsy = void 0;
-function isFalsy$1(val) {
+falsy$2.isntFalsy = falsy$2.isFalsy = void 0;
+function isFalsy$2(val) {
     return !val;
 }
-falsy$1.isFalsy = isFalsy$1;
-function isntFalsy$1(val) {
-    return !isFalsy$1(val);
+falsy$2.isFalsy = isFalsy$2;
+function isntFalsy$2(val) {
+    return !isFalsy$2(val);
 }
-falsy$1.isntFalsy = isntFalsy$1;
+falsy$2.isntFalsy = isntFalsy$2;
 
-var iterable$1 = {};
+var iterable$2 = {};
 
-iterable$1.isntIterable = iterable$1.isIterable = void 0;
-const null_1$3 = _null$1;
-const undefined_1$3 = _undefined$1;
-const function_1$1 = _function$1;
-function isIterable$1(val) {
-    return (0, null_1$3.isntNull)(val)
-        && (0, undefined_1$3.isntUndefined)(val)
-        && (0, function_1$1.isFunction)(val[Symbol.iterator]);
+iterable$2.isntIterable = iterable$2.isIterable = void 0;
+const null_1$6 = _null$2;
+const undefined_1$5 = _undefined$2;
+const function_1$4 = _function$2;
+function isIterable$2(val) {
+    return (0, null_1$6.isntNull)(val)
+        && (0, undefined_1$5.isntUndefined)(val)
+        && (0, function_1$4.isFunction)(val[Symbol.iterator]);
 }
-iterable$1.isIterable = isIterable$1;
-function isntIterable$1(val) {
-    return !isIterable$1(val);
+iterable$2.isIterable = isIterable$2;
+function isntIterable$2(val) {
+    return !isIterable$2(val);
 }
-iterable$1.isntIterable = isntIterable$1;
+iterable$2.isntIterable = isntIterable$2;
 
-var json$1 = {};
+var json$2 = {};
 
-var number$1 = {};
+var number$2 = {};
 
-number$1.isntNaN = number$1.isNaN = number$1.isNegativeInfinity = number$1.isPositiveInfinity = number$1.isFinite = number$1.isntNumber = number$1.isNumber = void 0;
-function isNumber$1(val) {
+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$1.isNumber = isNumber$1;
-function isntNumber$1(val) {
-    return !isNumber$1(val);
+number$2.isNumber = isNumber$2;
+function isntNumber$2(val) {
+    return !isNumber$2(val);
 }
-number$1.isntNumber = isntNumber$1;
-function isFinite(val) {
+number$2.isntNumber = isntNumber$2;
+function isFinite$1(val) {
     return Number.isFinite(val);
 }
-number$1.isFinite = isFinite;
-function isPositiveInfinity(val) {
+number$2.isFinite = isFinite$1;
+function isPositiveInfinity$1(val) {
     return val === Infinity;
 }
-number$1.isPositiveInfinity = isPositiveInfinity;
-function isNegativeInfinity(val) {
+number$2.isPositiveInfinity = isPositiveInfinity$1;
+function isNegativeInfinity$1(val) {
     return val === -Infinity;
 }
-number$1.isNegativeInfinity = isNegativeInfinity;
-function isNaN(val) {
+number$2.isNegativeInfinity = isNegativeInfinity$1;
+function isNaN$1(val) {
     return Number.isNaN(val);
 }
-number$1.isNaN = isNaN;
-function isntNaN(val) {
-    return !isNaN(val);
+number$2.isNaN = isNaN$1;
+function isntNaN$1(val) {
+    return !isNaN$1(val);
 }
-number$1.isntNaN = isntNaN;
+number$2.isntNaN = isntNaN$1;
 
-var object$1 = {};
+var object$2 = {};
 
 /** Detect free variable `global` from Node.js. */
 
@@ -463,7 +463,7 @@ var objectCtorString$1 = funcToString$1.call(Object);
  * _.isPlainObject(Object.create(null));
  * // => true
  */
-function isPlainObject$3(value) {
+function isPlainObject$4(value) {
   if (!isObjectLike$1(value) || baseGetTag(value) != objectTag$1) {
     return false;
   }
@@ -476,59 +476,59 @@ function isPlainObject$3(value) {
     funcToString$1.call(Ctor) == objectCtorString$1;
 }
 
-var isPlainObject_1$1 = isPlainObject$3;
+var isPlainObject_1$2 = isPlainObject$4;
 
-var __importDefault$1 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+var __importDefault$2 = (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 = __importDefault$1(isPlainObject_1$1);
-function isObject$1(val) {
+};object$2.isntEmptyObject = object$2.isEmptyObject = object$2.isntPlainObject = object$2.isPlainObject = object$2.isntObject = object$2.isObject = void 0;
+const isPlainObject_1$1 = __importDefault$2(isPlainObject_1$2);
+function isObject$2(val) {
     return val !== null
         && typeof val === 'object';
 }
-object$1.isObject = isObject$1;
-function isntObject$1(val) {
-    return !isObject$1(val);
+object$2.isObject = isObject$2;
+function isntObject$2(val) {
+    return !isObject$2(val);
 }
-object$1.isntObject = isntObject$1;
-function isPlainObject$2(val) {
-    return (0, isPlainObject_1.default)(val);
+object$2.isntObject = isntObject$2;
+function isPlainObject$3(val) {
+    return (0, isPlainObject_1$1.default)(val);
 }
-object$1.isPlainObject = isPlainObject$2;
-function isntPlainObject$1(val) {
-    return !isPlainObject$2(val);
+object$2.isPlainObject = isPlainObject$3;
+function isntPlainObject$2(val) {
+    return !isPlainObject$3(val);
 }
-object$1.isntPlainObject = isntPlainObject$1;
-function isEmptyObject$1(val) {
+object$2.isntPlainObject = isntPlainObject$2;
+function isEmptyObject$2(val) {
     return Object.keys(val).length === 0;
 }
-object$1.isEmptyObject = isEmptyObject$1;
-function isntEmptyObject$1(val) {
+object$2.isEmptyObject = isEmptyObject$2;
+function isntEmptyObject$2(val) {
     return Object.keys(val).length !== 0;
 }
-object$1.isntEmptyObject = isntEmptyObject$1;
-
-json$1.isntJsonable = json$1.isJsonable = json$1.isntJson = json$1.isJson = void 0;
-const null_1$2 = _null$1;
-const boolean_1 = boolean$1;
-const string_1$2 = string$1;
-const number_1$1 = number$1;
-const array_1$1 = array$1;
-const object_1$2 = object$1;
-function isJson$1(val) {
-    return (0, null_1$2.isNull)(val)
-        || (0, boolean_1.isBoolean)(val)
-        || (0, string_1$2.isString)(val)
-        || (0, number_1$1.isNumber)(val)
-        || ((0, array_1$1.isArray)(val) && val.every(isJson$1))
-        || ((0, object_1$2.isPlainObject)(val) && Object.values(val).every(isJson$1));
-}
-json$1.isJson = isJson$1;
-function isntJson$1(val) {
-    return !isJson$1(val);
-}
-json$1.isntJson = isntJson$1;
-function isJsonable(val) {
+object$2.isntEmptyObject = isntEmptyObject$2;
+
+json$2.isntJsonable = json$2.isJsonable = json$2.isntJson = json$2.isJson = void 0;
+const null_1$5 = _null$2;
+const boolean_1$1 = boolean$2;
+const string_1$4 = string$2;
+const number_1$2 = number$2;
+const array_1$2 = array$2;
+const object_1$4 = object$2;
+function isJson$2(val) {
+    return (0, null_1$5.isNull)(val)
+        || (0, boolean_1$1.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$4.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$1(val) {
     try {
         JSON.stringify(val);
         return true;
@@ -537,39 +537,39 @@ function isJsonable(val) {
         return false;
     }
 }
-json$1.isJsonable = isJsonable;
-function isntJsonable(val) {
-    return !isntJsonable();
+json$2.isJsonable = isJsonable$1;
+function isntJsonable$1(val) {
+    return !isntJsonable$1();
 }
-json$1.isntJsonable = isntJsonable;
+json$2.isntJsonable = isntJsonable$1;
 
-var promise = {};
+var promise$1 = {};
 
-promise.isPromiseLike = promise.isntPromiseLike = promise.isntPromise = promise.isPromise = void 0;
-const object_1$1 = object$1;
-const function_1 = _function$1;
-function isPromise(val) {
+promise$1.isPromiseLike = promise$1.isntPromiseLike = promise$1.isntPromise = promise$1.isPromise = void 0;
+const object_1$3 = object$2;
+const function_1$3 = _function$2;
+function isPromise$1(val) {
     return val instanceof Promise;
 }
-promise.isPromise = isPromise;
-function isntPromise(val) {
-    return !isPromise(val);
+promise$1.isPromise = isPromise$1;
+function isntPromise$1(val) {
+    return !isPromise$1(val);
 }
-promise.isntPromise = isntPromise;
-function isntPromiseLike(val) {
-    return !isPromiseLike(val);
+promise$1.isntPromise = isntPromise$1;
+function isntPromiseLike$1(val) {
+    return !isPromiseLike$1(val);
 }
-promise.isntPromiseLike = isntPromiseLike;
-function isPromiseLike(val) {
-    return (0, object_1$1.isObject)(val)
-        && (0, function_1.isFunction)(val.then);
+promise$1.isntPromiseLike = isntPromiseLike$1;
+function isPromiseLike$1(val) {
+    return (0, object_1$3.isObject)(val)
+        && (0, function_1$3.isFunction)(val.then);
 }
-promise.isPromiseLike = isPromiseLike;
+promise$1.isPromiseLike = isPromiseLike$1;
 
-var url$1 = {};
+var url$2 = {};
 
-url$1.isAbsoluteURL = void 0;
-function isAbsoluteURL$1(str) {
+url$2.isAbsoluteURL = void 0;
+function isAbsoluteURL$2(str) {
     try {
         new URL(str);
         return true;
@@ -578,7 +578,19 @@ function isAbsoluteURL$1(str) {
         return false;
     }
 }
-url$1.isAbsoluteURL = isAbsoluteURL$1;
+url$2.isAbsoluteURL = isAbsoluteURL$2;
+
+var regexp = {};
+
+regexp.isntRegExp = regexp.isRegExp = void 0;
+function isRegExp(val) {
+    return val instanceof RegExp;
+}
+regexp.isRegExp = isRegExp;
+function isntRegExp(val) {
+    return !isRegExp(val);
+}
+regexp.isntRegExp = isntRegExp;
 
 (function (exports) {
 	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -594,30 +606,31 @@ url$1.isAbsoluteURL = isAbsoluteURL$1;
 	}));
 	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$1, exports);
-	__exportStar(asyncIterable$1, exports);
-	__exportStar(bigint$1, exports);
-	__exportStar(boolean$1, exports);
-	__exportStar(char$1, exports);
-	__exportStar(date$1, exports);
-	__exportStar(_enum$1, exports);
-	__exportStar(error$1, exports);
-	__exportStar(falsy$1, exports);
-	__exportStar(_function$1, exports);
-	__exportStar(iterable$1, exports);
-	__exportStar(json$1, exports);
-	__exportStar(_null$1, exports);
-	__exportStar(number$1, exports);
-	__exportStar(object$1, exports);
-	__exportStar(promise, exports);
-	__exportStar(string$1, exports);
-	__exportStar(_undefined$1, exports);
-	__exportStar(url$1, exports);
+	};__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$1, exports);
+	__exportStar(string$2, exports);
+	__exportStar(_undefined$2, exports);
+	__exportStar(url$2, exports);
+	__exportStar(regexp, exports);
 	
-} (es2018$d));
+} (es2018$e));
 
 function convertConsToArray([value, next]) {
-    if (es2018$d.isNull(next)) {
+    if (es2018$e.isNull(next)) {
         return [value];
     }
     else {
@@ -756,17 +769,17 @@ class Queue {
     }
 }
 
-var es2018$c = {};
+var es2018$d = {};
 
 var customError$2 = {};
 
-var es2018$b = {};
+var es2018$c = {};
 
 var middleware$2 = {};
 
 var chunkAsync$5 = {};
 
-var es2018$a = {};
+var es2018$b = {};
 
 var go$3 = {};
 
@@ -788,19 +801,19 @@ go$3.go = go$2;
 	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 	};__exportStar(go$3, exports);
 	
-} (es2018$a));
+} (es2018$b));
 
-var es2018$9 = {};
+var es2018$a = {};
 
 var customError$1 = {};
 
-var es2018$8 = {};
+var es2018$9 = {};
 
 var middleware$1 = {};
 
 var chunkAsync$4 = {};
 
-var es2018$7 = {};
+var es2018$8 = {};
 
 var customError = {};
 
@@ -878,11 +891,11 @@ assert$5.assert = assert$4;
 	__exportStar(refute$1, exports);
 	__exportStar(assert$5, exports);
 	
-} (es2018$7));
+} (es2018$8));
 
 chunkAsync$4.chunkAsync = void 0;
-const go_1$L = es2018$a;
-const errors_1$L = es2018$7;
+const go_1$L = es2018$b;
+const errors_1$L = es2018$8;
 function chunkAsync$3(iterable, size) {
     (0, errors_1$L.assert)(Number.isInteger(size), 'The parameter size must be an integer');
     (0, errors_1$L.assert)(size > 0, 'The parameter size must be greater than 0');
@@ -903,193 +916,193 @@ chunkAsync$4.chunkAsync = chunkAsync$3;
 
 var chunkByAsync$5 = {};
 
-var es2018$6 = {};
+var es2018$7 = {};
 
-var array = {};
+var array$1 = {};
 
-array.isntEmptyArray = array.isEmptyArray = array.isntArray = array.isArray = void 0;
-function isArray(val) {
+array$1.isntEmptyArray = array$1.isEmptyArray = array$1.isntArray = array$1.isArray = void 0;
+function isArray$1(val) {
     return Array.isArray(val);
 }
-array.isArray = isArray;
-function isntArray(val) {
-    return !isArray(val);
+array$1.isArray = isArray$1;
+function isntArray$1(val) {
+    return !isArray$1(val);
 }
-array.isntArray = isntArray;
-function isEmptyArray(val) {
+array$1.isntArray = isntArray$1;
+function isEmptyArray$1(val) {
     return val.length === 0;
 }
-array.isEmptyArray = isEmptyArray;
-function isntEmptyArray(val) {
+array$1.isEmptyArray = isEmptyArray$1;
+function isntEmptyArray$1(val) {
     return val.length !== 0;
 }
-array.isntEmptyArray = isntEmptyArray;
+array$1.isntEmptyArray = isntEmptyArray$1;
 
-var asyncIterable = {};
+var asyncIterable$1 = {};
 
-var _null = {};
+var _null$1 = {};
 
-_null.isntNull = _null.isNull = void 0;
-function isNull(val) {
+_null$1.isntNull = _null$1.isNull = void 0;
+function isNull$1(val) {
     return val === null;
 }
-_null.isNull = isNull;
-function isntNull(val) {
-    return !isNull(val);
+_null$1.isNull = isNull$1;
+function isntNull$1(val) {
+    return !isNull$1(val);
 }
-_null.isntNull = isntNull;
+_null$1.isntNull = isntNull$1;
 
-var _undefined = {};
+var _undefined$1 = {};
 
-_undefined.isntUndefined = _undefined.isUndefined = void 0;
-function isUndefined(val) {
+_undefined$1.isntUndefined = _undefined$1.isUndefined = void 0;
+function isUndefined$1(val) {
     return val === undefined;
 }
-_undefined.isUndefined = isUndefined;
-function isntUndefined(val) {
-    return !isUndefined(val);
+_undefined$1.isUndefined = isUndefined$1;
+function isntUndefined$1(val) {
+    return !isUndefined$1(val);
 }
-_undefined.isntUndefined = isntUndefined;
+_undefined$1.isntUndefined = isntUndefined$1;
 
-asyncIterable.isntAsyncIterable = asyncIterable.isAsyncIterable = void 0;
-const null_1$1 = _null;
-const undefined_1$2 = _undefined;
-function isAsyncIterable(val) {
-    return (0, null_1$1.isntNull)(val)
-        && (0, undefined_1$2.isntUndefined)(val)
+asyncIterable$1.isntAsyncIterable = asyncIterable$1.isAsyncIterable = void 0;
+const null_1$4 = _null$1;
+const undefined_1$4 = _undefined$1;
+function isAsyncIterable$1(val) {
+    return (0, null_1$4.isntNull)(val)
+        && (0, undefined_1$4.isntUndefined)(val)
         && typeof val[Symbol.asyncIterator] === 'function';
 }
-asyncIterable.isAsyncIterable = isAsyncIterable;
-function isntAsyncIterable(val) {
-    return !isAsyncIterable(val);
+asyncIterable$1.isAsyncIterable = isAsyncIterable$1;
+function isntAsyncIterable$1(val) {
+    return !isAsyncIterable$1(val);
 }
-asyncIterable.isntAsyncIterable = isntAsyncIterable;
+asyncIterable$1.isntAsyncIterable = isntAsyncIterable$1;
 
-var bigint = {};
+var bigint$1 = {};
 
-bigint.isntBigInt = bigint.isBigInt = void 0;
-function isBigInt(val) {
+bigint$1.isntBigInt = bigint$1.isBigInt = void 0;
+function isBigInt$1(val) {
     return typeof val === 'bigint';
 }
-bigint.isBigInt = isBigInt;
-function isntBigInt(val) {
-    return !isBigInt(val);
+bigint$1.isBigInt = isBigInt$1;
+function isntBigInt$1(val) {
+    return !isBigInt$1(val);
 }
-bigint.isntBigInt = isntBigInt;
+bigint$1.isntBigInt = isntBigInt$1;
 
-var boolean = {};
+var boolean$1 = {};
 
-boolean.isntBoolean = boolean.isBoolean = void 0;
-function isBoolean(val) {
+boolean$1.isntBoolean = boolean$1.isBoolean = void 0;
+function isBoolean$1(val) {
     return typeof val === 'boolean';
 }
-boolean.isBoolean = isBoolean;
-function isntBoolean(val) {
-    return !isBoolean(val);
+boolean$1.isBoolean = isBoolean$1;
+function isntBoolean$1(val) {
+    return !isBoolean$1(val);
 }
-boolean.isntBoolean = isntBoolean;
+boolean$1.isntBoolean = isntBoolean$1;
 
-var char = {};
+var char$1 = {};
 
-var string = {};
+var string$1 = {};
 
-string.isntString = string.isString = void 0;
-function isString(val) {
+string$1.isntString = string$1.isString = void 0;
+function isString$1(val) {
     return typeof val === 'string';
 }
-string.isString = isString;
-function isntString(val) {
-    return !isString(val);
+string$1.isString = isString$1;
+function isntString$1(val) {
+    return !isString$1(val);
 }
-string.isntString = isntString;
+string$1.isntString = isntString$1;
 
-char.isntChar = char.isChar = void 0;
-const string_1$1 = string;
-function isChar(val) {
-    return (0, string_1$1.isString)(val)
+char$1.isntChar = char$1.isChar = void 0;
+const string_1$3 = string$1;
+function isChar$1(val) {
+    return (0, string_1$3.isString)(val)
         && val.length === 1;
 }
-char.isChar = isChar;
-function isntChar(val) {
-    return !isChar(val);
+char$1.isChar = isChar$1;
+function isntChar$1(val) {
+    return !isChar$1(val);
 }
-char.isntChar = isntChar;
+char$1.isntChar = isntChar$1;
 
-var date = {};
+var date$1 = {};
 
-date.isntDate = date.isDate = void 0;
-function isDate(val) {
+date$1.isntDate = date$1.isDate = void 0;
+function isDate$1(val) {
     return val instanceof Date;
 }
-date.isDate = isDate;
-function isntDate(val) {
-    return !isDate(val);
+date$1.isDate = isDate$1;
+function isntDate$1(val) {
+    return !isDate$1(val);
 }
-date.isntDate = isntDate;
+date$1.isntDate = isntDate$1;
 
-var _enum = {};
+var _enum$1 = {};
 
-_enum.inEnum = void 0;
-function inEnum(val, _enum) {
+_enum$1.inEnum = void 0;
+function inEnum$1(val, _enum) {
     return Object.values(_enum).includes(val);
 }
-_enum.inEnum = inEnum;
+_enum$1.inEnum = inEnum$1;
 
-var error = {};
+var error$1 = {};
 
-error.isntError = error.isError = void 0;
-function isError(val) {
+error$1.isntError = error$1.isError = void 0;
+function isError$1(val) {
     return val instanceof Error;
 }
-error.isError = isError;
-function isntError(val) {
-    return !isError(val);
+error$1.isError = isError$1;
+function isntError$1(val) {
+    return !isError$1(val);
 }
-error.isntError = isntError;
+error$1.isntError = isntError$1;
 
-var falsy = {};
+var falsy$1 = {};
 
-falsy.isntFalsy = falsy.isFalsy = void 0;
-function isFalsy(val) {
+falsy$1.isntFalsy = falsy$1.isFalsy = void 0;
+function isFalsy$1(val) {
     return !val;
 }
-falsy.isFalsy = isFalsy;
-function isntFalsy(val) {
-    return !isFalsy(val);
+falsy$1.isFalsy = isFalsy$1;
+function isntFalsy$1(val) {
+    return !isFalsy$1(val);
 }
-falsy.isntFalsy = isntFalsy;
+falsy$1.isntFalsy = isntFalsy$1;
 
-var _function = {};
+var _function$1 = {};
 
-_function.isntFunction = _function.isFunction = void 0;
-function isFunction$1(val) {
+_function$1.isntFunction = _function$1.isFunction = void 0;
+function isFunction$2(val) {
     return typeof val === 'function';
 }
-_function.isFunction = isFunction$1;
-function isntFunction(val) {
-    return !isFunction$1(val);
+_function$1.isFunction = isFunction$2;
+function isntFunction$1(val) {
+    return !isFunction$2(val);
 }
-_function.isntFunction = isntFunction;
+_function$1.isntFunction = isntFunction$1;
 
-var iterable = {};
+var iterable$1 = {};
 
-iterable.isntIterable = iterable.isIterable = void 0;
-const null_1 = _null;
-const undefined_1$1 = _undefined;
-function isIterable(val) {
-    return (0, null_1.isntNull)(val)
-        && (0, undefined_1$1.isntUndefined)(val)
+iterable$1.isntIterable = iterable$1.isIterable = void 0;
+const null_1$3 = _null$1;
+const undefined_1$3 = _undefined$1;
+function isIterable$1(val) {
+    return (0, null_1$3.isntNull)(val)
+        && (0, undefined_1$3.isntUndefined)(val)
         && typeof val[Symbol.iterator] === 'function';
 }
-iterable.isIterable = isIterable;
-function isntIterable(val) {
-    return !isIterable(val);
+iterable$1.isIterable = isIterable$1;
+function isntIterable$1(val) {
+    return !isIterable$1(val);
 }
-iterable.isntIterable = isntIterable;
+iterable$1.isntIterable = isntIterable$1;
 
 var jsonRpc = {};
 
-var object = {};
+var object$1 = {};
 
 /**
  * lodash (Custom Build) <https://lodash.com/>
@@ -1215,7 +1228,7 @@ function isObjectLike(value) {
  * _.isPlainObject(Object.create(null));
  * // => true
  */
-function isPlainObject$1(value) {
+function isPlainObject$2(value) {
   if (!isObjectLike(value) ||
       objectToString.call(value) != objectTag || isHostObject(value)) {
     return false;
@@ -1229,67 +1242,67 @@ function isPlainObject$1(value) {
     Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString);
 }
 
-var lodash_isplainobject = isPlainObject$1;
+var lodash_isplainobject = isPlainObject$2;
 
-var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+var __importDefault$1 = (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 lodash_isplainobject_1 = __importDefault(lodash_isplainobject);
-function isObject(val) {
+};object$1.isntEmptyObject = object$1.isEmptyObject = object$1.isntPlainObject = object$1.isPlainObject = object$1.isntObject = object$1.isObject = void 0;
+const lodash_isplainobject_1 = __importDefault$1(lodash_isplainobject);
+function isObject$1(val) {
     return val !== null
         && typeof val === 'object';
 }
-object.isObject = isObject;
-function isntObject(val) {
-    return !isObject(val);
+object$1.isObject = isObject$1;
+function isntObject$1(val) {
+    return !isObject$1(val);
 }
-object.isntObject = isntObject;
-function isPlainObject(val) {
+object$1.isntObject = isntObject$1;
+function isPlainObject$1(val) {
     return (0, lodash_isplainobject_1.default)(val);
 }
-object.isPlainObject = isPlainObject;
-function isntPlainObject(val) {
-    return !isPlainObject(val);
+object$1.isPlainObject = isPlainObject$1;
+function isntPlainObject$1(val) {
+    return !isPlainObject$1(val);
 }
-object.isntPlainObject = isntPlainObject;
-function isEmptyObject(val) {
+object$1.isntPlainObject = isntPlainObject$1;
+function isEmptyObject$1(val) {
     return Object.keys(val).length === 0;
 }
-object.isEmptyObject = isEmptyObject;
-function isntEmptyObject(val) {
+object$1.isEmptyObject = isEmptyObject$1;
+function isntEmptyObject$1(val) {
     return Object.keys(val).length !== 0;
 }
-object.isntEmptyObject = isntEmptyObject;
+object$1.isntEmptyObject = isntEmptyObject$1;
 
-var number = {};
+var number$1 = {};
 
-number.isntNumber = number.isNumber = void 0;
-function isNumber(val) {
+number$1.isntNumber = number$1.isNumber = void 0;
+function isNumber$1(val) {
     return typeof val === 'number';
 }
-number.isNumber = isNumber;
-function isntNumber(val) {
-    return !isNumber(val);
+number$1.isNumber = isNumber$1;
+function isntNumber$1(val) {
+    return !isNumber$1(val);
 }
-number.isntNumber = isntNumber;
+number$1.isntNumber = isntNumber$1;
 
 jsonRpc.isntJsonRpcError = jsonRpc.isJsonRpcError = jsonRpc.isntJsonRpcSuccess = jsonRpc.isJsonRpcSuccess = jsonRpc.isntJsonRpcRequest = jsonRpc.isJsonRpcRequest = jsonRpc.isntJsonRpcNotification = jsonRpc.isJsonRpcNotification = void 0;
-const array_1 = array;
-const object_1 = object;
-const string_1 = string;
-const number_1 = number;
-const undefined_1 = _undefined;
+const array_1$1 = array$1;
+const object_1$2 = object$1;
+const string_1$2 = string$1;
+const number_1$1 = number$1;
+const undefined_1$2 = _undefined$1;
 function isJsonRpcId(val) {
-    return (0, string_1.isString)(val) || (0, number_1.isNumber)(val);
+    return (0, string_1$2.isString)(val) || (0, number_1$1.isNumber)(val);
 }
 function isJsonRpcParams(val) {
-    return (0, array_1.isArray)(val) || (0, object_1.isObject)(val);
+    return (0, array_1$1.isArray)(val) || (0, object_1$2.isObject)(val);
 }
 function isJsonRpcNotification(val) {
-    return (0, object_1.isPlainObject)(val)
-        && (0, string_1.isString)(val.jsonrpc)
-        && (0, string_1.isString)(val.method)
-        && (0, undefined_1.isUndefined)(val.id)
+    return (0, object_1$2.isPlainObject)(val)
+        && (0, string_1$2.isString)(val.jsonrpc)
+        && (0, string_1$2.isString)(val.method)
+        && (0, undefined_1$2.isUndefined)(val.id)
         && isJsonRpcParams(val.params);
 }
 jsonRpc.isJsonRpcNotification = isJsonRpcNotification;
@@ -1298,9 +1311,9 @@ function isntJsonRpcNotification(val) {
 }
 jsonRpc.isntJsonRpcNotification = isntJsonRpcNotification;
 function isJsonRpcRequest(val) {
-    return (0, object_1.isPlainObject)(val)
-        && (0, string_1.isString)(val.jsonrpc)
-        && (0, string_1.isString)(val.method)
+    return (0, object_1$2.isPlainObject)(val)
+        && (0, string_1$2.isString)(val.jsonrpc)
+        && (0, string_1$2.isString)(val.method)
         && isJsonRpcId(val.id)
         && isJsonRpcParams(val.params);
 }
@@ -1310,9 +1323,9 @@ function isntJsonRpcRequest(val) {
 }
 jsonRpc.isntJsonRpcRequest = isntJsonRpcRequest;
 function isJsonRpcSuccess(val) {
-    return (0, object_1.isPlainObject)(val)
-        && (0, string_1.isString)(val.jsonrpc)
-        && (0, string_1.isString)(val.id)
+    return (0, object_1$2.isPlainObject)(val)
+        && (0, string_1$2.isString)(val.jsonrpc)
+        && (0, string_1$2.isString)(val.id)
         && 'result' in val;
 }
 jsonRpc.isJsonRpcSuccess = isJsonRpcSuccess;
@@ -1321,8 +1334,8 @@ function isntJsonRpcSuccess(val) {
 }
 jsonRpc.isntJsonRpcSuccess = isntJsonRpcSuccess;
 function isJsonRpcError(val) {
-    return (0, object_1.isPlainObject)(val)
-        && (0, string_1.isString)(val.jsonrpc)
+    return (0, object_1$2.isPlainObject)(val)
+        && (0, string_1$2.isString)(val.jsonrpc)
         && isJsonRpcId(val.id)
         && isJsonRpcErrorObject(val.error);
 }
@@ -1332,16 +1345,16 @@ function isntJsonRpcError(val) {
 }
 jsonRpc.isntJsonRpcError = isntJsonRpcError;
 function isJsonRpcErrorObject(val) {
-    return (0, object_1.isPlainObject)(val)
-        && (0, number_1.isNumber)(val.code)
-        && (0, string_1.isString)(val.message)
-        && ((0, undefined_1.isUndefined)(val.data) || (0, object_1.isObject)(val.data));
+    return (0, object_1$2.isPlainObject)(val)
+        && (0, number_1$1.isNumber)(val.code)
+        && (0, string_1$2.isString)(val.message)
+        && ((0, undefined_1$2.isUndefined)(val.data) || (0, object_1$2.isObject)(val.data));
 }
 
-var json = {};
+var json$1 = {};
 
-json.isntJson = json.isJson = void 0;
-function isJson(val) {
+json$1.isntJson = json$1.isJson = void 0;
+function isJson$1(val) {
     try {
         JSON.stringify(val);
         return true;
@@ -1350,16 +1363,16 @@ function isJson(val) {
         return false;
     }
 }
-json.isJson = isJson;
-function isntJson(val) {
-    return !isntJson();
+json$1.isJson = isJson$1;
+function isntJson$1(val) {
+    return !isntJson$1();
 }
-json.isntJson = isntJson;
+json$1.isntJson = isntJson$1;
 
-var url = {};
+var url$1 = {};
 
-url.isAbsoluteURL = void 0;
-function isAbsoluteURL(str) {
+url$1.isAbsoluteURL = void 0;
+function isAbsoluteURL$1(str) {
     try {
         new URL(str);
         return true;
@@ -1368,7 +1381,7 @@ function isAbsoluteURL(str) {
         return false;
     }
 }
-url.isAbsoluteURL = isAbsoluteURL;
+url$1.isAbsoluteURL = isAbsoluteURL$1;
 
 (function (exports) {
 	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -1380,30 +1393,30 @@ url.isAbsoluteURL = isAbsoluteURL;
 	}));
 	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, exports);
-	__exportStar(asyncIterable, exports);
-	__exportStar(bigint, exports);
-	__exportStar(boolean, exports);
-	__exportStar(char, exports);
-	__exportStar(date, exports);
-	__exportStar(_enum, exports);
-	__exportStar(error, exports);
-	__exportStar(falsy, exports);
-	__exportStar(_function, exports);
-	__exportStar(iterable, exports);
-	__exportStar(jsonRpc, exports);
-	__exportStar(json, exports);
-	__exportStar(_null, exports);
-	__exportStar(number, exports);
-	__exportStar(object, exports);
-	__exportStar(string, exports);
-	__exportStar(_undefined, exports);
-	__exportStar(url, exports);
+	};__exportStar(array$1, exports);
+	__exportStar(asyncIterable$1, exports);
+	__exportStar(bigint$1, exports);
+	__exportStar(boolean$1, exports);
+	__exportStar(char$1, exports);
+	__exportStar(date$1, exports);
+	__exportStar(_enum$1, exports);
+	__exportStar(error$1, exports);
+	__exportStar(falsy$1, exports);
+	__exportStar(_function$1, exports);
+	__exportStar(iterable$1, exports);
+	__exportStar(jsonRpc, exports);
+	__exportStar(json$1, exports);
+	__exportStar(_null$1, exports);
+	__exportStar(number$1, exports);
+	__exportStar(object$1, exports);
+	__exportStar(string$1, exports);
+	__exportStar(_undefined$1, exports);
+	__exportStar(url$1, exports);
 	
-} (es2018$6));
+} (es2018$7));
 
 chunkByAsync$5.chunkByAsync = void 0;
-const types_1$X = es2018$6;
+const types_1$X = es2018$7;
 function chunkByAsync$4(iterable, predicate) {
     if ((0, types_1$X.isAsyncIterable)(iterable)) {
         return chunkByAsyncIterable(iterable);
@@ -1464,8 +1477,8 @@ chunkBy$5.chunkBy = chunkBy$4;
 var chunk$5 = {};
 
 chunk$5.chunk = void 0;
-const go_1$K = es2018$a;
-const errors_1$K = es2018$7;
+const go_1$K = es2018$b;
+const errors_1$K = es2018$8;
 function chunk$4(iterable, size) {
     (0, errors_1$K.assert)(Number.isInteger(size), 'The parameter size must be an integer');
     (0, errors_1$K.assert)(size > 0, 'The parameter size must be greater than 0');
@@ -1487,8 +1500,8 @@ chunk$5.chunk = chunk$4;
 var concatAsync$5 = {};
 
 concatAsync$5.concatAsync = void 0;
-const types_1$W = es2018$6;
-const go_1$J = es2018$a;
+const types_1$W = es2018$7;
+const go_1$J = es2018$b;
 function concatAsync$4(iterable, ...otherIterables) {
     return (0, go_1$J.go)(async function* () {
         for (const iter of [iterable, ...otherIterables]) {
@@ -1510,7 +1523,7 @@ concatAsync$5.concatAsync = concatAsync$4;
 var concat$5 = {};
 
 concat$5.concat = void 0;
-const go_1$I = es2018$a;
+const go_1$I = es2018$b;
 function concat$4(iterable, ...otherIterables) {
     return (0, go_1$I.go)(function* () {
         for (const iter of [iterable, ...otherIterables]) {
@@ -1539,9 +1552,9 @@ function* copyIterable$2(iterable) {
 utils$2.copyIterable = copyIterable$2;
 
 dropAsync$5.dropAsync = void 0;
-const go_1$H = es2018$a;
+const go_1$H = es2018$b;
 const utils_1$b = utils$2;
-const errors_1$J = es2018$7;
+const errors_1$J = es2018$8;
 function dropAsync$4(iterable, count) {
     (0, errors_1$J.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1$J.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
@@ -1574,9 +1587,9 @@ dropAsync$5.dropAsync = dropAsync$4;
 var dropRightAsync$5 = {};
 
 dropRightAsync$5.dropRightAsync = void 0;
-const go_1$G = es2018$a;
+const go_1$G = es2018$b;
 const utils_1$a = utils$2;
-const errors_1$I = es2018$7;
+const errors_1$I = es2018$8;
 function dropRightAsync$4(iterable, count) {
     (0, errors_1$I.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1$I.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
@@ -1602,9 +1615,9 @@ async function toArrayAsync$8(iterable) {
 var dropRight$5 = {};
 
 dropRight$5.dropRight = void 0;
-const go_1$F = es2018$a;
+const go_1$F = es2018$b;
 const utils_1$9 = utils$2;
-const errors_1$H = es2018$7;
+const errors_1$H = es2018$8;
 function dropRight$4(iterable, count) {
     (0, errors_1$H.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1$H.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
@@ -1620,7 +1633,7 @@ dropRight$5.dropRight = dropRight$4;
 var dropUntilAsync$5 = {};
 
 dropUntilAsync$5.dropUntilAsync = void 0;
-const types_1$V = es2018$6;
+const types_1$V = es2018$7;
 function dropUntilAsync$4(iterable, predicate) {
     if ((0, types_1$V.isAsyncIterable)(iterable)) {
         return dropUntilAsyncIterable(iterable);
@@ -1702,9 +1715,9 @@ dropUntil$5.dropUntil = dropUntil$4;
 var drop$5 = {};
 
 drop$5.drop = void 0;
-const go_1$E = es2018$a;
+const go_1$E = es2018$b;
 const utils_1$8 = utils$2;
-const errors_1$G = es2018$7;
+const errors_1$G = es2018$8;
 function drop$4(iterable, count) {
     (0, errors_1$G.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1$G.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
@@ -1737,7 +1750,7 @@ drop$5.drop = drop$4;
 var filterAsync$5 = {};
 
 filterAsync$5.filterAsync = void 0;
-const types_1$U = es2018$6;
+const types_1$U = es2018$7;
 function filterAsync$4(iterable, predicate) {
     if ((0, types_1$U.isAsyncIterable)(iterable)) {
         return filterAsyncIterable(iterable);
@@ -1784,7 +1797,7 @@ var flattenDeepAsync$5 = {};
 var flattenByAsync$5 = {};
 
 flattenByAsync$5.flattenByAsync = void 0;
-const types_1$T = es2018$6;
+const types_1$T = es2018$7;
 function flattenByAsync$4(iterable, predicate) {
     if ((0, types_1$T.isAsyncIterable)(iterable)) {
         return flattenByAsyncIterable(iterable);
@@ -1824,7 +1837,7 @@ function isFiniteIterable$5(val) {
 
 flattenDeepAsync$5.flattenDeepAsync = void 0;
 const flatten_by_async_1$2 = flattenByAsync$5;
-const errors_1$F = es2018$7;
+const errors_1$F = es2018$8;
 function flattenDeepAsync$4(iterable, depth = Infinity) {
     (0, errors_1$F.assert)(depth === Infinity || Number.isInteger(depth), 'The parameter depth must be an integer');
     (0, errors_1$F.assert)(depth >= 0, 'The parameter depth must be greater than or equal to 0');
@@ -1842,7 +1855,7 @@ flattenAsync$5.flattenAsync = flattenAsync$4;
 var flattenBy$5 = {};
 
 flattenBy$5.flattenBy = void 0;
-const types_1$S = es2018$6;
+const types_1$S = es2018$7;
 function flattenBy$4(iterable, predicate) {
     return flatten(iterable, 1);
     function* flatten(iterable, level) {
@@ -1865,7 +1878,7 @@ var flattenDeep$5 = {};
 
 flattenDeep$5.flattenDeep = void 0;
 const flatten_by_1$2 = flattenBy$5;
-const errors_1$E = es2018$7;
+const errors_1$E = es2018$8;
 function flattenDeep$4(iterable, depth = Infinity) {
     (0, errors_1$E.assert)(depth === Infinity || Number.isInteger(depth), 'The parameter depth must be an integer');
     (0, errors_1$E.assert)(depth >= 0, 'The parameter depth must be greater than or equal to 0');
@@ -1885,7 +1898,7 @@ flatten$5.flatten = flatten$4;
 var mapAsync$5 = {};
 
 mapAsync$5.mapAsync = void 0;
-const types_1$R = es2018$6;
+const types_1$R = es2018$7;
 function mapAsync$4(iterable, fn) {
     if ((0, types_1$R.isAsyncIterable)(iterable)) {
         return mapAsyncIterable(iterable);
@@ -1925,8 +1938,8 @@ map$5.map = map$4;
 var repeatAsync$5 = {};
 
 repeatAsync$5.repeatAsync = void 0;
-const go_1$D = es2018$a;
-const errors_1$D = es2018$7;
+const go_1$D = es2018$b;
+const errors_1$D = es2018$8;
 function repeatAsync$4(iterable, times) {
     (0, errors_1$D.assert)(times === Infinity || Number.isInteger(times), 'The parameter times must be an integer');
     (0, errors_1$D.assert)(times >= 0, 'The parameter times must be greater than or equal to 0');
@@ -1960,8 +1973,8 @@ function isProduction$5() {
 var repeat$5 = {};
 
 repeat$5.repeat = void 0;
-const go_1$C = es2018$a;
-const errors_1$C = es2018$7;
+const go_1$C = es2018$b;
+const errors_1$C = es2018$8;
 function repeat$4(iterable, times) {
     (0, errors_1$C.assert)(times === Infinity || Number.isInteger(times), 'The parameter times must be an integer');
     (0, errors_1$C.assert)(times >= 0, 'The parameter times must be greater than or equal to 0');
@@ -1995,8 +2008,8 @@ function isProduction$4() {
 var sliceAsync$5 = {};
 
 sliceAsync$5.sliceAsync = void 0;
-const go_1$B = es2018$a;
-const errors_1$B = es2018$7;
+const go_1$B = es2018$b;
+const errors_1$B = es2018$8;
 function sliceAsync$4(iterable, start, end = Infinity) {
     (0, errors_1$B.assert)(Number.isInteger(start), 'The parameter start must be an integer');
     (0, errors_1$B.assert)(start >= 0, 'The parameter start must be greater than or equal to 0');
@@ -2018,8 +2031,8 @@ sliceAsync$5.sliceAsync = sliceAsync$4;
 var slice$5 = {};
 
 slice$5.slice = void 0;
-const go_1$A = es2018$a;
-const errors_1$A = es2018$7;
+const go_1$A = es2018$b;
+const errors_1$A = es2018$8;
 function slice$4(iterable, start, end = Infinity) {
     (0, errors_1$A.assert)(Number.isInteger(start), 'The parameter start must be an integer');
     (0, errors_1$A.assert)(start >= 0, 'The parameter start must be greater than or equal to 0');
@@ -2059,7 +2072,7 @@ splitAsync$5.splitAsync = splitAsync$4;
 var splitByAsync$5 = {};
 
 splitByAsync$5.splitByAsync = void 0;
-const types_1$Q = es2018$6;
+const types_1$Q = es2018$7;
 function splitByAsync$4(iterable, predicate) {
     if ((0, types_1$Q.isAsyncIterable)(iterable)) {
         return splitByAsyncIterable(iterable);
@@ -2141,8 +2154,8 @@ split$5.split = split$4;
 var takeAsync$5 = {};
 
 takeAsync$5.takeAsync = void 0;
-const go_1$z = es2018$a;
-const errors_1$z = es2018$7;
+const go_1$z = es2018$b;
+const errors_1$z = es2018$8;
 function takeAsync$4(iterable, count) {
     (0, errors_1$z.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1$z.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
@@ -2162,8 +2175,8 @@ takeAsync$5.takeAsync = takeAsync$4;
 var takeRightAsync$5 = {};
 
 takeRightAsync$5.takeRightAsync = void 0;
-const go_1$y = es2018$a;
-const errors_1$y = es2018$7;
+const go_1$y = es2018$b;
+const errors_1$y = es2018$8;
 function takeRightAsync$4(iterable, count) {
     (0, errors_1$y.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1$y.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
@@ -2192,8 +2205,8 @@ takeRightAsync$5.takeRightAsync = takeRightAsync$4;
 var takeRight$5 = {};
 
 takeRight$5.takeRight = void 0;
-const go_1$x = es2018$a;
-const errors_1$x = es2018$7;
+const go_1$x = es2018$b;
+const errors_1$x = es2018$8;
 function takeRight$4(iterable, count) {
     (0, errors_1$x.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1$x.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
@@ -2222,7 +2235,7 @@ takeRight$5.takeRight = takeRight$4;
 var takeUntilAsync$5 = {};
 
 takeUntilAsync$5.takeUntilAsync = void 0;
-const types_1$P = es2018$6;
+const types_1$P = es2018$7;
 function takeUntilAsync$4(iterable, predicate) {
     if ((0, types_1$P.isAsyncIterable)(iterable)) {
         return takeUntilAsyncIterable(iterable);
@@ -2268,8 +2281,8 @@ takeUntil$5.takeUntil = takeUntil$4;
 var take$5 = {};
 
 take$5.take = void 0;
-const go_1$w = es2018$a;
-const errors_1$w = es2018$7;
+const go_1$w = es2018$b;
+const errors_1$w = es2018$8;
 function take$4(iterable, count) {
     (0, errors_1$w.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1$w.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
@@ -2289,7 +2302,7 @@ take$5.take = take$4;
 var tapAsync$5 = {};
 
 tapAsync$5.tapAsync = void 0;
-const types_1$O = es2018$6;
+const types_1$O = es2018$7;
 function tapAsync$4(iterable, fn) {
     if ((0, types_1$O.isAsyncIterable)(iterable)) {
         return tapAsyncIterable(iterable);
@@ -2372,7 +2385,7 @@ uniqAsync$5.uniqAsync = uniqAsync$4;
 var uniqByAsync$5 = {};
 
 uniqByAsync$5.uniqByAsync = void 0;
-const types_1$N = es2018$6;
+const types_1$N = es2018$7;
 function uniqByAsync$4(iterable, fn) {
     if ((0, types_1$N.isAsyncIterable)(iterable)) {
         return uniqByAsyncIterable(iterable);
@@ -2441,7 +2454,7 @@ uniq$5.uniq = uniq$4;
 var zipAsync$5 = {};
 
 zipAsync$5.zipAsync = void 0;
-const types_1$M = es2018$6;
+const types_1$M = es2018$7;
 var Kind$2;
 (function (Kind) {
     Kind[Kind["Sync"] = 0] = "Sync";
@@ -2601,7 +2614,7 @@ consume$5.consume = consume$4;
 var eachAsync$5 = {};
 
 eachAsync$5.eachAsync = void 0;
-const types_1$L = es2018$6;
+const types_1$L = es2018$7;
 function eachAsync$4(iterable, fn) {
     if ((0, types_1$L.isAsyncIterable)(iterable)) {
         return eachAsyncIterable(iterable);
@@ -2641,7 +2654,7 @@ each$5.each = each$4;
 var everyAsync$5 = {};
 
 everyAsync$5.everyAsync = void 0;
-const types_1$K = es2018$6;
+const types_1$K = es2018$7;
 function everyAsync$4(iterable, predicate) {
     if ((0, types_1$K.isAsyncIterable)(iterable)) {
         return everyAsyncIterable(iterable);
@@ -2687,7 +2700,7 @@ every$5.every = every$4;
 var findAsync$5 = {};
 
 findAsync$5.findAsync = void 0;
-const types_1$J = es2018$6;
+const types_1$J = es2018$7;
 function findAsync$4(iterable, predicate) {
     if ((0, types_1$J.isAsyncIterable)(iterable)) {
         return findAsyncIterable(iterable);
@@ -2811,7 +2824,7 @@ match$5.match = match$4;
 var reduceAsync$5 = {};
 
 reduceAsync$5.reduceAsync = void 0;
-const types_1$I = es2018$6;
+const types_1$I = es2018$7;
 function reduceAsync$4(iterable, fn, initialValue) {
     if ((0, types_1$I.isUndefined)(initialValue)) {
         return reduceAsyncWithoutInitialValue$2(iterable, fn);
@@ -2907,7 +2920,7 @@ function reduceAsyncWithoutInitialValue$2(iterable, fn) {
 var reduce$5 = {};
 
 reduce$5.reduce = void 0;
-const types_1$H = es2018$6;
+const types_1$H = es2018$7;
 function reduce$4(iterable, fn, initialValue) {
     if ((0, types_1$H.isUndefined)(initialValue)) {
         return reduceWithoutInitialValue$2(iterable, fn);
@@ -2954,7 +2967,7 @@ function reduceWithoutInitialValue$2(iterable, fn) {
 var someAsync$5 = {};
 
 someAsync$5.someAsync = void 0;
-const types_1$G = es2018$6;
+const types_1$G = es2018$7;
 function someAsync$4(iterable, predicate) {
     if ((0, types_1$G.isAsyncIterable)(iterable)) {
         return someAsyncIterable(iterable);
@@ -3138,7 +3151,7 @@ toSet$5.toSet = toSet$4;
 	};__exportStar(middleware$1, exports);
 	__exportStar(output$2, exports);
 	
-} (es2018$8));
+} (es2018$9));
 
 var getErrorNames$3 = {};
 
@@ -3156,7 +3169,7 @@ function* traverseErrorPrototypeChain$2(err) {
 traverseErrorPrototypeChain$3.traverseErrorPrototypeChain = traverseErrorPrototypeChain$2;
 
 getErrorNames$3.getErrorNames = void 0;
-const types_1$F = es2018$6;
+const types_1$F = es2018$7;
 const traverse_error_prototype_chain_1$1 = traverseErrorPrototypeChain$3;
 function* getErrorNames$2(err) {
     var _a;
@@ -3177,7 +3190,7 @@ getErrorNames$3.getErrorNames = getErrorNames$2;
 var serializableError$1 = {};
 
 serializableError$1.isSerializableError = void 0;
-const types_1$E = es2018$6;
+const types_1$E = es2018$7;
 function isSerializableError$1(val) {
     return (0, types_1$E.isObject)(val)
         && (0, types_1$E.isString)(val.name)
@@ -3188,9 +3201,9 @@ function isSerializableError$1(val) {
 serializableError$1.isSerializableError = isSerializableError$1;
 
 customError$1.CustomError = void 0;
-const iterable_operator_1$3 = es2018$8;
+const iterable_operator_1$3 = es2018$9;
 const get_error_names_1$3 = getErrorNames$3;
-const types_1$D = es2018$6;
+const types_1$D = es2018$7;
 const serializable_error_1$1 = serializableError$1;
 class CustomError$1 extends Error {
     get name() {
@@ -3226,7 +3239,7 @@ var normalize$3 = {};
 
 normalize$3.normalize = void 0;
 const get_error_names_1$2 = getErrorNames$3;
-const iterable_operator_1$2 = es2018$8;
+const iterable_operator_1$2 = es2018$9;
 function normalize$2(err) {
     var _a;
     const [name, ...ancestors] = (0, iterable_operator_1$2.toArray)((0, get_error_names_1$2.getErrorNames)(err));
@@ -3241,7 +3254,7 @@ normalize$3.normalize = normalize$2;
 
 var hydrate$3 = {};
 
-var es2018$5 = {};
+var es2018$6 = {};
 
 var pass$3 = {};
 
@@ -3261,10 +3274,10 @@ pass$3.pass = pass$2;
 	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 	};__exportStar(pass$3, exports);
 	
-} (es2018$5));
+} (es2018$6));
 
 hydrate$3.hydrate = void 0;
-const pass_1$1 = es2018$5;
+const pass_1$1 = es2018$6;
 function hydrate$2(err) {
     var _a;
     const errorNames = [err.name, ...err.ancestors]
@@ -3318,11 +3331,11 @@ assert$3.assert = assert$2;
 	__exportStar(getErrorNames$3, exports);
 	__exportStar(traverseErrorPrototypeChain$3, exports);
 	
-} (es2018$9));
+} (es2018$a));
 
 chunkAsync$5.chunkAsync = void 0;
-const go_1$v = es2018$a;
-const errors_1$v = es2018$9;
+const go_1$v = es2018$b;
+const errors_1$v = es2018$a;
 function chunkAsync$2(iterable, size) {
     (0, errors_1$v.assert)(Number.isInteger(size), 'The parameter size must be an integer');
     (0, errors_1$v.assert)(size > 0, 'The parameter size must be greater than 0');
@@ -3344,7 +3357,7 @@ chunkAsync$5.chunkAsync = chunkAsync$2;
 var chunkByAsync$3 = {};
 
 chunkByAsync$3.chunkByAsync = void 0;
-const types_1$C = es2018$6;
+const types_1$C = es2018$7;
 function chunkByAsync$2(iterable, predicate) {
     if ((0, types_1$C.isAsyncIterable)(iterable)) {
         return chunkByAsyncIterable(iterable);
@@ -3405,8 +3418,8 @@ chunkBy$3.chunkBy = chunkBy$2;
 var chunk$3 = {};
 
 chunk$3.chunk = void 0;
-const go_1$u = es2018$a;
-const errors_1$u = es2018$9;
+const go_1$u = es2018$b;
+const errors_1$u = es2018$a;
 function chunk$2(iterable, size) {
     (0, errors_1$u.assert)(Number.isInteger(size), 'The parameter size must be an integer');
     (0, errors_1$u.assert)(size > 0, 'The parameter size must be greater than 0');
@@ -3428,8 +3441,8 @@ chunk$3.chunk = chunk$2;
 var concatAsync$3 = {};
 
 concatAsync$3.concatAsync = void 0;
-const types_1$B = es2018$6;
-const go_1$t = es2018$a;
+const types_1$B = es2018$7;
+const go_1$t = es2018$b;
 function concatAsync$2(iterable, ...otherIterables) {
     return (0, go_1$t.go)(async function* () {
         for (const iter of [iterable, ...otherIterables]) {
@@ -3451,7 +3464,7 @@ concatAsync$3.concatAsync = concatAsync$2;
 var concat$3 = {};
 
 concat$3.concat = void 0;
-const go_1$s = es2018$a;
+const go_1$s = es2018$b;
 function concat$2(iterable, ...otherIterables) {
     return (0, go_1$s.go)(function* () {
         for (const iter of [iterable, ...otherIterables]) {
@@ -3480,9 +3493,9 @@ function* copyIterable$1(iterable) {
 utils$1.copyIterable = copyIterable$1;
 
 dropAsync$3.dropAsync = void 0;
-const go_1$r = es2018$a;
+const go_1$r = es2018$b;
 const utils_1$7 = utils$1;
-const errors_1$t = es2018$9;
+const errors_1$t = es2018$a;
 function dropAsync$2(iterable, count) {
     (0, errors_1$t.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1$t.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
@@ -3515,9 +3528,9 @@ dropAsync$3.dropAsync = dropAsync$2;
 var dropRightAsync$3 = {};
 
 dropRightAsync$3.dropRightAsync = void 0;
-const go_1$q = es2018$a;
+const go_1$q = es2018$b;
 const utils_1$6 = utils$1;
-const errors_1$s = es2018$9;
+const errors_1$s = es2018$a;
 function dropRightAsync$2(iterable, count) {
     (0, errors_1$s.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1$s.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
@@ -3543,9 +3556,9 @@ async function toArrayAsync$5(iterable) {
 var dropRight$3 = {};
 
 dropRight$3.dropRight = void 0;
-const go_1$p = es2018$a;
+const go_1$p = es2018$b;
 const utils_1$5 = utils$1;
-const errors_1$r = es2018$9;
+const errors_1$r = es2018$a;
 function dropRight$2(iterable, count) {
     (0, errors_1$r.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1$r.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
@@ -3561,7 +3574,7 @@ dropRight$3.dropRight = dropRight$2;
 var dropUntilAsync$3 = {};
 
 dropUntilAsync$3.dropUntilAsync = void 0;
-const types_1$A = es2018$6;
+const types_1$A = es2018$7;
 function dropUntilAsync$2(iterable, predicate) {
     if ((0, types_1$A.isAsyncIterable)(iterable)) {
         return dropUntilAsyncIterable(iterable);
@@ -3643,9 +3656,9 @@ dropUntil$3.dropUntil = dropUntil$2;
 var drop$3 = {};
 
 drop$3.drop = void 0;
-const go_1$o = es2018$a;
+const go_1$o = es2018$b;
 const utils_1$4 = utils$1;
-const errors_1$q = es2018$9;
+const errors_1$q = es2018$a;
 function drop$2(iterable, count) {
     (0, errors_1$q.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1$q.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
@@ -3678,7 +3691,7 @@ drop$3.drop = drop$2;
 var filterAsync$3 = {};
 
 filterAsync$3.filterAsync = void 0;
-const types_1$z = es2018$6;
+const types_1$z = es2018$7;
 function filterAsync$2(iterable, predicate) {
     if ((0, types_1$z.isAsyncIterable)(iterable)) {
         return filterAsyncIterable(iterable);
@@ -3725,7 +3738,7 @@ var flattenDeepAsync$3 = {};
 var flattenByAsync$3 = {};
 
 flattenByAsync$3.flattenByAsync = void 0;
-const types_1$y = es2018$6;
+const types_1$y = es2018$7;
 function flattenByAsync$2(iterable, predicate) {
     if ((0, types_1$y.isAsyncIterable)(iterable)) {
         return flattenByAsyncIterable(iterable);
@@ -3765,7 +3778,7 @@ function isFiniteIterable$3(val) {
 
 flattenDeepAsync$3.flattenDeepAsync = void 0;
 const flatten_by_async_1$1 = flattenByAsync$3;
-const errors_1$p = es2018$9;
+const errors_1$p = es2018$a;
 function flattenDeepAsync$2(iterable, depth = Infinity) {
     (0, errors_1$p.assert)(depth === Infinity || Number.isInteger(depth), 'The parameter depth must be an integer');
     (0, errors_1$p.assert)(depth >= 0, 'The parameter depth must be greater than or equal to 0');
@@ -3783,7 +3796,7 @@ flattenAsync$3.flattenAsync = flattenAsync$2;
 var flattenBy$3 = {};
 
 flattenBy$3.flattenBy = void 0;
-const types_1$x = es2018$6;
+const types_1$x = es2018$7;
 function flattenBy$2(iterable, predicate) {
     return flatten(iterable, 1);
     function* flatten(iterable, level) {
@@ -3806,7 +3819,7 @@ var flattenDeep$3 = {};
 
 flattenDeep$3.flattenDeep = void 0;
 const flatten_by_1$1 = flattenBy$3;
-const errors_1$o = es2018$9;
+const errors_1$o = es2018$a;
 function flattenDeep$2(iterable, depth = Infinity) {
     (0, errors_1$o.assert)(depth === Infinity || Number.isInteger(depth), 'The parameter depth must be an integer');
     (0, errors_1$o.assert)(depth >= 0, 'The parameter depth must be greater than or equal to 0');
@@ -3826,7 +3839,7 @@ flatten$3.flatten = flatten$2;
 var mapAsync$3 = {};
 
 mapAsync$3.mapAsync = void 0;
-const types_1$w = es2018$6;
+const types_1$w = es2018$7;
 function mapAsync$2(iterable, fn) {
     if ((0, types_1$w.isAsyncIterable)(iterable)) {
         return mapAsyncIterable(iterable);
@@ -3866,8 +3879,8 @@ map$3.map = map$2;
 var repeatAsync$3 = {};
 
 repeatAsync$3.repeatAsync = void 0;
-const go_1$n = es2018$a;
-const errors_1$n = es2018$9;
+const go_1$n = es2018$b;
+const errors_1$n = es2018$a;
 function repeatAsync$2(iterable, times) {
     (0, errors_1$n.assert)(times === Infinity || Number.isInteger(times), 'The parameter times must be an integer');
     (0, errors_1$n.assert)(times >= 0, 'The parameter times must be greater than or equal to 0');
@@ -3901,8 +3914,8 @@ function isProduction$3() {
 var repeat$3 = {};
 
 repeat$3.repeat = void 0;
-const go_1$m = es2018$a;
-const errors_1$m = es2018$9;
+const go_1$m = es2018$b;
+const errors_1$m = es2018$a;
 function repeat$2(iterable, times) {
     (0, errors_1$m.assert)(times === Infinity || Number.isInteger(times), 'The parameter times must be an integer');
     (0, errors_1$m.assert)(times >= 0, 'The parameter times must be greater than or equal to 0');
@@ -3936,8 +3949,8 @@ function isProduction$2() {
 var sliceAsync$3 = {};
 
 sliceAsync$3.sliceAsync = void 0;
-const go_1$l = es2018$a;
-const errors_1$l = es2018$9;
+const go_1$l = es2018$b;
+const errors_1$l = es2018$a;
 function sliceAsync$2(iterable, start, end = Infinity) {
     (0, errors_1$l.assert)(Number.isInteger(start), 'The parameter start must be an integer');
     (0, errors_1$l.assert)(start >= 0, 'The parameter start must be greater than or equal to 0');
@@ -3959,8 +3972,8 @@ sliceAsync$3.sliceAsync = sliceAsync$2;
 var slice$3 = {};
 
 slice$3.slice = void 0;
-const go_1$k = es2018$a;
-const errors_1$k = es2018$9;
+const go_1$k = es2018$b;
+const errors_1$k = es2018$a;
 function slice$2(iterable, start, end = Infinity) {
     (0, errors_1$k.assert)(Number.isInteger(start), 'The parameter start must be an integer');
     (0, errors_1$k.assert)(start >= 0, 'The parameter start must be greater than or equal to 0');
@@ -4000,7 +4013,7 @@ splitAsync$3.splitAsync = splitAsync$2;
 var splitByAsync$3 = {};
 
 splitByAsync$3.splitByAsync = void 0;
-const types_1$v = es2018$6;
+const types_1$v = es2018$7;
 function splitByAsync$2(iterable, predicate) {
     if ((0, types_1$v.isAsyncIterable)(iterable)) {
         return splitByAsyncIterable(iterable);
@@ -4082,8 +4095,8 @@ split$3.split = split$2;
 var takeAsync$3 = {};
 
 takeAsync$3.takeAsync = void 0;
-const go_1$j = es2018$a;
-const errors_1$j = es2018$9;
+const go_1$j = es2018$b;
+const errors_1$j = es2018$a;
 function takeAsync$2(iterable, count) {
     (0, errors_1$j.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1$j.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
@@ -4103,8 +4116,8 @@ takeAsync$3.takeAsync = takeAsync$2;
 var takeRightAsync$3 = {};
 
 takeRightAsync$3.takeRightAsync = void 0;
-const go_1$i = es2018$a;
-const errors_1$i = es2018$9;
+const go_1$i = es2018$b;
+const errors_1$i = es2018$a;
 function takeRightAsync$2(iterable, count) {
     (0, errors_1$i.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1$i.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
@@ -4133,8 +4146,8 @@ takeRightAsync$3.takeRightAsync = takeRightAsync$2;
 var takeRight$3 = {};
 
 takeRight$3.takeRight = void 0;
-const go_1$h = es2018$a;
-const errors_1$h = es2018$9;
+const go_1$h = es2018$b;
+const errors_1$h = es2018$a;
 function takeRight$2(iterable, count) {
     (0, errors_1$h.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1$h.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
@@ -4163,7 +4176,7 @@ takeRight$3.takeRight = takeRight$2;
 var takeUntilAsync$3 = {};
 
 takeUntilAsync$3.takeUntilAsync = void 0;
-const types_1$u = es2018$6;
+const types_1$u = es2018$7;
 function takeUntilAsync$2(iterable, predicate) {
     if ((0, types_1$u.isAsyncIterable)(iterable)) {
         return takeUntilAsyncIterable(iterable);
@@ -4209,8 +4222,8 @@ takeUntil$3.takeUntil = takeUntil$2;
 var take$3 = {};
 
 take$3.take = void 0;
-const go_1$g = es2018$a;
-const errors_1$g = es2018$9;
+const go_1$g = es2018$b;
+const errors_1$g = es2018$a;
 function take$2(iterable, count) {
     (0, errors_1$g.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1$g.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
@@ -4230,7 +4243,7 @@ take$3.take = take$2;
 var tapAsync$3 = {};
 
 tapAsync$3.tapAsync = void 0;
-const types_1$t = es2018$6;
+const types_1$t = es2018$7;
 function tapAsync$2(iterable, fn) {
     if ((0, types_1$t.isAsyncIterable)(iterable)) {
         return tapAsyncIterable(iterable);
@@ -4313,7 +4326,7 @@ uniqAsync$3.uniqAsync = uniqAsync$2;
 var uniqByAsync$3 = {};
 
 uniqByAsync$3.uniqByAsync = void 0;
-const types_1$s = es2018$6;
+const types_1$s = es2018$7;
 function uniqByAsync$2(iterable, fn) {
     if ((0, types_1$s.isAsyncIterable)(iterable)) {
         return uniqByAsyncIterable(iterable);
@@ -4382,7 +4395,7 @@ uniq$3.uniq = uniq$2;
 var zipAsync$3 = {};
 
 zipAsync$3.zipAsync = void 0;
-const types_1$r = es2018$6;
+const types_1$r = es2018$7;
 var Kind$1;
 (function (Kind) {
     Kind[Kind["Sync"] = 0] = "Sync";
@@ -4542,7 +4555,7 @@ consume$3.consume = consume$2;
 var eachAsync$3 = {};
 
 eachAsync$3.eachAsync = void 0;
-const types_1$q = es2018$6;
+const types_1$q = es2018$7;
 function eachAsync$2(iterable, fn) {
     if ((0, types_1$q.isAsyncIterable)(iterable)) {
         return eachAsyncIterable(iterable);
@@ -4582,7 +4595,7 @@ each$3.each = each$2;
 var everyAsync$3 = {};
 
 everyAsync$3.everyAsync = void 0;
-const types_1$p = es2018$6;
+const types_1$p = es2018$7;
 function everyAsync$2(iterable, predicate) {
     if ((0, types_1$p.isAsyncIterable)(iterable)) {
         return everyAsyncIterable(iterable);
@@ -4628,7 +4641,7 @@ every$3.every = every$2;
 var findAsync$3 = {};
 
 findAsync$3.findAsync = void 0;
-const types_1$o = es2018$6;
+const types_1$o = es2018$7;
 function findAsync$2(iterable, predicate) {
     if ((0, types_1$o.isAsyncIterable)(iterable)) {
         return findAsyncIterable(iterable);
@@ -4752,7 +4765,7 @@ match$3.match = match$2;
 var reduceAsync$3 = {};
 
 reduceAsync$3.reduceAsync = void 0;
-const types_1$n = es2018$6;
+const types_1$n = es2018$7;
 function reduceAsync$2(iterable, fn, initialValue) {
     if ((0, types_1$n.isUndefined)(initialValue)) {
         return reduceAsyncWithoutInitialValue$1(iterable, fn);
@@ -4848,7 +4861,7 @@ function reduceAsyncWithoutInitialValue$1(iterable, fn) {
 var reduce$3 = {};
 
 reduce$3.reduce = void 0;
-const types_1$m = es2018$6;
+const types_1$m = es2018$7;
 function reduce$2(iterable, fn, initialValue) {
     if ((0, types_1$m.isUndefined)(initialValue)) {
         return reduceWithoutInitialValue$1(iterable, fn);
@@ -4895,7 +4908,7 @@ function reduceWithoutInitialValue$1(iterable, fn) {
 var someAsync$3 = {};
 
 someAsync$3.someAsync = void 0;
-const types_1$l = es2018$6;
+const types_1$l = es2018$7;
 function someAsync$2(iterable, predicate) {
     if ((0, types_1$l.isAsyncIterable)(iterable)) {
         return someAsyncIterable(iterable);
@@ -5079,7 +5092,7 @@ toSet$3.toSet = toSet$2;
 	};__exportStar(middleware$2, exports);
 	__exportStar(output$1, exports);
 	
-} (es2018$b));
+} (es2018$c));
 
 var getErrorNames$1 = {};
 
@@ -5097,7 +5110,7 @@ function* traverseErrorPrototypeChain(err) {
 traverseErrorPrototypeChain$1.traverseErrorPrototypeChain = traverseErrorPrototypeChain;
 
 getErrorNames$1.getErrorNames = void 0;
-const types_1$k = es2018$6;
+const types_1$k = es2018$7;
 const traverse_error_prototype_chain_1 = traverseErrorPrototypeChain$1;
 function* getErrorNames(err) {
     var _a;
@@ -5118,7 +5131,7 @@ getErrorNames$1.getErrorNames = getErrorNames;
 var serializableError = {};
 
 serializableError.isSerializableError = void 0;
-const types_1$j = es2018$6;
+const types_1$j = es2018$7;
 function isSerializableError(val) {
     return (0, types_1$j.isObject)(val)
         && (0, types_1$j.isString)(val.name)
@@ -5129,116 +5142,518 @@ function isSerializableError(val) {
 serializableError.isSerializableError = isSerializableError;
 
 customError$2.CustomError = void 0;
-const iterable_operator_1$1 = es2018$b;
+const iterable_operator_1$1 = es2018$c;
 const get_error_names_1$1 = getErrorNames$1;
-const types_1$i = es2018$6;
+const types_1$i = es2018$7;
 const serializable_error_1 = serializableError;
 class CustomError extends Error {
     get name() {
         var _a, _b;
         return (_b = (_a = (0, iterable_operator_1$1.first)((0, get_error_names_1$1.getErrorNames)(this))) !== null && _a !== void 0 ? _a : CustomError.name) !== null && _b !== void 0 ? _b : 'CustomError';
     }
-    static [Symbol.hasInstance](instance) {
-        var _a;
-        if ((0, types_1$i.isError)(instance) || (0, serializable_error_1.isSerializableError)(instance)) {
-            const reversedClassNames = [
-                (_a = this.prototype.constructor.name) !== null && _a !== void 0 ? _a : this.name,
-                ...(0, get_error_names_1$1.getErrorNames)(this.prototype)
-            ].reverse();
-            const reversedInstanceNames = (0, iterable_operator_1$1.toArray)((0, get_error_names_1$1.getErrorNames)(instance)).reverse();
-            return reversedClassNames.every((x, i) => x === reversedInstanceNames[i]);
-        }
-        else {
-            return false;
-        }
+    static [Symbol.hasInstance](instance) {
+        var _a;
+        if ((0, types_1$i.isError)(instance) || (0, serializable_error_1.isSerializableError)(instance)) {
+            const reversedClassNames = [
+                (_a = this.prototype.constructor.name) !== null && _a !== void 0 ? _a : this.name,
+                ...(0, get_error_names_1$1.getErrorNames)(this.prototype)
+            ].reverse();
+            const reversedInstanceNames = (0, iterable_operator_1$1.toArray)((0, get_error_names_1$1.getErrorNames)(instance)).reverse();
+            return reversedClassNames.every((x, i) => x === reversedInstanceNames[i]);
+        }
+        else {
+            return false;
+        }
+    }
+}
+customError$2.CustomError = CustomError;
+
+var assertionError = {};
+
+assertionError.AssertionError = void 0;
+const custom_error_1 = customError$2;
+class AssertionError extends custom_error_1.CustomError {
+}
+assertionError.AssertionError = AssertionError;
+
+var normalize$1 = {};
+
+normalize$1.normalize = void 0;
+const get_error_names_1 = getErrorNames$1;
+const iterable_operator_1 = es2018$c;
+function normalize(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$1.normalize = normalize;
+
+var hydrate$1 = {};
+
+var es2018$5 = {};
+
+var pass$1 = {};
+
+pass$1.pass = void 0;
+function pass() { }
+pass$1.pass = pass;
+
+(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$1, exports);
+	
+} (es2018$5));
+
+hydrate$1.hydrate = void 0;
+const pass_1 = es2018$5;
+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$1 = {};
+
+assert$1.assert = void 0;
+const assertion_error_1 = assertionError;
+function assert(condition, message) {
+    if (!condition)
+        throw new assertion_error_1.AssertionError(message);
+}
+assert$1.assert = assert;
+
+(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(customError$2, exports);
+	__exportStar(assertionError, exports);
+	__exportStar(serializableError, exports);
+	__exportStar(normalize$1, exports);
+	__exportStar(hydrate$1, exports);
+	__exportStar(assert$1, exports);
+	__exportStar(getErrorNames$1, exports);
+	__exportStar(traverseErrorPrototypeChain$1, exports);
+	
+} (es2018$d));
+
+var es2018$4 = {};
+
+var middleware = {};
+
+var chunkAsync$1 = {};
+
+var es2018$3 = {};
+
+var go$1 = {};
+
+go$1.go = void 0;
+function go(fn) {
+    return fn();
+}
+go$1.go = go;
+
+(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(go$1, exports);
+	
+} (es2018$3));
+
+chunkAsync$1.chunkAsync = void 0;
+const go_1$f = es2018$3;
+const errors_1$f = es2018$d;
+function chunkAsync(iterable, size) {
+    (0, errors_1$f.assert)(Number.isInteger(size), 'The parameter size must be an integer');
+    (0, errors_1$f.assert)(size > 0, 'The parameter size must be greater than 0');
+    return (0, go_1$f.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$1.chunkAsync = chunkAsync;
+
+var chunkByAsync$1 = {};
+
+var es2018$2 = {};
+
+var array = {};
+
+array.isntEmptyArray = array.isEmptyArray = array.isntArray = array.isArray = void 0;
+function isArray(val) {
+    return Array.isArray(val);
+}
+array.isArray = isArray;
+function isntArray(val) {
+    return !isArray(val);
+}
+array.isntArray = isntArray;
+function isEmptyArray(val) {
+    return val.length === 0;
+}
+array.isEmptyArray = isEmptyArray;
+function isntEmptyArray(val) {
+    return val.length !== 0;
+}
+array.isntEmptyArray = isntEmptyArray;
+
+var asyncIterable = {};
+
+var _null = {};
+
+_null.isntNull = _null.isNull = void 0;
+function isNull(val) {
+    return val === null;
+}
+_null.isNull = isNull;
+function isntNull(val) {
+    return !isNull(val);
+}
+_null.isntNull = isntNull;
+
+var _undefined = {};
+
+_undefined.isntUndefined = _undefined.isUndefined = void 0;
+function isUndefined(val) {
+    return val === undefined;
+}
+_undefined.isUndefined = isUndefined;
+function isntUndefined(val) {
+    return !isUndefined(val);
+}
+_undefined.isntUndefined = isntUndefined;
+
+var _function = {};
+
+_function.isntFunction = _function.isFunction = void 0;
+function isFunction$1(val) {
+    return typeof val === 'function';
+}
+_function.isFunction = isFunction$1;
+function isntFunction(val) {
+    return !isFunction$1(val);
+}
+_function.isntFunction = isntFunction;
+
+asyncIterable.isntAsyncIterable = asyncIterable.isAsyncIterable = void 0;
+const null_1$2 = _null;
+const undefined_1$1 = _undefined;
+const function_1$2 = _function;
+function isAsyncIterable(val) {
+    return (0, null_1$2.isntNull)(val)
+        && (0, undefined_1$1.isntUndefined)(val)
+        && (0, function_1$2.isFunction)(val[Symbol.asyncIterator]);
+}
+asyncIterable.isAsyncIterable = isAsyncIterable;
+function isntAsyncIterable(val) {
+    return !isAsyncIterable(val);
+}
+asyncIterable.isntAsyncIterable = isntAsyncIterable;
+
+var bigint = {};
+
+bigint.isntBigInt = bigint.isBigInt = void 0;
+function isBigInt(val) {
+    return typeof val === 'bigint';
+}
+bigint.isBigInt = isBigInt;
+function isntBigInt(val) {
+    return !isBigInt(val);
+}
+bigint.isntBigInt = isntBigInt;
+
+var boolean = {};
+
+boolean.isntBoolean = boolean.isBoolean = void 0;
+function isBoolean(val) {
+    return typeof val === 'boolean';
+}
+boolean.isBoolean = isBoolean;
+function isntBoolean(val) {
+    return !isBoolean(val);
+}
+boolean.isntBoolean = isntBoolean;
+
+var char = {};
+
+var string = {};
+
+string.isntString = string.isString = void 0;
+function isString(val) {
+    return typeof val === 'string';
+}
+string.isString = isString;
+function isntString(val) {
+    return !isString(val);
+}
+string.isntString = isntString;
+
+char.isntChar = char.isChar = void 0;
+const string_1$1 = string;
+function isChar(val) {
+    return (0, string_1$1.isString)(val)
+        && val.length === 1;
+}
+char.isChar = isChar;
+function isntChar(val) {
+    return !isChar(val);
+}
+char.isntChar = isntChar;
+
+var date = {};
+
+date.isntDate = date.isDate = void 0;
+function isDate(val) {
+    return val instanceof Date;
+}
+date.isDate = isDate;
+function isntDate(val) {
+    return !isDate(val);
+}
+date.isntDate = isntDate;
+
+var _enum = {};
+
+_enum.inEnum = void 0;
+function inEnum(val, _enum) {
+    return Object.values(_enum).includes(val);
+}
+_enum.inEnum = inEnum;
+
+var error = {};
+
+error.isntError = error.isError = void 0;
+function isError(val) {
+    return val instanceof Error;
+}
+error.isError = isError;
+function isntError(val) {
+    return !isError(val);
+}
+error.isntError = isntError;
+
+var falsy = {};
+
+falsy.isntFalsy = falsy.isFalsy = void 0;
+function isFalsy(val) {
+    return !val;
+}
+falsy.isFalsy = isFalsy;
+function isntFalsy(val) {
+    return !isFalsy(val);
+}
+falsy.isntFalsy = isntFalsy;
+
+var iterable = {};
+
+iterable.isntIterable = iterable.isIterable = void 0;
+const null_1$1 = _null;
+const undefined_1 = _undefined;
+const function_1$1 = _function;
+function isIterable(val) {
+    return (0, null_1$1.isntNull)(val)
+        && (0, undefined_1.isntUndefined)(val)
+        && (0, function_1$1.isFunction)(val[Symbol.iterator]);
+}
+iterable.isIterable = isIterable;
+function isntIterable(val) {
+    return !isIterable(val);
+}
+iterable.isntIterable = isntIterable;
+
+var json = {};
+
+var number = {};
+
+number.isntNaN = number.isNaN = number.isNegativeInfinity = number.isPositiveInfinity = number.isFinite = number.isntNumber = number.isNumber = void 0;
+function isNumber(val) {
+    return typeof val === 'number';
+}
+number.isNumber = isNumber;
+function isntNumber(val) {
+    return !isNumber(val);
+}
+number.isntNumber = isntNumber;
+function isFinite(val) {
+    return Number.isFinite(val);
+}
+number.isFinite = isFinite;
+function isPositiveInfinity(val) {
+    return val === Infinity;
+}
+number.isPositiveInfinity = isPositiveInfinity;
+function isNegativeInfinity(val) {
+    return val === -Infinity;
+}
+number.isNegativeInfinity = isNegativeInfinity;
+function isNaN(val) {
+    return Number.isNaN(val);
+}
+number.isNaN = isNaN;
+function isntNaN(val) {
+    return !isNaN(val);
+}
+number.isntNaN = isntNaN;
+
+var object = {};
+
+var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};object.isntEmptyObject = object.isEmptyObject = object.isntPlainObject = object.isPlainObject = object.isntObject = object.isObject = void 0;
+const isPlainObject_1 = __importDefault(isPlainObject_1$2);
+function isObject(val) {
+    return val !== null
+        && typeof val === 'object';
+}
+object.isObject = isObject;
+function isntObject(val) {
+    return !isObject(val);
+}
+object.isntObject = isntObject;
+function isPlainObject(val) {
+    return (0, isPlainObject_1.default)(val);
+}
+object.isPlainObject = isPlainObject;
+function isntPlainObject(val) {
+    return !isPlainObject(val);
+}
+object.isntPlainObject = isntPlainObject;
+function isEmptyObject(val) {
+    return Object.keys(val).length === 0;
+}
+object.isEmptyObject = isEmptyObject;
+function isntEmptyObject(val) {
+    return Object.keys(val).length !== 0;
+}
+object.isntEmptyObject = isntEmptyObject;
+
+json.isntJsonable = json.isJsonable = json.isntJson = json.isJson = void 0;
+const null_1 = _null;
+const boolean_1 = boolean;
+const string_1 = string;
+const number_1 = number;
+const array_1 = array;
+const object_1$1 = object;
+function isJson(val) {
+    return (0, null_1.isNull)(val)
+        || (0, boolean_1.isBoolean)(val)
+        || (0, string_1.isString)(val)
+        || (0, number_1.isNumber)(val)
+        || ((0, array_1.isArray)(val) && val.every(isJson))
+        || ((0, object_1$1.isPlainObject)(val) && Object.values(val).every(isJson));
+}
+json.isJson = isJson;
+function isntJson(val) {
+    return !isJson(val);
+}
+json.isntJson = isntJson;
+function isJsonable(val) {
+    try {
+        JSON.stringify(val);
+        return true;
+    }
+    catch (_a) {
+        return false;
     }
 }
-customError$2.CustomError = CustomError;
-
-var assertionError = {};
-
-assertionError.AssertionError = void 0;
-const custom_error_1 = customError$2;
-class AssertionError extends custom_error_1.CustomError {
+json.isJsonable = isJsonable;
+function isntJsonable(val) {
+    return !isntJsonable();
 }
-assertionError.AssertionError = AssertionError;
+json.isntJsonable = isntJsonable;
 
-var normalize$1 = {};
+var promise = {};
 
-normalize$1.normalize = void 0;
-const get_error_names_1 = getErrorNames$1;
-const iterable_operator_1 = es2018$b;
-function normalize(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
-    };
+promise.isPromiseLike = promise.isntPromiseLike = promise.isntPromise = promise.isPromise = void 0;
+const object_1 = object;
+const function_1 = _function;
+function isPromise(val) {
+    return val instanceof Promise;
 }
-normalize$1.normalize = normalize;
-
-var hydrate$1 = {};
-
-var es2018$4 = {};
-
-var pass$1 = {};
-
-pass$1.pass = void 0;
-function pass() { }
-pass$1.pass = pass;
-
-(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$1, exports);
-	
-} (es2018$4));
-
-hydrate$1.hydrate = void 0;
-const pass_1 = es2018$4;
-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;
+promise.isPromise = isPromise;
+function isntPromise(val) {
+    return !isPromise(val);
 }
-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;
+promise.isntPromise = isntPromise;
+function isntPromiseLike(val) {
+    return !isPromiseLike(val);
+}
+promise.isntPromiseLike = isntPromiseLike;
+function isPromiseLike(val) {
+    return (0, object_1.isObject)(val)
+        && (0, function_1.isFunction)(val.then);
 }
+promise.isPromiseLike = isPromiseLike;
 
-var assert$1 = {};
+var url = {};
 
-assert$1.assert = void 0;
-const assertion_error_1 = assertionError;
-function assert(condition, message) {
-    if (!condition)
-        throw new assertion_error_1.AssertionError(message);
+url.isAbsoluteURL = void 0;
+function isAbsoluteURL(str) {
+    try {
+        new URL(str);
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
 }
-assert$1.assert = assert;
+url.isAbsoluteURL = isAbsoluteURL;
 
 (function (exports) {
 	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -5254,72 +5669,30 @@ assert$1.assert = assert;
 	}));
 	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(customError$2, exports);
-	__exportStar(assertionError, exports);
-	__exportStar(serializableError, exports);
-	__exportStar(normalize$1, exports);
-	__exportStar(hydrate$1, exports);
-	__exportStar(assert$1, exports);
-	__exportStar(getErrorNames$1, exports);
-	__exportStar(traverseErrorPrototypeChain$1, exports);
-	
-} (es2018$c));
-
-var es2018$3 = {};
-
-var middleware = {};
-
-var chunkAsync$1 = {};
-
-var es2018$2 = {};
-
-var go$1 = {};
-
-go$1.go = void 0;
-function go(fn) {
-    return fn();
-}
-go$1.go = go;
-
-(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(go$1, exports);
+	};__exportStar(array, exports);
+	__exportStar(asyncIterable, exports);
+	__exportStar(bigint, exports);
+	__exportStar(boolean, exports);
+	__exportStar(char, exports);
+	__exportStar(date, exports);
+	__exportStar(_enum, exports);
+	__exportStar(error, exports);
+	__exportStar(falsy, exports);
+	__exportStar(_function, exports);
+	__exportStar(iterable, exports);
+	__exportStar(json, exports);
+	__exportStar(_null, exports);
+	__exportStar(number, exports);
+	__exportStar(object, exports);
+	__exportStar(promise, exports);
+	__exportStar(string, exports);
+	__exportStar(_undefined, exports);
+	__exportStar(url, exports);
 	
 } (es2018$2));
 
-chunkAsync$1.chunkAsync = void 0;
-const go_1$f = es2018$2;
-const errors_1$f = es2018$c;
-function chunkAsync(iterable, size) {
-    (0, errors_1$f.assert)(Number.isInteger(size), 'The parameter size must be an integer');
-    (0, errors_1$f.assert)(size > 0, 'The parameter size must be greater than 0');
-    return (0, go_1$f.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$1.chunkAsync = chunkAsync;
-
-var chunkByAsync$1 = {};
-
 chunkByAsync$1.chunkByAsync = void 0;
-const types_1$h = es2018$d;
+const types_1$h = es2018$2;
 function chunkByAsync(iterable, predicate) {
     if ((0, types_1$h.isAsyncIterable)(iterable)) {
         return chunkByAsyncIterable(iterable);
@@ -5380,8 +5753,8 @@ chunkBy$1.chunkBy = chunkBy;
 var chunk$1 = {};
 
 chunk$1.chunk = void 0;
-const go_1$e = es2018$2;
-const errors_1$e = es2018$c;
+const go_1$e = es2018$3;
+const errors_1$e = es2018$d;
 function chunk(iterable, size) {
     (0, errors_1$e.assert)(Number.isInteger(size), 'The parameter size must be an integer');
     (0, errors_1$e.assert)(size > 0, 'The parameter size must be greater than 0');
@@ -5403,8 +5776,8 @@ chunk$1.chunk = chunk;
 var concatAsync$1 = {};
 
 concatAsync$1.concatAsync = void 0;
-const types_1$g = es2018$d;
-const go_1$d = es2018$2;
+const types_1$g = es2018$2;
+const go_1$d = es2018$3;
 function concatAsync(iterable, ...otherIterables) {
     return (0, go_1$d.go)(async function* () {
         for (const iter of [iterable, ...otherIterables]) {
@@ -5426,7 +5799,7 @@ concatAsync$1.concatAsync = concatAsync;
 var concat$1 = {};
 
 concat$1.concat = void 0;
-const go_1$c = es2018$2;
+const go_1$c = es2018$3;
 function concat(iterable, ...otherIterables) {
     return (0, go_1$c.go)(function* () {
         for (const iter of [iterable, ...otherIterables]) {
@@ -5455,9 +5828,9 @@ function* copyIterable(iterable) {
 utils.copyIterable = copyIterable;
 
 dropAsync$1.dropAsync = void 0;
-const go_1$b = es2018$2;
+const go_1$b = es2018$3;
 const utils_1$3 = utils;
-const errors_1$d = es2018$c;
+const errors_1$d = es2018$d;
 function dropAsync(iterable, count) {
     (0, errors_1$d.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1$d.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
@@ -5490,9 +5863,9 @@ dropAsync$1.dropAsync = dropAsync;
 var dropRightAsync$1 = {};
 
 dropRightAsync$1.dropRightAsync = void 0;
-const go_1$a = es2018$2;
+const go_1$a = es2018$3;
 const utils_1$2 = utils;
-const errors_1$c = es2018$c;
+const errors_1$c = es2018$d;
 function dropRightAsync(iterable, count) {
     (0, errors_1$c.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1$c.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
@@ -5518,9 +5891,9 @@ async function toArrayAsync$2(iterable) {
 var dropRight$1 = {};
 
 dropRight$1.dropRight = void 0;
-const go_1$9 = es2018$2;
+const go_1$9 = es2018$3;
 const utils_1$1 = utils;
-const errors_1$b = es2018$c;
+const errors_1$b = es2018$d;
 function dropRight(iterable, count) {
     (0, errors_1$b.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1$b.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
@@ -5536,7 +5909,7 @@ dropRight$1.dropRight = dropRight;
 var dropUntilAsync$1 = {};
 
 dropUntilAsync$1.dropUntilAsync = void 0;
-const types_1$f = es2018$d;
+const types_1$f = es2018$2;
 function dropUntilAsync(iterable, predicate) {
     if ((0, types_1$f.isAsyncIterable)(iterable)) {
         return dropUntilAsyncIterable(iterable);
@@ -5618,9 +5991,9 @@ dropUntil$1.dropUntil = dropUntil;
 var drop$1 = {};
 
 drop$1.drop = void 0;
-const go_1$8 = es2018$2;
+const go_1$8 = es2018$3;
 const utils_1 = utils;
-const errors_1$a = es2018$c;
+const errors_1$a = es2018$d;
 function drop(iterable, count) {
     (0, errors_1$a.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1$a.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
@@ -5653,7 +6026,7 @@ drop$1.drop = drop;
 var filterAsync$1 = {};
 
 filterAsync$1.filterAsync = void 0;
-const types_1$e = es2018$d;
+const types_1$e = es2018$2;
 function filterAsync(iterable, predicate) {
     if ((0, types_1$e.isAsyncIterable)(iterable)) {
         return filterAsyncIterable(iterable);
@@ -5700,7 +6073,7 @@ var flattenDeepAsync$1 = {};
 var flattenByAsync$1 = {};
 
 flattenByAsync$1.flattenByAsync = void 0;
-const types_1$d = es2018$d;
+const types_1$d = es2018$2;
 function flattenByAsync(iterable, predicate) {
     if ((0, types_1$d.isAsyncIterable)(iterable)) {
         return flattenByAsyncIterable(iterable);
@@ -5740,7 +6113,7 @@ function isFiniteIterable$1(val) {
 
 flattenDeepAsync$1.flattenDeepAsync = void 0;
 const flatten_by_async_1 = flattenByAsync$1;
-const errors_1$9 = es2018$c;
+const errors_1$9 = es2018$d;
 function flattenDeepAsync(iterable, depth = Infinity) {
     (0, errors_1$9.assert)(depth === Infinity || Number.isInteger(depth), 'The parameter depth must be an integer');
     (0, errors_1$9.assert)(depth >= 0, 'The parameter depth must be greater than or equal to 0');
@@ -5758,7 +6131,7 @@ flattenAsync$1.flattenAsync = flattenAsync;
 var flattenBy$1 = {};
 
 flattenBy$1.flattenBy = void 0;
-const types_1$c = es2018$d;
+const types_1$c = es2018$2;
 function flattenBy(iterable, predicate) {
     return flatten(iterable, 1);
     function* flatten(iterable, level) {
@@ -5781,7 +6154,7 @@ var flattenDeep$1 = {};
 
 flattenDeep$1.flattenDeep = void 0;
 const flatten_by_1 = flattenBy$1;
-const errors_1$8 = es2018$c;
+const errors_1$8 = es2018$d;
 function flattenDeep(iterable, depth = Infinity) {
     (0, errors_1$8.assert)(depth === Infinity || Number.isInteger(depth), 'The parameter depth must be an integer');
     (0, errors_1$8.assert)(depth >= 0, 'The parameter depth must be greater than or equal to 0');
@@ -5801,7 +6174,7 @@ flatten$1.flatten = flatten;
 var mapAsync$1 = {};
 
 mapAsync$1.mapAsync = void 0;
-const types_1$b = es2018$d;
+const types_1$b = es2018$2;
 function mapAsync(iterable, fn) {
     if ((0, types_1$b.isAsyncIterable)(iterable)) {
         return mapAsyncIterable(iterable);
@@ -5841,8 +6214,8 @@ map$1.map = map;
 var repeatAsync$1 = {};
 
 repeatAsync$1.repeatAsync = void 0;
-const go_1$7 = es2018$2;
-const errors_1$7 = es2018$c;
+const go_1$7 = es2018$3;
+const errors_1$7 = es2018$d;
 function repeatAsync(iterable, times) {
     (0, errors_1$7.assert)(times === Infinity || Number.isInteger(times), 'The parameter times must be an integer');
     (0, errors_1$7.assert)(times >= 0, 'The parameter times must be greater than or equal to 0');
@@ -5876,8 +6249,8 @@ function isProduction$1() {
 var repeat$1 = {};
 
 repeat$1.repeat = void 0;
-const go_1$6 = es2018$2;
-const errors_1$6 = es2018$c;
+const go_1$6 = es2018$3;
+const errors_1$6 = es2018$d;
 function repeat(iterable, times) {
     (0, errors_1$6.assert)(times === Infinity || Number.isInteger(times), 'The parameter times must be an integer');
     (0, errors_1$6.assert)(times >= 0, 'The parameter times must be greater than or equal to 0');
@@ -5911,8 +6284,8 @@ function isProduction() {
 var sliceAsync$1 = {};
 
 sliceAsync$1.sliceAsync = void 0;
-const go_1$5 = es2018$2;
-const errors_1$5 = es2018$c;
+const go_1$5 = es2018$3;
+const errors_1$5 = es2018$d;
 function sliceAsync(iterable, start, end = Infinity) {
     (0, errors_1$5.assert)(Number.isInteger(start), 'The parameter start must be an integer');
     (0, errors_1$5.assert)(start >= 0, 'The parameter start must be greater than or equal to 0');
@@ -5934,8 +6307,8 @@ sliceAsync$1.sliceAsync = sliceAsync;
 var slice$1 = {};
 
 slice$1.slice = void 0;
-const go_1$4 = es2018$2;
-const errors_1$4 = es2018$c;
+const go_1$4 = es2018$3;
+const errors_1$4 = es2018$d;
 function slice(iterable, start, end = Infinity) {
     (0, errors_1$4.assert)(Number.isInteger(start), 'The parameter start must be an integer');
     (0, errors_1$4.assert)(start >= 0, 'The parameter start must be greater than or equal to 0');
@@ -5975,7 +6348,7 @@ splitAsync$1.splitAsync = splitAsync;
 var splitByAsync$1 = {};
 
 splitByAsync$1.splitByAsync = void 0;
-const types_1$a = es2018$d;
+const types_1$a = es2018$2;
 function splitByAsync(iterable, predicate) {
     if ((0, types_1$a.isAsyncIterable)(iterable)) {
         return splitByAsyncIterable(iterable);
@@ -6057,8 +6430,8 @@ split$1.split = split;
 var takeAsync$1 = {};
 
 takeAsync$1.takeAsync = void 0;
-const go_1$3 = es2018$2;
-const errors_1$3 = es2018$c;
+const go_1$3 = es2018$3;
+const errors_1$3 = es2018$d;
 function takeAsync(iterable, count) {
     (0, errors_1$3.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1$3.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
@@ -6078,8 +6451,8 @@ takeAsync$1.takeAsync = takeAsync;
 var takeRightAsync$1 = {};
 
 takeRightAsync$1.takeRightAsync = void 0;
-const go_1$2 = es2018$2;
-const errors_1$2 = es2018$c;
+const go_1$2 = es2018$3;
+const errors_1$2 = es2018$d;
 function takeRightAsync(iterable, count) {
     (0, errors_1$2.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1$2.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
@@ -6108,8 +6481,8 @@ takeRightAsync$1.takeRightAsync = takeRightAsync;
 var takeRight$1 = {};
 
 takeRight$1.takeRight = void 0;
-const go_1$1 = es2018$2;
-const errors_1$1 = es2018$c;
+const go_1$1 = es2018$3;
+const errors_1$1 = es2018$d;
 function takeRight(iterable, count) {
     (0, errors_1$1.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1$1.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
@@ -6138,7 +6511,7 @@ takeRight$1.takeRight = takeRight;
 var takeUntilAsync$1 = {};
 
 takeUntilAsync$1.takeUntilAsync = void 0;
-const types_1$9 = es2018$d;
+const types_1$9 = es2018$2;
 function takeUntilAsync(iterable, predicate) {
     if ((0, types_1$9.isAsyncIterable)(iterable)) {
         return takeUntilAsyncIterable(iterable);
@@ -6184,8 +6557,8 @@ takeUntil$1.takeUntil = takeUntil;
 var take$1 = {};
 
 take$1.take = void 0;
-const go_1 = es2018$2;
-const errors_1 = es2018$c;
+const go_1 = es2018$3;
+const errors_1 = es2018$d;
 function take(iterable, count) {
     (0, errors_1.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
@@ -6205,7 +6578,7 @@ take$1.take = take;
 var tapAsync$1 = {};
 
 tapAsync$1.tapAsync = void 0;
-const types_1$8 = es2018$d;
+const types_1$8 = es2018$2;
 function tapAsync(iterable, fn) {
     if ((0, types_1$8.isAsyncIterable)(iterable)) {
         return tapAsyncIterable(iterable);
@@ -6288,7 +6661,7 @@ uniqAsync$1.uniqAsync = uniqAsync;
 var uniqByAsync$1 = {};
 
 uniqByAsync$1.uniqByAsync = void 0;
-const types_1$7 = es2018$d;
+const types_1$7 = es2018$2;
 function uniqByAsync(iterable, fn) {
     if ((0, types_1$7.isAsyncIterable)(iterable)) {
         return uniqByAsyncIterable(iterable);
@@ -6357,7 +6730,7 @@ uniq$1.uniq = uniq;
 var zipAsync$1 = {};
 
 zipAsync$1.zipAsync = void 0;
-const types_1$6 = es2018$d;
+const types_1$6 = es2018$2;
 var Kind;
 (function (Kind) {
     Kind[Kind["Sync"] = 0] = "Sync";
@@ -6521,7 +6894,7 @@ consume$1.consume = consume;
 var eachAsync$1 = {};
 
 eachAsync$1.eachAsync = void 0;
-const types_1$5 = es2018$d;
+const types_1$5 = es2018$2;
 function eachAsync(iterable, fn) {
     if ((0, types_1$5.isAsyncIterable)(iterable)) {
         return eachAsyncIterable(iterable);
@@ -6561,7 +6934,7 @@ each$1.each = each;
 var everyAsync$1 = {};
 
 everyAsync$1.everyAsync = void 0;
-const types_1$4 = es2018$d;
+const types_1$4 = es2018$2;
 function everyAsync(iterable, predicate) {
     if ((0, types_1$4.isAsyncIterable)(iterable)) {
         return everyAsyncIterable(iterable);
@@ -6607,7 +6980,7 @@ every$1.every = every;
 var findAsync$1 = {};
 
 findAsync$1.findAsync = void 0;
-const types_1$3 = es2018$d;
+const types_1$3 = es2018$2;
 function findAsync(iterable, predicate) {
     if ((0, types_1$3.isAsyncIterable)(iterable)) {
         return findAsyncIterable(iterable);
@@ -6731,7 +7104,7 @@ match$1.match = match;
 var reduceAsync$1 = {};
 
 reduceAsync$1.reduceAsync = void 0;
-const types_1$2 = es2018$d;
+const types_1$2 = es2018$2;
 function reduceAsync(iterable, fn, initialValue) {
     if ((0, types_1$2.isUndefined)(initialValue)) {
         return reduceAsyncWithoutInitialValue(iterable, fn);
@@ -6827,7 +7200,7 @@ function reduceAsyncWithoutInitialValue(iterable, fn) {
 var reduce$1 = {};
 
 reduce$1.reduce = void 0;
-const types_1$1 = es2018$d;
+const types_1$1 = es2018$2;
 function reduce(iterable, fn, initialValue) {
     if ((0, types_1$1.isUndefined)(initialValue)) {
         return reduceWithoutInitialValue(iterable, fn);
@@ -6874,7 +7247,7 @@ function reduceWithoutInitialValue(iterable, fn) {
 var someAsync$1 = {};
 
 someAsync$1.someAsync = void 0;
-const types_1 = es2018$d;
+const types_1 = es2018$2;
 function someAsync(iterable, predicate) {
     if ((0, types_1.isAsyncIterable)(iterable)) {
         return someAsyncIterable(iterable);
@@ -7092,13 +7465,13 @@ countAsync$1.countAsync = countAsync;
 	};__exportStar(middleware, exports);
 	__exportStar(output, exports);
 	
-} (es2018$3));
+} (es2018$4));
 
 class LRUMap {
     constructor(limit) {
         this.map = new Map();
-        es2018$c.assert(Number.isInteger(limit), 'The parameter limit must be an integer');
-        es2018$c.assert(limit > 0, 'The parameter limit must be a positive value');
+        es2018$d.assert(Number.isInteger(limit), 'The parameter limit must be an integer');
+        es2018$d.assert(limit > 0, 'The parameter limit must be a positive value');
         this.limit = limit;
     }
     get [Symbol.toStringTag]() {
@@ -7146,7 +7519,7 @@ class LRUMap {
      * Return the earliest key inserted in the Map
      */
     getColdestKey() {
-        return es2018$3.first(this.map.keys());
+        return es2018$4.first(this.map.keys());
     }
 }
 
@@ -7427,8 +7800,8 @@ class TLRUMap {
          * 按过期时间升序排列所有项目的元数据
          */
         this.itemMetadataSortedByExpirationTime = [];
-        es2018$c.assert(Number.isInteger(limit), 'The parameter limit must be an integer');
-        es2018$c.assert(limit > 0, 'The parameter limit must be a positive value');
+        es2018$d.assert(Number.isInteger(limit), 'The parameter limit must be an integer');
+        es2018$d.assert(limit > 0, 'The parameter limit must be a positive value');
         this.limit = limit;
     }
     get [Symbol.toStringTag]() {
@@ -7547,7 +7920,7 @@ class TLRUMap {
      * Return the earliest key inserted in the Map
      */
     getColdestKey() {
-        return es2018$3.first(this.map.keys());
+        return es2018$4.first(this.map.keys());
     }
 }
 
@@ -7569,7 +7942,7 @@ class TrieMap {
         function* dfs(node, paths) {
             for (const [path, childNode] of node.children) {
                 const newPaths = [...paths, path];
-                if (es2018$d.isntUndefined(childNode.value)) {
+                if (es2018$e.isntUndefined(childNode.value)) {
                     yield [newPaths, childNode.value];
                 }
                 yield* dfs(childNode, newPaths);
@@ -7577,10 +7950,10 @@ class TrieMap {
         }
     }
     keys() {
-        return es2018$3.map(this.entries(), ([key]) => key);
+        return es2018$4.map(this.entries(), ([key]) => key);
     }
     values() {
-        return es2018$3.map(this.entries(), ([_, value]) => value);
+        return es2018$4.map(this.entries(), ([_, value]) => value);
     }
     set(key, value) {
         let node = this.root;
@@ -7632,7 +8005,7 @@ class TrieMap {
         delete node.value;
         // 如果节点没有后缀, 则代表这是末端节点, 往前删除其前缀
         if (node.children.size === 0) {
-            for (const [part, parentNode] of es2018$3.toArray(es2018$3.zip(key, parentNodes)).reverse()) {
+            for (const [part, parentNode] of es2018$4.toArray(es2018$4.zip(key, parentNodes)).reverse()) {
                 parentNode.children.delete(part);
                 if (parentNode.children.size !== 0)
                     break;
@@ -7671,7 +8044,7 @@ class FiniteStateMachine {
         }
     }
 }
-class BadEventError extends es2018$c.CustomError {
+class BadEventError extends es2018$d.CustomError {
     constructor(state, event) {
         super(`State ${state} cannot react to event ${event}`);
     }
@@ -9262,7 +9635,7 @@ class ObservableFiniteStateMachine extends FiniteStateMachine {
         super.send(event);
         const newState = this.state;
         this.stateChanges.next({ event, oldState, newState });
-        if (es2018$d.isEmptyObject(this.schema[newState])) {
+        if (es2018$e.isEmptyObject(this.schema[newState])) {
             this.stateChanges.complete();
         }
     }
@@ -9283,7 +9656,7 @@ class SparseSet {
     }
     has(value) {
         // 跟一般的实现不同, 不需要访问values数组.
-        return es2018$d.isntUndefined(this.valueToValueIndex[value]);
+        return es2018$e.isntUndefined(this.valueToValueIndex[value]);
     }
     add(value) {
         if (!this.has(value)) {
@@ -9306,5 +9679,122 @@ class SparseSet {
     }
 }
 
-export { BadEventError, Box, Emitter, ExpirableMap, FiniteStateMachine, HashMap, HashSet, LRUMap, ObservableFiniteStateMachine, Queue, SparseSet, TLRUMap, TrieMap, convertArrayToCons, convertConsToArray };
+// 相关提案: https://github.com/tc39/proposal-resizablearraybuffer
+class DynamicTypedArray {
+    constructor(typedArrayConstructor, { capacity = 0, growthFactor = 1.5 } = {}) {
+        this.typedArrayConstructor = typedArrayConstructor;
+        this._length = 0;
+        es2018$d.assert(Number.isInteger(capacity), 'capacity must be an integer');
+        es2018$d.assert(capacity >= 0, 'capacity must be greater than or equal to 0');
+        es2018$d.assert(growthFactor > 1, 'growthFactory must be greater than or equal to 1');
+        this.array = new typedArrayConstructor(capacity);
+        this.growthFactor = growthFactor;
+    }
+    get [Symbol.toStringTag]() {
+        return this.constructor.name;
+    }
+    /**
+     * 数组当前的容量.
+     */
+    get capacity() {
+        return this.array.length;
+    }
+    /**
+     * 数组逻辑上的长度, 总是小于或等于capacity.
+     */
+    get length() {
+        return this._length;
+    }
+    set(index, value) {
+        if (index >= this.capacity) {
+            const newCapacity = computeNewCapacity(this.capacity, index + 1, this.growthFactor);
+            this.resize(newCapacity);
+        }
+        if (index >= this._length) {
+            this._length = index + 1;
+        }
+        this.array[index] = value;
+    }
+    get(index) {
+        return index < this._length
+            ? this.array[index]
+            : undefined;
+    }
+    push(...values) {
+        const newLength = this._length + values.length;
+        if (newLength > this.capacity) {
+            const newCapacity = computeNewCapacity(this.capacity, newLength, this.growthFactor);
+            this.resize(newCapacity);
+        }
+        for (const value of values) {
+            this.array[this._length++] = value;
+        }
+    }
+    pop() {
+        if (this._length > 0) {
+            const value = this.array[this._length - 1];
+            this._length--;
+            const newCapacity = computeNewCapacity(this.capacity, this.length, this.growthFactor);
+            this.resize(newCapacity);
+            return value;
+        }
+        else {
+            return undefined;
+        }
+    }
+    resize(newCapacity) {
+        if (this.array.length === newCapacity) {
+            return;
+        }
+        else if (this.array.length < newCapacity) {
+            const newArray = new this.typedArrayConstructor(newCapacity);
+            newArray.set(this.array);
+            this.array = newArray;
+        }
+        else if (this.array.length > newCapacity) {
+            const newArray = new this.typedArrayConstructor(newCapacity);
+            // 不需要的部分将被舍弃.
+            for (let i = newCapacity; i--;) {
+                newArray[i] = this.array[i];
+            }
+            this.array = newArray;
+        }
+    }
+}
+function computeNewCapacity(oldCapacity, targetLength, growthFactor) {
+    if (oldCapacity === targetLength) {
+        return targetLength;
+    }
+    else if (oldCapacity < targetLength) {
+        // 增加容量以适配targetLength
+        let newCapacity = Math.max(oldCapacity, 1);
+        while (newCapacity < targetLength) {
+            newCapacity *= growthFactor;
+        }
+        return Math.floor(newCapacity);
+    }
+    else {
+        // 尝试减少容量以适配targetLength
+        // `targetLength = 0`是特殊情况,
+        // 此时无论怎么将oldCapacity除以growthFactory几次, 都不可能得到比targetLength小的结果.
+        if (targetLength === 0) {
+            return 0;
+        }
+        else {
+            let newCapacity = oldCapacity;
+            while (true) {
+                const temp = newCapacity / growthFactor;
+                if (temp < targetLength) {
+                    break;
+                }
+                else {
+                    newCapacity = temp;
+                }
+            }
+            return Math.floor(newCapacity);
+        }
+    }
+}
+
+export { BadEventError, Box, DynamicTypedArray, Emitter, ExpirableMap, FiniteStateMachine, HashMap, HashSet, LRUMap, ObservableFiniteStateMachine, Queue, SparseSet, TLRUMap, TrieMap, convertArrayToCons, convertConsToArray };
 //# sourceMappingURL=index.mjs.map