@blackglory/structures 0.3.2 → 0.3.5

package/dist/es2018/index.umd.js

@@ -239,30 +239,2458 @@
 
     var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
-    var es2018$6 = {};
+    var es2018$b = {};
+
+    var customError$1 = {};
+
+    var es2018$a = {};
+
+    var middleware$1 = {};
+
+    var chunkAsync$3 = {};
+
+    var es2018$9 = {};
+
+    var go$3 = {};
+
+    go$3.go = void 0;
+    function go$2(fn) {
+        return fn();
+    }
+    go$3.go = go$2;
+
+    (function (exports) {
+    var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    }) : (function(o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        o[k2] = m[k];
+    }));
+    var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
+        for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+    };__exportStar(go$3, exports);
+
+    }(es2018$9));
+
+    var es2018$8 = {};
+
+    var customError = {};
+
+    customError.CustomError = void 0;
+    class CustomError$1 extends Error {
+        get name() {
+            return this.constructor.name;
+        }
+    }
+    customError.CustomError = CustomError$1;
+
+    var expectedError = {};
+
+    expectedError.ExpectedError = void 0;
+    const custom_error_1$2 = customError;
+    class ExpectedError extends custom_error_1$2.CustomError {
+    }
+    expectedError.ExpectedError = ExpectedError;
+
+    var assertionError$1 = {};
+
+    assertionError$1.AssertionError = void 0;
+    const custom_error_1$1 = customError;
+    class AssertionError$1 extends custom_error_1$1.CustomError {
+    }
+    assertionError$1.AssertionError = AssertionError$1;
+
+    var normalize$3 = {};
+
+    normalize$3.normalize = void 0;
+    function normalize$2(err) {
+        var _a;
+        return {
+            name: err.name,
+            message: err.message,
+            stack: (_a = err.stack) !== null && _a !== void 0 ? _a : null
+        };
+    }
+    normalize$3.normalize = normalize$2;
+
+    var refute$1 = {};
+
+    refute$1.refute = void 0;
+    const expected_error_1 = expectedError;
+    function refute(condition, message) {
+        if (condition)
+            throw new expected_error_1.ExpectedError(message);
+    }
+    refute$1.refute = refute;
+
+    var assert$3 = {};
+
+    assert$3.assert = void 0;
+    const assertion_error_1$1 = assertionError$1;
+    function assert$2(condition, message) {
+        if (!condition)
+            throw new assertion_error_1$1.AssertionError(message);
+    }
+    assert$3.assert = assert$2;
+
+    (function (exports) {
+    var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    }) : (function(o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        o[k2] = m[k];
+    }));
+    var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
+        for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+    };__exportStar(customError, exports);
+    __exportStar(expectedError, exports);
+    __exportStar(assertionError$1, exports);
+    __exportStar(normalize$3, exports);
+    __exportStar(refute$1, exports);
+    __exportStar(assert$3, exports);
+
+    }(es2018$8));
+
+    chunkAsync$3.chunkAsync = void 0;
+    const go_1$v = es2018$9;
+    const errors_1$v = es2018$8;
+    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');
+        return (0, go_1$v.go)(async function* () {
+            let buffer = [];
+            for await (const element of iterable) {
+                buffer.push(element);
+                if (buffer.length >= size) {
+                    yield buffer;
+                    buffer = [];
+                }
+            }
+            if (buffer.length)
+                yield buffer;
+        });
+    }
+    chunkAsync$3.chunkAsync = chunkAsync$2;
+
+    var chunkByAsync$3 = {};
+
+    var es2018$7 = {};
+
+    var array$2 = {};
+
+    array$2.isntEmptyArray = array$2.isEmptyArray = array$2.isntArray = array$2.isArray = void 0;
+    function isArray$2(val) {
+        return Array.isArray(val);
+    }
+    array$2.isArray = isArray$2;
+    function isntArray$2(val) {
+        return !isArray$2(val);
+    }
+    array$2.isntArray = isntArray$2;
+    function isEmptyArray$2(val) {
+        return val.length === 0;
+    }
+    array$2.isEmptyArray = isEmptyArray$2;
+    function isntEmptyArray$2(val) {
+        return val.length !== 0;
+    }
+    array$2.isntEmptyArray = isntEmptyArray$2;
+
+    var asyncIterable$2 = {};
+
+    var _null$2 = {};
+
+    _null$2.isntNull = _null$2.isNull = void 0;
+    function isNull$2(val) {
+        return val === null;
+    }
+    _null$2.isNull = isNull$2;
+    function isntNull$2(val) {
+        return !isNull$2(val);
+    }
+    _null$2.isntNull = isntNull$2;
+
+    var _undefined$2 = {};
+
+    _undefined$2.isntUndefined = _undefined$2.isUndefined = void 0;
+    function isUndefined$2(val) {
+        return val === undefined;
+    }
+    _undefined$2.isUndefined = isUndefined$2;
+    function isntUndefined$2(val) {
+        return !isUndefined$2(val);
+    }
+    _undefined$2.isntUndefined = isntUndefined$2;
+
+    asyncIterable$2.isntAsyncIterable = asyncIterable$2.isAsyncIterable = void 0;
+    const null_1$6 = _null$2;
+    const undefined_1$7 = _undefined$2;
+    function isAsyncIterable$2(val) {
+        return (0, null_1$6.isntNull)(val)
+            && (0, undefined_1$7.isntUndefined)(val)
+            && typeof val[Symbol.asyncIterator] === 'function';
+    }
+    asyncIterable$2.isAsyncIterable = isAsyncIterable$2;
+    function isntAsyncIterable$2(val) {
+        return !isAsyncIterable$2(val);
+    }
+    asyncIterable$2.isntAsyncIterable = isntAsyncIterable$2;
+
+    var bigint$2 = {};
+
+    bigint$2.isntBigInt = bigint$2.isBigInt = void 0;
+    function isBigInt$2(val) {
+        return typeof val === 'bigint';
+    }
+    bigint$2.isBigInt = isBigInt$2;
+    function isntBigInt$2(val) {
+        return !isBigInt$2(val);
+    }
+    bigint$2.isntBigInt = isntBigInt$2;
+
+    var boolean$2 = {};
+
+    boolean$2.isntBoolean = boolean$2.isBoolean = void 0;
+    function isBoolean$2(val) {
+        return typeof val === 'boolean';
+    }
+    boolean$2.isBoolean = isBoolean$2;
+    function isntBoolean$2(val) {
+        return !isBoolean$2(val);
+    }
+    boolean$2.isntBoolean = isntBoolean$2;
+
+    var char$2 = {};
+
+    var string$2 = {};
+
+    string$2.isntString = string$2.isString = void 0;
+    function isString$2(val) {
+        return typeof val === 'string';
+    }
+    string$2.isString = isString$2;
+    function isntString$2(val) {
+        return !isString$2(val);
+    }
+    string$2.isntString = isntString$2;
+
+    char$2.isntChar = char$2.isChar = void 0;
+    const string_1$5 = string$2;
+    function isChar$2(val) {
+        return (0, string_1$5.isString)(val)
+            && val.length === 1;
+    }
+    char$2.isChar = isChar$2;
+    function isntChar$2(val) {
+        return !isChar$2(val);
+    }
+    char$2.isntChar = isntChar$2;
+
+    var date$2 = {};
+
+    date$2.isntDate = date$2.isDate = void 0;
+    function isDate$2(val) {
+        return val instanceof Date;
+    }
+    date$2.isDate = isDate$2;
+    function isntDate$2(val) {
+        return !isDate$2(val);
+    }
+    date$2.isntDate = isntDate$2;
+
+    var _enum$2 = {};
+
+    _enum$2.inEnum = void 0;
+    function inEnum$2(val, _enum) {
+        return Object.values(_enum).includes(val);
+    }
+    _enum$2.inEnum = inEnum$2;
+
+    var error$2 = {};
+
+    error$2.isntError = error$2.isError = void 0;
+    function isError$2(val) {
+        return val instanceof Error;
+    }
+    error$2.isError = isError$2;
+    function isntError$2(val) {
+        return !isError$2(val);
+    }
+    error$2.isntError = isntError$2;
+
+    var falsy$2 = {};
+
+    falsy$2.isntFalsy = falsy$2.isFalsy = void 0;
+    function isFalsy$2(val) {
+        return !val;
+    }
+    falsy$2.isFalsy = isFalsy$2;
+    function isntFalsy$2(val) {
+        return !isFalsy$2(val);
+    }
+    falsy$2.isntFalsy = isntFalsy$2;
+
+    var _function$2 = {};
+
+    _function$2.isntFunction = _function$2.isFunction = void 0;
+    function isFunction$3(val) {
+        return typeof val === 'function';
+    }
+    _function$2.isFunction = isFunction$3;
+    function isntFunction$2(val) {
+        return !isFunction$3(val);
+    }
+    _function$2.isntFunction = isntFunction$2;
+
+    var iterable$2 = {};
+
+    iterable$2.isntIterable = iterable$2.isIterable = void 0;
+    const null_1$5 = _null$2;
+    const undefined_1$6 = _undefined$2;
+    function isIterable$2(val) {
+        return (0, null_1$5.isntNull)(val)
+            && (0, undefined_1$6.isntUndefined)(val)
+            && typeof val[Symbol.iterator] === 'function';
+    }
+    iterable$2.isIterable = isIterable$2;
+    function isntIterable$2(val) {
+        return !isIterable$2(val);
+    }
+    iterable$2.isntIterable = isntIterable$2;
+
+    var jsonRpc$1 = {};
+
+    var object$2 = {};
+
+    /**
+     * lodash (Custom Build) <https://lodash.com/>
+     * Build: `lodash modularize exports="npm" -o ./`
+     * Copyright jQuery Foundation and other contributors <https://jquery.org/>
+     * Released under MIT license <https://lodash.com/license>
+     * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+     * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+     */
+
+    /** `Object#toString` result references. */
+    var objectTag = '[object Object]';
+
+    /**
+     * Checks if `value` is a host object in IE < 9.
+     *
+     * @private
+     * @param {*} value The value to check.
+     * @returns {boolean} Returns `true` if `value` is a host object, else `false`.
+     */
+    function isHostObject(value) {
+      // Many host objects are `Object` objects that can coerce to strings
+      // despite having improperly defined `toString` methods.
+      var result = false;
+      if (value != null && typeof value.toString != 'function') {
+        try {
+          result = !!(value + '');
+        } catch (e) {}
+      }
+      return result;
+    }
+
+    /**
+     * Creates a unary function that invokes `func` with its argument transformed.
+     *
+     * @private
+     * @param {Function} func The function to wrap.
+     * @param {Function} transform The argument transform.
+     * @returns {Function} Returns the new function.
+     */
+    function overArg(func, transform) {
+      return function(arg) {
+        return func(transform(arg));
+      };
+    }
+
+    /** Used for built-in method references. */
+    var funcProto = Function.prototype,
+        objectProto = Object.prototype;
+
+    /** Used to resolve the decompiled source of functions. */
+    var funcToString = funcProto.toString;
+
+    /** Used to check objects for own properties. */
+    var hasOwnProperty = objectProto.hasOwnProperty;
+
+    /** Used to infer the `Object` constructor. */
+    var objectCtorString = funcToString.call(Object);
+
+    /**
+     * Used to resolve the
+     * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+     * of values.
+     */
+    var objectToString = objectProto.toString;
+
+    /** Built-in value references. */
+    var getPrototype = overArg(Object.getPrototypeOf, Object);
+
+    /**
+     * Checks if `value` is object-like. A value is object-like if it's not `null`
+     * and has a `typeof` result of "object".
+     *
+     * @static
+     * @memberOf _
+     * @since 4.0.0
+     * @category Lang
+     * @param {*} value The value to check.
+     * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+     * @example
+     *
+     * _.isObjectLike({});
+     * // => true
+     *
+     * _.isObjectLike([1, 2, 3]);
+     * // => true
+     *
+     * _.isObjectLike(_.noop);
+     * // => false
+     *
+     * _.isObjectLike(null);
+     * // => false
+     */
+    function isObjectLike(value) {
+      return !!value && typeof value == 'object';
+    }
+
+    /**
+     * Checks if `value` is a plain object, that is, an object created by the
+     * `Object` constructor or one with a `[[Prototype]]` of `null`.
+     *
+     * @static
+     * @memberOf _
+     * @since 0.8.0
+     * @category Lang
+     * @param {*} value The value to check.
+     * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
+     * @example
+     *
+     * function Foo() {
+     *   this.a = 1;
+     * }
+     *
+     * _.isPlainObject(new Foo);
+     * // => false
+     *
+     * _.isPlainObject([1, 2, 3]);
+     * // => false
+     *
+     * _.isPlainObject({ 'x': 0, 'y': 0 });
+     * // => true
+     *
+     * _.isPlainObject(Object.create(null));
+     * // => true
+     */
+    function isPlainObject$3(value) {
+      if (!isObjectLike(value) ||
+          objectToString.call(value) != objectTag || isHostObject(value)) {
+        return false;
+      }
+      var proto = getPrototype(value);
+      if (proto === null) {
+        return true;
+      }
+      var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;
+      return (typeof Ctor == 'function' &&
+        Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString);
+    }
+
+    var lodash_isplainobject = isPlainObject$3;
+
+    var __importDefault$2 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+        return (mod && mod.__esModule) ? mod : { "default": mod };
+    };object$2.isntEmptyObject = object$2.isEmptyObject = object$2.isntPlainObject = object$2.isPlainObject = object$2.isntObject = object$2.isObject = void 0;
+    const lodash_isplainobject_1$2 = __importDefault$2(lodash_isplainobject);
+    function isObject$2(val) {
+        return val !== null
+            && typeof val === 'object';
+    }
+    object$2.isObject = isObject$2;
+    function isntObject$2(val) {
+        return !isObject$2(val);
+    }
+    object$2.isntObject = isntObject$2;
+    function isPlainObject$2(val) {
+        return (0, lodash_isplainobject_1$2.default)(val);
+    }
+    object$2.isPlainObject = isPlainObject$2;
+    function isntPlainObject$2(val) {
+        return !isPlainObject$2(val);
+    }
+    object$2.isntPlainObject = isntPlainObject$2;
+    function isEmptyObject$2(val) {
+        return Object.keys(val).length === 0;
+    }
+    object$2.isEmptyObject = isEmptyObject$2;
+    function isntEmptyObject$2(val) {
+        return Object.keys(val).length !== 0;
+    }
+    object$2.isntEmptyObject = isntEmptyObject$2;
+
+    var number$2 = {};
+
+    number$2.isntNumber = number$2.isNumber = void 0;
+    function isNumber$2(val) {
+        return typeof val === 'number';
+    }
+    number$2.isNumber = isNumber$2;
+    function isntNumber$2(val) {
+        return !isNumber$2(val);
+    }
+    number$2.isntNumber = isntNumber$2;
+
+    jsonRpc$1.isntJsonRpcError = jsonRpc$1.isJsonRpcError = jsonRpc$1.isntJsonRpcSuccess = jsonRpc$1.isJsonRpcSuccess = jsonRpc$1.isntJsonRpcRequest = jsonRpc$1.isJsonRpcRequest = jsonRpc$1.isntJsonRpcNotification = jsonRpc$1.isJsonRpcNotification = void 0;
+    const array_1$2 = array$2;
+    const object_1$3 = object$2;
+    const string_1$4 = string$2;
+    const number_1$2 = number$2;
+    const undefined_1$5 = _undefined$2;
+    function isJsonRpcId$1(val) {
+        return (0, string_1$4.isString)(val) || (0, number_1$2.isNumber)(val);
+    }
+    function isJsonRpcParams$1(val) {
+        return (0, array_1$2.isArray)(val) || (0, object_1$3.isObject)(val);
+    }
+    function isJsonRpcNotification$1(val) {
+        return (0, object_1$3.isPlainObject)(val)
+            && (0, string_1$4.isString)(val.jsonrpc)
+            && (0, string_1$4.isString)(val.method)
+            && (0, undefined_1$5.isUndefined)(val.id)
+            && isJsonRpcParams$1(val.params);
+    }
+    jsonRpc$1.isJsonRpcNotification = isJsonRpcNotification$1;
+    function isntJsonRpcNotification$1(val) {
+        return !isJsonRpcNotification$1(val);
+    }
+    jsonRpc$1.isntJsonRpcNotification = isntJsonRpcNotification$1;
+    function isJsonRpcRequest$1(val) {
+        return (0, object_1$3.isPlainObject)(val)
+            && (0, string_1$4.isString)(val.jsonrpc)
+            && (0, string_1$4.isString)(val.method)
+            && isJsonRpcId$1(val.id)
+            && isJsonRpcParams$1(val.params);
+    }
+    jsonRpc$1.isJsonRpcRequest = isJsonRpcRequest$1;
+    function isntJsonRpcRequest$1(val) {
+        return !isJsonRpcRequest$1(val);
+    }
+    jsonRpc$1.isntJsonRpcRequest = isntJsonRpcRequest$1;
+    function isJsonRpcSuccess$1(val) {
+        return (0, object_1$3.isPlainObject)(val)
+            && (0, string_1$4.isString)(val.jsonrpc)
+            && (0, string_1$4.isString)(val.id)
+            && 'result' in val;
+    }
+    jsonRpc$1.isJsonRpcSuccess = isJsonRpcSuccess$1;
+    function isntJsonRpcSuccess$1(val) {
+        return !isJsonRpcSuccess$1(val);
+    }
+    jsonRpc$1.isntJsonRpcSuccess = isntJsonRpcSuccess$1;
+    function isJsonRpcError$1(val) {
+        return (0, object_1$3.isPlainObject)(val)
+            && (0, string_1$4.isString)(val.jsonrpc)
+            && isJsonRpcId$1(val.id)
+            && isJsonRpcErrorObject$1(val.error);
+    }
+    jsonRpc$1.isJsonRpcError = isJsonRpcError$1;
+    function isntJsonRpcError$1(val) {
+        return !isJsonRpcError$1(val);
+    }
+    jsonRpc$1.isntJsonRpcError = isntJsonRpcError$1;
+    function isJsonRpcErrorObject$1(val) {
+        return (0, object_1$3.isPlainObject)(val)
+            && (0, number_1$2.isNumber)(val.code)
+            && (0, string_1$4.isString)(val.message)
+            && ((0, undefined_1$5.isUndefined)(val.data) || (0, object_1$3.isObject)(val.data));
+    }
+
+    var json$2 = {};
+
+    json$2.isntJson = json$2.isJson = void 0;
+    function isJson$2(val) {
+        try {
+            JSON.stringify(val);
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    json$2.isJson = isJson$2;
+    function isntJson$2(val) {
+        return !isntJson$2();
+    }
+    json$2.isntJson = isntJson$2;
+
+    var url$2 = {};
+
+    url$2.isAbsoluteURL = void 0;
+    function isAbsoluteURL$2(str) {
+        try {
+            new URL(str);
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    url$2.isAbsoluteURL = isAbsoluteURL$2;
+
+    (function (exports) {
+    var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    }) : (function(o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        o[k2] = m[k];
+    }));
+    var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
+        for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+    };__exportStar(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(jsonRpc$1, exports);
+    __exportStar(json$2, exports);
+    __exportStar(_null$2, exports);
+    __exportStar(number$2, exports);
+    __exportStar(object$2, exports);
+    __exportStar(string$2, exports);
+    __exportStar(_undefined$2, exports);
+    __exportStar(url$2, exports);
+
+    }(es2018$7));
+
+    chunkByAsync$3.chunkByAsync = void 0;
+    const types_1$C = es2018$7;
+    function chunkByAsync$2(iterable, predicate) {
+        if ((0, types_1$C.isAsyncIterable)(iterable)) {
+            return chunkByAsyncIterable(iterable);
+        }
+        else {
+            return chunkByIterable(iterable);
+        }
+        async function* chunkByAsyncIterable(iterable) {
+            let buffer = [];
+            let index = 0;
+            for await (const element of iterable) {
+                buffer.push(element);
+                if (await predicate(element, index)) {
+                    yield buffer;
+                    buffer = [];
+                }
+                index++;
+            }
+            if (buffer.length)
+                yield buffer;
+        }
+        async function* chunkByIterable(iterable) {
+            let buffer = [];
+            let index = 0;
+            for (const element of iterable) {
+                buffer.push(element);
+                if (await predicate(element, index)) {
+                    yield buffer;
+                    buffer = [];
+                }
+                index++;
+            }
+            if (buffer.length)
+                yield buffer;
+        }
+    }
+    chunkByAsync$3.chunkByAsync = chunkByAsync$2;
+
+    var chunkBy$3 = {};
+
+    chunkBy$3.chunkBy = void 0;
+    function* chunkBy$2(iterable, predicate) {
+        let buffer = [];
+        let index = 0;
+        for (const element of iterable) {
+            buffer.push(element);
+            if (predicate(element, index)) {
+                yield buffer;
+                buffer = [];
+            }
+            index++;
+        }
+        if (buffer.length)
+            yield buffer;
+    }
+    chunkBy$3.chunkBy = chunkBy$2;
+
+    var chunk$3 = {};
+
+    chunk$3.chunk = void 0;
+    const go_1$u = es2018$9;
+    const errors_1$u = es2018$8;
+    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');
+        return (0, go_1$u.go)(function* () {
+            let buffer = [];
+            for (const element of iterable) {
+                buffer.push(element);
+                if (buffer.length >= size) {
+                    yield buffer;
+                    buffer = [];
+                }
+            }
+            if (buffer.length)
+                yield buffer;
+        });
+    }
+    chunk$3.chunk = chunk$2;
+
+    var concatAsync$3 = {};
+
+    concatAsync$3.concatAsync = void 0;
+    const types_1$B = es2018$7;
+    const go_1$t = es2018$9;
+    function concatAsync$2(iterable, ...otherIterables) {
+        return (0, go_1$t.go)(async function* () {
+            for (const iter of [iterable, ...otherIterables]) {
+                if ((0, types_1$B.isAsyncIterable)(iter)) {
+                    for await (const element of iter) {
+                        yield element;
+                    }
+                }
+                else {
+                    for (const element of iter) {
+                        yield element;
+                    }
+                }
+            }
+        });
+    }
+    concatAsync$3.concatAsync = concatAsync$2;
+
+    var concat$3 = {};
+
+    concat$3.concat = void 0;
+    const go_1$s = es2018$9;
+    function concat$2(iterable, ...otherIterables) {
+        return (0, go_1$s.go)(function* () {
+            for (const iter of [iterable, ...otherIterables]) {
+                yield* iter;
+            }
+        });
+    }
+    concat$3.concat = concat$2;
+
+    var dropAsync$3 = {};
+
+    var utils$1 = {};
+
+    utils$1.copyIterable = utils$1.copyAsyncIterable = void 0;
+    async function* copyAsyncIterable$1(iterable) {
+        for await (const element of iterable) {
+            yield element;
+        }
+    }
+    utils$1.copyAsyncIterable = copyAsyncIterable$1;
+    function* copyIterable$1(iterable) {
+        for (const element of iterable) {
+            yield element;
+        }
+    }
+    utils$1.copyIterable = copyIterable$1;
+
+    dropAsync$3.dropAsync = void 0;
+    const go_1$r = es2018$9;
+    const utils_1$7 = utils$1;
+    const errors_1$t = es2018$8;
+    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');
+        if (count === 0)
+            return (0, utils_1$7.copyAsyncIterable)(iterable);
+        return (0, go_1$r.go)(async function* () {
+            var _a;
+            const iterator = iterable[Symbol.asyncIterator]();
+            let done;
+            try {
+                let value;
+                while ({ value, done } = await iterator.next(), !done) {
+                    if (count <= 0)
+                        break;
+                    count--;
+                }
+                while (!done) {
+                    yield value;
+                    ({ value, done } = await iterator.next());
+                }
+            }
+            finally {
+                if (!done)
+                    await ((_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator));
+            }
+        });
+    }
+    dropAsync$3.dropAsync = dropAsync$2;
+
+    var dropRightAsync$3 = {};
+
+    dropRightAsync$3.dropRightAsync = void 0;
+    const go_1$q = es2018$9;
+    const utils_1$6 = utils$1;
+    const errors_1$s = es2018$8;
+    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');
+        if (count === 0)
+            return (0, utils_1$6.copyAsyncIterable)(iterable);
+        return (0, go_1$q.go)(async function* () {
+            const arr = await toArrayAsync$5(iterable);
+            const result = arr.slice(0, -count);
+            for (const value of result) {
+                yield value;
+            }
+        });
+    }
+    dropRightAsync$3.dropRightAsync = dropRightAsync$2;
+    async function toArrayAsync$5(iterable) {
+        const result = [];
+        for await (const element of iterable) {
+            result.push(element);
+        }
+        return result;
+    }
+
+    var dropRight$3 = {};
+
+    dropRight$3.dropRight = void 0;
+    const go_1$p = es2018$9;
+    const utils_1$5 = utils$1;
+    const errors_1$r = es2018$8;
+    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');
+        if (count === 0)
+            return (0, utils_1$5.copyIterable)(iterable);
+        return (0, go_1$p.go)(function* () {
+            const arr = Array.from(iterable);
+            yield* arr.slice(0, -count);
+        });
+    }
+    dropRight$3.dropRight = dropRight$2;
+
+    var dropUntilAsync$3 = {};
+
+    dropUntilAsync$3.dropUntilAsync = void 0;
+    const types_1$A = es2018$7;
+    function dropUntilAsync$2(iterable, predicate) {
+        if ((0, types_1$A.isAsyncIterable)(iterable)) {
+            return dropUntilAsyncIterable(iterable);
+        }
+        else {
+            return dropUntilIterable(iterable);
+        }
+        async function* dropUntilAsyncIterable(iterable) {
+            var _a;
+            const iterator = iterable[Symbol.asyncIterator]();
+            let done;
+            try {
+                let index = 0;
+                let value;
+                while ({ value, done } = await iterator.next(), !done) {
+                    if (await predicate(value, index++))
+                        break;
+                }
+                while (!done) {
+                    yield value;
+                    ({ value, done } = await iterator.next());
+                }
+            }
+            finally {
+                if (!done)
+                    await ((_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator));
+            }
+        }
+        async function* dropUntilIterable(iterable) {
+            var _a;
+            const iterator = iterable[Symbol.iterator]();
+            let done;
+            try {
+                let index = 0;
+                let value;
+                while ({ value, done } = iterator.next(), !done) {
+                    if (await predicate(value, index++))
+                        break;
+                }
+                while (!done) {
+                    yield value;
+                    ({ value, done } = iterator.next());
+                }
+            }
+            finally {
+                if (!done)
+                    (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
+            }
+        }
+    }
+    dropUntilAsync$3.dropUntilAsync = dropUntilAsync$2;
+
+    var dropUntil$3 = {};
+
+    dropUntil$3.dropUntil = void 0;
+    function* dropUntil$2(iterable, predicate) {
+        var _a;
+        const iterator = iterable[Symbol.iterator]();
+        let done;
+        try {
+            let index = 0;
+            let value;
+            while ({ value, done } = iterator.next(), !done) {
+                if (predicate(value, index++))
+                    break;
+            }
+            while (!done) {
+                yield value;
+                ({ value, done } = iterator.next());
+            }
+        }
+        finally {
+            if (!done)
+                (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
+        }
+    }
+    dropUntil$3.dropUntil = dropUntil$2;
+
+    var drop$3 = {};
+
+    drop$3.drop = void 0;
+    const go_1$o = es2018$9;
+    const utils_1$4 = utils$1;
+    const errors_1$q = es2018$8;
+    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');
+        if (count === 0)
+            return (0, utils_1$4.copyIterable)(iterable);
+        return (0, go_1$o.go)(function* () {
+            var _a;
+            const iterator = iterable[Symbol.iterator]();
+            let done;
+            try {
+                let value;
+                while ({ value, done } = iterator.next(), !done) {
+                    if (count <= 0)
+                        break;
+                    count--;
+                }
+                while (!done) {
+                    yield value;
+                    ({ value, done } = iterator.next());
+                }
+            }
+            finally {
+                if (!done)
+                    (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
+            }
+        });
+    }
+    drop$3.drop = drop$2;
+
+    var filterAsync$3 = {};
+
+    filterAsync$3.filterAsync = void 0;
+    const types_1$z = es2018$7;
+    function filterAsync$2(iterable, predicate) {
+        if ((0, types_1$z.isAsyncIterable)(iterable)) {
+            return filterAsyncIterable(iterable);
+        }
+        else {
+            return filterIterable(iterable);
+        }
+        async function* filterAsyncIterable(iterable) {
+            let index = 0;
+            for await (const element of iterable) {
+                if (await predicate(element, index))
+                    yield element;
+                index++;
+            }
+        }
+        async function* filterIterable(iterable) {
+            let index = 0;
+            for (const element of iterable) {
+                if (await predicate(element, index))
+                    yield element;
+                index++;
+            }
+        }
+    }
+    filterAsync$3.filterAsync = filterAsync$2;
+
+    var filter$3 = {};
+
+    filter$3.filter = void 0;
+    function* filter$2(iterable, predicate) {
+        let index = 0;
+        for (const element of iterable) {
+            if (predicate(element, index))
+                yield element;
+            index++;
+        }
+    }
+    filter$3.filter = filter$2;
+
+    var flattenAsync$3 = {};
+
+    var flattenDeepAsync$3 = {};
+
+    var flattenByAsync$3 = {};
+
+    flattenByAsync$3.flattenByAsync = void 0;
+    const types_1$y = es2018$7;
+    function flattenByAsync$2(iterable, predicate) {
+        if ((0, types_1$y.isAsyncIterable)(iterable)) {
+            return flattenByAsyncIterable(iterable);
+        }
+        else {
+            return flattenByIterable(iterable);
+        }
+        async function* flattenByAsyncIterable(iterable) {
+            const level = 1;
+            for await (const element of iterable) {
+                if (isFiniteIterable$3(element) && await predicate(element, level)) {
+                    yield* flatten(element, level + 1);
+                }
+                else {
+                    yield element;
+                }
+            }
+        }
+        function flattenByIterable(iterable) {
+            return flatten(iterable, 1);
+        }
+        async function* flatten(iterable, level) {
+            for (const element of iterable) {
+                if (isFiniteIterable$3(element) && await predicate(element, level)) {
+                    yield* flatten(element, level + 1);
+                }
+                else {
+                    yield element;
+                }
+            }
+        }
+    }
+    flattenByAsync$3.flattenByAsync = flattenByAsync$2;
+    function isFiniteIterable$3(val) {
+        return (0, types_1$y.isIterable)(val) && (0, types_1$y.isntChar)(val);
+    }
+
+    flattenDeepAsync$3.flattenDeepAsync = void 0;
+    const flatten_by_async_1$1 = flattenByAsync$3;
+    const errors_1$p = es2018$8;
+    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');
+        return (0, flatten_by_async_1$1.flattenByAsync)(iterable, (_, level) => level <= depth);
+    }
+    flattenDeepAsync$3.flattenDeepAsync = flattenDeepAsync$2;
+
+    flattenAsync$3.flattenAsync = void 0;
+    const flatten_deep_async_1$1 = flattenDeepAsync$3;
+    function flattenAsync$2(iterable) {
+        return (0, flatten_deep_async_1$1.flattenDeepAsync)(iterable, 1);
+    }
+    flattenAsync$3.flattenAsync = flattenAsync$2;
+
+    var flattenBy$3 = {};
+
+    flattenBy$3.flattenBy = void 0;
+    const types_1$x = es2018$7;
+    function flattenBy$2(iterable, predicate) {
+        return flatten(iterable, 1);
+        function* flatten(iterable, level) {
+            for (const element of iterable) {
+                if (isFiniteIterable$2(element) && predicate(element, level)) {
+                    yield* flatten(element, level + 1);
+                }
+                else {
+                    yield element;
+                }
+            }
+        }
+    }
+    flattenBy$3.flattenBy = flattenBy$2;
+    function isFiniteIterable$2(val) {
+        return (0, types_1$x.isIterable)(val) && (0, types_1$x.isntChar)(val);
+    }
+
+    var flattenDeep$3 = {};
+
+    flattenDeep$3.flattenDeep = void 0;
+    const flatten_by_1$1 = flattenBy$3;
+    const errors_1$o = es2018$8;
+    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');
+        return (0, flatten_by_1$1.flattenBy)(iterable, (_, level) => level <= depth);
+    }
+    flattenDeep$3.flattenDeep = flattenDeep$2;
+
+    var flatten$3 = {};
+
+    flatten$3.flatten = void 0;
+    const flatten_deep_1$1 = flattenDeep$3;
+    function flatten$2(iterable) {
+        return (0, flatten_deep_1$1.flattenDeep)(iterable, 1);
+    }
+    flatten$3.flatten = flatten$2;
+
+    var mapAsync$3 = {};
+
+    mapAsync$3.mapAsync = void 0;
+    const types_1$w = es2018$7;
+    function mapAsync$2(iterable, fn) {
+        if ((0, types_1$w.isAsyncIterable)(iterable)) {
+            return mapAsyncIterable(iterable);
+        }
+        else {
+            return mapIterable(iterable);
+        }
+        async function* mapAsyncIterable(iterable) {
+            let index = 0;
+            for await (const element of iterable) {
+                yield await fn(element, index);
+                index++;
+            }
+        }
+        async function* mapIterable(iterable) {
+            let index = 0;
+            for (const element of iterable) {
+                yield await fn(element, index);
+                index++;
+            }
+        }
+    }
+    mapAsync$3.mapAsync = mapAsync$2;
+
+    var map$3 = {};
+
+    map$3.map = void 0;
+    function* map$2(iterable, fn) {
+        let index = 0;
+        for (const element of iterable) {
+            yield fn(element, index);
+            index++;
+        }
+    }
+    map$3.map = map$2;
+
+    var repeatAsync$3 = {};
+
+    repeatAsync$3.repeatAsync = void 0;
+    const go_1$n = es2018$9;
+    const errors_1$n = es2018$8;
+    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');
+        if (times === Infinity)
+            warnInfiniteLoop$3();
+        return (0, go_1$n.go)(async function* () {
+            const cache = [];
+            if (times > 0) {
+                for await (const element of iterable) {
+                    yield element;
+                    cache.push(element);
+                }
+                times--;
+            }
+            while (times > 0) {
+                yield* cache;
+                times--;
+            }
+        });
+    }
+    repeatAsync$3.repeatAsync = repeatAsync$2;
+    function warnInfiniteLoop$3() {
+        if (isProduction$3())
+            return;
+        console.warn('When iterable has no elements and times is Infinity, repeat() will be in dead loop');
+    }
+    function isProduction$3() {
+        return process.env.NODE_ENV === 'production';
+    }
+
+    var repeat$3 = {};
+
+    repeat$3.repeat = void 0;
+    const go_1$m = es2018$9;
+    const errors_1$m = es2018$8;
+    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');
+        if (times === Infinity)
+            warnInfiniteLoop$2();
+        return (0, go_1$m.go)(function* () {
+            const cache = [];
+            if (times > 0) {
+                for (const element of iterable) {
+                    yield element;
+                    cache.push(element);
+                }
+                times--;
+            }
+            while (times > 0) {
+                yield* cache;
+                times--;
+            }
+        });
+    }
+    repeat$3.repeat = repeat$2;
+    function warnInfiniteLoop$2() {
+        if (isProduction$2())
+            return;
+        console.warn('When iterable has no elements and times is Infinity, repeat() will be in dead loop');
+    }
+    function isProduction$2() {
+        return process.env.NODE_ENV === 'production';
+    }
+
+    var sliceAsync$3 = {};
+
+    sliceAsync$3.sliceAsync = void 0;
+    const go_1$l = es2018$9;
+    const errors_1$l = es2018$8;
+    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');
+        (0, errors_1$l.assert)(Number.isInteger(end), 'The parameter end must be an integer');
+        (0, errors_1$l.assert)(end >= start, 'The parameter end must be greater than or equal to start');
+        return (0, go_1$l.go)(async function* () {
+            let index = 0;
+            for await (const element of iterable) {
+                if (index >= end)
+                    break;
+                if (index >= start)
+                    yield element;
+                index++;
+            }
+        });
+    }
+    sliceAsync$3.sliceAsync = sliceAsync$2;
+
+    var slice$3 = {};
+
+    slice$3.slice = void 0;
+    const go_1$k = es2018$9;
+    const errors_1$k = es2018$8;
+    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');
+        (0, errors_1$k.assert)(Number.isInteger(end), 'The parameter end must be an integer');
+        (0, errors_1$k.assert)(end >= start, 'The parameter end must be greater than or equal to start');
+        return (0, go_1$k.go)(function* () {
+            let index = 0;
+            for (const element of iterable) {
+                if (index >= end)
+                    break;
+                if (index >= start)
+                    yield element;
+                index++;
+            }
+        });
+    }
+    slice$3.slice = slice$2;
+
+    var splitAsync$3 = {};
+
+    splitAsync$3.splitAsync = void 0;
+    async function* splitAsync$2(iterable, separator) {
+        let buffer = [];
+        for await (const element of iterable) {
+            if (element === separator) {
+                yield buffer;
+                buffer = [];
+            }
+            else {
+                buffer.push(element);
+            }
+        }
+        yield buffer;
+    }
+    splitAsync$3.splitAsync = splitAsync$2;
+
+    var splitByAsync$3 = {};
+
+    splitByAsync$3.splitByAsync = void 0;
+    const types_1$v = es2018$7;
+    function splitByAsync$2(iterable, predicate) {
+        if ((0, types_1$v.isAsyncIterable)(iterable)) {
+            return splitByAsyncIterable(iterable);
+        }
+        else {
+            return splitByIterable(iterable);
+        }
+        async function* splitByIterable(iterable) {
+            let buffer = [];
+            let index = 0;
+            for (const element of iterable) {
+                if (await predicate(element, index)) {
+                    yield buffer;
+                    buffer = [];
+                }
+                else {
+                    buffer.push(element);
+                }
+                index++;
+            }
+            yield buffer;
+        }
+        async function* splitByAsyncIterable(iterable) {
+            let buffer = [];
+            let index = 0;
+            for await (const element of iterable) {
+                if (await predicate(element, index)) {
+                    yield buffer;
+                    buffer = [];
+                }
+                else {
+                    buffer.push(element);
+                }
+                index++;
+            }
+            yield buffer;
+        }
+    }
+    splitByAsync$3.splitByAsync = splitByAsync$2;
+
+    var splitBy$3 = {};
+
+    splitBy$3.splitBy = void 0;
+    function* splitBy$2(iterable, predicate) {
+        let buffer = [];
+        let index = 0;
+        for (const element of iterable) {
+            if (predicate(element, index)) {
+                yield buffer;
+                buffer = [];
+            }
+            else {
+                buffer.push(element);
+            }
+            index++;
+        }
+        yield buffer;
+    }
+    splitBy$3.splitBy = splitBy$2;
+
+    var split$3 = {};
+
+    split$3.split = void 0;
+    function* split$2(iterable, separator) {
+        let buffer = [];
+        for (const element of iterable) {
+            if (element === separator) {
+                yield buffer;
+                buffer = [];
+            }
+            else {
+                buffer.push(element);
+            }
+        }
+        yield buffer;
+    }
+    split$3.split = split$2;
+
+    var takeAsync$3 = {};
+
+    takeAsync$3.takeAsync = void 0;
+    const go_1$j = es2018$9;
+    const errors_1$j = es2018$8;
+    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');
+        return (0, go_1$j.go)(async function* () {
+            if (count === 0)
+                return;
+            for await (const element of iterable) {
+                yield element;
+                count--;
+                if (count === 0)
+                    break;
+            }
+        });
+    }
+    takeAsync$3.takeAsync = takeAsync$2;
+
+    var takeRightAsync$3 = {};
+
+    takeRightAsync$3.takeRightAsync = void 0;
+    const go_1$i = es2018$9;
+    const errors_1$i = es2018$8;
+    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');
+        return (0, go_1$i.go)(async function* () {
+            var _a;
+            const iterator = iterable[Symbol.asyncIterator]();
+            let done;
+            try {
+                const buffer = [];
+                let value;
+                while ({ value, done } = await iterator.next(), !done) {
+                    buffer.push(value);
+                    if (buffer.length > count)
+                        buffer.shift();
+                }
+                yield* buffer;
+            }
+            finally {
+                if (!done)
+                    await ((_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator));
+            }
+        });
+    }
+    takeRightAsync$3.takeRightAsync = takeRightAsync$2;
+
+    var takeRight$3 = {};
+
+    takeRight$3.takeRight = void 0;
+    const go_1$h = es2018$9;
+    const errors_1$h = es2018$8;
+    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');
+        return (0, go_1$h.go)(function* () {
+            var _a;
+            const iterator = iterable[Symbol.iterator]();
+            let done;
+            try {
+                const buffer = [];
+                let value;
+                while ({ value, done } = iterator.next(), !done) {
+                    buffer.push(value);
+                    if (buffer.length > count)
+                        buffer.shift();
+                }
+                yield* buffer;
+            }
+            finally {
+                if (!done)
+                    (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
+            }
+        });
+    }
+    takeRight$3.takeRight = takeRight$2;
+
+    var takeUntilAsync$3 = {};
+
+    takeUntilAsync$3.takeUntilAsync = void 0;
+    const types_1$u = es2018$7;
+    function takeUntilAsync$2(iterable, predicate) {
+        if ((0, types_1$u.isAsyncIterable)(iterable)) {
+            return takeUntilAsyncIterable(iterable);
+        }
+        else {
+            return takeUntilIterable(iterable);
+        }
+        async function* takeUntilAsyncIterable(iterable) {
+            let index = 0;
+            for await (const element of iterable) {
+                if (await predicate(element, index))
+                    break;
+                yield element;
+                index++;
+            }
+        }
+        async function* takeUntilIterable(iterable) {
+            let index = 0;
+            for (const element of iterable) {
+                if (await predicate(element, index))
+                    break;
+                yield element;
+                index++;
+            }
+        }
+    }
+    takeUntilAsync$3.takeUntilAsync = takeUntilAsync$2;
+
+    var takeUntil$3 = {};
+
+    takeUntil$3.takeUntil = void 0;
+    function* takeUntil$2(iterable, predicate) {
+        let index = 0;
+        for (const element of iterable) {
+            if (predicate(element, index))
+                break;
+            yield element;
+            index++;
+        }
+    }
+    takeUntil$3.takeUntil = takeUntil$2;
+
+    var take$3 = {};
+
+    take$3.take = void 0;
+    const go_1$g = es2018$9;
+    const errors_1$g = es2018$8;
+    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');
+        return (0, go_1$g.go)(function* () {
+            if (count === 0)
+                return;
+            for (const element of iterable) {
+                yield element;
+                count--;
+                if (count === 0)
+                    break;
+            }
+        });
+    }
+    take$3.take = take$2;
+
+    var tapAsync$3 = {};
+
+    tapAsync$3.tapAsync = void 0;
+    const types_1$t = es2018$7;
+    function tapAsync$2(iterable, fn) {
+        if ((0, types_1$t.isAsyncIterable)(iterable)) {
+            return tapAsyncIterable(iterable);
+        }
+        else {
+            return tapIterable(iterable);
+        }
+        async function* tapIterable(iterable) {
+            let index = 0;
+            for (const element of iterable) {
+                await fn(element, index);
+                yield element;
+                index++;
+            }
+        }
+        async function* tapAsyncIterable(iterable) {
+            let index = 0;
+            for await (const element of iterable) {
+                await fn(element, index);
+                yield element;
+                index++;
+            }
+        }
+    }
+    tapAsync$3.tapAsync = tapAsync$2;
+
+    var tap$3 = {};
+
+    tap$3.tap = void 0;
+    function* tap$2(iterable, fn) {
+        let index = 0;
+        for (const element of iterable) {
+            fn(element, index);
+            yield element;
+            index++;
+        }
+    }
+    tap$3.tap = tap$2;
+
+    var toAsyncIterable$3 = {};
+
+    toAsyncIterable$3.toAsyncIterable = void 0;
+    async function* toAsyncIterable$2(iterable) {
+        for (const value of iterable) {
+            yield value;
+        }
+    }
+    toAsyncIterable$3.toAsyncIterable = toAsyncIterable$2;
+
+    var transformAsync$3 = {};
+
+    transformAsync$3.transformAsync = void 0;
+    async function* transformAsync$2(iterable, transformer) {
+        yield* transformer(iterable);
+    }
+    transformAsync$3.transformAsync = transformAsync$2;
+
+    var transform$3 = {};
+
+    transform$3.transform = void 0;
+    function* transform$2(iterable, transformer) {
+        yield* transformer(iterable);
+    }
+    transform$3.transform = transform$2;
+
+    var uniqAsync$3 = {};
+
+    uniqAsync$3.uniqAsync = void 0;
+    async function* uniqAsync$2(iterable) {
+        const bucket = new Set();
+        for await (const element of iterable) {
+            if (!bucket.has(element)) {
+                yield element;
+                bucket.add(element);
+            }
+        }
+    }
+    uniqAsync$3.uniqAsync = uniqAsync$2;
+
+    var uniqByAsync$3 = {};
+
+    uniqByAsync$3.uniqByAsync = void 0;
+    const types_1$s = es2018$7;
+    function uniqByAsync$2(iterable, fn) {
+        if ((0, types_1$s.isAsyncIterable)(iterable)) {
+            return uniqByAsyncIterable(iterable);
+        }
+        else {
+            return uniqByIterable(iterable);
+        }
+        async function* uniqByAsyncIterable(iterable) {
+            const bucket = new Set();
+            let index = 0;
+            for await (const element of iterable) {
+                const result = await fn(element, index);
+                if (!bucket.has(result)) {
+                    yield element;
+                    bucket.add(result);
+                }
+                index++;
+            }
+        }
+        async function* uniqByIterable(iterable) {
+            const bucket = new Set();
+            let index = 0;
+            for (const element of iterable) {
+                const result = await fn(element, index);
+                if (!bucket.has(result)) {
+                    yield element;
+                    bucket.add(result);
+                }
+                index++;
+            }
+        }
+    }
+    uniqByAsync$3.uniqByAsync = uniqByAsync$2;
+
+    var uniqBy$3 = {};
+
+    uniqBy$3.uniqBy = void 0;
+    function* uniqBy$2(iterable, fn) {
+        const bucket = new Set();
+        let index = 0;
+        for (const element of iterable) {
+            const result = fn(element, index);
+            if (!bucket.has(result)) {
+                yield element;
+                bucket.add(result);
+            }
+            index++;
+        }
+    }
+    uniqBy$3.uniqBy = uniqBy$2;
+
+    var uniq$3 = {};
+
+    uniq$3.uniq = void 0;
+    function* uniq$2(iterable) {
+        const bucket = new Set();
+        for (const element of iterable) {
+            if (!bucket.has(element)) {
+                yield element;
+                bucket.add(element);
+            }
+        }
+    }
+    uniq$3.uniq = uniq$2;
+
+    var zipAsync$3 = {};
+
+    zipAsync$3.zipAsync = void 0;
+    const types_1$r = es2018$7;
+    var Kind$1;
+    (function (Kind) {
+        Kind[Kind["Sync"] = 0] = "Sync";
+        Kind[Kind["Async"] = 1] = "Async";
+    })(Kind$1 || (Kind$1 = {}));
+    function zipAsync$2(iterable, ...otherIterables) {
+        return zipWithSize$3(iterable, ...otherIterables);
+    }
+    zipAsync$3.zipAsync = zipAsync$2;
+    async function* zipWithSize$3(...iterables) {
+        var _a, _b, _c, _d;
+        const length = iterables.length;
+        const iterators = iterables.map(iterable => {
+            if ((0, types_1$r.isAsyncIterable)(iterable)) {
+                return [Kind$1.Async, iterable[Symbol.asyncIterator]()];
+            }
+            else {
+                return [Kind$1.Sync, iterable[Symbol.iterator]()];
+            }
+        });
+        const dones = iterators.map(() => false);
+        try {
+            while (true) {
+                const result = new Array(length);
+                for (let i = 0; i < length; i++) {
+                    const [kind, iterator] = iterators[i];
+                    let temp;
+                    if (kind === Kind$1.Async) {
+                        temp = await iterator.next();
+                    }
+                    else {
+                        temp = iterator.next();
+                    }
+                    if (temp.done) {
+                        dones[i] = true;
+                        return;
+                    }
+                    result[i] = temp.value;
+                }
+                yield result;
+            }
+        }
+        finally {
+            const undoneIterators = iterators.filter((_, i) => !dones[i]);
+            for (const [kind, iterator] of undoneIterators) {
+                if (kind === Kind$1.Async) {
+                    await ((_b = (_a = iterator).return) === null || _b === void 0 ? void 0 : _b.call(_a));
+                }
+                else {
+                    (_d = (_c = iterator).return) === null || _d === void 0 ? void 0 : _d.call(_c);
+                }
+            }
+        }
+    }
+
+    var zip$3 = {};
+
+    zip$3.zip = void 0;
+    function zip$2(iterable, ...otherIterables) {
+        return zipWithSize$2(iterable, ...otherIterables);
+    }
+    zip$3.zip = zip$2;
+    function* zipWithSize$2(...iterables) {
+        const length = iterables.length;
+        const iterators = iterables.map(iterable => iterable[Symbol.iterator]());
+        const dones = iterators.map(() => false);
+        try {
+            while (true) {
+                const result = new Array(length);
+                for (let i = 0; i < length; i++) {
+                    const { value, done } = iterators[i].next();
+                    if (done) {
+                        dones[i] = true;
+                        return;
+                    }
+                    result[i] = value;
+                }
+                yield result;
+            }
+        }
+        finally {
+            const undoneIterators = iterators.filter((_, i) => !dones[i]);
+            undoneIterators.forEach(x => { var _a; return (_a = x.return) === null || _a === void 0 ? void 0 : _a.call(x); });
+        }
+    }
+
+    (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(chunkAsync$3, exports);
+    __exportStar(chunkByAsync$3, exports);
+    __exportStar(chunkBy$3, exports);
+    __exportStar(chunk$3, exports);
+    __exportStar(concatAsync$3, exports);
+    __exportStar(concat$3, exports);
+    __exportStar(dropAsync$3, exports);
+    __exportStar(dropRightAsync$3, exports);
+    __exportStar(dropRight$3, exports);
+    __exportStar(dropUntilAsync$3, exports);
+    __exportStar(dropUntil$3, exports);
+    __exportStar(drop$3, exports);
+    __exportStar(filterAsync$3, exports);
+    __exportStar(filter$3, exports);
+    __exportStar(flattenAsync$3, exports);
+    __exportStar(flattenByAsync$3, exports);
+    __exportStar(flattenBy$3, exports);
+    __exportStar(flattenDeepAsync$3, exports);
+    __exportStar(flattenDeep$3, exports);
+    __exportStar(flatten$3, exports);
+    __exportStar(mapAsync$3, exports);
+    __exportStar(map$3, exports);
+    __exportStar(repeatAsync$3, exports);
+    __exportStar(repeat$3, exports);
+    __exportStar(sliceAsync$3, exports);
+    __exportStar(slice$3, exports);
+    __exportStar(splitAsync$3, exports);
+    __exportStar(splitByAsync$3, exports);
+    __exportStar(splitBy$3, exports);
+    __exportStar(split$3, exports);
+    __exportStar(takeAsync$3, exports);
+    __exportStar(takeRightAsync$3, exports);
+    __exportStar(takeRight$3, exports);
+    __exportStar(takeUntilAsync$3, exports);
+    __exportStar(takeUntil$3, exports);
+    __exportStar(take$3, exports);
+    __exportStar(tapAsync$3, exports);
+    __exportStar(tap$3, exports);
+    __exportStar(toAsyncIterable$3, exports);
+    __exportStar(transformAsync$3, exports);
+    __exportStar(transform$3, exports);
+    __exportStar(uniqAsync$3, exports);
+    __exportStar(uniqByAsync$3, exports);
+    __exportStar(uniqBy$3, exports);
+    __exportStar(uniq$3, exports);
+    __exportStar(zipAsync$3, exports);
+    __exportStar(zip$3, exports);
+
+    }(middleware$1));
+
+    var output$1 = {};
+
+    var consume$3 = {};
+
+    consume$3.consume = void 0;
+    function consume$2(iterable, consumer) {
+        return consumer(iterable);
+    }
+    consume$3.consume = consume$2;
+
+    var eachAsync$3 = {};
+
+    eachAsync$3.eachAsync = void 0;
+    const types_1$q = es2018$7;
+    function eachAsync$2(iterable, fn) {
+        if ((0, types_1$q.isAsyncIterable)(iterable)) {
+            return eachAsyncIterable(iterable);
+        }
+        else {
+            return eachIterable(iterable);
+        }
+        async function eachAsyncIterable(iterable) {
+            let index = 0;
+            for await (const element of iterable) {
+                await fn(element, index);
+                index++;
+            }
+        }
+        async function eachIterable(iterable) {
+            let index = 0;
+            for (const element of iterable) {
+                await fn(element, index);
+                index++;
+            }
+        }
+    }
+    eachAsync$3.eachAsync = eachAsync$2;
+
+    var each$3 = {};
+
+    each$3.each = void 0;
+    function each$2(iterable, fn) {
+        let index = 0;
+        for (const element of iterable) {
+            fn(element, index);
+            index++;
+        }
+    }
+    each$3.each = each$2;
+
+    var everyAsync$3 = {};
+
+    everyAsync$3.everyAsync = void 0;
+    const types_1$p = es2018$7;
+    function everyAsync$2(iterable, predicate) {
+        if ((0, types_1$p.isAsyncIterable)(iterable)) {
+            return everyAsyncIterable(iterable);
+        }
+        else {
+            return everyIterable(iterable);
+        }
+        async function everyIterable(iterable) {
+            let index = 0;
+            for (const element of iterable) {
+                if (!await predicate(element, index))
+                    return false;
+                index++;
+            }
+            return true;
+        }
+        async function everyAsyncIterable(iterable) {
+            let index = 0;
+            for await (const element of iterable) {
+                if (!await predicate(element, index))
+                    return false;
+                index++;
+            }
+            return true;
+        }
+    }
+    everyAsync$3.everyAsync = everyAsync$2;
+
+    var every$3 = {};
+
+    every$3.every = void 0;
+    function every$2(iterable, predicate) {
+        let index = 0;
+        for (const element of iterable) {
+            if (!predicate(element, index))
+                return false;
+            index++;
+        }
+        return true;
+    }
+    every$3.every = every$2;
+
+    var findAsync$3 = {};
+
+    findAsync$3.findAsync = void 0;
+    const types_1$o = es2018$7;
+    function findAsync$2(iterable, predicate) {
+        if ((0, types_1$o.isAsyncIterable)(iterable)) {
+            return findAsyncIterable(iterable);
+        }
+        else {
+            return findIterable(iterable);
+        }
+        async function findIterable(iterable) {
+            let index = 0;
+            for (const element of iterable) {
+                if (await predicate(element, index))
+                    return element;
+                index++;
+            }
+            return undefined;
+        }
+        async function findAsyncIterable(iterable) {
+            let index = 0;
+            for await (const element of iterable) {
+                if (await predicate(element, index))
+                    return element;
+                index++;
+            }
+            return undefined;
+        }
+    }
+    findAsync$3.findAsync = findAsync$2;
+
+    var find$3 = {};
+
+    find$3.find = void 0;
+    function find$2(iterable, predicate) {
+        let index = 0;
+        for (const element of iterable) {
+            if (predicate(element, index))
+                return element;
+            index++;
+        }
+        return undefined;
+    }
+    find$3.find = find$2;
+
+    var firstAsync$3 = {};
+
+    firstAsync$3.firstAsync = void 0;
+    async function firstAsync$2(iterable) {
+        for await (const element of iterable) {
+            return element;
+        }
+        return undefined;
+    }
+    firstAsync$3.firstAsync = firstAsync$2;
+
+    var first$3 = {};
+
+    first$3.first = void 0;
+    function first$2(iterable) {
+        for (const element of iterable) {
+            return element;
+        }
+        return undefined;
+    }
+    first$3.first = first$2;
+
+    var includesAsync$3 = {};
+
+    includesAsync$3.includesAsync = void 0;
+    async function includesAsync$2(iterable, value) {
+        for await (const element of iterable) {
+            if (element === value)
+                return true;
+        }
+        return false;
+    }
+    includesAsync$3.includesAsync = includesAsync$2;
+
+    var includes$3 = {};
+
+    includes$3.includes = void 0;
+    function includes$2(iterable, value) {
+        for (const element of iterable) {
+            if (element === value)
+                return true;
+        }
+        return false;
+    }
+    includes$3.includes = includes$2;
+
+    var matchAsync$3 = {};
+
+    matchAsync$3.matchAsync = void 0;
+    async function matchAsync$2(iterable, sequence) {
+        const sequenceLength = sequence.length;
+        let matchCount = 0;
+        for await (const element of iterable) {
+            if (element === sequence[matchCount])
+                matchCount++;
+            if (matchCount === sequenceLength)
+                return true;
+        }
+        return false;
+    }
+    matchAsync$3.matchAsync = matchAsync$2;
+
+    var match$3 = {};
+
+    match$3.match = void 0;
+    function match$2(iterable, sequence) {
+        const sequenceLength = sequence.length;
+        let matchCount = 0;
+        for (const element of iterable) {
+            if (element === sequence[matchCount])
+                matchCount++;
+            if (matchCount === sequenceLength)
+                return true;
+        }
+        return false;
+    }
+    match$3.match = match$2;
+
+    var reduceAsync$3 = {};
+
+    reduceAsync$3.reduceAsync = void 0;
+    const types_1$n = es2018$7;
+    function reduceAsync$2(iterable, fn, initialValue) {
+        if ((0, types_1$n.isUndefined)(initialValue)) {
+            return reduceAsyncWithoutInitialValue$1(iterable, fn);
+        }
+        else {
+            return reduceAsyncWithInitialValue$1(iterable, fn, initialValue);
+        }
+    }
+    reduceAsync$3.reduceAsync = reduceAsync$2;
+    function reduceAsyncWithInitialValue$1(iterable, fn, initialValue) {
+        if ((0, types_1$n.isAsyncIterable)(iterable)) {
+            return reduceAsyncIterable(iterable);
+        }
+        else {
+            return reduceIterable(iterable);
+        }
+        async function reduceIterable(iterable) {
+            let result = initialValue, index = 0;
+            for (const currentValue of iterable) {
+                result = await fn(result, currentValue, index++);
+            }
+            return result;
+        }
+        async function reduceAsyncIterable(iterable) {
+            let result = initialValue, index = 0;
+            for await (const currentValue of iterable) {
+                result = await fn(result, currentValue, index++);
+            }
+            return result;
+        }
+    }
+    function reduceAsyncWithoutInitialValue$1(iterable, fn) {
+        if ((0, types_1$n.isAsyncIterable)(iterable)) {
+            return reduceAsyncIterable(iterable);
+        }
+        else {
+            return reduceIterable(iterable);
+        }
+        async function reduceAsyncIterable(iterable) {
+            var _a;
+            const iterator = iterable[Symbol.asyncIterator]();
+            let done;
+            try {
+                let result = await readInitialValue(iterator);
+                let index = 1;
+                let value;
+                while ({ value, done } = await iterator.next(), !done) {
+                    result = await fn(result, value, index++);
+                }
+                return result;
+            }
+            finally {
+                if (!done)
+                    await ((_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator));
+            }
+            async function readInitialValue(iterator) {
+                const result = await iterator.next();
+                if (result.done) {
+                    done = true;
+                    throw new Error('Reduce of empty iterable with no initial value');
+                }
+                return result.value;
+            }
+        }
+        async function reduceIterable(iterable) {
+            var _a;
+            const iterator = iterable[Symbol.iterator]();
+            let done;
+            try {
+                let result = readInitialValue(iterator);
+                let index = 1;
+                let value;
+                while ({ value, done } = iterator.next(), !done) {
+                    result = await fn(result, value, index++);
+                }
+                return result;
+            }
+            finally {
+                if (!done)
+                    (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
+            }
+            function readInitialValue(iterator) {
+                const result = iterator.next();
+                if (result.done) {
+                    done = true;
+                    throw new Error('Reduce of empty iterable with no initial value');
+                }
+                return result.value;
+            }
+        }
+    }
+
+    var reduce$3 = {};
+
+    reduce$3.reduce = void 0;
+    const types_1$m = es2018$7;
+    function reduce$2(iterable, fn, initialValue) {
+        if ((0, types_1$m.isUndefined)(initialValue)) {
+            return reduceWithoutInitialValue$1(iterable, fn);
+        }
+        else {
+            return reduceWithInitialValue$1(iterable, fn, initialValue);
+        }
+    }
+    reduce$3.reduce = reduce$2;
+    function reduceWithInitialValue$1(iterable, fn, initialValue) {
+        let result = initialValue, index = 0;
+        for (const currentValue of iterable) {
+            result = fn(result, currentValue, index++);
+        }
+        return result;
+    }
+    function reduceWithoutInitialValue$1(iterable, fn) {
+        var _a;
+        const iterator = iterable[Symbol.iterator]();
+        let done;
+        try {
+            let result = readInitialValue(iterator);
+            let index = 1;
+            let value;
+            while ({ value, done } = iterator.next(), !done) {
+                result = fn(result, value, index++);
+            }
+            return result;
+        }
+        finally {
+            if (!done)
+                (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
+        }
+        function readInitialValue(iterator) {
+            const result = iterator.next();
+            if (result.done) {
+                done = true;
+                throw new Error('Reduce of empty iterable with no initial value');
+            }
+            return result.value;
+        }
+    }
+
+    var someAsync$3 = {};
+
+    someAsync$3.someAsync = void 0;
+    const types_1$l = es2018$7;
+    function someAsync$2(iterable, predicate) {
+        if ((0, types_1$l.isAsyncIterable)(iterable)) {
+            return someAsyncIterable(iterable);
+        }
+        else {
+            return someIterable(iterable);
+        }
+        async function someIterable(iterable) {
+            let index = 0;
+            for (const element of iterable) {
+                if (await predicate(element, index))
+                    return true;
+                index++;
+            }
+            return false;
+        }
+        async function someAsyncIterable(iterable) {
+            let index = 0;
+            for await (const element of iterable) {
+                if (await predicate(element, index))
+                    return true;
+                index++;
+            }
+            return false;
+        }
+    }
+    someAsync$3.someAsync = someAsync$2;
+
+    var some$3 = {};
+
+    some$3.some = void 0;
+    function some$2(iterable, predicate) {
+        let index = 0;
+        for (const element of iterable) {
+            if (predicate(element, index))
+                return true;
+            index++;
+        }
+        return false;
+    }
+    some$3.some = some$2;
+
+    var lastAsync$3 = {};
+
+    lastAsync$3.lastAsync = void 0;
+    async function lastAsync$2(iterable) {
+        var _a;
+        const iterator = iterable[Symbol.asyncIterator]();
+        let done;
+        try {
+            let value;
+            let result;
+            while ({ value, done } = await iterator.next(), !done) {
+                result = value;
+            }
+            return result;
+        }
+        finally {
+            if (!done)
+                await ((_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator));
+        }
+    }
+    lastAsync$3.lastAsync = lastAsync$2;
 
-    var customError = {};
+    var last$3 = {};
 
-    customError.CustomError = void 0;
-    class CustomError extends Error {
-        get name() {
-            return this.constructor.name;
+    last$3.last = void 0;
+    function last$2(iterable) {
+        var _a;
+        const iterator = iterable[Symbol.iterator]();
+        let done;
+        try {
+            let value;
+            let result;
+            while ({ value, done } = iterator.next(), !done) {
+                result = value;
+            }
+            return result;
+        }
+        finally {
+            if (!done)
+                (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
         }
     }
-    customError.CustomError = CustomError;
+    last$3.last = last$2;
 
-    var expectedError = {};
+    var toArrayAsync$4 = {};
 
-    expectedError.ExpectedError = void 0;
-    const custom_error_1$1 = customError;
-    class ExpectedError extends custom_error_1$1.CustomError {
+    toArrayAsync$4.toArrayAsync = void 0;
+    const consume_1$7 = consume$3;
+    function toArrayAsync$3(iterable) {
+        return (0, consume_1$7.consume)(iterable, async (iterable) => {
+            const result = [];
+            for await (const element of iterable) {
+                result.push(element);
+            }
+            return result;
+        });
     }
-    expectedError.ExpectedError = ExpectedError;
+    toArrayAsync$4.toArrayAsync = toArrayAsync$3;
+
+    var toArray$3 = {};
+
+    toArray$3.toArray = void 0;
+    const consume_1$6 = consume$3;
+    function toArray$2(iterable) {
+        return (0, consume_1$6.consume)(iterable, iterable => Array.from(iterable));
+    }
+    toArray$3.toArray = toArray$2;
+
+    var toSetAsync$3 = {};
+
+    toSetAsync$3.toSetAsync = void 0;
+    const consume_1$5 = consume$3;
+    function toSetAsync$2(iterable) {
+        return (0, consume_1$5.consume)(iterable, async (iterable) => {
+            const result = new Set();
+            for await (const element of iterable) {
+                result.add(element);
+            }
+            return result;
+        });
+    }
+    toSetAsync$3.toSetAsync = toSetAsync$2;
+
+    var toSet$3 = {};
+
+    toSet$3.toSet = void 0;
+    const consume_1$4 = consume$3;
+    function toSet$2(iterable) {
+        return (0, consume_1$4.consume)(iterable, iterable => new Set(iterable));
+    }
+    toSet$3.toSet = toSet$2;
+
+    (function (exports) {
+    var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    }) : (function(o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        o[k2] = m[k];
+    }));
+    var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
+        for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+    };__exportStar(consume$3, exports);
+    __exportStar(eachAsync$3, exports);
+    __exportStar(each$3, exports);
+    __exportStar(everyAsync$3, exports);
+    __exportStar(every$3, exports);
+    __exportStar(findAsync$3, exports);
+    __exportStar(find$3, exports);
+    __exportStar(firstAsync$3, exports);
+    __exportStar(first$3, exports);
+    __exportStar(includesAsync$3, exports);
+    __exportStar(includes$3, exports);
+    __exportStar(matchAsync$3, exports);
+    __exportStar(match$3, exports);
+    __exportStar(reduceAsync$3, exports);
+    __exportStar(reduce$3, exports);
+    __exportStar(someAsync$3, exports);
+    __exportStar(some$3, exports);
+    __exportStar(lastAsync$3, exports);
+    __exportStar(last$3, exports);
+    __exportStar(toArrayAsync$4, exports);
+    __exportStar(toArray$3, exports);
+    __exportStar(toSetAsync$3, exports);
+    __exportStar(toSet$3, exports);
+
+    }(output$1));
+
+    (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(middleware$1, exports);
+    __exportStar(output$1, exports);
+
+    }(es2018$a));
+
+    var getErrorNames$1 = {};
+
+    var traverseErrorPrototypeChain$1 = {};
+
+    traverseErrorPrototypeChain$1.traverseErrorPrototypeChain = void 0;
+    function* traverseErrorPrototypeChain(err) {
+        let current = err;
+        while ((current = Object.getPrototypeOf(current))) {
+            yield current;
+            if (current === Error.prototype)
+                break;
+        }
+    }
+    traverseErrorPrototypeChain$1.traverseErrorPrototypeChain = traverseErrorPrototypeChain;
+
+    getErrorNames$1.getErrorNames = void 0;
+    const types_1$k = es2018$7;
+    const traverse_error_prototype_chain_1 = traverseErrorPrototypeChain$1;
+    function* getErrorNames(err) {
+        var _a;
+        if ((0, types_1$k.isError)(err)) {
+            for (const prototype of (0, traverse_error_prototype_chain_1.traverseErrorPrototypeChain)(err)) {
+                if ((_a = prototype.constructor) === null || _a === void 0 ? void 0 : _a.name) {
+                    yield prototype.constructor.name;
+                }
+            }
+        }
+        else {
+            yield err.name;
+            yield* err.ancestors;
+        }
+    }
+    getErrorNames$1.getErrorNames = getErrorNames;
+
+    var serializableError = {};
+
+    serializableError.isSerializableError = void 0;
+    const types_1$j = es2018$7;
+    function isSerializableError(val) {
+        return (0, types_1$j.isObject)(val)
+            && (0, types_1$j.isString)(val.name)
+            && (0, types_1$j.isString)(val.message)
+            && ((0, types_1$j.isString)(val.stack) || (0, types_1$j.isNull)(val.stack))
+            && ((0, types_1$j.isArray)(val.ancestors) && val.ancestors.every(types_1$j.isString));
+    }
+    serializableError.isSerializableError = isSerializableError;
+
+    customError$1.CustomError = void 0;
+    const iterable_operator_1$1 = es2018$a;
+    const get_error_names_1$1 = getErrorNames$1;
+    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;
+            }
+        }
+    }
+    customError$1.CustomError = CustomError;
 
     var assertionError = {};
 
     assertionError.AssertionError = void 0;
