@blackglory/structures 0.3.2 → 0.3.3

package/dist/es2018/index.mjs

@@ -235,36 +235,70 @@ var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof win
 
 var es2018$6 = {};
 
+var customError$1 = {};
+
+var es2018$5 = {};
+
+var middleware = {};
+
+var chunkAsync$1 = {};
+
+var es2018$4 = {};
+
+var go$1 = {};
+
+go$1.go = void 0;
+function go(fn) {
+    return fn();
+}
+go$1.go = go;
+
+(function (exports) {
+var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};__exportStar(go$1, exports);
+
+}(es2018$4));
+
+var es2018$3 = {};
+
 var customError = {};
 
 customError.CustomError = void 0;
-class CustomError extends Error {
+class CustomError$1 extends Error {
     get name() {
         return this.constructor.name;
     }
 }
-customError.CustomError = CustomError;
+customError.CustomError = CustomError$1;
 
 var expectedError = {};
 
 expectedError.ExpectedError = void 0;
-const custom_error_1$1 = customError;
-class ExpectedError extends custom_error_1$1.CustomError {
+const custom_error_1$2 = customError;
+class ExpectedError extends custom_error_1$2.CustomError {
 }
 expectedError.ExpectedError = ExpectedError;
 
-var assertionError = {};
+var assertionError$1 = {};
 
-assertionError.AssertionError = void 0;
-const custom_error_1 = customError;
-class AssertionError extends custom_error_1.CustomError {
+assertionError$1.AssertionError = void 0;
+const custom_error_1$1 = customError;
+class AssertionError$1 extends custom_error_1$1.CustomError {
 }
-assertionError.AssertionError = AssertionError;
+assertionError$1.AssertionError = AssertionError$1;
 
-var normalize$1 = {};
+var normalize$3 = {};
 
-normalize$1.normalize = void 0;
-function normalize(err) {
+normalize$3.normalize = void 0;
+function normalize$2(err) {
     var _a;
     return {
         name: err.name,
@@ -272,7 +306,7 @@ function normalize(err) {
         stack: (_a = err.stack) !== null && _a !== void 0 ? _a : null
     };
 }
-normalize$1.normalize = normalize;
+normalize$3.normalize = normalize$2;
 
 var refute$1 = {};
 
@@ -284,15 +318,15 @@ function refute(condition, message) {
 }
 refute$1.refute = refute;
 
-var assert$1 = {};
+var assert$3 = {};
 
-assert$1.assert = void 0;
-const assertion_error_1 = assertionError;
-function assert(condition, message) {
+assert$3.assert = void 0;
+const assertion_error_1$1 = assertionError$1;
+function assert$2(condition, message) {
     if (!condition)
-        throw new assertion_error_1.AssertionError(message);
+        throw new assertion_error_1$1.AssertionError(message);
 }
-assert$1.assert = assert;
+assert$3.assert = assert$2;
 
 (function (exports) {
 var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -306,46 +340,16 @@ var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m
     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, exports);
-__exportStar(normalize$1, exports);
+__exportStar(assertionError$1, exports);
+__exportStar(normalize$3, exports);
 __exportStar(refute$1, exports);
-__exportStar(assert$1, exports);
-
-}(es2018$6));
-
-var es2018$5 = {};
-
-var middleware = {};
-
-var chunkAsync$1 = {};
-
-var es2018$4 = {};
-
-var go$1 = {};
-
-go$1.go = void 0;
-function go(fn) {
-    return fn();
-}
-go$1.go = go;
-
-(function (exports) {
-var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};__exportStar(go$1, exports);
+__exportStar(assert$3, exports);
 
-}(es2018$4));
+}(es2018$3));
 
 chunkAsync$1.chunkAsync = void 0;
 const go_1$f = es2018$4;
-const errors_1$f = es2018$6;
+const errors_1$f = es2018$3;
 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');
@@ -366,324 +370,472 @@ chunkAsync$1.chunkAsync = chunkAsync;
 
 var chunkByAsync$1 = {};
 
-var es2018$3 = {};
+var es2018$2 = {};
 
-var array$1 = {};
+var array = {};
 
-array$1.isntEmptyArray = array$1.isEmptyArray = array$1.isntArray = array$1.isArray = void 0;
-function isArray$1(val) {
+array.isntEmptyArray = array.isEmptyArray = array.isntArray = array.isArray = void 0;
+function isArray(val) {
     return Array.isArray(val);
 }
-array$1.isArray = isArray$1;
-function isntArray$1(val) {
-    return !isArray$1(val);
+array.isArray = isArray;
+function isntArray(val) {
+    return !isArray(val);
 }
-array$1.isntArray = isntArray$1;
-function isEmptyArray$1(val) {
+array.isntArray = isntArray;
+function isEmptyArray(val) {
     return val.length === 0;
 }
-array$1.isEmptyArray = isEmptyArray$1;
-function isntEmptyArray$1(val) {
+array.isEmptyArray = isEmptyArray;
+function isntEmptyArray(val) {
     return val.length !== 0;
 }
-array$1.isntEmptyArray = isntEmptyArray$1;
+array.isntEmptyArray = isntEmptyArray;
 
-var asyncIterable$1 = {};
+var asyncIterable = {};
 
-var _null$1 = {};
+var _null = {};
 
-_null$1.isntNull = _null$1.isNull = void 0;
-function isNull$1(val) {
+_null.isntNull = _null.isNull = void 0;
+function isNull(val) {
     return val === null;
 }
-_null$1.isNull = isNull$1;
-function isntNull$1(val) {
-    return !isNull$1(val);
+_null.isNull = isNull;
+function isntNull(val) {
+    return !isNull(val);
 }
-_null$1.isntNull = isntNull$1;
+_null.isntNull = isntNull;
 
-var _undefined$1 = {};
+var _undefined = {};
 
-_undefined$1.isntUndefined = _undefined$1.isUndefined = void 0;
-function isUndefined$1(val) {
+_undefined.isntUndefined = _undefined.isUndefined = void 0;
+function isUndefined(val) {
     return val === undefined;
 }
-_undefined$1.isUndefined = isUndefined$1;
-function isntUndefined$1(val) {
-    return !isUndefined$1(val);
+_undefined.isUndefined = isUndefined;
+function isntUndefined(val) {
+    return !isUndefined(val);
 }
-_undefined$1.isntUndefined = isntUndefined$1;
+_undefined.isntUndefined = isntUndefined;
 
-asyncIterable$1.isntAsyncIterable = asyncIterable$1.isAsyncIterable = void 0;
-const null_1$3 = _null$1;
-const undefined_1$5 = _undefined$1;
-function isAsyncIterable$1(val) {
-    return (0, null_1$3.isntNull)(val)
-        && (0, undefined_1$5.isntUndefined)(val)
+asyncIterable.isntAsyncIterable = asyncIterable.isAsyncIterable = void 0;
+const null_1$1 = _null;
+const undefined_1$2 = _undefined;
+function isAsyncIterable(val) {
+    return (0, null_1$1.isntNull)(val)
+        && (0, undefined_1$2.isntUndefined)(val)
         && typeof val[Symbol.asyncIterator] === 'function';
 }
-asyncIterable$1.isAsyncIterable = isAsyncIterable$1;
-function isntAsyncIterable$1(val) {
-    return !isAsyncIterable$1(val);
+asyncIterable.isAsyncIterable = isAsyncIterable;
+function isntAsyncIterable(val) {
+    return !isAsyncIterable(val);
 }
-asyncIterable$1.isntAsyncIterable = isntAsyncIterable$1;
+asyncIterable.isntAsyncIterable = isntAsyncIterable;
 
-var bigint$1 = {};
+var bigint = {};
 
-bigint$1.isntBigInt = bigint$1.isBigInt = void 0;
-function isBigInt$1(val) {
+bigint.isntBigInt = bigint.isBigInt = void 0;
+function isBigInt(val) {
     return typeof val === 'bigint';
 }
-bigint$1.isBigInt = isBigInt$1;
-function isntBigInt$1(val) {
-    return !isBigInt$1(val);
+bigint.isBigInt = isBigInt;
+function isntBigInt(val) {
+    return !isBigInt(val);
 }
-bigint$1.isntBigInt = isntBigInt$1;
+bigint.isntBigInt = isntBigInt;
 
-var boolean$1 = {};
+var boolean = {};
 
-boolean$1.isntBoolean = boolean$1.isBoolean = void 0;
-function isBoolean$1(val) {
+boolean.isntBoolean = boolean.isBoolean = void 0;
+function isBoolean(val) {
     return typeof val === 'boolean';
 }
-boolean$1.isBoolean = isBoolean$1;
-function isntBoolean$1(val) {
-    return !isBoolean$1(val);
+boolean.isBoolean = isBoolean;
+function isntBoolean(val) {
+    return !isBoolean(val);
 }
-boolean$1.isntBoolean = isntBoolean$1;
+boolean.isntBoolean = isntBoolean;
 
-var char$1 = {};
+var char = {};
 
-var string$1 = {};
+var string = {};
 
-string$1.isntString = string$1.isString = void 0;
-function isString$1(val) {
+string.isntString = string.isString = void 0;
+function isString(val) {
     return typeof val === 'string';
 }
-string$1.isString = isString$1;
-function isntString$1(val) {
-    return !isString$1(val);
+string.isString = isString;
+function isntString(val) {
+    return !isString(val);
 }
-string$1.isntString = isntString$1;
+string.isntString = isntString;
 
-char$1.isntChar = char$1.isChar = void 0;
-const string_1$3 = string$1;
-function isChar$1(val) {
-    return (0, string_1$3.isString)(val)
+char.isntChar = char.isChar = void 0;
+const string_1$1 = string;
+function isChar(val) {
+    return (0, string_1$1.isString)(val)
         && val.length === 1;
 }
-char$1.isChar = isChar$1;
-function isntChar$1(val) {
-    return !isChar$1(val);
+char.isChar = isChar;
+function isntChar(val) {
+    return !isChar(val);
 }
-char$1.isntChar = isntChar$1;
+char.isntChar = isntChar;
 
-var date$1 = {};
+var date = {};
 
-date$1.isntDate = date$1.isDate = void 0;
-function isDate$1(val) {
+date.isntDate = date.isDate = void 0;
+function isDate(val) {
     return val instanceof Date;
 }
-date$1.isDate = isDate$1;
-function isntDate$1(val) {
-    return !isDate$1(val);
+date.isDate = isDate;
+function isntDate(val) {
+    return !isDate(val);
 }
-date$1.isntDate = isntDate$1;
+date.isntDate = isntDate;
 
-var _enum$1 = {};
+var _enum = {};
 
-_enum$1.inEnum = void 0;
-function inEnum$1(val, _enum) {
+_enum.inEnum = void 0;
+function inEnum(val, _enum) {
     return Object.values(_enum).includes(val);
 }
-_enum$1.inEnum = inEnum$1;
+_enum.inEnum = inEnum;
 
-var error$1 = {};
+var error = {};
 
-error$1.isntError = error$1.isError = void 0;
-function isError$1(val) {
+error.isntError = error.isError = void 0;
+function isError(val) {
     return val instanceof Error;
 }
-error$1.isError = isError$1;
-function isntError$1(val) {
-    return !isError$1(val);
+error.isError = isError;
+function isntError(val) {
+    return !isError(val);
 }
-error$1.isntError = isntError$1;
+error.isntError = isntError;
 
-var falsy$1 = {};
+var falsy = {};
 
-falsy$1.isntFalsy = falsy$1.isFalsy = void 0;
-function isFalsy$1(val) {
+falsy.isntFalsy = falsy.isFalsy = void 0;
+function isFalsy(val) {
     return !val;
 }
-falsy$1.isFalsy = isFalsy$1;
-function isntFalsy$1(val) {
-    return !isFalsy$1(val);
+falsy.isFalsy = isFalsy;
+function isntFalsy(val) {
+    return !isFalsy(val);
 }
-falsy$1.isntFalsy = isntFalsy$1;
+falsy.isntFalsy = isntFalsy;
 
-var _function$1 = {};
+var _function = {};
 
-_function$1.isntFunction = _function$1.isFunction = void 0;
-function isFunction$2(val) {
+_function.isntFunction = _function.isFunction = void 0;
+function isFunction$1(val) {
     return typeof val === 'function';
 }
-_function$1.isFunction = isFunction$2;
-function isntFunction$1(val) {
-    return !isFunction$2(val);
+_function.isFunction = isFunction$1;
+function isntFunction(val) {
+    return !isFunction$1(val);
 }
-_function$1.isntFunction = isntFunction$1;
+_function.isntFunction = isntFunction;
 
-var iterable$1 = {};
+var iterable = {};
 
-iterable$1.isntIterable = iterable$1.isIterable = void 0;
-const null_1$2 = _null$1;
-const undefined_1$4 = _undefined$1;
-function isIterable$1(val) {
-    return (0, null_1$2.isntNull)(val)
-        && (0, undefined_1$4.isntUndefined)(val)
+iterable.isntIterable = iterable.isIterable = void 0;
+const null_1 = _null;
+const undefined_1$1 = _undefined;
+function isIterable(val) {
+    return (0, null_1.isntNull)(val)
+        && (0, undefined_1$1.isntUndefined)(val)
         && typeof val[Symbol.iterator] === 'function';
 }
-iterable$1.isIterable = isIterable$1;
-function isntIterable$1(val) {
-    return !isIterable$1(val);
+iterable.isIterable = isIterable;
+function isntIterable(val) {
+    return !isIterable(val);
 }
-iterable$1.isntIterable = isntIterable$1;
+iterable.isntIterable = isntIterable;
 
-var jsonRpc$1 = {};
+var jsonRpc = {};
 
-var object$1 = {};
+var object = {};
 
-object$1.isntEmptyObject = object$1.isEmptyObject = object$1.isRecord = object$1.isntObject = object$1.isObject = void 0;
-function isObject$1(val) {
-    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);
-}
-object$1.isRecord = isRecord;
-function isEmptyObject$1(val) {
-    return Object.keys(val).length === 0;
-}
-object$1.isEmptyObject = isEmptyObject$1;
-function isntEmptyObject$1(val) {
-    return Object.keys(val).length !== 0;
-}
-object$1.isntEmptyObject = isntEmptyObject$1;
+/**
+ * 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
+ */
 
-var number$1 = {};
+/** `Object#toString` result references. */
+var objectTag = '[object Object]';
 
-number$1.isntNumber = number$1.isNumber = void 0;
-function isNumber$1(val) {
-    return typeof val === 'number';
-}
-number$1.isNumber = isNumber$1;
-function isntNumber$1(val) {
-    return !isNumber$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;
-const array_1$1 = array$1;
-const object_1$1 = object$1;
-const string_1$2 = string$1;
-const number_1$1 = number$1;
-const undefined_1$3 = _undefined$1;
-function isJsonRpcId$1(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 isJsonRpcNotification$1(val) {
-    return (0, object_1$1.isRecord)(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);
-}
-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$1.isRecord)(val)
-        && (0, string_1$2.isString)(val.jsonrpc)
-        && (0, string_1$2.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$1.isRecord)(val)
-        && (0, string_1$2.isString)(val.jsonrpc)
-        && (0, string_1$2.isString)(val.id)
-        && (0, undefined_1$3.isntUndefined)(val.result);
-}
-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$1.isRecord)(val)
-        && (0, string_1$2.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$1.isRecord)(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));
-}
-
-var json$1 = {};
-
-json$1.isntJson = json$1.isJson = void 0;
-function isJson$1(val) {
+/**
+ * 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 {
-        JSON.stringify(val);
-        return true;
-    }
-    catch (_a) {
-        return false;
-    }
+      result = !!(value + '');
+    } catch (e) {}
+  }
+  return result;
 }
-json$1.isJson = isJson$1;
-function isntJson$1(val) {
-    return !isntJson$1();
+
+/**
+ * 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));
+  };
 }
-json$1.isntJson = isntJson$1;
 
-var url$1 = {};
+/** Used for built-in method references. */
+var funcProto = Function.prototype,
+    objectProto = Object.prototype;
 
-url$1.isAbsoluteURL = void 0;
-function isAbsoluteURL$1(str) {
-    try {
-        new URL(str);
-        return true;
-    }
+/** 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$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);
+}
+
+var lodash_isplainobject = isPlainObject$1;
+
+var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};object.isntEmptyObject = object.isEmptyObject = object.isntPlainObject = object.isPlainObject = object.isntObject = object.isObject = void 0;
+const lodash_isplainobject_1 = __importDefault(lodash_isplainobject);
+function isObject(val) {
+    return val !== null
+        && typeof val === 'object';
+}
+object.isObject = isObject;
+function isntObject(val) {
+    return !isObject(val);
+}
+object.isntObject = isntObject;
+function isPlainObject(val) {
+    return (0, lodash_isplainobject_1.default)(val);
+}
+object.isPlainObject = isPlainObject;
+function isntPlainObject(val) {
+    return !isPlainObject(val);
+}
+object.isntPlainObject = isntPlainObject;
+function isEmptyObject(val) {
+    return Object.keys(val).length === 0;
+}
+object.isEmptyObject = isEmptyObject;
+function isntEmptyObject(val) {
+    return Object.keys(val).length !== 0;
+}
+object.isntEmptyObject = isntEmptyObject;
+
+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;
+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);
+}
+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));
+}
+
+var json = {};
+
+json.isntJson = json.isJson = void 0;
+function isJson(val) {
+    try {
+        JSON.stringify(val);
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+json.isJson = isJson;
+function isntJson(val) {
+    return !isntJson();
+}
+json.isntJson = isntJson;
+
+var url = {};
+
+url.isAbsoluteURL = void 0;
+function isAbsoluteURL(str) {
+    try {
+        new URL(str);
+        return true;
+    }
     catch (_a) {
         return false;
     }
 }
-url$1.isAbsoluteURL = isAbsoluteURL$1;
+url.isAbsoluteURL = isAbsoluteURL;
 
 (function (exports) {
 var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -695,32 +847,32 @@ 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(array$1, exports);
-__exportStar(asyncIterable$1, exports);
-__exportStar(bigint$1, exports);
-__exportStar(boolean$1, exports);
-__exportStar(char$1, exports);
-__exportStar(date$1, exports);
-__exportStar(_enum$1, exports);
-__exportStar(error$1, exports);
-__exportStar(falsy$1, exports);
-__exportStar(_function$1, exports);
-__exportStar(iterable$1, exports);
-__exportStar(jsonRpc$1, exports);
-__exportStar(json$1, exports);
-__exportStar(_null$1, exports);
-__exportStar(number$1, exports);
-__exportStar(object$1, exports);
-__exportStar(string$1, exports);
-__exportStar(_undefined$1, exports);
-__exportStar(url$1, exports);
+};__exportStar(array, exports);
+__exportStar(asyncIterable, exports);
+__exportStar(bigint, exports);
+__exportStar(boolean, exports);
+__exportStar(char, exports);
+__exportStar(date, exports);
+__exportStar(_enum, exports);
+__exportStar(error, exports);
+__exportStar(falsy, exports);
+__exportStar(_function, exports);
+__exportStar(iterable, exports);
+__exportStar(jsonRpc, exports);
+__exportStar(json, exports);
+__exportStar(_null, exports);
+__exportStar(number, exports);
+__exportStar(object, exports);
+__exportStar(string, exports);
+__exportStar(_undefined, exports);
+__exportStar(url, exports);
 
-}(es2018$3));
+}(es2018$2));
 
 chunkByAsync$1.chunkByAsync = void 0;
-const types_1$h = es2018$3;
+const types_1$k = es2018$2;
 function chunkByAsync(iterable, predicate) {
-    if ((0, types_1$h.isAsyncIterable)(iterable)) {
+    if ((0, types_1$k.isAsyncIterable)(iterable)) {
         return chunkByAsyncIterable(iterable);
     }
     else {
@@ -780,7 +932,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$3;
 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');
@@ -802,12 +954,12 @@ chunk$1.chunk = chunk;
 var concatAsync$1 = {};
 
 concatAsync$1.concatAsync = void 0;
-const types_1$g = es2018$3;
+const types_1$j = es2018$2;
 const go_1$d = es2018$4;
 function concatAsync(iterable, ...otherIterables) {
     return (0, go_1$d.go)(async function* () {
         for (const iter of [iterable, ...otherIterables]) {
-            if ((0, types_1$g.isAsyncIterable)(iter)) {
+            if ((0, types_1$j.isAsyncIterable)(iter)) {
                 for await (const element of iter) {
                     yield element;
                 }
@@ -856,7 +1008,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$3;
 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 +1043,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$3;
 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 +1071,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$3;
 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');
@@ -935,9 +1087,9 @@ dropRight$1.dropRight = dropRight;
 var dropUntilAsync$1 = {};
 
 dropUntilAsync$1.dropUntilAsync = void 0;
-const types_1$f = es2018$3;
+const types_1$i = es2018$2;
 function dropUntilAsync(iterable, predicate) {
-    if ((0, types_1$f.isAsyncIterable)(iterable)) {
+    if ((0, types_1$i.isAsyncIterable)(iterable)) {
         return dropUntilAsyncIterable(iterable);
     }
     else {
@@ -1019,7 +1171,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$3;
 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');
@@ -1052,9 +1204,9 @@ drop$1.drop = drop;
 var filterAsync$1 = {};
 
 filterAsync$1.filterAsync = void 0;
-const types_1$e = es2018$3;
+const types_1$h = es2018$2;
 function filterAsync(iterable, predicate) {
-    if ((0, types_1$e.isAsyncIterable)(iterable)) {
+    if ((0, types_1$h.isAsyncIterable)(iterable)) {
         return filterAsyncIterable(iterable);
     }
     else {
@@ -1099,9 +1251,9 @@ var flattenDeepAsync$1 = {};
 var flattenByAsync$1 = {};
 
 flattenByAsync$1.flattenByAsync = void 0;
-const types_1$d = es2018$3;
+const types_1$g = es2018$2;
 function flattenByAsync(iterable, predicate) {
-    if ((0, types_1$d.isAsyncIterable)(iterable)) {
+    if ((0, types_1$g.isAsyncIterable)(iterable)) {
         return flattenByAsyncIterable(iterable);
     }
     else {
@@ -1134,12 +1286,12 @@ function flattenByAsync(iterable, predicate) {
 }
 flattenByAsync$1.flattenByAsync = flattenByAsync;
 function isFiniteIterable$1(val) {
-    return (0, types_1$d.isIterable)(val) && (0, types_1$d.isntChar)(val);
+    return (0, types_1$g.isIterable)(val) && (0, types_1$g.isntChar)(val);
 }
 
 flattenDeepAsync$1.flattenDeepAsync = void 0;
 const flatten_by_async_1 = flattenByAsync$1;
-const errors_1$9 = es2018$6;
+const errors_1$9 = es2018$3;
 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');
@@ -1157,7 +1309,7 @@ flattenAsync$1.flattenAsync = flattenAsync;
 var flattenBy$1 = {};
 
 flattenBy$1.flattenBy = void 0;
-const types_1$c = es2018$3;
+const types_1$f = es2018$2;
 function flattenBy(iterable, predicate) {
     return flatten(iterable, 1);
     function* flatten(iterable, level) {
@@ -1173,14 +1325,14 @@ function flattenBy(iterable, predicate) {
 }
 flattenBy$1.flattenBy = flattenBy;
 function isFiniteIterable(val) {
-    return (0, types_1$c.isIterable)(val) && (0, types_1$c.isntChar)(val);
+    return (0, types_1$f.isIterable)(val) && (0, types_1$f.isntChar)(val);
 }
 
 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$3;
 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');
@@ -1200,9 +1352,9 @@ flatten$1.flatten = flatten;
 var mapAsync$1 = {};
 
 mapAsync$1.mapAsync = void 0;
-const types_1$b = es2018$3;
+const types_1$e = es2018$2;
 function mapAsync(iterable, fn) {
-    if ((0, types_1$b.isAsyncIterable)(iterable)) {
+    if ((0, types_1$e.isAsyncIterable)(iterable)) {
         return mapAsyncIterable(iterable);
     }
     else {
@@ -1241,7 +1393,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$3;
 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 +1428,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$3;
 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 +1463,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$3;
 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 +1486,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$3;
 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');
@@ -1374,9 +1526,9 @@ splitAsync$1.splitAsync = splitAsync;
 var splitByAsync$1 = {};
 
 splitByAsync$1.splitByAsync = void 0;
-const types_1$a = es2018$3;
+const types_1$d = es2018$2;
 function splitByAsync(iterable, predicate) {
-    if ((0, types_1$a.isAsyncIterable)(iterable)) {
+    if ((0, types_1$d.isAsyncIterable)(iterable)) {
         return splitByAsyncIterable(iterable);
     }
     else {
@@ -1457,7 +1609,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$3;
 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 +1630,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$3;
 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 +1660,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$3;
 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');
@@ -1537,9 +1689,9 @@ takeRight$1.takeRight = takeRight;
 var takeUntilAsync$1 = {};
 
 takeUntilAsync$1.takeUntilAsync = void 0;
-const types_1$9 = es2018$3;
+const types_1$c = es2018$2;
 function takeUntilAsync(iterable, predicate) {
-    if ((0, types_1$9.isAsyncIterable)(iterable)) {
+    if ((0, types_1$c.isAsyncIterable)(iterable)) {
         return takeUntilAsyncIterable(iterable);
     }
     else {
@@ -1584,7 +1736,7 @@ var take$1 = {};
 
 take$1.take = void 0;
 const go_1 = es2018$4;
-const errors_1 = es2018$6;
+const errors_1 = es2018$3;
 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');
@@ -1604,9 +1756,9 @@ take$1.take = take;
 var tapAsync$1 = {};
 
 tapAsync$1.tapAsync = void 0;
-const types_1$8 = es2018$3;
+const types_1$b = es2018$2;
 function tapAsync(iterable, fn) {
-    if ((0, types_1$8.isAsyncIterable)(iterable)) {
+    if ((0, types_1$b.isAsyncIterable)(iterable)) {
         return tapAsyncIterable(iterable);
     }
     else {
@@ -1687,9 +1839,9 @@ uniqAsync$1.uniqAsync = uniqAsync;
 var uniqByAsync$1 = {};
 
 uniqByAsync$1.uniqByAsync = void 0;
-const types_1$7 = es2018$3;
+const types_1$a = es2018$2;
 function uniqByAsync(iterable, fn) {
-    if ((0, types_1$7.isAsyncIterable)(iterable)) {
+    if ((0, types_1$a.isAsyncIterable)(iterable)) {
         return uniqByAsyncIterable(iterable);
     }
     else {
@@ -1756,7 +1908,7 @@ uniq$1.uniq = uniq;
 var zipAsync$1 = {};
 
 zipAsync$1.zipAsync = void 0;
-const types_1$6 = es2018$3;
+const types_1$9 = es2018$2;
 var Kind;
 (function (Kind) {
     Kind[Kind["Sync"] = 0] = "Sync";
@@ -1770,7 +1922,7 @@ async function* zipWithSize$1(...iterables) {
     var _a, _b, _c, _d;
     const length = iterables.length;
     const iterators = iterables.map(iterable => {
-        if ((0, types_1$6.isAsyncIterable)(iterable)) {
+        if ((0, types_1$9.isAsyncIterable)(iterable)) {
             return [Kind.Async, iterable[Symbol.asyncIterator]()];
         }
         else {
@@ -1916,9 +2068,9 @@ consume$1.consume = consume;
 var eachAsync$1 = {};
 
 eachAsync$1.eachAsync = void 0;
-const types_1$5 = es2018$3;
+const types_1$8 = es2018$2;
 function eachAsync(iterable, fn) {
-    if ((0, types_1$5.isAsyncIterable)(iterable)) {
+    if ((0, types_1$8.isAsyncIterable)(iterable)) {
         return eachAsyncIterable(iterable);
     }
     else {
@@ -1956,9 +2108,9 @@ each$1.each = each;
 var everyAsync$1 = {};
 
 everyAsync$1.everyAsync = void 0;
-const types_1$4 = es2018$3;
+const types_1$7 = es2018$2;
 function everyAsync(iterable, predicate) {
-    if ((0, types_1$4.isAsyncIterable)(iterable)) {
+    if ((0, types_1$7.isAsyncIterable)(iterable)) {
         return everyAsyncIterable(iterable);
     }
     else {
@@ -2002,9 +2154,9 @@ every$1.every = every;
 var findAsync$1 = {};
 
 findAsync$1.findAsync = void 0;
-const types_1$3 = es2018$3;
+const types_1$6 = es2018$2;
 function findAsync(iterable, predicate) {
-    if ((0, types_1$3.isAsyncIterable)(iterable)) {
+    if ((0, types_1$6.isAsyncIterable)(iterable)) {
         return findAsyncIterable(iterable);
     }
     else {
@@ -2126,9 +2278,9 @@ match$1.match = match;
 var reduceAsync$1 = {};
 
 reduceAsync$1.reduceAsync = void 0;
-const types_1$2 = es2018$3;
+const types_1$5 = es2018$2;
 function reduceAsync(iterable, fn, initialValue) {
-    if ((0, types_1$2.isUndefined)(initialValue)) {
+    if ((0, types_1$5.isUndefined)(initialValue)) {
         return reduceAsyncWithoutInitialValue(iterable, fn);
     }
     else {
@@ -2137,7 +2289,7 @@ function reduceAsync(iterable, fn, initialValue) {
 }
 reduceAsync$1.reduceAsync = reduceAsync;
 function reduceAsyncWithInitialValue(iterable, fn, initialValue) {
-    if ((0, types_1$2.isAsyncIterable)(iterable)) {
+    if ((0, types_1$5.isAsyncIterable)(iterable)) {
         return reduceAsyncIterable(iterable);
     }
     else {
@@ -2159,7 +2311,7 @@ function reduceAsyncWithInitialValue(iterable, fn, initialValue) {
     }
 }
 function reduceAsyncWithoutInitialValue(iterable, fn) {
-    if ((0, types_1$2.isAsyncIterable)(iterable)) {
+    if ((0, types_1$5.isAsyncIterable)(iterable)) {
         return reduceAsyncIterable(iterable);
     }
     else {
@@ -2222,9 +2374,9 @@ function reduceAsyncWithoutInitialValue(iterable, fn) {
 var reduce$1 = {};
 
 reduce$1.reduce = void 0;
-const types_1$1 = es2018$3;
+const types_1$4 = es2018$2;
 function reduce(iterable, fn, initialValue) {
-    if ((0, types_1$1.isUndefined)(initialValue)) {
+    if ((0, types_1$4.isUndefined)(initialValue)) {
         return reduceWithoutInitialValue(iterable, fn);
     }
     else {
@@ -2269,9 +2421,9 @@ function reduceWithoutInitialValue(iterable, fn) {
 var someAsync$1 = {};
 
 someAsync$1.someAsync = void 0;
-const types_1 = es2018$3;
+const types_1$3 = es2018$2;
 function someAsync(iterable, predicate) {
-    if ((0, types_1.isAsyncIterable)(iterable)) {
+    if ((0, types_1$3.isAsyncIterable)(iterable)) {
         return someAsyncIterable(iterable);
     }
     else {
@@ -2455,6 +2607,135 @@ __exportStar(output, exports);
 
 }(es2018$5));
 
+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$2 = es2018$2;
+const traverse_error_prototype_chain_1 = traverseErrorPrototypeChain$1;
+function* getErrorNames(err) {
+    var _a;
+    if ((0, types_1$2.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$1 = es2018$2;
+function isSerializableError(val) {
+    return (0, types_1$1.isObject)(val)
+        && (0, types_1$1.isString)(val.name)
+        && (0, types_1$1.isString)(val.message)
+        && ((0, types_1$1.isString)(val.stack) || (0, types_1$1.isNull)(val.stack))
+        && ((0, types_1$1.isArray)(val.ancestors) && val.ancestors.every(types_1$1.isString));
+}
+serializableError.isSerializableError = isSerializableError;
+
+customError$1.CustomError = void 0;
+const iterable_operator_1$1 = es2018$5;
+const get_error_names_1$1 = getErrorNames$1;
+const types_1 = es2018$2;
+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.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$1;
+class AssertionError extends custom_error_1.CustomError {
+}
+assertionError.AssertionError = AssertionError;
+
+var normalize$1 = {};
+
+normalize$1.normalize = void 0;
+const get_error_names_1 = getErrorNames$1;
+const iterable_operator_1 = es2018$5;
+function normalize(err) {
+    var _a;
+    const [name, ...ancestors] = (0, iterable_operator_1.toArray)((0, get_error_names_1.getErrorNames)(err));
+    return {
+        name,
+        ancestors,
+        message: err.message,
+        stack: (_a = err.stack) !== null && _a !== void 0 ? _a : null
+    };
+}
+normalize$1.normalize = normalize;
+
+var assert$1 = {};
+
+assert$1.assert = void 0;
+const assertion_error_1 = assertionError;
+function assert(condition, message) {
+    if (!condition)
+        throw new assertion_error_1.AssertionError(message);
+}
+assert$1.assert = assert;
+
+(function (exports) {
+var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    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$1, exports);
+__exportStar(assertionError, exports);
+__exportStar(serializableError, exports);
+__exportStar(normalize$1, exports);
+__exportStar(assert$1, exports);
+__exportStar(getErrorNames$1, exports);
+__exportStar(traverseErrorPrototypeChain$1, exports);
+
+}(es2018$6));
+
 var _LRUMap_limit, _LRUMap_map;
 class LRUMap {
     constructor(limit) {
@@ -2513,11 +2794,11 @@ class LRUMap {
     }
 }
 
-var es2018$2 = {};
+var es2018$1 = {};
 
 var exponentialBackoff = {};
 
-var es2018$1 = {};
+var es2018 = {};
 
 var random$1 = {};
 
@@ -2561,10 +2842,10 @@ var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m
 __exportStar(randomInt$1, exports);
 __exportStar(randomIntInclusive$1, exports);
 
-}(es2018$1));
+}(es2018));
 
 exponentialBackoff.calculateExponentialBackoffTimeout = void 0;
-const extra_rand_1 = es2018$1;
+const extra_rand_1 = es2018;
 function calculateExponentialBackoffTimeout({ baseTimeout, retries, maxTimeout = Infinity, factor = 2, jitter = true }) {
     const timeout = Math.min(factor ** retries * baseTimeout, maxTimeout);
     if (jitter) {
@@ -2679,7 +2960,7 @@ __exportStar(setImmediate$1, exports);
 __exportStar(setTimeoutLoop$1, exports);
 __exportStar(setDynamicTimeoutLoop$1, exports);
 
-}(es2018$2));
+}(es2018$1));
 
 var _ExpirableMap_map, _ExpirableMap_cancelClearTimeout;
 class ExpirableMap {
@@ -2769,7 +3050,7 @@ class ExpirableMap {
         if (this.itemMetadataSortedByExpirationTime.length > 0) {
             const item = this.itemMetadataSortedByExpirationTime[0];
             if (Number.isFinite(item.expirationTime)) {
-                const cancel = es2018$2.setSchedule(item.expirationTime, () => {
+                const cancel = es2018$1.setSchedule(item.expirationTime, () => {
                     this.clearExpiredItems(Date.now());
                     this.rescheduleClearTimeout();
                 });
@@ -2900,7 +3181,7 @@ class TLRUMap {
         if (this.itemMetadataSortedByExpirationTime.length > 0) {
             const item = this.itemMetadataSortedByExpirationTime[0];
             if (Number.isFinite(item.expirationTime)) {
-                const cancel = es2018$2.setSchedule(item.expirationTime, () => {
+                const cancel = es2018$1.setSchedule(item.expirationTime, () => {
                     this.clearExpiredItems(Date.now());
                     this.rescheduleClearTimeout();
                 });
@@ -3025,7 +3306,7 @@ class BadEventError extends es2018$6.CustomError {
     }
 }
 
-function isFunction$1(value) {
+function isFunction(value) {
     return typeof value === 'function';
 }
 
@@ -3093,7 +3374,7 @@ var Subscription = (function () {
                 }
             }
             var initialTeardown = this.initialTeardown;
-            if (isFunction$1(initialTeardown)) {
+            if (isFunction(initialTeardown)) {
                 try {
                     initialTeardown();
                 }
@@ -3185,10 +3466,10 @@ var Subscription = (function () {
 var EMPTY_SUBSCRIPTION = Subscription.EMPTY;
 function isSubscription(value) {
     return (value instanceof Subscription ||
-        (value && 'closed' in value && isFunction$1(value.remove) && isFunction$1(value.add) && isFunction$1(value.unsubscribe)));
+        (value && 'closed' in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe)));
 }
 function execTeardown(teardown) {
-    if (isFunction$1(teardown)) {
+    if (isFunction(teardown)) {
         teardown();
     }
     else {
@@ -3323,7 +3604,7 @@ var SafeSubscriber = (function (_super) {
     function SafeSubscriber(observerOrNext, error, complete) {
         var _this = _super.call(this) || this;
         var next;
-        if (isFunction$1(observerOrNext)) {
+        if (isFunction(observerOrNext)) {
             next = observerOrNext;
         }
         else if (observerOrNext) {
@@ -3481,7 +3762,7 @@ function getPromiseCtor(promiseCtor) {
     return (_a = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config.Promise) !== null && _a !== void 0 ? _a : Promise;
 }
 function isObserver(value) {
-    return value && isFunction$1(value.next) && isFunction$1(value.error) && isFunction$1(value.complete);
+    return value && isFunction(value.next) && isFunction(value.error) && isFunction(value.complete);
 }
 function isSubscriber(value) {
     return (value && value instanceof Subscriber) || (isObserver(value) && isSubscription(value));
@@ -3639,505 +3920,6 @@ var AnonymousSubject = (function (_super) {
     return AnonymousSubject;
 }(Subject));
 
-var es2018 = {};
-
-var array = {};
-
-array.isntEmptyArray = array.isEmptyArray = array.isntArray = array.isArray = void 0;
-function isArray(val) {
-    return Array.isArray(val);
-}
-array.isArray = isArray;
-function isntArray(val) {
-    return !isArray(val);
-}
-array.isntArray = isntArray;
-function isEmptyArray(val) {
-    return val.length === 0;
-}
-array.isEmptyArray = isEmptyArray;
-function isntEmptyArray(val) {
-    return val.length !== 0;
-}
-array.isntEmptyArray = isntEmptyArray;
-
-var asyncIterable = {};
-
-var _null = {};
-
-_null.isntNull = _null.isNull = void 0;
-function isNull(val) {
-    return val === null;
-}
-_null.isNull = isNull;
-function isntNull(val) {
-    return !isNull(val);
-}
-_null.isntNull = isntNull;
-
-var _undefined = {};
-
-_undefined.isntUndefined = _undefined.isUndefined = void 0;
-function isUndefined(val) {
-    return val === undefined;
-}
-_undefined.isUndefined = isUndefined;
-function isntUndefined(val) {
-    return !isUndefined(val);
-}
-_undefined.isntUndefined = isntUndefined;
-
-asyncIterable.isntAsyncIterable = asyncIterable.isAsyncIterable = void 0;
-const null_1$1 = _null;
-const undefined_1$2 = _undefined;
-function isAsyncIterable(val) {
-    return (0, null_1$1.isntNull)(val)
-        && (0, undefined_1$2.isntUndefined)(val)
-        && typeof val[Symbol.asyncIterator] === 'function';
-}
-asyncIterable.isAsyncIterable = isAsyncIterable;
-function isntAsyncIterable(val) {
-    return !isAsyncIterable(val);
-}
-asyncIterable.isntAsyncIterable = isntAsyncIterable;
-
-var bigint = {};
-
-bigint.isntBigInt = bigint.isBigInt = void 0;
-function isBigInt(val) {
-    return typeof val === 'bigint';
-}
-bigint.isBigInt = isBigInt;
-function isntBigInt(val) {
-    return !isBigInt(val);
-}
-bigint.isntBigInt = isntBigInt;
-
-var boolean = {};
-
-boolean.isntBoolean = boolean.isBoolean = void 0;
-function isBoolean(val) {
-    return typeof val === 'boolean';
-}
-boolean.isBoolean = isBoolean;
-function isntBoolean(val) {
-    return !isBoolean(val);
-}
-boolean.isntBoolean = isntBoolean;
-
-var char = {};
-
-var string = {};
-
-string.isntString = string.isString = void 0;
-function isString(val) {
-    return typeof val === 'string';
-}
-string.isString = isString;
-function isntString(val) {
-    return !isString(val);
-}
-string.isntString = isntString;
-
-char.isntChar = char.isChar = void 0;
-const string_1$1 = string;
-function isChar(val) {
-    return (0, string_1$1.isString)(val)
-        && val.length === 1;
-}
-char.isChar = isChar;
-function isntChar(val) {
-    return !isChar(val);
-}
-char.isntChar = isntChar;
-
-var date = {};
-
-date.isntDate = date.isDate = void 0;
-function isDate(val) {
-    return val instanceof Date;
-}
-date.isDate = isDate;
-function isntDate(val) {
-    return !isDate(val);
-}
-date.isntDate = isntDate;
-
-var _enum = {};
-
-_enum.inEnum = void 0;
-function inEnum(val, _enum) {
-    return Object.values(_enum).includes(val);
-}
-_enum.inEnum = inEnum;
-
-var error = {};
-
-error.isntError = error.isError = void 0;
-function isError(val) {
-    return val instanceof Error;
-}
-error.isError = isError;
-function isntError(val) {
-    return !isError(val);
-}
-error.isntError = isntError;
-
-var falsy = {};
-
-falsy.isntFalsy = falsy.isFalsy = void 0;
-function isFalsy(val) {
-    return !val;
-}
-falsy.isFalsy = isFalsy;
-function isntFalsy(val) {
-    return !isFalsy(val);
-}
-falsy.isntFalsy = isntFalsy;
-
-var _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;
-function isIterable(val) {
-    return (0, null_1.isntNull)(val)
-        && (0, undefined_1$1.isntUndefined)(val)
-        && typeof val[Symbol.iterator] === 'function';
-}
-iterable.isIterable = isIterable;
-function isntIterable(val) {
-    return !isIterable(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;
-
-/** 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$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);
-}
-
-var lodash_isplainobject = isPlainObject$1;
-
-var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};object.isntEmptyObject = object.isEmptyObject = object.isntPlainObject = object.isPlainObject = object.isntObject = object.isObject = void 0;
-const lodash_isplainobject_1 = __importDefault(lodash_isplainobject);
-function isObject(val) {
-    return val !== null
-        && typeof val === 'object';
-}
-object.isObject = isObject;
-function isntObject(val) {
-    return !isObject(val);
-}
-object.isntObject = isntObject;
-function isPlainObject(val) {
-    return (0, lodash_isplainobject_1.default)(val);
-}
-object.isPlainObject = isPlainObject;
-function isntPlainObject(val) {
-    return !isPlainObject(val);
-}
-object.isntPlainObject = isntPlainObject;
-function isEmptyObject(val) {
-    return Object.keys(val).length === 0;
-}
-object.isEmptyObject = isEmptyObject;
-function isntEmptyObject(val) {
-    return Object.keys(val).length !== 0;
-}
-object.isntEmptyObject = isntEmptyObject;
-
-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;
-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);
-}
-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));
-}
-
-var json = {};
-
-json.isntJson = json.isJson = void 0;
-function isJson(val) {
-    try {
-        JSON.stringify(val);
-        return true;
-    }
-    catch (_a) {
-        return false;
-    }
-}
-json.isJson = isJson;
-function isntJson(val) {
-    return !isntJson();
-}
-json.isntJson = isntJson;
-
-var url = {};
-
-url.isAbsoluteURL = void 0;
-function isAbsoluteURL(str) {
-    try {
-        new URL(str);
-        return true;
-    }
-    catch (_a) {
-        return false;
-    }
-}
-url.isAbsoluteURL = isAbsoluteURL;
-
-(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, exports);
-__exportStar(asyncIterable, exports);
-__exportStar(bigint, exports);
-__exportStar(boolean, exports);
-__exportStar(char, exports);
-__exportStar(date, exports);
-__exportStar(_enum, exports);
-__exportStar(error, exports);
-__exportStar(falsy, exports);
-__exportStar(_function, exports);
-__exportStar(iterable, exports);
-__exportStar(jsonRpc, exports);
-__exportStar(json, exports);
-__exportStar(_null, exports);
-__exportStar(number, exports);
-__exportStar(object, exports);
-__exportStar(string, exports);
-__exportStar(_undefined, exports);
-__exportStar(url, exports);
-
-}(es2018));
-
 class ObservableFiniteStateMachine extends FiniteStateMachine {
     constructor() {
         super(...arguments);
@@ -4154,7 +3936,7 @@ class ObservableFiniteStateMachine extends FiniteStateMachine {
         super.send(event);
         const newState = this.state;
         this.stateChanges.next({ event, oldState, newState });
-        if (es2018.isEmptyObject(this.schema[newState])) {
+        if (es2018$2.isEmptyObject(this.schema[newState])) {
             this.stateChanges.complete();
         }
     }