@blackglory/structures 0.2.5 → 0.3.0

package/dist/es2018/index.mjs

@@ -1,12 +1,3 @@
-function convertConsToArray([value, next]) {
-    if (next === null)
-        return [value];
-    return [value, ...convertConsToArray(next)];
-}
-function convertArrayToCons([value, ...next]) {
-    return [value, next.length ? convertArrayToCons(next) : null];
-}
-
 /*! *****************************************************************************
 Copyright (c) Microsoft Corporation.
 
@@ -35,6 +26,30 @@ function __classPrivateFieldSet(receiver, state, value, kind, f) {
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 }
 
+var _Box_value;
+class Box {
+    constructor(value) {
+        _Box_value.set(this, void 0);
+        __classPrivateFieldSet(this, _Box_value, value, "f");
+    }
+    set(value) {
+        __classPrivateFieldSet(this, _Box_value, value, "f");
+    }
+    get() {
+        return __classPrivateFieldGet(this, _Box_value, "f");
+    }
+}
+_Box_value = new WeakMap();
+
+function convertConsToArray([value, next]) {
+    if (next === null)
+        return [value];
+    return [value, ...convertConsToArray(next)];
+}
+function convertArrayToCons([value, ...next]) {
+    return [value, next.length ? convertArrayToCons(next) : null];
+}
+
 var _Emitter_map;
 class Emitter {
     constructor() {
@@ -163,7 +178,7 @@ class Queue {
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
-var es2018$4 = {};
+var es2018$6 = {};
 
 var customError = {};
 
@@ -241,15 +256,15 @@ __exportStar(normalize$1, exports);
 __exportStar(refute$1, exports);
 __exportStar(assert$1, exports);
 
-}(es2018$4));
+}(es2018$6));
 
-var es2018$3 = {};
+var es2018$5 = {};
 
 var middleware = {};
 
 var chunkAsync$1 = {};
 
-var es2018$2 = {};
+var es2018$4 = {};
 
 var go$1 = {};
 
@@ -271,15 +286,15 @@ 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(go$1, exports);
 
-}(es2018$2));
+}(es2018$4));
 
 chunkAsync$1.chunkAsync = void 0;
-const go_1$f = es2018$2;
-const errors_1$f = es2018$4;
+const go_1$f = es2018$4;
+const errors_1$f = es2018$6;
 function chunkAsync(iterable, size) {
-    errors_1$f.assert(Number.isInteger(size), 'The parameter size must be an integer');
-    errors_1$f.assert(size > 0, 'The parameter size must be greater than 0');
-    return go_1$f.go(async function* () {
+    (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');
+    return (0, go_1$f.go)(async function* () {
         let buffer = [];
         for await (const element of iterable) {
             buffer.push(element);
@@ -296,285 +311,297 @@ chunkAsync$1.chunkAsync = chunkAsync;
 
 var chunkByAsync$1 = {};
 
-var es2018$1 = {};
+var es2018$3 = {};
 
-var array = {};
+var array$1 = {};
 
-array.isntEmptyArray = array.isEmptyArray = array.isntArray = array.isArray = void 0;
-function isArray(val) {
+array$1.isntEmptyArray = array$1.isEmptyArray = array$1.isntArray = array$1.isArray = void 0;
+function isArray$1(val) {
     return Array.isArray(val);
 }
-array.isArray = isArray;
-function isntArray(val) {
-    return !isArray(val);
+array$1.isArray = isArray$1;
+function isntArray$1(val) {
+    return !isArray$1(val);
 }
-array.isntArray = isntArray;
-function isEmptyArray(val) {
+array$1.isntArray = isntArray$1;
+function isEmptyArray$1(val) {
     return val.length === 0;
 }
-array.isEmptyArray = isEmptyArray;
-function isntEmptyArray(val) {
+array$1.isEmptyArray = isEmptyArray$1;
+function isntEmptyArray$1(val) {
     return val.length !== 0;
 }
-array.isntEmptyArray = isntEmptyArray;
+array$1.isntEmptyArray = isntEmptyArray$1;
 
-var asyncIterable = {};
+var asyncIterable$1 = {};
 
-var _null = {};
+var _null$1 = {};
 
-_null.isntNull = _null.isNull = void 0;
-function isNull(val) {
+_null$1.isntNull = _null$1.isNull = void 0;
+function isNull$1(val) {
     return val === null;
 }
-_null.isNull = isNull;
-function isntNull(val) {
-    return !isNull(val);
+_null$1.isNull = isNull$1;
+function isntNull$1(val) {
+    return !isNull$1(val);
 }
-_null.isntNull = isntNull;
+_null$1.isntNull = isntNull$1;
 
-var _undefined = {};
+var _undefined$1 = {};
 
-_undefined.isntUndefined = _undefined.isUndefined = void 0;
-function isUndefined(val) {
+_undefined$1.isntUndefined = _undefined$1.isUndefined = void 0;
+function isUndefined$1(val) {
     return val === undefined;
 }
-_undefined.isUndefined = isUndefined;
-function isntUndefined(val) {
-    return !isUndefined(val);
+_undefined$1.isUndefined = isUndefined$1;
+function isntUndefined$1(val) {
+    return !isUndefined$1(val);
 }
-_undefined.isntUndefined = isntUndefined;
+_undefined$1.isntUndefined = isntUndefined$1;
 
-asyncIterable.isntAsyncIterable = asyncIterable.isAsyncIterable = void 0;
-const null_1$1 = _null;
-const undefined_1$2 = _undefined;
-function isAsyncIterable(val) {
-    return null_1$1.isntNull(val)
-        && undefined_1$2.isntUndefined(val)
+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)
         && typeof val[Symbol.asyncIterator] === 'function';
 }
-asyncIterable.isAsyncIterable = isAsyncIterable;
-function isntAsyncIterable(val) {
-    return !isAsyncIterable(val);
+asyncIterable$1.isAsyncIterable = isAsyncIterable$1;
+function isntAsyncIterable$1(val) {
+    return !isAsyncIterable$1(val);
 }
-asyncIterable.isntAsyncIterable = isntAsyncIterable;
+asyncIterable$1.isntAsyncIterable = isntAsyncIterable$1;
 
-var bigint = {};
+var bigint$1 = {};
 
-bigint.isntBigInt = bigint.isBigInt = void 0;
-function isBigInt(val) {
+bigint$1.isntBigInt = bigint$1.isBigInt = void 0;
+function isBigInt$1(val) {
     return typeof val === 'bigint';
 }
-bigint.isBigInt = isBigInt;
-function isntBigInt(val) {
-    return !isBigInt(val);
+bigint$1.isBigInt = isBigInt$1;
+function isntBigInt$1(val) {
+    return !isBigInt$1(val);
 }
-bigint.isntBigInt = isntBigInt;
+bigint$1.isntBigInt = isntBigInt$1;
 
-var boolean = {};
+var boolean$1 = {};
 
-boolean.isntBoolean = boolean.isBoolean = void 0;
-function isBoolean(val) {
+boolean$1.isntBoolean = boolean$1.isBoolean = void 0;
+function isBoolean$1(val) {
     return typeof val === 'boolean';
 }
-boolean.isBoolean = isBoolean;
-function isntBoolean(val) {
-    return !isBoolean(val);
+boolean$1.isBoolean = isBoolean$1;
+function isntBoolean$1(val) {
+    return !isBoolean$1(val);
 }
-boolean.isntBoolean = isntBoolean;
+boolean$1.isntBoolean = isntBoolean$1;
 
-var char = {};
+var char$1 = {};
 
-var string = {};
+var string$1 = {};
 
-string.isntString = string.isString = void 0;
-function isString(val) {
+string$1.isntString = string$1.isString = void 0;
+function isString$1(val) {
     return typeof val === 'string';
 }
-string.isString = isString;
-function isntString(val) {
-    return !isString(val);
+string$1.isString = isString$1;
+function isntString$1(val) {
+    return !isString$1(val);
 }
-string.isntString = isntString;
+string$1.isntString = isntString$1;
 
-char.isntChar = char.isChar = void 0;
-const string_1$1 = string;
-function isChar(val) {
-    return string_1$1.isString(val)
+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)
         && val.length === 1;
 }
-char.isChar = isChar;
-function isntChar(val) {
-    return !isChar(val);
+char$1.isChar = isChar$1;
+function isntChar$1(val) {
+    return !isChar$1(val);
 }
-char.isntChar = isntChar;
+char$1.isntChar = isntChar$1;
 
-var date = {};
+var date$1 = {};
 
-date.isntDate = date.isDate = void 0;
-function isDate(val) {
+date$1.isntDate = date$1.isDate = void 0;
+function isDate$1(val) {
     return val instanceof Date;
 }
-date.isDate = isDate;
-function isntDate(val) {
-    return !isDate(val);
+date$1.isDate = isDate$1;
+function isntDate$1(val) {
+    return !isDate$1(val);
 }
-date.isntDate = isntDate;
+date$1.isntDate = isntDate$1;
 
-var _enum = {};
+var _enum$1 = {};
 
-_enum.inEnum = void 0;
-function inEnum(val, _enum) {
+_enum$1.inEnum = void 0;
+function inEnum$1(val, _enum) {
     return Object.values(_enum).includes(val);
 }
-_enum.inEnum = inEnum;
+_enum$1.inEnum = inEnum$1;
 
-var falsy = {};
+var error$1 = {};
 
-falsy.isntFalsy = falsy.isFalsy = void 0;
-function isFalsy(val) {
+error$1.isntError = error$1.isError = void 0;
+function isError$1(val) {
+    return val instanceof Error;
+}
+error$1.isError = isError$1;
+function isntError$1(val) {
+    return !isError$1(val);
+}
+error$1.isntError = isntError$1;
+
+var falsy$1 = {};
+
+falsy$1.isntFalsy = falsy$1.isFalsy = void 0;
+function isFalsy$1(val) {
     return !val;
 }
-falsy.isFalsy = isFalsy;
-function isntFalsy(val) {
-    return !isFalsy(val);
+falsy$1.isFalsy = isFalsy$1;
+function isntFalsy$1(val) {
+    return !isFalsy$1(val);
 }
-falsy.isntFalsy = isntFalsy;
+falsy$1.isntFalsy = isntFalsy$1;
 
-var _function = {};
+var _function$1 = {};
 
-_function.isntFunction = _function.isFunction = void 0;
-function isFunction(val) {
+_function$1.isntFunction = _function$1.isFunction = void 0;
+function isFunction$2(val) {
     return typeof val === 'function';
 }
-_function.isFunction = isFunction;
-function isntFunction(val) {
-    return !isFunction(val);
+_function$1.isFunction = isFunction$2;
+function isntFunction$1(val) {
+    return !isFunction$2(val);
 }
-_function.isntFunction = isntFunction;
+_function$1.isntFunction = isntFunction$1;
 
-var iterable = {};
+var iterable$1 = {};
 
-iterable.isntIterable = iterable.isIterable = void 0;
-const null_1 = _null;
-const undefined_1$1 = _undefined;
-function isIterable(val) {
-    return null_1.isntNull(val)
-        && undefined_1$1.isntUndefined(val)
+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)
         && typeof val[Symbol.iterator] === 'function';
 }
-iterable.isIterable = isIterable;
-function isntIterable(val) {
-    return !isIterable(val);
+iterable$1.isIterable = isIterable$1;
+function isntIterable$1(val) {
+    return !isIterable$1(val);
 }
-iterable.isntIterable = isntIterable;
+iterable$1.isntIterable = isntIterable$1;
 
-var jsonRpc = {};
+var jsonRpc$1 = {};
 
-var object = {};
+var object$1 = {};
 
-object.isntEmptyObject = object.isEmptyObject = object.isRecord = object.isntObject = object.isObject = void 0;
-function isObject(val) {
+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.isObject = isObject;
-function isntObject(val) {
-    return !isObject(val);
+object$1.isObject = isObject$1;
+function isntObject$1(val) {
+    return !isObject$1(val);
 }
-object.isntObject = isntObject;
-function isRecord(val) {
-    return isObject(val);
+object$1.isntObject = isntObject$1;
+function isRecord$1(val) {
+    return isObject$1(val);
 }
-object.isRecord = isRecord;
-function isEmptyObject(val) {
+object$1.isRecord = isRecord$1;
+function isEmptyObject$1(val) {
     return Object.keys(val).length === 0;
 }
-object.isEmptyObject = isEmptyObject;
-function isntEmptyObject(val) {
+object$1.isEmptyObject = isEmptyObject$1;
+function isntEmptyObject$1(val) {
     return Object.keys(val).length !== 0;
 }
-object.isntEmptyObject = isntEmptyObject;
+object$1.isntEmptyObject = isntEmptyObject$1;
 
-var number = {};
+var number$1 = {};
 
-number.isntNumber = number.isNumber = void 0;
-function isNumber(val) {
+number$1.isntNumber = number$1.isNumber = void 0;
+function isNumber$1(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 string_1.isString(val) || number_1.isNumber(val);
-}
-function isJsonRpcParams(val) {
-    return array_1.isArray(val) || object_1.isObject(val);
-}
-function isJsonRpcNotification(val) {
-    return object_1.isRecord(val)
-        && string_1.isString(val.jsonrpc)
-        && string_1.isString(val.method)
-        && undefined_1.isUndefined(val.id)
-        && isJsonRpcParams(val.params);
-}
-jsonRpc.isJsonRpcNotification = isJsonRpcNotification;
-function isntJsonRpcNotification(val) {
-    return !isJsonRpcNotification(val);
-}
-jsonRpc.isntJsonRpcNotification = isntJsonRpcNotification;
-function isJsonRpcRequest(val) {
-    return object_1.isRecord(val)
-        && string_1.isString(val.jsonrpc)
-        && 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 object_1.isRecord(val)
-        && string_1.isString(val.jsonrpc)
-        && string_1.isString(val.id)
-        && undefined_1.isntUndefined(val.result);
-}
-jsonRpc.isJsonRpcSuccess = isJsonRpcSuccess;
-function isntJsonRpcSuccess(val) {
-    return !isJsonRpcSuccess(val);
-}
-jsonRpc.isntJsonRpcSuccess = isntJsonRpcSuccess;
-function isJsonRpcError(val) {
-    return object_1.isRecord(val)
-        && 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 object_1.isRecord(val)
-        && number_1.isNumber(val.code)
-        && string_1.isString(val.message)
-        && (undefined_1.isUndefined(val.data) || object_1.isObject(val.data));
-}
-
-var json = {};
-
-json.isntJson = json.isJson = void 0;
-function isJson(val) {
+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 {
         JSON.stringify(val);
         return true;
@@ -583,16 +610,16 @@ function isJson(val) {
         return false;
     }
 }
-json.isJson = isJson;
-function isntJson(val) {
-    return !isntJson();
+json$1.isJson = isJson$1;
+function isntJson$1(val) {
+    return !isntJson$1();
 }
-json.isntJson = isntJson;
+json$1.isntJson = isntJson$1;
 
-var url = {};
+var url$1 = {};
 
-url.isAbsoluteURL = void 0;
-function isAbsoluteURL(str) {
+url$1.isAbsoluteURL = void 0;
+function isAbsoluteURL$1(str) {
     try {
         new URL(str);
         return true;
@@ -601,7 +628,7 @@ function isAbsoluteURL(str) {
         return false;
     }
 }
-url.isAbsoluteURL = isAbsoluteURL;
+url$1.isAbsoluteURL = isAbsoluteURL$1;
 
 (function (exports) {
 var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -613,31 +640,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, exports);
-__exportStar(asyncIterable, exports);
-__exportStar(bigint, exports);
-__exportStar(boolean, exports);
-__exportStar(char, exports);
-__exportStar(date, exports);
-__exportStar(_enum, 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);
+};__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);
 
-}(es2018$1));
+}(es2018$3));
 
 chunkByAsync$1.chunkByAsync = void 0;
-const types_1$h = es2018$1;
+const types_1$h = es2018$3;
 function chunkByAsync(iterable, predicate) {
-    if (types_1$h.isAsyncIterable(iterable)) {
+    if ((0, types_1$h.isAsyncIterable)(iterable)) {
         return chunkByAsyncIterable(iterable);
     }
     else {
@@ -696,12 +724,12 @@ chunkBy$1.chunkBy = chunkBy;
 var chunk$1 = {};
 
 chunk$1.chunk = void 0;
-const go_1$e = es2018$2;
-const errors_1$e = es2018$4;
+const go_1$e = es2018$4;
+const errors_1$e = es2018$6;
 function chunk(iterable, size) {
-    errors_1$e.assert(Number.isInteger(size), 'The parameter size must be an integer');
-    errors_1$e.assert(size > 0, 'The parameter size must be greater than 0');
-    return go_1$e.go(function* () {
+    (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');
+    return (0, go_1$e.go)(function* () {
         let buffer = [];
         for (const element of iterable) {
             buffer.push(element);
@@ -719,12 +747,12 @@ chunk$1.chunk = chunk;
 var concatAsync$1 = {};
 
 concatAsync$1.concatAsync = void 0;
-const types_1$g = es2018$1;
-const go_1$d = es2018$2;
+const types_1$g = es2018$3;
+const go_1$d = es2018$4;
 function concatAsync(iterable, ...otherIterables) {
-    return go_1$d.go(async function* () {
+    return (0, go_1$d.go)(async function* () {
         for (const iter of [iterable, ...otherIterables]) {
-            if (types_1$g.isAsyncIterable(iter)) {
+            if ((0, types_1$g.isAsyncIterable)(iter)) {
                 for await (const element of iter) {
                     yield element;
                 }
@@ -742,9 +770,9 @@ concatAsync$1.concatAsync = concatAsync;
 var concat$1 = {};
 
 concat$1.concat = void 0;
-const go_1$c = es2018$2;
+const go_1$c = es2018$4;
 function concat(iterable, ...otherIterables) {
-    return go_1$c.go(function* () {
+    return (0, go_1$c.go)(function* () {
         for (const iter of [iterable, ...otherIterables]) {
             yield* iter;
         }
@@ -771,15 +799,15 @@ function* copyIterable(iterable) {
 utils.copyIterable = copyIterable;
 
 dropAsync$1.dropAsync = void 0;
-const go_1$b = es2018$2;
+const go_1$b = es2018$4;
 const utils_1$3 = utils;
-const errors_1$d = es2018$4;
+const errors_1$d = es2018$6;
 function dropAsync(iterable, count) {
-    errors_1$d.assert(Number.isInteger(count), 'The parameter count must be an integer');
-    errors_1$d.assert(count >= 0, 'The parameter count must be greater than or equal to 0');
+    (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');
     if (count === 0)
-        return utils_1$3.copyAsyncIterable(iterable);
-    return go_1$b.go(async function* () {
+        return (0, utils_1$3.copyAsyncIterable)(iterable);
+    return (0, go_1$b.go)(async function* () {
         var _a;
         const iterator = iterable[Symbol.asyncIterator]();
         let done;
@@ -806,15 +834,15 @@ dropAsync$1.dropAsync = dropAsync;
 var dropRightAsync$1 = {};
 
 dropRightAsync$1.dropRightAsync = void 0;
-const go_1$a = es2018$2;
+const go_1$a = es2018$4;
 const utils_1$2 = utils;
-const errors_1$c = es2018$4;
+const errors_1$c = es2018$6;
 function dropRightAsync(iterable, count) {
-    errors_1$c.assert(Number.isInteger(count), 'The parameter count must be an integer');
-    errors_1$c.assert(count >= 0, 'The parameter count must be greater than or equal to 0');
+    (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');
     if (count === 0)
-        return utils_1$2.copyAsyncIterable(iterable);
-    return go_1$a.go(async function* () {
+        return (0, utils_1$2.copyAsyncIterable)(iterable);
+    return (0, go_1$a.go)(async function* () {
         const arr = await toArrayAsync$2(iterable);
         const result = arr.slice(0, -count);
         for (const value of result) {
@@ -834,15 +862,15 @@ async function toArrayAsync$2(iterable) {
 var dropRight$1 = {};
 
 dropRight$1.dropRight = void 0;
-const go_1$9 = es2018$2;
+const go_1$9 = es2018$4;
 const utils_1$1 = utils;
-const errors_1$b = es2018$4;
+const errors_1$b = es2018$6;
 function dropRight(iterable, count) {
-    errors_1$b.assert(Number.isInteger(count), 'The parameter count must be an integer');
-    errors_1$b.assert(count >= 0, 'The parameter count must be greater than or equal to 0');
+    (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');
     if (count === 0)
-        return utils_1$1.copyIterable(iterable);
-    return go_1$9.go(function* () {
+        return (0, utils_1$1.copyIterable)(iterable);
+    return (0, go_1$9.go)(function* () {
         const arr = Array.from(iterable);
         yield* arr.slice(0, -count);
     });
@@ -852,9 +880,9 @@ dropRight$1.dropRight = dropRight;
 var dropUntilAsync$1 = {};
 
 dropUntilAsync$1.dropUntilAsync = void 0;
-const types_1$f = es2018$1;
+const types_1$f = es2018$3;
 function dropUntilAsync(iterable, predicate) {
-    if (types_1$f.isAsyncIterable(iterable)) {
+    if ((0, types_1$f.isAsyncIterable)(iterable)) {
         return dropUntilAsyncIterable(iterable);
     }
     else {
@@ -934,15 +962,15 @@ dropUntil$1.dropUntil = dropUntil;
 var drop$1 = {};
 
 drop$1.drop = void 0;
-const go_1$8 = es2018$2;
+const go_1$8 = es2018$4;
 const utils_1 = utils;
-const errors_1$a = es2018$4;
+const errors_1$a = es2018$6;
 function drop(iterable, count) {
-    errors_1$a.assert(Number.isInteger(count), 'The parameter count must be an integer');
-    errors_1$a.assert(count >= 0, 'The parameter count must be greater than or equal to 0');
+    (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');
     if (count === 0)
-        return utils_1.copyIterable(iterable);
-    return go_1$8.go(function* () {
+        return (0, utils_1.copyIterable)(iterable);
+    return (0, go_1$8.go)(function* () {
         var _a;
         const iterator = iterable[Symbol.iterator]();
         let done;
@@ -969,9 +997,9 @@ drop$1.drop = drop;
 var filterAsync$1 = {};
 
 filterAsync$1.filterAsync = void 0;
-const types_1$e = es2018$1;
+const types_1$e = es2018$3;
 function filterAsync(iterable, predicate) {
-    if (types_1$e.isAsyncIterable(iterable)) {
+    if ((0, types_1$e.isAsyncIterable)(iterable)) {
         return filterAsyncIterable(iterable);
     }
     else {
@@ -1016,9 +1044,9 @@ var flattenDeepAsync$1 = {};
 var flattenByAsync$1 = {};
 
 flattenByAsync$1.flattenByAsync = void 0;
-const types_1$d = es2018$1;
+const types_1$d = es2018$3;
 function flattenByAsync(iterable, predicate) {
-    if (types_1$d.isAsyncIterable(iterable)) {
+    if ((0, types_1$d.isAsyncIterable)(iterable)) {
         return flattenByAsyncIterable(iterable);
     }
     else {
@@ -1051,30 +1079,30 @@ function flattenByAsync(iterable, predicate) {
 }
 flattenByAsync$1.flattenByAsync = flattenByAsync;
 function isFiniteIterable$1(val) {
-    return types_1$d.isIterable(val) && types_1$d.isntChar(val);
+    return (0, types_1$d.isIterable)(val) && (0, types_1$d.isntChar)(val);
 }
 
 flattenDeepAsync$1.flattenDeepAsync = void 0;
 const flatten_by_async_1 = flattenByAsync$1;
-const errors_1$9 = es2018$4;
+const errors_1$9 = es2018$6;
 function flattenDeepAsync(iterable, depth = Infinity) {
-    errors_1$9.assert(depth === Infinity || Number.isInteger(depth), 'The parameter depth must be an integer');
-    errors_1$9.assert(depth >= 0, 'The parameter depth must be greater than or equal to 0');
-    return flatten_by_async_1.flattenByAsync(iterable, (_, level) => level <= depth);
+    (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');
+    return (0, flatten_by_async_1.flattenByAsync)(iterable, (_, level) => level <= depth);
 }
 flattenDeepAsync$1.flattenDeepAsync = flattenDeepAsync;
 
 flattenAsync$1.flattenAsync = void 0;
 const flatten_deep_async_1 = flattenDeepAsync$1;
 function flattenAsync(iterable) {
-    return flatten_deep_async_1.flattenDeepAsync(iterable, 1);
+    return (0, flatten_deep_async_1.flattenDeepAsync)(iterable, 1);
 }
 flattenAsync$1.flattenAsync = flattenAsync;
 
 var flattenBy$1 = {};
 
 flattenBy$1.flattenBy = void 0;
-const types_1$c = es2018$1;
+const types_1$c = es2018$3;
 function flattenBy(iterable, predicate) {
     return flatten(iterable, 1);
     function* flatten(iterable, level) {
@@ -1090,18 +1118,18 @@ function flattenBy(iterable, predicate) {
 }
 flattenBy$1.flattenBy = flattenBy;
 function isFiniteIterable(val) {
-    return types_1$c.isIterable(val) && types_1$c.isntChar(val);
+    return (0, types_1$c.isIterable)(val) && (0, types_1$c.isntChar)(val);
 }
 
 var flattenDeep$1 = {};
 
 flattenDeep$1.flattenDeep = void 0;
 const flatten_by_1 = flattenBy$1;
-const errors_1$8 = es2018$4;
+const errors_1$8 = es2018$6;
 function flattenDeep(iterable, depth = Infinity) {
-    errors_1$8.assert(depth === Infinity || Number.isInteger(depth), 'The parameter depth must be an integer');
-    errors_1$8.assert(depth >= 0, 'The parameter depth must be greater than or equal to 0');
-    return flatten_by_1.flattenBy(iterable, (_, level) => level <= depth);
+    (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');
+    return (0, flatten_by_1.flattenBy)(iterable, (_, level) => level <= depth);
 }
 flattenDeep$1.flattenDeep = flattenDeep;
 
@@ -1110,16 +1138,16 @@ var flatten$1 = {};
 flatten$1.flatten = void 0;
 const flatten_deep_1 = flattenDeep$1;
 function flatten(iterable) {
-    return flatten_deep_1.flattenDeep(iterable, 1);
+    return (0, flatten_deep_1.flattenDeep)(iterable, 1);
 }
 flatten$1.flatten = flatten;
 
 var mapAsync$1 = {};
 
 mapAsync$1.mapAsync = void 0;
-const types_1$b = es2018$1;
+const types_1$b = es2018$3;
 function mapAsync(iterable, fn) {
-    if (types_1$b.isAsyncIterable(iterable)) {
+    if ((0, types_1$b.isAsyncIterable)(iterable)) {
         return mapAsyncIterable(iterable);
     }
     else {
@@ -1157,14 +1185,14 @@ map$1.map = map;
 var repeatAsync$1 = {};
 
 repeatAsync$1.repeatAsync = void 0;
-const go_1$7 = es2018$2;
-const errors_1$7 = es2018$4;
+const go_1$7 = es2018$4;
+const errors_1$7 = es2018$6;
 function repeatAsync(iterable, times) {
-    errors_1$7.assert(times === Infinity || Number.isInteger(times), 'The parameter times must be an integer');
-    errors_1$7.assert(times >= 0, 'The parameter times must be greater than or equal to 0');
+    (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');
     if (times === Infinity)
         warnInfiniteLoop$1();
-    return go_1$7.go(async function* () {
+    return (0, go_1$7.go)(async function* () {
         const cache = [];
         if (times > 0) {
             for await (const element of iterable) {
@@ -1192,14 +1220,14 @@ function isProduction$1() {
 var repeat$1 = {};
 
 repeat$1.repeat = void 0;
-const go_1$6 = es2018$2;
-const errors_1$6 = es2018$4;
+const go_1$6 = es2018$4;
+const errors_1$6 = es2018$6;
 function repeat(iterable, times) {
-    errors_1$6.assert(times === Infinity || Number.isInteger(times), 'The parameter times must be an integer');
-    errors_1$6.assert(times >= 0, 'The parameter times must be greater than or equal to 0');
+    (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');
     if (times === Infinity)
         warnInfiniteLoop();
-    return go_1$6.go(function* () {
+    return (0, go_1$6.go)(function* () {
         const cache = [];
         if (times > 0) {
             for (const element of iterable) {
@@ -1227,14 +1255,14 @@ function isProduction() {
 var sliceAsync$1 = {};
 
 sliceAsync$1.sliceAsync = void 0;
-const go_1$5 = es2018$2;
-const errors_1$5 = es2018$4;
+const go_1$5 = es2018$4;
+const errors_1$5 = es2018$6;
 function sliceAsync(iterable, start, end = Infinity) {
-    errors_1$5.assert(Number.isInteger(start), 'The parameter start must be an integer');
-    errors_1$5.assert(start >= 0, 'The parameter start must be greater than or equal to 0');
-    errors_1$5.assert(Number.isInteger(end), 'The parameter end must be an integer');
-    errors_1$5.assert(end >= start, 'The parameter end must be greater than or equal to start');
-    return go_1$5.go(async function* () {
+    (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');
+    (0, errors_1$5.assert)(Number.isInteger(end), 'The parameter end must be an integer');
+    (0, errors_1$5.assert)(end >= start, 'The parameter end must be greater than or equal to start');
+    return (0, go_1$5.go)(async function* () {
         let index = 0;
         for await (const element of iterable) {
             if (index >= end)
@@ -1250,14 +1278,14 @@ sliceAsync$1.sliceAsync = sliceAsync;
 var slice$1 = {};
 
 slice$1.slice = void 0;
-const go_1$4 = es2018$2;
-const errors_1$4 = es2018$4;
+const go_1$4 = es2018$4;
+const errors_1$4 = es2018$6;
 function slice(iterable, start, end = Infinity) {
-    errors_1$4.assert(Number.isInteger(start), 'The parameter start must be an integer');
-    errors_1$4.assert(start >= 0, 'The parameter start must be greater than or equal to 0');
-    errors_1$4.assert(Number.isInteger(end), 'The parameter end must be an integer');
-    errors_1$4.assert(end >= start, 'The parameter end must be greater than or equal to start');
-    return go_1$4.go(function* () {
+    (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');
+    (0, errors_1$4.assert)(Number.isInteger(end), 'The parameter end must be an integer');
+    (0, errors_1$4.assert)(end >= start, 'The parameter end must be greater than or equal to start');
+    return (0, go_1$4.go)(function* () {
         let index = 0;
         for (const element of iterable) {
             if (index >= end)
@@ -1291,9 +1319,9 @@ splitAsync$1.splitAsync = splitAsync;
 var splitByAsync$1 = {};
 
 splitByAsync$1.splitByAsync = void 0;
-const types_1$a = es2018$1;
+const types_1$a = es2018$3;
 function splitByAsync(iterable, predicate) {
-    if (types_1$a.isAsyncIterable(iterable)) {
+    if ((0, types_1$a.isAsyncIterable)(iterable)) {
         return splitByAsyncIterable(iterable);
     }
     else {
@@ -1373,12 +1401,12 @@ split$1.split = split;
 var takeAsync$1 = {};
 
 takeAsync$1.takeAsync = void 0;
-const go_1$3 = es2018$2;
-const errors_1$3 = es2018$4;
+const go_1$3 = es2018$4;
+const errors_1$3 = es2018$6;
 function takeAsync(iterable, count) {
-    errors_1$3.assert(Number.isInteger(count), 'The parameter count must be an integer');
-    errors_1$3.assert(count >= 0, 'The parameter count must be greater than or equal to 0');
-    return go_1$3.go(async function* () {
+    (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');
+    return (0, go_1$3.go)(async function* () {
         if (count === 0)
             return;
         for await (const element of iterable) {
@@ -1394,12 +1422,12 @@ takeAsync$1.takeAsync = takeAsync;
 var takeRightAsync$1 = {};
 
 takeRightAsync$1.takeRightAsync = void 0;
-const go_1$2 = es2018$2;
-const errors_1$2 = es2018$4;
+const go_1$2 = es2018$4;
+const errors_1$2 = es2018$6;
 function takeRightAsync(iterable, count) {
-    errors_1$2.assert(Number.isInteger(count), 'The parameter count must be an integer');
-    errors_1$2.assert(count >= 0, 'The parameter count must be greater than or equal to 0');
-    return go_1$2.go(async function* () {
+    (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');
+    return (0, go_1$2.go)(async function* () {
         var _a;
         const iterator = iterable[Symbol.asyncIterator]();
         let done;
@@ -1424,12 +1452,12 @@ takeRightAsync$1.takeRightAsync = takeRightAsync;
 var takeRight$1 = {};
 
 takeRight$1.takeRight = void 0;
-const go_1$1 = es2018$2;
-const errors_1$1 = es2018$4;
+const go_1$1 = es2018$4;
+const errors_1$1 = es2018$6;
 function takeRight(iterable, count) {
-    errors_1$1.assert(Number.isInteger(count), 'The parameter count must be an integer');
-    errors_1$1.assert(count >= 0, 'The parameter count must be greater than or equal to 0');
-    return go_1$1.go(function* () {
+    (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');
+    return (0, go_1$1.go)(function* () {
         var _a;
         const iterator = iterable[Symbol.iterator]();
         let done;
@@ -1454,9 +1482,9 @@ takeRight$1.takeRight = takeRight;
 var takeUntilAsync$1 = {};
 
 takeUntilAsync$1.takeUntilAsync = void 0;
-const types_1$9 = es2018$1;
+const types_1$9 = es2018$3;
 function takeUntilAsync(iterable, predicate) {
-    if (types_1$9.isAsyncIterable(iterable)) {
+    if ((0, types_1$9.isAsyncIterable)(iterable)) {
         return takeUntilAsyncIterable(iterable);
     }
     else {
@@ -1500,12 +1528,12 @@ takeUntil$1.takeUntil = takeUntil;
 var take$1 = {};
 
 take$1.take = void 0;
-const go_1 = es2018$2;
-const errors_1 = es2018$4;
+const go_1 = es2018$4;
+const errors_1 = es2018$6;
 function take(iterable, count) {
-    errors_1.assert(Number.isInteger(count), 'The parameter count must be an integer');
-    errors_1.assert(count >= 0, 'The parameter count must be greater than or equal to 0');
-    return go_1.go(function* () {
+    (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');
+    return (0, go_1.go)(function* () {
         if (count === 0)
             return;
         for (const element of iterable) {
@@ -1521,9 +1549,9 @@ take$1.take = take;
 var tapAsync$1 = {};
 
 tapAsync$1.tapAsync = void 0;
-const types_1$8 = es2018$1;
+const types_1$8 = es2018$3;
 function tapAsync(iterable, fn) {
-    if (types_1$8.isAsyncIterable(iterable)) {
+    if ((0, types_1$8.isAsyncIterable)(iterable)) {
         return tapAsyncIterable(iterable);
     }
     else {
@@ -1604,9 +1632,9 @@ uniqAsync$1.uniqAsync = uniqAsync;
 var uniqByAsync$1 = {};
 
 uniqByAsync$1.uniqByAsync = void 0;
-const types_1$7 = es2018$1;
+const types_1$7 = es2018$3;
 function uniqByAsync(iterable, fn) {
-    if (types_1$7.isAsyncIterable(iterable)) {
+    if ((0, types_1$7.isAsyncIterable)(iterable)) {
         return uniqByAsyncIterable(iterable);
     }
     else {
@@ -1673,7 +1701,7 @@ uniq$1.uniq = uniq;
 var zipAsync$1 = {};
 
 zipAsync$1.zipAsync = void 0;
-const types_1$6 = es2018$1;
+const types_1$6 = es2018$3;
 var Kind;
 (function (Kind) {
     Kind[Kind["Sync"] = 0] = "Sync";
@@ -1687,7 +1715,7 @@ async function* zipWithSize$1(...iterables) {
     var _a, _b, _c, _d;
     const length = iterables.length;
     const iterators = iterables.map(iterable => {
-        if (types_1$6.isAsyncIterable(iterable)) {
+        if ((0, types_1$6.isAsyncIterable)(iterable)) {
             return [Kind.Async, iterable[Symbol.asyncIterator]()];
         }
         else {
@@ -1833,9 +1861,9 @@ consume$1.consume = consume;
 var eachAsync$1 = {};
 
 eachAsync$1.eachAsync = void 0;
-const types_1$5 = es2018$1;
+const types_1$5 = es2018$3;
 function eachAsync(iterable, fn) {
-    if (types_1$5.isAsyncIterable(iterable)) {
+    if ((0, types_1$5.isAsyncIterable)(iterable)) {
         return eachAsyncIterable(iterable);
     }
     else {
@@ -1873,9 +1901,9 @@ each$1.each = each;
 var everyAsync$1 = {};
 
 everyAsync$1.everyAsync = void 0;
-const types_1$4 = es2018$1;
+const types_1$4 = es2018$3;
 function everyAsync(iterable, predicate) {
-    if (types_1$4.isAsyncIterable(iterable)) {
+    if ((0, types_1$4.isAsyncIterable)(iterable)) {
         return everyAsyncIterable(iterable);
     }
     else {
@@ -1919,9 +1947,9 @@ every$1.every = every;
 var findAsync$1 = {};
 
 findAsync$1.findAsync = void 0;
-const types_1$3 = es2018$1;
+const types_1$3 = es2018$3;
 function findAsync(iterable, predicate) {
-    if (types_1$3.isAsyncIterable(iterable)) {
+    if ((0, types_1$3.isAsyncIterable)(iterable)) {
         return findAsyncIterable(iterable);
     }
     else {
@@ -2043,9 +2071,9 @@ match$1.match = match;
 var reduceAsync$1 = {};
 
 reduceAsync$1.reduceAsync = void 0;
-const types_1$2 = es2018$1;
+const types_1$2 = es2018$3;
 function reduceAsync(iterable, fn, initialValue) {
-    if (types_1$2.isUndefined(initialValue)) {
+    if ((0, types_1$2.isUndefined)(initialValue)) {
         return reduceAsyncWithoutInitialValue(iterable, fn);
     }
     else {
@@ -2054,7 +2082,7 @@ function reduceAsync(iterable, fn, initialValue) {
 }
 reduceAsync$1.reduceAsync = reduceAsync;
 function reduceAsyncWithInitialValue(iterable, fn, initialValue) {
-    if (types_1$2.isAsyncIterable(iterable)) {
+    if ((0, types_1$2.isAsyncIterable)(iterable)) {
         return reduceAsyncIterable(iterable);
     }
     else {
@@ -2076,7 +2104,7 @@ function reduceAsyncWithInitialValue(iterable, fn, initialValue) {
     }
 }
 function reduceAsyncWithoutInitialValue(iterable, fn) {
-    if (types_1$2.isAsyncIterable(iterable)) {
+    if ((0, types_1$2.isAsyncIterable)(iterable)) {
         return reduceAsyncIterable(iterable);
     }
     else {
@@ -2139,9 +2167,9 @@ function reduceAsyncWithoutInitialValue(iterable, fn) {
 var reduce$1 = {};
 
 reduce$1.reduce = void 0;
-const types_1$1 = es2018$1;
+const types_1$1 = es2018$3;
 function reduce(iterable, fn, initialValue) {
-    if (types_1$1.isUndefined(initialValue)) {
+    if ((0, types_1$1.isUndefined)(initialValue)) {
         return reduceWithoutInitialValue(iterable, fn);
     }
     else {
@@ -2186,9 +2214,9 @@ function reduceWithoutInitialValue(iterable, fn) {
 var someAsync$1 = {};
 
 someAsync$1.someAsync = void 0;
-const types_1 = es2018$1;
+const types_1 = es2018$3;
 function someAsync(iterable, predicate) {
-    if (types_1.isAsyncIterable(iterable)) {
+    if ((0, types_1.isAsyncIterable)(iterable)) {
         return someAsyncIterable(iterable);
     }
     else {
@@ -2278,7 +2306,7 @@ var toArrayAsync$1 = {};
 toArrayAsync$1.toArrayAsync = void 0;
 const consume_1$3 = consume$1;
 function toArrayAsync(iterable) {
-    return consume_1$3.consume(iterable, async (iterable) => {
+    return (0, consume_1$3.consume)(iterable, async (iterable) => {
         const result = [];
         for await (const element of iterable) {
             result.push(element);
@@ -2293,7 +2321,7 @@ var toArray$1 = {};
 toArray$1.toArray = void 0;
 const consume_1$2 = consume$1;
 function toArray(iterable) {
-    return consume_1$2.consume(iterable, iterable => Array.from(iterable));
+    return (0, consume_1$2.consume)(iterable, iterable => Array.from(iterable));
 }
 toArray$1.toArray = toArray;
 
@@ -2302,7 +2330,7 @@ var toSetAsync$1 = {};
 toSetAsync$1.toSetAsync = void 0;
 const consume_1$1 = consume$1;
 function toSetAsync(iterable) {
-    return consume_1$1.consume(iterable, async (iterable) => {
+    return (0, consume_1$1.consume)(iterable, async (iterable) => {
         const result = new Set();
         for await (const element of iterable) {
             result.add(element);
@@ -2317,7 +2345,7 @@ var toSet$1 = {};
 toSet$1.toSet = void 0;
 const consume_1 = consume$1;
 function toSet(iterable) {
-    return consume_1.consume(iterable, iterable => new Set(iterable));
+    return (0, consume_1.consume)(iterable, iterable => new Set(iterable));
 }
 toSet$1.toSet = toSet;
 
@@ -2370,15 +2398,15 @@ var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m
 };__exportStar(middleware, exports);
 __exportStar(output, exports);
 
-}(es2018$3));
+}(es2018$5));
 
 var _LRUMap_limit, _LRUMap_map;
 class LRUMap {
     constructor(limit) {
         _LRUMap_limit.set(this, void 0);
         _LRUMap_map.set(this, new Map());
-        es2018$4.assert(Number.isInteger(limit), 'The parameter limit must be an integer');
-        es2018$4.assert(limit > 0, 'The parameter limit must be a positive value');
+        es2018$6.assert(Number.isInteger(limit), 'The parameter limit must be an integer');
+        es2018$6.assert(limit > 0, 'The parameter limit must be a positive value');
         __classPrivateFieldSet(this, _LRUMap_limit, limit, "f");
     }
     get [(_LRUMap_limit = new WeakMap(), _LRUMap_map = new WeakMap(), Symbol.toStringTag)]() {
@@ -2426,44 +2454,105 @@ class LRUMap {
      * Return the earliest key inserted in the Map
      */
     getColdestKey() {
-        return es2018$3.first(__classPrivateFieldGet(this, _LRUMap_map, "f").keys());
+        return es2018$5.first(__classPrivateFieldGet(this, _LRUMap_map, "f").keys());
     }
 }
 
