@blackglory/structures 0.10.15 → 0.10.16

package/dist/es2018/index.umd.js

@@ -21,7 +21,7 @@
 
     var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
-    var es2018$8 = {};
+    var es2018$7 = {};
 
     var array$1 = {};
 
@@ -646,10 +646,10 @@
     	__exportStar(regexp$1, exports);
     	__exportStar(symbol, exports);
     	
-    } (es2018$8));
+    } (es2018$7));
 
     function convertConsToArray([value, next]) {
-        if (es2018$8.isNull(next)) {
+        if (es2018$7.isNull(next)) {
             return [value];
         }
         else {
@@ -805,17 +805,17 @@
         }
     }
 
-    var es2018$7 = {};
+    var es2018$6 = {};
 
-    var customError$1 = {};
+    var customError = {};
 
-    var es2018$6 = {};
+    var es2018$5 = {};
 
     var middleware = {};
 
     var chunkAsync = {};
 
-    var es2018$5 = {};
+    var es2018$4 = {};
 
     var go$1 = {};
 
@@ -844,11 +844,11 @@
 
     var goMacrotask$1 = {};
 
-    var es2018$4 = {};
+    var es2018$3 = {};
 
     var exponentialBackoff = {};
 
-    var es2018$3 = {};
+    var es2018$2 = {};
 
     var random$1 = {};
 
@@ -892,10 +892,10 @@
     	__exportStar(randomInt$1, exports);
     	__exportStar(randomIntInclusive$1, exports);
     	
-    } (es2018$3));
+    } (es2018$2));
 
     exponentialBackoff.calculateExponentialBackoffTimeout = void 0;
-    const extra_rand_1 = es2018$3;
+    const extra_rand_1 = es2018$2;
     function calculateExponentialBackoffTimeout({ baseTimeout, retries, maxTimeout = Infinity, factor = 2, jitter = true }) {
         const timeout = Math.min(factor ** retries * baseTimeout, maxTimeout);
         if (jitter) {
@@ -1010,10 +1010,10 @@
     	__exportStar(setTimeoutLoop$1, exports);
     	__exportStar(setDynamicTimeoutLoop$1, exports);
     	
-    } (es2018$4));
+    } (es2018$3));
 
     goMacrotask$1.goMacrotask = void 0;
-    const extra_timers_1 = es2018$4;
+    const extra_timers_1 = es2018$3;
     function goMacrotask(fn) {
         return new Promise((resolve, reject) => {
             (0, extra_timers_1.setImmediate)(async () => {
@@ -1046,13 +1046,38 @@
     	__exportStar(goMicrotask$1, exports);
     	__exportStar(goMacrotask$1, exports);
     	
-    } (es2018$5));
+    } (es2018$4));
 
-    var es2018$2 = {};
+    var hasRequiredChunkAsync;
 
-    var customError = {};
+    function requireChunkAsync () {
+    	if (hasRequiredChunkAsync) return chunkAsync;
+    	hasRequiredChunkAsync = 1;
+    chunkAsync.chunkAsync = void 0;
+    	const go_1 = es2018$4;
+    	const errors_1 = requireEs2018();
+    	function chunkAsync$1(iterable, size) {
+    	    (0, errors_1.assert)(Number.isInteger(size), 'The parameter size must be an integer');
+    	    (0, errors_1.assert)(size > 0, 'The parameter size must be greater than 0');
+    	    return (0, go_1.go)(async function* () {
+    	        let buffer = [];
+    	        for await (const element of iterable) {
+    	            buffer.push(element);
+    	            if (buffer.length >= size) {
+    	                yield buffer;
+    	                buffer = [];
+    	            }
+    	        }
+    	        if (buffer.length)
+    	            yield buffer;
+    	    });
+    	}
+    	chunkAsync.chunkAsync = chunkAsync$1;
+    	
+    	return chunkAsync;
+    }
 
-    var getErrorNames$3 = {};
+    var chunkByAsync$1 = {};
 
     var es2018$1 = {};
 
@@ -1427,269 +1452,10 @@
     	
     } (es2018$1));
 
