@blackglory/structures 0.3.3 → 0.3.4

package/dist/es2015/index.mjs

@@ -233,17 +233,17 @@ class Queue {
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
-var es2018$6 = {};
+var es2018$7 = {};
 
 var customError$1 = {};
 
-var es2018$5 = {};
+var es2018$6 = {};
 
 var middleware = {};
 
 var chunkAsync$1 = {};
 
-var es2018$4 = {};
+var es2018$5 = {};
 
 var go$1 = {};
 
@@ -265,9 +265,9 @@ 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$4));
+}(es2018$5));
 
-var es2018$3 = {};
+var es2018$4 = {};
 
 var customError = {};
 
@@ -345,11 +345,11 @@ __exportStar(normalize$3, exports);
 __exportStar(refute$1, exports);
 __exportStar(assert$3, exports);
 
-}(es2018$3));
+}(es2018$4));
 
 chunkAsync$1.chunkAsync = void 0;
-const go_1$f = es2018$4;
-const errors_1$f = es2018$3;
+const go_1$f = es2018$5;
+const errors_1$f = es2018$4;
 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');
@@ -370,7 +370,7 @@ chunkAsync$1.chunkAsync = chunkAsync;
 
 var chunkByAsync$1 = {};
 
-var es2018$2 = {};
+var es2018$3 = {};
 
 var array = {};
 
@@ -867,10 +867,10 @@ __exportStar(string, exports);
 __exportStar(_undefined, exports);
 __exportStar(url, exports);
 
-}(es2018$2));
+}(es2018$3));
 
 chunkByAsync$1.chunkByAsync = void 0;
