@blackglory/structures 0.2.4 → 0.2.8

package/dist/es2015/index.umd.js

@@ -2,16 +2,7 @@
     typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
     typeof define === 'function' && define.amd ? define(['exports'], factory) :
     (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Structures = {}));
-}(this, (function (exports) { 'use strict';
-
-    function convertConsToArray([value, next]) {
-        if (next === null)
-            return [value];
-        return [value, ...convertConsToArray(next)];
-    }
-    function convertArrayToCons([value, ...next]) {
-        return [value, next.length ? convertArrayToCons(next) : null];
-    }
+})(this, (function (exports) { 'use strict';
 
     /*! *****************************************************************************
     Copyright (c) Microsoft Corporation.
@@ -41,6 +32,30 @@
         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() {
@@ -169,7 +184,7 @@
 
     var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
-    var es2018$3 = {};
+    var es2018$6 = {};
 
     var customError = {};
 
@@ -247,15 +262,15 @@
     __exportStar(refute$1, exports);
     __exportStar(assert$1, exports);
 
-    }(es2018$3));
+    }(es2018$6));
 
-    var es2018$2 = {};
+    var es2018$5 = {};
 
     var middleware = {};
 
     var chunkAsync$1 = {};
 
-    var es2018$1 = {};
+    var es2018$4 = {};
 
     var go$1 = {};
 
@@ -277,15 +292,15 @@
         for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
     };__exportStar(go$1, exports);
 
-    }(es2018$1));
+    }(es2018$4));
 
     chunkAsync$1.chunkAsync = void 0;
-    const go_1$f = es2018$1;
-    const errors_1$f = es2018$3;
+    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);
@@ -302,285 +317,297 @@
 
     var chunkByAsync$1 = {};
 
-    var es2018 = {};
+    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;
@@ -589,16 +616,16 @@
             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;
@@ -607,7 +634,7 @@
             return false;
         }
     }
-    url.isAbsoluteURL = isAbsoluteURL;
+    url$1.isAbsoluteURL = isAbsoluteURL$1;
 
     (function (exports) {
     var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -619,31 +646,32 @@
     }));
     var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
         for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-    };__exportStar(array, 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));
+    }(es2018$3));
 
     chunkByAsync$1.chunkByAsync = void 0;
-    const types_1$h = es2018;
+    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 {
@@ -702,12 +730,12 @@
     var chunk$1 = {};
 
     chunk$1.chunk = void 0;
-    const go_1$e = es2018$1;
-    const errors_1$e = es2018$3;
+    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);
@@ -725,12 +753,12 @@
     var concatAsync$1 = {};
 
     concatAsync$1.concatAsync = void 0;
-    const types_1$g = es2018;
-    const go_1$d = es2018$1;
+    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;
                     }
@@ -748,9 +776,9 @@
     var concat$1 = {};
 
     concat$1.concat = void 0;
-    const go_1$c = es2018$1;
+    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;
             }
@@ -777,15 +805,15 @@
     utils.copyIterable = copyIterable;
 
     dropAsync$1.dropAsync = void 0;
-    const go_1$b = es2018$1;
+    const go_1$b = es2018$4;
     const utils_1$3 = utils;
-    const errors_1$d = es2018$3;
+    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;
@@ -812,15 +840,15 @@
     var dropRightAsync$1 = {};
 
     dropRightAsync$1.dropRightAsync = void 0;
-    const go_1$a = es2018$1;
+    const go_1$a = es2018$4;
     const utils_1$2 = utils;
-    const errors_1$c = es2018$3;
+    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) {
@@ -840,15 +868,15 @@
     var dropRight$1 = {};
 
     dropRight$1.dropRight = void 0;
-    const go_1$9 = es2018$1;
+    const go_1$9 = es2018$4;
     const utils_1$1 = utils;
-    const errors_1$b = es2018$3;
+    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);
         });
@@ -858,9 +886,9 @@
     var dropUntilAsync$1 = {};
 
     dropUntilAsync$1.dropUntilAsync = void 0;
-    const types_1$f = es2018;
+    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 {
@@ -940,15 +968,15 @@
     var drop$1 = {};
 
     drop$1.drop = void 0;
-    const go_1$8 = es2018$1;
+    const go_1$8 = es2018$4;
     const utils_1 = utils;
-    const errors_1$a = es2018$3;
+    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;
@@ -975,9 +1003,9 @@
     var filterAsync$1 = {};
 
     filterAsync$1.filterAsync = void 0;
-    const types_1$e = es2018;
+    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 {
@@ -1022,9 +1050,9 @@
     var flattenByAsync$1 = {};
 
     flattenByAsync$1.flattenByAsync = void 0;
-    const types_1$d = es2018;
+    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 {
@@ -1057,30 +1085,30 @@
     }
     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$3;
+    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;
+    const types_1$c = es2018$3;
     function flattenBy(iterable, predicate) {
         return flatten(iterable, 1);
         function* flatten(iterable, level) {
@@ -1096,18 +1124,18 @@
     }
     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$3;
+    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;
 
@@ -1116,16 +1144,16 @@
     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;
+    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 {
@@ -1163,14 +1191,14 @@
     var repeatAsync$1 = {};
 
     repeatAsync$1.repeatAsync = void 0;
-    const go_1$7 = es2018$1;
-    const errors_1$7 = es2018$3;
+    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) {
@@ -1198,14 +1226,14 @@
     var repeat$1 = {};
 
     repeat$1.repeat = void 0;
-    const go_1$6 = es2018$1;
-    const errors_1$6 = es2018$3;
+    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) {
@@ -1233,14 +1261,14 @@
     var sliceAsync$1 = {};
 
     sliceAsync$1.sliceAsync = void 0;
-    const go_1$5 = es2018$1;
-    const errors_1$5 = es2018$3;
+    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)
@@ -1256,14 +1284,14 @@
     var slice$1 = {};
 
     slice$1.slice = void 0;
-    const go_1$4 = es2018$1;
-    const errors_1$4 = es2018$3;
+    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)
@@ -1297,9 +1325,9 @@
     var splitByAsync$1 = {};
 
     splitByAsync$1.splitByAsync = void 0;
-    const types_1$a = es2018;
+    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 {
@@ -1379,12 +1407,12 @@
     var takeAsync$1 = {};
 
     takeAsync$1.takeAsync = void 0;
-    const go_1$3 = es2018$1;
-    const errors_1$3 = es2018$3;
+    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) {
@@ -1400,12 +1428,12 @@
     var takeRightAsync$1 = {};
 
     takeRightAsync$1.takeRightAsync = void 0;
-    const go_1$2 = es2018$1;
-    const errors_1$2 = es2018$3;
+    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;
@@ -1430,12 +1458,12 @@
     var takeRight$1 = {};
 
     takeRight$1.takeRight = void 0;
-    const go_1$1 = es2018$1;
-    const errors_1$1 = es2018$3;
+    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;
@@ -1460,9 +1488,9 @@
     var takeUntilAsync$1 = {};
 
     takeUntilAsync$1.takeUntilAsync = void 0;
-    const types_1$9 = es2018;
+    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 {
@@ -1506,12 +1534,12 @@
     var take$1 = {};
 
     take$1.take = void 0;
-    const go_1 = es2018$1;
-    const errors_1 = es2018$3;
+    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) {
@@ -1527,9 +1555,9 @@
     var tapAsync$1 = {};
 
     tapAsync$1.tapAsync = void 0;
-    const types_1$8 = es2018;
+    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 {
@@ -1610,9 +1638,9 @@
     var uniqByAsync$1 = {};
 
     uniqByAsync$1.uniqByAsync = void 0;
-    const types_1$7 = es2018;
+    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 {
@@ -1679,7 +1707,7 @@
     var zipAsync$1 = {};
 
     zipAsync$1.zipAsync = void 0;
-    const types_1$6 = es2018;
+    const types_1$6 = es2018$3;
     var Kind;
     (function (Kind) {
         Kind[Kind["Sync"] = 0] = "Sync";
@@ -1693,7 +1721,7 @@
         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 {
@@ -1839,9 +1867,9 @@
     var eachAsync$1 = {};
 
     eachAsync$1.eachAsync = void 0;
-    const types_1$5 = es2018;
+    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 {
@@ -1879,9 +1907,9 @@
     var everyAsync$1 = {};
 
     everyAsync$1.everyAsync = void 0;
-    const types_1$4 = es2018;
+    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 {
@@ -1925,9 +1953,9 @@
     var findAsync$1 = {};
 
     findAsync$1.findAsync = void 0;
-    const types_1$3 = es2018;
+    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 {
@@ -2049,9 +2077,9 @@
     var reduceAsync$1 = {};
 
     reduceAsync$1.reduceAsync = void 0;
-    const types_1$2 = es2018;
+    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 {
@@ -2060,7 +2088,7 @@
     }
     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 {
@@ -2082,7 +2110,7 @@
         }
     }
     function reduceAsyncWithoutInitialValue(iterable, fn) {
-        if (types_1$2.isAsyncIterable(iterable)) {
+        if ((0, types_1$2.isAsyncIterable)(iterable)) {
             return reduceAsyncIterable(iterable);
         }
         else {
@@ -2145,9 +2173,9 @@
     var reduce$1 = {};
 
     reduce$1.reduce = void 0;
-    const types_1$1 = es2018;
+    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 {
@@ -2192,9 +2220,9 @@
     var someAsync$1 = {};
 
     someAsync$1.someAsync = void 0;
-    const types_1 = es2018;
+    const types_1 = es2018$3;
     function someAsync(iterable, predicate) {
-        if (types_1.isAsyncIterable(iterable)) {
+        if ((0, types_1.isAsyncIterable)(iterable)) {
             return someAsyncIterable(iterable);
         }
         else {
@@ -2284,7 +2312,7 @@
     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);
@@ -2299,7 +2327,7 @@
     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;
 
@@ -2308,7 +2336,7 @@
     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);
@@ -2323,7 +2351,7 @@
     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;
 
@@ -2376,15 +2404,15 @@
     };__exportStar(middleware, exports);
     __exportStar(output, exports);
 
-    }(es2018$2));
+    }(es2018$5));
 
     var _LRUMap_limit, _LRUMap_map;
     class LRUMap {
         constructor(limit) {
             _LRUMap_limit.set(this, void 0);
             _LRUMap_map.set(this, new Map());
-            es2018$3.assert(Number.isInteger(limit), 'The parameter limit must be an integer');
-            es2018$3.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)]() {
@@ -2432,26 +2460,432 @@
          * Return the earliest key inserted in the Map
          */
         getColdestKey() {
-            return es2018$2.first(__classPrivateFieldGet(this, _LRUMap_map, "f").keys());
+            return es2018$5.first(__classPrivateFieldGet(this, _LRUMap_map, "f").keys());
         }
     }
 
-    var _TrieMap_root;
-    class TrieNode {
-        constructor(value) {
-            this.value = value;
-            this.children = new Map();
-        }
+    var es2018$2 = {};
+
+    var exponentialBackoff = {};
+
+    var es2018$1 = {};
+
+    var random$1 = {};
+
+    random$1.random = void 0;
+    function random(min, max) {
+        return Math.random() * (max - min) + min;
     }
-    class TrieMap {
-        constructor() {
-            _TrieMap_root.set(this, new TrieNode());
-        }
-        get [(_TrieMap_root = new WeakMap(), Symbol.toStringTag)]() {
-            return this.constructor.name;
-        }
-        set(key, value) {
-            let node = __classPrivateFieldGet(this, _TrieMap_root, "f");
+    random$1.random = random;
+
+    var randomInt$1 = {};
+
+    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;
+    }
+    randomInt$1.randomInt = randomInt;
+
+    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$2;
+    function setImmediate(cb) {
+        if (globalThis.setImmediate) {
+            const timer = globalThis.setImmediate(cb);
+            return () => clearImmediate(timer);
+        }
+        else {
+            return (0, set_timeout_1$2.setTimeout)(0, cb);
+        }
+    }
+    setImmediate$1.setImmediate = setImmediate;
+
+    var setTimeoutLoop$1 = {};
+
+    setTimeoutLoop$1.setTimeoutLoop = void 0;
+    const set_timeout_1$1 = setTimeout$2;
+    function setTimeoutLoop(timeout, cb) {
+        let isCancelled = false;
+        let cancel = (0, set_timeout_1$1.setTimeout)(timeout, loop);
+        return () => {
+            isCancelled = true;
+            cancel();
+        };
+        async function loop() {
+            await cb();
+            if (!isCancelled) {
+                cancel = (0, set_timeout_1$1.setTimeout)(timeout, loop);
+            }
+        }
+    }
+    setTimeoutLoop$1.setTimeoutLoop = setTimeoutLoop;
+
+    var setDynamicTimeoutLoop$1 = {};
+
+    setDynamicTimeoutLoop$1.setDynamicTimeoutLoop = void 0;
+    const set_timeout_1 = setTimeout$2;
+    function setDynamicTimeoutLoop(timeout, cb) {
+        let isCancelled = false;
+        let cancel = (0, set_timeout_1.setTimeout)(timeout, loop);
+        return () => {
+            isCancelled = true;
+            cancel();
+        };
+        async function loop() {
+            const start = Date.now();
+            await cb();
+            const elapsed = Date.now() - start;
+            if (!isCancelled) {
+                cancel = (0, set_timeout_1.setTimeout)(Math.max(timeout - elapsed, 0), loop);
+            }
+        }
+    }
+    setDynamicTimeoutLoop$1.setDynamicTimeoutLoop = setDynamicTimeoutLoop;
+
+    (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(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$2));
+
+    var _ExpirableMap_map, _ExpirableMap_cancelClearTimeout;
+    class ExpirableMap {
+        constructor() {
+            _ExpirableMap_map.set(this, new Map());
+            _ExpirableMap_cancelClearTimeout.set(this, void 0);
+            /**
+             * 按过期时间升序排列所有项目的元数据
+             */
+            this.itemMetadataSortedByExpirationTime = [];
+        }
+        get [(_ExpirableMap_map = new WeakMap(), _ExpirableMap_cancelClearTimeout = new WeakMap(), Symbol.toStringTag)]() {
+            return this.constructor.name;
+        }
+        get size() {
+            return __classPrivateFieldGet(this, _ExpirableMap_map, "f").size;
+        }
+        set(key, value, maxAge) {
+            __classPrivateFieldGet(this, _ExpirableMap_map, "f").set(key, value);
+            this.removeItemMetadata(key);
+            this.addItemMetadata(key, Date.now() + maxAge);
+            return this;
+        }
+        has(key) {
+            return __classPrivateFieldGet(this, _ExpirableMap_map, "f").has(key);
+        }
+        get(key) {
+            return __classPrivateFieldGet(this, _ExpirableMap_map, "f").get(key);
+        }
+        delete(key) {
+            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.rescheduleClearTimeout();
+                }
+            }
+            return exists;
+        }
+        clear() {
+            var _a;
+            __classPrivateFieldGet(this, _ExpirableMap_map, "f").clear();
+            (_a = __classPrivateFieldGet(this, _ExpirableMap_cancelClearTimeout, "f")) === null || _a === void 0 ? void 0 : _a.call(this);
+            this.itemMetadataSortedByExpirationTime = [];
+        }
+        addItemMetadata(key, expirationTime) {
+            for (let i = 0; i < this.itemMetadataSortedByExpirationTime.length; i++) {
+                const item = this.itemMetadataSortedByExpirationTime[i];
+                if (expirationTime < item.expirationTime) {
+                    this.itemMetadataSortedByExpirationTime.splice(i, 0, { key, expirationTime });
+                    // 如果本次插入导致原先的第一个项目不再是低一个项目, 则需要重新规划过期回调
+                    if (i === 0) {
+                        this.rescheduleClearTimeout();
+                    }
+                    return;
+                }
+            }
+            // 如果代码运行到此处, 意味着数组要么为空, 要么新项目过期时间大于数组内的所有项目, 故直接插入到数组尾端.
+            this.itemMetadataSortedByExpirationTime.push({ key, expirationTime });
+            // 如果新插入的项目是唯一而项目, 则需要重新规划过期回调
+            if (this.itemMetadataSortedByExpirationTime.length === 1) {
+                this.rescheduleClearTimeout();
+            }
+        }
+        removeItemMetadata(key) {
+            const index = this.itemMetadataSortedByExpirationTime.findIndex(x => x.key === key);
+            if (index >= 0) {
+                this.itemMetadataSortedByExpirationTime.splice(index, 1);
+                // 如果被移除的是第一个项目, 则需要重新规划过期回调
+                if (index === 0) {
+                    this.rescheduleClearTimeout();
+                }
+            }
+        }
+        clearExpiredItems(timestamp) {
+            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));
+        }
+        rescheduleClearTimeout() {
+            var _a;
+            (_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$2.setSchedule(item.expirationTime, () => {
+                        this.clearExpiredItems(Date.now());
+                        this.rescheduleClearTimeout();
+                    });
+                    __classPrivateFieldSet(this, _ExpirableMap_cancelClearTimeout, () => {
+                        cancel();
+                        __classPrivateFieldSet(this, _ExpirableMap_cancelClearTimeout, undefined, "f");
+                    }, "f");
+                }
+            }
+        }
+    }
+
+    var _TLRUMap_limit, _TLRUMap_map, _TLRUMap_cancelClearTimeout;
+    /**
+     * TLRUMap = LRUMap + ExpirableMap
+     */
+    class TLRUMap {
+        constructor(limit) {
+            _TLRUMap_limit.set(this, void 0);
+            _TLRUMap_map.set(this, new Map());
+            _TLRUMap_cancelClearTimeout.set(this, void 0);
+            /**
+             * 按过期时间升序排列所有项目的元数据
+             */
+            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_cancelClearTimeout = new WeakMap(), Symbol.toStringTag)]() {
+            return this.constructor.name;
+        }
+        get size() {
+            return __classPrivateFieldGet(this, _TLRUMap_map, "f").size;
+        }
+        set(key, value, maxAge) {
+            if (__classPrivateFieldGet(this, _TLRUMap_map, "f").has(key)) {
+                this.updateItem(key, value);
+                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.addItemMetadata(key, Date.now() + maxAge);
+            }
+            return this;
+        }
+        has(key) {
+            return __classPrivateFieldGet(this, _TLRUMap_map, "f").has(key);
+        }
+        get(key) {
+            if (this.has(key)) {
+                const value = __classPrivateFieldGet(this, _TLRUMap_map, "f").get(key);
+                this.updateItem(key, value);
+                return value;
+            }
+            else {
+                return undefined;
+            }
+        }
+        delete(key) {
+            const result = __classPrivateFieldGet(this, _TLRUMap_map, "f").delete(key);
+            if (result) {
+                const index = this.itemMetadataSortedByExpirationTime.findIndex(x => x.key === key);
+                this.itemMetadataSortedByExpirationTime.splice(index, 1);
+                // 如果被删除的项目是第一个项目, 则需要重新规划过期回调
+                if (index === 0) {
+                    this.rescheduleClearTimeout();
+                }
+            }
+            return result;
+        }
+        clear() {
+            var _a;
+            __classPrivateFieldGet(this, _TLRUMap_map, "f").clear();
+            (_a = __classPrivateFieldGet(this, _TLRUMap_cancelClearTimeout, "f")) === null || _a === void 0 ? void 0 : _a.call(this);
+            this.itemMetadataSortedByExpirationTime = [];
+        }
+        /**
+         * 重新插入项目, 这会使项目置于#map迭代器的末端.
+         */
+        updateItem(key, value) {
+            __classPrivateFieldGet(this, _TLRUMap_map, "f").delete(key);
+            __classPrivateFieldGet(this, _TLRUMap_map, "f").set(key, value);
+        }
+        addItemMetadata(key, expirationTime) {
+            for (let i = 0; i < this.itemMetadataSortedByExpirationTime.length; i++) {
+                const item = this.itemMetadataSortedByExpirationTime[i];
+                if (expirationTime < item.expirationTime) {
+                    this.itemMetadataSortedByExpirationTime.splice(i, 0, { key, expirationTime });
+                    // 如果本次插入导致原先的第一个项目不再是低一个项目, 则需要重新规划过期回调
+                    if (i === 0) {
+                        this.rescheduleClearTimeout();
+                    }
+                    return;
+                }
+            }
+            // 如果代码运行到此处, 意味着数组要么为空, 要么新项目过期时间大于数组内的所有项目, 故直接插入到数组尾端.
+            this.itemMetadataSortedByExpirationTime.push({ key, expirationTime });
+            // 如果新插入的项目是唯一而项目, 则需要重新规划过期回调
+            if (this.itemMetadataSortedByExpirationTime.length === 1) {
+                this.rescheduleClearTimeout();
+            }
+        }
+        removeItemMetadata(key) {
+            const index = this.itemMetadataSortedByExpirationTime.findIndex(x => x.key === key);
+            if (index >= 0) {
+                this.itemMetadataSortedByExpirationTime.splice(index, 1);
+                // 如果被移除的是第一个项目, 则需要重新规划过期回调
+                if (index === 0) {
+                    this.rescheduleClearTimeout();
+                }
+            }
+        }
+        clearExpiredItems(timestamp) {
+            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));
+        }
+        rescheduleClearTimeout() {
+            var _a;
+            (_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$2.setSchedule(item.expirationTime, () => {
+                        this.clearExpiredItems(Date.now());
+                        this.rescheduleClearTimeout();
+                    });
+                    __classPrivateFieldSet(this, _TLRUMap_cancelClearTimeout, () => {
+                        cancel();
+                        __classPrivateFieldSet(this, _TLRUMap_cancelClearTimeout, undefined, "f");
+                    }, "f");
+                }
+            }
+        }
+        /**
+         * Return the earliest key inserted in the Map
+         */
+        getColdestKey() {
+            return es2018$5.first(__classPrivateFieldGet(this, _TLRUMap_map, "f").keys());
+        }
+    }
+
+    var _TrieMap_root;
+    class TrieNode {
+        constructor(value) {
+            this.value = value;
+            this.children = new Map();
+        }
+    }
+    class TrieMap {
+        constructor() {
+            _TrieMap_root.set(this, new TrieNode());
+        }
+        get [(_TrieMap_root = new WeakMap(), Symbol.toStringTag)]() {
+            return this.constructor.name;
+        }
+        set(key, value) {
+            let node = __classPrivateFieldGet(this, _TrieMap_root, "f");
             for (const part of key) {
                 if (!node.children.has(part)) {
                     node.children.set(part, new TrieNode());
@@ -2500,7 +2934,7 @@
             delete node.value;
             // 如果节点没有后缀, 则代表这是末端节点, 往前删除其前缀
             if (node.children.size === 0) {
-                for (const [part, parentNode] of es2018$2.toArray(es2018$2.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;
@@ -2510,16 +2944,1103 @@
         }
     }
 
+    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.stateChanged = new Subject();
+        }
+        get stateChangedObservable() {
+            return this.stateChanged;
+        }
+        /**
+         * @throws {BadEventError}
+         */
+        send(event) {
+            const oldState = this.state;
+            super.send(event);
+            const newState = this.state;
+            this.stateChanged.next({ event, oldState, newState });
+            if (es2018.isEmptyObject(this.schema[newState])) {
+                this.stateChanged.complete();
+            }
+        }
+    }
+
+    exports.BadEventError = BadEventError;
+    exports.Box = Box;
     exports.Emitter = Emitter;
+    exports.ExpirableMap = ExpirableMap;
+    exports.FiniteStateMachine = FiniteStateMachine;
     exports.HashMap = HashMap;
     exports.HashSet = HashSet;
     exports.LRUMap = LRUMap;
+    exports.ObservableFiniteStateMachine = ObservableFiniteStateMachine;
     exports.Queue = Queue;
+    exports.TLRUMap = TLRUMap;
     exports.TrieMap = TrieMap;
     exports.convertArrayToCons = convertArrayToCons;
     exports.convertConsToArray = convertConsToArray;
 
     Object.defineProperty(exports, '__esModule', { value: true });
 
-})));
+}));
 //# sourceMappingURL=index.umd.js.map