@blackglory/structures 0.6.5 → 0.6.6

package/dist/es2018/index.umd.js

@@ -21,227 +21,227 @@
 
     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. */
 
@@ -469,7 +469,7 @@
      * _.isPlainObject(Object.create(null));
      * // => true
      */
-    function isPlainObject$3(value) {
+    function isPlainObject$4(value) {
       if (!isObjectLike$1(value) || baseGetTag(value) != objectTag$1) {
         return false;
       }
@@ -482,59 +482,59 @@
         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;
@@ -543,39 +543,39 @@
             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;
@@ -584,7 +584,19 @@
             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) {
@@ -600,30 +612,31 @@
     	}));
     	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 {
@@ -762,17 +775,17 @@
         }
     }
 
-    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 = {};
 
@@ -794,19 +807,19 @@
     	    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 = {};
 
@@ -884,11 +897,11 @@
     	__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');
@@ -909,193 +922,193 @@
 
     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/>
@@ -1221,7 +1234,7 @@
      * _.isPlainObject(Object.create(null));
      * // => true
      */
-    function isPlainObject$1(value) {
+    function isPlainObject$2(value) {
       if (!isObjectLike(value) ||
           objectToString.call(value) != objectTag || isHostObject(value)) {
         return false;
@@ -1235,67 +1248,67 @@
         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;
@@ -1304,9 +1317,9 @@
     }
     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);
     }
@@ -1316,9 +1329,9 @@
     }
     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;
@@ -1327,8 +1340,8 @@
     }
     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);
     }
@@ -1338,16 +1351,16 @@
     }
     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;
@@ -1356,16 +1369,16 @@
             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;
@@ -1374,7 +1387,7 @@
             return false;
         }
     }
-    url.isAbsoluteURL = isAbsoluteURL;
+    url$1.isAbsoluteURL = isAbsoluteURL$1;
 
     (function (exports) {
     	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -1386,30 +1399,30 @@
     	}));
     	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);
@@ -1470,8 +1483,8 @@
     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');
@@ -1493,8 +1506,8 @@
     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]) {
@@ -1516,7 +1529,7 @@
     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]) {
@@ -1545,9 +1558,9 @@
     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');
@@ -1580,9 +1593,9 @@
     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');
@@ -1608,9 +1621,9 @@
     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');
@@ -1626,7 +1639,7 @@
     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);
@@ -1708,9 +1721,9 @@
     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');
@@ -1743,7 +1756,7 @@
     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);
@@ -1790,7 +1803,7 @@
     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);
@@ -1830,7 +1843,7 @@
 
     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');
@@ -1848,7 +1861,7 @@
     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) {
@@ -1871,7 +1884,7 @@
 
     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');
@@ -1891,7 +1904,7 @@
     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);
@@ -1931,8 +1944,8 @@
     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');
@@ -1966,8 +1979,8 @@
     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');
@@ -2001,8 +2014,8 @@
     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');
@@ -2024,8 +2037,8 @@
     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');
@@ -2065,7 +2078,7 @@
     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);
@@ -2147,8 +2160,8 @@
     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');
@@ -2168,8 +2181,8 @@
     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');
@@ -2198,8 +2211,8 @@
     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');
@@ -2228,7 +2241,7 @@
     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);
@@ -2274,8 +2287,8 @@
     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');
@@ -2295,7 +2308,7 @@
     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);
@@ -2378,7 +2391,7 @@
     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);
@@ -2447,7 +2460,7 @@
     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";
@@ -2607,7 +2620,7 @@
     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);
@@ -2647,7 +2660,7 @@
     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);
@@ -2693,7 +2706,7 @@
     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);
@@ -2817,7 +2830,7 @@
     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);
@@ -2913,7 +2926,7 @@
     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);
@@ -2960,7 +2973,7 @@
     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);
@@ -3144,7 +3157,7 @@
     	};__exportStar(middleware$1, exports);
     	__exportStar(output$2, exports);
     	
-    } (es2018$8));
+    } (es2018$9));
 
     var getErrorNames$3 = {};
 
@@ -3162,7 +3175,7 @@
     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;
@@ -3183,7 +3196,7 @@
     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)
@@ -3194,9 +3207,9 @@
     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() {
@@ -3232,7 +3245,7 @@
 
     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));
@@ -3247,7 +3260,7 @@
 
     var hydrate$3 = {};
 
-    var es2018$5 = {};
+    var es2018$6 = {};
 
     var pass$3 = {};
 
@@ -3267,10 +3280,10 @@
     	    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]
@@ -3324,11 +3337,11 @@
     	__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');
@@ -3350,7 +3363,7 @@
     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);
@@ -3411,8 +3424,8 @@
     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');
@@ -3434,8 +3447,8 @@
     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]) {
@@ -3457,7 +3470,7 @@
     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]) {
@@ -3486,9 +3499,9 @@
     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');
@@ -3521,9 +3534,9 @@
     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');
@@ -3549,9 +3562,9 @@
     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');
@@ -3567,7 +3580,7 @@
     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);
@@ -3649,9 +3662,9 @@
     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');
@@ -3684,7 +3697,7 @@
     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);
@@ -3731,7 +3744,7 @@
     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);
@@ -3771,7 +3784,7 @@
 
     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');
@@ -3789,7 +3802,7 @@
     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) {
@@ -3812,7 +3825,7 @@
 
     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');
@@ -3832,7 +3845,7 @@
     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);