-    const custom_error_1 = customError;
+    const custom_error_1 = customError$1;
     class AssertionError extends custom_error_1.CustomError {
     }
     assertionError.AssertionError = AssertionError;
@@ -270,25 +2698,69 @@
     var normalize$1 = {};
 
     normalize$1.normalize = void 0;
+    const get_error_names_1 = getErrorNames$1;
+    const iterable_operator_1 = es2018$a;
     function normalize(err) {
         var _a;
+        const [name, ...ancestors] = (0, iterable_operator_1.toArray)((0, get_error_names_1.getErrorNames)(err));
         return {
-            name: err.name,
+            name,
+            ancestors,
             message: err.message,
             stack: (_a = err.stack) !== null && _a !== void 0 ? _a : null
         };
     }
     normalize$1.normalize = normalize;
 
-    var refute$1 = {};
+    var hydrate$1 = {};
 
-    refute$1.refute = void 0;
-    const expected_error_1 = expectedError;
-    function refute(condition, message) {
-        if (condition)
-            throw new expected_error_1.ExpectedError(message);
+    var es2018$6 = {};
+
+    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$6));
+
+    hydrate$1.hydrate = void 0;
+    const pass_1 = es2018$6;
+    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;
     }
-    refute$1.refute = refute;
 
     var assert$1 = {};
 