-    var traverseErrorPrototypeChain$3 = {};
-
-    traverseErrorPrototypeChain$3.traverseErrorPrototypeChain = void 0;
-    function* traverseErrorPrototypeChain$2(err) {
-        let current = err;
-        while ((current = Object.getPrototypeOf(current))) {
-            yield current;
-            if (current === Error.prototype)
-                break;
-        }
-    }
-    traverseErrorPrototypeChain$3.traverseErrorPrototypeChain = traverseErrorPrototypeChain$2;
-
-    getErrorNames$3.getErrorNames = void 0;
-    const types_1$m = es2018$1;
-    const traverse_error_prototype_chain_1$1 = traverseErrorPrototypeChain$3;
-    function* getErrorNames$2(err) {
-        var _a;
-        if ((0, types_1$m.isError)(err)) {
-            for (const prototype of (0, traverse_error_prototype_chain_1$1.traverseErrorPrototypeChain)(err)) {
-                if ((_a = prototype.constructor) === null || _a === void 0 ? void 0 : _a.name) {
-                    yield prototype.constructor.name;
-                }
-            }
-        }
-        else {
-            yield err.name;
-            yield* err.ancestors;
-        }
-    }
-    getErrorNames$3.getErrorNames = getErrorNames$2;
-
-    var serializableError$1 = {};
-
-    serializableError$1.isSerializableError = void 0;
-    const types_1$l = es2018$1;
-    function isSerializableError$1(val) {
-        return (0, types_1$l.isObject)(val)
-            && (0, types_1$l.isString)(val.name)
-            && (0, types_1$l.isString)(val.message)
-            && ((0, types_1$l.isString)(val.stack) || (0, types_1$l.isNull)(val.stack))
-            && ((0, types_1$l.isArray)(val.ancestors) && val.ancestors.every(types_1$l.isString));
-    }
-    serializableError$1.isSerializableError = isSerializableError$1;
-
-    var hasRequiredCustomError;
-
-    function requireCustomError () {
-    	if (hasRequiredCustomError) return customError;
-    	hasRequiredCustomError = 1;
-    customError.CustomError = void 0;
-    	const iterable_operator_1 = requireEs2018();
-    	const get_error_names_1 = getErrorNames$3;
-    	const types_1 = es2018$1;
-    	const serializable_error_1 = serializableError$1;
-    	class CustomError extends Error {
-    	    get name() {
-    	        var _a, _b;
-    	        return (_b = (_a = (0, iterable_operator_1.first)((0, get_error_names_1.getErrorNames)(this))) !== null && _a !== void 0 ? _a : CustomError.name) !== null && _b !== void 0 ? _b : 'CustomError';
-    	    }
-    	    static [Symbol.hasInstance](instance) {
-    	        var _a;
-    	        if ((0, types_1.isError)(instance) || (0, serializable_error_1.isSerializableError)(instance)) {
-    	            const reversedClassNames = [
-    	                (_a = this.prototype.constructor.name) !== null && _a !== void 0 ? _a : this.name,
-    	                ...(0, get_error_names_1.getErrorNames)(this.prototype)
-    	            ].reverse();
-    	            const reversedInstanceNames = (0, iterable_operator_1.toArray)((0, get_error_names_1.getErrorNames)(instance)).reverse();
-    	            return reversedClassNames.every((x, i) => x === reversedInstanceNames[i]);
-    	        }
-    	        else {
-    	            return false;
-    	        }
-    	    }
-    	}
-    	customError.CustomError = CustomError;
-    	
-    	return customError;
-    }
-
-    var assertionError$1 = {};
-
-    var hasRequiredAssertionError;
-
-    function requireAssertionError () {
-    	if (hasRequiredAssertionError) return assertionError$1;
-    	hasRequiredAssertionError = 1;
-    assertionError$1.AssertionError = void 0;
-    	const custom_error_1 = requireCustomError();
-    	class AssertionError extends custom_error_1.CustomError {
-    	}
-    	assertionError$1.AssertionError = AssertionError;
-    	
-    	return assertionError$1;
-    }
-
-    var normalize$2 = {};
-
-    var hasRequiredNormalize;
-
-    function requireNormalize () {
-    	if (hasRequiredNormalize) return normalize$2;
-    	hasRequiredNormalize = 1;
-    normalize$2.normalize = void 0;
-    	const get_error_names_1 = getErrorNames$3;
-    	const iterable_operator_1 = requireEs2018();
-    	function normalize(err) {
-    	    var _a;
-    	    const [name, ...ancestors] = (0, iterable_operator_1.toArray)((0, get_error_names_1.getErrorNames)(err));
-    	    return {
-    	        name,
-    	        ancestors,
-    	        message: err.message,
-    	        stack: (_a = err.stack) !== null && _a !== void 0 ? _a : null
-    	    };
-    	}
-    	normalize$2.normalize = normalize;
-    	
-    	return normalize$2;
-    }
-
-    var hydrate$3 = {};
-
-    var es2018 = {};
-
-    var pass$1 = {};
-
-    pass$1.pass = void 0;
-    function pass() { }
-    pass$1.pass = pass;
-
-    var passAsync$1 = {};
-
-    passAsync$1.passAsync = void 0;
-    async function passAsync() { }
-    passAsync$1.passAsync = passAsync;
-
-    (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);
-    	__exportStar(passAsync$1, exports);
-    	
-    } (es2018));
-
-    hydrate$3.hydrate = void 0;
-    const pass_1$1 = es2018;
-    function hydrate$2(err) {
-        var _a;
-        const errorNames = [err.name, ...err.ancestors]
-            .slice(0, -1)
-            .reverse();
-        let errorConstructor = Error;
-        for (const name of errorNames) {
-            errorConstructor = createChildErrorConstructor$1(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$3.hydrate = hydrate$2;
-    function createChildErrorConstructor$1(parentErrorConstructor, name) {
-        const constructor = function () { (0, pass_1$1.pass)(); };
-        constructor.prototype = Object.create(parentErrorConstructor.prototype);
-        constructor.prototype.constructor = constructor;
-        Object.defineProperty(constructor, 'name', { value: name });
-        return constructor;
-    }
-
-    var assert$2 = {};
-
-    var hasRequiredAssert;
-
-    function requireAssert () {
-    	if (hasRequiredAssert) return assert$2;
-    	hasRequiredAssert = 1;
-    assert$2.assert = void 0;
-    	const assertion_error_1 = requireAssertionError();
-    	function assert(condition, message) {
-    	    if (!condition)
-    	        throw new assertion_error_1.AssertionError(message);
-    	}
-    	assert$2.assert = assert;
-    	
-    	return assert$2;
-    }
-
-    var hasRequiredEs2018$1;
-
-    function requireEs2018$1 () {
-    	if (hasRequiredEs2018$1) return es2018$2;
-    	hasRequiredEs2018$1 = 1;
-    	(function (exports) {
-    		var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    		    if (k2 === undefined) k2 = k;
-    		    var desc = Object.getOwnPropertyDescriptor(m, k);
-    		    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-    		      desc = { enumerable: true, get: function() { return m[k]; } };
-    		    }
-    		    Object.defineProperty(o, k2, desc);
-    		}) : (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(requireCustomError(), exports);
-    		__exportStar(requireAssertionError(), exports);
-    		__exportStar(serializableError$1, exports);
-    		__exportStar(requireNormalize(), exports);
-    		__exportStar(hydrate$3, exports);
-    		__exportStar(requireAssert(), exports);
-    		__exportStar(getErrorNames$3, exports);
-    		__exportStar(traverseErrorPrototypeChain$3, exports);
-    		
-    } (es2018$2));
-    	return es2018$2;
-    }
-
-    var hasRequiredChunkAsync;
-
-    function requireChunkAsync () {
-    	if (hasRequiredChunkAsync) return chunkAsync;
-    	hasRequiredChunkAsync = 1;
-    chunkAsync.chunkAsync = void 0;
-    	const go_1 = es2018$5;
-    	const errors_1 = requireEs2018$1();
-    	function chunkAsync$1(iterable, size) {
-    	    (0, errors_1.assert)(Number.isInteger(size), 'The parameter size must be an integer');
-    	    (0, errors_1.assert)(size > 0, 'The parameter size must be greater than 0');
-    	    return (0, go_1.go)(async function* () {
-    	        let buffer = [];
-    	        for await (const element of iterable) {
-    	            buffer.push(element);
-    	            if (buffer.length >= size) {
-    	                yield buffer;
-    	                buffer = [];
-    	            }
-    	        }
-    	        if (buffer.length)
-    	            yield buffer;
-    	    });
-    	}
-    	chunkAsync.chunkAsync = chunkAsync$1;
-    	
-    	return chunkAsync;
-    }
-
-    var chunkByAsync$1 = {};
-
     chunkByAsync$1.chunkByAsync = void 0;
-    const types_1$k = es2018$1;
+    const types_1$j = es2018$1;
     function chunkByAsync(iterable, predicate) {
-        if ((0, types_1$k.isAsyncIterable)(iterable)) {
+        if ((0, types_1$j.isAsyncIterable)(iterable)) {
             return chunkByAsyncIterable(iterable, predicate);
         }
         else {
@@ -1753,8 +1519,8 @@
     	if (hasRequiredChunk) return chunk;
     	hasRequiredChunk = 1;
     chunk.chunk = void 0;
-    	const go_1 = es2018$5;
-    	const errors_1 = requireEs2018$1();
+    	const go_1 = es2018$4;
+    	const errors_1 = requireEs2018();
     	function chunk$1(iterable, size) {
     	    (0, errors_1.assert)(Number.isInteger(size), 'The parameter size must be an integer');
     	    (0, errors_1.assert)(size > 0, 'The parameter size must be greater than 0');
@@ -1779,12 +1545,12 @@
     var concatAsync$1 = {};
 
     concatAsync$1.concatAsync = void 0;
-    const types_1$j = es2018$1;
-    const go_1$1 = es2018$5;
+    const types_1$i = es2018$1;
+    const go_1$1 = es2018$4;
     function concatAsync(iterable, ...otherIterables) {
         return (0, go_1$1.go)(async function* () {
             for (const iter of [iterable, ...otherIterables]) {
-                if ((0, types_1$j.isAsyncIterable)(iter)) {
+                if ((0, types_1$i.isAsyncIterable)(iter)) {
                     for await (const element of iter) {
                         yield element;
                     }
@@ -1802,7 +1568,7 @@
     var concat$1 = {};
 
     concat$1.concat = void 0;
-    const go_1 = es2018$5;
+    const go_1 = es2018$4;
     function concat(iterable, ...otherIterables) {
         return (0, go_1.go)(function* () {
             for (const iter of [iterable, ...otherIterables]) {
@@ -1836,9 +1602,9 @@
     	if (hasRequiredDropAsync) return dropAsync;
     	hasRequiredDropAsync = 1;
     dropAsync.dropAsync = void 0;
-    	const go_1 = es2018$5;
+    	const go_1 = es2018$4;
     	const utils_1 = utils;
-    	const errors_1 = requireEs2018$1();
+    	const errors_1 = requireEs2018();
     	function dropAsync$1(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');
@@ -1879,9 +1645,9 @@
     	if (hasRequiredDropRightAsync) return dropRightAsync;
     	hasRequiredDropRightAsync = 1;
     dropRightAsync.dropRightAsync = void 0;
-    	const go_1 = es2018$5;
+    	const go_1 = es2018$4;
     	const utils_1 = utils;
-    	const errors_1 = requireEs2018$1();
+    	const errors_1 = requireEs2018();
     	function dropRightAsync$1(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');
@@ -1915,9 +1681,9 @@
     	if (hasRequiredDropRight) return dropRight;
     	hasRequiredDropRight = 1;
     dropRight.dropRight = void 0;
-    	const go_1 = es2018$5;
+    	const go_1 = es2018$4;
     	const utils_1 = utils;
-    	const errors_1 = requireEs2018$1();
+    	const errors_1 = requireEs2018();
     	function dropRight$1(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');
@@ -1936,9 +1702,9 @@
     var dropUntilAsync$1 = {};
 
     dropUntilAsync$1.dropUntilAsync = void 0;
-    const types_1$i = es2018$1;
+    const types_1$h = es2018$1;
     function dropUntilAsync(iterable, predicate) {
-        if ((0, types_1$i.isAsyncIterable)(iterable)) {
+        if ((0, types_1$h.isAsyncIterable)(iterable)) {
             return dropUntilAsyncIterable(iterable, predicate);
         }
         else {
@@ -2023,9 +1789,9 @@
     	if (hasRequiredDrop) return drop;
     	hasRequiredDrop = 1;
     drop.drop = void 0;
-    	const go_1 = es2018$5;
+    	const go_1 = es2018$4;
     	const utils_1 = utils;
-    	const errors_1 = requireEs2018$1();
+    	const errors_1 = requireEs2018();
     	function drop$1(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');
@@ -2061,9 +1827,9 @@
     var filterAsync$1 = {};
 
     filterAsync$1.filterAsync = void 0;
-    const types_1$h = es2018$1;
+    const types_1$g = es2018$1;
     function filterAsync(iterable, predicate) {
-        if ((0, types_1$h.isAsyncIterable)(iterable)) {
+        if ((0, types_1$g.isAsyncIterable)(iterable)) {
             return filterAsyncIterable(iterable, predicate);
         }
         else {
@@ -2108,9 +1874,9 @@
     var flattenByAsync$1 = {};
 
     flattenByAsync$1.flattenByAsync = void 0;
-    const types_1$g = es2018$1;
+    const types_1$f = es2018$1;
     function flattenByAsync(iterable, predicate) {
-        if ((0, types_1$g.isAsyncIterable)(iterable)) {
+        if ((0, types_1$f.isAsyncIterable)(iterable)) {
             return flattenByAsyncIterable(iterable, predicate);
         }
         else {
@@ -2143,7 +1909,7 @@
         }
     }
     function isFiniteIterable$1(val) {
-        return (0, types_1$g.isIterable)(val) && (0, types_1$g.isntChar)(val);
+        return (0, types_1$f.isIterable)(val) && (0, types_1$f.isntChar)(val);
     }
 
     var hasRequiredFlattenDeepAsync;
@@ -2153,7 +1919,7 @@
     	hasRequiredFlattenDeepAsync = 1;
     flattenDeepAsync.flattenDeepAsync = void 0;
     	const flatten_by_async_1 = flattenByAsync$1;
-    	const errors_1 = requireEs2018$1();
+    	const errors_1 = requireEs2018();
     	function flattenDeepAsync$1(iterable, depth = Infinity) {
     	    (0, errors_1.assert)(depth === Infinity || Number.isInteger(depth), 'The parameter depth must be an integer');
     	    (0, errors_1.assert)(depth >= 0, 'The parameter depth must be greater than or equal to 0');
@@ -2182,7 +1948,7 @@
     var flattenBy$1 = {};
 
     flattenBy$1.flattenBy = void 0;
-    const types_1$f = es2018$1;
+    const types_1$e = es2018$1;
     function flattenBy(iterable, predicate) {
         return flatten$1(iterable, predicate, 1);
     }
@@ -2198,7 +1964,7 @@
         }
     }
     function isFiniteIterable(val) {
-        return (0, types_1$f.isIterable)(val) && (0, types_1$f.isntChar)(val);
+        return (0, types_1$e.isIterable)(val) && (0, types_1$e.isntChar)(val);
     }
 
     var flattenDeep = {};
@@ -2210,7 +1976,7 @@
     	hasRequiredFlattenDeep = 1;
     flattenDeep.flattenDeep = void 0;
     	const flatten_by_1 = flattenBy$1;
-    	const errors_1 = requireEs2018$1();
+    	const errors_1 = requireEs2018();
     	function flattenDeep$1(iterable, depth = Infinity) {
     	    (0, errors_1.assert)(depth === Infinity || Number.isInteger(depth), 'The parameter depth must be an integer');
     	    (0, errors_1.assert)(depth >= 0, 'The parameter depth must be greater than or equal to 0');
@@ -2241,9 +2007,9 @@
     var mapAsync$1 = {};
 
     mapAsync$1.mapAsync = void 0;
-    const types_1$e = es2018$1;
+    const types_1$d = es2018$1;
     function mapAsync(iterable, fn) {
-        if ((0, types_1$e.isAsyncIterable)(iterable)) {
+        if ((0, types_1$d.isAsyncIterable)(iterable)) {
             return mapAsyncIterable(iterable, fn);
         }
         else {
@@ -2286,8 +2052,8 @@
     	if (hasRequiredRepeatAsync) return repeatAsync;
     	hasRequiredRepeatAsync = 1;
     repeatAsync.repeatAsync = void 0;
-    	const go_1 = es2018$5;
-    	const errors_1 = requireEs2018$1();
+    	const go_1 = es2018$4;
+    	const errors_1 = requireEs2018();
     	function repeatAsync$1(iterable, times) {
     	    (0, errors_1.assert)(times === Infinity || Number.isInteger(times), 'The parameter times must be an integer');
     	    (0, errors_1.assert)(times >= 0, 'The parameter times must be greater than or equal to 0');
@@ -2329,8 +2095,8 @@
     	if (hasRequiredRepeat) return repeat;
     	hasRequiredRepeat = 1;
     repeat.repeat = void 0;
-    	const go_1 = es2018$5;
-    	const errors_1 = requireEs2018$1();
+    	const go_1 = es2018$4;
+    	const errors_1 = requireEs2018();
     	function repeat$1(iterable, times) {
     	    (0, errors_1.assert)(times === Infinity || Number.isInteger(times), 'The parameter times must be an integer');
     	    (0, errors_1.assert)(times >= 0, 'The parameter times must be greater than or equal to 0');
@@ -2372,8 +2138,8 @@
     	if (hasRequiredSliceAsync) return sliceAsync;
     	hasRequiredSliceAsync = 1;
     sliceAsync.sliceAsync = void 0;
-    	const go_1 = es2018$5;
-    	const errors_1 = requireEs2018$1();
+    	const go_1 = es2018$4;
+    	const errors_1 = requireEs2018();
     	function sliceAsync$1(iterable, start, end = Infinity) {
     	    (0, errors_1.assert)(Number.isInteger(start), 'The parameter start must be an integer');
     	    (0, errors_1.assert)(start >= 0, 'The parameter start must be greater than or equal to 0');
@@ -2403,8 +2169,8 @@
     	if (hasRequiredSlice) return slice;
     	hasRequiredSlice = 1;
     slice.slice = void 0;
-    	const go_1 = es2018$5;
-    	const errors_1 = requireEs2018$1();
+    	const go_1 = es2018$4;
+    	const errors_1 = requireEs2018();
     	function slice$1(iterable, start, end = Infinity) {
     	    (0, errors_1.assert)(Number.isInteger(start), 'The parameter start must be an integer');
     	    (0, errors_1.assert)(start >= 0, 'The parameter start must be greater than or equal to 0');
@@ -2447,9 +2213,9 @@
     var splitByAsync$1 = {};
 
     splitByAsync$1.splitByAsync = void 0;
-    const types_1$d = es2018$1;
+    const types_1$c = es2018$1;
     function splitByAsync(iterable, predicate) {
-        if ((0, types_1$d.isAsyncIterable)(iterable)) {
+        if ((0, types_1$c.isAsyncIterable)(iterable)) {
             return splitByAsyncIterable(iterable, predicate);
         }
         else {
@@ -2534,8 +2300,8 @@
     	if (hasRequiredTakeAsync) return takeAsync;
     	hasRequiredTakeAsync = 1;
     takeAsync.takeAsync = void 0;
-    	const go_1 = es2018$5;
-    	const errors_1 = requireEs2018$1();
+    	const go_1 = es2018$4;
+    	const errors_1 = requireEs2018();
     	function takeAsync$1(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');
@@ -2563,8 +2329,8 @@
     	if (hasRequiredTakeRightAsync) return takeRightAsync;
     	hasRequiredTakeRightAsync = 1;
     takeRightAsync.takeRightAsync = void 0;
-    	const go_1 = es2018$5;
-    	const errors_1 = requireEs2018$1();
+    	const go_1 = es2018$4;
+    	const errors_1 = requireEs2018();
     	function takeRightAsync$1(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');
@@ -2601,8 +2367,8 @@
     	if (hasRequiredTakeRight) return takeRight;
     	hasRequiredTakeRight = 1;
     takeRight.takeRight = void 0;
-    	const go_1 = es2018$5;
-    	const errors_1 = requireEs2018$1();
+    	const go_1 = es2018$4;
+    	const errors_1 = requireEs2018();
     	function takeRight$1(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');
@@ -2634,9 +2400,9 @@
     var takeUntilAsync$1 = {};
 
     takeUntilAsync$1.takeUntilAsync = void 0;
-    const types_1$c = es2018$1;
+    const types_1$b = es2018$1;
     function takeUntilAsync(iterable, predicate) {
-        if ((0, types_1$c.isAsyncIterable)(iterable)) {
+        if ((0, types_1$b.isAsyncIterable)(iterable)) {
             return takeUntilAsyncIterable(iterable, predicate);
         }
         else {
@@ -2685,8 +2451,8 @@
     	if (hasRequiredTake) return take;
     	hasRequiredTake = 1;
     take.take = void 0;
-    	const go_1 = es2018$5;
-    	const errors_1 = requireEs2018$1();
+    	const go_1 = es2018$4;
+    	const errors_1 = requireEs2018();
     	function take$1(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');
@@ -2709,9 +2475,9 @@
     var tapAsync$1 = {};
 
     tapAsync$1.tapAsync = void 0;
-    const types_1$b = es2018$1;
+    const types_1$a = es2018$1;
     function tapAsync(iterable, fn) {
-        if ((0, types_1$b.isAsyncIterable)(iterable)) {
+        if ((0, types_1$a.isAsyncIterable)(iterable)) {
             return tapAsyncIterable(iterable, fn);
         }
         else {
@@ -2792,9 +2558,9 @@
     var uniqByAsync$1 = {};
 
     uniqByAsync$1.uniqByAsync = void 0;
-    const types_1$a = es2018$1;
+    const types_1$9 = es2018$1;
     function uniqByAsync(iterable, fn) {
-        if ((0, types_1$a.isAsyncIterable)(iterable)) {
+        if ((0, types_1$9.isAsyncIterable)(iterable)) {
             return uniqByAsyncIterable(iterable, fn);
         }
         else {
@@ -2861,7 +2627,7 @@
     var zipAsync$1 = {};
 
     zipAsync$1.zipAsync = void 0;
-    const types_1$9 = es2018$1;
+    const types_1$8 = es2018$1;
     var Kind;
     (function (Kind) {
         Kind[Kind["Sync"] = 0] = "Sync";
@@ -2875,7 +2641,7 @@
         var _a, _b, _c, _d;
         const length = iterables.length;
         const iterators = iterables.map(iterable => {
-            if ((0, types_1$9.isAsyncIterable)(iterable)) {
+            if ((0, types_1$8.isAsyncIterable)(iterable)) {
                 return [Kind.Async, iterable[Symbol.asyncIterator]()];
             }
             else {
@@ -3032,9 +2798,9 @@
     var eachAsync$1 = {};
 
     eachAsync$1.eachAsync = void 0;
-    const types_1$8 = es2018$1;
+    const types_1$7 = es2018$1;
     function eachAsync(iterable, fn) {
-        if ((0, types_1$8.isAsyncIterable)(iterable)) {
+        if ((0, types_1$7.isAsyncIterable)(iterable)) {
             return eachAsyncIterable(iterable, fn);
         }
         else {
@@ -3072,9 +2838,9 @@
     var everyAsync$1 = {};
 
     everyAsync$1.everyAsync = void 0;
-    const types_1$7 = es2018$1;
+    const types_1$6 = es2018$1;
     function everyAsync(iterable, predicate) {
-        if ((0, types_1$7.isAsyncIterable)(iterable)) {
+        if ((0, types_1$6.isAsyncIterable)(iterable)) {
             return everyAsyncIterable(iterable, predicate);
         }
         else {
@@ -3118,9 +2884,9 @@
     var findAsync$1 = {};
 
     findAsync$1.findAsync = void 0;
-    const types_1$6 = es2018$1;
+    const types_1$5 = es2018$1;
     function findAsync(iterable, predicate) {
-        if ((0, types_1$6.isAsyncIterable)(iterable)) {
+        if ((0, types_1$5.isAsyncIterable)(iterable)) {
             return findAsyncIterable(iterable, predicate);
         }
         else {
@@ -3242,9 +3008,9 @@
     var reduceAsync$1 = {};
 
     reduceAsync$1.reduceAsync = void 0;
-    const types_1$5 = es2018$1;
+    const types_1$4 = es2018$1;
     function reduceAsync(iterable, fn, initialValue) {
-        if ((0, types_1$5.isUndefined)(initialValue)) {
+        if ((0, types_1$4.isUndefined)(initialValue)) {
             return reduceAsyncWithoutInitialValue(iterable, fn);
         }
         else {
@@ -3253,7 +3019,7 @@
     }
     reduceAsync$1.reduceAsync = reduceAsync;
     function reduceAsyncWithInitialValue(iterable, fn, initialValue) {
-        if ((0, types_1$5.isAsyncIterable)(iterable)) {
+        if ((0, types_1$4.isAsyncIterable)(iterable)) {
             return reduceAsyncIterable(iterable);
         }
         else {
@@ -3275,7 +3041,7 @@
         }
     }
     function reduceAsyncWithoutInitialValue(iterable, fn) {
-        if ((0, types_1$5.isAsyncIterable)(iterable)) {
+        if ((0, types_1$4.isAsyncIterable)(iterable)) {
             return reduceAsyncIterable(iterable);
         }
         else {
@@ -3338,9 +3104,9 @@
     var reduce$1 = {};
 
     reduce$1.reduce = void 0;
-    const types_1$4 = es2018$1;
+    const types_1$3 = es2018$1;
     function reduce(iterable, fn, initialValue) {
-        if ((0, types_1$4.isUndefined)(initialValue)) {
+        if ((0, types_1$3.isUndefined)(initialValue)) {
             return reduceWithoutInitialValue(iterable, fn);
         }
         else {
@@ -3385,9 +3151,9 @@
     var someAsync$1 = {};
 
     someAsync$1.someAsync = void 0;
-    const types_1$3 = es2018$1;
+    const types_1$2 = es2018$1;
     function someAsync(iterable, predicate) {
-        if ((0, types_1$3.isAsyncIterable)(iterable)) {
+        if ((0, types_1$2.isAsyncIterable)(iterable)) {
             return someAsyncIterable(iterable, predicate);
         }
         else {
@@ -3622,11 +3388,11 @@
     	
     } (output));
 
-    var hasRequiredEs2018;
+    var hasRequiredEs2018$1;
 
-    function requireEs2018 () {
-    	if (hasRequiredEs2018) return es2018$6;
-    	hasRequiredEs2018 = 1;
+    function requireEs2018$1 () {
+    	if (hasRequiredEs2018$1) return es2018$5;
+    	hasRequiredEs2018$1 = 1;
     	(function (exports) {
     		var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     		    if (k2 === undefined) k2 = k;
@@ -3644,8 +3410,8 @@
     		};__exportStar(requireMiddleware(), exports);
     		__exportStar(output, exports);
     		
-    } (es2018$6));
-    	return es2018$6;
+    } (es2018$5));
+    	return es2018$5;
     }
 
     var getErrorNames$1 = {};
@@ -3664,11 +3430,11 @@
     traverseErrorPrototypeChain$1.traverseErrorPrototypeChain = traverseErrorPrototypeChain;
 
     getErrorNames$1.getErrorNames = void 0;
-    const types_1$2 = es2018$8;
+    const types_1$1 = es2018$7;
     const traverse_error_prototype_chain_1 = traverseErrorPrototypeChain$1;
     function* getErrorNames(err) {
         var _a;
-        if ((0, types_1$2.isError)(err)) {
+        if ((0, types_1$1.isError)(err)) {
             for (const prototype of (0, traverse_error_prototype_chain_1.traverseErrorPrototypeChain)(err)) {
                 if ((_a = prototype.constructor) === null || _a === void 0 ? void 0 : _a.name) {
                     yield prototype.constructor.name;
@@ -3685,70 +3451,123 @@
     var serializableError = {};
 
     serializableError.isSerializableError = void 0;
-    const types_1$1 = es2018$8;
+    const types_1 = es2018$7;
     function isSerializableError(val) {
-        return (0, types_1$1.isObject)(val)
-            && (0, types_1$1.isString)(val.name)
-            && (0, types_1$1.isString)(val.message)
-            && ((0, types_1$1.isString)(val.stack) || (0, types_1$1.isNull)(val.stack))
-            && ((0, types_1$1.isArray)(val.ancestors) && val.ancestors.every(types_1$1.isString));
+        return (0, types_1.isObject)(val)
+            && (0, types_1.isString)(val.name)
+            && (0, types_1.isString)(val.message)
+            && ((0, types_1.isString)(val.stack) || (0, types_1.isNull)(val.stack))
+            && ((0, types_1.isArray)(val.ancestors) && val.ancestors.every(types_1.isString));
     }
     serializableError.isSerializableError = isSerializableError;
 
-    customError$1.CustomError = void 0;
-    const iterable_operator_1$1 = requireEs2018();
-    const get_error_names_1$1 = getErrorNames$1;
-    const types_1 = es2018$8;
-    const serializable_error_1 = serializableError;
-    class CustomError extends Error {
-        get name() {
-            var _a, _b;
-            return (_b = (_a = (0, iterable_operator_1$1.first)((0, get_error_names_1$1.getErrorNames)(this))) !== null && _a !== void 0 ? _a : CustomError.name) !== null && _b !== void 0 ? _b : 'CustomError';
-        }
-        static [Symbol.hasInstance](instance) {
-            var _a;
-            if ((0, types_1.isError)(instance) || (0, serializable_error_1.isSerializableError)(instance)) {
-                const reversedClassNames = [
-                    (_a = this.prototype.constructor.name) !== null && _a !== void 0 ? _a : this.name,
-                    ...(0, get_error_names_1$1.getErrorNames)(this.prototype)
-                ].reverse();
-                const reversedInstanceNames = (0, iterable_operator_1$1.toArray)((0, get_error_names_1$1.getErrorNames)(instance)).reverse();
-                return reversedClassNames.every((x, i) => x === reversedInstanceNames[i]);
-            }
-            else {
-                return false;
-            }
-        }
+    var hasRequiredCustomError;
+
+    function requireCustomError () {
+    	if (hasRequiredCustomError) return customError;
+    	hasRequiredCustomError = 1;
+    customError.CustomError = void 0;
+    	const iterable_operator_1 = requireEs2018$1();
+    	const get_error_names_1 = getErrorNames$1;
+    	const types_1 = es2018$7;
+    	const serializable_error_1 = serializableError;
+    	class CustomError extends Error {
+    	    get name() {
+    	        var _a, _b;
+    	        return (_b = (_a = (0, iterable_operator_1.first)((0, get_error_names_1.getErrorNames)(this))) !== null && _a !== void 0 ? _a : CustomError.name) !== null && _b !== void 0 ? _b : 'CustomError';
+    	    }
+    	    static [Symbol.hasInstance](instance) {
+    	        var _a;
+    	        if ((0, types_1.isError)(instance) || (0, serializable_error_1.isSerializableError)(instance)) {
+    	            const reversedClassNames = [
+    	                (_a = this.prototype.constructor.name) !== null && _a !== void 0 ? _a : this.name,
+    	                ...(0, get_error_names_1.getErrorNames)(this.prototype)
+    	            ].reverse();
+    	            const reversedInstanceNames = (0, iterable_operator_1.toArray)((0, get_error_names_1.getErrorNames)(instance)).reverse();
+    	            return reversedClassNames.every((x, i) => x === reversedInstanceNames[i]);
+    	        }
+    	        else {
+    	            return false;
+    	        }
+    	    }
+    	}
+    	customError.CustomError = CustomError;
+    	
+    	return customError;
     }
-    customError$1.CustomError = CustomError;
 
     var assertionError = {};
 
+    var hasRequiredAssertionError;
+
+    function requireAssertionError () {
+    	if (hasRequiredAssertionError) return assertionError;
+    	hasRequiredAssertionError = 1;
     assertionError.AssertionError = void 0;
-    const custom_error_1 = customError$1;
-    class AssertionError extends custom_error_1.CustomError {
+    	const custom_error_1 = requireCustomError();
+    	class AssertionError extends custom_error_1.CustomError {
+    	}
+    	assertionError.AssertionError = AssertionError;
+    	
+    	return assertionError;
     }
-    assertionError.AssertionError = AssertionError;
 
-    var normalize$1 = {};
+    var normalize = {};
 
-    normalize$1.normalize = void 0;
-    const get_error_names_1 = getErrorNames$1;
-    const iterable_operator_1 = requireEs2018();
-    function normalize(err) {
-        var _a;
-        const [name, ...ancestors] = (0, iterable_operator_1.toArray)((0, get_error_names_1.getErrorNames)(err));
-        return {
-            name,
-            ancestors,
-            message: err.message,
-            stack: (_a = err.stack) !== null && _a !== void 0 ? _a : null
-        };
+    var hasRequiredNormalize;
+
+    function requireNormalize () {
+    	if (hasRequiredNormalize) return normalize;
+    	hasRequiredNormalize = 1;
+    normalize.normalize = void 0;
+    	const get_error_names_1 = getErrorNames$1;
+    	const iterable_operator_1 = requireEs2018$1();
+    	function normalize$1(err) {
+    	    var _a;
+    	    const [name, ...ancestors] = (0, iterable_operator_1.toArray)((0, get_error_names_1.getErrorNames)(err));
+    	    return {
+    	        name,
+    	        ancestors,
+    	        message: err.message,
+    	        stack: (_a = err.stack) !== null && _a !== void 0 ? _a : null
+    	    };
+    	}
+    	normalize.normalize = normalize$1;
+    	
+    	return normalize;
     }
-    normalize$1.normalize = normalize;
 
     var hydrate$1 = {};
 
+    var es2018 = {};
+
+    var pass$1 = {};
+
+    pass$1.pass = void 0;
+    function pass() { }
+    pass$1.pass = pass;
+
+    var passAsync$1 = {};
+
+    passAsync$1.passAsync = void 0;
+    async function passAsync() { }
+    passAsync$1.passAsync = passAsync;
+
+    (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);
+    	__exportStar(passAsync$1, exports);
+    	
+    } (es2018));
+
     hydrate$1.hydrate = void 0;
     const pass_1 = es2018;
     function hydrate(err) {
@@ -3775,48 +3594,65 @@
         return constructor;
     }
 
-    var assert$1 = {};
+    var assert = {};
 
-    assert$1.assert = void 0;
-    const assertion_error_1 = assertionError;
-    function assert(condition, message) {
-        if (!condition)
-            throw new assertion_error_1.AssertionError(message);
-    }
-    assert$1.assert = assert;
+    var hasRequiredAssert;
 
-    (function (exports) {
-    	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    	    if (k2 === undefined) k2 = k;
-    	    var desc = Object.getOwnPropertyDescriptor(m, k);
-    	    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-    	      desc = { enumerable: true, get: function() { return m[k]; } };
-    	    }
-    	    Object.defineProperty(o, k2, desc);
-    	}) : (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(customError$1, exports);
-    	__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);
+    function requireAssert () {
+    	if (hasRequiredAssert) return assert;
+    	hasRequiredAssert = 1;
+    assert.assert = void 0;
+    	const assertion_error_1 = requireAssertionError();
+    	function assert$1(condition, message) {
+    	    if (!condition)
+    	        throw new assertion_error_1.AssertionError(message);
+    	}
+    	assert.assert = assert$1;
     	
-    } (es2018$7));
+    	return assert;
+    }
 
-    var es2018Exports = requireEs2018();
+    var hasRequiredEs2018;
+
+    function requireEs2018 () {
+    	if (hasRequiredEs2018) return es2018$6;
+    	hasRequiredEs2018 = 1;
+    	(function (exports) {
+    		var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    		    if (k2 === undefined) k2 = k;
+    		    var desc = Object.getOwnPropertyDescriptor(m, k);
+    		    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+    		      desc = { enumerable: true, get: function() { return m[k]; } };
+    		    }
+    		    Object.defineProperty(o, k2, desc);
+    		}) : (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(requireCustomError(), exports);
+    		__exportStar(requireAssertionError(), exports);
+    		__exportStar(serializableError, exports);
+    		__exportStar(requireNormalize(), exports);
+    		__exportStar(hydrate$1, exports);
+    		__exportStar(requireAssert(), exports);
+    		__exportStar(getErrorNames$1, exports);
+    		__exportStar(traverseErrorPrototypeChain$1, exports);
+    		
+    } (es2018$6));
+    	return es2018$6;
+    }
+
+    var es2018Exports$1 = requireEs2018();
+
+    var es2018Exports = requireEs2018$1();
 
     class LRUMap {
         constructor(limit) {
             this.map = new Map();
-            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');
+            es2018Exports$1.assert(Number.isInteger(limit), 'The parameter limit must be an integer');
+            es2018Exports$1.assert(limit > 0, 'The parameter limit must be a positive value');
             this.limit = limit;
         }
         get [Symbol.toStringTag]() {
@@ -3954,7 +3790,7 @@
             if (this.itemMetadataSortedByExpirationTime.length > 0) {
                 const item = this.itemMetadataSortedByExpirationTime[0];
                 if (Number.isFinite(item.expirationTime)) {
-                    const cancel = es2018$4.setSchedule(item.expirationTime, () => {
+                    const cancel = es2018$3.setSchedule(item.expirationTime, () => {
                         this.clearExpiredItems(Date.now());
                         this.rescheduleClearTimeout();
                     });
@@ -3977,8 +3813,8 @@
              * 按过期时间升序排列所有项目的元数据
              */
             this.itemMetadataSortedByExpirationTime = [];
-            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');
+            es2018Exports$1.assert(Number.isInteger(limit), 'The parameter limit must be an integer');
+            es2018Exports$1.assert(limit > 0, 'The parameter limit must be a positive value');
             this.limit = limit;
         }
         get [Symbol.toStringTag]() {
@@ -4082,7 +3918,7 @@
             if (this.itemMetadataSortedByExpirationTime.length > 0) {
                 const item = this.itemMetadataSortedByExpirationTime[0];
                 if (Number.isFinite(item.expirationTime)) {
-                    const cancel = es2018$4.setSchedule(item.expirationTime, () => {
+                    const cancel = es2018$3.setSchedule(item.expirationTime, () => {
                         this.clearExpiredItems(Date.now());
                         this.rescheduleClearTimeout();
                     });
@@ -4119,7 +3955,7 @@
             function* dfs(node, paths) {
                 for (const [path, childNode] of node.children) {
                     const newPaths = [...paths, path];
-                    if (es2018$8.isntUndefined(childNode.value)) {
+                    if (es2018$7.isntUndefined(childNode.value)) {
                         yield [newPaths, childNode.value];
                     }
                     yield* dfs(childNode, newPaths);
@@ -4221,7 +4057,7 @@
             }
         }
     }
-    class BadEventError extends es2018$7.CustomError {
+    class BadEventError extends es2018Exports$1.CustomError {
         constructor(state, event) {
             super(`State ${state} cannot react to event ${event}`);
         }
@@ -5812,7 +5648,7 @@
             super.send(event);
             const newState = this.state;
             this.stateChanges.next({ event, oldState, newState });
-            if (es2018$8.isEmptyObject(this.schema[newState])) {
+            if (es2018$7.isEmptyObject(this.schema[newState])) {
                 this.stateChanges.complete();
             }
         }
@@ -5946,7 +5782,7 @@
         constructor(array) {
             this.keyToIndex = [];
             this.indexToKey = [];
-            es2018$7.assert(array.length === 0, 'array should be empty');
+            es2018Exports$1.assert(array.length === 0, 'array should be empty');
             this.indexToValue = array;
         }
         get [Symbol.toStringTag]() {
@@ -6070,9 +5906,9 @@
         constructor(typedArrayConstructor, { capacity = 0, growthFactor = 1.5 } = {}) {
             this.typedArrayConstructor = typedArrayConstructor;
             this._length = 0;
-            es2018$7.assert(Number.isInteger(capacity), 'capacity must be an integer');
-            es2018$7.assert(capacity >= 0, 'capacity must be greater than or equal to 0');
-            es2018$7.assert(growthFactor >= 1, 'growthFactory must be greater than or equal to 1');
+            es2018Exports$1.assert(Number.isInteger(capacity), 'capacity must be an integer');
+            es2018Exports$1.assert(capacity >= 0, 'capacity must be greater than or equal to 0');
+            es2018Exports$1.assert(growthFactor >= 1, 'growthFactory must be greater than or equal to 1');
             this.array = new typedArrayConstructor(capacity);
             this.growthFactor = growthFactor;
         }
@@ -6226,7 +6062,7 @@
             while (currentNode.down) {
                 currentNode = currentNode.down;
             }
-            while (currentNode.next && es2018$8.isntNull(currentNode.next.value)) {
+            while (currentNode.next && es2018$7.isntNull(currentNode.next.value)) {
                 currentNode = currentNode.next;
                 yield currentNode;
             }
@@ -6256,12 +6092,12 @@
             this._size--;
         }
         has(value) {
-            return es2018$8.isntNull(this.findNode(value));
+            return es2018$7.isntNull(this.findNode(value));
         }
         findNode(value) {
             let currentNode = this.head;
             while (true) {
-                while (currentNode.next && es2018$8.isntNull(currentNode.next.value)) {
+                while (currentNode.next && es2018$7.isntNull(currentNode.next.value)) {
                     const result = this.compare(currentNode.next.value, value);
                     if (result === 0) {
                         return currentNode.next;
@@ -6285,7 +6121,7 @@
             let previousNode = this.findPreviousNode(value);
             // 如果previousNode.next.value等于value, 则说明value已经存在
             if (previousNode.next &&
-                es2018$8.isntNull(previousNode.next.value) &&
+                es2018$7.isntNull(previousNode.next.value) &&
                 this.compare(previousNode.next.value, value) === 0) {
                 return;
             }
@@ -6340,7 +6176,7 @@
         findPreviousNode(value) {
             let currentNode = this.head;
             while (true) {
-                while (currentNode.next && es2018$8.isntNull(currentNode.next.value)) {
+                while (currentNode.next && es2018$7.isntNull(currentNode.next.value)) {
                     const result = this.compare(currentNode.next.value, value);
                     if (result >= 0) {
                         break;
@@ -6442,7 +6278,7 @@
         }
         add(value) {
             var _a;
-            es2018$7.assert(value >= 0, 'value must be greater than or equal to 0');
+            es2018Exports$1.assert(value >= 0, 'value must be greater than or equal to 0');
             if (value >= this.length) {
                 this.length = value + 1;
             }
@@ -6470,7 +6306,7 @@
         }
         // 输入一定是一个小于bitsPerElement的值, 取值范围是[0, bitsPerElement)
         getMask(value) {
-            return 2 ** value;
+            return 1 << value;
         }
     }
 
@@ -6533,7 +6369,7 @@
         }
         add(value) {
             var _a;
-            es2018$7.assert(value >= 0, 'value must be greater than or equal to 0');
+            es2018Exports$1.assert(value >= 0, 'value must be greater than or equal to 0');
             if (value >= this.length) {
                 this.length = value + 1;
             }