@blackglory/structures 0.2.8 → 0.3.3

package/dist/es2018/index.umd.js

@@ -18,6 +18,61 @@
     OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
     PERFORMANCE OF THIS SOFTWARE.
     ***************************************************************************** */
+    /* global Reflect, Promise */
+
+    var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+
+    function __extends(d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    }
+
+    function __values(o) {
+        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+        if (m) return m.call(o);
+        if (o && typeof o.length === "number") return {
+            next: function () {
+                if (o && i >= o.length) o = void 0;
+                return { value: o && o[i++], done: !o };
+            }
+        };
+        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+    }
+
+    function __read(o, n) {
+        var m = typeof Symbol === "function" && o[Symbol.iterator];
+        if (!m) return o;
+        var i = m.call(o), r, ar = [], e;
+        try {
+            while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+        }
+        catch (error) { e = { error: error }; }
+        finally {
+            try {
+                if (r && !r.done && (m = i["return"])) m.call(i);
+            }
+            finally { if (e) throw e.error; }
+        }
+        return ar;
+    }
+
+    function __spreadArray(to, from, pack) {
+        if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+            if (ar || !(i in from)) {
+                if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+                ar[i] = from[i];
+            }
+        }
+        return to.concat(ar || Array.prototype.slice.call(from));
+    }
 
     function __classPrivateFieldGet(receiver, state, kind, f) {
         if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
@@ -186,36 +241,70 @@
 
     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,
@@ -223,7 +312,7 @@
             stack: (_a = err.stack) !== null && _a !== void 0 ? _a : null
         };
     }
-    normalize$1.normalize = normalize;
+    normalize$3.normalize = normalize$2;
 
     var refute$1 = {};
 