@@ -310,14 +2782,16 @@
     }));
     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, exports);
-    __exportStar(expectedError, exports);
+    };__exportStar(customError$1, exports);
     __exportStar(assertionError, exports);
+    __exportStar(serializableError, exports);
     __exportStar(normalize$1, exports);
-    __exportStar(refute$1, exports);
+    __exportStar(hydrate$1, exports);
     __exportStar(assert$1, exports);
+    __exportStar(getErrorNames$1, exports);
+    __exportStar(traverseErrorPrototypeChain$1, exports);
 
-    }(es2018$6));
+    }(es2018$b));
 
     var es2018$5 = {};
 
@@ -351,7 +2825,7 @@
 
     chunkAsync$1.chunkAsync = void 0;
     const go_1$f = es2018$4;
-    const errors_1$f = es2018$6;
+    const errors_1$f = es2018$b;
     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');
@@ -421,11 +2895,11 @@
     _undefined$1.isntUndefined = isntUndefined$1;
 
     asyncIterable$1.isntAsyncIterable = asyncIterable$1.isAsyncIterable = void 0;
-    const null_1$3 = _null$1;
-    const undefined_1$5 = _undefined$1;
+    const null_1$4 = _null$1;
+    const undefined_1$4 = _undefined$1;
     function isAsyncIterable$1(val) {
-        return (0, null_1$3.isntNull)(val)
-            && (0, undefined_1$5.isntUndefined)(val)
+        return (0, null_1$4.isntNull)(val)
+            && (0, undefined_1$4.isntUndefined)(val)
             && typeof val[Symbol.asyncIterator] === 'function';
     }
     asyncIterable$1.isAsyncIterable = isAsyncIterable$1;
