@blackglory/structures 0.2.3 → 0.2.7

package/dist/es2018/index.mjs

@@ -1,12 +1,3 @@
-function convertConsToArray([value, next]) {
-    if (next === null)
-        return [value];
-    return [value, ...convertConsToArray(next)];
-}
-function convertArrayToCons([value, ...next]) {
-    return [value, next.length ? convertArrayToCons(next) : null];
-}
-
 /*! *****************************************************************************
 Copyright (c) Microsoft Corporation.
 
@@ -35,6 +26,30 @@ function __classPrivateFieldSet(receiver, state, value, kind, f) {
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 }
 
+var _Box_value;
+class Box {
+    constructor(value) {
+        _Box_value.set(this, void 0);
+        __classPrivateFieldSet(this, _Box_value, value, "f");
+    }
+    set(value) {
+        __classPrivateFieldSet(this, _Box_value, value, "f");
+    }
+    get() {
+        return __classPrivateFieldGet(this, _Box_value, "f");
+    }
+}
+_Box_value = new WeakMap();
+
+function convertConsToArray([value, next]) {
+    if (next === null)
+        return [value];
+    return [value, ...convertConsToArray(next)];
+}
+function convertArrayToCons([value, ...next]) {
+    return [value, next.length ? convertArrayToCons(next) : null];
+}
+
 var _Emitter_map;
 class Emitter {
     constructor() {
@@ -163,7 +178,7 @@ class Queue {
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
-var es2018$3 = {};
+var es2018$5 = {};
 
 var customError = {};
 
@@ -241,73 +256,15 @@ __exportStar(normalize$1, exports);
 __exportStar(refute$1, exports);
 __exportStar(assert$1, exports);
 
-}(es2018$3));
+}(es2018$5));
 
-var _LRUMap_limit, _LRUMap_map;
-class LRUMap {
-    constructor(limit) {
-        _LRUMap_limit.set(this, void 0);
-        _LRUMap_map.set(this, new Map());
-        es2018$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');
-        __classPrivateFieldSet(this, _LRUMap_limit, limit, "f");
-    }
-    get [(_LRUMap_limit = new WeakMap(), _LRUMap_map = new WeakMap(), Symbol.toStringTag)]() {
-        return this.constructor.name;
-    }
-    get size() {
-        return __classPrivateFieldGet(this, _LRUMap_map, "f").size;
-    }
-    set(key, value) {
-        if (__classPrivateFieldGet(this, _LRUMap_map, "f").has(key)) {
-            this.updateItem(key, value);
-        }
-        else {
-            if (__classPrivateFieldGet(this, _LRUMap_map, "f").size === __classPrivateFieldGet(this, _LRUMap_limit, "f")) {
-                __classPrivateFieldGet(this, _LRUMap_map, "f").delete(this.getColdestKey());
-            }
-            __classPrivateFieldGet(this, _LRUMap_map, "f").set(key, value);
-        }
-        return this;
-    }
-    has(key) {
-        return __classPrivateFieldGet(this, _LRUMap_map, "f").has(key);
-    }
-    get(key) {
-        if (!this.has(key))
-            return undefined;
-        const value = __classPrivateFieldGet(this, _LRUMap_map, "f").get(key);
-        this.updateItem(key, value);
-        return value;
-    }
-    delete(key) {
-        return __classPrivateFieldGet(this, _LRUMap_map, "f").delete(key);
-    }
-    clear() {
-        __classPrivateFieldGet(this, _LRUMap_map, "f").clear();
-    }
-    /**
-     * Reinsert the item.
-     */
-    updateItem(key, value) {
-        __classPrivateFieldGet(this, _LRUMap_map, "f").delete(key);
-        __classPrivateFieldGet(this, _LRUMap_map, "f").set(key, value);
-    }
-    /**
-     * Return the earliest key inserted in the Map
-     */
-    getColdestKey() {
-        return __classPrivateFieldGet(this, _LRUMap_map, "f").keys().next().value;
-    }
-}
-
-var es2018$2 = {};
+var es2018$4 = {};
 
 var middleware = {};
 
 var chunkAsync$1 = {};
 