-var es2018 = {};
+var es2018$2 = {};
 
-var setTimeout$1 = {};
+var exponentialBackoff = {};
 
-setTimeout$1.setTimeout = void 0;
-function setTimeout(timeout, cb) {
-    const timer = globalThis.setTimeout(cb, timeout);
-    return () => clearTimeout(timer);
-}
-setTimeout$1.setTimeout = setTimeout;
+var es2018$1 = {};
 
-var setSchedule$1 = {};
+var random$1 = {};
 
-setSchedule$1.setSchedule = void 0;
-const set_timeout_1$3 = setTimeout$1;
-function setSchedule(timestamp, cb) {
-    const timeout = timestamp - Date.now();
-    return (0, set_timeout_1$3.setTimeout)(timeout, cb);
+random$1.random = void 0;
+function random(min, max) {
+    return Math.random() * (max - min) + min;
 }
-setSchedule$1.setSchedule = setSchedule;
+random$1.random = random;
 
-var setInterval$1 = {};
+var randomInt$1 = {};
 
-setInterval$1.setInterval = void 0;
-function setInterval(timeout, cb) {
-    const timer = globalThis.setInterval(cb, timeout);
-    return () => clearInterval(timer);
+randomInt$1.randomInt = void 0;
+function randomInt(min, max) {
+    min = Math.ceil(min);
+    max = Math.floor(max);
+    return Math.floor(Math.random() * (max - min)) + min;
 }
-setInterval$1.setInterval = setInterval;
+randomInt$1.randomInt = randomInt;
 
-var setImmediate$1 = {};
+var randomIntInclusive$1 = {};
+
+randomIntInclusive$1.randomIntInclusive = void 0;
+function randomIntInclusive(min, max) {
+    min = Math.ceil(min);
+    max = Math.floor(max);
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+randomIntInclusive$1.randomIntInclusive = randomIntInclusive;
+
+(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(random$1, exports);
+__exportStar(randomInt$1, exports);
+__exportStar(randomIntInclusive$1, exports);
+
+}(es2018$1));
+
+exponentialBackoff.calculateExponentialBackoffTimeout = void 0;
+const extra_rand_1 = es2018$1;
+function calculateExponentialBackoffTimeout({ baseTimeout, retries, maxTimeout = Infinity, factor = 2, jitter = true }) {
+    const timeout = Math.min(factor ** retries * baseTimeout, maxTimeout);
+    if (jitter) {
+        return (0, extra_rand_1.randomIntInclusive)(0, timeout);
+    }
+    else {
+        return timeout;
+    }
+}
+exponentialBackoff.calculateExponentialBackoffTimeout = calculateExponentialBackoffTimeout;
+
+var setTimeout$2 = {};
+
+setTimeout$2.setTimeout = void 0;
+function setTimeout$1(timeout, cb) {
+    const timer = globalThis.setTimeout(cb, timeout);
+    return () => clearTimeout(timer);
+}
+setTimeout$2.setTimeout = setTimeout$1;
+
+var setSchedule$1 = {};
+
+setSchedule$1.setSchedule = void 0;
+const set_timeout_1$3 = setTimeout$2;
+function setSchedule(timestamp, cb) {
+    const timeout = timestamp - Date.now();
+    return (0, set_timeout_1$3.setTimeout)(timeout, cb);
+}
+setSchedule$1.setSchedule = setSchedule;
+
+var setInterval$1 = {};
+
+setInterval$1.setInterval = void 0;
+function setInterval(timeout, cb) {
+    const timer = globalThis.setInterval(cb, timeout);
+    return () => clearInterval(timer);
+}
+setInterval$1.setInterval = setInterval;
+
+var setImmediate$1 = {};
 
 setImmediate$1.setImmediate = void 0;
-const set_timeout_1$2 = setTimeout$1;
+const set_timeout_1$2 = setTimeout$2;
 function setImmediate(cb) {
     if (globalThis.setImmediate) {
         const timer = globalThis.setImmediate(cb);
@@ -2478,7 +2567,7 @@ setImmediate$1.setImmediate = setImmediate;
 var setTimeoutLoop$1 = {};
 
 setTimeoutLoop$1.setTimeoutLoop = void 0;
-const set_timeout_1$1 = setTimeout$1;
+const set_timeout_1$1 = setTimeout$2;
 function setTimeoutLoop(timeout, cb) {
     let isCancelled = false;
     let cancel = (0, set_timeout_1$1.setTimeout)(timeout, loop);
@@ -2488,8 +2577,9 @@ function setTimeoutLoop(timeout, cb) {
     };
     async function loop() {
         await cb();
-        if (!isCancelled)
+        if (!isCancelled) {
             cancel = (0, set_timeout_1$1.setTimeout)(timeout, loop);
+        }
     }
 }
 setTimeoutLoop$1.setTimeoutLoop = setTimeoutLoop;
@@ -2497,7 +2587,7 @@ setTimeoutLoop$1.setTimeoutLoop = setTimeoutLoop;
 var setDynamicTimeoutLoop$1 = {};
 
 setDynamicTimeoutLoop$1.setDynamicTimeoutLoop = void 0;
-const set_timeout_1 = setTimeout$1;
+const set_timeout_1 = setTimeout$2;
 function setDynamicTimeoutLoop(timeout, cb) {
     let isCancelled = false;
     let cancel = (0, set_timeout_1.setTimeout)(timeout, loop);
@@ -2509,8 +2599,9 @@ function setDynamicTimeoutLoop(timeout, cb) {
         const start = Date.now();
         await cb();
         const elapsed = Date.now() - start;
-        if (!isCancelled)
+        if (!isCancelled) {
             cancel = (0, set_timeout_1.setTimeout)(Math.max(timeout - elapsed, 0), loop);
+        }
     }
 }
 setDynamicTimeoutLoop$1.setDynamicTimeoutLoop = setDynamicTimeoutLoop;
@@ -2525,26 +2616,27 @@ 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(setTimeout$1, exports);
+};__exportStar(exponentialBackoff, exports);
+__exportStar(setTimeout$2, exports);
 __exportStar(setSchedule$1, exports);
 __exportStar(setInterval$1, exports);
 __exportStar(setImmediate$1, exports);
 __exportStar(setTimeoutLoop$1, exports);
 __exportStar(setDynamicTimeoutLoop$1, exports);
 
-}(es2018));
+}(es2018$2));
 