@@ -543,11 +3017,11 @@
     var iterable$1 = {};
 
     iterable$1.isntIterable = iterable$1.isIterable = void 0;
-    const null_1$2 = _null$1;
-    const undefined_1$4 = _undefined$1;
+    const null_1$3 = _null$1;
+    const undefined_1$3 = _undefined$1;
     function isIterable$1(val) {
-        return (0, null_1$2.isntNull)(val)
-            && (0, undefined_1$4.isntUndefined)(val)
+        return (0, null_1$3.isntNull)(val)
+            && (0, undefined_1$3.isntUndefined)(val)
             && typeof val[Symbol.iterator] === 'function';
     }
     iterable$1.isIterable = isIterable$1;
@@ -556,23 +3030,31 @@
     }
     iterable$1.isntIterable = isntIterable$1;
 
-    var jsonRpc$1 = {};
+    var jsonRpc = {};
 
     var object$1 = {};
 
-    object$1.isntEmptyObject = object$1.isEmptyObject = object$1.isRecord = object$1.isntObject = object$1.isObject = void 0;
+    var __importDefault$1 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+        return (mod && mod.__esModule) ? mod : { "default": mod };
+    };object$1.isntEmptyObject = object$1.isEmptyObject = object$1.isntPlainObject = object$1.isPlainObject = object$1.isntObject = object$1.isObject = void 0;
+    const lodash_isplainobject_1$1 = __importDefault$1(lodash_isplainobject);
     function isObject$1(val) {
-        return val !== null && typeof val === 'object';
+        return val !== null
+            && typeof val === 'object';
     }
     object$1.isObject = isObject$1;
     function isntObject$1(val) {
         return !isObject$1(val);
     }
     object$1.isntObject = isntObject$1;