-var es2018$1 = {};
+var es2018$3 = {};
 
 var go$1 = {};
 
@@ -329,15 +286,15 @@ var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };__exportStar(go$1, exports);
 
-}(es2018$1));
+}(es2018$3));
 
 chunkAsync$1.chunkAsync = void 0;
-const go_1$f = es2018$1;
-const errors_1$f = es2018$3;
+const go_1$f = es2018$3;
+const errors_1$f = es2018$5;
 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);
@@ -354,7 +311,7 @@ chunkAsync$1.chunkAsync = chunkAsync;
 
 var chunkByAsync$1 = {};
 
-var es2018 = {};
+var es2018$2 = {};
 
 var array = {};
 
@@ -406,8 +363,8 @@ 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)
+    return (0, null_1$1.isntNull)(val)
+        && (0, undefined_1$2.isntUndefined)(val)
         && typeof val[Symbol.asyncIterator] === 'function';
 }
 asyncIterable.isAsyncIterable = isAsyncIterable;
@@ -444,36 +401,20 @@ var char = {};
 
 var string = {};
 
-string.isntStringObject = string.isStringObject = string.isntStringPrimitive = string.isStringPrimitive = string.isntString = string.isString = void 0;
+string.isntString = string.isString = void 0;
 function isString(val) {
-    return isStringPrimitive(val) || isStringObject(val);
+    return typeof val === 'string';
 }
 string.isString = isString;
 function isntString(val) {
     return !isString(val);
 }
 string.isntString = isntString;
-function isStringPrimitive(val) {
-    return typeof val === 'string';
-}
-string.isStringPrimitive = isStringPrimitive;
-function isntStringPrimitive(val) {
-    return !isStringPrimitive(val);
-}
-string.isntStringPrimitive = isntStringPrimitive;
-function isStringObject(val) {
-    return typeof val === 'object' && val instanceof String;
-}
-string.isStringObject = isStringObject;
-function isntStringObject(val) {
-    return !isStringObject(val);
-}
-string.isntStringObject = isntStringObject;
 
-char.isntCharObject = char.isCharObject = char.isntCharPrimitive = char.isCharPrimitive = char.isntChar = char.isChar = void 0;
+char.isntChar = char.isChar = void 0;
 const string_1$1 = string;
 function isChar(val) {
-    return (string_1$1.isString(val) || string_1$1.isStringObject(val))
+    return (0, string_1$1.isString)(val)
         && val.length === 1;
 }
 char.isChar = isChar;
@@ -481,24 +422,6 @@ function isntChar(val) {
     return !isChar(val);
 }
 char.isntChar = isntChar;
-function isCharPrimitive(val) {
-    return string_1$1.isString(val)
-        && val.length === 1;
-}
-char.isCharPrimitive = isCharPrimitive;
-function isntCharPrimitive(val) {
-    return !isCharPrimitive(val);
-}
-char.isntCharPrimitive = isntCharPrimitive;
-function isCharObject(val) {
-    return string_1$1.isStringObject(val)
-        && val.length === 1;
-}
-char.isCharObject = isCharObject;
-function isntCharObject(val) {
-    return !isCharObject(val);
-}
-char.isntCharObject = isntCharObject;
 
 var date = {};
 
@@ -520,6 +443,18 @@ function inEnum(val, _enum) {
 }
 _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;
@@ -550,8 +485,8 @@ 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)
+    return (0, null_1.isntNull)(val)
+        && (0, undefined_1$1.isntUndefined)(val)
         && typeof val[Symbol.iterator] === 'function';
 }
 iterable.isIterable = isIterable;
