extra-react-hooks 0.2.1 → 0.3.0

package/dist/es2015/index.mjs

@@ -2485,7 +2485,7 @@ function requireReact_development () {
 
 function useIncrement(initialValue) {
     const [value, setValue] = react.exports.useState(initialValue);
-    return [value, increment, reset];
+    return [value, react.exports.useCallback(increment, []), react.exports.useCallback(reset, [])];
     function increment(step = 1) {
         setValue(value => value + step);
     }
@@ -2499,14 +2499,17 @@ function useMount(effect) {
 }
 
 function useIsMounted() {
-    const isMounted = react.exports.useRef(false);
+    const mounted = react.exports.useRef(false);
     useMount(() => {
-        isMounted.current = true;
+        mounted.current = true;
         return () => {
-            isMounted.current = false;
+            mounted.current = false;
         };
     });
-    return () => isMounted.current;
+    return react.exports.useCallback(isMounted, []);
+    function isMounted() {
+        return mounted.current;
+    }
 }
 
 var State;
@@ -2526,7 +2529,10 @@ function useIsFirstRender() {
             break;
         case State.NotFirst: break;
     }
-    return () => state.current === State.First;
+    return react.exports.useCallback(isFirstRender, []);
+    function isFirstRender() {
+        return state.current === State.First;
+    }
 }
 
 function useRenderCounter() {
@@ -2535,6 +2541,10 @@ function useRenderCounter() {
     return counter.current;
 }
 
+function useUnmount(effect) {
+    react.exports.useEffect(() => effect, []);
+}
+
 function useUpdateEffect(effect, deps) {
     const isFirstRender = useIsFirstRender();
     react.exports.useEffect(() => {
@@ -2546,6 +2556,71 @@ function useUpdateEffect(effect, deps) {
 
 var es2018$9 = {};
 
+var customError = {};
+
+var es2018$8 = {};
+
+var middleware = {};
+
+var chunkAsync = {};
+
+var es2018$7 = {};
+
+var go$1 = {};
+
+go$1.go = void 0;
+function go(fn) {
+    return fn();
+}
+go$1.go = go;
+
+(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(go$1, exports);
+	
+} (es2018$7));
+
+var hasRequiredChunkAsync;
+
+function requireChunkAsync () {
+	if (hasRequiredChunkAsync) return chunkAsync;
+	hasRequiredChunkAsync = 1;
+chunkAsync.chunkAsync = void 0;
+	const go_1 = es2018$7;
+	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 chunkByAsync$1 = {};
+
+var es2018$6 = {};
+
 var array$2 = {};
 
 array$2.isntEmptyArray = array$2.isEmptyArray = array$2.isntArray = array$2.isArray = void 0;
@@ -3109,18 +3184,6 @@ function isAbsoluteURL$2(str) {
 }
 url$2.isAbsoluteURL = isAbsoluteURL$2;
 
-var regexp = {};
-
-regexp.isntRegExp = regexp.isRegExp = void 0;
-function isRegExp(val) {
-    return val instanceof RegExp;
-}
-regexp.isRegExp = isRegExp;
-function isntRegExp(val) {
-    return !isRegExp(val);
-}
-regexp.isntRegExp = isntRegExp;
-
 (function (exports) {
 	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
 	    if (k2 === undefined) k2 = k;
@@ -3154,58 +3217,84 @@ regexp.isntRegExp = isntRegExp;
 	__exportStar(string$2, exports);
 	__exportStar(_undefined$2, exports);
 	__exportStar(url$2, exports);
-	__exportStar(regexp, exports);
 	
-} (es2018$9));
-
-var es2018$8 = {};
-
-var customError = {};
-
-var es2018$7 = {};
-
-var middleware = {};
-
-var chunkAsync = {};
+} (es2018$6));
 
-var es2018$6 = {};
+chunkByAsync$1.chunkByAsync = void 0;
+const types_1$j = es2018$6;
+function chunkByAsync(iterable, predicate) {
+    if ((0, types_1$j.isAsyncIterable)(iterable)) {
+        return chunkByAsyncIterable(iterable);
+    }
+    else {
+        return chunkByIterable(iterable);
+    }
+    async function* chunkByAsyncIterable(iterable) {
+        let buffer = [];
+        let index = 0;
+        for await (const element of iterable) {
+            buffer.push(element);
+            if (await predicate(element, index)) {
+                yield buffer;
+                buffer = [];
+            }
+            index++;
+        }
+        if (buffer.length)
+            yield buffer;
+    }
+    async function* chunkByIterable(iterable) {
+        let buffer = [];
+        let index = 0;
+        for (const element of iterable) {
+            buffer.push(element);
+            if (await predicate(element, index)) {
+                yield buffer;
+                buffer = [];
+            }
+            index++;
+        }
+        if (buffer.length)
+            yield buffer;
+    }
+}
+chunkByAsync$1.chunkByAsync = chunkByAsync;
 
-var go$1 = {};
+var chunkBy$1 = {};
 
-go$1.go = void 0;
-function go(fn) {
-    return fn();
+chunkBy$1.chunkBy = void 0;
+function* chunkBy(iterable, predicate) {
+    let buffer = [];
+    let index = 0;
+    for (const element of iterable) {
+        buffer.push(element);
+        if (predicate(element, index)) {
+            yield buffer;
+            buffer = [];
+        }
+        index++;
+    }
+    if (buffer.length)
+        yield buffer;
 }
-go$1.go = go;
+chunkBy$1.chunkBy = chunkBy;
 
-(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(go$1, exports);
-	
-} (es2018$6));
+var chunk = {};
 
-var hasRequiredChunkAsync;
+var hasRequiredChunk;
 
-function requireChunkAsync () {
-	if (hasRequiredChunkAsync) return chunkAsync;
-	hasRequiredChunkAsync = 1;
-chunkAsync.chunkAsync = void 0;
-	const go_1 = es2018$6;
+function requireChunk () {
+	if (hasRequiredChunk) return chunk;
+	hasRequiredChunk = 1;
+chunk.chunk = void 0;
+	const go_1 = es2018$7;
 	const errors_1 = requireEs2018();
-	function chunkAsync$1(iterable, size) {
+	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');
-	    return (0, go_1.go)(async function* () {
+	    return (0, go_1.go)(function* () {
 	        let buffer = [];
-	        for await (const element of iterable) {
+	        for (const element of iterable) {
 	            buffer.push(element);
 	            if (buffer.length >= size) {
 	                yield buffer;
@@ -3216,733 +3305,854 @@ chunkAsync.chunkAsync = void 0;
 	            yield buffer;
 	    });
 	}
-	chunkAsync.chunkAsync = chunkAsync$1;
+	chunk.chunk = chunk$1;
 	
-	return chunkAsync;
+	return chunk;
 }
 
-var chunkByAsync$1 = {};
+var concatAsync$1 = {};
 
-var es2018$5 = {};
+concatAsync$1.concatAsync = void 0;
+const types_1$i = es2018$6;
+const go_1$1 = es2018$7;
+function concatAsync(iterable, ...otherIterables) {
+    return (0, go_1$1.go)(async function* () {
+        for (const iter of [iterable, ...otherIterables]) {
+            if ((0, types_1$i.isAsyncIterable)(iter)) {
+                for await (const element of iter) {
+                    yield element;
+                }
+            }
+            else {
+                for (const element of iter) {
+                    yield element;
+                }
+            }
+        }
+    });
+}
+concatAsync$1.concatAsync = concatAsync;
 
-var array$1 = {};
+var concat$5 = {};
 
-array$1.isntEmptyArray = array$1.isEmptyArray = array$1.isntArray = array$1.isArray = void 0;
-function isArray$4(val) {
-    return Array.isArray(val);
-}
-array$1.isArray = isArray$4;
-function isntArray$1(val) {
-    return !isArray$4(val);
-}
-array$1.isntArray = isntArray$1;
-function isEmptyArray$1(val) {
-    return val.length === 0;
-}
-array$1.isEmptyArray = isEmptyArray$1;
-function isntEmptyArray$1(val) {
-    return val.length !== 0;
+concat$5.concat = void 0;
+const go_1 = es2018$7;
+function concat$4(iterable, ...otherIterables) {
+    return (0, go_1.go)(function* () {
+        for (const iter of [iterable, ...otherIterables]) {
+            yield* iter;
+        }
+    });
 }
-array$1.isntEmptyArray = isntEmptyArray$1;
+concat$5.concat = concat$4;
 
-var asyncIterable$1 = {};
+var dropAsync = {};
 
-var _null$1 = {};
+var utils = {};
 
-_null$1.isntNull = _null$1.isNull = void 0;
-function isNull$1(val) {
-    return val === null;
+utils.copyIterable = utils.copyAsyncIterable = void 0;
+async function* copyAsyncIterable(iterable) {
+    for await (const element of iterable) {
+        yield element;
+    }
 }
-_null$1.isNull = isNull$1;
-function isntNull$1(val) {
-    return !isNull$1(val);
+utils.copyAsyncIterable = copyAsyncIterable;
+function* copyIterable(iterable) {
+    for (const element of iterable) {
+        yield element;
+    }
 }
-_null$1.isntNull = isntNull$1;
+utils.copyIterable = copyIterable;
 
-var _undefined$1 = {};
+var hasRequiredDropAsync;
 
-_undefined$1.isntUndefined = _undefined$1.isUndefined = void 0;
-function isUndefined$1(val) {
-    return val === undefined;
-}
-_undefined$1.isUndefined = isUndefined$1;
-function isntUndefined$1(val) {
-    return !isUndefined$1(val);
+function requireDropAsync () {
+	if (hasRequiredDropAsync) return dropAsync;
+	hasRequiredDropAsync = 1;
+dropAsync.dropAsync = void 0;
+	const go_1 = es2018$7;
+	const utils_1 = utils;
+	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');
+	    if (count === 0)
+	        return (0, utils_1.copyAsyncIterable)(iterable);
+	    return (0, go_1.go)(async function* () {
+	        var _a;
+	        const iterator = iterable[Symbol.asyncIterator]();
+	        let done;
+	        try {
+	            let value;
+	            while ({ value, done } = await iterator.next(), !done) {
+	                if (count <= 0)
+	                    break;
+	                count--;
+	            }
+	            while (!done) {
+	                yield value;
+	                ({ value, done } = await iterator.next());
+	            }
+	        }
+	        finally {
+	            if (!done)
+	                await ((_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator));
+	        }
+	    });
+	}
+	dropAsync.dropAsync = dropAsync$1;
+	
+	return dropAsync;
 }
-_undefined$1.isntUndefined = isntUndefined$1;
 
-var _function$1 = {};
+var dropRightAsync = {};
 
-_function$1.isntFunction = _function$1.isFunction = void 0;
-function isFunction$3(val) {
-    return typeof val === 'function';
-}
-_function$1.isFunction = isFunction$3;
-function isntFunction$1(val) {
-    return !isFunction$3(val);
-}
-_function$1.isntFunction = isntFunction$1;
+var hasRequiredDropRightAsync;
 
-asyncIterable$1.isntAsyncIterable = asyncIterable$1.isAsyncIterable = void 0;
-const null_1$5 = _null$1;
-const undefined_1$3 = _undefined$1;
-const function_1$5 = _function$1;
-function isAsyncIterable$3(val) {
-    return (0, null_1$5.isntNull)(val)
-        && (0, undefined_1$3.isntUndefined)(val)
-        && (0, function_1$5.isFunction)(val[Symbol.asyncIterator]);
-}
-asyncIterable$1.isAsyncIterable = isAsyncIterable$3;
-function isntAsyncIterable$1(val) {
-    return !isAsyncIterable$3(val);
+function requireDropRightAsync () {
+	if (hasRequiredDropRightAsync) return dropRightAsync;
+	hasRequiredDropRightAsync = 1;
+dropRightAsync.dropRightAsync = void 0;
+	const go_1 = es2018$7;
+	const utils_1 = utils;
+	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');
+	    if (count === 0)
+	        return (0, utils_1.copyAsyncIterable)(iterable);
+	    return (0, go_1.go)(async function* () {
+	        const arr = await toArrayAsync(iterable);
+	        const result = arr.slice(0, -count);
+	        for (const value of result) {
+	            yield value;
+	        }
+	    });
+	}
+	dropRightAsync.dropRightAsync = dropRightAsync$1;
+	async function toArrayAsync(iterable) {
+	    const result = [];
+	    for await (const element of iterable) {
+	        result.push(element);
+	    }
+	    return result;
+	}
+	
+	return dropRightAsync;
 }
-asyncIterable$1.isntAsyncIterable = isntAsyncIterable$1;
 
-var bigint$1 = {};
-
-bigint$1.isntBigInt = bigint$1.isBigInt = void 0;
-function isBigInt$1(val) {
-    return typeof val === 'bigint';
-}
-bigint$1.isBigInt = isBigInt$1;
-function isntBigInt$1(val) {
-    return !isBigInt$1(val);
-}
-bigint$1.isntBigInt = isntBigInt$1;
+var dropRight = {};
 
-var boolean$1 = {};
+var hasRequiredDropRight;
 
-boolean$1.isntBoolean = boolean$1.isBoolean = void 0;
-function isBoolean$1(val) {
-    return typeof val === 'boolean';
-}
-boolean$1.isBoolean = isBoolean$1;
-function isntBoolean$1(val) {
-    return !isBoolean$1(val);
+function requireDropRight () {
+	if (hasRequiredDropRight) return dropRight;
+	hasRequiredDropRight = 1;
+dropRight.dropRight = void 0;
+	const go_1 = es2018$7;
+	const utils_1 = utils;
+	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');
+	    if (count === 0)
+	        return (0, utils_1.copyIterable)(iterable);
+	    return (0, go_1.go)(function* () {
+	        const arr = Array.from(iterable);
+	        yield* arr.slice(0, -count);
+	    });
+	}
+	dropRight.dropRight = dropRight$1;
+	
+	return dropRight;
 }
-boolean$1.isntBoolean = isntBoolean$1;
-
-var char$1 = {};
-
-var string$1 = {};
 
-string$1.isntString = string$1.isString = void 0;
-function isString$1(val) {
-    return typeof val === 'string';
-}
-string$1.isString = isString$1;
-function isntString$1(val) {
-    return !isString$1(val);
-}
-string$1.isntString = isntString$1;
+var dropUntilAsync$1 = {};
 
-char$1.isntChar = char$1.isChar = void 0;
-const string_1$3 = string$1;
-function isChar$1(val) {
-    return (0, string_1$3.isString)(val)
-        && val.length === 1;
-}
-char$1.isChar = isChar$1;
-function isntChar$1(val) {
-    return !isChar$1(val);
+dropUntilAsync$1.dropUntilAsync = void 0;
+const types_1$h = es2018$6;
+function dropUntilAsync(iterable, predicate) {
+    if ((0, types_1$h.isAsyncIterable)(iterable)) {
+        return dropUntilAsyncIterable(iterable);
+    }
+    else {
+        return dropUntilIterable(iterable);
+    }
+    async function* dropUntilAsyncIterable(iterable) {
+        var _a;
+        const iterator = iterable[Symbol.asyncIterator]();
+        let done;
+        try {
+            let index = 0;
+            let value;
+            while ({ value, done } = await iterator.next(), !done) {
+                if (await predicate(value, index++))
+                    break;
+            }
+            while (!done) {
+                yield value;
+                ({ value, done } = await iterator.next());
+            }
+        }
+        finally {
+            if (!done)
+                await ((_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator));
+        }
+    }
+    async function* dropUntilIterable(iterable) {
+        var _a;
+        const iterator = iterable[Symbol.iterator]();
+        let done;
+        try {
+            let index = 0;
+            let value;
+            while ({ value, done } = iterator.next(), !done) {
+                if (await predicate(value, index++))
+                    break;
+            }
+            while (!done) {
+                yield value;
+                ({ value, done } = iterator.next());
+            }
+        }
+        finally {
+            if (!done)
+                (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
+        }
+    }
 }
-char$1.isntChar = isntChar$1;
+dropUntilAsync$1.dropUntilAsync = dropUntilAsync;
 
-var date$1 = {};
+var dropUntil$1 = {};
 
-date$1.isntDate = date$1.isDate = void 0;
-function isDate$2(val) {
-    return val instanceof Date;
-}
-date$1.isDate = isDate$2;
-function isntDate$1(val) {
-    return !isDate$2(val);
+dropUntil$1.dropUntil = void 0;
+function* dropUntil(iterable, predicate) {
+    var _a;
+    const iterator = iterable[Symbol.iterator]();
+    let done;
+    try {
+        let index = 0;
+        let value;
+        while ({ value, done } = iterator.next(), !done) {
+            if (predicate(value, index++))
+                break;
+        }
+        while (!done) {
+            yield value;
+            ({ value, done } = iterator.next());
+        }
+    }
+    finally {
+        if (!done)
+            (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
+    }
 }
-date$1.isntDate = isntDate$1;
+dropUntil$1.dropUntil = dropUntil;
 
-var _enum$1 = {};
+var drop = {};
 
-_enum$1.inEnum = void 0;
-function inEnum$1(val, _enum) {
-    return Object.values(_enum).includes(val);
-}
-_enum$1.inEnum = inEnum$1;
+var hasRequiredDrop;
 
-var error$1 = {};
-
-error$1.isntError = error$1.isError = void 0;
-function isError$1(val) {
-    return val instanceof Error;
-}
-error$1.isError = isError$1;
-function isntError$1(val) {
-    return !isError$1(val);
+function requireDrop () {
+	if (hasRequiredDrop) return drop;
+	hasRequiredDrop = 1;
+drop.drop = void 0;
+	const go_1 = es2018$7;
+	const utils_1 = utils;
+	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');
+	    if (count === 0)
+	        return (0, utils_1.copyIterable)(iterable);
+	    return (0, go_1.go)(function* () {
+	        var _a;
+	        const iterator = iterable[Symbol.iterator]();
+	        let done;
+	        try {
+	            let value;
+	            while ({ value, done } = iterator.next(), !done) {
+	                if (count <= 0)
+	                    break;
+	                count--;
+	            }
+	            while (!done) {
+	                yield value;
+	                ({ value, done } = iterator.next());
+	            }
+	        }
+	        finally {
+	            if (!done)
+	                (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
+	        }
+	    });
+	}
+	drop.drop = drop$1;
+	
+	return drop;
 }
-error$1.isntError = isntError$1;
 
-var falsy$1 = {};
+var filterAsync$1 = {};
 
-falsy$1.isntFalsy = falsy$1.isFalsy = void 0;
-function isFalsy$1(val) {
-    return !val;
-}
-falsy$1.isFalsy = isFalsy$1;
-function isntFalsy$1(val) {
-    return !isFalsy$1(val);
+filterAsync$1.filterAsync = void 0;
+const types_1$g = es2018$6;
+function filterAsync(iterable, predicate) {
+    if ((0, types_1$g.isAsyncIterable)(iterable)) {
+        return filterAsyncIterable(iterable);
+    }
+    else {
+        return filterIterable(iterable);
+    }
+    async function* filterAsyncIterable(iterable) {
+        let index = 0;
+        for await (const element of iterable) {
+            if (await predicate(element, index))
+                yield element;
+            index++;
+        }
+    }
+    async function* filterIterable(iterable) {
+        let index = 0;
+        for (const element of iterable) {
+            if (await predicate(element, index))
+                yield element;
+            index++;
+        }
+    }
 }
-falsy$1.isntFalsy = isntFalsy$1;
+filterAsync$1.filterAsync = filterAsync;
 
-var iterable$1 = {};
+var filter$3 = {};
 
-iterable$1.isntIterable = iterable$1.isIterable = void 0;
-const null_1$4 = _null$1;
-const undefined_1$2 = _undefined$1;
-const function_1$4 = _function$1;
-function isIterable$3(val) {
-    return (0, null_1$4.isntNull)(val)
-        && (0, undefined_1$2.isntUndefined)(val)
-        && (0, function_1$4.isFunction)(val[Symbol.iterator]);
-}
-iterable$1.isIterable = isIterable$3;
-function isntIterable$1(val) {
-    return !isIterable$3(val);
+filter$3.filter = void 0;
+function* filter$2(iterable, predicate) {
+    let index = 0;
+    for (const element of iterable) {
+        if (predicate(element, index))
+            yield element;
+        index++;
+    }
 }
-iterable$1.isntIterable = isntIterable$1;
+filter$3.filter = filter$2;
 
-var json$1 = {};
+var flattenAsync = {};
 
-var number$1 = {};
+var flattenDeepAsync = {};
 
-number$1.isntNaN = number$1.isNaN = number$1.isNegativeInfinity = number$1.isPositiveInfinity = number$1.isFinite = number$1.isntNumber = number$1.isNumber = void 0;
-function isNumber$1(val) {
-    return typeof val === 'number';
-}
-number$1.isNumber = isNumber$1;
-function isntNumber$1(val) {
-    return !isNumber$1(val);
-}
-number$1.isntNumber = isntNumber$1;
-function isFinite$1(val) {
-    return Number.isFinite(val);
-}
-number$1.isFinite = isFinite$1;
-function isPositiveInfinity$1(val) {
-    return val === Infinity;
-}
-number$1.isPositiveInfinity = isPositiveInfinity$1;
-function isNegativeInfinity$1(val) {
-    return val === -Infinity;
-}
-number$1.isNegativeInfinity = isNegativeInfinity$1;
-function isNaN$2(val) {
-    return Number.isNaN(val);
+var flattenByAsync$1 = {};
+
+flattenByAsync$1.flattenByAsync = void 0;
+const types_1$f = es2018$6;
+function flattenByAsync(iterable, predicate) {
+    if ((0, types_1$f.isAsyncIterable)(iterable)) {
+        return flattenByAsyncIterable(iterable);
+    }
+    else {
+        return flattenByIterable(iterable);
+    }
+    async function* flattenByAsyncIterable(iterable) {
+        const level = 1;
+        for await (const element of iterable) {
+            if (isFiniteIterable$1(element) && await predicate(element, level)) {
+                yield* flatten(element, level + 1);
+            }
+            else {
+                yield element;
+            }
+        }
+    }
+    function flattenByIterable(iterable) {
+        return flatten(iterable, 1);
+    }
+    async function* flatten(iterable, level) {
+        for (const element of iterable) {
+            if (isFiniteIterable$1(element) && await predicate(element, level)) {
+                yield* flatten(element, level + 1);
+            }
+            else {
+                yield element;
+            }
+        }
+    }
 }
-number$1.isNaN = isNaN$2;
-function isntNaN$1(val) {
-    return !isNaN$2(val);
+flattenByAsync$1.flattenByAsync = flattenByAsync;
+function isFiniteIterable$1(val) {
+    return (0, types_1$f.isIterable)(val) && (0, types_1$f.isntChar)(val);
 }
-number$1.isntNaN = isntNaN$1;
 
-var object$1 = {};
+var hasRequiredFlattenDeepAsync;
 
-var __importDefault$1 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};object$1.isntEmptyObject = object$1.isEmptyObject = object$1.isntPlainObject = object$1.isPlainObject = object$1.isntObject = object$1.isObject = void 0;
-const isPlainObject_1$1 = __importDefault$1(isPlainObject_1$3);
-function isObject$1(val) {
-    return val !== null
-        && typeof val === 'object';
-}
-object$1.isObject = isObject$1;
-function isntObject$1(val) {
-    return !isObject$1(val);
-}
-object$1.isntObject = isntObject$1;
-function isPlainObject$1(val) {
-    return (0, isPlainObject_1$1.default)(val);
+function requireFlattenDeepAsync () {
+	if (hasRequiredFlattenDeepAsync) return flattenDeepAsync;
+	hasRequiredFlattenDeepAsync = 1;
+flattenDeepAsync.flattenDeepAsync = void 0;
+	const flatten_by_async_1 = flattenByAsync$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');
+	    return (0, flatten_by_async_1.flattenByAsync)(iterable, (_, level) => level <= depth);
+	}
+	flattenDeepAsync.flattenDeepAsync = flattenDeepAsync$1;
+	
+	return flattenDeepAsync;
 }
-object$1.isPlainObject = isPlainObject$1;
-function isntPlainObject$1(val) {
-    return !isPlainObject$1(val);
+
+var hasRequiredFlattenAsync;
+
+function requireFlattenAsync () {
+	if (hasRequiredFlattenAsync) return flattenAsync;
+	hasRequiredFlattenAsync = 1;
+flattenAsync.flattenAsync = void 0;
+	const flatten_deep_async_1 = requireFlattenDeepAsync();
+	function flattenAsync$1(iterable) {
+	    return (0, flatten_deep_async_1.flattenDeepAsync)(iterable, 1);
+	}
+	flattenAsync.flattenAsync = flattenAsync$1;
+	
+	return flattenAsync;
 }
-object$1.isntPlainObject = isntPlainObject$1;
-function isEmptyObject$1(val) {
-    return Object.keys(val).length === 0;
+
+var flattenBy$1 = {};
+
+flattenBy$1.flattenBy = void 0;
+const types_1$e = es2018$6;
+function flattenBy(iterable, predicate) {
+    return flatten(iterable, 1);
+    function* flatten(iterable, level) {
+        for (const element of iterable) {
+            if (isFiniteIterable(element) && predicate(element, level)) {
+                yield* flatten(element, level + 1);
+            }
+            else {
+                yield element;
+            }
+        }
+    }
 }
-object$1.isEmptyObject = isEmptyObject$1;
-function isntEmptyObject$1(val) {
-    return Object.keys(val).length !== 0;
+flattenBy$1.flattenBy = flattenBy;
+function isFiniteIterable(val) {
+    return (0, types_1$e.isIterable)(val) && (0, types_1$e.isntChar)(val);
 }
-object$1.isntEmptyObject = isntEmptyObject$1;
 
-json$1.isntJsonable = json$1.isJsonable = json$1.isntJson = json$1.isJson = void 0;
-const null_1$3 = _null$1;
-const boolean_1$1 = boolean$1;
-const string_1$2 = string$1;
-const number_1$1 = number$1;
-const array_1$1 = array$1;
-const object_1$3 = object$1;
-function isJson$1(val) {
-    return (0, null_1$3.isNull)(val)
-        || (0, boolean_1$1.isBoolean)(val)
-        || (0, string_1$2.isString)(val)
-        || (0, number_1$1.isNumber)(val)
-        || ((0, array_1$1.isArray)(val) && val.every(isJson$1))
-        || ((0, object_1$3.isPlainObject)(val) && Object.values(val).every(isJson$1));
-}
-json$1.isJson = isJson$1;
-function isntJson$1(val) {
-    return !isJson$1(val);
-}
-json$1.isntJson = isntJson$1;
-function isJsonable$1(val) {
-    try {
-        JSON.stringify(val);
-        return true;
-    }
-    catch (_a) {
-        return false;
-    }
-}
-json$1.isJsonable = isJsonable$1;
-function isntJsonable$1(val) {
-    return !isntJsonable$1();
-}
-json$1.isntJsonable = isntJsonable$1;
+var flattenDeep = {};
 
-var promise$1 = {};
+var hasRequiredFlattenDeep;
 
-promise$1.isPromiseLike = promise$1.isntPromiseLike = promise$1.isntPromise = promise$1.isPromise = void 0;
-const object_1$2 = object$1;
-const function_1$3 = _function$1;
-function isPromise$3(val) {
-    return val instanceof Promise;
-}
-promise$1.isPromise = isPromise$3;
-function isntPromise$1(val) {
-    return !isPromise$3(val);
-}
-promise$1.isntPromise = isntPromise$1;
-function isntPromiseLike$1(val) {
-    return !isPromiseLike$1(val);
-}
-promise$1.isntPromiseLike = isntPromiseLike$1;
-function isPromiseLike$1(val) {
-    return (0, object_1$2.isObject)(val)
-        && (0, function_1$3.isFunction)(val.then);
+function requireFlattenDeep () {
+	if (hasRequiredFlattenDeep) return flattenDeep;
+	hasRequiredFlattenDeep = 1;
+flattenDeep.flattenDeep = void 0;
+	const flatten_by_1 = flattenBy$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');
+	    return (0, flatten_by_1.flattenBy)(iterable, (_, level) => level <= depth);
+	}
+	flattenDeep.flattenDeep = flattenDeep$1;
+	
+	return flattenDeep;
 }
-promise$1.isPromiseLike = isPromiseLike$1;
 
-var url$1 = {};
+var flatten = {};
 
-url$1.isAbsoluteURL = void 0;
-function isAbsoluteURL$1(str) {
-    try {
-        new URL(str);
-        return true;
-    }
-    catch (_a) {
-        return false;
-    }
-}
-url$1.isAbsoluteURL = isAbsoluteURL$1;
+var hasRequiredFlatten;
 
-(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(array$1, exports);
-	__exportStar(asyncIterable$1, exports);
-	__exportStar(bigint$1, exports);
-	__exportStar(boolean$1, exports);
-	__exportStar(char$1, exports);
-	__exportStar(date$1, exports);
-	__exportStar(_enum$1, exports);
-	__exportStar(error$1, exports);
-	__exportStar(falsy$1, exports);
-	__exportStar(_function$1, exports);
-	__exportStar(iterable$1, exports);
-	__exportStar(json$1, exports);
-	__exportStar(_null$1, exports);
-	__exportStar(number$1, exports);
-	__exportStar(object$1, exports);
-	__exportStar(promise$1, exports);
-	__exportStar(string$1, exports);
-	__exportStar(_undefined$1, exports);
-	__exportStar(url$1, exports);
+function requireFlatten () {
+	if (hasRequiredFlatten) return flatten;
+	hasRequiredFlatten = 1;
+flatten.flatten = void 0;
+	const flatten_deep_1 = requireFlattenDeep();
+	function flatten$1(iterable) {
+	    return (0, flatten_deep_1.flattenDeep)(iterable, 1);
+	}
+	flatten.flatten = flatten$1;
 	
-} (es2018$5));
+	return flatten;
+}
 
-chunkByAsync$1.chunkByAsync = void 0;
-const types_1$j = es2018$5;
-function chunkByAsync(iterable, predicate) {
-    if ((0, types_1$j.isAsyncIterable)(iterable)) {
-        return chunkByAsyncIterable(iterable);
+var mapAsync$1 = {};
+
+mapAsync$1.mapAsync = void 0;
+const types_1$d = es2018$6;
+function mapAsync(iterable, fn) {
+    if ((0, types_1$d.isAsyncIterable)(iterable)) {
+        return mapAsyncIterable(iterable);
     }
     else {
-        return chunkByIterable(iterable);
+        return mapIterable(iterable);
     }
-    async function* chunkByAsyncIterable(iterable) {
-        let buffer = [];
+    async function* mapAsyncIterable(iterable) {
         let index = 0;
         for await (const element of iterable) {
-            buffer.push(element);
-            if (await predicate(element, index)) {
-                yield buffer;
-                buffer = [];
-            }
+            yield await fn(element, index);
             index++;
         }
-        if (buffer.length)
-            yield buffer;
     }
-    async function* chunkByIterable(iterable) {
-        let buffer = [];
+    async function* mapIterable(iterable) {
         let index = 0;
         for (const element of iterable) {
-            buffer.push(element);
-            if (await predicate(element, index)) {
-                yield buffer;
-                buffer = [];
-            }
+            yield await fn(element, index);
             index++;
         }
-        if (buffer.length)
-            yield buffer;
     }
 }
-chunkByAsync$1.chunkByAsync = chunkByAsync;
+mapAsync$1.mapAsync = mapAsync;
 
-var chunkBy$1 = {};
+var map$3 = {};
 
-chunkBy$1.chunkBy = void 0;
-function* chunkBy(iterable, predicate) {
-    let buffer = [];
+map$3.map = void 0;
+function* map$2(iterable, fn) {
     let index = 0;
     for (const element of iterable) {
-        buffer.push(element);
-        if (predicate(element, index)) {
-            yield buffer;
-            buffer = [];
-        }
+        yield fn(element, index);
         index++;
     }
-    if (buffer.length)
-        yield buffer;
 }
-chunkBy$1.chunkBy = chunkBy;
+map$3.map = map$2;
 
-var chunk = {};
+var repeatAsync = {};
 
-var hasRequiredChunk;
+var hasRequiredRepeatAsync;
 
-function requireChunk () {
-	if (hasRequiredChunk) return chunk;
-	hasRequiredChunk = 1;
-chunk.chunk = void 0;
-	const go_1 = es2018$6;
+function requireRepeatAsync () {
+	if (hasRequiredRepeatAsync) return repeatAsync;
+	hasRequiredRepeatAsync = 1;
+repeatAsync.repeatAsync = void 0;
+	const go_1 = es2018$7;
 	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');
-	    return (0, go_1.go)(function* () {
-	        let buffer = [];
-	        for (const element of iterable) {
-	            buffer.push(element);
-	            if (buffer.length >= size) {
-	                yield buffer;
-	                buffer = [];
+	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');
+	    if (times === Infinity)
+	        warnInfiniteLoop();
+	    return (0, go_1.go)(async function* () {
+	        const cache = [];
+	        if (times > 0) {
+	            for await (const element of iterable) {
+	                yield element;
+	                cache.push(element);
 	            }
+	            times--;
+	        }
+	        while (times > 0) {
+	            yield* cache;
+	            times--;
 	        }
-	        if (buffer.length)
-	            yield buffer;
 	    });
 	}
-	chunk.chunk = chunk$1;
+	repeatAsync.repeatAsync = repeatAsync$1;
+	function warnInfiniteLoop() {
+	    if (isProduction())
+	        return;
+	    console.warn('When iterable has no elements and times is Infinity, repeat() will be in dead loop');
+	}
+	function isProduction() {
+	    return process.env.NODE_ENV === 'production';
+	}
 	
-	return chunk;
+	return repeatAsync;
 }
 
-var concatAsync$1 = {};
-
-concatAsync$1.concatAsync = void 0;
-const types_1$i = es2018$5;
-const go_1$1 = es2018$6;
-function concatAsync(iterable, ...otherIterables) {
-    return (0, go_1$1.go)(async function* () {
-        for (const iter of [iterable, ...otherIterables]) {
-            if ((0, types_1$i.isAsyncIterable)(iter)) {
-                for await (const element of iter) {
-                    yield element;
-                }
-            }
-            else {
-                for (const element of iter) {
-                    yield element;
-                }
-            }
-        }
-    });
-}
-concatAsync$1.concatAsync = concatAsync;
+var repeat$2 = {};
 
-var concat$5 = {};
+var hasRequiredRepeat;
 
-concat$5.concat = void 0;
-const go_1 = es2018$6;
-function concat$4(iterable, ...otherIterables) {
-    return (0, go_1.go)(function* () {
-        for (const iter of [iterable, ...otherIterables]) {
-            yield* iter;
-        }
-    });
-}
-concat$5.concat = concat$4;
-
-var dropAsync = {};
-
-var utils = {};
-
-utils.copyIterable = utils.copyAsyncIterable = void 0;
-async function* copyAsyncIterable(iterable) {
-    for await (const element of iterable) {
-        yield element;
-    }
-}
-utils.copyAsyncIterable = copyAsyncIterable;
-function* copyIterable(iterable) {
-    for (const element of iterable) {
-        yield element;
-    }
-}
-utils.copyIterable = copyIterable;
-
-var hasRequiredDropAsync;
-
-function requireDropAsync () {
-	if (hasRequiredDropAsync) return dropAsync;
-	hasRequiredDropAsync = 1;
-dropAsync.dropAsync = void 0;
-	const go_1 = es2018$6;
-	const utils_1 = utils;
+function requireRepeat () {
+	if (hasRequiredRepeat) return repeat$2;
+	hasRequiredRepeat = 1;
+repeat$2.repeat = void 0;
+	const go_1 = es2018$7;
 	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');
-	    if (count === 0)
-	        return (0, utils_1.copyAsyncIterable)(iterable);
-	    return (0, go_1.go)(async function* () {
-	        var _a;
-	        const iterator = iterable[Symbol.asyncIterator]();
-	        let done;
-	        try {
-	            let value;
-	            while ({ value, done } = await iterator.next(), !done) {
-	                if (count <= 0)
-	                    break;
-	                count--;
-	            }
-	            while (!done) {
-	                yield value;
-	                ({ value, done } = await iterator.next());
+	function repeat(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');
+	    if (times === Infinity)
+	        warnInfiniteLoop();
+	    return (0, go_1.go)(function* () {
+	        const cache = [];
+	        if (times > 0) {
+	            for (const element of iterable) {
+	                yield element;
+	                cache.push(element);
 	            }
+	            times--;
 	        }
-	        finally {
-	            if (!done)
-	                await ((_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator));
+	        while (times > 0) {
+	            yield* cache;
+	            times--;
 	        }
 	    });
 	}
-	dropAsync.dropAsync = dropAsync$1;
+	repeat$2.repeat = repeat;
+	function warnInfiniteLoop() {
+	    if (isProduction())
+	        return;
+	    console.warn('When iterable has no elements and times is Infinity, repeat() will be in dead loop');
+	}
+	function isProduction() {
+	    return process.env.NODE_ENV === 'production';
+	}
 	
-	return dropAsync;
+	return repeat$2;
 }
 
-var dropRightAsync = {};
+var sliceAsync = {};
 
-var hasRequiredDropRightAsync;
+var hasRequiredSliceAsync;
 
-function requireDropRightAsync () {
-	if (hasRequiredDropRightAsync) return dropRightAsync;
-	hasRequiredDropRightAsync = 1;
-dropRightAsync.dropRightAsync = void 0;
-	const go_1 = es2018$6;
-	const utils_1 = utils;
+function requireSliceAsync () {
+	if (hasRequiredSliceAsync) return sliceAsync;
+	hasRequiredSliceAsync = 1;
+sliceAsync.sliceAsync = void 0;
+	const go_1 = es2018$7;
 	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');
-	    if (count === 0)
-	        return (0, utils_1.copyAsyncIterable)(iterable);
+	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');
+	    (0, errors_1.assert)(Number.isInteger(end), 'The parameter end must be an integer');
+	    (0, errors_1.assert)(end >= start, 'The parameter end must be greater than or equal to start');
 	    return (0, go_1.go)(async function* () {
-	        const arr = await toArrayAsync(iterable);
-	        const result = arr.slice(0, -count);
-	        for (const value of result) {
-	            yield value;
+	        let index = 0;
+	        for await (const element of iterable) {
+	            if (index >= end)
+	                break;
+	            if (index >= start)
+	                yield element;
+	            index++;
 	        }
 	    });
 	}
-	dropRightAsync.dropRightAsync = dropRightAsync$1;
-	async function toArrayAsync(iterable) {
-	    const result = [];
-	    for await (const element of iterable) {
-	        result.push(element);
-	    }
-	    return result;
-	}
+	sliceAsync.sliceAsync = sliceAsync$1;
 	
-	return dropRightAsync;
+	return sliceAsync;
 }
 
-var dropRight = {};
+var slice = {};
 
-var hasRequiredDropRight;
+var hasRequiredSlice;
 
-function requireDropRight () {
-	if (hasRequiredDropRight) return dropRight;
-	hasRequiredDropRight = 1;
-dropRight.dropRight = void 0;
-	const go_1 = es2018$6;
-	const utils_1 = utils;
+function requireSlice () {
+	if (hasRequiredSlice) return slice;
+	hasRequiredSlice = 1;
+slice.slice = void 0;
+	const go_1 = es2018$7;
 	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');
-	    if (count === 0)
-	        return (0, utils_1.copyIterable)(iterable);
+	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');
+	    (0, errors_1.assert)(Number.isInteger(end), 'The parameter end must be an integer');
+	    (0, errors_1.assert)(end >= start, 'The parameter end must be greater than or equal to start');
 	    return (0, go_1.go)(function* () {
-	        const arr = Array.from(iterable);
-	        yield* arr.slice(0, -count);
+	        let index = 0;
+	        for (const element of iterable) {
+	            if (index >= end)
+	                break;
+	            if (index >= start)
+	                yield element;
+	            index++;
+	        }
 	    });
 	}
-	dropRight.dropRight = dropRight$1;
+	slice.slice = slice$1;
 	
-	return dropRight;
+	return slice;
 }
 
-var dropUntilAsync$1 = {};
+var splitAsync$1 = {};
 
-dropUntilAsync$1.dropUntilAsync = void 0;
-const types_1$h = es2018$5;
-function dropUntilAsync(iterable, predicate) {
-    if ((0, types_1$h.isAsyncIterable)(iterable)) {
-        return dropUntilAsyncIterable(iterable);
+splitAsync$1.splitAsync = void 0;
+async function* splitAsync(iterable, separator) {
+    let buffer = [];
+    for await (const element of iterable) {
+        if (element === separator) {
+            yield buffer;
+            buffer = [];
+        }
+        else {
+            buffer.push(element);
+        }
+    }
+    yield buffer;
+}
+splitAsync$1.splitAsync = splitAsync;
+
+var splitByAsync$1 = {};
+
+splitByAsync$1.splitByAsync = void 0;
+const types_1$c = es2018$6;
+function splitByAsync(iterable, predicate) {
+    if ((0, types_1$c.isAsyncIterable)(iterable)) {
+        return splitByAsyncIterable(iterable);
     }
     else {
-        return dropUntilIterable(iterable);
+        return splitByIterable(iterable);
     }
-    async function* dropUntilAsyncIterable(iterable) {
-        var _a;
-        const iterator = iterable[Symbol.asyncIterator]();
-        let done;
-        try {
-            let index = 0;
-            let value;
-            while ({ value, done } = await iterator.next(), !done) {
-                if (await predicate(value, index++))
-                    break;
+    async function* splitByIterable(iterable) {
+        let buffer = [];
+        let index = 0;
+        for (const element of iterable) {
+            if (await predicate(element, index)) {
+                yield buffer;
+                buffer = [];
             }
-            while (!done) {
-                yield value;
-                ({ value, done } = await iterator.next());
+            else {
+                buffer.push(element);
             }
+            index++;
         }
-        finally {
-            if (!done)
-                await ((_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator));
-        }
+        yield buffer;
     }
-    async function* dropUntilIterable(iterable) {
-        var _a;
-        const iterator = iterable[Symbol.iterator]();
-        let done;
-        try {
-            let index = 0;
-            let value;
-            while ({ value, done } = iterator.next(), !done) {
-                if (await predicate(value, index++))
-                    break;
+    async function* splitByAsyncIterable(iterable) {
+        let buffer = [];
+        let index = 0;
+        for await (const element of iterable) {
+            if (await predicate(element, index)) {
+                yield buffer;
+                buffer = [];
             }
-            while (!done) {
-                yield value;
-                ({ value, done } = iterator.next());
+            else {
+                buffer.push(element);
             }
+            index++;
         }
-        finally {
-            if (!done)
-                (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
-        }
+        yield buffer;
     }
 }
-dropUntilAsync$1.dropUntilAsync = dropUntilAsync;
+splitByAsync$1.splitByAsync = splitByAsync;
 
-var dropUntil$1 = {};
+var splitBy$1 = {};
 
-dropUntil$1.dropUntil = void 0;
-function* dropUntil(iterable, predicate) {
-    var _a;
-    const iterator = iterable[Symbol.iterator]();
-    let done;
-    try {
-        let index = 0;
-        let value;
-        while ({ value, done } = iterator.next(), !done) {
-            if (predicate(value, index++))
-                break;
+splitBy$1.splitBy = void 0;
+function* splitBy(iterable, predicate) {
+    let buffer = [];
+    let index = 0;
+    for (const element of iterable) {
+        if (predicate(element, index)) {
+            yield buffer;
+            buffer = [];
         }
-        while (!done) {
-            yield value;
-            ({ value, done } = iterator.next());
+        else {
+            buffer.push(element);
         }
+        index++;
     }
-    finally {
-        if (!done)
-            (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
+    yield buffer;
+}
+splitBy$1.splitBy = splitBy;
+
+var split$1 = {};
+
+split$1.split = void 0;
+function* split(iterable, separator) {
+    let buffer = [];
+    for (const element of iterable) {
+        if (element === separator) {
+            yield buffer;
+            buffer = [];
+        }
+        else {
+            buffer.push(element);
+        }
     }
+    yield buffer;
 }
-dropUntil$1.dropUntil = dropUntil;
+split$1.split = split;
 
-var drop = {};
+var takeAsync = {};
 
-var hasRequiredDrop;
+var hasRequiredTakeAsync;
 
-function requireDrop () {
-	if (hasRequiredDrop) return drop;
-	hasRequiredDrop = 1;
-drop.drop = void 0;
-	const go_1 = es2018$6;
-	const utils_1 = utils;
+function requireTakeAsync () {
+	if (hasRequiredTakeAsync) return takeAsync;
+	hasRequiredTakeAsync = 1;
+takeAsync.takeAsync = void 0;
+	const go_1 = es2018$7;
 	const errors_1 = requireEs2018();
-	function drop$1(iterable, count) {
+	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');
+	    return (0, go_1.go)(async function* () {
+	        if (count === 0)
+	            return;
+	        for await (const element of iterable) {
+	            yield element;
+	            count--;
+	            if (count === 0)
+	                break;
+	        }
+	    });
+	}
+	takeAsync.takeAsync = takeAsync$1;
+	
+	return takeAsync;
+}
+
+var takeRightAsync = {};
+
+var hasRequiredTakeRightAsync;
+
+function requireTakeRightAsync () {
+	if (hasRequiredTakeRightAsync) return takeRightAsync;
+	hasRequiredTakeRightAsync = 1;
+takeRightAsync.takeRightAsync = void 0;
+	const go_1 = es2018$7;
+	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');
+	    return (0, go_1.go)(async function* () {
+	        var _a;
+	        const iterator = iterable[Symbol.asyncIterator]();
+	        let done;
+	        try {
+	            const buffer = [];
+	            let value;
+	            while ({ value, done } = await iterator.next(), !done) {
+	                buffer.push(value);
+	                if (buffer.length > count)
+	                    buffer.shift();
+	            }
+	            yield* buffer;
+	        }
+	        finally {
+	            if (!done)
+	                await ((_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator));
+	        }
+	    });
+	}
+	takeRightAsync.takeRightAsync = takeRightAsync$1;
+	
+	return takeRightAsync;
+}
+
+var takeRight = {};
+
+var hasRequiredTakeRight;
+
+function requireTakeRight () {
+	if (hasRequiredTakeRight) return takeRight;
+	hasRequiredTakeRight = 1;
+takeRight.takeRight = void 0;
+	const go_1 = es2018$7;
+	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');
-	    if (count === 0)
-	        return (0, utils_1.copyIterable)(iterable);
 	    return (0, go_1.go)(function* () {
 	        var _a;
 	        const iterator = iterable[Symbol.iterator]();
 	        let done;
 	        try {
+	            const buffer = [];
 	            let value;
 	            while ({ value, done } = iterator.next(), !done) {
-	                if (count <= 0)
-	                    break;
-	                count--;
-	            }
-	            while (!done) {
-	                yield value;
-	                ({ value, done } = iterator.next());
+	                buffer.push(value);
+	                if (buffer.length > count)
+	                    buffer.shift();
 	            }
+	            yield* buffer;
 	        }
 	        finally {
 	            if (!done)
@@ -3950,1318 +4160,842 @@ drop.drop = void 0;
 	        }
 	    });
 	}
-	drop.drop = drop$1;
+	takeRight.takeRight = takeRight$1;
 	
-	return drop;
+	return takeRight;
 }
 
-var filterAsync$1 = {};
+var takeUntilAsync$1 = {};
 
-filterAsync$1.filterAsync = void 0;
-const types_1$g = es2018$5;
-function filterAsync(iterable, predicate) {
-    if ((0, types_1$g.isAsyncIterable)(iterable)) {
-        return filterAsyncIterable(iterable);
+takeUntilAsync$1.takeUntilAsync = void 0;
+const types_1$b = es2018$6;
+function takeUntilAsync(iterable, predicate) {
+    if ((0, types_1$b.isAsyncIterable)(iterable)) {
+        return takeUntilAsyncIterable(iterable);
     }
     else {
-        return filterIterable(iterable);
+        return takeUntilIterable(iterable);
     }
-    async function* filterAsyncIterable(iterable) {
+    async function* takeUntilAsyncIterable(iterable) {
         let index = 0;
         for await (const element of iterable) {
             if (await predicate(element, index))
-                yield element;
+                break;
+            yield element;
             index++;
         }
     }
-    async function* filterIterable(iterable) {
+    async function* takeUntilIterable(iterable) {
         let index = 0;
         for (const element of iterable) {
             if (await predicate(element, index))
-                yield element;
+                break;
+            yield element;
             index++;
         }
     }
 }
-filterAsync$1.filterAsync = filterAsync;
+takeUntilAsync$1.takeUntilAsync = takeUntilAsync;
 
-var filter$3 = {};
+var takeUntil$3 = {};
 
-filter$3.filter = void 0;
-function* filter$2(iterable, predicate) {
+takeUntil$3.takeUntil = void 0;
+function* takeUntil$2(iterable, predicate) {
     let index = 0;
     for (const element of iterable) {
         if (predicate(element, index))
-            yield element;
+            break;
+        yield element;
         index++;
     }
 }
-filter$3.filter = filter$2;
+takeUntil$3.takeUntil = takeUntil$2;
 
-var flattenAsync = {};
+var take$2 = {};
 
-var flattenDeepAsync = {};
+var hasRequiredTake;
 
-var flattenByAsync$1 = {};
+function requireTake () {
+	if (hasRequiredTake) return take$2;
+	hasRequiredTake = 1;
+take$2.take = void 0;
+	const go_1 = es2018$7;
+	const errors_1 = requireEs2018();
+	function take(iterable, count) {
+	    (0, errors_1.assert)(Number.isInteger(count), 'The parameter count must be an integer');
+	    (0, errors_1.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
+	    return (0, go_1.go)(function* () {
+	        if (count === 0)
+	            return;
+	        for (const element of iterable) {
+	            yield element;
+	            count--;
+	            if (count === 0)
+	                break;
+	        }
+	    });
+	}
+	take$2.take = take;
+	
+	return take$2;
+}
 
-flattenByAsync$1.flattenByAsync = void 0;
-const types_1$f = es2018$5;
-function flattenByAsync(iterable, predicate) {
-    if ((0, types_1$f.isAsyncIterable)(iterable)) {
-        return flattenByAsyncIterable(iterable);
+var tapAsync$1 = {};
+
+tapAsync$1.tapAsync = void 0;
+const types_1$a = es2018$6;
+function tapAsync(iterable, fn) {
+    if ((0, types_1$a.isAsyncIterable)(iterable)) {
+        return tapAsyncIterable(iterable);
     }
     else {
-        return flattenByIterable(iterable);
+        return tapIterable(iterable);
     }
-    async function* flattenByAsyncIterable(iterable) {
-        const level = 1;
-        for await (const element of iterable) {
-            if (isFiniteIterable$1(element) && await predicate(element, level)) {
-                yield* flatten(element, level + 1);
-            }
-            else {
-                yield element;
-            }
+    async function* tapIterable(iterable) {
+        let index = 0;
+        for (const element of iterable) {
+            await fn(element, index);
+            yield element;
+            index++;
         }
     }
-    function flattenByIterable(iterable) {
-        return flatten(iterable, 1);
-    }
-    async function* flatten(iterable, level) {
-        for (const element of iterable) {
-            if (isFiniteIterable$1(element) && await predicate(element, level)) {
-                yield* flatten(element, level + 1);
-            }
-            else {
-                yield element;
-            }
+    async function* tapAsyncIterable(iterable) {
+        let index = 0;
+        for await (const element of iterable) {
+            await fn(element, index);
+            yield element;
+            index++;
         }
     }
 }
-flattenByAsync$1.flattenByAsync = flattenByAsync;
-function isFiniteIterable$1(val) {
-    return (0, types_1$f.isIterable)(val) && (0, types_1$f.isntChar)(val);
-}
+tapAsync$1.tapAsync = tapAsync;
 
-var hasRequiredFlattenDeepAsync;
+var tap$3 = {};
 
-function requireFlattenDeepAsync () {
-	if (hasRequiredFlattenDeepAsync) return flattenDeepAsync;
-	hasRequiredFlattenDeepAsync = 1;
-flattenDeepAsync.flattenDeepAsync = void 0;
-	const flatten_by_async_1 = flattenByAsync$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');
-	    return (0, flatten_by_async_1.flattenByAsync)(iterable, (_, level) => level <= depth);
-	}
-	flattenDeepAsync.flattenDeepAsync = flattenDeepAsync$1;
-	
-	return flattenDeepAsync;
+tap$3.tap = void 0;
+function* tap$2(iterable, fn) {
+    let index = 0;
+    for (const element of iterable) {
+        fn(element, index);
+        yield element;
+        index++;
+    }
 }
+tap$3.tap = tap$2;
 
-var hasRequiredFlattenAsync;
+var toAsyncIterable$1 = {};
 
-function requireFlattenAsync () {
-	if (hasRequiredFlattenAsync) return flattenAsync;
-	hasRequiredFlattenAsync = 1;
-flattenAsync.flattenAsync = void 0;
-	const flatten_deep_async_1 = requireFlattenDeepAsync();
-	function flattenAsync$1(iterable) {
-	    return (0, flatten_deep_async_1.flattenDeepAsync)(iterable, 1);
-	}
-	flattenAsync.flattenAsync = flattenAsync$1;
-	
-	return flattenAsync;
+toAsyncIterable$1.toAsyncIterable = void 0;
+async function* toAsyncIterable(iterable) {
+    for (const value of iterable) {
+        yield value;
+    }
 }
+toAsyncIterable$1.toAsyncIterable = toAsyncIterable;
 
-var flattenBy$1 = {};
+var transformAsync$1 = {};
 
-flattenBy$1.flattenBy = void 0;
-const types_1$e = es2018$5;
-function flattenBy(iterable, predicate) {
-    return flatten(iterable, 1);
-    function* flatten(iterable, level) {
-        for (const element of iterable) {
-            if (isFiniteIterable(element) && predicate(element, level)) {
-                yield* flatten(element, level + 1);
-            }
-            else {
-                yield element;
-            }
-        }
-    }
-}
-flattenBy$1.flattenBy = flattenBy;
-function isFiniteIterable(val) {
-    return (0, types_1$e.isIterable)(val) && (0, types_1$e.isntChar)(val);
+transformAsync$1.transformAsync = void 0;
+async function* transformAsync(iterable, transformer) {
+    yield* transformer(iterable);
 }
+transformAsync$1.transformAsync = transformAsync;
 
-var flattenDeep = {};
-
-var hasRequiredFlattenDeep;
+var transform$1 = {};
 
-function requireFlattenDeep () {
-	if (hasRequiredFlattenDeep) return flattenDeep;
-	hasRequiredFlattenDeep = 1;
-flattenDeep.flattenDeep = void 0;
-	const flatten_by_1 = flattenBy$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');
-	    return (0, flatten_by_1.flattenBy)(iterable, (_, level) => level <= depth);
-	}
-	flattenDeep.flattenDeep = flattenDeep$1;
-	
-	return flattenDeep;
+transform$1.transform = void 0;
+function* transform(iterable, transformer) {
+    yield* transformer(iterable);
 }
+transform$1.transform = transform;
 
-var flatten = {};
-
-var hasRequiredFlatten;
+var uniqAsync$1 = {};
 
-function requireFlatten () {
-	if (hasRequiredFlatten) return flatten;
-	hasRequiredFlatten = 1;
-flatten.flatten = void 0;
-	const flatten_deep_1 = requireFlattenDeep();
-	function flatten$1(iterable) {
-	    return (0, flatten_deep_1.flattenDeep)(iterable, 1);
-	}
-	flatten.flatten = flatten$1;
-	
-	return flatten;
+uniqAsync$1.uniqAsync = void 0;
+async function* uniqAsync(iterable) {
+    const bucket = new Set();
+    for await (const element of iterable) {
+        if (!bucket.has(element)) {
+            yield element;
+            bucket.add(element);
+        }
+    }
 }
+uniqAsync$1.uniqAsync = uniqAsync;
 
-var mapAsync$1 = {};
+var uniqByAsync$1 = {};
 
-mapAsync$1.mapAsync = void 0;
-const types_1$d = es2018$5;
-function mapAsync(iterable, fn) {
-    if ((0, types_1$d.isAsyncIterable)(iterable)) {
-        return mapAsyncIterable(iterable);
+uniqByAsync$1.uniqByAsync = void 0;
+const types_1$9 = es2018$6;
+function uniqByAsync(iterable, fn) {
+    if ((0, types_1$9.isAsyncIterable)(iterable)) {
+        return uniqByAsyncIterable(iterable);
     }
     else {
-        return mapIterable(iterable);
+        return uniqByIterable(iterable);
     }
-    async function* mapAsyncIterable(iterable) {
+    async function* uniqByAsyncIterable(iterable) {
+        const bucket = new Set();
         let index = 0;
         for await (const element of iterable) {
-            yield await fn(element, index);
+            const result = await fn(element, index);
+            if (!bucket.has(result)) {
+                yield element;
+                bucket.add(result);
+            }
             index++;
         }
     }
-    async function* mapIterable(iterable) {
+    async function* uniqByIterable(iterable) {
+        const bucket = new Set();
         let index = 0;
         for (const element of iterable) {
-            yield await fn(element, index);
+            const result = await fn(element, index);
+            if (!bucket.has(result)) {
+                yield element;
+                bucket.add(result);
+            }
             index++;
         }
     }
 }
-mapAsync$1.mapAsync = mapAsync;
+uniqByAsync$1.uniqByAsync = uniqByAsync;
 
-var map$3 = {};
+var uniqBy$1 = {};
 
-map$3.map = void 0;
-function* map$2(iterable, fn) {
+uniqBy$1.uniqBy = void 0;
+function* uniqBy(iterable, fn) {
+    const bucket = new Set();
     let index = 0;
     for (const element of iterable) {
-        yield fn(element, index);
+        const result = fn(element, index);
+        if (!bucket.has(result)) {
+            yield element;
+            bucket.add(result);
+        }
         index++;
     }
 }
-map$3.map = map$2;
-
-var repeatAsync = {};
-
-var hasRequiredRepeatAsync;
-
-function requireRepeatAsync () {
-	if (hasRequiredRepeatAsync) return repeatAsync;
-	hasRequiredRepeatAsync = 1;
-repeatAsync.repeatAsync = void 0;
-	const go_1 = es2018$6;
-	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');
-	    if (times === Infinity)
-	        warnInfiniteLoop();
-	    return (0, go_1.go)(async function* () {
-	        const cache = [];
-	        if (times > 0) {
-	            for await (const element of iterable) {
-	                yield element;
-	                cache.push(element);
-	            }
-	            times--;
-	        }
-	        while (times > 0) {
-	            yield* cache;
-	            times--;
-	        }
-	    });
-	}
-	repeatAsync.repeatAsync = repeatAsync$1;
-	function warnInfiniteLoop() {
-	    if (isProduction())
-	        return;
-	    console.warn('When iterable has no elements and times is Infinity, repeat() will be in dead loop');
-	}
-	function isProduction() {
-	    return process.env.NODE_ENV === 'production';
-	}
-	
-	return repeatAsync;
-}
-
-var repeat$2 = {};
+uniqBy$1.uniqBy = uniqBy;
 
-var hasRequiredRepeat;
+var uniq$1 = {};
 
-function requireRepeat () {
-	if (hasRequiredRepeat) return repeat$2;
-	hasRequiredRepeat = 1;
-repeat$2.repeat = void 0;
-	const go_1 = es2018$6;
-	const errors_1 = requireEs2018();
-	function repeat(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');
-	    if (times === Infinity)
-	        warnInfiniteLoop();
-	    return (0, go_1.go)(function* () {
-	        const cache = [];
-	        if (times > 0) {
-	            for (const element of iterable) {
-	                yield element;
-	                cache.push(element);
-	            }
-	            times--;
-	        }
-	        while (times > 0) {
-	            yield* cache;
-	            times--;
-	        }
-	    });
-	}
-	repeat$2.repeat = repeat;
-	function warnInfiniteLoop() {
-	    if (isProduction())
-	        return;
-	    console.warn('When iterable has no elements and times is Infinity, repeat() will be in dead loop');
-	}
-	function isProduction() {
-	    return process.env.NODE_ENV === 'production';
-	}
-	
-	return repeat$2;
+uniq$1.uniq = void 0;
+function* uniq(iterable) {
+    const bucket = new Set();
+    for (const element of iterable) {
+        if (!bucket.has(element)) {
+            yield element;
+            bucket.add(element);
+        }
+    }
 }
+uniq$1.uniq = uniq;
 
-var sliceAsync = {};
-
-var hasRequiredSliceAsync;
+var zipAsync$1 = {};
 
-function requireSliceAsync () {
-	if (hasRequiredSliceAsync) return sliceAsync;
-	hasRequiredSliceAsync = 1;
-sliceAsync.sliceAsync = void 0;
-	const go_1 = es2018$6;
-	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');
-	    (0, errors_1.assert)(Number.isInteger(end), 'The parameter end must be an integer');
-	    (0, errors_1.assert)(end >= start, 'The parameter end must be greater than or equal to start');
-	    return (0, go_1.go)(async function* () {
-	        let index = 0;
-	        for await (const element of iterable) {
-	            if (index >= end)
-	                break;
-	            if (index >= start)
-	                yield element;
-	            index++;
-	        }
-	    });
-	}
-	sliceAsync.sliceAsync = sliceAsync$1;
-	
-	return sliceAsync;
-}
-
-var slice = {};
-
-var hasRequiredSlice;
-
-function requireSlice () {
-	if (hasRequiredSlice) return slice;
-	hasRequiredSlice = 1;
-slice.slice = void 0;
-	const go_1 = es2018$6;
-	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');
-	    (0, errors_1.assert)(Number.isInteger(end), 'The parameter end must be an integer');
-	    (0, errors_1.assert)(end >= start, 'The parameter end must be greater than or equal to start');
-	    return (0, go_1.go)(function* () {
-	        let index = 0;
-	        for (const element of iterable) {
-	            if (index >= end)
-	                break;
-	            if (index >= start)
-	                yield element;
-	            index++;
-	        }
-	    });
-	}
-	slice.slice = slice$1;
-	
-	return slice;
+zipAsync$1.zipAsync = void 0;
+const types_1$8 = es2018$6;
+var Kind;
+(function (Kind) {
+    Kind[Kind["Sync"] = 0] = "Sync";
+    Kind[Kind["Async"] = 1] = "Async";
+})(Kind || (Kind = {}));
+function zipAsync(iterable, ...otherIterables) {
+    return zipWithSize$1(iterable, ...otherIterables);
 }
-
-var splitAsync$1 = {};
-
-splitAsync$1.splitAsync = void 0;
-async function* splitAsync(iterable, separator) {
-    let buffer = [];
-    for await (const element of iterable) {
-        if (element === separator) {
-            yield buffer;
-            buffer = [];
+zipAsync$1.zipAsync = zipAsync;
+async function* zipWithSize$1(...iterables) {
+    var _a, _b, _c, _d;
+    const length = iterables.length;
+    const iterators = iterables.map(iterable => {
+        if ((0, types_1$8.isAsyncIterable)(iterable)) {
+            return [Kind.Async, iterable[Symbol.asyncIterator]()];
         }
         else {
-            buffer.push(element);
+            return [Kind.Sync, iterable[Symbol.iterator]()];
         }
-    }
-    yield buffer;
-}
-splitAsync$1.splitAsync = splitAsync;
-
-var splitByAsync$1 = {};
-
-splitByAsync$1.splitByAsync = void 0;
-const types_1$c = es2018$5;
-function splitByAsync(iterable, predicate) {
-    if ((0, types_1$c.isAsyncIterable)(iterable)) {
-        return splitByAsyncIterable(iterable);
-    }
-    else {
-        return splitByIterable(iterable);
-    }
-    async function* splitByIterable(iterable) {
-        let buffer = [];
-        let index = 0;
-        for (const element of iterable) {
-            if (await predicate(element, index)) {
-                yield buffer;
-                buffer = [];
-            }
-            else {
-                buffer.push(element);
+    });
+    const dones = iterators.map(() => false);
+    try {
+        while (true) {
+            const result = new Array(length);
+            for (let i = 0; i < length; i++) {
+                const [kind, iterator] = iterators[i];
+                let temp;
+                if (kind === Kind.Async) {
+                    temp = await iterator.next();
+                }
+                else {
+                    temp = iterator.next();
+                }
+                if (temp.done) {
+                    dones[i] = true;
+                    return;
+                }
+                result[i] = temp.value;
             }
-            index++;
+            yield result;
         }
-        yield buffer;
     }
-    async function* splitByAsyncIterable(iterable) {
-        let buffer = [];
-        let index = 0;
-        for await (const element of iterable) {
-            if (await predicate(element, index)) {
-                yield buffer;
-                buffer = [];
+    finally {
+        const undoneIterators = iterators.filter((_, i) => !dones[i]);
+        for (const [kind, iterator] of undoneIterators) {
+            if (kind === Kind.Async) {
+                await ((_b = (_a = iterator).return) === null || _b === void 0 ? void 0 : _b.call(_a));
             }
             else {
-                buffer.push(element);
+                (_d = (_c = iterator).return) === null || _d === void 0 ? void 0 : _d.call(_c);
             }
-            index++;
         }
-        yield buffer;
     }
 }
-splitByAsync$1.splitByAsync = splitByAsync;
 
-var splitBy$1 = {};
+var zip$5 = {};
 
-splitBy$1.splitBy = void 0;
-function* splitBy(iterable, predicate) {
-    let buffer = [];
-    let index = 0;
-    for (const element of iterable) {
-        if (predicate(element, index)) {
-            yield buffer;
-            buffer = [];
-        }
-        else {
-            buffer.push(element);
-        }
-        index++;
-    }
-    yield buffer;
+zip$5.zip = void 0;
+function zip$4(iterable, ...otherIterables) {
+    return zipWithSize(iterable, ...otherIterables);
 }
-splitBy$1.splitBy = splitBy;
-
-var split$1 = {};
-
-split$1.split = void 0;
-function* split(iterable, separator) {
-    let buffer = [];
-    for (const element of iterable) {
-        if (element === separator) {
-            yield buffer;
-            buffer = [];
-        }
-        else {
-            buffer.push(element);
+zip$5.zip = zip$4;
+function* zipWithSize(...iterables) {
+    const length = iterables.length;
+    const iterators = iterables.map(iterable => iterable[Symbol.iterator]());
+    const dones = iterators.map(() => false);
+    try {
+        while (true) {
+            const result = new Array(length);
+            for (let i = 0; i < length; i++) {
+                const { value, done } = iterators[i].next();
+                if (done) {
+                    dones[i] = true;
+                    return;
+                }
+                result[i] = value;
+            }
+            yield result;
         }
     }
-    yield buffer;
-}
-split$1.split = split;
-
-var takeAsync = {};
-
-var hasRequiredTakeAsync;
-
-function requireTakeAsync () {
-	if (hasRequiredTakeAsync) return takeAsync;
-	hasRequiredTakeAsync = 1;
-takeAsync.takeAsync = void 0;
-	const go_1 = es2018$6;
-	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');
-	    return (0, go_1.go)(async function* () {
-	        if (count === 0)
-	            return;
-	        for await (const element of iterable) {
-	            yield element;
-	            count--;
-	            if (count === 0)
-	                break;
-	        }
-	    });
-	}
-	takeAsync.takeAsync = takeAsync$1;
-	
-	return takeAsync;
+    finally {
+        const undoneIterators = iterators.filter((_, i) => !dones[i]);
+        undoneIterators.forEach(x => { var _a; return (_a = x.return) === null || _a === void 0 ? void 0 : _a.call(x); });
+    }
 }
 
-var takeRightAsync = {};
-
-var hasRequiredTakeRightAsync;
+var hasRequiredMiddleware;
 
-function requireTakeRightAsync () {
-	if (hasRequiredTakeRightAsync) return takeRightAsync;
-	hasRequiredTakeRightAsync = 1;
-takeRightAsync.takeRightAsync = void 0;
-	const go_1 = es2018$6;
-	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');
-	    return (0, go_1.go)(async function* () {
-	        var _a;
-	        const iterator = iterable[Symbol.asyncIterator]();
-	        let done;
-	        try {
-	            const buffer = [];
-	            let value;
-	            while ({ value, done } = await iterator.next(), !done) {
-	                buffer.push(value);
-	                if (buffer.length > count)
-	                    buffer.shift();
-	            }
-	            yield* buffer;
-	        }
-	        finally {
-	            if (!done)
-	                await ((_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator));
-	        }
-	    });
-	}
-	takeRightAsync.takeRightAsync = takeRightAsync$1;
-	
-	return takeRightAsync;
+function requireMiddleware () {
+	if (hasRequiredMiddleware) return middleware;
+	hasRequiredMiddleware = 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(requireChunkAsync(), exports);
+		__exportStar(chunkByAsync$1, exports);
+		__exportStar(chunkBy$1, exports);
+		__exportStar(requireChunk(), exports);
+		__exportStar(concatAsync$1, exports);
+		__exportStar(concat$5, exports);
+		__exportStar(requireDropAsync(), exports);
+		__exportStar(requireDropRightAsync(), exports);
+		__exportStar(requireDropRight(), exports);
+		__exportStar(dropUntilAsync$1, exports);
+		__exportStar(dropUntil$1, exports);
+		__exportStar(requireDrop(), exports);
+		__exportStar(filterAsync$1, exports);
+		__exportStar(filter$3, exports);
+		__exportStar(requireFlattenAsync(), exports);
+		__exportStar(flattenByAsync$1, exports);
+		__exportStar(flattenBy$1, exports);
+		__exportStar(requireFlattenDeepAsync(), exports);
+		__exportStar(requireFlattenDeep(), exports);
+		__exportStar(requireFlatten(), exports);
+		__exportStar(mapAsync$1, exports);
+		__exportStar(map$3, exports);
+		__exportStar(requireRepeatAsync(), exports);
+		__exportStar(requireRepeat(), exports);
+		__exportStar(requireSliceAsync(), exports);
+		__exportStar(requireSlice(), exports);
+		__exportStar(splitAsync$1, exports);
+		__exportStar(splitByAsync$1, exports);
+		__exportStar(splitBy$1, exports);
+		__exportStar(split$1, exports);
+		__exportStar(requireTakeAsync(), exports);
+		__exportStar(requireTakeRightAsync(), exports);
+		__exportStar(requireTakeRight(), exports);
+		__exportStar(takeUntilAsync$1, exports);
+		__exportStar(takeUntil$3, exports);
+		__exportStar(requireTake(), exports);
+		__exportStar(tapAsync$1, exports);
+		__exportStar(tap$3, exports);
+		__exportStar(toAsyncIterable$1, exports);
+		__exportStar(transformAsync$1, exports);
+		__exportStar(transform$1, exports);
+		__exportStar(uniqAsync$1, exports);
+		__exportStar(uniqByAsync$1, exports);
+		__exportStar(uniqBy$1, exports);
+		__exportStar(uniq$1, exports);
+		__exportStar(zipAsync$1, exports);
+		__exportStar(zip$5, exports);
+		
+} (middleware));
+	return middleware;
 }
 
-var takeRight = {};
+var output = {};
 
-var hasRequiredTakeRight;
+var consume$1 = {};
 
-function requireTakeRight () {
-	if (hasRequiredTakeRight) return takeRight;
-	hasRequiredTakeRight = 1;
-takeRight.takeRight = void 0;
-	const go_1 = es2018$6;
-	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');
-	    return (0, go_1.go)(function* () {
-	        var _a;
-	        const iterator = iterable[Symbol.iterator]();
-	        let done;
-	        try {
-	            const buffer = [];
-	            let value;
-	            while ({ value, done } = iterator.next(), !done) {
-	                buffer.push(value);
-	                if (buffer.length > count)
-	                    buffer.shift();
-	            }
-	            yield* buffer;
-	        }
-	        finally {
-	            if (!done)
-	                (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
-	        }
-	    });
-	}
-	takeRight.takeRight = takeRight$1;
-	
-	return takeRight;
+consume$1.consume = void 0;
+function consume(iterable, consumer) {
+    return consumer(iterable);
 }
+consume$1.consume = consume;
 
-var takeUntilAsync$1 = {};
+var eachAsync$1 = {};
 
-takeUntilAsync$1.takeUntilAsync = void 0;
-const types_1$b = es2018$5;
-function takeUntilAsync(iterable, predicate) {
-    if ((0, types_1$b.isAsyncIterable)(iterable)) {
-        return takeUntilAsyncIterable(iterable);
+eachAsync$1.eachAsync = void 0;
+const types_1$7 = es2018$6;
+function eachAsync(iterable, fn) {
+    if ((0, types_1$7.isAsyncIterable)(iterable)) {
+        return eachAsyncIterable(iterable);
     }
     else {
-        return takeUntilIterable(iterable);
+        return eachIterable(iterable);
     }
-    async function* takeUntilAsyncIterable(iterable) {
+    async function eachAsyncIterable(iterable) {
         let index = 0;
         for await (const element of iterable) {
-            if (await predicate(element, index))
-                break;
-            yield element;
+            await fn(element, index);
             index++;
         }
     }
-    async function* takeUntilIterable(iterable) {
+    async function eachIterable(iterable) {
         let index = 0;
         for (const element of iterable) {
-            if (await predicate(element, index))
-                break;
-            yield element;
+            await fn(element, index);
             index++;
         }
     }
 }
-takeUntilAsync$1.takeUntilAsync = takeUntilAsync;
+eachAsync$1.eachAsync = eachAsync;
 
-var takeUntil$3 = {};
+var each$1 = {};
 
-takeUntil$3.takeUntil = void 0;
-function* takeUntil$2(iterable, predicate) {
+each$1.each = void 0;
+function each(iterable, fn) {
     let index = 0;
     for (const element of iterable) {
-        if (predicate(element, index))
-            break;
-        yield element;
+        fn(element, index);
         index++;
     }
 }
-takeUntil$3.takeUntil = takeUntil$2;
-
-var take$2 = {};
-
-var hasRequiredTake;
-
-function requireTake () {
-	if (hasRequiredTake) return take$2;
-	hasRequiredTake = 1;
-take$2.take = void 0;
-	const go_1 = es2018$6;
-	const errors_1 = requireEs2018();
-	function take(iterable, count) {
-	    (0, errors_1.assert)(Number.isInteger(count), 'The parameter count must be an integer');
-	    (0, errors_1.assert)(count >= 0, 'The parameter count must be greater than or equal to 0');
-	    return (0, go_1.go)(function* () {
-	        if (count === 0)
-	            return;
-	        for (const element of iterable) {
-	            yield element;
-	            count--;
-	            if (count === 0)
-	                break;
-	        }
-	    });
-	}
-	take$2.take = take;
-	
-	return take$2;
-}
+each$1.each = each;
 
-var tapAsync$1 = {};
+var everyAsync$1 = {};
 
-tapAsync$1.tapAsync = void 0;
-const types_1$a = es2018$5;
-function tapAsync(iterable, fn) {
-    if ((0, types_1$a.isAsyncIterable)(iterable)) {
-        return tapAsyncIterable(iterable);
+everyAsync$1.everyAsync = void 0;
+const types_1$6 = es2018$6;
+function everyAsync(iterable, predicate) {
+    if ((0, types_1$6.isAsyncIterable)(iterable)) {
+        return everyAsyncIterable(iterable);
     }
     else {
-        return tapIterable(iterable);
+        return everyIterable(iterable);
     }
-    async function* tapIterable(iterable) {
+    async function everyIterable(iterable) {
         let index = 0;
         for (const element of iterable) {
-            await fn(element, index);
-            yield element;
+            if (!await predicate(element, index))
+                return false;
             index++;
         }
+        return true;
     }
-    async function* tapAsyncIterable(iterable) {
+    async function everyAsyncIterable(iterable) {
         let index = 0;
         for await (const element of iterable) {
-            await fn(element, index);
-            yield element;
+            if (!await predicate(element, index))
+                return false;
             index++;
         }
+        return true;
     }
 }
-tapAsync$1.tapAsync = tapAsync;
+everyAsync$1.everyAsync = everyAsync;
 
-var tap$3 = {};
+var every$3 = {};
 
-tap$3.tap = void 0;
-function* tap$2(iterable, fn) {
+every$3.every = void 0;
+function every$2(iterable, predicate) {
     let index = 0;
     for (const element of iterable) {
-        fn(element, index);
-        yield element;
+        if (!predicate(element, index))
+            return false;
         index++;
     }
+    return true;
 }
-tap$3.tap = tap$2;
+every$3.every = every$2;
 
-var toAsyncIterable$1 = {};
+var findAsync$1 = {};
 
-toAsyncIterable$1.toAsyncIterable = void 0;
-async function* toAsyncIterable(iterable) {
-    for (const value of iterable) {
-        yield value;
+findAsync$1.findAsync = void 0;
+const types_1$5 = es2018$6;
+function findAsync(iterable, predicate) {
+    if ((0, types_1$5.isAsyncIterable)(iterable)) {
+        return findAsyncIterable(iterable);
+    }
+    else {
+        return findIterable(iterable);
+    }
+    async function findIterable(iterable) {
+        let index = 0;
+        for (const element of iterable) {
+            if (await predicate(element, index))
+                return element;
+            index++;
+        }
+        return undefined;
+    }
+    async function findAsyncIterable(iterable) {
+        let index = 0;
+        for await (const element of iterable) {
+            if (await predicate(element, index))
+                return element;
+            index++;
+        }
+        return undefined;
     }
 }
-toAsyncIterable$1.toAsyncIterable = toAsyncIterable;
+findAsync$1.findAsync = findAsync;
 
-var transformAsync$1 = {};
+var find$3 = {};
 
-transformAsync$1.transformAsync = void 0;
-async function* transformAsync(iterable, transformer) {
-    yield* transformer(iterable);
+find$3.find = void 0;
+function find$2(iterable, predicate) {
+    let index = 0;
+    for (const element of iterable) {
+        if (predicate(element, index))
+            return element;
+        index++;
+    }
+    return undefined;
 }
-transformAsync$1.transformAsync = transformAsync;
+find$3.find = find$2;
 
-var transform$1 = {};
+var firstAsync$1 = {};
 
-transform$1.transform = void 0;
-function* transform(iterable, transformer) {
-    yield* transformer(iterable);
+firstAsync$1.firstAsync = void 0;
+async function firstAsync(iterable) {
+    for await (const element of iterable) {
+        return element;
+    }
+    return undefined;
 }
-transform$1.transform = transform;
+firstAsync$1.firstAsync = firstAsync;
 
-var uniqAsync$1 = {};
+var first$3 = {};
 
-uniqAsync$1.uniqAsync = void 0;
-async function* uniqAsync(iterable) {
-    const bucket = new Set();
-    for await (const element of iterable) {
-        if (!bucket.has(element)) {
-            yield element;
-            bucket.add(element);
-        }
+first$3.first = void 0;
+function first$2(iterable) {
+    for (const element of iterable) {
+        return element;
     }
+    return undefined;
 }
-uniqAsync$1.uniqAsync = uniqAsync;
+first$3.first = first$2;
 
-var uniqByAsync$1 = {};
+var includesAsync$1 = {};
 
-uniqByAsync$1.uniqByAsync = void 0;
-const types_1$9 = es2018$5;
-function uniqByAsync(iterable, fn) {
-    if ((0, types_1$9.isAsyncIterable)(iterable)) {
-        return uniqByAsyncIterable(iterable);
-    }
-    else {
-        return uniqByIterable(iterable);
-    }
-    async function* uniqByAsyncIterable(iterable) {
-        const bucket = new Set();
-        let index = 0;
-        for await (const element of iterable) {
-            const result = await fn(element, index);
-            if (!bucket.has(result)) {
-                yield element;
-                bucket.add(result);
-            }
-            index++;
-        }
-    }
-    async function* uniqByIterable(iterable) {
-        const bucket = new Set();
-        let index = 0;
-        for (const element of iterable) {
-            const result = await fn(element, index);
-            if (!bucket.has(result)) {
-                yield element;
-                bucket.add(result);
-            }
-            index++;
-        }
+includesAsync$1.includesAsync = void 0;
+async function includesAsync(iterable, value) {
+    for await (const element of iterable) {
+        if (element === value)
+            return true;
     }
+    return false;
 }
-uniqByAsync$1.uniqByAsync = uniqByAsync;
+includesAsync$1.includesAsync = includesAsync;
 
-var uniqBy$1 = {};
+var includes$1 = {};
 
-uniqBy$1.uniqBy = void 0;
-function* uniqBy(iterable, fn) {
-    const bucket = new Set();
-    let index = 0;
+includes$1.includes = void 0;
+function includes(iterable, value) {
     for (const element of iterable) {
-        const result = fn(element, index);
-        if (!bucket.has(result)) {
-            yield element;
-            bucket.add(result);
-        }
-        index++;
+        if (element === value)
+            return true;
     }
+    return false;
 }
-uniqBy$1.uniqBy = uniqBy;
+includes$1.includes = includes;
 
-var uniq$1 = {};
+var matchAsync$1 = {};
 
-uniq$1.uniq = void 0;
-function* uniq(iterable) {
-    const bucket = new Set();
-    for (const element of iterable) {
-        if (!bucket.has(element)) {
-            yield element;
-            bucket.add(element);
-        }
+matchAsync$1.matchAsync = void 0;
+async function matchAsync(iterable, sequence) {
+    const sequenceLength = sequence.length;
+    let matchCount = 0;
+    for await (const element of iterable) {
+        if (element === sequence[matchCount])
+            matchCount++;
+        if (matchCount === sequenceLength)
+            return true;
     }
+    return false;
 }
-uniq$1.uniq = uniq;
+matchAsync$1.matchAsync = matchAsync;
 
-var zipAsync$1 = {};
+var match$1 = {};
 
-zipAsync$1.zipAsync = void 0;
-const types_1$8 = es2018$5;
-var Kind;
-(function (Kind) {
-    Kind[Kind["Sync"] = 0] = "Sync";
-    Kind[Kind["Async"] = 1] = "Async";
-})(Kind || (Kind = {}));
-function zipAsync(iterable, ...otherIterables) {
-    return zipWithSize$1(iterable, ...otherIterables);
-}
-zipAsync$1.zipAsync = zipAsync;
-async function* zipWithSize$1(...iterables) {
-    var _a, _b, _c, _d;
-    const length = iterables.length;
-    const iterators = iterables.map(iterable => {
-        if ((0, types_1$8.isAsyncIterable)(iterable)) {
-            return [Kind.Async, iterable[Symbol.asyncIterator]()];
-        }
-        else {
-            return [Kind.Sync, iterable[Symbol.iterator]()];
-        }
-    });
-    const dones = iterators.map(() => false);
-    try {
-        while (true) {
-            const result = new Array(length);
-            for (let i = 0; i < length; i++) {
-                const [kind, iterator] = iterators[i];
-                let temp;
-                if (kind === Kind.Async) {
-                    temp = await iterator.next();
-                }
-                else {
-                    temp = iterator.next();
-                }
-                if (temp.done) {
-                    dones[i] = true;
-                    return;
-                }
-                result[i] = temp.value;
-            }
-            yield result;
-        }
-    }
-    finally {
-        const undoneIterators = iterators.filter((_, i) => !dones[i]);
-        for (const [kind, iterator] of undoneIterators) {
-            if (kind === Kind.Async) {
-                await ((_b = (_a = iterator).return) === null || _b === void 0 ? void 0 : _b.call(_a));
-            }
-            else {
-                (_d = (_c = iterator).return) === null || _d === void 0 ? void 0 : _d.call(_c);
-            }
-        }
+match$1.match = void 0;
+function match(iterable, sequence) {
+    const sequenceLength = sequence.length;
+    let matchCount = 0;
+    for (const element of iterable) {
+        if (element === sequence[matchCount])
+            matchCount++;
+        if (matchCount === sequenceLength)
+            return true;
     }
+    return false;
 }
+match$1.match = match;
 
-var zip$5 = {};
+var reduceAsync$1 = {};
 
-zip$5.zip = void 0;
-function zip$4(iterable, ...otherIterables) {
-    return zipWithSize(iterable, ...otherIterables);
+reduceAsync$1.reduceAsync = void 0;
+const types_1$4 = es2018$6;
+function reduceAsync(iterable, fn, initialValue) {
+    if ((0, types_1$4.isUndefined)(initialValue)) {
+        return reduceAsyncWithoutInitialValue(iterable, fn);
+    }
+    else {
+        return reduceAsyncWithInitialValue(iterable, fn, initialValue);
+    }
 }
-zip$5.zip = zip$4;
-function* zipWithSize(...iterables) {
-    const length = iterables.length;
-    const iterators = iterables.map(iterable => iterable[Symbol.iterator]());
-    const dones = iterators.map(() => false);
-    try {
-        while (true) {
-            const result = new Array(length);
-            for (let i = 0; i < length; i++) {
-                const { value, done } = iterators[i].next();
-                if (done) {
-                    dones[i] = true;
-                    return;
-                }
-                result[i] = value;
-            }
-            yield result;
+reduceAsync$1.reduceAsync = reduceAsync;
+function reduceAsyncWithInitialValue(iterable, fn, initialValue) {
+    if ((0, types_1$4.isAsyncIterable)(iterable)) {
+        return reduceAsyncIterable(iterable);
+    }
+    else {
+        return reduceIterable(iterable);
+    }
+    async function reduceIterable(iterable) {
+        let result = initialValue, index = 0;
+        for (const currentValue of iterable) {
+            result = await fn(result, currentValue, index++);
         }
+        return result;
     }
-    finally {
-        const undoneIterators = iterators.filter((_, i) => !dones[i]);
-        undoneIterators.forEach(x => { var _a; return (_a = x.return) === null || _a === void 0 ? void 0 : _a.call(x); });
+    async function reduceAsyncIterable(iterable) {
+        let result = initialValue, index = 0;
+        for await (const currentValue of iterable) {
+            result = await fn(result, currentValue, index++);
+        }
+        return result;
     }
 }
-
-var hasRequiredMiddleware;
-
-function requireMiddleware () {
-	if (hasRequiredMiddleware) return middleware;
-	hasRequiredMiddleware = 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(requireChunkAsync(), exports);
-		__exportStar(chunkByAsync$1, exports);
-		__exportStar(chunkBy$1, exports);
-		__exportStar(requireChunk(), exports);
-		__exportStar(concatAsync$1, exports);
-		__exportStar(concat$5, exports);
-		__exportStar(requireDropAsync(), exports);
-		__exportStar(requireDropRightAsync(), exports);
-		__exportStar(requireDropRight(), exports);
-		__exportStar(dropUntilAsync$1, exports);
-		__exportStar(dropUntil$1, exports);
-		__exportStar(requireDrop(), exports);
-		__exportStar(filterAsync$1, exports);
-		__exportStar(filter$3, exports);
-		__exportStar(requireFlattenAsync(), exports);
-		__exportStar(flattenByAsync$1, exports);
-		__exportStar(flattenBy$1, exports);
-		__exportStar(requireFlattenDeepAsync(), exports);
-		__exportStar(requireFlattenDeep(), exports);
-		__exportStar(requireFlatten(), exports);
-		__exportStar(mapAsync$1, exports);
-		__exportStar(map$3, exports);
-		__exportStar(requireRepeatAsync(), exports);
-		__exportStar(requireRepeat(), exports);
-		__exportStar(requireSliceAsync(), exports);
-		__exportStar(requireSlice(), exports);
-		__exportStar(splitAsync$1, exports);
-		__exportStar(splitByAsync$1, exports);
-		__exportStar(splitBy$1, exports);
-		__exportStar(split$1, exports);
-		__exportStar(requireTakeAsync(), exports);
-		__exportStar(requireTakeRightAsync(), exports);
-		__exportStar(requireTakeRight(), exports);
-		__exportStar(takeUntilAsync$1, exports);
-		__exportStar(takeUntil$3, exports);
-		__exportStar(requireTake(), exports);
-		__exportStar(tapAsync$1, exports);
-		__exportStar(tap$3, exports);
-		__exportStar(toAsyncIterable$1, exports);
-		__exportStar(transformAsync$1, exports);
-		__exportStar(transform$1, exports);
-		__exportStar(uniqAsync$1, exports);
-		__exportStar(uniqByAsync$1, exports);
-		__exportStar(uniqBy$1, exports);
-		__exportStar(uniq$1, exports);
-		__exportStar(zipAsync$1, exports);
-		__exportStar(zip$5, exports);
-		
-} (middleware));
-	return middleware;
-}
-
-var output = {};
-
-var consume$1 = {};
-
-consume$1.consume = void 0;
-function consume(iterable, consumer) {
-    return consumer(iterable);
-}
-consume$1.consume = consume;
-
-var eachAsync$1 = {};
-
-eachAsync$1.eachAsync = void 0;
-const types_1$7 = es2018$5;
-function eachAsync(iterable, fn) {
-    if ((0, types_1$7.isAsyncIterable)(iterable)) {
-        return eachAsyncIterable(iterable);
+function reduceAsyncWithoutInitialValue(iterable, fn) {
+    if ((0, types_1$4.isAsyncIterable)(iterable)) {
+        return reduceAsyncIterable(iterable);
     }
     else {
-        return eachIterable(iterable);
+        return reduceIterable(iterable);
     }
-    async function eachAsyncIterable(iterable) {
-        let index = 0;
-        for await (const element of iterable) {
-            await fn(element, index);
-            index++;
+    async function reduceAsyncIterable(iterable) {
+        var _a;
+        const iterator = iterable[Symbol.asyncIterator]();
+        let done;
+        try {
+            let result = await readInitialValue(iterator);
+            let index = 1;
+            let value;
+            while ({ value, done } = await iterator.next(), !done) {
+                result = await fn(result, value, index++);
+            }
+            return result;
         }
-    }
-    async function eachIterable(iterable) {
-        let index = 0;
-        for (const element of iterable) {
-            await fn(element, index);
-            index++;
+        finally {
+            if (!done)
+                await ((_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator));
+        }
+        async function readInitialValue(iterator) {
+            const result = await iterator.next();
+            if (result.done) {
+                done = true;
+                throw new Error('Reduce of empty iterable with no initial value');
+            }
+            return result.value;
         }
     }
-}
-eachAsync$1.eachAsync = eachAsync;
-
-var each$1 = {};
-
-each$1.each = void 0;
-function each(iterable, fn) {
-    let index = 0;
-    for (const element of iterable) {
-        fn(element, index);
-        index++;
+    async function reduceIterable(iterable) {
+        var _a;
+        const iterator = iterable[Symbol.iterator]();
+        let done;
+        try {
+            let result = readInitialValue(iterator);
+            let index = 1;
+            let value;
+            while ({ value, done } = iterator.next(), !done) {
+                result = await fn(result, value, index++);
+            }
+            return result;
+        }
+        finally {
+            if (!done)
+                (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
+        }
+        function readInitialValue(iterator) {
+            const result = iterator.next();
+            if (result.done) {
+                done = true;
+                throw new Error('Reduce of empty iterable with no initial value');
+            }
+            return result.value;
+        }
     }
 }
-each$1.each = each;
 
-var everyAsync$1 = {};
+var reduce$3 = {};
 
-everyAsync$1.everyAsync = void 0;
-const types_1$6 = es2018$5;
-function everyAsync(iterable, predicate) {
-    if ((0, types_1$6.isAsyncIterable)(iterable)) {
-        return everyAsyncIterable(iterable);
+reduce$3.reduce = void 0;
+const types_1$3 = es2018$6;
+function reduce$2(iterable, fn, initialValue) {
+    if ((0, types_1$3.isUndefined)(initialValue)) {
+        return reduceWithoutInitialValue(iterable, fn);
     }
     else {
-        return everyIterable(iterable);
+        return reduceWithInitialValue(iterable, fn, initialValue);
     }
-    async function everyIterable(iterable) {
-        let index = 0;
-        for (const element of iterable) {
-            if (!await predicate(element, index))
-                return false;
-            index++;
-        }
-        return true;
+}
+reduce$3.reduce = reduce$2;
+function reduceWithInitialValue(iterable, fn, initialValue) {
+    let result = initialValue, index = 0;
+    for (const currentValue of iterable) {
+        result = fn(result, currentValue, index++);
     }
-    async function everyAsyncIterable(iterable) {
-        let index = 0;
-        for await (const element of iterable) {
-            if (!await predicate(element, index))
-                return false;
-            index++;
+    return result;
+}
+function reduceWithoutInitialValue(iterable, fn) {
+    var _a;
+    const iterator = iterable[Symbol.iterator]();
+    let done;
+    try {
+        let result = readInitialValue(iterator);
+        let index = 1;
+        let value;
+        while ({ value, done } = iterator.next(), !done) {
+            result = fn(result, value, index++);
         }
-        return true;
+        return result;
     }
-}
-everyAsync$1.everyAsync = everyAsync;
-
-var every$3 = {};
-
-every$3.every = void 0;
-function every$2(iterable, predicate) {
-    let index = 0;
-    for (const element of iterable) {
-        if (!predicate(element, index))
-            return false;
-        index++;
+    finally {
+        if (!done)
+            (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
+    }
+    function readInitialValue(iterator) {
+        const result = iterator.next();
+        if (result.done) {
+            done = true;
+            throw new Error('Reduce of empty iterable with no initial value');
+        }
+        return result.value;
     }
-    return true;
 }
-every$3.every = every$2;
 
-var findAsync$1 = {};
+var someAsync$1 = {};
 
-findAsync$1.findAsync = void 0;
-const types_1$5 = es2018$5;
-function findAsync(iterable, predicate) {
-    if ((0, types_1$5.isAsyncIterable)(iterable)) {
-        return findAsyncIterable(iterable);
+someAsync$1.someAsync = void 0;
+const types_1$2 = es2018$6;
+function someAsync(iterable, predicate) {
+    if ((0, types_1$2.isAsyncIterable)(iterable)) {
+        return someAsyncIterable(iterable);
     }
     else {
-        return findIterable(iterable);
+        return someIterable(iterable);
     }
-    async function findIterable(iterable) {
+    async function someIterable(iterable) {
         let index = 0;
         for (const element of iterable) {
             if (await predicate(element, index))
-                return element;
+                return true;
             index++;
         }
-        return undefined;
+        return false;
     }
-    async function findAsyncIterable(iterable) {
+    async function someAsyncIterable(iterable) {
         let index = 0;
         for await (const element of iterable) {
             if (await predicate(element, index))
-                return element;
+                return true;
             index++;
         }
-        return undefined;
+        return false;
     }
 }
-findAsync$1.findAsync = findAsync;
+someAsync$1.someAsync = someAsync;
 
-var find$3 = {};
+var some$1 = {};
 
-find$3.find = void 0;
-function find$2(iterable, predicate) {
+some$1.some = void 0;
+function some(iterable, predicate) {
     let index = 0;
     for (const element of iterable) {
         if (predicate(element, index))
-            return element;
-        index++;
-    }
-    return undefined;
-}
-find$3.find = find$2;
-
-var firstAsync$1 = {};
-
-firstAsync$1.firstAsync = void 0;
-async function firstAsync(iterable) {
-    for await (const element of iterable) {
-        return element;
-    }
-    return undefined;
-}
-firstAsync$1.firstAsync = firstAsync;
-
-var first$3 = {};
-
-first$3.first = void 0;
-function first$2(iterable) {
-    for (const element of iterable) {
-        return element;
-    }
-    return undefined;
-}
-first$3.first = first$2;
-
-var includesAsync$1 = {};
-
-includesAsync$1.includesAsync = void 0;
-async function includesAsync(iterable, value) {
-    for await (const element of iterable) {
-        if (element === value)
-            return true;
-    }
-    return false;
-}
-includesAsync$1.includesAsync = includesAsync;
-
-var includes$1 = {};
-
-includes$1.includes = void 0;
-function includes(iterable, value) {
-    for (const element of iterable) {
-        if (element === value)
-            return true;
-    }
-    return false;
-}
-includes$1.includes = includes;
-
-var matchAsync$1 = {};
-
-matchAsync$1.matchAsync = void 0;
-async function matchAsync(iterable, sequence) {
-    const sequenceLength = sequence.length;
-    let matchCount = 0;
-    for await (const element of iterable) {
-        if (element === sequence[matchCount])
-            matchCount++;
-        if (matchCount === sequenceLength)
-            return true;
-    }
-    return false;
-}
-matchAsync$1.matchAsync = matchAsync;
-
-var match$1 = {};
-
-match$1.match = void 0;
-function match(iterable, sequence) {
-    const sequenceLength = sequence.length;
-    let matchCount = 0;
-    for (const element of iterable) {
-        if (element === sequence[matchCount])
-            matchCount++;
-        if (matchCount === sequenceLength)
             return true;
+        index++;
     }
     return false;
 }
-match$1.match = match;
+some$1.some = some;
 
-var reduceAsync$1 = {};
+var lastAsync$1 = {};
 
-reduceAsync$1.reduceAsync = void 0;
-const types_1$4 = es2018$5;
-function reduceAsync(iterable, fn, initialValue) {
-    if ((0, types_1$4.isUndefined)(initialValue)) {
-        return reduceAsyncWithoutInitialValue(iterable, fn);
-    }
-    else {
-        return reduceAsyncWithInitialValue(iterable, fn, initialValue);
-    }
-}
-reduceAsync$1.reduceAsync = reduceAsync;
-function reduceAsyncWithInitialValue(iterable, fn, initialValue) {
-    if ((0, types_1$4.isAsyncIterable)(iterable)) {
-        return reduceAsyncIterable(iterable);
-    }
-    else {
-        return reduceIterable(iterable);
-    }
-    async function reduceIterable(iterable) {
-        let result = initialValue, index = 0;
-        for (const currentValue of iterable) {
-            result = await fn(result, currentValue, index++);
-        }
-        return result;
-    }
-    async function reduceAsyncIterable(iterable) {
-        let result = initialValue, index = 0;
-        for await (const currentValue of iterable) {
-            result = await fn(result, currentValue, index++);
+lastAsync$1.lastAsync = void 0;
+async function lastAsync(iterable) {
+    var _a;
+    const iterator = iterable[Symbol.asyncIterator]();
+    let done;
+    try {
+        let value;
+        let result;
+        while ({ value, done } = await iterator.next(), !done) {
+            result = value;
         }
         return result;
     }
-}
-function reduceAsyncWithoutInitialValue(iterable, fn) {
-    if ((0, types_1$4.isAsyncIterable)(iterable)) {
-        return reduceAsyncIterable(iterable);
-    }
-    else {
-        return reduceIterable(iterable);
-    }
-    async function reduceAsyncIterable(iterable) {
-        var _a;
-        const iterator = iterable[Symbol.asyncIterator]();
-        let done;
-        try {
-            let result = await readInitialValue(iterator);
-            let index = 1;
-            let value;
-            while ({ value, done } = await iterator.next(), !done) {
-                result = await fn(result, value, index++);
-            }
-            return result;
-        }
-        finally {
-            if (!done)
-                await ((_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator));
-        }
-        async function readInitialValue(iterator) {
-            const result = await iterator.next();
-            if (result.done) {
-                done = true;
-                throw new Error('Reduce of empty iterable with no initial value');
-            }
-            return result.value;
-        }
-    }
-    async function reduceIterable(iterable) {
-        var _a;
-        const iterator = iterable[Symbol.iterator]();
-        let done;
-        try {
-            let result = readInitialValue(iterator);
-            let index = 1;
-            let value;
-            while ({ value, done } = iterator.next(), !done) {
-                result = await fn(result, value, index++);
-            }
-            return result;
-        }
-        finally {
-            if (!done)
-                (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
-        }
-        function readInitialValue(iterator) {
-            const result = iterator.next();
-            if (result.done) {
-                done = true;
-                throw new Error('Reduce of empty iterable with no initial value');
-            }
-            return result.value;
-        }
+    finally {
+        if (!done)
+            await ((_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator));
     }
 }
+lastAsync$1.lastAsync = lastAsync;
 
-var reduce$3 = {};
+var last$4 = {};
 
-reduce$3.reduce = void 0;
-const types_1$3 = es2018$5;
-function reduce$2(iterable, fn, initialValue) {
-    if ((0, types_1$3.isUndefined)(initialValue)) {
-        return reduceWithoutInitialValue(iterable, fn);
-    }
-    else {
-        return reduceWithInitialValue(iterable, fn, initialValue);
-    }
-}
-reduce$3.reduce = reduce$2;
-function reduceWithInitialValue(iterable, fn, initialValue) {
-    let result = initialValue, index = 0;
-    for (const currentValue of iterable) {
-        result = fn(result, currentValue, index++);
-    }
-    return result;
-}
-function reduceWithoutInitialValue(iterable, fn) {
+last$4.last = void 0;
+function last$3(iterable) {
     var _a;
     const iterator = iterable[Symbol.iterator]();
     let done;
     try {
-        let result = readInitialValue(iterator);
-        let index = 1;
         let value;
+        let result;
         while ({ value, done } = iterator.next(), !done) {
-            result = fn(result, value, index++);
+            result = value;
         }
         return result;
     }
@@ -5269,177 +5003,486 @@ function reduceWithoutInitialValue(iterable, fn) {
         if (!done)
             (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
     }
-    function readInitialValue(iterator) {
-        const result = iterator.next();
-        if (result.done) {
-            done = true;
-            throw new Error('Reduce of empty iterable with no initial value');
-        }
-        return result.value;
-    }
 }
+last$4.last = last$3;
 
-var someAsync$1 = {};
+var toArrayAsync$1 = {};
 
-someAsync$1.someAsync = void 0;
-const types_1$2 = es2018$5;
-function someAsync(iterable, predicate) {
-    if ((0, types_1$2.isAsyncIterable)(iterable)) {
-        return someAsyncIterable(iterable);
-    }
-    else {
-        return someIterable(iterable);
-    }
-    async function someIterable(iterable) {
-        let index = 0;
-        for (const element of iterable) {
-            if (await predicate(element, index))
-                return true;
-            index++;
-        }
-        return false;
-    }
-    async function someAsyncIterable(iterable) {
-        let index = 0;
+toArrayAsync$1.toArrayAsync = void 0;
+const consume_1$3 = consume$1;
+function toArrayAsync(iterable) {
+    return (0, consume_1$3.consume)(iterable, async (iterable) => {
+        const result = [];
         for await (const element of iterable) {
-            if (await predicate(element, index))
-                return true;
-            index++;
+            result.push(element);
         }
-        return false;
-    }
+        return result;
+    });
 }
-someAsync$1.someAsync = someAsync;
+toArrayAsync$1.toArrayAsync = toArrayAsync;
 
-var some$1 = {};
+var toArray$3 = {};
 
-some$1.some = void 0;
-function some(iterable, predicate) {
-    let index = 0;
-    for (const element of iterable) {
-        if (predicate(element, index))
-            return true;
-        index++;
-    }
-    return false;
+toArray$3.toArray = void 0;
+const consume_1$2 = consume$1;
+function toArray$2(iterable) {
+    return (0, consume_1$2.consume)(iterable, iterable => Array.from(iterable));
 }
-some$1.some = some;
+toArray$3.toArray = toArray$2;
 
-var lastAsync$1 = {};
+var toSetAsync$1 = {};
 
-lastAsync$1.lastAsync = void 0;
-async function lastAsync(iterable) {
-    var _a;
-    const iterator = iterable[Symbol.asyncIterator]();
-    let done;
-    try {
-        let value;
-        let result;
-        while ({ value, done } = await iterator.next(), !done) {
-            result = value;
+toSetAsync$1.toSetAsync = void 0;
+const consume_1$1 = consume$1;
+function toSetAsync(iterable) {
+    return (0, consume_1$1.consume)(iterable, async (iterable) => {
+        const result = new Set();
+        for await (const element of iterable) {
+            result.add(element);
         }
         return result;
+    });
+}
+toSetAsync$1.toSetAsync = toSetAsync;
+
+var toSet$1 = {};
+
+toSet$1.toSet = void 0;
+const consume_1 = consume$1;
+function toSet(iterable) {
+    return (0, consume_1.consume)(iterable, iterable => new Set(iterable));
+}
+toSet$1.toSet = toSet;
+
+var count$3 = {};
+
+count$3.count = void 0;
+function count$2(iterable) {
+    let count = 0;
+    for (const _ of iterable) {
+        count++;
     }
-    finally {
-        if (!done)
-            await ((_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator));
+    return count;
+}
+count$3.count = count$2;
+
+var countAsync$1 = {};
+
+countAsync$1.countAsync = void 0;
+async function countAsync(iterable) {
+    let count = 0;
+    for await (const _ of iterable) {
+        count++;
     }
+    return count;
+}
+countAsync$1.countAsync = countAsync;
+
+(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(consume$1, exports);
+	__exportStar(eachAsync$1, exports);
+	__exportStar(each$1, exports);
+	__exportStar(everyAsync$1, exports);
+	__exportStar(every$3, exports);
+	__exportStar(findAsync$1, exports);
+	__exportStar(find$3, exports);
+	__exportStar(firstAsync$1, exports);
+	__exportStar(first$3, exports);
+	__exportStar(includesAsync$1, exports);
+	__exportStar(includes$1, exports);
+	__exportStar(matchAsync$1, exports);
+	__exportStar(match$1, exports);
+	__exportStar(reduceAsync$1, exports);
+	__exportStar(reduce$3, exports);
+	__exportStar(someAsync$1, exports);
+	__exportStar(some$1, exports);
+	__exportStar(lastAsync$1, exports);
+	__exportStar(last$4, exports);
+	__exportStar(toArrayAsync$1, exports);
+	__exportStar(toArray$3, exports);
+	__exportStar(toSetAsync$1, exports);
+	__exportStar(toSet$1, exports);
+	__exportStar(count$3, exports);
+	__exportStar(countAsync$1, exports);
+	
+} (output));
+
+var hasRequiredEs2018$1;
+
+function requireEs2018$1 () {
+	if (hasRequiredEs2018$1) return es2018$8;
+	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(requireMiddleware(), exports);
+		__exportStar(output, exports);
+		
+} (es2018$8));
+	return es2018$8;
+}
+
+var getErrorNames$1 = {};
+
+var es2018$5 = {};
+
+var array$1 = {};
+
+array$1.isntEmptyArray = array$1.isEmptyArray = array$1.isntArray = array$1.isArray = void 0;
+function isArray$4(val) {
+    return Array.isArray(val);
+}
+array$1.isArray = isArray$4;
+function isntArray$1(val) {
+    return !isArray$4(val);
+}
+array$1.isntArray = isntArray$1;
+function isEmptyArray$1(val) {
+    return val.length === 0;
+}
+array$1.isEmptyArray = isEmptyArray$1;
+function isntEmptyArray$1(val) {
+    return val.length !== 0;
+}
+array$1.isntEmptyArray = isntEmptyArray$1;
+
+var asyncIterable$1 = {};
+
+var _null$1 = {};
+
+_null$1.isntNull = _null$1.isNull = void 0;
+function isNull$1(val) {
+    return val === null;
+}
+_null$1.isNull = isNull$1;
+function isntNull$1(val) {
+    return !isNull$1(val);
+}
+_null$1.isntNull = isntNull$1;
+
+var _undefined$1 = {};
+
+_undefined$1.isntUndefined = _undefined$1.isUndefined = void 0;
+function isUndefined$1(val) {
+    return val === undefined;
+}
+_undefined$1.isUndefined = isUndefined$1;
+function isntUndefined$1(val) {
+    return !isUndefined$1(val);
+}
+_undefined$1.isntUndefined = isntUndefined$1;
+
+var _function$1 = {};
+
+_function$1.isntFunction = _function$1.isFunction = void 0;
+function isFunction$3(val) {
+    return typeof val === 'function';
+}
+_function$1.isFunction = isFunction$3;
+function isntFunction$1(val) {
+    return !isFunction$3(val);
+}
+_function$1.isntFunction = isntFunction$1;
+
+asyncIterable$1.isntAsyncIterable = asyncIterable$1.isAsyncIterable = void 0;
+const null_1$5 = _null$1;
+const undefined_1$3 = _undefined$1;
+const function_1$5 = _function$1;
+function isAsyncIterable$3(val) {
+    return (0, null_1$5.isntNull)(val)
+        && (0, undefined_1$3.isntUndefined)(val)
+        && (0, function_1$5.isFunction)(val[Symbol.asyncIterator]);
+}
+asyncIterable$1.isAsyncIterable = isAsyncIterable$3;
+function isntAsyncIterable$1(val) {
+    return !isAsyncIterable$3(val);
+}
+asyncIterable$1.isntAsyncIterable = isntAsyncIterable$1;
+
+var bigint$1 = {};
+
+bigint$1.isntBigInt = bigint$1.isBigInt = void 0;
+function isBigInt$1(val) {
+    return typeof val === 'bigint';
+}
+bigint$1.isBigInt = isBigInt$1;
+function isntBigInt$1(val) {
+    return !isBigInt$1(val);
+}
+bigint$1.isntBigInt = isntBigInt$1;
+
+var boolean$1 = {};
+
+boolean$1.isntBoolean = boolean$1.isBoolean = void 0;
+function isBoolean$1(val) {
+    return typeof val === 'boolean';
+}
+boolean$1.isBoolean = isBoolean$1;
+function isntBoolean$1(val) {
+    return !isBoolean$1(val);
+}
+boolean$1.isntBoolean = isntBoolean$1;
+
+var char$1 = {};
+
+var string$1 = {};
+
+string$1.isntString = string$1.isString = void 0;
+function isString$1(val) {
+    return typeof val === 'string';
+}
+string$1.isString = isString$1;
+function isntString$1(val) {
+    return !isString$1(val);
+}
+string$1.isntString = isntString$1;
+
+char$1.isntChar = char$1.isChar = void 0;
+const string_1$3 = string$1;
+function isChar$1(val) {
+    return (0, string_1$3.isString)(val)
+        && val.length === 1;
+}
+char$1.isChar = isChar$1;
+function isntChar$1(val) {
+    return !isChar$1(val);
+}
+char$1.isntChar = isntChar$1;
+
+var date$1 = {};
+
+date$1.isntDate = date$1.isDate = void 0;
+function isDate$2(val) {
+    return val instanceof Date;
+}
+date$1.isDate = isDate$2;
+function isntDate$1(val) {
+    return !isDate$2(val);
+}
+date$1.isntDate = isntDate$1;
+
+var _enum$1 = {};
+
+_enum$1.inEnum = void 0;
+function inEnum$1(val, _enum) {
+    return Object.values(_enum).includes(val);
+}
+_enum$1.inEnum = inEnum$1;
+
+var error$1 = {};
+
+error$1.isntError = error$1.isError = void 0;
+function isError$1(val) {
+    return val instanceof Error;
+}
+error$1.isError = isError$1;
+function isntError$1(val) {
+    return !isError$1(val);
+}
+error$1.isntError = isntError$1;
+
+var falsy$1 = {};
+
+falsy$1.isntFalsy = falsy$1.isFalsy = void 0;
+function isFalsy$1(val) {
+    return !val;
+}
+falsy$1.isFalsy = isFalsy$1;
+function isntFalsy$1(val) {
+    return !isFalsy$1(val);
+}
+falsy$1.isntFalsy = isntFalsy$1;
+
+var iterable$1 = {};
+
+iterable$1.isntIterable = iterable$1.isIterable = void 0;
+const null_1$4 = _null$1;
+const undefined_1$2 = _undefined$1;
+const function_1$4 = _function$1;
+function isIterable$3(val) {
+    return (0, null_1$4.isntNull)(val)
+        && (0, undefined_1$2.isntUndefined)(val)
+        && (0, function_1$4.isFunction)(val[Symbol.iterator]);
+}
+iterable$1.isIterable = isIterable$3;
+function isntIterable$1(val) {
+    return !isIterable$3(val);
+}
+iterable$1.isntIterable = isntIterable$1;
+
+var json$1 = {};
+
+var number$1 = {};
+
+number$1.isntNaN = number$1.isNaN = number$1.isNegativeInfinity = number$1.isPositiveInfinity = number$1.isFinite = number$1.isntNumber = number$1.isNumber = void 0;
+function isNumber$1(val) {
+    return typeof val === 'number';
+}
+number$1.isNumber = isNumber$1;
+function isntNumber$1(val) {
+    return !isNumber$1(val);
+}
+number$1.isntNumber = isntNumber$1;
+function isFinite$1(val) {
+    return Number.isFinite(val);
+}
+number$1.isFinite = isFinite$1;
+function isPositiveInfinity$1(val) {
+    return val === Infinity;
+}
+number$1.isPositiveInfinity = isPositiveInfinity$1;
+function isNegativeInfinity$1(val) {
+    return val === -Infinity;
+}
+number$1.isNegativeInfinity = isNegativeInfinity$1;
+function isNaN$2(val) {
+    return Number.isNaN(val);
+}
+number$1.isNaN = isNaN$2;
+function isntNaN$1(val) {
+    return !isNaN$2(val);
+}
+number$1.isntNaN = isntNaN$1;
+
+var object$1 = {};
+
+var __importDefault$1 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};object$1.isntEmptyObject = object$1.isEmptyObject = object$1.isntPlainObject = object$1.isPlainObject = object$1.isntObject = object$1.isObject = void 0;
+const isPlainObject_1$1 = __importDefault$1(isPlainObject_1$3);
+function isObject$1(val) {
+    return val !== null
+        && typeof val === 'object';
+}
+object$1.isObject = isObject$1;
+function isntObject$1(val) {
+    return !isObject$1(val);
+}
+object$1.isntObject = isntObject$1;
+function isPlainObject$1(val) {
+    return (0, isPlainObject_1$1.default)(val);
+}
+object$1.isPlainObject = isPlainObject$1;
+function isntPlainObject$1(val) {
+    return !isPlainObject$1(val);
+}
+object$1.isntPlainObject = isntPlainObject$1;
+function isEmptyObject$1(val) {
+    return Object.keys(val).length === 0;
+}
+object$1.isEmptyObject = isEmptyObject$1;
+function isntEmptyObject$1(val) {
+    return Object.keys(val).length !== 0;
 }
-lastAsync$1.lastAsync = lastAsync;
-
-var last$4 = {};
+object$1.isntEmptyObject = isntEmptyObject$1;
 
-last$4.last = void 0;
-function last$3(iterable) {
-    var _a;
-    const iterator = iterable[Symbol.iterator]();
-    let done;
+json$1.isntJsonable = json$1.isJsonable = json$1.isntJson = json$1.isJson = void 0;
+const null_1$3 = _null$1;
+const boolean_1$1 = boolean$1;
+const string_1$2 = string$1;
+const number_1$1 = number$1;
+const array_1$1 = array$1;
+const object_1$3 = object$1;
+function isJson$1(val) {
+    return (0, null_1$3.isNull)(val)
+        || (0, boolean_1$1.isBoolean)(val)
+        || (0, string_1$2.isString)(val)
+        || (0, number_1$1.isNumber)(val)
+        || ((0, array_1$1.isArray)(val) && val.every(isJson$1))
+        || ((0, object_1$3.isPlainObject)(val) && Object.values(val).every(isJson$1));
+}
+json$1.isJson = isJson$1;
+function isntJson$1(val) {
+    return !isJson$1(val);
+}
+json$1.isntJson = isntJson$1;
+function isJsonable$1(val) {
     try {
-        let value;
-        let result;
-        while ({ value, done } = iterator.next(), !done) {
-            result = value;
-        }
-        return result;
+        JSON.stringify(val);
+        return true;
     }
-    finally {
-        if (!done)
-            (_a = iterator.return) === null || _a === void 0 ? void 0 : _a.call(iterator);
+    catch (_a) {
+        return false;
     }
 }
-last$4.last = last$3;
-
-var toArrayAsync$1 = {};
-
-toArrayAsync$1.toArrayAsync = void 0;
-const consume_1$3 = consume$1;
-function toArrayAsync(iterable) {
-    return (0, consume_1$3.consume)(iterable, async (iterable) => {
-        const result = [];
-        for await (const element of iterable) {
-            result.push(element);
-        }
-        return result;
-    });
+json$1.isJsonable = isJsonable$1;
+function isntJsonable$1(val) {
+    return !isntJsonable$1();
 }
-toArrayAsync$1.toArrayAsync = toArrayAsync;
+json$1.isntJsonable = isntJsonable$1;
 
-var toArray$3 = {};
+var promise$1 = {};
 
-toArray$3.toArray = void 0;
-const consume_1$2 = consume$1;
-function toArray$2(iterable) {
-    return (0, consume_1$2.consume)(iterable, iterable => Array.from(iterable));
+promise$1.isPromiseLike = promise$1.isntPromiseLike = promise$1.isntPromise = promise$1.isPromise = void 0;
+const object_1$2 = object$1;
+const function_1$3 = _function$1;
+function isPromise$3(val) {
+    return val instanceof Promise;
 }
-toArray$3.toArray = toArray$2;
-
-var toSetAsync$1 = {};
-
-toSetAsync$1.toSetAsync = void 0;
-const consume_1$1 = consume$1;
-function toSetAsync(iterable) {
-    return (0, consume_1$1.consume)(iterable, async (iterable) => {
-        const result = new Set();
-        for await (const element of iterable) {
-            result.add(element);
-        }
-        return result;
-    });
+promise$1.isPromise = isPromise$3;
+function isntPromise$1(val) {
+    return !isPromise$3(val);
 }
-toSetAsync$1.toSetAsync = toSetAsync;
-
-var toSet$1 = {};
-
-toSet$1.toSet = void 0;
-const consume_1 = consume$1;
-function toSet(iterable) {
-    return (0, consume_1.consume)(iterable, iterable => new Set(iterable));
+promise$1.isntPromise = isntPromise$1;
+function isntPromiseLike$1(val) {
+    return !isPromiseLike$1(val);
 }
-toSet$1.toSet = toSet;
+promise$1.isntPromiseLike = isntPromiseLike$1;
+function isPromiseLike$1(val) {
+    return (0, object_1$2.isObject)(val)
+        && (0, function_1$3.isFunction)(val.then);
+}
+promise$1.isPromiseLike = isPromiseLike$1;
 
-var count$3 = {};
+var url$1 = {};
 
-count$3.count = void 0;
-function count$2(iterable) {
-    let count = 0;
-    for (const _ of iterable) {
-        count++;
+url$1.isAbsoluteURL = void 0;
+function isAbsoluteURL$1(str) {
+    try {
+        new URL(str);
+        return true;
+    }
+    catch (_a) {
+        return false;
     }
-    return count;
 }
-count$3.count = count$2;
+url$1.isAbsoluteURL = isAbsoluteURL$1;
 
-var countAsync$1 = {};
+var regexp = {};
 
-countAsync$1.countAsync = void 0;
-async function countAsync(iterable) {
-    let count = 0;
-    for await (const _ of iterable) {
-        count++;
-    }
-    return count;
+regexp.isntRegExp = regexp.isRegExp = void 0;
+function isRegExp(val) {
+    return val instanceof RegExp;
 }
-countAsync$1.countAsync = countAsync;
+regexp.isRegExp = isRegExp;
+function isntRegExp(val) {
+    return !isRegExp(val);
+}
+regexp.isntRegExp = isntRegExp;
 
 (function (exports) {
 	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -5455,61 +5498,28 @@ countAsync$1.countAsync = countAsync;
 	}));
 	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(consume$1, exports);
-	__exportStar(eachAsync$1, exports);
-	__exportStar(each$1, exports);
-	__exportStar(everyAsync$1, exports);
-	__exportStar(every$3, exports);
-	__exportStar(findAsync$1, exports);
-	__exportStar(find$3, exports);
-	__exportStar(firstAsync$1, exports);
-	__exportStar(first$3, exports);
-	__exportStar(includesAsync$1, exports);
-	__exportStar(includes$1, exports);
-	__exportStar(matchAsync$1, exports);
-	__exportStar(match$1, exports);
-	__exportStar(reduceAsync$1, exports);
-	__exportStar(reduce$3, exports);
-	__exportStar(someAsync$1, exports);
-	__exportStar(some$1, exports);
-	__exportStar(lastAsync$1, exports);
-	__exportStar(last$4, exports);
-	__exportStar(toArrayAsync$1, exports);
-	__exportStar(toArray$3, exports);
-	__exportStar(toSetAsync$1, exports);
-	__exportStar(toSet$1, exports);
-	__exportStar(count$3, exports);
-	__exportStar(countAsync$1, exports);
+	};__exportStar(array$1, exports);
+	__exportStar(asyncIterable$1, exports);
+	__exportStar(bigint$1, exports);
+	__exportStar(boolean$1, exports);
+	__exportStar(char$1, exports);
+	__exportStar(date$1, exports);
+	__exportStar(_enum$1, exports);
+	__exportStar(error$1, exports);
+	__exportStar(falsy$1, exports);
+	__exportStar(_function$1, exports);
+	__exportStar(iterable$1, exports);
+	__exportStar(json$1, exports);
+	__exportStar(_null$1, exports);
+	__exportStar(number$1, exports);
+	__exportStar(object$1, exports);
+	__exportStar(promise$1, exports);
+	__exportStar(string$1, exports);
+	__exportStar(_undefined$1, exports);
+	__exportStar(url$1, exports);
+	__exportStar(regexp, exports);
 	
-} (output));
-
-var hasRequiredEs2018$1;
-
-function requireEs2018$1 () {
-	if (hasRequiredEs2018$1) return es2018$7;
-	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(requireMiddleware(), exports);
-		__exportStar(output, exports);
-		
-} (es2018$7));
-	return es2018$7;
-}
-
-var getErrorNames$1 = {};
+} (es2018$5));
 
 var traverseErrorPrototypeChain$1 = {};
 
@@ -5525,7 +5535,7 @@ function* traverseErrorPrototypeChain(err) {
 traverseErrorPrototypeChain$1.traverseErrorPrototypeChain = traverseErrorPrototypeChain;
 
 getErrorNames$1.getErrorNames = void 0;
-const types_1$1 = es2018$9;
+const types_1$1 = es2018$5;
 const traverse_error_prototype_chain_1 = traverseErrorPrototypeChain$1;
 function* getErrorNames(err) {
     var _a;
@@ -5546,7 +5556,7 @@ getErrorNames$1.getErrorNames = getErrorNames;
 var serializableError = {};
 
 serializableError.isSerializableError = void 0;
-const types_1 = es2018$9;
+const types_1 = es2018$5;
 function isSerializableError(val) {
     return (0, types_1.isObject)(val)
         && (0, types_1.isString)(val.name)
@@ -5564,7 +5574,7 @@ function requireCustomError () {
 customError.CustomError = void 0;
 	const iterable_operator_1 = requireEs2018$1();
 	const get_error_names_1 = getErrorNames$1;
-	const types_1 = es2018$9;
+	const types_1 = es2018$5;
 	const serializable_error_1 = serializableError;
 	class CustomError extends Error {
 	    get name() {
@@ -5703,7 +5713,7 @@ assert.assert = void 0;
 var hasRequiredEs2018;
 
 function requireEs2018 () {
-	if (hasRequiredEs2018) return es2018$8;
+	if (hasRequiredEs2018) return es2018$9;
 	hasRequiredEs2018 = 1;
 	(function (exports) {
 		var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -5728,69 +5738,106 @@ function requireEs2018 () {
 		__exportStar(getErrorNames$1, exports);
 		__exportStar(traverseErrorPrototypeChain$1, exports);
 		
-} (es2018$8));
-	return es2018$8;
+} (es2018$9));
+	return es2018$9;
 }
 
 var es2018Exports$1 = requireEs2018();
 
-function useSingleSelection(values, defaultSelectedIndex) {
-    es2018Exports$1.assert(values.length > 0, 'The parameter values must be a non-empty array');
-    if (es2018$9.isntUndefined(defaultSelectedIndex)) {
-        es2018Exports$1.assert(defaultSelectedIndex >= 0 && defaultSelectedIndex < values.length, 'The parameter defaultSelectedIndex must be in the range of 0 to values.length');
+function useIIFE(iife, deps) {
+    const oldDeps = react.exports.useRef([]);
+    const isFirstRender = useIsFirstRender();
+    if (isFirstRender()) {
+        iife();
+    }
+    else {
+        if (deps.length === oldDeps.current.length) {
+            if (deps.some((x, i) => x !== oldDeps.current[i])) {
+                iife();
+            }
+        }
+        else {
+            iife();
+        }
     }
+    oldDeps.current = Array.from(deps);
+}
+
+function useSingleSelection(options, defaultSelectedIndex) {
+    useIIFE(() => {
+        es2018Exports$1.assert(defaultSelectedIndex >= 0 && defaultSelectedIndex < options.length, 'The parameter defaultSelectedIndex must be in the range of 0 to values.length');
+    }, [defaultSelectedIndex]);
     const [selectedIndex, setSelectedIndex] = react.exports.useState(defaultSelectedIndex);
-    return react.exports.useMemo(() => ({
-        selectedValue: es2018$9.isUndefined(selectedIndex) ? undefined : values[selectedIndex],
-        options: values.map((value, index) => ({
-            value,
-            index,
-            selected: index === selectedIndex,
-            select: () => setSelectedIndex(index)
-        }))
-    }), [selectedIndex]);
+    return {
+        selectedIndex,
+        optionStates: react.exports.useMemo(createOptionStates, [options, selectedIndex]),
+        select: react.exports.useCallback(select, [])
+    };
+    function createOptionStates() {
+        return options.map((_, index) => ({
+            selected: index === selectedIndex
+        }));
+    }
+    function select(index) {
+        setSelectedIndex(index);
+    }
 }
 
 var es2018Exports = requireEs2018$1();
 
-function useMultipleSelection(values, defaultSelectedIndexes = []) {
-    es2018Exports$1.assert(values.length > 0, 'The parameter values must be a non-empty array');
-    for (const index of defaultSelectedIndexes) {
-        es2018Exports$1.assert(index >= 0 && index < values.length, 'The index of parameter defaultSelectedIndexes must be in the range of 0 to values.length');
-    }
+function useMultipleSelection(options, defaultSelectedIndexes = []) {
+    useIIFE(() => {
+        for (const index of defaultSelectedIndexes) {
+            es2018Exports$1.assert(index >= 0 && index < options.length, 'The index of parameter defaultSelectedIndexes must be in the range of 0 to values.length');
+        }
+    }, [defaultSelectedIndexes]);
     const [selectedIndexes, setSelectedIndexes] = react.exports.useState(new Set(defaultSelectedIndexes));
-    return react.exports.useMemo(() => ({
-        selectedValues: es2018Exports.toArray(es2018Exports.map(selectedIndexes, i => values[i])),
-        options: values.map((value, index) => {
-            const selected = selectedIndexes.has(index);
-            const select = () => {
-                const set = new Set(selectedIndexes);
-                set.add(index);
-                setSelectedIndexes(set);
-            };
-            const unselect = () => {
-                const set = new Set(selectedIndexes);
-                set.delete(index);
-                setSelectedIndexes(set);
-            };
-            return {
-                value,
-                index,
-                selected,
-                select,
-                unselect,
-                toggle: selected ? unselect : select
-            };
-        })
-    }), [selectedIndexes]);
+    return {
+        selectedIndexes: react.exports.useMemo(() => es2018Exports.toArray(selectedIndexes), [selectedIndexes]),
+        optionStates: react.exports.useMemo(createOptionStates, [options, selectedIndexes]),
+        toggle: react.exports.useCallback(toggle, []),
+        select: react.exports.useCallback(select, []),
+        unselect: react.exports.useCallback(unselect, [])
+    };
+    function createOptionStates() {
+        return options.map((_, index) => {
+            const selected = isSelected(index);
+            return { selected };
+        });
+    }
+    function isSelected(index) {
+        return selectedIndexes.has(index);
+    }
+    function toggle(index) {
+        if (isSelected(index)) {
+            unselect(index);
+        }
+        else {
+            select(index);
+        }
+    }
+    function select(index) {
+        setSelectedIndexes(selectedIndexes => {
+            const result = new Set(selectedIndexes);
+            result.add(index);
+            return result;
+        });
+    }
+    function unselect(index) {
+        setSelectedIndexes(selectedIndexes => {
+            const result = new Set(selectedIndexes);
+            result.delete(index);
+            return result;
+        });
+    }
 }
 
-function useStateCycle(stateList, initialStateIndex = 0) {
+function useStateCycle(orderedStates, initialStateIndex = 0) {
     const [index, setIndex] = react.exports.useState(initialStateIndex);
-    return [stateList[index], next];
+    return [orderedStates[index], react.exports.useCallback(next, [orderedStates])];
     function next() {
         setIndex(index => {
-            if (index + 1 < stateList.length) {
+            if (index + 1 < orderedStates.length) {
                 return index + 1;
             }
             else {
@@ -5802,7 +5849,7 @@ function useStateCycle(stateList, initialStateIndex = 0) {
 
 function useToggle(initialState = false) {
     const [state, setState] = react.exports.useState(initialState);
-    return [state, toggle];
+    return [state, react.exports.useCallback(toggle, [])];
     function toggle() {
         setState(state => !state);
     }
@@ -5814,7 +5861,7 @@ function useResizeObserver(callback, refs) {
         const observer = new ResizeObserver(callback);
         refs
             .map(x => x.current)
-            .filter(es2018$9.isntNull)
+            .filter(es2018$5.isntNull)
             .forEach(x => observer.observe(x));
         return () => observer.disconnect();
     }, deps);
@@ -5822,7 +5869,7 @@ function useResizeObserver(callback, refs) {
 
 function useStep(steps, initialStepIndex = 0) {
     const [index, setIndex] = react.exports.useState(initialStepIndex);
-    return [steps[index], next, previous];
+    return [steps[index], react.exports.useCallback(next, [steps]), react.exports.useCallback(previous, [])];
     function next() {
         setIndex(index => {
             if (index === steps.length - 1) {
@@ -5847,7 +5894,10 @@ function useStep(steps, initialStepIndex = 0) {
 
 function useForceUpdate() {
     const [, setState] = react.exports.useState({});
-    return () => setState({});
+    return react.exports.useCallback(forceUpdate, []);
+    function forceUpdate() {
+        setState({});
+    }
 }
 
 var es2018$3 = {};
@@ -14411,7 +14461,7 @@ exports.BadEventError = exports.ObservableFiniteStateMachine = void 0;
 
 function useFiniteStateMachine(schema, initialState) {
     const forceUpdate = useForceUpdate();
-    const fsm = react.exports.useMemo(() => new es2018$3.ObservableFiniteStateMachine(schema, initialState), [schema]);
+    const fsm = react.exports.useMemo(() => new es2018$3.ObservableFiniteStateMachine(schema, initialState), [schema, initialState]);
     react.exports.useEffect(() => {
         const observable = fsm.observeStateChanges();
         const subscription = observable.subscribe(() => forceUpdate());
@@ -14421,5 +14471,5 @@ function useFiniteStateMachine(schema, initialState) {
 }
 
 var ObservableFiniteStateMachine = es2018$3.ObservableFiniteStateMachine;
-export { ObservableFiniteStateMachine, useFiniteStateMachine, useForceUpdate, useIncrement, useIsFirstRender, useIsMounted, useMount, useMultipleSelection, useRenderCounter, useResizeObserver, useSingleSelection, useStateCycle, useStep, useToggle, useUpdateEffect };
+export { ObservableFiniteStateMachine, useFiniteStateMachine, useForceUpdate, useIIFE, useIncrement, useIsFirstRender, useIsMounted, useMount, useMultipleSelection, useRenderCounter, useResizeObserver, useSingleSelection, useStateCycle, useStep, useToggle, useUnmount, useUpdateEffect };
 //# sourceMappingURL=index.mjs.map