-var _ExpirableMap_map, _ExpirableMap_cancelNextTimeout;
+var _ExpirableMap_map, _ExpirableMap_cancelClearTimeout;
 class ExpirableMap {
     constructor() {
         _ExpirableMap_map.set(this, new Map());
-        _ExpirableMap_cancelNextTimeout.set(this, void 0);
+        _ExpirableMap_cancelClearTimeout.set(this, void 0);
         /**
-         * 按过期时间升序排列所有Map项目的信息
+         * 按过期时间升序排列所有项目的元数据
          */
-        this.itemsSortedByExpirationTime = [];
+        this.itemMetadataSortedByExpirationTime = [];
     }
-    get [(_ExpirableMap_map = new WeakMap(), _ExpirableMap_cancelNextTimeout = new WeakMap(), Symbol.toStringTag)]() {
+    get [(_ExpirableMap_map = new WeakMap(), _ExpirableMap_cancelClearTimeout = new WeakMap(), Symbol.toStringTag)]() {
         return this.constructor.name;
     }
     get size() {
@@ -2552,8 +2644,8 @@ class ExpirableMap {
     }
     set(key, value, maxAge) {
         __classPrivateFieldGet(this, _ExpirableMap_map, "f").set(key, value);
-        this.removeItem(key);
-        this.addItem(key, Date.now() + maxAge);
+        this.removeItemMetadata(key);
+        this.addItemMetadata(key, Date.now() + maxAge);
         return this;
     }
     has(key) {
@@ -2563,79 +2655,79 @@ class ExpirableMap {
         return __classPrivateFieldGet(this, _ExpirableMap_map, "f").get(key);
     }
     delete(key) {
-        const result = __classPrivateFieldGet(this, _ExpirableMap_map, "f").delete(key);
-        if (result) {
-            const index = this.itemsSortedByExpirationTime.findIndex(x => x.key === key);
-            this.itemsSortedByExpirationTime.splice(index, 1);
+        const exists = __classPrivateFieldGet(this, _ExpirableMap_map, "f").delete(key);
+        if (exists) {
+            const index = this.itemMetadataSortedByExpirationTime.findIndex(x => x.key === key);
+            this.itemMetadataSortedByExpirationTime.splice(index, 1);
             // 如果被删除的项目是第一个项目, 则需要重新规划过期回调
             if (index === 0) {
-                this.rescheduleTimeout();
+                this.rescheduleClearTimeout();
             }
         }
-        return result;
+        return exists;
     }
     clear() {
         var _a;
         __classPrivateFieldGet(this, _ExpirableMap_map, "f").clear();
-        (_a = __classPrivateFieldGet(this, _ExpirableMap_cancelNextTimeout, "f")) === null || _a === void 0 ? void 0 : _a.call(this);
-        this.itemsSortedByExpirationTime = [];
+        (_a = __classPrivateFieldGet(this, _ExpirableMap_cancelClearTimeout, "f")) === null || _a === void 0 ? void 0 : _a.call(this);
+        this.itemMetadataSortedByExpirationTime = [];
     }
-    addItem(key, expirationTime) {
-        for (let i = 0; i < this.itemsSortedByExpirationTime.length; i++) {
-            const item = this.itemsSortedByExpirationTime[i];
+    addItemMetadata(key, expirationTime) {
+        for (let i = 0; i < this.itemMetadataSortedByExpirationTime.length; i++) {
+            const item = this.itemMetadataSortedByExpirationTime[i];
             if (expirationTime < item.expirationTime) {
-                this.itemsSortedByExpirationTime.splice(i, 0, { key, expirationTime });
+                this.itemMetadataSortedByExpirationTime.splice(i, 0, { key, expirationTime });
                 // 如果本次插入导致原先的第一个项目不再是低一个项目, 则需要重新规划过期回调
                 if (i === 0) {
-                    this.rescheduleTimeout();
+                    this.rescheduleClearTimeout();
                 }
                 return;
             }
         }
         // 如果代码运行到此处, 意味着数组要么为空, 要么新项目过期时间大于数组内的所有项目, 故直接插入到数组尾端.
-        this.itemsSortedByExpirationTime.push({ key, expirationTime });
+        this.itemMetadataSortedByExpirationTime.push({ key, expirationTime });
         // 如果新插入的项目是唯一而项目, 则需要重新规划过期回调
-        if (this.itemsSortedByExpirationTime.length === 1) {
-            this.rescheduleTimeout();
+        if (this.itemMetadataSortedByExpirationTime.length === 1) {
+            this.rescheduleClearTimeout();
         }
     }
-    removeItem(key) {
-        const index = this.itemsSortedByExpirationTime.findIndex(x => x.key === key);
+    removeItemMetadata(key) {
+        const index = this.itemMetadataSortedByExpirationTime.findIndex(x => x.key === key);
         if (index >= 0) {
-            this.itemsSortedByExpirationTime.splice(index, 1);
+            this.itemMetadataSortedByExpirationTime.splice(index, 1);
             // 如果被移除的是第一个项目, 则需要重新规划过期回调
             if (index === 0) {
-                this.rescheduleTimeout();
+                this.rescheduleClearTimeout();
             }
         }
     }
     clearExpiredItems(timestamp) {
-        const indexOfFirstUnexpiredItem = this.itemsSortedByExpirationTime.findIndex(x => x.expirationTime > timestamp);
-        const expiredItems = indexOfFirstUnexpiredItem >= 0
-            ? this.itemsSortedByExpirationTime.splice(0, indexOfFirstUnexpiredItem)
-            : this.itemsSortedByExpirationTime.splice(0, this.itemsSortedByExpirationTime.length);
-        expiredItems.forEach(x => __classPrivateFieldGet(this, _ExpirableMap_map, "f").delete(x.key));
+        const indexOfFirstUnexpired = this.itemMetadataSortedByExpirationTime.findIndex(x => x.expirationTime > timestamp);
+        const expiredItemKeys = indexOfFirstUnexpired >= 0
+            ? this.itemMetadataSortedByExpirationTime.splice(0, indexOfFirstUnexpired)
+            : this.itemMetadataSortedByExpirationTime.splice(0, this.itemMetadataSortedByExpirationTime.length);
+        expiredItemKeys.forEach(x => __classPrivateFieldGet(this, _ExpirableMap_map, "f").delete(x.key));
     }
-    rescheduleTimeout() {
+    rescheduleClearTimeout() {
         var _a;
-        (_a = __classPrivateFieldGet(this, _ExpirableMap_cancelNextTimeout, "f")) === null || _a === void 0 ? void 0 : _a.call(this);
-        if (this.itemsSortedByExpirationTime.length > 0) {
-            const item = this.itemsSortedByExpirationTime[0];
+        (_a = __classPrivateFieldGet(this, _ExpirableMap_cancelClearTimeout, "f")) === null || _a === void 0 ? void 0 : _a.call(this);
+        if (this.itemMetadataSortedByExpirationTime.length > 0) {
+            const item = this.itemMetadataSortedByExpirationTime[0];
             if (Number.isFinite(item.expirationTime)) {
-                const cancel = es2018.setSchedule(item.expirationTime, () => {
+                const cancel = es2018$2.setSchedule(item.expirationTime, () => {
                     this.clearExpiredItems(Date.now());
-                    this.rescheduleTimeout();
+                    this.rescheduleClearTimeout();
                 });
-                __classPrivateFieldSet(this, _ExpirableMap_cancelNextTimeout, () => {
+                __classPrivateFieldSet(this, _ExpirableMap_cancelClearTimeout, () => {
                     cancel();
-                    __classPrivateFieldSet(this, _ExpirableMap_cancelNextTimeout, undefined, "f");
+                    __classPrivateFieldSet(this, _ExpirableMap_cancelClearTimeout, undefined, "f");
                 }, "f");
             }
         }
     }
 }
 
-var _TLRUMap_limit, _TLRUMap_map, _TLRUMap_cancelNextTimeout;
+var _TLRUMap_limit, _TLRUMap_map, _TLRUMap_cancelClearTimeout;
 /**
  * TLRUMap = LRUMap + ExpirableMap
  */
@@ -2643,16 +2735,16 @@ class TLRUMap {
     constructor(limit) {
         _TLRUMap_limit.set(this, void 0);
         _TLRUMap_map.set(this, new Map());
-        _TLRUMap_cancelNextTimeout.set(this, void 0);
+        _TLRUMap_cancelClearTimeout.set(this, void 0);
         /**
-         * 按过期时间升序排列所有Map项目的信息
+         * 按过期时间升序排列所有项目的元数据
          */
-        this.itemsSortedByExpirationTime = [];
-        es2018$4.assert(Number.isInteger(limit), 'The parameter limit must be an integer');
-        es2018$4.assert(limit > 0, 'The parameter limit must be a positive value');
+        this.itemMetadataSortedByExpirationTime = [];
+        es2018$6.assert(Number.isInteger(limit), 'The parameter limit must be an integer');
+        es2018$6.assert(limit > 0, 'The parameter limit must be a positive value');
         __classPrivateFieldSet(this, _TLRUMap_limit, limit, "f");
     }
-    get [(_TLRUMap_limit = new WeakMap(), _TLRUMap_map = new WeakMap(), _TLRUMap_cancelNextTimeout = new WeakMap(), Symbol.toStringTag)]() {
+    get [(_TLRUMap_limit = new WeakMap(), _TLRUMap_map = new WeakMap(), _TLRUMap_cancelClearTimeout = new WeakMap(), Symbol.toStringTag)]() {
         return this.constructor.name;
     }
     get size() {
@@ -2661,15 +2753,15 @@ class TLRUMap {
     set(key, value, maxAge) {
         if (__classPrivateFieldGet(this, _TLRUMap_map, "f").has(key)) {
             this.updateItem(key, value);
-            this.removeItem(key);
-            this.addItem(key, Date.now() + maxAge);
+            this.removeItemMetadata(key);
+            this.addItemMetadata(key, Date.now() + maxAge);
         }
         else {
             if (__classPrivateFieldGet(this, _TLRUMap_map, "f").size === __classPrivateFieldGet(this, _TLRUMap_limit, "f")) {
                 __classPrivateFieldGet(this, _TLRUMap_map, "f").delete(this.getColdestKey());
             }
             __classPrivateFieldGet(this, _TLRUMap_map, "f").set(key, value);
-            this.addItem(key, Date.now() + maxAge);
+            this.addItemMetadata(key, Date.now() + maxAge);
         }
         return this;
     }
@@ -2689,11 +2781,11 @@ class TLRUMap {
     delete(key) {
         const result = __classPrivateFieldGet(this, _TLRUMap_map, "f").delete(key);
         if (result) {
-            const index = this.itemsSortedByExpirationTime.findIndex(x => x.key === key);
-            this.itemsSortedByExpirationTime.splice(index, 1);
+            const index = this.itemMetadataSortedByExpirationTime.findIndex(x => x.key === key);
+            this.itemMetadataSortedByExpirationTime.splice(index, 1);
             // 如果被删除的项目是第一个项目, 则需要重新规划过期回调
             if (index === 0) {
-                this.rescheduleTimeout();
+                this.rescheduleClearTimeout();
             }
         }
         return result;
@@ -2701,8 +2793,8 @@ class TLRUMap {
     clear() {
         var _a;
         __classPrivateFieldGet(this, _TLRUMap_map, "f").clear();
-        (_a = __classPrivateFieldGet(this, _TLRUMap_cancelNextTimeout, "f")) === null || _a === void 0 ? void 0 : _a.call(this);
-        this.itemsSortedByExpirationTime = [];
+        (_a = __classPrivateFieldGet(this, _TLRUMap_cancelClearTimeout, "f")) === null || _a === void 0 ? void 0 : _a.call(this);
+        this.itemMetadataSortedByExpirationTime = [];
     }
     /**
      * 重新插入项目, 这会使项目置于#map迭代器的末端.
@@ -2711,55 +2803,55 @@ class TLRUMap {
         __classPrivateFieldGet(this, _TLRUMap_map, "f").delete(key);
         __classPrivateFieldGet(this, _TLRUMap_map, "f").set(key, value);
     }
-    addItem(key, expirationTime) {
-        for (let i = 0; i < this.itemsSortedByExpirationTime.length; i++) {
-            const item = this.itemsSortedByExpirationTime[i];
+    addItemMetadata(key, expirationTime) {
+        for (let i = 0; i < this.itemMetadataSortedByExpirationTime.length; i++) {
+            const item = this.itemMetadataSortedByExpirationTime[i];
             if (expirationTime < item.expirationTime) {
-                this.itemsSortedByExpirationTime.splice(i, 0, { key, expirationTime });
+                this.itemMetadataSortedByExpirationTime.splice(i, 0, { key, expirationTime });
                 // 如果本次插入导致原先的第一个项目不再是低一个项目, 则需要重新规划过期回调
                 if (i === 0) {
-                    this.rescheduleTimeout();
+                    this.rescheduleClearTimeout();
                 }
                 return;
             }
         }
         // 如果代码运行到此处, 意味着数组要么为空, 要么新项目过期时间大于数组内的所有项目, 故直接插入到数组尾端.
-        this.itemsSortedByExpirationTime.push({ key, expirationTime });
+        this.itemMetadataSortedByExpirationTime.push({ key, expirationTime });
         // 如果新插入的项目是唯一而项目, 则需要重新规划过期回调
-        if (this.itemsSortedByExpirationTime.length === 1) {
-            this.rescheduleTimeout();
+        if (this.itemMetadataSortedByExpirationTime.length === 1) {
+            this.rescheduleClearTimeout();
         }
     }
-    removeItem(key) {
-        const index = this.itemsSortedByExpirationTime.findIndex(x => x.key === key);
+    removeItemMetadata(key) {
+        const index = this.itemMetadataSortedByExpirationTime.findIndex(x => x.key === key);
         if (index >= 0) {
-            this.itemsSortedByExpirationTime.splice(index, 1);
+            this.itemMetadataSortedByExpirationTime.splice(index, 1);
             // 如果被移除的是第一个项目, 则需要重新规划过期回调
             if (index === 0) {
-                this.rescheduleTimeout();
+                this.rescheduleClearTimeout();
             }
         }
     }
     clearExpiredItems(timestamp) {
-        const indexOfFirstUnexpiredItem = this.itemsSortedByExpirationTime.findIndex(x => x.expirationTime > timestamp);
-        const expiredItems = indexOfFirstUnexpiredItem >= 0
-            ? this.itemsSortedByExpirationTime.splice(0, indexOfFirstUnexpiredItem)
-            : this.itemsSortedByExpirationTime.splice(0, this.itemsSortedByExpirationTime.length);
-        expiredItems.forEach(x => __classPrivateFieldGet(this, _TLRUMap_map, "f").delete(x.key));
+        const indexOfFirstUnexpiredItem = this.itemMetadataSortedByExpirationTime.findIndex(x => x.expirationTime > timestamp);
+        const expiredItemKeys = indexOfFirstUnexpiredItem >= 0
+            ? this.itemMetadataSortedByExpirationTime.splice(0, indexOfFirstUnexpiredItem)
+            : this.itemMetadataSortedByExpirationTime.splice(0, this.itemMetadataSortedByExpirationTime.length);
+        expiredItemKeys.forEach(x => __classPrivateFieldGet(this, _TLRUMap_map, "f").delete(x.key));
     }
-    rescheduleTimeout() {
+    rescheduleClearTimeout() {
         var _a;
-        (_a = __classPrivateFieldGet(this, _TLRUMap_cancelNextTimeout, "f")) === null || _a === void 0 ? void 0 : _a.call(this);
-        if (this.itemsSortedByExpirationTime.length > 0) {
-            const item = this.itemsSortedByExpirationTime[0];
+        (_a = __classPrivateFieldGet(this, _TLRUMap_cancelClearTimeout, "f")) === null || _a === void 0 ? void 0 : _a.call(this);
+        if (this.itemMetadataSortedByExpirationTime.length > 0) {
+            const item = this.itemMetadataSortedByExpirationTime[0];
             if (Number.isFinite(item.expirationTime)) {
-                const cancel = es2018.setSchedule(item.expirationTime, () => {
+                const cancel = es2018$2.setSchedule(item.expirationTime, () => {
                     this.clearExpiredItems(Date.now());
-                    this.rescheduleTimeout();
+                    this.rescheduleClearTimeout();
                 });
-                __classPrivateFieldSet(this, _TLRUMap_cancelNextTimeout, () => {
+                __classPrivateFieldSet(this, _TLRUMap_cancelClearTimeout, () => {
                     cancel();
-                    __classPrivateFieldSet(this, _TLRUMap_cancelNextTimeout, undefined, "f");
+                    __classPrivateFieldSet(this, _TLRUMap_cancelClearTimeout, undefined, "f");
                 }, "f");
             }
         }
@@ -2768,7 +2860,7 @@ class TLRUMap {
      * Return the earliest key inserted in the Map
      */
     getColdestKey() {
-        return es2018$3.first(__classPrivateFieldGet(this, _TLRUMap_map, "f").keys());
+        return es2018$5.first(__classPrivateFieldGet(this, _TLRUMap_map, "f").keys());
     }
 }
 
@@ -2836,7 +2928,7 @@ class TrieMap {
         delete node.value;
         // 如果节点没有后缀, 则代表这是末端节点, 往前删除其前缀
         if (node.children.size === 0) {
-            for (const [part, parentNode] of es2018$3.toArray(es2018$3.zip(key, parentNodes)).reverse()) {
+            for (const [part, parentNode] of es2018$5.toArray(es2018$5.zip(key, parentNodes)).reverse()) {
                 parentNode.children.delete(part);
                 if (parentNode.children.size !== 0)
                     break;
@@ -2846,5 +2938,1086 @@ class TrieMap {
     }
 }
 
-export { Emitter, ExpirableMap, HashMap, HashSet, LRUMap, Queue, TLRUMap, TrieMap, convertArrayToCons, convertConsToArray };
+var _FiniteStateMachine_state;
+class FiniteStateMachine {
+    constructor(schema, initialState) {
+        this.schema = schema;
+        _FiniteStateMachine_state.set(this, void 0);
+        __classPrivateFieldSet(this, _FiniteStateMachine_state, initialState, "f");
+    }
+    get state() {
+        return __classPrivateFieldGet(this, _FiniteStateMachine_state, "f");
+    }
+    matches(state) {
+        return __classPrivateFieldGet(this, _FiniteStateMachine_state, "f") === state;
+    }
+    /**
+     * @throws {BadEventError}
+     */
+    send(event) {
+        if (event in this.schema[this.state]) {
+            __classPrivateFieldSet(this, _FiniteStateMachine_state, this.schema[this.state][event], "f");
+        }
+        else {
+            throw new BadEventError(this.state, event);
+        }
+    }
+}
+_FiniteStateMachine_state = new WeakMap();
+class BadEventError extends es2018$6.CustomError {
+    constructor(state, event) {
+        super(`State ${state} cannot react to event ${event}`);
+    }
+}
+
+/*! *****************************************************************************
+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) {
+    return typeof value === 'function';
+}
+
+function createErrorClass(createImpl) {
+    var _super = function (instance) {
+        Error.call(instance);
+        instance.stack = new Error().stack;
+    };
+    var ctorFunc = createImpl(_super);
+    ctorFunc.prototype = Object.create(Error.prototype);
+    ctorFunc.prototype.constructor = ctorFunc;
+    return ctorFunc;
+}
+
+var UnsubscriptionError = createErrorClass(function (_super) {
+    return function UnsubscriptionErrorImpl(errors) {
+        _super(this);
+        this.message = errors
+            ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function (err, i) { return i + 1 + ") " + err.toString(); }).join('\n  ')
+            : '';
+        this.name = 'UnsubscriptionError';
+        this.errors = errors;
+    };
+});
+
+function arrRemove(arr, item) {
+    if (arr) {
+        var index = arr.indexOf(item);
+        0 <= index && arr.splice(index, 1);
+    }
+}
+
+var Subscription = (function () {
+    function Subscription(initialTeardown) {
+        this.initialTeardown = initialTeardown;
+        this.closed = false;
+        this._parentage = null;
+        this._teardowns = null;
+    }
+    Subscription.prototype.unsubscribe = function () {
+        var e_1, _a, e_2, _b;
+        var errors;
+        if (!this.closed) {
+            this.closed = true;
+            var _parentage = this._parentage;
+            if (_parentage) {
+                this._parentage = null;
+                if (Array.isArray(_parentage)) {
+                    try {
+                        for (var _parentage_1 = __values(_parentage), _parentage_1_1 = _parentage_1.next(); !_parentage_1_1.done; _parentage_1_1 = _parentage_1.next()) {
+                            var parent_1 = _parentage_1_1.value;
+                            parent_1.remove(this);
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (_parentage_1_1 && !_parentage_1_1.done && (_a = _parentage_1.return)) _a.call(_parentage_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                }
+                else {
+                    _parentage.remove(this);
+                }
+            }
+            var initialTeardown = this.initialTeardown;
+            if (isFunction$1(initialTeardown)) {
+                try {
+                    initialTeardown();
+                }
+                catch (e) {
+                    errors = e instanceof UnsubscriptionError ? e.errors : [e];
+                }
+            }
+            var _teardowns = this._teardowns;
+            if (_teardowns) {
+                this._teardowns = null;
+                try {
+                    for (var _teardowns_1 = __values(_teardowns), _teardowns_1_1 = _teardowns_1.next(); !_teardowns_1_1.done; _teardowns_1_1 = _teardowns_1.next()) {
+                        var teardown_1 = _teardowns_1_1.value;
+                        try {
+                            execTeardown(teardown_1);
+                        }
+                        catch (err) {
+                            errors = errors !== null && errors !== void 0 ? errors : [];
+                            if (err instanceof UnsubscriptionError) {
+                                errors = __spreadArray(__spreadArray([], __read(errors)), __read(err.errors));
+                            }
+                            else {
+                                errors.push(err);
+                            }
+                        }
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_teardowns_1_1 && !_teardowns_1_1.done && (_b = _teardowns_1.return)) _b.call(_teardowns_1);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            }
+            if (errors) {
+                throw new UnsubscriptionError(errors);
+            }
+        }
+    };
+    Subscription.prototype.add = function (teardown) {
+        var _a;
+        if (teardown && teardown !== this) {
+            if (this.closed) {
+                execTeardown(teardown);
+            }
+            else {
+                if (teardown instanceof Subscription) {
+                    if (teardown.closed || teardown._hasParent(this)) {
+                        return;
+                    }
+                    teardown._addParent(this);
+                }
+                (this._teardowns = (_a = this._teardowns) !== null && _a !== void 0 ? _a : []).push(teardown);
+            }
+        }
+    };
+    Subscription.prototype._hasParent = function (parent) {
+        var _parentage = this._parentage;
+        return _parentage === parent || (Array.isArray(_parentage) && _parentage.includes(parent));
+    };
+    Subscription.prototype._addParent = function (parent) {
+        var _parentage = this._parentage;
+        this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
+    };
+    Subscription.prototype._removeParent = function (parent) {
+        var _parentage = this._parentage;
+        if (_parentage === parent) {
+            this._parentage = null;
+        }
+        else if (Array.isArray(_parentage)) {
+            arrRemove(_parentage, parent);
+        }
+    };
+    Subscription.prototype.remove = function (teardown) {
+        var _teardowns = this._teardowns;
+        _teardowns && arrRemove(_teardowns, teardown);
+        if (teardown instanceof Subscription) {
+            teardown._removeParent(this);
+        }
+    };
+    Subscription.EMPTY = (function () {
+        var empty = new Subscription();
+        empty.closed = true;
+        return empty;
+    })();
+    return Subscription;
+}());
+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)));
+}
+function execTeardown(teardown) {
+    if (isFunction$1(teardown)) {
+        teardown();
+    }
+    else {
+        teardown.unsubscribe();
+    }
+}
+
+var config = {
+    onUnhandledError: null,
+    onStoppedNotification: null,
+    Promise: undefined,
+    useDeprecatedSynchronousErrorHandling: false,
+    useDeprecatedNextContext: false,
+};
+
+var timeoutProvider = {
+    setTimeout: function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var delegate = timeoutProvider.delegate;
+        return ((delegate === null || delegate === void 0 ? void 0 : delegate.setTimeout) || setTimeout).apply(void 0, __spreadArray([], __read(args)));
+    },
+    clearTimeout: function (handle) {
+        var delegate = timeoutProvider.delegate;
+        return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearTimeout) || clearTimeout)(handle);
+    },
+    delegate: undefined,
+};
+
+function reportUnhandledError(err) {
+    timeoutProvider.setTimeout(function () {
+        {
+            throw err;
+        }
+    });
+}
+
+function noop() { }
+
+var context = null;
+function errorContext(cb) {
+    if (config.useDeprecatedSynchronousErrorHandling) {
+        var isRoot = !context;
+        if (isRoot) {
+            context = { errorThrown: false, error: null };
+        }
+        cb();
+        if (isRoot) {
+            var _a = context, errorThrown = _a.errorThrown, error = _a.error;
+            context = null;
+            if (errorThrown) {
+                throw error;
+            }
+        }
+    }
+    else {
+        cb();
+    }
+}
+
+var Subscriber = (function (_super) {
+    __extends(Subscriber, _super);
+    function Subscriber(destination) {
+        var _this = _super.call(this) || this;
+        _this.isStopped = false;
+        if (destination) {
+            _this.destination = destination;
+            if (isSubscription(destination)) {
+                destination.add(_this);
+            }
+        }
+        else {
+            _this.destination = EMPTY_OBSERVER;
+        }
+        return _this;
+    }
+    Subscriber.create = function (next, error, complete) {
+        return new SafeSubscriber(next, error, complete);
+    };
+    Subscriber.prototype.next = function (value) {
+        if (this.isStopped) ;
+        else {
+            this._next(value);
+        }
+    };
+    Subscriber.prototype.error = function (err) {
+        if (this.isStopped) ;
+        else {
+            this.isStopped = true;
+            this._error(err);
+        }
+    };
+    Subscriber.prototype.complete = function () {
+        if (this.isStopped) ;
+        else {
+            this.isStopped = true;
+            this._complete();
+        }
+    };
+    Subscriber.prototype.unsubscribe = function () {
+        if (!this.closed) {
+            this.isStopped = true;
+            _super.prototype.unsubscribe.call(this);
+            this.destination = null;
+        }
+    };
+    Subscriber.prototype._next = function (value) {
+        this.destination.next(value);
+    };
+    Subscriber.prototype._error = function (err) {
+        try {
+            this.destination.error(err);
+        }
+        finally {
+            this.unsubscribe();
+        }
+    };
+    Subscriber.prototype._complete = function () {
+        try {
+            this.destination.complete();
+        }
+        finally {
+            this.unsubscribe();
+        }
+    };
+    return Subscriber;
+}(Subscription));
+var SafeSubscriber = (function (_super) {
+    __extends(SafeSubscriber, _super);
+    function SafeSubscriber(observerOrNext, error, complete) {
+        var _this = _super.call(this) || this;
+        var next;
+        if (isFunction$1(observerOrNext)) {
+            next = observerOrNext;
+        }
+        else if (observerOrNext) {
+            (next = observerOrNext.next, error = observerOrNext.error, complete = observerOrNext.complete);
+            var context_1;
+            if (_this && config.useDeprecatedNextContext) {
+                context_1 = Object.create(observerOrNext);
+                context_1.unsubscribe = function () { return _this.unsubscribe(); };
+            }
+            else {
+                context_1 = observerOrNext;
+            }
+            next = next === null || next === void 0 ? void 0 : next.bind(context_1);
+            error = error === null || error === void 0 ? void 0 : error.bind(context_1);
+            complete = complete === null || complete === void 0 ? void 0 : complete.bind(context_1);
+        }
+        _this.destination = {
+            next: next ? wrapForErrorHandling(next) : noop,
+            error: wrapForErrorHandling(error !== null && error !== void 0 ? error : defaultErrorHandler),
+            complete: complete ? wrapForErrorHandling(complete) : noop,
+        };
+        return _this;
+    }
+    return SafeSubscriber;
+}(Subscriber));
+function wrapForErrorHandling(handler, instance) {
+    return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        try {
+            handler.apply(void 0, __spreadArray([], __read(args)));
+        }
+        catch (err) {
+            {
+                reportUnhandledError(err);
+            }
+        }
+    };
+}
+function defaultErrorHandler(err) {
+    throw err;
+}
+var EMPTY_OBSERVER = {
+    closed: true,
+    next: noop,
+    error: defaultErrorHandler,
+    complete: noop,
+};
+
+var observable = (function () { return (typeof Symbol === 'function' && Symbol.observable) || '@@observable'; })();
+
+function identity(x) {
+    return x;
+}
+
+function pipeFromArray(fns) {
+    if (fns.length === 0) {
+        return identity;
+    }
+    if (fns.length === 1) {
+        return fns[0];
+    }
+    return function piped(input) {
+        return fns.reduce(function (prev, fn) { return fn(prev); }, input);
+    };
+}
+
+var Observable = (function () {
+    function Observable(subscribe) {
+        if (subscribe) {
+            this._subscribe = subscribe;
+        }
+    }
+    Observable.prototype.lift = function (operator) {
+        var observable = new Observable();
+        observable.source = this;
+        observable.operator = operator;
+        return observable;
+    };
+    Observable.prototype.subscribe = function (observerOrNext, error, complete) {
+        var _this = this;
+        var subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete);
+        errorContext(function () {
+            var _a = _this, operator = _a.operator, source = _a.source;
+            subscriber.add(operator
+                ?
+                    operator.call(subscriber, source)
+                : source
+                    ?
+                        _this._subscribe(subscriber)
+                    :
+                        _this._trySubscribe(subscriber));
+        });
+        return subscriber;
+    };
+    Observable.prototype._trySubscribe = function (sink) {
+        try {
+            return this._subscribe(sink);
+        }
+        catch (err) {
+            sink.error(err);
+        }
+    };
+    Observable.prototype.forEach = function (next, promiseCtor) {
+        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);
+        });
+    };
+    Observable.prototype._subscribe = function (subscriber) {
+        var _a;
+        return (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber);
+    };
+    Observable.prototype[observable] = function () {
+        return this;
+    };
+    Observable.prototype.pipe = function () {
+        var operations = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            operations[_i] = arguments[_i];
+        }
+        return pipeFromArray(operations)(this);
+    };
+    Observable.prototype.toPromise = function (promiseCtor) {
+        var _this = this;
+        promiseCtor = getPromiseCtor(promiseCtor);
+        return new promiseCtor(function (resolve, reject) {
+            var value;
+            _this.subscribe(function (x) { return (value = x); }, function (err) { return reject(err); }, function () { return resolve(value); });
+        });
+    };
+    Observable.create = function (subscribe) {
+        return new Observable(subscribe);
+    };
+    return Observable;
+}());
+function getPromiseCtor(promiseCtor) {
+    var _a;
+    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);
+}
+function isSubscriber(value) {
+    return (value && value instanceof Subscriber) || (isObserver(value) && isSubscription(value));
+}
+
+var ObjectUnsubscribedError = createErrorClass(function (_super) {
+    return function ObjectUnsubscribedErrorImpl() {
+        _super(this);
+        this.name = 'ObjectUnsubscribedError';
+        this.message = 'object unsubscribed';
+    };
+});
+
+var Subject = (function (_super) {
+    __extends(Subject, _super);
+    function Subject() {
+        var _this = _super.call(this) || this;
+        _this.closed = false;
+        _this.observers = [];
+        _this.isStopped = false;
+        _this.hasError = false;
+        _this.thrownError = null;
+        return _this;
+    }
+    Subject.prototype.lift = function (operator) {
+        var subject = new AnonymousSubject(this, this);
+        subject.operator = operator;
+        return subject;
+    };
+    Subject.prototype._throwIfClosed = function () {
+        if (this.closed) {
+            throw new ObjectUnsubscribedError();
+        }
+    };
+    Subject.prototype.next = function (value) {
+        var _this = this;
+        errorContext(function () {
+            var e_1, _a;
+            _this._throwIfClosed();
+            if (!_this.isStopped) {
+                var copy = _this.observers.slice();
+                try {
+                    for (var copy_1 = __values(copy), copy_1_1 = copy_1.next(); !copy_1_1.done; copy_1_1 = copy_1.next()) {
+                        var observer = copy_1_1.value;
+                        observer.next(value);
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (copy_1_1 && !copy_1_1.done && (_a = copy_1.return)) _a.call(copy_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+        });
+    };
+    Subject.prototype.error = function (err) {
+        var _this = this;
+        errorContext(function () {
+            _this._throwIfClosed();
+            if (!_this.isStopped) {
+                _this.hasError = _this.isStopped = true;
+                _this.thrownError = err;
+                var observers = _this.observers;
+                while (observers.length) {
+                    observers.shift().error(err);
+                }
+            }
+        });
+    };
+    Subject.prototype.complete = function () {
+        var _this = this;
+        errorContext(function () {
+            _this._throwIfClosed();
+            if (!_this.isStopped) {
+                _this.isStopped = true;
+                var observers = _this.observers;
+                while (observers.length) {
+                    observers.shift().complete();
+                }
+            }
+        });
+    };
+    Subject.prototype.unsubscribe = function () {
+        this.isStopped = this.closed = true;
+        this.observers = null;
+    };
+    Object.defineProperty(Subject.prototype, "observed", {
+        get: function () {
+            var _a;
+            return ((_a = this.observers) === null || _a === void 0 ? void 0 : _a.length) > 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Subject.prototype._trySubscribe = function (subscriber) {
+        this._throwIfClosed();
+        return _super.prototype._trySubscribe.call(this, subscriber);
+    };
+    Subject.prototype._subscribe = function (subscriber) {
+        this._throwIfClosed();
+        this._checkFinalizedStatuses(subscriber);
+        return this._innerSubscribe(subscriber);
+    };
+    Subject.prototype._innerSubscribe = function (subscriber) {
+        var _a = this, hasError = _a.hasError, isStopped = _a.isStopped, observers = _a.observers;
+        return hasError || isStopped
+            ? EMPTY_SUBSCRIPTION
+            : (observers.push(subscriber), new Subscription(function () { return arrRemove(observers, subscriber); }));
+    };
+    Subject.prototype._checkFinalizedStatuses = function (subscriber) {
+        var _a = this, hasError = _a.hasError, thrownError = _a.thrownError, isStopped = _a.isStopped;
+        if (hasError) {
+            subscriber.error(thrownError);
+        }
+        else if (isStopped) {
+            subscriber.complete();
+        }
+    };
+    Subject.prototype.asObservable = function () {
+        var observable = new Observable();
+        observable.source = this;
+        return observable;
+    };
+    Subject.create = function (destination, source) {
+        return new AnonymousSubject(destination, source);
+    };
+    return Subject;
+}(Observable));
+var AnonymousSubject = (function (_super) {
+    __extends(AnonymousSubject, _super);
+    function AnonymousSubject(destination, source) {
+        var _this = _super.call(this) || this;
+        _this.destination = destination;
+        _this.source = source;
+        return _this;
+    }
+    AnonymousSubject.prototype.next = function (value) {
+        var _a, _b;
+        (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.next) === null || _b === void 0 ? void 0 : _b.call(_a, value);
+    };
+    AnonymousSubject.prototype.error = function (err) {
+        var _a, _b;
+        (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.call(_a, err);
+    };
+    AnonymousSubject.prototype.complete = function () {
+        var _a, _b;
+        (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.complete) === null || _b === void 0 ? void 0 : _b.call(_a);
+    };
+    AnonymousSubject.prototype._subscribe = function (subscriber) {
+        var _a, _b;
+        return (_b = (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber)) !== null && _b !== void 0 ? _b : EMPTY_SUBSCRIPTION;
+    };
+    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.stateChanges = new Subject();
+    }
+    observeStateChanges() {
+        return this.stateChanges;
+    }
+    /**
+     * @throws {BadEventError}
+     */
+    send(event) {
+        const oldState = this.state;
+        super.send(event);
+        const newState = this.state;
+        this.stateChanges.next({ event, oldState, newState });
+        if (es2018.isEmptyObject(this.schema[newState])) {
+            this.stateChanges.complete();
+        }
+    }
+}
+
+export { BadEventError, Box, Emitter, ExpirableMap, FiniteStateMachine, HashMap, HashSet, LRUMap, ObservableFiniteStateMachine, Queue, TLRUMap, TrieMap, convertArrayToCons, convertConsToArray };
 //# sourceMappingURL=index.mjs.map