@@ -605,16 +540,16 @@ const string_1 = string;
 const number_1 = number;
 const undefined_1 = _undefined;
 function isJsonRpcId(val) {
-    return string_1.isString(val) || number_1.isNumber(val);
+    return (0, string_1.isString)(val) || (0, number_1.isNumber)(val);
 }
 function isJsonRpcParams(val) {
-    return array_1.isArray(val) || object_1.isObject(val);
+    return (0, array_1.isArray)(val) || (0, 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)
+    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;
@@ -623,9 +558,9 @@ function isntJsonRpcNotification(val) {
 }
 jsonRpc.isntJsonRpcNotification = isntJsonRpcNotification;
 function isJsonRpcRequest(val) {
-    return object_1.isRecord(val)
-        && string_1.isString(val.jsonrpc)
-        && string_1.isString(val.method)
+    return (0, object_1.isRecord)(val)
+        && (0, string_1.isString)(val.jsonrpc)
+        && (0, string_1.isString)(val.method)
         && isJsonRpcId(val.id)
         && isJsonRpcParams(val.params);
 }
@@ -635,10 +570,10 @@ function isntJsonRpcRequest(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);
+    return (0, object_1.isRecord)(val)
+        && (0, string_1.isString)(val.jsonrpc)
+        && (0, string_1.isString)(val.id)
+        && (0, undefined_1.isntUndefined)(val.result);
 }
 jsonRpc.isJsonRpcSuccess = isJsonRpcSuccess;
 function isntJsonRpcSuccess(val) {
@@ -646,8 +581,8 @@ function isntJsonRpcSuccess(val) {
 }
 jsonRpc.isntJsonRpcSuccess = isntJsonRpcSuccess;
 function isJsonRpcError(val) {
-    return object_1.isRecord(val)
-        && string_1.isString(val.jsonrpc)
+    return (0, object_1.isRecord)(val)
+        && (0, string_1.isString)(val.jsonrpc)
         && isJsonRpcId(val.id)
         && isJsonRpcErrorObject(val.error);
 }
@@ -657,10 +592,10 @@ function isntJsonRpcError(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));
+    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 = {};
@@ -712,6 +647,7 @@ __exportStar(boolean, exports);
 __exportStar(char, exports);
 __exportStar(date, exports);
 __exportStar(_enum, exports);
+__exportStar(error, exports);
 __exportStar(falsy, exports);
 __exportStar(_function, exports);
 __exportStar(iterable, exports);
@@ -724,12 +660,12 @@ __exportStar(string, exports);
 __exportStar(_undefined, exports);
 __exportStar(url, exports);
 
-}(es2018));
+}(es2018$2));
 
 chunkByAsync$1.chunkByAsync = void 0;
-const types_1$h = es2018;
+const types_1$h = es2018$2;
 function chunkByAsync(iterable, predicate) {
-    if (types_1$h.isAsyncIterable(iterable)) {
+    if ((0, types_1$h.isAsyncIterable)(iterable)) {
         return chunkByAsyncIterable(iterable);
     }
     else {
@@ -788,12 +724,12 @@ chunkBy$1.chunkBy = chunkBy;
 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$3;
+const errors_1$e = es2018$5;
 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);
@@ -811,12 +747,12 @@ chunk$1.chunk = chunk;
 var concatAsync$1 = {};
 
 concatAsync$1.concatAsync = void 0;
-const types_1$g = es2018;
-const go_1$d = es2018$1;
+const types_1$g = es2018$2;
+const go_1$d = es2018$3;
 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;
                 }
@@ -834,9 +770,9 @@ concatAsync$1.concatAsync = concatAsync;
 var concat$1 = {};
 
 concat$1.concat = void 0;
-const go_1$c = es2018$1;
+const go_1$c = es2018$3;
 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;
         }