-const types_1$k = es2018$2;
+const types_1$k = es2018$3;
 function chunkByAsync(iterable, predicate) {
     if ((0, types_1$k.isAsyncIterable)(iterable)) {
         return chunkByAsyncIterable(iterable);
@@ -931,8 +931,8 @@ chunkBy$1.chunkBy = chunkBy;
 var chunk$1 = {};
 
 chunk$1.chunk = void 0;
-const go_1$e = es2018$4;
-const errors_1$e = es2018$3;
+const go_1$e = es2018$5;
+const errors_1$e = es2018$4;
 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');
@@ -954,8 +954,8 @@ chunk$1.chunk = chunk;
 var concatAsync$1 = {};
 
 concatAsync$1.concatAsync = void 0;
-const types_1$j = es2018$2;
-const go_1$d = es2018$4;
+const types_1$j = es2018$3;
+const go_1$d = es2018$5;
 function concatAsync(iterable, ...otherIterables) {
     return (0, go_1$d.go)(async function* () {
         for (const iter of [iterable, ...otherIterables]) {
@@ -977,7 +977,7 @@ concatAsync$1.concatAsync = concatAsync;
 var concat$1 = {};
 
 concat$1.concat = void 0;
-const go_1$c = es2018$4;
+const go_1$c = es2018$5;
 function concat(iterable, ...otherIterables) {
     return (0, go_1$c.go)(function* () {
         for (const iter of [iterable, ...otherIterables]) {
@@ -1006,9 +1006,9 @@ function* copyIterable(iterable) {
 utils.copyIterable = copyIterable;
 
 dropAsync$1.dropAsync = void 0;
-const go_1$b = es2018$4;
+const go_1$b = es2018$5;
 const utils_1$3 = utils;
-const errors_1$d = es2018$3;
+const errors_1$d = es2018$4;
 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');
@@ -1041,9 +1041,9 @@ dropAsync$1.dropAsync = dropAsync;
 var dropRightAsync$1 = {};
 
 dropRightAsync$1.dropRightAsync = void 0;
-const go_1$a = es2018$4;
+const go_1$a = es2018$5;
 const utils_1$2 = utils;
-const errors_1$c = es2018$3;
+const errors_1$c = es2018$4;
 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');
@@ -1069,9 +1069,9 @@ async function toArrayAsync$2(iterable) {
 var dropRight$1 = {};
 
 dropRight$1.dropRight = void 0;
-const go_1$9 = es2018$4;
+const go_1$9 = es2018$5;
 const utils_1$1 = utils;
-const errors_1$b = es2018$3;
+const errors_1$b = es2018$4;
 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');
@@ -1087,7 +1087,7 @@ dropRight$1.dropRight = dropRight;
 var dropUntilAsync$1 = {};
 
 dropUntilAsync$1.dropUntilAsync = void 0;
-const types_1$i = es2018$2;
+const types_1$i = es2018$3;
 function dropUntilAsync(iterable, predicate) {
     if ((0, types_1$i.isAsyncIterable)(iterable)) {
         return dropUntilAsyncIterable(iterable);
@@ -1169,9 +1169,9 @@ dropUntil$1.dropUntil = dropUntil;
 var drop$1 = {};
 
 drop$1.drop = void 0;
-const go_1$8 = es2018$4;
+const go_1$8 = es2018$5;
 const utils_1 = utils;
-const errors_1$a = es2018$3;
+const errors_1$a = es2018$4;
 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');
@@ -1204,7 +1204,7 @@ drop$1.drop = drop;
 var filterAsync$1 = {};
 
 filterAsync$1.filterAsync = void 0;
-const types_1$h = es2018$2;
+const types_1$h = es2018$3;
 function filterAsync(iterable, predicate) {
     if ((0, types_1$h.isAsyncIterable)(iterable)) {
         return filterAsyncIterable(iterable);
@@ -1251,7 +1251,7 @@ var flattenDeepAsync$1 = {};
 var flattenByAsync$1 = {};
 
 flattenByAsync$1.flattenByAsync = void 0;
-const types_1$g = es2018$2;
+const types_1$g = es2018$3;
 function flattenByAsync(iterable, predicate) {
     if ((0, types_1$g.isAsyncIterable)(iterable)) {
         return flattenByAsyncIterable(iterable);
@@ -1291,7 +1291,7 @@ function isFiniteIterable$1(val) {
 
 flattenDeepAsync$1.flattenDeepAsync = void 0;
 const flatten_by_async_1 = flattenByAsync$1;
-const errors_1$9 = es2018$3;
+const errors_1$9 = es2018$4;
 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');
@@ -1309,7 +1309,7 @@ flattenAsync$1.flattenAsync = flattenAsync;
 var flattenBy$1 = {};
 
 flattenBy$1.flattenBy = void 0;
-const types_1$f = es2018$2;
+const types_1$f = es2018$3;
 function flattenBy(iterable, predicate) {
     return flatten(iterable, 1);
     function* flatten(iterable, level) {
@@ -1332,7 +1332,7 @@ 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$4;
 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');
@@ -1352,7 +1352,7 @@ flatten$1.flatten = flatten;
 var mapAsync$1 = {};
 
 mapAsync$1.mapAsync = void 0;
-const types_1$e = es2018$2;
+const types_1$e = es2018$3;
 function mapAsync(iterable, fn) {
     if ((0, types_1$e.isAsyncIterable)(iterable)) {
         return mapAsyncIterable(iterable);
@@ -1392,8 +1392,8 @@ map$1.map = map;
 var repeatAsync$1 = {};
 
 repeatAsync$1.repeatAsync = void 0;
-const go_1$7 = es2018$4;
-const errors_1$7 = es2018$3;
+const go_1$7 = es2018$5;
+const errors_1$7 = es2018$4;
 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');
@@ -1427,8 +1427,8 @@ function isProduction$1() {
 var repeat$1 = {};
 
 repeat$1.repeat = void 0;
-const go_1$6 = es2018$4;
-const errors_1$6 = es2018$3;
+const go_1$6 = es2018$5;
+const errors_1$6 = es2018$4;
 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');
@@ -1462,8 +1462,8 @@ function isProduction() {
 var sliceAsync$1 = {};
 
 sliceAsync$1.sliceAsync = void 0;
-const go_1$5 = es2018$4;
-const errors_1$5 = es2018$3;
+const go_1$5 = es2018$5;
+const errors_1$5 = es2018$4;
 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');
@@ -1485,8 +1485,8 @@ sliceAsync$1.sliceAsync = sliceAsync;
 var slice$1 = {};
 
 slice$1.slice = void 0;
-const go_1$4 = es2018$4;
-const errors_1$4 = es2018$3;
+const go_1$4 = es2018$5;
+const errors_1$4 = es2018$4;
 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');
@@ -1526,7 +1526,7 @@ splitAsync$1.splitAsync = splitAsync;
 var splitByAsync$1 = {};
 
 splitByAsync$1.splitByAsync = void 0;
-const types_1$d = es2018$2;
+const types_1$d = es2018$3;
 function splitByAsync(iterable, predicate) {
     if ((0, types_1$d.isAsyncIterable)(iterable)) {
         return splitByAsyncIterable(iterable);
@@ -1608,8 +1608,8 @@ split$1.split = split;
 var takeAsync$1 = {};
 
 takeAsync$1.takeAsync = void 0;
-const go_1$3 = es2018$4;
-const errors_1$3 = es2018$3;
+const go_1$3 = es2018$5;
+const errors_1$3 = es2018$4;
 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');
@@ -1629,8 +1629,8 @@ takeAsync$1.takeAsync = takeAsync;
 var takeRightAsync$1 = {};
 
 takeRightAsync$1.takeRightAsync = void 0;
-const go_1$2 = es2018$4;
-const errors_1$2 = es2018$3;
+const go_1$2 = es2018$5;
+const errors_1$2 = es2018$4;
 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');
@@ -1659,8 +1659,8 @@ takeRightAsync$1.takeRightAsync = takeRightAsync;
 var takeRight$1 = {};
 
 takeRight$1.takeRight = void 0;
-const go_1$1 = es2018$4;
-const errors_1$1 = es2018$3;
+const go_1$1 = es2018$5;
+const errors_1$1 = es2018$4;
 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');
@@ -1689,7 +1689,7 @@ takeRight$1.takeRight = takeRight;
 var takeUntilAsync$1 = {};
 
 takeUntilAsync$1.takeUntilAsync = void 0;
-const types_1$c = es2018$2;
+const types_1$c = es2018$3;
 function takeUntilAsync(iterable, predicate) {
     if ((0, types_1$c.isAsyncIterable)(iterable)) {
         return takeUntilAsyncIterable(iterable);
@@ -1735,8 +1735,8 @@ takeUntil$1.takeUntil = takeUntil;
 var take$1 = {};
 
 take$1.take = void 0;
-const go_1 = es2018$4;
-const errors_1 = es2018$3;
+const go_1 = es2018$5;
+const errors_1 = es2018$4;
 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');
@@ -1756,7 +1756,7 @@ take$1.take = take;
 var tapAsync$1 = {};
 
 tapAsync$1.tapAsync = void 0;
-const types_1$b = es2018$2;
+const types_1$b = es2018$3;
 function tapAsync(iterable, fn) {
     if ((0, types_1$b.isAsyncIterable)(iterable)) {
         return tapAsyncIterable(iterable);
@@ -1839,7 +1839,7 @@ uniqAsync$1.uniqAsync = uniqAsync;
 var uniqByAsync$1 = {};
 
 uniqByAsync$1.uniqByAsync = void 0;
-const types_1$a = es2018$2;
+const types_1$a = es2018$3;
 function uniqByAsync(iterable, fn) {
     if ((0, types_1$a.isAsyncIterable)(iterable)) {
         return uniqByAsyncIterable(iterable);
@@ -1908,7 +1908,7 @@ uniq$1.uniq = uniq;
 var zipAsync$1 = {};
 
 zipAsync$1.zipAsync = void 0;
-const types_1$9 = es2018$2;
+const types_1$9 = es2018$3;
 var Kind;
 (function (Kind) {
     Kind[Kind["Sync"] = 0] = "Sync";
@@ -2068,7 +2068,7 @@ consume$1.consume = consume;
 var eachAsync$1 = {};
 
 eachAsync$1.eachAsync = void 0;
-const types_1$8 = es2018$2;
+const types_1$8 = es2018$3;
 function eachAsync(iterable, fn) {
     if ((0, types_1$8.isAsyncIterable)(iterable)) {
         return eachAsyncIterable(iterable);
@@ -2108,7 +2108,7 @@ each$1.each = each;
 var everyAsync$1 = {};
 
 everyAsync$1.everyAsync = void 0;
-const types_1$7 = es2018$2;
+const types_1$7 = es2018$3;
 function everyAsync(iterable, predicate) {
     if ((0, types_1$7.isAsyncIterable)(iterable)) {
         return everyAsyncIterable(iterable);
@@ -2154,7 +2154,7 @@ every$1.every = every;
 var findAsync$1 = {};
 
 findAsync$1.findAsync = void 0;
-const types_1$6 = es2018$2;
+const types_1$6 = es2018$3;
 function findAsync(iterable, predicate) {
     if ((0, types_1$6.isAsyncIterable)(iterable)) {
         return findAsyncIterable(iterable);
@@ -2278,7 +2278,7 @@ match$1.match = match;
 var reduceAsync$1 = {};
 
 reduceAsync$1.reduceAsync = void 0;
-const types_1$5 = es2018$2;
+const types_1$5 = es2018$3;
 function reduceAsync(iterable, fn, initialValue) {
     if ((0, types_1$5.isUndefined)(initialValue)) {
         return reduceAsyncWithoutInitialValue(iterable, fn);
@@ -2374,7 +2374,7 @@ function reduceAsyncWithoutInitialValue(iterable, fn) {
 var reduce$1 = {};
 
 reduce$1.reduce = void 0;
-const types_1$4 = es2018$2;
+const types_1$4 = es2018$3;
 function reduce(iterable, fn, initialValue) {
     if ((0, types_1$4.isUndefined)(initialValue)) {
         return reduceWithoutInitialValue(iterable, fn);
@@ -2421,7 +2421,7 @@ function reduceWithoutInitialValue(iterable, fn) {
 var someAsync$1 = {};
 
 someAsync$1.someAsync = void 0;
-const types_1$3 = es2018$2;
+const types_1$3 = es2018$3;
 function someAsync(iterable, predicate) {
     if ((0, types_1$3.isAsyncIterable)(iterable)) {
         return someAsyncIterable(iterable);
@@ -2605,7 +2605,7 @@ var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m
 };__exportStar(middleware, exports);
 __exportStar(output, exports);
 
-}(es2018$5));
+}(es2018$6));
 
 var getErrorNames$1 = {};
 
@@ -2623,7 +2623,7 @@ function* traverseErrorPrototypeChain(err) {
 traverseErrorPrototypeChain$1.traverseErrorPrototypeChain = traverseErrorPrototypeChain;
 
 getErrorNames$1.getErrorNames = void 0;
-const types_1$2 = es2018$2;
+const types_1$2 = es2018$3;
 const traverse_error_prototype_chain_1 = traverseErrorPrototypeChain$1;
 function* getErrorNames(err) {
     var _a;
@@ -2644,7 +2644,7 @@ getErrorNames$1.getErrorNames = getErrorNames;
 var serializableError = {};
 
 serializableError.isSerializableError = void 0;
-const types_1$1 = es2018$2;
+const types_1$1 = es2018$3;
 function isSerializableError(val) {
     return (0, types_1$1.isObject)(val)
         && (0, types_1$1.isString)(val.name)
@@ -2655,9 +2655,9 @@ function isSerializableError(val) {
 serializableError.isSerializableError = isSerializableError;
 
 customError$1.CustomError = void 0;
-const iterable_operator_1$1 = es2018$5;
+const iterable_operator_1$1 = es2018$6;
 const get_error_names_1$1 = getErrorNames$1;
-const types_1 = es2018$2;
+const types_1 = es2018$3;
 const serializable_error_1 = serializableError;
 class CustomError extends Error {
     get name() {
@@ -2693,7 +2693,7 @@ var normalize$1 = {};
 
 normalize$1.normalize = void 0;
 const get_error_names_1 = getErrorNames$1;
-const iterable_operator_1 = es2018$5;
+const iterable_operator_1 = es2018$6;
 function normalize(err) {
     var _a;
     const [name, ...ancestors] = (0, iterable_operator_1.toArray)((0, get_error_names_1.getErrorNames)(err));
@@ -2706,6 +2706,56 @@ function normalize(err) {
 }
 normalize$1.normalize = normalize;
 
+var hydrate$1 = {};
+
+var es2018$2 = {};
+
+var pass$1 = {};
+
+pass$1.pass = void 0;
+function pass() { }
+pass$1.pass = pass;
+
+(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(pass$1, exports);
+
+}(es2018$2));
+
+hydrate$1.hydrate = void 0;
+const pass_1 = es2018$2;
+function hydrate(err) {
+    var _a;
+    const errorNames = [err.name, ...err.ancestors]
+        .slice(0, -1)
+        .reverse();
+    let errorConstructor = Error;
+    for (const name of errorNames) {
+        errorConstructor = createChildErrorConstructor(errorConstructor, name);
+    }
+    const result = new errorConstructor();
+    result.name = err.name;
+    result.message = err.message;
+    result.stack = (_a = err.stack) !== null && _a !== void 0 ? _a : undefined;
+    return result;
+}
+hydrate$1.hydrate = hydrate;
+function createChildErrorConstructor(parentErrorConstructor, name) {
+    const constructor = function () { (0, pass_1.pass)(); };
+    constructor.prototype = Object.create(parentErrorConstructor.prototype);
+    constructor.prototype.constructor = constructor;
+    Object.defineProperty(constructor, 'name', { value: name });
+    return constructor;
+}
+
 var assert$1 = {};
 
 assert$1.assert = void 0;
@@ -2730,19 +2780,20 @@ var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m
 __exportStar(assertionError, exports);
 __exportStar(serializableError, exports);
 __exportStar(normalize$1, exports);
+__exportStar(hydrate$1, exports);
 __exportStar(assert$1, exports);
 __exportStar(getErrorNames$1, exports);
 __exportStar(traverseErrorPrototypeChain$1, exports);
 
-}(es2018$6));
+}(es2018$7));
 
 var _LRUMap_limit, _LRUMap_map;
 class LRUMap {
     constructor(limit) {
         _LRUMap_limit.set(this, void 0);
         _LRUMap_map.set(this, new Map());
-        es2018$6.assert(Number.isInteger(limit), 'The parameter limit must be an integer');
-        es2018$6.assert(limit > 0, 'The parameter limit must be a positive value');
+        es2018$7.assert(Number.isInteger(limit), 'The parameter limit must be an integer');
+        es2018$7.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)]() {
@@ -2790,7 +2841,7 @@ class LRUMap {
      * Return the earliest key inserted in the Map
      */
     getColdestKey() {
-        return es2018$5.first(__classPrivateFieldGet(this, _LRUMap_map, "f").keys());
+        return es2018$6.first(__classPrivateFieldGet(this, _LRUMap_map, "f").keys());
     }
 }
 
@@ -3076,8 +3127,8 @@ class TLRUMap {
          * 按过期时间升序排列所有项目的元数据
          */
         this.itemMetadataSortedByExpirationTime = [];
-        es2018$6.assert(Number.isInteger(limit), 'The parameter limit must be an integer');
-        es2018$6.assert(limit > 0, 'The parameter limit must be a positive value');
+        es2018$7.assert(Number.isInteger(limit), 'The parameter limit must be an integer');
+        es2018$7.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)]() {
@@ -3196,7 +3247,7 @@ class TLRUMap {
      * Return the earliest key inserted in the Map
      */
     getColdestKey() {
-        return es2018$5.first(__classPrivateFieldGet(this, _TLRUMap_map, "f").keys());
+        return es2018$6.first(__classPrivateFieldGet(this, _TLRUMap_map, "f").keys());
     }
 }
 
@@ -3264,7 +3315,7 @@ class TrieMap {
         delete node.value;
         // 如果节点没有后缀, 则代表这是末端节点, 往前删除其前缀
         if (node.children.size === 0) {
-            for (const [part, parentNode] of es2018$5.toArray(es2018$5.zip(key, parentNodes)).reverse()) {
+            for (const [part, parentNode] of es2018$6.toArray(es2018$6.zip(key, parentNodes)).reverse()) {
                 parentNode.children.delete(part);
                 if (parentNode.children.size !== 0)
                     break;
@@ -3287,11 +3338,14 @@ class FiniteStateMachine {
     matches(state) {
         return __classPrivateFieldGet(this, _FiniteStateMachine_state, "f") === state;
     }
+    can(event) {
+        return event in this.schema[this.state];
+    }
     /**
      * @throws {BadEventError}
      */
     send(event) {
-        if (event in this.schema[this.state]) {
+        if (this.can(event)) {
             __classPrivateFieldSet(this, _FiniteStateMachine_state, this.schema[this.state][event], "f");
         }
         else {
@@ -3300,7 +3354,7 @@ class FiniteStateMachine {
     }
 }
 _FiniteStateMachine_state = new WeakMap();
-class BadEventError extends es2018$6.CustomError {
+class BadEventError extends es2018$7.CustomError {
     constructor(state, event) {
         super(`State ${state} cannot react to event ${event}`);
     }
@@ -3599,52 +3653,88 @@ var Subscriber = (function (_super) {
     };
     return Subscriber;
 }(Subscription));
+var _bind = Function.prototype.bind;
+function bind(fn, thisArg) {
+    return _bind.call(fn, thisArg);
+}
+var ConsumerObserver = (function () {
+    function ConsumerObserver(partialObserver) {
+        this.partialObserver = partialObserver;
+    }
+    ConsumerObserver.prototype.next = function (value) {
+        var partialObserver = this.partialObserver;
+        if (partialObserver.next) {
+            try {
+                partialObserver.next(value);
+            }
+            catch (error) {
+                handleUnhandledError(error);
+            }
+        }
+    };
+    ConsumerObserver.prototype.error = function (err) {
+        var partialObserver = this.partialObserver;
+        if (partialObserver.error) {
+            try {
+                partialObserver.error(err);
+            }
+            catch (error) {
+                handleUnhandledError(error);
+            }
+        }
+        else {
+            handleUnhandledError(err);
+        }
+    };
+    ConsumerObserver.prototype.complete = function () {
+        var partialObserver = this.partialObserver;
+        if (partialObserver.complete) {
+            try {
+                partialObserver.complete();
+            }
+            catch (error) {
+                handleUnhandledError(error);
+            }
+        }
+    };
+    return ConsumerObserver;
+}());
 var SafeSubscriber = (function (_super) {
     __extends(SafeSubscriber, _super);
     function SafeSubscriber(observerOrNext, error, complete) {
         var _this = _super.call(this) || this;
-        var next;
-        if (isFunction(observerOrNext)) {
-            next = observerOrNext;
+        var partialObserver;
+        if (isFunction(observerOrNext) || !observerOrNext) {
+            partialObserver = {
+                next: observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : undefined,
+                error: error !== null && error !== void 0 ? error : undefined,
+                complete: complete !== null && complete !== void 0 ? complete : undefined,
+            };
         }
-        else if (observerOrNext) {
-            (next = observerOrNext.next, error = observerOrNext.error, complete = observerOrNext.complete);
+        else {
             var context_1;
             if (_this && config.useDeprecatedNextContext) {
                 context_1 = Object.create(observerOrNext);
                 context_1.unsubscribe = function () { return _this.unsubscribe(); };
+                partialObserver = {
+                    next: observerOrNext.next && bind(observerOrNext.next, context_1),
+                    error: observerOrNext.error && bind(observerOrNext.error, context_1),
+                    complete: observerOrNext.complete && bind(observerOrNext.complete, context_1),
+                };
             }
             else {
-                context_1 = observerOrNext;
+                partialObserver = observerOrNext;
             }
-            next = next === null || next === void 0 ? void 0 : next.bind(context_1);
-            error = error === null || error === void 0 ? void 0 : error.bind(context_1);
-            complete = complete === null || complete === void 0 ? void 0 : complete.bind(context_1);
         }
-        _this.destination = {
-            next: next ? wrapForErrorHandling(next) : noop,
-            error: wrapForErrorHandling(error !== null && error !== void 0 ? error : defaultErrorHandler),
-            complete: complete ? wrapForErrorHandling(complete) : noop,
-        };
+        _this.destination = new ConsumerObserver(partialObserver);
         return _this;
     }
     return SafeSubscriber;
 }(Subscriber));
-function wrapForErrorHandling(handler, instance) {
-    return function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        try {
-            handler.apply(void 0, __spreadArray([], __read(args)));
-        }
-        catch (err) {
-            {
-                reportUnhandledError(err);
-            }
-        }
-    };
+function handleUnhandledError(error) {
+    {
+        reportUnhandledError(error);
+    }
 }
 function defaultErrorHandler(err) {
     throw err;
@@ -3936,7 +4026,7 @@ class ObservableFiniteStateMachine extends FiniteStateMachine {
         super.send(event);
         const newState = this.state;
         this.stateChanges.next({ event, oldState, newState });
-        if (es2018$2.isEmptyObject(this.schema[newState])) {
+        if (es2018$3.isEmptyObject(this.schema[newState])) {
             this.stateChanges.complete();
         }
     }