@blackglory/structures 0.2.6 → 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$4 = {};
+var es2018$5 = {};
 
 var customError = {};
 
@@ -241,15 +256,15 @@ __exportStar(normalize$1, exports);
 __exportStar(refute$1, exports);
 __exportStar(assert$1, exports);
 
-}(es2018$4));
+}(es2018$5));
 
-var es2018$3 = {};
+var es2018$4 = {};
 
 var middleware = {};
 
 var chunkAsync$1 = {};
 
-var es2018$2 = {};
+var es2018$3 = {};
 
 var go$1 = {};
 
@@ -271,11 +286,11 @@ var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };__exportStar(go$1, exports);
 
-}(es2018$2));
+}(es2018$3));
 
 chunkAsync$1.chunkAsync = void 0;
-const go_1$f = es2018$2;
-const errors_1$f = es2018$4;
+const go_1$f = es2018$3;
+const errors_1$f = es2018$5;
 function chunkAsync(iterable, size) {
     (0, errors_1$f.assert)(Number.isInteger(size), 'The parameter size must be an integer');
     (0, errors_1$f.assert)(size > 0, 'The parameter size must be greater than 0');
@@ -296,7 +311,7 @@ chunkAsync$1.chunkAsync = chunkAsync;
 
 var chunkByAsync$1 = {};
 
-var es2018$1 = {};
+var es2018$2 = {};
 
 var array = {};
 
@@ -645,10 +660,10 @@ __exportStar(string, exports);
 __exportStar(_undefined, exports);
 __exportStar(url, exports);
 
-}(es2018$1));
+}(es2018$2));
 
 chunkByAsync$1.chunkByAsync = void 0;
