@blackglory/structures 0.3.2 → 0.3.5

package/dist/es2015/index.mjs

@@ -233,30 +233,2458 @@ class Queue {
 
 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;
@@ -264,25 +2692,69 @@ assertionError.AssertionError = AssertionError;
 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 = {};
 
@@ -304,14 +2776,16 @@ var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Obj
 }));
 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 = {};
 
@@ -345,7 +2819,7 @@ var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m
 
 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');
@@ -415,11 +2889,11 @@ function isntUndefined$1(val) {
 _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;
@@ -537,11 +3011,11 @@ _function$1.isntFunction = isntFunction$1;
 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;
@@ -550,23 +3024,31 @@ function isntIterable$1(val) {
 }
 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;
 }
@@ -588,69 +3070,69 @@ function isntNumber$1(val) {
 }
 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 = {};
@@ -706,7 +3188,7 @@ __exportStar(error$1, exports);
 __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);
@@ -780,7 +3262,7 @@ var chunk$1 = {};
 
 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');
@@ -856,7 +3338,7 @@ utils.copyIterable = copyIterable;
 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');
@@ -891,7 +3373,7 @@ var dropRightAsync$1 = {};
 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');
@@ -919,7 +3401,7 @@ var dropRight$1 = {};
 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');
@@ -1019,7 +3501,7 @@ var drop$1 = {};
 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');
@@ -1139,7 +3621,7 @@ function isFiniteIterable$1(val) {
 
 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');
@@ -1180,7 +3662,7 @@ var flattenDeep$1 = {};
 
 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');
@@ -1241,7 +3723,7 @@ var repeatAsync$1 = {};
 
 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');
@@ -1276,7 +3758,7 @@ var repeat$1 = {};
 
 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');
@@ -1311,7 +3793,7 @@ var sliceAsync$1 = {};
 
 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');
@@ -1334,7 +3816,7 @@ var slice$1 = {};
 
 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');
@@ -1457,7 +3939,7 @@ var takeAsync$1 = {};
 
 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');
@@ -1478,7 +3960,7 @@ var takeRightAsync$1 = {};
 
 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');
@@ -1508,7 +3990,7 @@ var takeRight$1 = {};
 
 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');
@@ -1584,7 +4066,7 @@ var take$1 = {};
 
 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');
@@ -2460,8 +4942,8 @@ class LRUMap {
     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)]() {
@@ -2795,8 +5277,8 @@ class TLRUMap {
          * 按过期时间升序排列所有项目的元数据
          */
         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)]() {
@@ -3006,11 +5488,14 @@ class FiniteStateMachine {
     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 {
@@ -3019,7 +5504,7 @@ class FiniteStateMachine {
     }
 }
 _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}`);
     }
@@ -3063,7 +5548,7 @@ var Subscription = (function () {
         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;
@@ -3092,23 +5577,23 @@ var Subscription = (function () {
                     _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 : [];
@@ -3124,7 +5609,7 @@ var Subscription = (function () {
                 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; }
                 }
@@ -3138,7 +5623,7 @@ var Subscription = (function () {
         var _a;
         if (teardown && teardown !== this) {
             if (this.closed) {
-                execTeardown(teardown);
+                execFinalizer(teardown);
             }
             else {
                 if (teardown instanceof Subscription) {
@@ -3147,7 +5632,7 @@ var Subscription = (function () {
                     }
                     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);
             }
         }
     };
@@ -3169,8 +5654,8 @@ var Subscription = (function () {
         }
     };
     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);
         }
@@ -3187,12 +5672,12 @@ function isSubscription(value) {
     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();
     }
 }
 
@@ -3205,13 +5690,16 @@ var config = {
 };
 
 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;
@@ -3318,52 +5806,88 @@ var Subscriber = (function (_super) {
     };
     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;
@@ -3500,6 +6024,7 @@ var Subject = (function (_super) {
     function Subject() {
         var _this = _super.call(this) || this;
         _this.closed = false;
+        _this.currentObservers = null;
         _this.observers = [];
         _this.isStopped = false;
         _this.hasError = false;
@@ -3522,17 +6047,19 @@ var Subject = (function (_super) {
             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; }
                 }
@@ -3568,7 +6095,7 @@ var Subject = (function (_super) {
     };
     Subject.prototype.unsubscribe = function () {
         this.isStopped = this.closed = true;
-        this.observers = null;
+        this.observers = this.currentObservers = null;
     };
     Object.defineProperty(Subject.prototype, "observed", {
         get: function () {
@@ -3588,10 +6115,17 @@ var Subject = (function (_super) {
         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;
@@ -3681,19 +6215,32 @@ _undefined.isntUndefined = _undefined.isUndefined = void 0;
 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) {
@@ -3795,27 +6342,16 @@ function isntFalsy(val) {
 }
 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) {
@@ -3823,149 +6359,21 @@ function isntIterable(val) {
 }
 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 };
@@ -3997,87 +6405,27 @@ function isntEmptyObject(val) {
 }
 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;
@@ -4086,11 +6434,34 @@ function isJson(val) {
         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 = {};
 
@@ -4127,11 +6498,11 @@ __exportStar(error, exports);
 __exportStar(falsy, exports);
 __exportStar(_function, exports);
 __exportStar(iterable, exports);
-__exportStar(jsonRpc, exports);
 __exportStar(json, exports);
 __exportStar(_null, exports);
 __exportStar(number, exports);
 __exportStar(object, exports);
+__exportStar(promise, exports);
 __exportStar(string, exports);
 __exportStar(_undefined, exports);
 __exportStar(url, exports);