@@ -235,15 +324,15 @@
     }
     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) {
@@ -257,46 +346,16 @@
         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');
@@ -317,298 +376,446 @@
 
     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$1(val) {
-        return isObject$1(val);
-    }
-    object$1.isRecord = isRecord$1;
-    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) {
-        try {
+    /**
+     * 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;
         }
@@ -616,16 +823,16 @@
             return false;
         }
     }
-    json$1.isJson = isJson$1;
-    function isntJson$1(val) {
-        return !isntJson$1();
+    json.isJson = isJson;
+    function isntJson(val) {
+        return !isntJson();
     }
-    json$1.isntJson = isntJson$1;
+    json.isntJson = isntJson;
 
-    var url$1 = {};
+    var url = {};
 
-    url$1.isAbsoluteURL = void 0;
-    function isAbsoluteURL$1(str) {
+    url.isAbsoluteURL = void 0;
+    function isAbsoluteURL(str) {
         try {
             new URL(str);
             return true;
@@ -634,7 +841,7 @@
             return false;
         }
     }
-    url$1.isAbsoluteURL = isAbsoluteURL$1;
+    url.isAbsoluteURL = isAbsoluteURL;
 
     (function (exports) {
     var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -646,32 +853,32 @@
     }));
     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 {
@@ -731,7 +938,7 @@
 
     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');
@@ -753,12 +960,12 @@
     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;
                     }
@@ -807,7 +1014,7 @@
     dropAsync$1.dropAsync = void 0;
     const go_1$b = es2018$4;
     const utils_1$3 = utils;
-    const errors_1$d = es2018$6;
+    const errors_1$d = es2018$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');
@@ -842,7 +1049,7 @@
     dropRightAsync$1.dropRightAsync = void 0;
     const go_1$a = es2018$4;
     const utils_1$2 = utils;
-    const errors_1$c = es2018$6;
+    const errors_1$c = es2018$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');
@@ -870,7 +1077,7 @@
     dropRight$1.dropRight = void 0;
     const go_1$9 = es2018$4;
     const utils_1$1 = utils;
-    const errors_1$b = es2018$6;
+    const errors_1$b = es2018$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');
@@ -886,9 +1093,9 @@
     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 {
@@ -970,7 +1177,7 @@
     drop$1.drop = void 0;
     const go_1$8 = es2018$4;
     const utils_1 = utils;
-    const errors_1$a = es2018$6;
+    const errors_1$a = es2018$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');
@@ -1003,9 +1210,9 @@
     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 {
@@ -1050,9 +1257,9 @@
     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 {
@@ -1085,12 +1292,12 @@
     }
     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');
@@ -1108,7 +1315,7 @@
     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) {
@@ -1124,14 +1331,14 @@
     }
     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');
@@ -1151,9 +1358,9 @@
     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 {
@@ -1192,7 +1399,7 @@
 
     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');
@@ -1227,7 +1434,7 @@
 
     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');
@@ -1262,7 +1469,7 @@
 
     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');
@@ -1285,7 +1492,7 @@
 
     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');
@@ -1325,9 +1532,9 @@
     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 {
@@ -1408,7 +1615,7 @@
 
     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');
@@ -1429,7 +1636,7 @@
 
     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');
@@ -1459,7 +1666,7 @@
 
     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');
@@ -1488,9 +1695,9 @@
     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 {
@@ -1535,7 +1742,7 @@
 
     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');
@@ -1555,9 +1762,9 @@
     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 {
@@ -1638,9 +1845,9 @@
     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 {
@@ -1707,7 +1914,7 @@
     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";
@@ -1721,7 +1928,7 @@
         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 {
@@ -1867,9 +2074,9 @@
     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 {
@@ -1907,9 +2114,9 @@
     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 {
@@ -1953,9 +2160,9 @@
     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 {
@@ -2077,9 +2284,9 @@
     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 {
@@ -2088,7 +2295,7 @@
     }
     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 {
@@ -2110,7 +2317,7 @@
         }
     }
     function reduceAsyncWithoutInitialValue(iterable, fn) {
-        if ((0, types_1$2.isAsyncIterable)(iterable)) {
+        if ((0, types_1$5.isAsyncIterable)(iterable)) {
             return reduceAsyncIterable(iterable);
         }
         else {
@@ -2173,9 +2380,9 @@
     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 {
@@ -2220,9 +2427,9 @@
     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 {
@@ -2406,6 +2613,135 @@
 
     }(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) {
@@ -2464,11 +2800,11 @@
         }
     }
 
-    var es2018$2 = {};
+    var es2018$1 = {};
 
     var exponentialBackoff = {};
 
-    var es2018$1 = {};
+    var es2018 = {};
 
     var random$1 = {};
 
@@ -2512,10 +2848,10 @@
     __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) {
@@ -2630,7 +2966,7 @@
     __exportStar(setTimeoutLoop$1, exports);
     __exportStar(setDynamicTimeoutLoop$1, exports);
 
-    }(es2018$2));
+    }(es2018$1));
 
     var _ExpirableMap_map, _ExpirableMap_cancelClearTimeout;
     class ExpirableMap {
@@ -2720,7 +3056,7 @@
             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();
                     });
@@ -2851,7 +3187,7 @@
             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();
                     });
@@ -2976,73 +3312,7 @@
         }
     }
 
-    /*! *****************************************************************************
-    Copyright (c) Microsoft Corporation.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose with or without fee is hereby granted.
-
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
-    ***************************************************************************** */
-    /* global Reflect, Promise */
-
-    var extendStatics = function(d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-
-    function __extends(d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    }
-
-    function __values(o) {
-        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-        if (m) return m.call(o);
-        if (o && typeof o.length === "number") return {
-            next: function () {
-                if (o && i >= o.length) o = void 0;
-                return { value: o && o[i++], done: !o };
-            }
-        };
-        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-    }
-
-    function __read(o, n) {
-        var m = typeof Symbol === "function" && o[Symbol.iterator];
-        if (!m) return o;
-        var i = m.call(o), r, ar = [], e;
-        try {
-            while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-        }
-        catch (error) { e = { error: error }; }
-        finally {
-            try {
-                if (r && !r.done && (m = i["return"])) m.call(i);
-            }
-            finally { if (e) throw e.error; }
-        }
-        return ar;
-    }
-
-    function __spreadArray(to, from) {
-        for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-            to[j] = from[i];
-        return to;
-    }
-
-    function isFunction$1(value) {
+    function isFunction(value) {
         return typeof value === 'function';
     }
 
@@ -3110,7 +3380,7 @@
                     }
                 }
                 var initialTeardown = this.initialTeardown;
-                if (isFunction$1(initialTeardown)) {
+                if (isFunction(initialTeardown)) {
                     try {
                         initialTeardown();
                     }
@@ -3202,10 +3472,10 @@
     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 {
@@ -3340,7 +3610,7 @@
         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) {
@@ -3450,16 +3720,20 @@
             var _this = this;
             promiseCtor = getPromiseCtor(promiseCtor);
             return new promiseCtor(function (resolve, reject) {
-                var subscription;
-                subscription = _this.subscribe(function (value) {
-                    try {
-                        next(value);
-                    }
-                    catch (err) {
-                        reject(err);
-                        subscription === null || subscription === void 0 ? void 0 : subscription.unsubscribe();
-                    }
-                }, reject, resolve);
+                var subscriber = new SafeSubscriber({
+                    next: function (value) {
+                        try {
+                            next(value);
+                        }
+                        catch (err) {
+                            reject(err);
+                            subscriber.unsubscribe();
+                        }
+                    },
+                    error: reject,
+                    complete: resolve,
+                });
+                _this.subscribe(subscriber);
             });
         };
         Observable.prototype._subscribe = function (subscriber) {
@@ -3494,7 +3768,7 @@
         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));
@@ -3652,364 +3926,13 @@
         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 = {};
-
-    object.isntEmptyObject = object.isEmptyObject = object.isRecord = object.isntObject = object.isObject = void 0;
-    function isObject(val) {
-        return val !== null && typeof val === 'object';
-    }
-    object.isObject = isObject;
-    function isntObject(val) {
-        return !isObject(val);
-    }
-    object.isntObject = isntObject;
-    function isRecord(val) {
-        return isObject(val);
-    }
-    object.isRecord = isRecord;
-    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.isRecord)(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.isRecord)(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.isRecord)(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.isRecord)(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.isRecord)(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);
-            this.stateChanged = new Subject();
+            this.stateChanges = new Subject();
         }
-        get stateChangedObservable() {
-            return this.stateChanged;
+        observeStateChanges() {
+            return this.stateChanges;
         }
         /**
          * @throws {BadEventError}
@@ -4018,9 +3941,9 @@
             const oldState = this.state;
             super.send(event);
             const newState = this.state;
-            this.stateChanged.next({ event, oldState, newState });
-            if (es2018.isEmptyObject(this.schema[newState])) {
-                this.stateChanged.complete();
+            this.stateChanges.next({ event, oldState, newState });
+            if (es2018$2.isEmptyObject(this.schema[newState])) {
+                this.stateChanges.complete();
             }
         }
     }