-const types_1$h = es2018$1;
+const types_1$h = es2018$2;
 function chunkByAsync(iterable, predicate) {
     if ((0, types_1$h.isAsyncIterable)(iterable)) {
         return chunkByAsyncIterable(iterable);
@@ -709,8 +724,8 @@ chunkBy$1.chunkBy = chunkBy;
 var chunk$1 = {};
 
 chunk$1.chunk = void 0;
-const go_1$e = es2018$2;
-const errors_1$e = es2018$4;
+const go_1$e = es2018$3;
+const errors_1$e = es2018$5;
 function chunk(iterable, size) {
     (0, errors_1$e.assert)(Number.isInteger(size), 'The parameter size must be an integer');
     (0, errors_1$e.assert)(size > 0, 'The parameter size must be greater than 0');
@@ -732,8 +747,8 @@ chunk$1.chunk = chunk;
 var concatAsync$1 = {};
 
 concatAsync$1.concatAsync = void 0;
-const types_1$g = es2018$1;
-const go_1$d = es2018$2;
+const types_1$g = es2018$2;
+const go_1$d = es2018$3;
 function concatAsync(iterable, ...otherIterables) {
     return (0, go_1$d.go)(async function* () {
         for (const iter of [iterable, ...otherIterables]) {
@@ -755,7 +770,7 @@ concatAsync$1.concatAsync = concatAsync;
 var concat$1 = {};
 
 concat$1.concat = void 0;
-const go_1$c = es2018$2;
+const go_1$c = es2018$3;
 function concat(iterable, ...otherIterables) {
     return (0, go_1$c.go)(function* () {
         for (const iter of [iterable, ...otherIterables]) {
@@ -784,9 +799,9 @@ function* copyIterable(iterable) {
 utils.copyIterable = copyIterable;
 
 dropAsync$1.dropAsync = void 0;
-const go_1$b = es2018$2;
+const go_1$b = es2018$3;
 const utils_1$3 = utils;
-const errors_1$d = es2018$4;
+const errors_1$d = es2018$5;
 function dropAsync(iterable, count) {
     (0, errors_1$d.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1$d.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
@@ -819,9 +834,9 @@ dropAsync$1.dropAsync = dropAsync;
 var dropRightAsync$1 = {};
 
 dropRightAsync$1.dropRightAsync = void 0;
-const go_1$a = es2018$2;
+const go_1$a = es2018$3;
 const utils_1$2 = utils;
-const errors_1$c = es2018$4;
+const errors_1$c = es2018$5;
 function dropRightAsync(iterable, count) {
     (0, errors_1$c.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1$c.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
@@ -847,9 +862,9 @@ async function toArrayAsync$2(iterable) {
 var dropRight$1 = {};
 
 dropRight$1.dropRight = void 0;
-const go_1$9 = es2018$2;
+const go_1$9 = es2018$3;
 const utils_1$1 = utils;
-const errors_1$b = es2018$4;
+const errors_1$b = es2018$5;
 function dropRight(iterable, count) {
     (0, errors_1$b.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1$b.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
@@ -865,7 +880,7 @@ dropRight$1.dropRight = dropRight;
 var dropUntilAsync$1 = {};
 
 dropUntilAsync$1.dropUntilAsync = void 0;
-const types_1$f = es2018$1;
+const types_1$f = es2018$2;
 function dropUntilAsync(iterable, predicate) {
     if ((0, types_1$f.isAsyncIterable)(iterable)) {
         return dropUntilAsyncIterable(iterable);
@@ -947,9 +962,9 @@ dropUntil$1.dropUntil = dropUntil;
 var drop$1 = {};
 
 drop$1.drop = void 0;
-const go_1$8 = es2018$2;
+const go_1$8 = es2018$3;
 const utils_1 = utils;
-const errors_1$a = es2018$4;
+const errors_1$a = es2018$5;
 function drop(iterable, count) {
     (0, errors_1$a.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1$a.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
@@ -982,7 +997,7 @@ drop$1.drop = drop;
 var filterAsync$1 = {};
 
 filterAsync$1.filterAsync = void 0;
-const types_1$e = es2018$1;
+const types_1$e = es2018$2;
 function filterAsync(iterable, predicate) {
     if ((0, types_1$e.isAsyncIterable)(iterable)) {
         return filterAsyncIterable(iterable);
@@ -1029,7 +1044,7 @@ var flattenDeepAsync$1 = {};
 var flattenByAsync$1 = {};
 
 flattenByAsync$1.flattenByAsync = void 0;
-const types_1$d = es2018$1;
+const types_1$d = es2018$2;
 function flattenByAsync(iterable, predicate) {
     if ((0, types_1$d.isAsyncIterable)(iterable)) {
         return flattenByAsyncIterable(iterable);
@@ -1069,7 +1084,7 @@ function isFiniteIterable$1(val) {
 
 flattenDeepAsync$1.flattenDeepAsync = void 0;
 const flatten_by_async_1 = flattenByAsync$1;
-const errors_1$9 = es2018$4;
+const errors_1$9 = es2018$5;
 function flattenDeepAsync(iterable, depth = Infinity) {
     (0, errors_1$9.assert)(depth === Infinity || Number.isInteger(depth), 'The parameter depth must be an integer');
     (0, errors_1$9.assert)(depth >= 0, 'The parameter depth must be greater than or equal to 0');
@@ -1087,7 +1102,7 @@ flattenAsync$1.flattenAsync = flattenAsync;
 var flattenBy$1 = {};
 
 flattenBy$1.flattenBy = void 0;
-const types_1$c = es2018$1;
+const types_1$c = es2018$2;
 function flattenBy(iterable, predicate) {
     return flatten(iterable, 1);
     function* flatten(iterable, level) {
@@ -1110,7 +1125,7 @@ var flattenDeep$1 = {};
 
 flattenDeep$1.flattenDeep = void 0;
 const flatten_by_1 = flattenBy$1;
-const errors_1$8 = es2018$4;
+const errors_1$8 = es2018$5;
 function flattenDeep(iterable, depth = Infinity) {
     (0, errors_1$8.assert)(depth === Infinity || Number.isInteger(depth), 'The parameter depth must be an integer');
     (0, errors_1$8.assert)(depth >= 0, 'The parameter depth must be greater than or equal to 0');
@@ -1130,7 +1145,7 @@ flatten$1.flatten = flatten;
 var mapAsync$1 = {};
 
 mapAsync$1.mapAsync = void 0;
-const types_1$b = es2018$1;
+const types_1$b = es2018$2;
 function mapAsync(iterable, fn) {
     if ((0, types_1$b.isAsyncIterable)(iterable)) {
         return mapAsyncIterable(iterable);
@@ -1170,8 +1185,8 @@ map$1.map = map;
 var repeatAsync$1 = {};
 
 repeatAsync$1.repeatAsync = void 0;
-const go_1$7 = es2018$2;
-const errors_1$7 = es2018$4;
+const go_1$7 = es2018$3;
+const errors_1$7 = es2018$5;
 function repeatAsync(iterable, times) {
     (0, errors_1$7.assert)(times === Infinity || Number.isInteger(times), 'The parameter times must be an integer');
     (0, errors_1$7.assert)(times >= 0, 'The parameter times must be greater than or equal to 0');
@@ -1205,8 +1220,8 @@ function isProduction$1() {
 var repeat$1 = {};
 
 repeat$1.repeat = void 0;
-const go_1$6 = es2018$2;
-const errors_1$6 = es2018$4;
+const go_1$6 = es2018$3;
+const errors_1$6 = es2018$5;
 function repeat(iterable, times) {
     (0, errors_1$6.assert)(times === Infinity || Number.isInteger(times), 'The parameter times must be an integer');
     (0, errors_1$6.assert)(times >= 0, 'The parameter times must be greater than or equal to 0');
@@ -1240,8 +1255,8 @@ function isProduction() {
 var sliceAsync$1 = {};
 
 sliceAsync$1.sliceAsync = void 0;
-const go_1$5 = es2018$2;
-const errors_1$5 = es2018$4;
+const go_1$5 = es2018$3;
+const errors_1$5 = es2018$5;
 function sliceAsync(iterable, start, end = Infinity) {
     (0, errors_1$5.assert)(Number.isInteger(start), 'The parameter start must be an integer');
     (0, errors_1$5.assert)(start >= 0, 'The parameter start must be greater than or equal to 0');
@@ -1263,8 +1278,8 @@ sliceAsync$1.sliceAsync = sliceAsync;
 var slice$1 = {};
 
 slice$1.slice = void 0;
-const go_1$4 = es2018$2;
-const errors_1$4 = es2018$4;
+const go_1$4 = es2018$3;
+const errors_1$4 = es2018$5;
 function slice(iterable, start, end = Infinity) {
     (0, errors_1$4.assert)(Number.isInteger(start), 'The parameter start must be an integer');
     (0, errors_1$4.assert)(start >= 0, 'The parameter start must be greater than or equal to 0');
@@ -1304,7 +1319,7 @@ splitAsync$1.splitAsync = splitAsync;
 var splitByAsync$1 = {};
 
 splitByAsync$1.splitByAsync = void 0;
-const types_1$a = es2018$1;
+const types_1$a = es2018$2;
 function splitByAsync(iterable, predicate) {
     if ((0, types_1$a.isAsyncIterable)(iterable)) {
         return splitByAsyncIterable(iterable);
@@ -1386,8 +1401,8 @@ split$1.split = split;
 var takeAsync$1 = {};
 
 takeAsync$1.takeAsync = void 0;
-const go_1$3 = es2018$2;
-const errors_1$3 = es2018$4;
+const go_1$3 = es2018$3;
+const errors_1$3 = es2018$5;
 function takeAsync(iterable, count) {
     (0, errors_1$3.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1$3.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
@@ -1407,8 +1422,8 @@ takeAsync$1.takeAsync = takeAsync;
 var takeRightAsync$1 = {};
 
 takeRightAsync$1.takeRightAsync = void 0;
-const go_1$2 = es2018$2;
-const errors_1$2 = es2018$4;
+const go_1$2 = es2018$3;
+const errors_1$2 = es2018$5;
 function takeRightAsync(iterable, count) {
     (0, errors_1$2.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1$2.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
@@ -1437,8 +1452,8 @@ takeRightAsync$1.takeRightAsync = takeRightAsync;
 var takeRight$1 = {};
 
 takeRight$1.takeRight = void 0;
-const go_1$1 = es2018$2;
-const errors_1$1 = es2018$4;
+const go_1$1 = es2018$3;
+const errors_1$1 = es2018$5;
 function takeRight(iterable, count) {
     (0, errors_1$1.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1$1.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
@@ -1467,7 +1482,7 @@ takeRight$1.takeRight = takeRight;
 var takeUntilAsync$1 = {};
 
 takeUntilAsync$1.takeUntilAsync = void 0;
-const types_1$9 = es2018$1;
+const types_1$9 = es2018$2;
 function takeUntilAsync(iterable, predicate) {
     if ((0, types_1$9.isAsyncIterable)(iterable)) {
         return takeUntilAsyncIterable(iterable);
@@ -1513,8 +1528,8 @@ takeUntil$1.takeUntil = takeUntil;
 var take$1 = {};
 
 take$1.take = void 0;
-const go_1 = es2018$2;
-const errors_1 = es2018$4;
+const go_1 = es2018$3;
+const errors_1 = es2018$5;
 function take(iterable, count) {
     (0, errors_1.assert)(Number.isInteger(count), 'The parameter count must be an integer');
     (0, errors_1.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
@@ -1534,7 +1549,7 @@ take$1.take = take;
 var tapAsync$1 = {};
 
 tapAsync$1.tapAsync = void 0;
-const types_1$8 = es2018$1;
+const types_1$8 = es2018$2;
 function tapAsync(iterable, fn) {
     if ((0, types_1$8.isAsyncIterable)(iterable)) {
         return tapAsyncIterable(iterable);
@@ -1617,7 +1632,7 @@ uniqAsync$1.uniqAsync = uniqAsync;
 var uniqByAsync$1 = {};
 
 uniqByAsync$1.uniqByAsync = void 0;
-const types_1$7 = es2018$1;
+const types_1$7 = es2018$2;
 function uniqByAsync(iterable, fn) {
     if ((0, types_1$7.isAsyncIterable)(iterable)) {
         return uniqByAsyncIterable(iterable);
@@ -1686,7 +1701,7 @@ uniq$1.uniq = uniq;
 var zipAsync$1 = {};
 
 zipAsync$1.zipAsync = void 0;
-const types_1$6 = es2018$1;
+const types_1$6 = es2018$2;
 var Kind;
 (function (Kind) {
     Kind[Kind["Sync"] = 0] = "Sync";
@@ -1846,7 +1861,7 @@ consume$1.consume = consume;
 var eachAsync$1 = {};
 
 eachAsync$1.eachAsync = void 0;
-const types_1$5 = es2018$1;
+const types_1$5 = es2018$2;
 function eachAsync(iterable, fn) {
     if ((0, types_1$5.isAsyncIterable)(iterable)) {
         return eachAsyncIterable(iterable);
@@ -1886,7 +1901,7 @@ each$1.each = each;
 var everyAsync$1 = {};
 
 everyAsync$1.everyAsync = void 0;
-const types_1$4 = es2018$1;
+const types_1$4 = es2018$2;
 function everyAsync(iterable, predicate) {
     if ((0, types_1$4.isAsyncIterable)(iterable)) {
         return everyAsyncIterable(iterable);
@@ -1932,7 +1947,7 @@ every$1.every = every;
 var findAsync$1 = {};
 
 findAsync$1.findAsync = void 0;
-const types_1$3 = es2018$1;
+const types_1$3 = es2018$2;
 function findAsync(iterable, predicate) {
     if ((0, types_1$3.isAsyncIterable)(iterable)) {
         return findAsyncIterable(iterable);
@@ -2056,7 +2071,7 @@ match$1.match = match;
 var reduceAsync$1 = {};
 
 reduceAsync$1.reduceAsync = void 0;
-const types_1$2 = es2018$1;
+const types_1$2 = es2018$2;
 function reduceAsync(iterable, fn, initialValue) {
     if ((0, types_1$2.isUndefined)(initialValue)) {
         return reduceAsyncWithoutInitialValue(iterable, fn);
@@ -2152,7 +2167,7 @@ function reduceAsyncWithoutInitialValue(iterable, fn) {
 var reduce$1 = {};
 
 reduce$1.reduce = void 0;
-const types_1$1 = es2018$1;
+const types_1$1 = es2018$2;
 function reduce(iterable, fn, initialValue) {
     if ((0, types_1$1.isUndefined)(initialValue)) {
         return reduceWithoutInitialValue(iterable, fn);
@@ -2199,7 +2214,7 @@ function reduceWithoutInitialValue(iterable, fn) {
 var someAsync$1 = {};
 
 someAsync$1.someAsync = void 0;
-const types_1 = es2018$1;
+const types_1 = es2018$2;
 function someAsync(iterable, predicate) {
     if ((0, types_1.isAsyncIterable)(iterable)) {
         return someAsyncIterable(iterable);
@@ -2383,15 +2398,15 @@ var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m
 };__exportStar(middleware, exports);
 __exportStar(output, exports);
 
-}(es2018$3));
+}(es2018$4));
 
 var _LRUMap_limit, _LRUMap_map;
 class LRUMap {
     constructor(limit) {
         _LRUMap_limit.set(this, void 0);
         _LRUMap_map.set(this, new Map());
-        es2018$4.assert(Number.isInteger(limit), 'The parameter limit must be an integer');
-        es2018$4.assert(limit > 0, 'The parameter limit must be a positive value');
+        es2018$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)]() {
@@ -2439,12 +2454,73 @@ class LRUMap {
      * Return the earliest key inserted in the Map
      */
     getColdestKey() {
-        return es2018$3.first(__classPrivateFieldGet(this, _LRUMap_map, "f").keys());
+        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;
@@ -2501,8 +2577,9 @@ function setTimeoutLoop(timeout, cb) {
     };
     async function loop() {
         await cb();
-        if (!isCancelled)
+        if (!isCancelled) {
             cancel = (0, set_timeout_1$1.setTimeout)(timeout, loop);
+        }
     }
 }
 setTimeoutLoop$1.setTimeoutLoop = setTimeoutLoop;
@@ -2522,8 +2599,9 @@ function setDynamicTimeoutLoop(timeout, cb) {
         const start = Date.now();
         await cb();
         const elapsed = Date.now() - start;
-        if (!isCancelled)
+        if (!isCancelled) {
             cancel = (0, set_timeout_1.setTimeout)(Math.max(timeout - elapsed, 0), loop);
+        }
     }
 }
 setDynamicTimeoutLoop$1.setDynamicTimeoutLoop = setDynamicTimeoutLoop;
@@ -2538,14 +2616,15 @@ var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Obj
 }));
 var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};__exportStar(setTimeout$1, exports);
+};__exportStar(exponentialBackoff, exports);
+__exportStar(setTimeout$1, exports);
 __exportStar(setSchedule$1, exports);
 __exportStar(setInterval$1, exports);
 __exportStar(setImmediate$1, exports);
 __exportStar(setTimeoutLoop$1, exports);
 __exportStar(setDynamicTimeoutLoop$1, exports);
 
-}(es2018));
+}(es2018$1));
 
 var _ExpirableMap_map, _ExpirableMap_cancelClearTimeout;
 class ExpirableMap {
@@ -2635,7 +2714,7 @@ class ExpirableMap {
         if (this.itemMetadataSortedByExpirationTime.length > 0) {
             const item = this.itemMetadataSortedByExpirationTime[0];
             if (Number.isFinite(item.expirationTime)) {
-                const cancel = es2018.setSchedule(item.expirationTime, () => {
+                const cancel = es2018$1.setSchedule(item.expirationTime, () => {
                     this.clearExpiredItems(Date.now());
                     this.rescheduleClearTimeout();
                 });
@@ -2661,8 +2740,8 @@ class TLRUMap {
          * 按过期时间升序排列所有项目的元数据
          */
         this.itemMetadataSortedByExpirationTime = [];
-        es2018$4.assert(Number.isInteger(limit), 'The parameter limit must be an integer');
-        es2018$4.assert(limit > 0, 'The parameter limit must be a positive value');
+        es2018$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)]() {
@@ -2766,7 +2845,7 @@ class TLRUMap {
         if (this.itemMetadataSortedByExpirationTime.length > 0) {
             const item = this.itemMetadataSortedByExpirationTime[0];
             if (Number.isFinite(item.expirationTime)) {
-                const cancel = es2018.setSchedule(item.expirationTime, () => {
+                const cancel = es2018$1.setSchedule(item.expirationTime, () => {
                     this.clearExpiredItems(Date.now());
                     this.rescheduleClearTimeout();
                 });
@@ -2781,7 +2860,7 @@ class TLRUMap {
      * Return the earliest key inserted in the Map
      */
     getColdestKey() {
-        return es2018$3.first(__classPrivateFieldGet(this, _TLRUMap_map, "f").keys());
+        return es2018$4.first(__classPrivateFieldGet(this, _TLRUMap_map, "f").keys());
     }
 }
 
@@ -2849,7 +2928,7 @@ class TrieMap {
         delete node.value;
         // 如果节点没有后缀, 则代表这是末端节点, 往前删除其前缀
         if (node.children.size === 0) {
-            for (const [part, parentNode] of es2018$3.toArray(es2018$3.zip(key, parentNodes)).reverse()) {
+            for (const [part, parentNode] of es2018$4.toArray(es2018$4.zip(key, parentNodes)).reverse()) {
                 parentNode.children.delete(part);
                 if (parentNode.children.size !== 0)
                     break;
@@ -2859,5 +2938,5 @@ class TrieMap {
     }
 }
 
-export { Emitter, ExpirableMap, HashMap, HashSet, LRUMap, Queue, TLRUMap, TrieMap, convertArrayToCons, convertConsToArray };
+export { Box, Emitter, ExpirableMap, HashMap, HashSet, LRUMap, Queue, TLRUMap, TrieMap, convertArrayToCons, convertConsToArray };
 //# sourceMappingURL=index.mjs.map