@blackglory/structures 0.3.3 → 0.3.4

package/dist/es2018/index.umd.js

@@ -239,17 +239,17 @@
 
     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 = {};
 
@@ -271,9 +271,9 @@
         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 = {};
 
@@ -351,11 +351,11 @@
     __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');
@@ -376,7 +376,7 @@
 
     var chunkByAsync$1 = {};
 
-    var es2018$2 = {};
+    var es2018$3 = {};
 
     var array = {};
 
@@ -873,10 +873,10 @@
     __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);
@@ -937,8 +937,8 @@
     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');
@@ -960,8 +960,8 @@
     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]) {
@@ -983,7 +983,7 @@
     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]) {
@@ -1012,9 +1012,9 @@
     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');
@@ -1047,9 +1047,9 @@
     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');
@@ -1075,9 +1075,9 @@
     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');
@@ -1093,7 +1093,7 @@
     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);
@@ -1175,9 +1175,9 @@
     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');
@@ -1210,7 +1210,7 @@
     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);
@@ -1257,7 +1257,7 @@
     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);
@@ -1297,7 +1297,7 @@
 
     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');
@@ -1315,7 +1315,7 @@
     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) {
@@ -1338,7 +1338,7 @@
 
     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');
@@ -1358,7 +1358,7 @@
     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);
@@ -1398,8 +1398,8 @@
     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');
@@ -1433,8 +1433,8 @@
     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');
@@ -1468,8 +1468,8 @@
     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');
@@ -1491,8 +1491,8 @@
     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');
@@ -1532,7 +1532,7 @@
     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);
@@ -1614,8 +1614,8 @@
     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');
@@ -1635,8 +1635,8 @@
     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');
@@ -1665,8 +1665,8 @@
     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');
@@ -1695,7 +1695,7 @@
     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);
@@ -1741,8 +1741,8 @@
     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');
@@ -1762,7 +1762,7 @@
     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);
@@ -1845,7 +1845,7 @@
     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);
@@ -1914,7 +1914,7 @@
     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";
@@ -2074,7 +2074,7 @@
     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);
@@ -2114,7 +2114,7 @@
     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);
@@ -2160,7 +2160,7 @@
     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);
@@ -2284,7 +2284,7 @@
     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);
@@ -2380,7 +2380,7 @@
     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);
@@ -2427,7 +2427,7 @@
     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);
@@ -2611,7 +2611,7 @@
     };__exportStar(middleware, exports);
     __exportStar(output, exports);
 
-    }(es2018$5));
+    }(es2018$6));
 
     var getErrorNames$1 = {};
 
@@ -2629,7 +2629,7 @@
     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;
@@ -2650,7 +2650,7 @@
     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)
@@ -2661,9 +2661,9 @@
     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() {
@@ -2699,7 +2699,7 @@
 
     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));
@@ -2712,6 +2712,56 @@
     }
     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;
@@ -2736,19 +2786,20 @@
     __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)]() {
@@ -2796,7 +2847,7 @@
          * 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());
         }
     }
 
@@ -3082,8 +3133,8 @@
              * 按过期时间升序排列所有项目的元数据
              */
             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)]() {
@@ -3202,7 +3253,7 @@
          * 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());
         }
     }
 
@@ -3270,7 +3321,7 @@
             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;
@@ -3293,11 +3344,14 @@
         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 {
@@ -3306,7 +3360,7 @@
         }
     }
     _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}`);
         }
@@ -3605,52 +3659,88 @@
         };
         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;
@@ -3942,7 +4032,7 @@
             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();
             }
         }