@blackglory/structures 0.2.8 → 0.3.3

package/dist/es2015/index.mjs

@@ -12,6 +12,61 @@ 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, 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");
@@ -180,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,
@@ -217,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 = {};
 
@@ -229,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) {
@@ -251,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');
@@ -311,298 +370,446 @@ 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$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;
     }
@@ -610,16 +817,16 @@ function isJson$1(val) {
         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;
@@ -628,7 +835,7 @@ function isAbsoluteURL$1(str) {
         return false;
     }
 }
-url$1.isAbsoluteURL = isAbsoluteURL$1;
+url.isAbsoluteURL = isAbsoluteURL;
 
 (function (exports) {
 var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -640,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 {
@@ -725,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');
@@ -747,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;
                 }
@@ -801,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');
@@ -836,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');
@@ -864,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');
@@ -880,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 {
@@ -964,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');
@@ -997,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 {
@@ -1044,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 {
@@ -1079,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');
@@ -1102,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) {
@@ -1118,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');
@@ -1145,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 {
@@ -1186,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');
@@ -1221,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');
@@ -1256,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');
@@ -1279,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');
@@ -1319,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 {
@@ -1402,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');
@@ -1423,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');
@@ -1453,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');
@@ -1482,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 {
@@ -1529,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');
@@ -1549,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 {
@@ -1632,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 {
@@ -1701,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";
@@ -1715,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 {
@@ -1861,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 {
@@ -1901,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 {
@@ -1947,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 {
@@ -2071,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 {
@@ -2082,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 {
@@ -2104,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 {
@@ -2167,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 {
@@ -2214,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 {
@@ -2400,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) {
@@ -2458,11 +2794,11 @@ class LRUMap {
     }
 }
 
-var es2018$2 = {};
+var es2018$1 = {};
 
 var exponentialBackoff = {};
 
-var es2018$1 = {};
+var es2018 = {};
 
 var random$1 = {};
 
@@ -2506,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) {
@@ -2624,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 {
@@ -2714,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();
                 });
@@ -2845,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();
                 });
@@ -2970,73 +3306,7 @@ class BadEventError extends es2018$6.CustomError {
     }
 }
 
-/*! *****************************************************************************
-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';
 }
 
@@ -3104,7 +3374,7 @@ var Subscription = (function () {
                 }
             }
             var initialTeardown = this.initialTeardown;
-            if (isFunction$1(initialTeardown)) {
+            if (isFunction(initialTeardown)) {
                 try {
                     initialTeardown();
                 }
@@ -3196,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 {
@@ -3334,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) {
@@ -3444,16 +3714,20 @@ var Observable = (function () {
         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) {
@@ -3488,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));
@@ -3646,364 +3920,13 @@ 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 = {};
-
-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}
@@ -4012,9 +3935,9 @@ class ObservableFiniteStateMachine extends FiniteStateMachine {
         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();
         }
     }
 }