-    function isRecord(val) {
-        return isObject$1(val);
+    function isPlainObject$1(val) {
+        return (0, lodash_isplainobject_1$1.default)(val);
     }
-    object$1.isRecord = isRecord;
+    object$1.isPlainObject = isPlainObject$1;
+    function isntPlainObject$1(val) {
+        return !isPlainObject$1(val);
+    }
+    object$1.isntPlainObject = isntPlainObject$1;
     function isEmptyObject$1(val) {
         return Object.keys(val).length === 0;
     }
@@ -594,69 +3076,69 @@
     }
     number$1.isntNumber = isntNumber$1;
 
-    jsonRpc$1.isntJsonRpcError = jsonRpc$1.isJsonRpcError = jsonRpc$1.isntJsonRpcSuccess = jsonRpc$1.isJsonRpcSuccess = jsonRpc$1.isntJsonRpcRequest = jsonRpc$1.isJsonRpcRequest = jsonRpc$1.isntJsonRpcNotification = jsonRpc$1.isJsonRpcNotification = void 0;
+    jsonRpc.isntJsonRpcError = jsonRpc.isJsonRpcError = jsonRpc.isntJsonRpcSuccess = jsonRpc.isJsonRpcSuccess = jsonRpc.isntJsonRpcRequest = jsonRpc.isJsonRpcRequest = jsonRpc.isntJsonRpcNotification = jsonRpc.isJsonRpcNotification = void 0;
     const array_1$1 = array$1;
