extra-react-hooks 0.2.1 → 0.3.0

package/dist/es2018/index.umd.js

@@ -2491,7 +2491,7 @@
 
 	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);
 	    }
@@ -2505,14 +2505,17 @@
 	}
 
 	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;
@@ -2532,7 +2535,10 @@
 	            break;
 	        case State.NotFirst: break;
 	    }
-	    return () => state.current === State.First;
+	    return react.exports.useCallback(isFirstRender, []);
+	    function isFirstRender() {
+	        return state.current === State.First;
+	    }
 	}
 
 	function useRenderCounter() {
@@ -2541,6 +2547,10 @@
 	    return counter.current;
 	}
 
+	function useUnmount(effect) {
+	    react.exports.useEffect(() => effect, []);
+	}
+
 	function useUpdateEffect(effect, deps) {
 	    const isFirstRender = useIsFirstRender();
 	    react.exports.useEffect(() => {
@@ -2552,6 +2562,71 @@
 
 	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;
@@ -3115,18 +3190,6 @@
 	}
 	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;
@@ -3160,58 +3223,84 @@
 		__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;
@@ -3222,733 +3311,854 @@
 		            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)
@@ -3956,1318 +4166,842 @@
 		        }
 		    });
 		}
-		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;
 	    }
@@ -5275,177 +5009,486 @@
 	        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) {
@@ -5461,61 +5504,28 @@
 		}));
 		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 = {};
 
@@ -5531,7 +5541,7 @@
 	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;
@@ -5552,7 +5562,7 @@
 	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)
@@ -5570,7 +5580,7 @@
 	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() {
@@ -5709,7 +5719,7 @@
 	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) {
@@ -5734,69 +5744,106 @@
 			__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 {
@@ -5808,7 +5855,7 @@
 
 	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);
 	    }
@@ -5820,7 +5867,7 @@
 	        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);
@@ -5828,7 +5875,7 @@
 
 	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) {
@@ -5853,7 +5900,10 @@
 
 	function useForceUpdate() {
 	    const [, setState] = react.exports.useState({});
-	    return () => setState({});
+	    return react.exports.useCallback(forceUpdate, []);
+	    function forceUpdate() {
+	        setState({});
+	    }
 	}
 
 	var es2018$3 = {};
@@ -14417,7 +14467,7 @@
 
 	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());
@@ -14429,6 +14479,7 @@
 	exports.ObservableFiniteStateMachine = es2018$3.ObservableFiniteStateMachine;
 	exports.useFiniteStateMachine = useFiniteStateMachine;
 	exports.useForceUpdate = useForceUpdate;
+	exports.useIIFE = useIIFE;
 	exports.useIncrement = useIncrement;
 	exports.useIsFirstRender = useIsFirstRender;
 	exports.useIsMounted = useIsMounted;
@@ -14440,6 +14491,7 @@
 	exports.useStateCycle = useStateCycle;
 	exports.useStep = useStep;
 	exports.useToggle = useToggle;
+	exports.useUnmount = useUnmount;
 	exports.useUpdateEffect = useUpdateEffect;
 
 	Object.defineProperty(exports, '__esModule', { value: true });