@blackglory/structures 0.10.15 → 0.10.16

package/dist/es2018/index.mjs

@@ -15,7 +15,7 @@ class Box {
 
 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 = {};
 
@@ -640,10 +640,10 @@ symbol.isntSymbol = isntSymbol;
 	__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 {
@@ -799,17 +799,17 @@ class Queue {
     }
 }
 
-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 = {};
 
@@ -838,11 +838,11 @@ goMicrotask$1.goMicrotask = goMicrotask;
 
 var goMacrotask$1 = {};
 
-var es2018$4 = {};
+var es2018$3 = {};
 
 var exponentialBackoff = {};
 
-var es2018$3 = {};
+var es2018$2 = {};
 
 var random$1 = {};
 
@@ -886,10 +886,10 @@ randomIntInclusive$1.randomIntInclusive = randomIntInclusive;
 	__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) {
@@ -1004,10 +1004,10 @@ setDynamicTimeoutLoop$1.setDynamicTimeoutLoop = setDynamicTimeoutLoop;
 	__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 () => {
@@ -1040,13 +1040,38 @@ goMacrotask$1.goMacrotask = goMacrotask;
 	__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 = {};
 
@@ -1421,269 +1446,10 @@ regexp.isntRegExp = isntRegExp;
 	
 } (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 {
@@ -1747,8 +1513,8 @@ function requireChunk () {
 	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');
@@ -1773,12 +1539,12 @@ chunk.chunk = void 0;
 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;
                 }
@@ -1796,7 +1562,7 @@ concatAsync$1.concatAsync = concatAsync;
 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]) {
@@ -1830,9 +1596,9 @@ function requireDropAsync () {
 	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');
@@ -1873,9 +1639,9 @@ function requireDropRightAsync () {
 	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');
@@ -1909,9 +1675,9 @@ function requireDropRight () {
 	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');
@@ -1930,9 +1696,9 @@ dropRight.dropRight = void 0;
 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 {
@@ -2017,9 +1783,9 @@ function requireDrop () {
 	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');
@@ -2055,9 +1821,9 @@ drop.drop = void 0;
 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 {
@@ -2102,9 +1868,9 @@ var flattenDeepAsync = {};
 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 {
@@ -2137,7 +1903,7 @@ async function* flatten$2(iterable, predicate, level) {
     }
 }
 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;
@@ -2147,7 +1913,7 @@ function requireFlattenDeepAsync () {
 	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');
@@ -2176,7 +1942,7 @@ flattenAsync.flattenAsync = void 0;
 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);
 }
@@ -2192,7 +1958,7 @@ function* flatten$1(iterable, predicate, level) {
     }
 }
 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 = {};
@@ -2204,7 +1970,7 @@ function requireFlattenDeep () {
 	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');
@@ -2235,9 +2001,9 @@ flatten.flatten = void 0;
 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 {
@@ -2280,8 +2046,8 @@ function requireRepeatAsync () {
 	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');
@@ -2323,8 +2089,8 @@ function requireRepeat () {
 	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');
@@ -2366,8 +2132,8 @@ function requireSliceAsync () {
 	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');
@@ -2397,8 +2163,8 @@ function requireSlice () {
 	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');
@@ -2441,9 +2207,9 @@ splitAsync$1.splitAsync = splitAsync;
 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 {
@@ -2528,8 +2294,8 @@ function requireTakeAsync () {
 	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');
@@ -2557,8 +2323,8 @@ function requireTakeRightAsync () {
 	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');
@@ -2595,8 +2361,8 @@ function requireTakeRight () {
 	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');
@@ -2628,9 +2394,9 @@ takeRight.takeRight = void 0;
 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 {
@@ -2679,8 +2445,8 @@ function requireTake () {
 	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');
@@ -2703,9 +2469,9 @@ take.take = void 0;
 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 {
@@ -2786,9 +2552,9 @@ uniqAsync$1.uniqAsync = uniqAsync;
 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 {
@@ -2855,7 +2621,7 @@ uniq$1.uniq = uniq;
 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";
@@ -2869,7 +2635,7 @@ async function* zipWithSize$1(...iterables) {
     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 {
@@ -3026,9 +2792,9 @@ consume$1.consume = consume;
 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 {
@@ -3066,9 +2832,9 @@ each$1.each = each;
 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 {
@@ -3112,9 +2878,9 @@ every$1.every = every;
 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 {
@@ -3236,9 +3002,9 @@ match$1.match = match;
 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 {
@@ -3247,7 +3013,7 @@ function reduceAsync(iterable, fn, initialValue) {
 }
 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 {
@@ -3269,7 +3035,7 @@ function reduceAsyncWithInitialValue(iterable, fn, initialValue) {
     }
 }
 function reduceAsyncWithoutInitialValue(iterable, fn) {
-    if ((0, types_1$5.isAsyncIterable)(iterable)) {
+    if ((0, types_1$4.isAsyncIterable)(iterable)) {
         return reduceAsyncIterable(iterable);
     }
     else {
@@ -3332,9 +3098,9 @@ function reduceAsyncWithoutInitialValue(iterable, fn) {
 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 {
@@ -3379,9 +3145,9 @@ function reduceWithoutInitialValue(iterable, fn) {
 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 {
@@ -3616,11 +3382,11 @@ groupByAsync$1.groupByAsync = groupByAsync;
 	
 } (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;
@@ -3638,8 +3404,8 @@ function requireEs2018 () {
 		};__exportStar(requireMiddleware(), exports);
 		__exportStar(output, exports);
 		
-} (es2018$6));
-	return es2018$6;
+} (es2018$5));
+	return es2018$5;
 }
 
 var getErrorNames$1 = {};
@@ -3658,11 +3424,11 @@ function* traverseErrorPrototypeChain(err) {
 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;
@@ -3679,70 +3445,123 @@ getErrorNames$1.getErrorNames = getErrorNames;
 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) {
@@ -3769,48 +3588,65 @@ function createChildErrorConstructor(parentErrorConstructor, name) {
     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]() {
@@ -3948,7 +3784,7 @@ class ExpirableMap {
         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();
                 });
@@ -3971,8 +3807,8 @@ class TLRUMap {
          * 按过期时间升序排列所有项目的元数据
          */
         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]() {
@@ -4076,7 +3912,7 @@ class TLRUMap {
         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();
                 });
@@ -4113,7 +3949,7 @@ class TrieMap {
         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);
@@ -4215,7 +4051,7 @@ class FiniteStateMachine {
         }
     }
 }
-class BadEventError extends es2018$7.CustomError {
+class BadEventError extends es2018Exports$1.CustomError {
     constructor(state, event) {
         super(`State ${state} cannot react to event ${event}`);
     }
@@ -5806,7 +5642,7 @@ class ObservableFiniteStateMachine extends FiniteStateMachine {
         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();
         }
     }
@@ -5940,7 +5776,7 @@ class TypedSparseMap {
     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]() {
@@ -6064,9 +5900,9 @@ class DynamicTypedArray {
     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;
     }
@@ -6220,7 +6056,7 @@ class SkipList {
         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;
         }
@@ -6250,12 +6086,12 @@ class SkipList {
         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;
@@ -6279,7 +6115,7 @@ class SkipList {
         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;
         }
@@ -6334,7 +6170,7 @@ class SkipList {
     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;
@@ -6436,7 +6272,7 @@ class BitSet {
     }
     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;
         }
@@ -6464,7 +6300,7 @@ class BitSet {
     }
     // 输入一定是一个小于bitsPerElement的值, 取值范围是[0, bitsPerElement)
     getMask(value) {
-        return 2 ** value;
+        return 1 << value;
     }
 }
 
@@ -6527,7 +6363,7 @@ class TypedBitSet {
     }
     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;
         }