-    const object_1$1 = object$1;
+    const object_1$2 = object$1;
     const string_1$2 = string$1;
     const number_1$1 = number$1;
-    const undefined_1$3 = _undefined$1;
-    function isJsonRpcId$1(val) {
+    const undefined_1$2 = _undefined$1;
+    function isJsonRpcId(val) {
         return (0, string_1$2.isString)(val) || (0, number_1$1.isNumber)(val);
     }
-    function isJsonRpcParams$1(val) {
-        return (0, array_1$1.isArray)(val) || (0, object_1$1.isObject)(val);
+    function isJsonRpcParams(val) {
+        return (0, array_1$1.isArray)(val) || (0, object_1$2.isObject)(val);
     }
-    function isJsonRpcNotification$1(val) {
-        return (0, object_1$1.isRecord)(val)
+    function isJsonRpcNotification(val) {
+        return (0, object_1$2.isPlainObject)(val)
             && (0, string_1$2.isString)(val.jsonrpc)
             && (0, string_1$2.isString)(val.method)
-            && (0, undefined_1$3.isUndefined)(val.id)
-            && isJsonRpcParams$1(val.params);
+            && (0, undefined_1$2.isUndefined)(val.id)
+            && isJsonRpcParams(val.params);
     }
-    jsonRpc$1.isJsonRpcNotification = isJsonRpcNotification$1;
-    function isntJsonRpcNotification$1(val) {
-        return !isJsonRpcNotification$1(val);
+    jsonRpc.isJsonRpcNotification = isJsonRpcNotification;
+    function isntJsonRpcNotification(val) {
+        return !isJsonRpcNotification(val);
     }
-    jsonRpc$1.isntJsonRpcNotification = isntJsonRpcNotification$1;
-    function isJsonRpcRequest$1(val) {
-        return (0, object_1$1.isRecord)(val)
+    jsonRpc.isntJsonRpcNotification = isntJsonRpcNotification;
+    function isJsonRpcRequest(val) {
+        return (0, object_1$2.isPlainObject)(val)
             && (0, string_1$2.isString)(val.jsonrpc)
             && (0, string_1$2.isString)(val.method)
-            && isJsonRpcId$1(val.id)
-            && isJsonRpcParams$1(val.params);
+            && isJsonRpcId(val.id)
+            && isJsonRpcParams(val.params);
     }
-    jsonRpc$1.isJsonRpcRequest = isJsonRpcRequest$1;
-    function isntJsonRpcRequest$1(val) {
-        return !isJsonRpcRequest$1(val);
+    jsonRpc.isJsonRpcRequest = isJsonRpcRequest;
+    function isntJsonRpcRequest(val) {
+        return !isJsonRpcRequest(val);
     }
-    jsonRpc$1.isntJsonRpcRequest = isntJsonRpcRequest$1;
-    function isJsonRpcSuccess$1(val) {
-        return (0, object_1$1.isRecord)(val)
+    jsonRpc.isntJsonRpcRequest = isntJsonRpcRequest;
+    function isJsonRpcSuccess(val) {
+        return (0, object_1$2.isPlainObject)(val)
             && (0, string_1$2.isString)(val.jsonrpc)
             && (0, string_1$2.isString)(val.id)
-            && (0, undefined_1$3.isntUndefined)(val.result);
+            && 'result' in val;
     }
-    jsonRpc$1.isJsonRpcSuccess = isJsonRpcSuccess$1;
-    function isntJsonRpcSuccess$1(val) {
-        return !isJsonRpcSuccess$1(val);
+    jsonRpc.isJsonRpcSuccess = isJsonRpcSuccess;
+    function isntJsonRpcSuccess(val) {
+        return !isJsonRpcSuccess(val);
     }
-    jsonRpc$1.isntJsonRpcSuccess = isntJsonRpcSuccess$1;
-    function isJsonRpcError$1(val) {
-        return (0, object_1$1.isRecord)(val)
+    jsonRpc.isntJsonRpcSuccess = isntJsonRpcSuccess;
+    function isJsonRpcError(val) {
+        return (0, object_1$2.isPlainObject)(val)
             && (0, string_1$2.isString)(val.jsonrpc)
-            && isJsonRpcId$1(val.id)
-            && isJsonRpcErrorObject$1(val.error);
+            && isJsonRpcId(val.id)
+            && isJsonRpcErrorObject(val.error);
     }
-    jsonRpc$1.isJsonRpcError = isJsonRpcError$1;
-    function isntJsonRpcError$1(val) {
-        return !isJsonRpcError$1(val);
+    jsonRpc.isJsonRpcError = isJsonRpcError;
+    function isntJsonRpcError(val) {
+        return !isJsonRpcError(val);
     }
-    jsonRpc$1.isntJsonRpcError = isntJsonRpcError$1;
-    function isJsonRpcErrorObject$1(val) {
-        return (0, object_1$1.isRecord)(val)
+    jsonRpc.isntJsonRpcError = isntJsonRpcError;
+    function isJsonRpcErrorObject(val) {
+        return (0, object_1$2.isPlainObject)(val)
             && (0, number_1$1.isNumber)(val.code)
             && (0, string_1$2.isString)(val.message)
-            && ((0, undefined_1$3.isUndefined)(val.data) || (0, object_1$1.isObject)(val.data));
+            && ((0, undefined_1$2.isUndefined)(val.data) || (0, object_1$2.isObject)(val.data));
     }
 
     var json$1 = {};
@@ -712,7 +3194,7 @@
     __exportStar(falsy$1, exports);
     __exportStar(_function$1, exports);
     __exportStar(iterable$1, exports);
-    __exportStar(jsonRpc$1, exports);
+    __exportStar(jsonRpc, exports);
     __exportStar(json$1, exports);
     __exportStar(_null$1, exports);
     __exportStar(number$1, exports);
@@ -786,7 +3268,7 @@
 
     chunk$1.chunk = void 0;
     const go_1$e = es2018$4;
-    const errors_1$e = es2018$6;
+    const errors_1$e = es2018$b;
     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');
@@ -862,7 +3344,7 @@
     dropAsync$1.dropAsync = void 0;
     const go_1$b = es2018$4;
     const utils_1$3 = utils;
-    const errors_1$d = es2018$6;
+    const errors_1$d = es2018$b;
     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');
@@ -897,7 +3379,7 @@
     dropRightAsync$1.dropRightAsync = void 0;
     const go_1$a = es2018$4;
     const utils_1$2 = utils;
-    const errors_1$c = es2018$6;
+    const errors_1$c = es2018$b;
     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');
@@ -925,7 +3407,7 @@
     dropRight$1.dropRight = void 0;
     const go_1$9 = es2018$4;
     const utils_1$1 = utils;
-    const errors_1$b = es2018$6;
+    const errors_1$b = es2018$b;
     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');
@@ -1025,7 +3507,7 @@
     drop$1.drop = void 0;
     const go_1$8 = es2018$4;
     const utils_1 = utils;
-    const errors_1$a = es2018$6;
+    const errors_1$a = es2018$b;
     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');
@@ -1145,7 +3627,7 @@
 
     flattenDeepAsync$1.flattenDeepAsync = void 0;
     const flatten_by_async_1 = flattenByAsync$1;
-    const errors_1$9 = es2018$6;
+    const errors_1$9 = es2018$b;
     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');
@@ -1186,7 +3668,7 @@
 
     flattenDeep$1.flattenDeep = void 0;
     const flatten_by_1 = flattenBy$1;
-    const errors_1$8 = es2018$6;
+    const errors_1$8 = es2018$b;
     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');
@@ -1247,7 +3729,7 @@
 
     repeatAsync$1.repeatAsync = void 0;
     const go_1$7 = es2018$4;
-    const errors_1$7 = es2018$6;
+    const errors_1$7 = es2018$b;
     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');
@@ -1282,7 +3764,7 @@
 
     repeat$1.repeat = void 0;
     const go_1$6 = es2018$4;
-    const errors_1$6 = es2018$6;
+    const errors_1$6 = es2018$b;
     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');
@@ -1317,7 +3799,7 @@
 
     sliceAsync$1.sliceAsync = void 0;
     const go_1$5 = es2018$4;
-    const errors_1$5 = es2018$6;
+    const errors_1$5 = es2018$b;
     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');
@@ -1340,7 +3822,7 @@
 
     slice$1.slice = void 0;
     const go_1$4 = es2018$4;
-    const errors_1$4 = es2018$6;
+    const errors_1$4 = es2018$b;
     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');
@@ -1463,7 +3945,7 @@
 
     takeAsync$1.takeAsync = void 0;
     const go_1$3 = es2018$4;
-    const errors_1$3 = es2018$6;
+    const errors_1$3 = es2018$b;
     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');
@@ -1484,7 +3966,7 @@
 
     takeRightAsync$1.takeRightAsync = void 0;
     const go_1$2 = es2018$4;
-    const errors_1$2 = es2018$6;
+    const errors_1$2 = es2018$b;
     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');
@@ -1514,7 +3996,7 @@
 
     takeRight$1.takeRight = void 0;
     const go_1$1 = es2018$4;
-    const errors_1$1 = es2018$6;
+    const errors_1$1 = es2018$b;
     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');
@@ -1590,7 +4072,7 @@
 
     take$1.take = void 0;
     const go_1 = es2018$4;
-    const errors_1 = es2018$6;
+    const errors_1 = es2018$b;
     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');
@@ -2466,8 +4948,8 @@
         constructor(limit) {
             _LRUMap_limit.set(this, void 0);
             _LRUMap_map.set(this, new Map());
-            es2018$6.assert(Number.isInteger(limit), 'The parameter limit must be an integer');
-            es2018$6.assert(limit > 0, 'The parameter limit must be a positive value');
+            es2018$b.assert(Number.isInteger(limit), 'The parameter limit must be an integer');
+            es2018$b.assert(limit > 0, 'The parameter limit must be a positive value');
             __classPrivateFieldSet(this, _LRUMap_limit, limit, "f");
         }
         get [(_LRUMap_limit = new WeakMap(), _LRUMap_map = new WeakMap(), Symbol.toStringTag)]() {
@@ -2801,8 +5283,8 @@
              * 按过期时间升序排列所有项目的元数据
              */
             this.itemMetadataSortedByExpirationTime = [];
-            es2018$6.assert(Number.isInteger(limit), 'The parameter limit must be an integer');
-            es2018$6.assert(limit > 0, 'The parameter limit must be a positive value');
+            es2018$b.assert(Number.isInteger(limit), 'The parameter limit must be an integer');
+            es2018$b.assert(limit > 0, 'The parameter limit must be a positive value');
             __classPrivateFieldSet(this, _TLRUMap_limit, limit, "f");
         }
         get [(_TLRUMap_limit = new WeakMap(), _TLRUMap_map = new WeakMap(), _TLRUMap_cancelClearTimeout = new WeakMap(), Symbol.toStringTag)]() {
@@ -3012,11 +5494,14 @@
         matches(state) {
             return __classPrivateFieldGet(this, _FiniteStateMachine_state, "f") === state;
         }
+        can(event) {
+            return event in this.schema[this.state];
+        }
         /**
          * @throws {BadEventError}
          */
         send(event) {
-            if (event in this.schema[this.state]) {
+            if (this.can(event)) {
                 __classPrivateFieldSet(this, _FiniteStateMachine_state, this.schema[this.state][event], "f");
             }
             else {
@@ -3025,7 +5510,7 @@
         }
     }
     _FiniteStateMachine_state = new WeakMap();
-    class BadEventError extends es2018$6.CustomError {
+    class BadEventError extends es2018$b.CustomError {
         constructor(state, event) {
             super(`State ${state} cannot react to event ${event}`);
         }
@@ -3069,7 +5554,7 @@
             this.initialTeardown = initialTeardown;
             this.closed = false;
             this._parentage = null;
-            this._teardowns = null;
+            this._finalizers = null;
         }
         Subscription.prototype.unsubscribe = function () {
             var e_1, _a, e_2, _b;
@@ -3098,23 +5583,23 @@
                         _parentage.remove(this);
                     }
                 }
-                var initialTeardown = this.initialTeardown;
-                if (isFunction$1(initialTeardown)) {
+                var initialFinalizer = this.initialTeardown;
+                if (isFunction$1(initialFinalizer)) {
                     try {
-                        initialTeardown();
+                        initialFinalizer();
                     }
                     catch (e) {
                         errors = e instanceof UnsubscriptionError ? e.errors : [e];
                     }
                 }
-                var _teardowns = this._teardowns;
-                if (_teardowns) {
-                    this._teardowns = null;
+                var _finalizers = this._finalizers;
+                if (_finalizers) {
+                    this._finalizers = null;
                     try {
-                        for (var _teardowns_1 = __values(_teardowns), _teardowns_1_1 = _teardowns_1.next(); !_teardowns_1_1.done; _teardowns_1_1 = _teardowns_1.next()) {
-                            var teardown_1 = _teardowns_1_1.value;
+                        for (var _finalizers_1 = __values(_finalizers), _finalizers_1_1 = _finalizers_1.next(); !_finalizers_1_1.done; _finalizers_1_1 = _finalizers_1.next()) {
+                            var finalizer = _finalizers_1_1.value;
                             try {
-                                execTeardown(teardown_1);
+                                execFinalizer(finalizer);
                             }
                             catch (err) {
                                 errors = errors !== null && errors !== void 0 ? errors : [];
@@ -3130,7 +5615,7 @@
                     catch (e_2_1) { e_2 = { error: e_2_1 }; }
                     finally {
                         try {
-                            if (_teardowns_1_1 && !_teardowns_1_1.done && (_b = _teardowns_1.return)) _b.call(_teardowns_1);
+                            if (_finalizers_1_1 && !_finalizers_1_1.done && (_b = _finalizers_1.return)) _b.call(_finalizers_1);
                         }
                         finally { if (e_2) throw e_2.error; }
                     }
@@ -3144,7 +5629,7 @@
             var _a;
             if (teardown && teardown !== this) {
                 if (this.closed) {
-                    execTeardown(teardown);
+                    execFinalizer(teardown);
                 }
                 else {
                     if (teardown instanceof Subscription) {
@@ -3153,7 +5638,7 @@
                         }
                         teardown._addParent(this);
                     }
-                    (this._teardowns = (_a = this._teardowns) !== null && _a !== void 0 ? _a : []).push(teardown);
+                    (this._finalizers = (_a = this._finalizers) !== null && _a !== void 0 ? _a : []).push(teardown);
                 }
             }
         };
@@ -3175,8 +5660,8 @@
             }
         };
         Subscription.prototype.remove = function (teardown) {
-            var _teardowns = this._teardowns;
-            _teardowns && arrRemove(_teardowns, teardown);
+            var _finalizers = this._finalizers;
+            _finalizers && arrRemove(_finalizers, teardown);
             if (teardown instanceof Subscription) {
                 teardown._removeParent(this);
             }
@@ -3193,12 +5678,12 @@
         return (value instanceof Subscription ||
             (value && 'closed' in value && isFunction$1(value.remove) && isFunction$1(value.add) && isFunction$1(value.unsubscribe)));
     }
-    function execTeardown(teardown) {
-        if (isFunction$1(teardown)) {
-            teardown();
+    function execFinalizer(finalizer) {
+        if (isFunction$1(finalizer)) {
+            finalizer();
         }
         else {
-            teardown.unsubscribe();
+            finalizer.unsubscribe();
         }
     }
 
@@ -3211,13 +5696,16 @@
     };
 
     var timeoutProvider = {
-        setTimeout: function () {
+        setTimeout: function (handler, timeout) {
             var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
+            for (var _i = 2; _i < arguments.length; _i++) {
+                args[_i - 2] = arguments[_i];
             }
             var delegate = timeoutProvider.delegate;
-            return ((delegate === null || delegate === void 0 ? void 0 : delegate.setTimeout) || setTimeout).apply(void 0, __spreadArray([], __read(args)));
+            if (delegate === null || delegate === void 0 ? void 0 : delegate.setTimeout) {
+                return delegate.setTimeout.apply(delegate, __spreadArray([handler, timeout], __read(args)));
+            }
+            return setTimeout.apply(void 0, __spreadArray([handler, timeout], __read(args)));
         },
         clearTimeout: function (handle) {
             var delegate = timeoutProvider.delegate;
@@ -3324,52 +5812,88 @@
         };
         return Subscriber;
     }(Subscription));
+    var _bind = Function.prototype.bind;
+    function bind(fn, thisArg) {
+        return _bind.call(fn, thisArg);
+    }
+    var ConsumerObserver = (function () {
+        function ConsumerObserver(partialObserver) {
+            this.partialObserver = partialObserver;
+        }
+        ConsumerObserver.prototype.next = function (value) {
+            var partialObserver = this.partialObserver;
+            if (partialObserver.next) {
+                try {
+                    partialObserver.next(value);
+                }
+                catch (error) {
+                    handleUnhandledError(error);
+                }
+            }
+        };
+        ConsumerObserver.prototype.error = function (err) {
+            var partialObserver = this.partialObserver;
+            if (partialObserver.error) {
+                try {
+                    partialObserver.error(err);
+                }
+                catch (error) {
+                    handleUnhandledError(error);
+                }
+            }
+            else {
+                handleUnhandledError(err);
+            }
+        };
+        ConsumerObserver.prototype.complete = function () {
+            var partialObserver = this.partialObserver;
+            if (partialObserver.complete) {
+                try {
+                    partialObserver.complete();
+                }
+                catch (error) {
+                    handleUnhandledError(error);
+                }
+            }
+        };
+        return ConsumerObserver;
+    }());
     var SafeSubscriber = (function (_super) {
         __extends(SafeSubscriber, _super);
         function SafeSubscriber(observerOrNext, error, complete) {
             var _this = _super.call(this) || this;
-            var next;
-            if (isFunction$1(observerOrNext)) {
-                next = observerOrNext;
+            var partialObserver;
+            if (isFunction$1(observerOrNext) || !observerOrNext) {
+                partialObserver = {
+                    next: observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : undefined,
+                    error: error !== null && error !== void 0 ? error : undefined,
+                    complete: complete !== null && complete !== void 0 ? complete : undefined,
+                };
             }
-            else if (observerOrNext) {
-                (next = observerOrNext.next, error = observerOrNext.error, complete = observerOrNext.complete);
+            else {
                 var context_1;
                 if (_this && config.useDeprecatedNextContext) {
                     context_1 = Object.create(observerOrNext);
                     context_1.unsubscribe = function () { return _this.unsubscribe(); };
+                    partialObserver = {
+                        next: observerOrNext.next && bind(observerOrNext.next, context_1),
+                        error: observerOrNext.error && bind(observerOrNext.error, context_1),
+                        complete: observerOrNext.complete && bind(observerOrNext.complete, context_1),
+                    };
                 }
                 else {
-                    context_1 = observerOrNext;
+                    partialObserver = observerOrNext;
                 }
-                next = next === null || next === void 0 ? void 0 : next.bind(context_1);
-                error = error === null || error === void 0 ? void 0 : error.bind(context_1);
-                complete = complete === null || complete === void 0 ? void 0 : complete.bind(context_1);
-            }
-            _this.destination = {
-                next: next ? wrapForErrorHandling(next) : noop,
-                error: wrapForErrorHandling(error !== null && error !== void 0 ? error : defaultErrorHandler),
-                complete: complete ? wrapForErrorHandling(complete) : noop,
-            };
+            }
+            _this.destination = new ConsumerObserver(partialObserver);
             return _this;
         }
         return SafeSubscriber;
     }(Subscriber));
-    function wrapForErrorHandling(handler, instance) {
-        return function () {
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            try {
-                handler.apply(void 0, __spreadArray([], __read(args)));
-            }
-            catch (err) {
-                {
-                    reportUnhandledError(err);
-                }
-            }
-        };
+    function handleUnhandledError(error) {
+        {
+            reportUnhandledError(error);
+        }
     }
     function defaultErrorHandler(err) {
         throw err;
@@ -3506,6 +6030,7 @@
         function Subject() {
             var _this = _super.call(this) || this;
             _this.closed = false;
+            _this.currentObservers = null;
             _this.observers = [];
             _this.isStopped = false;
             _this.hasError = false;
@@ -3528,17 +6053,19 @@
                 var e_1, _a;
                 _this._throwIfClosed();
                 if (!_this.isStopped) {
-                    var copy = _this.observers.slice();
+                    if (!_this.currentObservers) {
+                        _this.currentObservers = Array.from(_this.observers);
+                    }
                     try {
-                        for (var copy_1 = __values(copy), copy_1_1 = copy_1.next(); !copy_1_1.done; copy_1_1 = copy_1.next()) {
-                            var observer = copy_1_1.value;
+                        for (var _b = __values(_this.currentObservers), _c = _b.next(); !_c.done; _c = _b.next()) {
+                            var observer = _c.value;
                             observer.next(value);
                         }
                     }
                     catch (e_1_1) { e_1 = { error: e_1_1 }; }
                     finally {
                         try {
-                            if (copy_1_1 && !copy_1_1.done && (_a = copy_1.return)) _a.call(copy_1);
+                            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                         }
                         finally { if (e_1) throw e_1.error; }
                     }
@@ -3574,7 +6101,7 @@
         };
         Subject.prototype.unsubscribe = function () {
             this.isStopped = this.closed = true;
-            this.observers = null;
+            this.observers = this.currentObservers = null;
         };
         Object.defineProperty(Subject.prototype, "observed", {
             get: function () {
@@ -3594,10 +6121,17 @@
             return this._innerSubscribe(subscriber);
         };
         Subject.prototype._innerSubscribe = function (subscriber) {
+            var _this = this;
             var _a = this, hasError = _a.hasError, isStopped = _a.isStopped, observers = _a.observers;
-            return hasError || isStopped
-                ? EMPTY_SUBSCRIPTION
-                : (observers.push(subscriber), new Subscription(function () { return arrRemove(observers, subscriber); }));
+            if (hasError || isStopped) {
+                return EMPTY_SUBSCRIPTION;
+            }
+            this.currentObservers = null;
+            observers.push(subscriber);
+            return new Subscription(function () {
+                _this.currentObservers = null;
+                arrRemove(observers, subscriber);
+            });
         };
         Subject.prototype._checkFinalizedStatuses = function (subscriber) {
             var _a = this, hasError = _a.hasError, thrownError = _a.thrownError, isStopped = _a.isStopped;
@@ -3687,19 +6221,32 @@
     function isUndefined(val) {
         return val === undefined;
     }
-    _undefined.isUndefined = isUndefined;
-    function isntUndefined(val) {
-        return !isUndefined(val);
+    _undefined.isUndefined = isUndefined;
+    function isntUndefined(val) {
+        return !isUndefined(val);
+    }
+    _undefined.isntUndefined = isntUndefined;
+
+    var _function = {};
+
+    _function.isntFunction = _function.isFunction = void 0;
+    function isFunction(val) {
+        return typeof val === 'function';
+    }
+    _function.isFunction = isFunction;
+    function isntFunction(val) {
+        return !isFunction(val);
     }
-    _undefined.isntUndefined = isntUndefined;
+    _function.isntFunction = isntFunction;
 
     asyncIterable.isntAsyncIterable = asyncIterable.isAsyncIterable = void 0;
-    const null_1$1 = _null;
-    const undefined_1$2 = _undefined;
+    const null_1$2 = _null;
+    const undefined_1$1 = _undefined;
+    const function_1$2 = _function;
     function isAsyncIterable(val) {
-        return (0, null_1$1.isntNull)(val)
-            && (0, undefined_1$2.isntUndefined)(val)
-            && typeof val[Symbol.asyncIterator] === 'function';
+        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) {
@@ -3801,27 +6348,16 @@
     }
     falsy.isntFalsy = isntFalsy;
 
-    var _function = {};
-
-    _function.isntFunction = _function.isFunction = void 0;
-    function isFunction(val) {
-        return typeof val === 'function';
-    }
-    _function.isFunction = isFunction;
-    function isntFunction(val) {
-        return !isFunction(val);
-    }
-    _function.isntFunction = isntFunction;
-
     var iterable = {};
 
     iterable.isntIterable = iterable.isIterable = void 0;
-    const null_1 = _null;
-    const undefined_1$1 = _undefined;
+    const null_1$1 = _null;
+    const undefined_1 = _undefined;
+    const function_1$1 = _function;
     function isIterable(val) {
-        return (0, null_1.isntNull)(val)
-            && (0, undefined_1$1.isntUndefined)(val)
-            && typeof val[Symbol.iterator] === 'function';
+        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) {
@@ -3829,149 +6365,21 @@
     }
     iterable.isntIterable = isntIterable;
 
-    var jsonRpc = {};
-
-    var object = {};
-
-    /**
-     * lodash (Custom Build) <https://lodash.com/>
-     * Build: `lodash modularize exports="npm" -o ./`
-     * Copyright jQuery Foundation and other contributors <https://jquery.org/>
-     * Released under MIT license <https://lodash.com/license>
-     * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
-     * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
-     */
-
-    /** `Object#toString` result references. */
-    var objectTag = '[object Object]';
-
-    /**
-     * Checks if `value` is a host object in IE < 9.
-     *
-     * @private
-     * @param {*} value The value to check.
-     * @returns {boolean} Returns `true` if `value` is a host object, else `false`.
-     */
-    function isHostObject(value) {
-      // Many host objects are `Object` objects that can coerce to strings
-      // despite having improperly defined `toString` methods.
-      var result = false;
-      if (value != null && typeof value.toString != 'function') {
-        try {
-          result = !!(value + '');
-        } catch (e) {}
-      }
-      return result;
-    }
-
-    /**
-     * Creates a unary function that invokes `func` with its argument transformed.
-     *
-     * @private
-     * @param {Function} func The function to wrap.
-     * @param {Function} transform The argument transform.
-     * @returns {Function} Returns the new function.
-     */
-    function overArg(func, transform) {
-      return function(arg) {
-        return func(transform(arg));
-      };
-    }
-
-    /** Used for built-in method references. */
-    var funcProto = Function.prototype,
-        objectProto = Object.prototype;
-
-    /** Used to resolve the decompiled source of functions. */
-    var funcToString = funcProto.toString;
-
-    /** Used to check objects for own properties. */
-    var hasOwnProperty = objectProto.hasOwnProperty;
-
-    /** Used to infer the `Object` constructor. */
-    var objectCtorString = funcToString.call(Object);
-
-    /**
-     * Used to resolve the
-     * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
-     * of values.
-     */
-    var objectToString = objectProto.toString;
+    var json = {};
 
-    /** Built-in value references. */
-    var getPrototype = overArg(Object.getPrototypeOf, Object);
+    var number = {};
 
-    /**
-     * Checks if `value` is object-like. A value is object-like if it's not `null`
-     * and has a `typeof` result of "object".
-     *
-     * @static
-     * @memberOf _
-     * @since 4.0.0
-     * @category Lang
-     * @param {*} value The value to check.
-     * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
-     * @example
-     *
-     * _.isObjectLike({});
-     * // => true
-     *
-     * _.isObjectLike([1, 2, 3]);
-     * // => true
-     *
-     * _.isObjectLike(_.noop);
-     * // => false
-     *
-     * _.isObjectLike(null);
-     * // => false
-     */
-    function isObjectLike(value) {
-      return !!value && typeof value == 'object';
+    number.isntNumber = number.isNumber = void 0;
+    function isNumber(val) {
+        return typeof val === 'number';
     }
-
-    /**
-     * Checks if `value` is a plain object, that is, an object created by the
-     * `Object` constructor or one with a `[[Prototype]]` of `null`.
-     *
-     * @static
-     * @memberOf _
-     * @since 0.8.0
-     * @category Lang
-     * @param {*} value The value to check.
-     * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
-     * @example
-     *
-     * function Foo() {
-     *   this.a = 1;
-     * }
-     *
-     * _.isPlainObject(new Foo);
-     * // => false
-     *
-     * _.isPlainObject([1, 2, 3]);
-     * // => false
-     *
-     * _.isPlainObject({ 'x': 0, 'y': 0 });
-     * // => true
-     *
-     * _.isPlainObject(Object.create(null));
-     * // => true
-     */
-    function isPlainObject$1(value) {
-      if (!isObjectLike(value) ||
-          objectToString.call(value) != objectTag || isHostObject(value)) {
-        return false;
-      }
-      var proto = getPrototype(value);
-      if (proto === null) {
-        return true;
-      }
-      var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;
-      return (typeof Ctor == 'function' &&
-        Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString);
+    number.isNumber = isNumber;
+    function isntNumber(val) {
+        return !isNumber(val);
     }
+    number.isntNumber = isntNumber;
 
-    var lodash_isplainobject = isPlainObject$1;
+    var object = {};
 
     var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
         return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -4003,87 +6411,27 @@
     }
     object.isntEmptyObject = isntEmptyObject;
 
-    var number = {};
-
-    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;
-
-    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;
+    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 undefined_1 = _undefined;
-    function isJsonRpcId(val) {
-        return (0, string_1.isString)(val) || (0, number_1.isNumber)(val);
-    }
-    function isJsonRpcParams(val) {
-        return (0, array_1.isArray)(val) || (0, object_1.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)
-            && isJsonRpcParams(val.params);
-    }
-    jsonRpc.isJsonRpcNotification = isJsonRpcNotification;
-    function isntJsonRpcNotification(val) {
-        return !isJsonRpcNotification(val);
-    }
-    jsonRpc.isntJsonRpcNotification = isntJsonRpcNotification;
-    function isJsonRpcRequest(val) {
-        return (0, object_1.isPlainObject)(val)
-            && (0, string_1.isString)(val.jsonrpc)
-            && (0, string_1.isString)(val.method)
-            && isJsonRpcId(val.id)
-            && isJsonRpcParams(val.params);
-    }
-    jsonRpc.isJsonRpcRequest = isJsonRpcRequest;
-    function isntJsonRpcRequest(val) {
-        return !isJsonRpcRequest(val);
-    }
-    jsonRpc.isntJsonRpcRequest = isntJsonRpcRequest;
-    function isJsonRpcSuccess(val) {
-        return (0, object_1.isPlainObject)(val)
-            && (0, string_1.isString)(val.jsonrpc)
-            && (0, string_1.isString)(val.id)
-            && 'result' in val;
-    }
-    jsonRpc.isJsonRpcSuccess = isJsonRpcSuccess;
-    function isntJsonRpcSuccess(val) {
-        return !isJsonRpcSuccess(val);
-    }
-    jsonRpc.isntJsonRpcSuccess = isntJsonRpcSuccess;
-    function isJsonRpcError(val) {
-        return (0, object_1.isPlainObject)(val)
-            && (0, string_1.isString)(val.jsonrpc)
-            && isJsonRpcId(val.id)
-            && isJsonRpcErrorObject(val.error);
-    }
-    jsonRpc.isJsonRpcError = isJsonRpcError;
-    function isntJsonRpcError(val) {
-        return !isJsonRpcError(val);
+    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));
     }
-    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));
+    json.isJson = isJson;
+    function isntJson(val) {
+        return !isJson(val);
     }
-
-    var json = {};
-
-    json.isntJson = json.isJson = void 0;
-    function isJson(val) {
+    json.isntJson = isntJson;
+    function isJsonable(val) {
         try {
             JSON.stringify(val);
             return true;
@@ -4092,11 +6440,34 @@
             return false;
         }
     }
-    json.isJson = isJson;
-    function isntJson(val) {
-        return !isntJson();
+    json.isJsonable = isJsonable;
+    function isntJsonable(val) {
+        return !isntJsonable();
     }
-    json.isntJson = isntJson;
+    json.isntJsonable = isntJsonable;
+
+    var promise = {};
+
+    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;
+    }
+    promise.isPromise = isPromise;
+    function isntPromise(val) {
+        return !isPromise(val);
+    }
+    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 url = {};
 
@@ -4133,11 +6504,11 @@
     __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(promise, exports);
     __exportStar(string, exports);
     __exportStar(_undefined, exports);
     __exportStar(url, exports);