@@ -863,15 +799,15 @@ function* copyIterable(iterable) {
 utils.copyIterable = copyIterable;
 
 dropAsync$1.dropAsync = void 0;
-const go_1$b = es2018$1;
+const go_1$b = es2018$3;
 const utils_1$3 = utils;
-const errors_1$d = es2018$3;
+const errors_1$d = es2018$5;
 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;
@@ -898,15 +834,15 @@ dropAsync$1.dropAsync = dropAsync;
 var dropRightAsync$1 = {};
 
 dropRightAsync$1.dropRightAsync = void 0;
-const go_1$a = es2018$1;
+const go_1$a = es2018$3;
 const utils_1$2 = utils;
-const errors_1$c = es2018$3;
+const errors_1$c = es2018$5;
 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) {
@@ -926,15 +862,15 @@ async function toArrayAsync$2(iterable) {
 var dropRight$1 = {};
 
 dropRight$1.dropRight = void 0;
-const go_1$9 = es2018$1;
+const go_1$9 = es2018$3;
 const utils_1$1 = utils;
-const errors_1$b = es2018$3;
+const errors_1$b = es2018$5;
 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);
     });
@@ -944,9 +880,9 @@ dropRight$1.dropRight = dropRight;
 var dropUntilAsync$1 = {};
 
 dropUntilAsync$1.dropUntilAsync = void 0;
