@blackglory/structures 0.2.6 → 0.2.7

package/dist/es2018/index.umd.js

@@ -4,15 +4,6 @@
     (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];
-    }
-
     /*! *****************************************************************************
     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$4 = {};
+    var es2018$5 = {};
 
     var customError = {};
 
@@ -247,15 +262,15 @@
     __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 = {};
 
@@ -277,11 +292,11 @@
         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');
@@ -302,7 +317,7 @@
 
     var chunkByAsync$1 = {};
 
-    var es2018$1 = {};
+    var es2018$2 = {};
 
     var array = {};
 
@@ -651,10 +666,10 @@
     __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);
@@ -715,8 +730,8 @@
     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');
@@ -738,8 +753,8 @@
     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]) {
@@ -761,7 +776,7 @@
     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]) {
@@ -790,9 +805,9 @@
     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');
@@ -825,9 +840,9 @@
     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');
@@ -853,9 +868,9 @@
     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');
@@ -871,7 +886,7 @@
     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);
@@ -953,9 +968,9 @@
     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');
@@ -988,7 +1003,7 @@
     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);
@@ -1035,7 +1050,7 @@
     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);
@@ -1075,7 +1090,7 @@
 
     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');
@@ -1093,7 +1108,7 @@
     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) {
@@ -1116,7 +1131,7 @@
 
     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');
@@ -1136,7 +1151,7 @@
     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);
@@ -1176,8 +1191,8 @@
     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');
@@ -1211,8 +1226,8 @@
     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');
@@ -1246,8 +1261,8 @@
     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');
@@ -1269,8 +1284,8 @@
     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');
@@ -1310,7 +1325,7 @@
     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);
@@ -1392,8 +1407,8 @@
     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');
@@ -1413,8 +1428,8 @@
     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');
@@ -1443,8 +1458,8 @@
     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');
@@ -1473,7 +1488,7 @@
     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);
@@ -1519,8 +1534,8 @@
     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');
@@ -1540,7 +1555,7 @@
     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);
@@ -1623,7 +1638,7 @@
     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);
@@ -1692,7 +1707,7 @@
     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";
@@ -1852,7 +1867,7 @@
     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);
@@ -1892,7 +1907,7 @@
     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);
@@ -1938,7 +1953,7 @@
     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);
@@ -2062,7 +2077,7 @@
     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);
@@ -2158,7 +2173,7 @@
     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);
@@ -2205,7 +2220,7 @@
     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);
@@ -2389,15 +2404,15 @@
     };__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)]() {
@@ -2445,12 +2460,73 @@
          * 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;
@@ -2507,8 +2583,9 @@
         };
         async function loop() {
             await cb();
-            if (!isCancelled)
+            if (!isCancelled) {
                 cancel = (0, set_timeout_1$1.setTimeout)(timeout, loop);
+            }
         }
     }
     setTimeoutLoop$1.setTimeoutLoop = setTimeoutLoop;
@@ -2528,8 +2605,9 @@
             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;
@@ -2544,14 +2622,15 @@
     }));
     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 {
@@ -2641,7 +2720,7 @@
             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();
                     });
@@ -2667,8 +2746,8 @@
              * 按过期时间升序排列所有项目的元数据
              */
             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)]() {
@@ -2772,7 +2851,7 @@
             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();
                     });
@@ -2787,7 +2866,7 @@
          * 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());
         }
     }
 
@@ -2855,7 +2934,7 @@
             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;
@@ -2865,6 +2944,7 @@
         }
     }
 
+    exports.Box = Box;
     exports.Emitter = Emitter;
     exports.ExpirableMap = ExpirableMap;
     exports.HashMap = HashMap;