@@ -3872,8 +3885,8 @@
     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');
@@ -3907,8 +3920,8 @@
     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');
@@ -3942,8 +3955,8 @@
     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');
@@ -3965,8 +3978,8 @@
     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');
@@ -4006,7 +4019,7 @@
     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);
@@ -4088,8 +4101,8 @@
     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');
@@ -4109,8 +4122,8 @@
     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');
@@ -4139,8 +4152,8 @@
     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');
@@ -4169,7 +4182,7 @@
     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);
@@ -4215,8 +4228,8 @@
     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');
@@ -4236,7 +4249,7 @@
     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);
@@ -4319,7 +4332,7 @@
     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);
@@ -4388,7 +4401,7 @@
     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";
@@ -4548,7 +4561,7 @@
     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);
@@ -4588,7 +4601,7 @@
     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);
@@ -4634,7 +4647,7 @@
     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);
@@ -4758,7 +4771,7 @@
     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);
@@ -4854,7 +4867,7 @@
     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);
@@ -4901,7 +4914,7 @@
     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);
@@ -5085,7 +5098,7 @@
     	};__exportStar(middleware$2, exports);
     	__exportStar(output$1, exports);
     	
-    } (es2018$b));
+    } (es2018$c));
 
     var getErrorNames$1 = {};
 
@@ -5103,7 +5116,7 @@
     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;
@@ -5124,7 +5137,7 @@
     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)
@@ -5135,116 +5148,518 @@
     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) {
@@ -5260,72 +5675,30 @@
     	}));
     	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);
@@ -5386,8 +5759,8 @@
     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');
@@ -5409,8 +5782,8 @@
     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]) {
@@ -5432,7 +5805,7 @@
     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]) {
@@ -5461,9 +5834,9 @@
     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');
@@ -5496,9 +5869,9 @@
     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');
@@ -5524,9 +5897,9 @@
     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');
@@ -5542,7 +5915,7 @@
     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);
@@ -5624,9 +5997,9 @@
     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');
@@ -5659,7 +6032,7 @@
     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);
@@ -5706,7 +6079,7 @@
     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);
@@ -5746,7 +6119,7 @@
 
     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');
@@ -5764,7 +6137,7 @@
     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) {
@@ -5787,7 +6160,7 @@
 
     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');
@@ -5807,7 +6180,7 @@
     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);
@@ -5847,8 +6220,8 @@
     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');
@@ -5882,8 +6255,8 @@
     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');
@@ -5917,8 +6290,8 @@
     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');
@@ -5940,8 +6313,8 @@
     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');
@@ -5981,7 +6354,7 @@
     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);
@@ -6063,8 +6436,8 @@
     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');
@@ -6084,8 +6457,8 @@
     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');
@@ -6114,8 +6487,8 @@
     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');
@@ -6144,7 +6517,7 @@
     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);
@@ -6190,8 +6563,8 @@
     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');
@@ -6211,7 +6584,7 @@
     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);
@@ -6294,7 +6667,7 @@
     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);
@@ -6363,7 +6736,7 @@
     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";
@@ -6527,7 +6900,7 @@
     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);
@@ -6567,7 +6940,7 @@
     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);
@@ -6613,7 +6986,7 @@
     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);
@@ -6737,7 +7110,7 @@
     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);
@@ -6833,7 +7206,7 @@
     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);
@@ -6880,7 +7253,7 @@
     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);
@@ -7098,13 +7471,13 @@
     	};__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]() {
@@ -7152,7 +7525,7 @@
          * Return the earliest key inserted in the Map
          */
         getColdestKey() {
-            return es2018$3.first(this.map.keys());
+            return es2018$4.first(this.map.keys());
         }
     }
 
@@ -7433,8 +7806,8 @@
              * 按过期时间升序排列所有项目的元数据
              */
             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]() {
@@ -7553,7 +7926,7 @@
          * Return the earliest key inserted in the Map
          */
         getColdestKey() {
-            return es2018$3.first(this.map.keys());
+            return es2018$4.first(this.map.keys());
         }
     }
 
@@ -7575,7 +7948,7 @@
             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);
@@ -7583,10 +7956,10 @@
             }
         }
         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;
@@ -7638,7 +8011,7 @@
             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;
@@ -7677,7 +8050,7 @@
             }
         }
     }
-    class BadEventError extends es2018$c.CustomError {
+    class BadEventError extends es2018$d.CustomError {
         constructor(state, event) {
             super(`State ${state} cannot react to event ${event}`);
         }
@@ -9268,7 +9641,7 @@
             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();
             }
         }
@@ -9289,7 +9662,7 @@
         }
         has(value) {
             // 跟一般的实现不同, 不需要访问values数组.
-            return es2018$d.isntUndefined(this.valueToValueIndex[value]);
+            return es2018$e.isntUndefined(this.valueToValueIndex[value]);
         }
         add(value) {
             if (!this.has(value)) {
@@ -9312,8 +9685,126 @@
         }
     }
 
+    // 相关提案: 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);
+            }
+        }
+    }
+
     exports.BadEventError = BadEventError;
     exports.Box = Box;
+    exports.DynamicTypedArray = DynamicTypedArray;
     exports.Emitter = Emitter;
     exports.ExpirableMap = ExpirableMap;
     exports.FiniteStateMachine = FiniteStateMachine;