-const types_1$f = es2018;
+const types_1$f = es2018$2;
 function dropUntilAsync(iterable, predicate) {
-    if (types_1$f.isAsyncIterable(iterable)) {
+    if ((0, types_1$f.isAsyncIterable)(iterable)) {
         return dropUntilAsyncIterable(iterable);
     }
     else {
@@ -1026,15 +962,15 @@ dropUntil$1.dropUntil = dropUntil;
 var drop$1 = {};
 
 drop$1.drop = void 0;
-const go_1$8 = es2018$1;
+const go_1$8 = es2018$3;
 const utils_1 = utils;
-const errors_1$a = es2018$3;
+const errors_1$a = es2018$5;
 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;
@@ -1061,9 +997,9 @@ drop$1.drop = drop;
 var filterAsync$1 = {};
 
 filterAsync$1.filterAsync = void 0;
-const types_1$e = es2018;
+const types_1$e = es2018$2;
 function filterAsync(iterable, predicate) {
-    if (types_1$e.isAsyncIterable(iterable)) {
+    if ((0, types_1$e.isAsyncIterable)(iterable)) {
         return filterAsyncIterable(iterable);
     }
     else {
@@ -1108,9 +1044,9 @@ var flattenDeepAsync$1 = {};
 var flattenByAsync$1 = {};
 
 flattenByAsync$1.flattenByAsync = void 0;
-const types_1$d = es2018;
+const types_1$d = es2018$2;
 function flattenByAsync(iterable, predicate) {
-    if (types_1$d.isAsyncIterable(iterable)) {
+    if ((0, types_1$d.isAsyncIterable)(iterable)) {
         return flattenByAsyncIterable(iterable);
     }
     else {
@@ -1143,30 +1079,30 @@ function flattenByAsync(iterable, predicate) {
 }
 flattenByAsync$1.flattenByAsync = flattenByAsync;
 function isFiniteIterable$1(val) {
-    return types_1$d.isIterable(val) && types_1$d.isntChar(val);
+    return (0, types_1$d.isIterable)(val) && (0, types_1$d.isntChar)(val);
 }
 
 flattenDeepAsync$1.flattenDeepAsync = void 0;
 const flatten_by_async_1 = flattenByAsync$1;
-const errors_1$9 = es2018$3;
+const errors_1$9 = es2018$5;
 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$2;
 function flattenBy(iterable, predicate) {
     return flatten(iterable, 1);
     function* flatten(iterable, level) {
@@ -1182,18 +1118,18 @@ function flattenBy(iterable, predicate) {
 }
 flattenBy$1.flattenBy = flattenBy;
 function isFiniteIterable(val) {
-    return types_1$c.isIterable(val) && types_1$c.isntChar(val);
+    return (0, types_1$c.isIterable)(val) && (0, types_1$c.isntChar)(val);
 }
 
 var flattenDeep$1 = {};
 
 flattenDeep$1.flattenDeep = void 0;
 const flatten_by_1 = flattenBy$1;
-const errors_1$8 = es2018$3;
+const errors_1$8 = es2018$5;
 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;
 
@@ -1202,16 +1138,16 @@ var flatten$1 = {};
 flatten$1.flatten = void 0;
 const flatten_deep_1 = flattenDeep$1;
 function flatten(iterable) {
-    return flatten_deep_1.flattenDeep(iterable, 1);
+    return (0, flatten_deep_1.flattenDeep)(iterable, 1);
 }
 flatten$1.flatten = flatten;
 
 var mapAsync$1 = {};
 
 mapAsync$1.mapAsync = void 0;
-const types_1$b = es2018;
+const types_1$b = es2018$2;
 function mapAsync(iterable, fn) {
-    if (types_1$b.isAsyncIterable(iterable)) {
+    if ((0, types_1$b.isAsyncIterable)(iterable)) {
         return mapAsyncIterable(iterable);
     }
     else {
@@ -1249,14 +1185,14 @@ map$1.map = map;
 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$3;
+const errors_1$7 = es2018$5;
 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) {
@@ -1284,14 +1220,14 @@ function isProduction$1() {
 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$3;
+const errors_1$6 = es2018$5;
 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) {
@@ -1319,14 +1255,14 @@ function isProduction() {
 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$3;
+const errors_1$5 = es2018$5;
 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)
@@ -1342,14 +1278,14 @@ sliceAsync$1.sliceAsync = sliceAsync;
 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$3;
+const errors_1$4 = es2018$5;
 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)
@@ -1383,9 +1319,9 @@ splitAsync$1.splitAsync = splitAsync;
 var splitByAsync$1 = {};
 
 splitByAsync$1.splitByAsync = void 0;
-const types_1$a = es2018;
+const types_1$a = es2018$2;
 function splitByAsync(iterable, predicate) {
-    if (types_1$a.isAsyncIterable(iterable)) {
+    if ((0, types_1$a.isAsyncIterable)(iterable)) {
         return splitByAsyncIterable(iterable);
     }
     else {
@@ -1465,12 +1401,12 @@ split$1.split = split;
 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$3;
+const errors_1$3 = es2018$5;
 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) {
@@ -1486,12 +1422,12 @@ takeAsync$1.takeAsync = takeAsync;
 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$3;
+const errors_1$2 = es2018$5;
 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;
@@ -1516,12 +1452,12 @@ takeRightAsync$1.takeRightAsync = takeRightAsync;
 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$3;
+const errors_1$1 = es2018$5;
 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;
@@ -1546,9 +1482,9 @@ takeRight$1.takeRight = takeRight;
 var takeUntilAsync$1 = {};
 
 takeUntilAsync$1.takeUntilAsync = void 0;
-const types_1$9 = es2018;
+const types_1$9 = es2018$2;
 function takeUntilAsync(iterable, predicate) {
-    if (types_1$9.isAsyncIterable(iterable)) {
+    if ((0, types_1$9.isAsyncIterable)(iterable)) {
         return takeUntilAsyncIterable(iterable);
     }
     else {
@@ -1592,12 +1528,12 @@ takeUntil$1.takeUntil = takeUntil;
 var take$1 = {};
 
 take$1.take = void 0;
-const go_1 = es2018$1;
-const errors_1 = es2018$3;
+const go_1 = es2018$3;
+const errors_1 = es2018$5;
 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) {
@@ -1613,9 +1549,9 @@ take$1.take = take;
 var tapAsync$1 = {};
 
 tapAsync$1.tapAsync = void 0;
-const types_1$8 = es2018;
+const types_1$8 = es2018$2;
 function tapAsync(iterable, fn) {
-    if (types_1$8.isAsyncIterable(iterable)) {
+    if ((0, types_1$8.isAsyncIterable)(iterable)) {
         return tapAsyncIterable(iterable);
     }
     else {
@@ -1696,9 +1632,9 @@ uniqAsync$1.uniqAsync = uniqAsync;
 var uniqByAsync$1 = {};
 
 uniqByAsync$1.uniqByAsync = void 0;
-const types_1$7 = es2018;
+const types_1$7 = es2018$2;
 function uniqByAsync(iterable, fn) {
-    if (types_1$7.isAsyncIterable(iterable)) {
+    if ((0, types_1$7.isAsyncIterable)(iterable)) {
         return uniqByAsyncIterable(iterable);
     }
     else {
@@ -1765,7 +1701,7 @@ uniq$1.uniq = uniq;
 var zipAsync$1 = {};
 
 zipAsync$1.zipAsync = void 0;
-const types_1$6 = es2018;
+const types_1$6 = es2018$2;
 var Kind;
 (function (Kind) {
     Kind[Kind["Sync"] = 0] = "Sync";
@@ -1779,7 +1715,7 @@ async function* zipWithSize$1(...iterables) {
     var _a, _b, _c, _d;
     const length = iterables.length;
     const iterators = iterables.map(iterable => {
-        if (types_1$6.isAsyncIterable(iterable)) {
+        if ((0, types_1$6.isAsyncIterable)(iterable)) {
             return [Kind.Async, iterable[Symbol.asyncIterator]()];
         }
         else {
@@ -1925,9 +1861,9 @@ consume$1.consume = consume;
 var eachAsync$1 = {};
 
 eachAsync$1.eachAsync = void 0;
-const types_1$5 = es2018;
+const types_1$5 = es2018$2;
 function eachAsync(iterable, fn) {
-    if (types_1$5.isAsyncIterable(iterable)) {
+    if ((0, types_1$5.isAsyncIterable)(iterable)) {
         return eachAsyncIterable(iterable);
     }
     else {
@@ -1965,9 +1901,9 @@ each$1.each = each;
 var everyAsync$1 = {};
 
 everyAsync$1.everyAsync = void 0;
-const types_1$4 = es2018;
+const types_1$4 = es2018$2;
 function everyAsync(iterable, predicate) {
-    if (types_1$4.isAsyncIterable(iterable)) {
+    if ((0, types_1$4.isAsyncIterable)(iterable)) {
         return everyAsyncIterable(iterable);
     }
     else {
@@ -2011,9 +1947,9 @@ every$1.every = every;
 var findAsync$1 = {};
 
 findAsync$1.findAsync = void 0;
-const types_1$3 = es2018;
+const types_1$3 = es2018$2;
 function findAsync(iterable, predicate) {
-    if (types_1$3.isAsyncIterable(iterable)) {
+    if ((0, types_1$3.isAsyncIterable)(iterable)) {
         return findAsyncIterable(iterable);
     }
     else {
@@ -2135,9 +2071,9 @@ match$1.match = match;
 var reduceAsync$1 = {};
 
 reduceAsync$1.reduceAsync = void 0;
-const types_1$2 = es2018;
+const types_1$2 = es2018$2;
 function reduceAsync(iterable, fn, initialValue) {
-    if (types_1$2.isUndefined(initialValue)) {
+    if ((0, types_1$2.isUndefined)(initialValue)) {
         return reduceAsyncWithoutInitialValue(iterable, fn);
     }
     else {
@@ -2146,7 +2082,7 @@ function reduceAsync(iterable, fn, initialValue) {
 }
 reduceAsync$1.reduceAsync = reduceAsync;
 function reduceAsyncWithInitialValue(iterable, fn, initialValue) {
-    if (types_1$2.isAsyncIterable(iterable)) {
+    if ((0, types_1$2.isAsyncIterable)(iterable)) {
         return reduceAsyncIterable(iterable);
     }
     else {
@@ -2168,7 +2104,7 @@ function reduceAsyncWithInitialValue(iterable, fn, initialValue) {
     }
 }
 function reduceAsyncWithoutInitialValue(iterable, fn) {
-    if (types_1$2.isAsyncIterable(iterable)) {
+    if ((0, types_1$2.isAsyncIterable)(iterable)) {
         return reduceAsyncIterable(iterable);
     }
     else {
@@ -2231,9 +2167,9 @@ function reduceAsyncWithoutInitialValue(iterable, fn) {
 var reduce$1 = {};
 
 reduce$1.reduce = void 0;
-const types_1$1 = es2018;
+const types_1$1 = es2018$2;
 function reduce(iterable, fn, initialValue) {
-    if (types_1$1.isUndefined(initialValue)) {
+    if ((0, types_1$1.isUndefined)(initialValue)) {
         return reduceWithoutInitialValue(iterable, fn);
     }
     else {
@@ -2278,9 +2214,9 @@ function reduceWithoutInitialValue(iterable, fn) {
 var someAsync$1 = {};
 
 someAsync$1.someAsync = void 0;
-const types_1 = es2018;
+const types_1 = es2018$2;
 function someAsync(iterable, predicate) {
-    if (types_1.isAsyncIterable(iterable)) {
+    if ((0, types_1.isAsyncIterable)(iterable)) {
         return someAsyncIterable(iterable);
     }
     else {
@@ -2370,7 +2306,7 @@ var toArrayAsync$1 = {};
 toArrayAsync$1.toArrayAsync = void 0;
 const consume_1$3 = consume$1;
 function toArrayAsync(iterable) {
-    return consume_1$3.consume(iterable, async (iterable) => {
+    return (0, consume_1$3.consume)(iterable, async (iterable) => {
         const result = [];
         for await (const element of iterable) {
             result.push(element);
@@ -2385,7 +2321,7 @@ var toArray$1 = {};
 toArray$1.toArray = void 0;
 const consume_1$2 = consume$1;
 function toArray(iterable) {
-    return consume_1$2.consume(iterable, iterable => Array.from(iterable));
+    return (0, consume_1$2.consume)(iterable, iterable => Array.from(iterable));
 }
 toArray$1.toArray = toArray;
 
@@ -2394,7 +2330,7 @@ var toSetAsync$1 = {};
 toSetAsync$1.toSetAsync = void 0;
 const consume_1$1 = consume$1;
 function toSetAsync(iterable) {
-    return consume_1$1.consume(iterable, async (iterable) => {
+    return (0, consume_1$1.consume)(iterable, async (iterable) => {
         const result = new Set();
         for await (const element of iterable) {
             result.add(element);
@@ -2409,7 +2345,7 @@ var toSet$1 = {};
 toSet$1.toSet = void 0;
 const consume_1 = consume$1;
 function toSet(iterable) {
-    return consume_1.consume(iterable, iterable => new Set(iterable));
+    return (0, consume_1.consume)(iterable, iterable => new Set(iterable));
 }
 toSet$1.toSet = toSet;
 
@@ -2462,7 +2398,471 @@ var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m
 };__exportStar(middleware, exports);
 __exportStar(output, exports);
 
-}(es2018$2));
+}(es2018$4));
+
+var _LRUMap_limit, _LRUMap_map;
+class LRUMap {
+    constructor(limit) {
+        _LRUMap_limit.set(this, void 0);
+        _LRUMap_map.set(this, new Map());
+        es2018$5.assert(Number.isInteger(limit), 'The parameter limit must be an integer');
+        es2018$5.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)]() {
+        return this.constructor.name;
+    }
+    get size() {
+        return __classPrivateFieldGet(this, _LRUMap_map, "f").size;
+    }
+    set(key, value) {
+        if (__classPrivateFieldGet(this, _LRUMap_map, "f").has(key)) {
+            this.updateItem(key, value);
+        }
+        else {
+            if (__classPrivateFieldGet(this, _LRUMap_map, "f").size === __classPrivateFieldGet(this, _LRUMap_limit, "f")) {
+                __classPrivateFieldGet(this, _LRUMap_map, "f").delete(this.getColdestKey());
+            }
+            __classPrivateFieldGet(this, _LRUMap_map, "f").set(key, value);
+        }
+        return this;
+    }
+    has(key) {
+        return __classPrivateFieldGet(this, _LRUMap_map, "f").has(key);
+    }
+    get(key) {
+        if (!this.has(key))
+            return undefined;
+        const value = __classPrivateFieldGet(this, _LRUMap_map, "f").get(key);
+        this.updateItem(key, value);
+        return value;
+    }
+    delete(key) {
+        return __classPrivateFieldGet(this, _LRUMap_map, "f").delete(key);
+    }
+    clear() {
+        __classPrivateFieldGet(this, _LRUMap_map, "f").clear();
+    }
+    /**
+     * Reinsert the item.
+     */
+    updateItem(key, value) {
+        __classPrivateFieldGet(this, _LRUMap_map, "f").delete(key);
+        __classPrivateFieldGet(this, _LRUMap_map, "f").set(key, value);
+    }
+    /**
+     * Return the earliest key inserted in the Map
+     */
+    getColdestKey() {
+        return es2018$4.first(__classPrivateFieldGet(this, _LRUMap_map, "f").keys());
+    }
+}
+
+var es2018$1 = {};
+
+var exponentialBackoff = {};
+
+var es2018 = {};
+
+var random$1 = {};
+
+random$1.random = void 0;
+function random(min, max) {
+    return Math.random() * (max - min) + min;
+}
+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));
+
+exponentialBackoff.calculateExponentialBackoffTimeout = void 0;
+const extra_rand_1 = es2018;
+function calculateExponentialBackoffTimeout({ baseTimeout, retries, maxTimeout = Infinity, factor = 2, jitter = true }) {
+    const timeout = Math.min(factor ** retries * baseTimeout, maxTimeout);
+    if (jitter) {
+        return (0, extra_rand_1.randomIntInclusive)(0, timeout);
+    }
+    else {
+        return timeout;
+    }
+}
+exponentialBackoff.calculateExponentialBackoffTimeout = calculateExponentialBackoffTimeout;
+
+var setTimeout$1 = {};
+
+setTimeout$1.setTimeout = void 0;
+function setTimeout(timeout, cb) {
+    const timer = globalThis.setTimeout(cb, timeout);
+    return () => clearTimeout(timer);
+}
+setTimeout$1.setTimeout = setTimeout;
+
+var setSchedule$1 = {};
+
+setSchedule$1.setSchedule = void 0;
+const set_timeout_1$3 = setTimeout$1;
+function setSchedule(timestamp, cb) {
+    const timeout = timestamp - Date.now();
+    return (0, set_timeout_1$3.setTimeout)(timeout, cb);
+}
+setSchedule$1.setSchedule = setSchedule;
+
+var setInterval$1 = {};
+
+setInterval$1.setInterval = void 0;
+function setInterval(timeout, cb) {
+    const timer = globalThis.setInterval(cb, timeout);
+    return () => clearInterval(timer);
+}
+setInterval$1.setInterval = setInterval;
+
+var setImmediate$1 = {};
+
+setImmediate$1.setImmediate = void 0;
+const set_timeout_1$2 = setTimeout$1;
+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$1;
+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$1;
+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$1, exports);
+__exportStar(setSchedule$1, exports);
+__exportStar(setInterval$1, exports);
+__exportStar(setImmediate$1, exports);
+__exportStar(setTimeoutLoop$1, exports);
+__exportStar(setDynamicTimeoutLoop$1, exports);
+
+}(es2018$1));
+
+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$1.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$5.assert(Number.isInteger(limit), 'The parameter limit must be an integer');
+        es2018$5.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$1.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$4.first(__classPrivateFieldGet(this, _TLRUMap_map, "f").keys());
+    }
+}
 
 var _TrieMap_root;
 class TrieNode {
@@ -2528,7 +2928,7 @@ class TrieMap {
         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$4.toArray(es2018$4.zip(key, parentNodes)).reverse()) {
                 parentNode.children.delete(part);
                 if (parentNode.children.size !== 0)
                     break;
@@ -2538,5 +2938,5 @@ class TrieMap {
     }
 }
 
-export { Emitter, HashMap, HashSet, LRUMap, Queue, TrieMap, convertArrayToCons, convertConsToArray };
+export { Box, Emitter, ExpirableMap, HashMap, HashSet, LRUMap, Queue, TLRUMap, TrieMap, convertArrayToCons, convertConsToArray };
 //# sourceMappingURL=index.mjs.map