extra-react-hooks 0.2.0 → 0.3.1

package/dist/es2015/index.umd.js

@@ -2491,13 +2491,13 @@
 
 	function useIncrement(initialValue) {
 	    const [value, setValue] = react.exports.useState(initialValue);
-	    const increment = react.exports.useCallback((step = 1) => {
+	    return [value, react.exports.useCallback(increment, []), react.exports.useCallback(reset, [])];
+	    function increment(step = 1) {
 	        setValue(value => value + step);
-	    }, []);
-	    const reset = react.exports.useCallback(() => {
+	    }
+	    function reset() {
 	        setValue(initialValue);
-	    }, []);
-	    return [value, increment, reset];
+	    }
 	}
 
 	function useMount(effect) {
@@ -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(() => {
@@ -2550,227 +2560,292 @@
 	    }, deps);
 	}
 
+	var es2018$9 = {};
+
+	var customError = {};
+
+	var es2018$8 = {};
+
+	var middleware = {};
+
+	var chunkAsync = {};
+
 	var es2018$7 = {};
 
-	var array = {};
+	var go$1 = {};
 
-	array.isntEmptyArray = array.isEmptyArray = array.isntArray = array.isArray = void 0;
-	function isArray$3(val) {
+	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;
+	function isArray$5(val) {
 	    return Array.isArray(val);
 	}
-	array.isArray = isArray$3;
-	function isntArray(val) {
-	    return !isArray$3(val);
+	array$2.isArray = isArray$5;
+	function isntArray$2(val) {
+	    return !isArray$5(val);
 	}
-	array.isntArray = isntArray;
-	function isEmptyArray(val) {
+	array$2.isntArray = isntArray$2;
+	function isEmptyArray$2(val) {
 	    return val.length === 0;
 	}
-	array.isEmptyArray = isEmptyArray;
-	function isntEmptyArray(val) {
+	array$2.isEmptyArray = isEmptyArray$2;
+	function isntEmptyArray$2(val) {
 	    return val.length !== 0;
 	}
-	array.isntEmptyArray = isntEmptyArray;
+	array$2.isntEmptyArray = isntEmptyArray$2;
 
-	var asyncIterable = {};
+	var asyncIterable$2 = {};
 
-	var _null = {};
+	var _null$2 = {};
 
-	_null.isntNull = _null.isNull = void 0;
-	function isNull(val) {
+	_null$2.isntNull = _null$2.isNull = void 0;
+	function isNull$2(val) {
 	    return val === null;
 	}
-	_null.isNull = isNull;
-	function isntNull(val) {
-	    return !isNull(val);
+	_null$2.isNull = isNull$2;
+	function isntNull$2(val) {
+	    return !isNull$2(val);
 	}
-	_null.isntNull = isntNull;
+	_null$2.isntNull = isntNull$2;
 
-	var _undefined = {};
+	var _undefined$2 = {};
 
-	_undefined.isntUndefined = _undefined.isUndefined = void 0;
-	function isUndefined(val) {
+	_undefined$2.isntUndefined = _undefined$2.isUndefined = void 0;
+	function isUndefined$2(val) {
 	    return val === undefined;
 	}
-	_undefined.isUndefined = isUndefined;
-	function isntUndefined(val) {
-	    return !isUndefined(val);
+	_undefined$2.isUndefined = isUndefined$2;
+	function isntUndefined$2(val) {
+	    return !isUndefined$2(val);
 	}
-	_undefined.isntUndefined = isntUndefined;
+	_undefined$2.isntUndefined = isntUndefined$2;
 
-	var _function = {};
+	var _function$2 = {};
 
-	_function.isntFunction = _function.isFunction = void 0;
-	function isFunction$2(val) {
+	_function$2.isntFunction = _function$2.isFunction = void 0;
+	function isFunction$4(val) {
 	    return typeof val === 'function';
 	}
-	_function.isFunction = isFunction$2;
-	function isntFunction(val) {
-	    return !isFunction$2(val);
+	_function$2.isFunction = isFunction$4;
+	function isntFunction$2(val) {
+	    return !isFunction$4(val);
 	}
-	_function.isntFunction = isntFunction;
+	_function$2.isntFunction = isntFunction$2;
 
-	asyncIterable.isntAsyncIterable = asyncIterable.isAsyncIterable = void 0;
-	const null_1$2 = _null;
-	const undefined_1$1 = _undefined;
-	const function_1$2 = _function;
-	function isAsyncIterable$2(val) {
-	    return (0, null_1$2.isntNull)(val)
-	        && (0, undefined_1$1.isntUndefined)(val)
-	        && (0, function_1$2.isFunction)(val[Symbol.asyncIterator]);
+	asyncIterable$2.isntAsyncIterable = asyncIterable$2.isAsyncIterable = void 0;
+	const null_1$8 = _null$2;
+	const undefined_1$5 = _undefined$2;
+	const function_1$8 = _function$2;
+	function isAsyncIterable$4(val) {
+	    return (0, null_1$8.isntNull)(val)
+	        && (0, undefined_1$5.isntUndefined)(val)
+	        && (0, function_1$8.isFunction)(val[Symbol.asyncIterator]);
 	}
-	asyncIterable.isAsyncIterable = isAsyncIterable$2;
-	function isntAsyncIterable(val) {
-	    return !isAsyncIterable$2(val);
+	asyncIterable$2.isAsyncIterable = isAsyncIterable$4;
+	function isntAsyncIterable$2(val) {
+	    return !isAsyncIterable$4(val);
 	}
-	asyncIterable.isntAsyncIterable = isntAsyncIterable;
+	asyncIterable$2.isntAsyncIterable = isntAsyncIterable$2;
 
-	var bigint = {};
+	var bigint$2 = {};
 
-	bigint.isntBigInt = bigint.isBigInt = void 0;
-	function isBigInt(val) {
+	bigint$2.isntBigInt = bigint$2.isBigInt = void 0;
+	function isBigInt$2(val) {
 	    return typeof val === 'bigint';
 	}
-	bigint.isBigInt = isBigInt;
-	function isntBigInt(val) {
-	    return !isBigInt(val);
+	bigint$2.isBigInt = isBigInt$2;
+	function isntBigInt$2(val) {
+	    return !isBigInt$2(val);
 	}
-	bigint.isntBigInt = isntBigInt;
+	bigint$2.isntBigInt = isntBigInt$2;
 
-	var boolean = {};
+	var boolean$2 = {};
 
-	boolean.isntBoolean = boolean.isBoolean = void 0;
-	function isBoolean(val) {
+	boolean$2.isntBoolean = boolean$2.isBoolean = void 0;
+	function isBoolean$2(val) {
 	    return typeof val === 'boolean';
 	}
-	boolean.isBoolean = isBoolean;
-	function isntBoolean(val) {
-	    return !isBoolean(val);
+	boolean$2.isBoolean = isBoolean$2;
+	function isntBoolean$2(val) {
+	    return !isBoolean$2(val);
 	}
-	boolean.isntBoolean = isntBoolean;
+	boolean$2.isntBoolean = isntBoolean$2;
 
-	var char = {};
+	var char$2 = {};
 
-	var string = {};
+	var string$2 = {};
 
-	string.isntString = string.isString = void 0;
-	function isString(val) {
+	string$2.isntString = string$2.isString = void 0;
+	function isString$2(val) {
 	    return typeof val === 'string';
 	}
-	string.isString = isString;
-	function isntString(val) {
-	    return !isString(val);
+	string$2.isString = isString$2;
+	function isntString$2(val) {
+	    return !isString$2(val);
 	}
-	string.isntString = isntString;
+	string$2.isntString = isntString$2;
 
-	char.isntChar = char.isChar = void 0;
-	const string_1$1 = string;
-	function isChar(val) {
-	    return (0, string_1$1.isString)(val)
+	char$2.isntChar = char$2.isChar = void 0;
+	const string_1$5 = string$2;
+	function isChar$2(val) {
+	    return (0, string_1$5.isString)(val)
 	        && val.length === 1;
 	}
-	char.isChar = isChar;
-	function isntChar(val) {
-	    return !isChar(val);
+	char$2.isChar = isChar$2;
+	function isntChar$2(val) {
+	    return !isChar$2(val);
 	}
-	char.isntChar = isntChar;
+	char$2.isntChar = isntChar$2;
 
-	var date = {};
+	var date$2 = {};
 
-	date.isntDate = date.isDate = void 0;
-	function isDate$1(val) {
+	date$2.isntDate = date$2.isDate = void 0;
+	function isDate$3(val) {
 	    return val instanceof Date;
 	}
-	date.isDate = isDate$1;
-	function isntDate(val) {
-	    return !isDate$1(val);
+	date$2.isDate = isDate$3;
+	function isntDate$2(val) {
+	    return !isDate$3(val);
 	}
-	date.isntDate = isntDate;
+	date$2.isntDate = isntDate$2;
 
-	var _enum = {};
+	var _enum$2 = {};
 
-	_enum.inEnum = void 0;
-	function inEnum(val, _enum) {
+	_enum$2.inEnum = void 0;
+	function inEnum$2(val, _enum) {
 	    return Object.values(_enum).includes(val);
 	}
-	_enum.inEnum = inEnum;
+	_enum$2.inEnum = inEnum$2;
 
-	var error = {};
+	var error$2 = {};
 
-	error.isntError = error.isError = void 0;
-	function isError(val) {
+	error$2.isntError = error$2.isError = void 0;
+	function isError$2(val) {
 	    return val instanceof Error;
 	}
-	error.isError = isError;
-	function isntError(val) {
-	    return !isError(val);
+	error$2.isError = isError$2;
+	function isntError$2(val) {
+	    return !isError$2(val);
 	}
-	error.isntError = isntError;
+	error$2.isntError = isntError$2;
 
-	var falsy = {};
+	var falsy$2 = {};
 
-	falsy.isntFalsy = falsy.isFalsy = void 0;
-	function isFalsy(val) {
+	falsy$2.isntFalsy = falsy$2.isFalsy = void 0;
+	function isFalsy$2(val) {
 	    return !val;
 	}
-	falsy.isFalsy = isFalsy;
-	function isntFalsy(val) {
-	    return !isFalsy(val);
+	falsy$2.isFalsy = isFalsy$2;
+	function isntFalsy$2(val) {
+	    return !isFalsy$2(val);
 	}
-	falsy.isntFalsy = isntFalsy;
+	falsy$2.isntFalsy = isntFalsy$2;
 
-	var iterable = {};
+	var iterable$2 = {};
 
-	iterable.isntIterable = iterable.isIterable = void 0;
-	const null_1$1 = _null;
-	const undefined_1 = _undefined;
-	const function_1$1 = _function;
-	function isIterable$2(val) {
-	    return (0, null_1$1.isntNull)(val)
-	        && (0, undefined_1.isntUndefined)(val)
-	        && (0, function_1$1.isFunction)(val[Symbol.iterator]);
+	iterable$2.isntIterable = iterable$2.isIterable = void 0;
+	const null_1$7 = _null$2;
+	const undefined_1$4 = _undefined$2;
+	const function_1$7 = _function$2;
+	function isIterable$4(val) {
+	    return (0, null_1$7.isntNull)(val)
+	        && (0, undefined_1$4.isntUndefined)(val)
+	        && (0, function_1$7.isFunction)(val[Symbol.iterator]);
 	}
-	iterable.isIterable = isIterable$2;
-	function isntIterable(val) {
-	    return !isIterable$2(val);
+	iterable$2.isIterable = isIterable$4;
+	function isntIterable$2(val) {
+	    return !isIterable$4(val);
 	}
-	iterable.isntIterable = isntIterable;
+	iterable$2.isntIterable = isntIterable$2;
 
-	var json = {};
+	var json$2 = {};
 
-	var number = {};
+	var number$2 = {};
 
-	number.isntNaN = number.isNaN = number.isNegativeInfinity = number.isPositiveInfinity = number.isFinite = number.isntNumber = number.isNumber = void 0;
-	function isNumber(val) {
+	number$2.isntNaN = number$2.isNaN = number$2.isNegativeInfinity = number$2.isPositiveInfinity = number$2.isFinite = number$2.isntNumber = number$2.isNumber = void 0;
+	function isNumber$2(val) {
 	    return typeof val === 'number';
 	}
-	number.isNumber = isNumber;
-	function isntNumber(val) {
-	    return !isNumber(val);
+	number$2.isNumber = isNumber$2;
+	function isntNumber$2(val) {
+	    return !isNumber$2(val);
 	}
-	number.isntNumber = isntNumber;
-	function isFinite(val) {
+	number$2.isntNumber = isntNumber$2;
+	function isFinite$2(val) {
 	    return Number.isFinite(val);
 	}
-	number.isFinite = isFinite;
-	function isPositiveInfinity(val) {
+	number$2.isFinite = isFinite$2;
+	function isPositiveInfinity$2(val) {
 	    return val === Infinity;
 	}
-	number.isPositiveInfinity = isPositiveInfinity;
-	function isNegativeInfinity(val) {
+	number$2.isPositiveInfinity = isPositiveInfinity$2;
+	function isNegativeInfinity$2(val) {
 	    return val === -Infinity;
 	}
-	number.isNegativeInfinity = isNegativeInfinity;
-	function isNaN$1(val) {
+	number$2.isNegativeInfinity = isNegativeInfinity$2;
+	function isNaN$3(val) {
 	    return Number.isNaN(val);
 	}
-	number.isNaN = isNaN$1;
-	function isntNaN(val) {
-	    return !isNaN$1(val);
+	number$2.isNaN = isNaN$3;
+	function isntNaN$2(val) {
+	    return !isNaN$3(val);
 	}
-	number.isntNaN = isntNaN;
+	number$2.isntNaN = isntNaN$2;
 
-	var object = {};
+	var object$2 = {};
 
 	/** Detect free variable `global` from Node.js. */
 
@@ -2998,7 +3073,7 @@
 	 * _.isPlainObject(Object.create(null));
 	 * // => true
 	 */
-	function isPlainObject$1(value) {
+	function isPlainObject$3(value) {
 	  if (!isObjectLike(value) || baseGetTag(value) != objectTag) {
 	    return false;
 	  }
@@ -3011,59 +3086,59 @@
 	    funcToString.call(Ctor) == objectCtorString;
 	}
 
-	var isPlainObject_1$1 = isPlainObject$1;
+	var isPlainObject_1$3 = isPlainObject$3;
 
-	var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+	var __importDefault$2 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
 	    return (mod && mod.__esModule) ? mod : { "default": mod };
-	};object.isntEmptyObject = object.isEmptyObject = object.isntPlainObject = object.isPlainObject = object.isntObject = object.isObject = void 0;
-	const isPlainObject_1 = __importDefault(isPlainObject_1$1);
-	function isObject(val) {
+	};object$2.isntEmptyObject = object$2.isEmptyObject = object$2.isntPlainObject = object$2.isPlainObject = object$2.isntObject = object$2.isObject = void 0;
+	const isPlainObject_1$2 = __importDefault$2(isPlainObject_1$3);
+	function isObject$2(val) {
 	    return val !== null
 	        && typeof val === 'object';
 	}
-	object.isObject = isObject;
-	function isntObject(val) {
-	    return !isObject(val);
+	object$2.isObject = isObject$2;
+	function isntObject$2(val) {
+	    return !isObject$2(val);
 	}
-	object.isntObject = isntObject;
-	function isPlainObject(val) {
-	    return (0, isPlainObject_1.default)(val);
+	object$2.isntObject = isntObject$2;
+	function isPlainObject$2(val) {
+	    return (0, isPlainObject_1$2.default)(val);
 	}
-	object.isPlainObject = isPlainObject;
-	function isntPlainObject(val) {
-	    return !isPlainObject(val);
+	object$2.isPlainObject = isPlainObject$2;
+	function isntPlainObject$2(val) {
+	    return !isPlainObject$2(val);
 	}
-	object.isntPlainObject = isntPlainObject;
-	function isEmptyObject(val) {
+	object$2.isntPlainObject = isntPlainObject$2;
+	function isEmptyObject$2(val) {
 	    return Object.keys(val).length === 0;
 	}
-	object.isEmptyObject = isEmptyObject;
-	function isntEmptyObject(val) {
+	object$2.isEmptyObject = isEmptyObject$2;
+	function isntEmptyObject$2(val) {
 	    return Object.keys(val).length !== 0;
 	}
-	object.isntEmptyObject = isntEmptyObject;
-
-	json.isntJsonable = json.isJsonable = json.isntJson = json.isJson = void 0;
-	const null_1 = _null;
-	const boolean_1 = boolean;
-	const string_1 = string;
-	const number_1 = number;
-	const array_1 = array;
-	const object_1$1 = object;
-	function isJson(val) {
-	    return (0, null_1.isNull)(val)
-	        || (0, boolean_1.isBoolean)(val)
-	        || (0, string_1.isString)(val)
-	        || (0, number_1.isNumber)(val)
-	        || ((0, array_1.isArray)(val) && val.every(isJson))
-	        || ((0, object_1$1.isPlainObject)(val) && Object.values(val).every(isJson));
-	}
-	json.isJson = isJson;
-	function isntJson(val) {
-	    return !isJson(val);
-	}
-	json.isntJson = isntJson;
-	function isJsonable(val) {
+	object$2.isntEmptyObject = isntEmptyObject$2;
+
+	json$2.isntJsonable = json$2.isJsonable = json$2.isntJson = json$2.isJson = void 0;
+	const null_1$6 = _null$2;
+	const boolean_1$2 = boolean$2;
+	const string_1$4 = string$2;
+	const number_1$2 = number$2;
+	const array_1$2 = array$2;
+	const object_1$5 = object$2;
+	function isJson$2(val) {
+	    return (0, null_1$6.isNull)(val)
+	        || (0, boolean_1$2.isBoolean)(val)
+	        || (0, string_1$4.isString)(val)
+	        || (0, number_1$2.isNumber)(val)
+	        || ((0, array_1$2.isArray)(val) && val.every(isJson$2))
+	        || ((0, object_1$5.isPlainObject)(val) && Object.values(val).every(isJson$2));
+	}
+	json$2.isJson = isJson$2;
+	function isntJson$2(val) {
+	    return !isJson$2(val);
+	}
+	json$2.isntJson = isntJson$2;
+	function isJsonable$2(val) {
 	    try {
 	        JSON.stringify(val);
 	        return true;
@@ -3072,39 +3147,39 @@
 	        return false;
 	    }
 	}
-	json.isJsonable = isJsonable;
-	function isntJsonable(val) {
-	    return !isntJsonable();
+	json$2.isJsonable = isJsonable$2;
+	function isntJsonable$2(val) {
+	    return !isntJsonable$2();
 	}
-	json.isntJsonable = isntJsonable;
+	json$2.isntJsonable = isntJsonable$2;
 
-	var promise = {};
+	var promise$2 = {};
 
-	promise.isPromiseLike = promise.isntPromiseLike = promise.isntPromise = promise.isPromise = void 0;
-	const object_1 = object;
-	const function_1 = _function;
-	function isPromise$2(val) {
+	promise$2.isPromiseLike = promise$2.isntPromiseLike = promise$2.isntPromise = promise$2.isPromise = void 0;
+	const object_1$4 = object$2;
+	const function_1$6 = _function$2;
+	function isPromise$4(val) {
 	    return val instanceof Promise;
 	}
-	promise.isPromise = isPromise$2;
-	function isntPromise(val) {
-	    return !isPromise$2(val);
+	promise$2.isPromise = isPromise$4;
+	function isntPromise$2(val) {
+	    return !isPromise$4(val);
 	}
-	promise.isntPromise = isntPromise;
-	function isntPromiseLike(val) {
-	    return !isPromiseLike(val);
+	promise$2.isntPromise = isntPromise$2;
+	function isntPromiseLike$2(val) {
+	    return !isPromiseLike$2(val);
 	}
-	promise.isntPromiseLike = isntPromiseLike;
-	function isPromiseLike(val) {
-	    return (0, object_1.isObject)(val)
-	        && (0, function_1.isFunction)(val.then);
+	promise$2.isntPromiseLike = isntPromiseLike$2;
+	function isPromiseLike$2(val) {
+	    return (0, object_1$4.isObject)(val)
+	        && (0, function_1$6.isFunction)(val.then);
 	}
-	promise.isPromiseLike = isPromiseLike;
+	promise$2.isPromiseLike = isPromiseLike$2;
 
-	var url = {};
+	var url$2 = {};
 
-	url.isAbsoluteURL = void 0;
-	function isAbsoluteURL(str) {
+	url$2.isAbsoluteURL = void 0;
+	function isAbsoluteURL$2(str) {
 	    try {
 	        new URL(str);
 	        return true;
@@ -3113,7 +3188,7 @@
 	        return false;
 	    }
 	}
-	url.isAbsoluteURL = isAbsoluteURL;
+	url$2.isAbsoluteURL = isAbsoluteURL$2;
 
 	(function (exports) {
 		var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -3129,95 +3204,30 @@
 		}));
 		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, exports);
-		__exportStar(asyncIterable, exports);
-		__exportStar(bigint, exports);
-		__exportStar(boolean, exports);
-		__exportStar(char, exports);
-		__exportStar(date, exports);
-		__exportStar(_enum, exports);
-		__exportStar(error, exports);
-		__exportStar(falsy, exports);
-		__exportStar(_function, exports);
-		__exportStar(iterable, exports);
-		__exportStar(json, exports);
-		__exportStar(_null, exports);
-		__exportStar(number, exports);
-		__exportStar(object, exports);
-		__exportStar(promise, exports);
-		__exportStar(string, exports);
-		__exportStar(_undefined, exports);
-		__exportStar(url, exports);
-		
-	} (es2018$7));
-
-	var es2018$6 = {};
-
-	var customError = {};
-
-	var es2018$5 = {};
-
-	var middleware = {};
-
-	var chunkAsync = {};
-
-	var es2018$4 = {};
-
-	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$4));
-
-	var hasRequiredChunkAsync;
-
-	function requireChunkAsync () {
-		if (hasRequiredChunkAsync) return chunkAsync;
-		hasRequiredChunkAsync = 1;
-	chunkAsync.chunkAsync = void 0;
-		const go_1 = es2018$4;
-		const errors_1 = requireEs2018();
-		function chunkAsync$1(iterable, size) {
-		    (0, errors_1.assert)(Number.isInteger(size), 'The parameter size must be an integer');
-		    (0, errors_1.assert)(size > 0, 'The parameter size must be greater than 0');
-		    return (0, go_1.go)(async function* () {
-		        let buffer = [];
-		        for await (const element of iterable) {
-		            buffer.push(element);
-		            if (buffer.length >= size) {
-		                yield buffer;
-		                buffer = [];
-		            }
-		        }
-		        if (buffer.length)
-		            yield buffer;
-		    });
-		}
-		chunkAsync.chunkAsync = chunkAsync$1;
+		};__exportStar(array$2, exports);
+		__exportStar(asyncIterable$2, exports);
+		__exportStar(bigint$2, exports);
+		__exportStar(boolean$2, exports);
+		__exportStar(char$2, exports);
+		__exportStar(date$2, exports);
+		__exportStar(_enum$2, exports);
+		__exportStar(error$2, exports);
+		__exportStar(falsy$2, exports);
+		__exportStar(_function$2, exports);
+		__exportStar(iterable$2, exports);
+		__exportStar(json$2, exports);
+		__exportStar(_null$2, exports);
+		__exportStar(number$2, exports);
+		__exportStar(object$2, exports);
+		__exportStar(promise$2, exports);
+		__exportStar(string$2, exports);
+		__exportStar(_undefined$2, exports);
+		__exportStar(url$2, exports);
 		
-		return chunkAsync;
-	}
-
-	var chunkByAsync$1 = {};
+	} (es2018$6));
 
 	chunkByAsync$1.chunkByAsync = void 0;
-	const types_1$j = es2018$7;
+	const types_1$j = es2018$6;
 	function chunkByAsync(iterable, predicate) {
 	    if ((0, types_1$j.isAsyncIterable)(iterable)) {
 	        return chunkByAsyncIterable(iterable);
@@ -3283,7 +3293,7 @@
 		if (hasRequiredChunk) return chunk;
 		hasRequiredChunk = 1;
 	chunk.chunk = void 0;
-		const go_1 = es2018$4;
+		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');
@@ -3309,8 +3319,8 @@
 	var concatAsync$1 = {};
 
 	concatAsync$1.concatAsync = void 0;
-	const types_1$i = es2018$7;
-	const go_1$1 = es2018$4;
+	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]) {
@@ -3332,7 +3342,7 @@
 	var concat$5 = {};
 
 	concat$5.concat = void 0;
-	const go_1 = es2018$4;
+	const go_1 = es2018$7;
 	function concat$4(iterable, ...otherIterables) {
 	    return (0, go_1.go)(function* () {
 	        for (const iter of [iterable, ...otherIterables]) {
@@ -3366,7 +3376,7 @@
 		if (hasRequiredDropAsync) return dropAsync;
 		hasRequiredDropAsync = 1;
 	dropAsync.dropAsync = void 0;
-		const go_1 = es2018$4;
+		const go_1 = es2018$7;
 		const utils_1 = utils;
 		const errors_1 = requireEs2018();
 		function dropAsync$1(iterable, count) {
@@ -3409,7 +3419,7 @@
 		if (hasRequiredDropRightAsync) return dropRightAsync;
 		hasRequiredDropRightAsync = 1;
 	dropRightAsync.dropRightAsync = void 0;
-		const go_1 = es2018$4;
+		const go_1 = es2018$7;
 		const utils_1 = utils;
 		const errors_1 = requireEs2018();
 		function dropRightAsync$1(iterable, count) {
@@ -3445,7 +3455,7 @@
 		if (hasRequiredDropRight) return dropRight;
 		hasRequiredDropRight = 1;
 	dropRight.dropRight = void 0;
-		const go_1 = es2018$4;
+		const go_1 = es2018$7;
 		const utils_1 = utils;
 		const errors_1 = requireEs2018();
 		function dropRight$1(iterable, count) {
@@ -3466,7 +3476,7 @@
 	var dropUntilAsync$1 = {};
 
 	dropUntilAsync$1.dropUntilAsync = void 0;
-	const types_1$h = es2018$7;
+	const types_1$h = es2018$6;
 	function dropUntilAsync(iterable, predicate) {
 	    if ((0, types_1$h.isAsyncIterable)(iterable)) {
 	        return dropUntilAsyncIterable(iterable);
@@ -3553,7 +3563,7 @@
 		if (hasRequiredDrop) return drop;
 		hasRequiredDrop = 1;
 	drop.drop = void 0;
-		const go_1 = es2018$4;
+		const go_1 = es2018$7;
 		const utils_1 = utils;
 		const errors_1 = requireEs2018();
 		function drop$1(iterable, count) {
@@ -3591,7 +3601,7 @@
 	var filterAsync$1 = {};
 
 	filterAsync$1.filterAsync = void 0;
-	const types_1$g = es2018$7;
+	const types_1$g = es2018$6;
 	function filterAsync(iterable, predicate) {
 	    if ((0, types_1$g.isAsyncIterable)(iterable)) {
 	        return filterAsyncIterable(iterable);
@@ -3638,7 +3648,7 @@
 	var flattenByAsync$1 = {};
 
 	flattenByAsync$1.flattenByAsync = void 0;
-	const types_1$f = es2018$7;
+	const types_1$f = es2018$6;
 	function flattenByAsync(iterable, predicate) {
 	    if ((0, types_1$f.isAsyncIterable)(iterable)) {
 	        return flattenByAsyncIterable(iterable);
@@ -3712,7 +3722,7 @@
 	var flattenBy$1 = {};
 
 	flattenBy$1.flattenBy = void 0;
-	const types_1$e = es2018$7;
+	const types_1$e = es2018$6;
 	function flattenBy(iterable, predicate) {
 	    return flatten(iterable, 1);
 	    function* flatten(iterable, level) {
@@ -3771,7 +3781,7 @@
 	var mapAsync$1 = {};
 
 	mapAsync$1.mapAsync = void 0;
-	const types_1$d = es2018$7;
+	const types_1$d = es2018$6;
 	function mapAsync(iterable, fn) {
 	    if ((0, types_1$d.isAsyncIterable)(iterable)) {
 	        return mapAsyncIterable(iterable);
@@ -3816,7 +3826,7 @@
 		if (hasRequiredRepeatAsync) return repeatAsync;
 		hasRequiredRepeatAsync = 1;
 	repeatAsync.repeatAsync = void 0;
-		const go_1 = es2018$4;
+		const go_1 = es2018$7;
 		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');
@@ -3859,7 +3869,7 @@
 		if (hasRequiredRepeat) return repeat$2;
 		hasRequiredRepeat = 1;
 	repeat$2.repeat = void 0;
-		const go_1 = es2018$4;
+		const go_1 = es2018$7;
 		const errors_1 = requireEs2018();
 		function repeat(iterable, times) {
 		    (0, errors_1.assert)(times === Infinity || Number.isInteger(times), 'The parameter times must be an integer');
@@ -3902,7 +3912,7 @@
 		if (hasRequiredSliceAsync) return sliceAsync;
 		hasRequiredSliceAsync = 1;
 	sliceAsync.sliceAsync = void 0;
-		const go_1 = es2018$4;
+		const go_1 = es2018$7;
 		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');
@@ -3933,7 +3943,7 @@
 		if (hasRequiredSlice) return slice;
 		hasRequiredSlice = 1;
 	slice.slice = void 0;
-		const go_1 = es2018$4;
+		const go_1 = es2018$7;
 		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');
@@ -3977,7 +3987,7 @@
 	var splitByAsync$1 = {};
 
 	splitByAsync$1.splitByAsync = void 0;
-	const types_1$c = es2018$7;
+	const types_1$c = es2018$6;
 	function splitByAsync(iterable, predicate) {
 	    if ((0, types_1$c.isAsyncIterable)(iterable)) {
 	        return splitByAsyncIterable(iterable);
@@ -4064,7 +4074,7 @@
 		if (hasRequiredTakeAsync) return takeAsync;
 		hasRequiredTakeAsync = 1;
 	takeAsync.takeAsync = void 0;
-		const go_1 = es2018$4;
+		const go_1 = es2018$7;
 		const errors_1 = requireEs2018();
 		function takeAsync$1(iterable, count) {
 		    (0, errors_1.assert)(Number.isInteger(count), 'The parameter count must be an integer');
@@ -4093,7 +4103,7 @@
 		if (hasRequiredTakeRightAsync) return takeRightAsync;
 		hasRequiredTakeRightAsync = 1;
 	takeRightAsync.takeRightAsync = void 0;
-		const go_1 = es2018$4;
+		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');
@@ -4131,7 +4141,7 @@
 		if (hasRequiredTakeRight) return takeRight;
 		hasRequiredTakeRight = 1;
 	takeRight.takeRight = void 0;
-		const go_1 = es2018$4;
+		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');
@@ -4164,7 +4174,7 @@
 	var takeUntilAsync$1 = {};
 
 	takeUntilAsync$1.takeUntilAsync = void 0;
-	const types_1$b = es2018$7;
+	const types_1$b = es2018$6;
 	function takeUntilAsync(iterable, predicate) {
 	    if ((0, types_1$b.isAsyncIterable)(iterable)) {
 	        return takeUntilAsyncIterable(iterable);
@@ -4215,7 +4225,7 @@
 		if (hasRequiredTake) return take$2;
 		hasRequiredTake = 1;
 	take$2.take = void 0;
-		const go_1 = es2018$4;
+		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');
@@ -4239,7 +4249,7 @@
 	var tapAsync$1 = {};
 
 	tapAsync$1.tapAsync = void 0;
-	const types_1$a = es2018$7;
+	const types_1$a = es2018$6;
 	function tapAsync(iterable, fn) {
 	    if ((0, types_1$a.isAsyncIterable)(iterable)) {
 	        return tapAsyncIterable(iterable);
@@ -4322,7 +4332,7 @@
 	var uniqByAsync$1 = {};
 
 	uniqByAsync$1.uniqByAsync = void 0;
-	const types_1$9 = es2018$7;
+	const types_1$9 = es2018$6;
 	function uniqByAsync(iterable, fn) {
 	    if ((0, types_1$9.isAsyncIterable)(iterable)) {
 	        return uniqByAsyncIterable(iterable);
@@ -4391,7 +4401,7 @@
 	var zipAsync$1 = {};
 
 	zipAsync$1.zipAsync = void 0;
-	const types_1$8 = es2018$7;
+	const types_1$8 = es2018$6;
 	var Kind;
 	(function (Kind) {
 	    Kind[Kind["Sync"] = 0] = "Sync";
@@ -4562,7 +4572,7 @@
 	var eachAsync$1 = {};
 
 	eachAsync$1.eachAsync = void 0;
-	const types_1$7 = es2018$7;
+	const types_1$7 = es2018$6;
 	function eachAsync(iterable, fn) {
 	    if ((0, types_1$7.isAsyncIterable)(iterable)) {
 	        return eachAsyncIterable(iterable);
@@ -4602,7 +4612,7 @@
 	var everyAsync$1 = {};
 
 	everyAsync$1.everyAsync = void 0;
-	const types_1$6 = es2018$7;
+	const types_1$6 = es2018$6;
 	function everyAsync(iterable, predicate) {
 	    if ((0, types_1$6.isAsyncIterable)(iterable)) {
 	        return everyAsyncIterable(iterable);
@@ -4648,7 +4658,7 @@
 	var findAsync$1 = {};
 
 	findAsync$1.findAsync = void 0;
-	const types_1$5 = es2018$7;
+	const types_1$5 = es2018$6;
 	function findAsync(iterable, predicate) {
 	    if ((0, types_1$5.isAsyncIterable)(iterable)) {
 	        return findAsyncIterable(iterable);
@@ -4772,7 +4782,7 @@
 	var reduceAsync$1 = {};
 
 	reduceAsync$1.reduceAsync = void 0;
-	const types_1$4 = es2018$7;
+	const types_1$4 = es2018$6;
 	function reduceAsync(iterable, fn, initialValue) {
 	    if ((0, types_1$4.isUndefined)(initialValue)) {
 	        return reduceAsyncWithoutInitialValue(iterable, fn);
@@ -4868,7 +4878,7 @@
 	var reduce$3 = {};
 
 	reduce$3.reduce = void 0;
-	const types_1$3 = es2018$7;
+	const types_1$3 = es2018$6;
 	function reduce$2(iterable, fn, initialValue) {
 	    if ((0, types_1$3.isUndefined)(initialValue)) {
 	        return reduceWithoutInitialValue(iterable, fn);
@@ -4915,7 +4925,7 @@
 	var someAsync$1 = {};
 
 	someAsync$1.someAsync = void 0;
-	const types_1$2 = es2018$7;
+	const types_1$2 = es2018$6;
 	function someAsync(iterable, predicate) {
 	    if ((0, types_1$2.isAsyncIterable)(iterable)) {
 	        return someAsyncIterable(iterable);
@@ -5119,7 +5129,7 @@
 	var hasRequiredEs2018$1;
 
 	function requireEs2018$1 () {
-		if (hasRequiredEs2018$1) return es2018$5;
+		if (hasRequiredEs2018$1) return es2018$8;
 		hasRequiredEs2018$1 = 1;
 		(function (exports) {
 			var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -5138,12 +5148,385 @@
 			};__exportStar(requireMiddleware(), exports);
 			__exportStar(output, exports);
 			
-	} (es2018$5));
-		return es2018$5;
+	} (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;
+	}
+	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 promise$1 = {};
+
+	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);
+	}
+	promise$1.isPromiseLike = isPromiseLike$1;
+
+	var url$1 = {};
+
+	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 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;
+		    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);
+		__exportStar(regexp, exports);
+		
+	} (es2018$5));
+
 	var traverseErrorPrototypeChain$1 = {};
 
 	traverseErrorPrototypeChain$1.traverseErrorPrototypeChain = void 0;
@@ -5158,7 +5541,7 @@
 	traverseErrorPrototypeChain$1.traverseErrorPrototypeChain = traverseErrorPrototypeChain;
 
 	getErrorNames$1.getErrorNames = void 0;
-	const types_1$1 = es2018$7;
+	const types_1$1 = es2018$5;
 	const traverse_error_prototype_chain_1 = traverseErrorPrototypeChain$1;
 	function* getErrorNames(err) {
 	    var _a;
@@ -5179,7 +5562,7 @@
 	var serializableError = {};
 
 	serializableError.isSerializableError = void 0;
-	const types_1 = es2018$7;
+	const types_1 = es2018$5;
 	function isSerializableError(val) {
 	    return (0, types_1.isObject)(val)
 	        && (0, types_1.isString)(val.name)
@@ -5197,7 +5580,7 @@
 	customError.CustomError = void 0;
 		const iterable_operator_1 = requireEs2018$1();
 		const get_error_names_1 = getErrorNames$1;
-		const types_1 = es2018$7;
+		const types_1 = es2018$5;
 		const serializable_error_1 = serializableError;
 		class CustomError extends Error {
 		    get name() {
@@ -5267,7 +5650,7 @@
 
 	var hydrate$1 = {};
 
-	var es2018$3 = {};
+	var es2018$4 = {};
 
 	var pass$1 = {};
 
@@ -5287,10 +5670,10 @@
 		    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 		};__exportStar(pass$1, exports);
 		
-	} (es2018$3));
+	} (es2018$4));
 
 	hydrate$1.hydrate = void 0;
-	const pass_1 = es2018$3;
+	const pass_1 = es2018$4;
 	function hydrate(err) {
 	    var _a;
 	    const errorNames = [err.name, ...err.ancestors]
@@ -5336,7 +5719,7 @@
 	var hasRequiredEs2018;
 
 	function requireEs2018 () {
-		if (hasRequiredEs2018) return es2018$6;
+		if (hasRequiredEs2018) return es2018$9;
 		hasRequiredEs2018 = 1;
 		(function (exports) {
 			var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -5361,82 +5744,121 @@
 			__exportStar(getErrorNames$1, exports);
 			__exportStar(traverseErrorPrototypeChain$1, exports);
 			
-	} (es2018$6));
-		return es2018$6;
+	} (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$7.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$7.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]);
-	}
-
-	function useStateCycle(stateList, initialStateIndex = 0) {
-	    const [index, setIndex] = react.exports.useState(initialStateIndex);
-	    return [
-	        stateList[index],
-	        () => setIndex(index => {
-	            if (index + 1 < stateList.length) {
-	                return index + 1;
-	            }
-	            else {
+	    return {
+	        selectedIndexes: react.exports.useMemo(() => es2018Exports.toArray(selectedIndexes), [selectedIndexes]),
+	        optionStates: react.exports.useMemo(createOptionStates, [options, selectedIndexes]),
+	        toggle: react.exports.useCallback(toggle, [selectedIndexes]),
+	        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(orderedStates, initialStateIndex = 0) {
+	    const [index, setIndex] = react.exports.useState(initialStateIndex);
+	    return [orderedStates[index], react.exports.useCallback(next, [orderedStates])];
+	    function next() {
+	        setIndex(index => {
+	            if (index + 1 < orderedStates.length) {
+	                return index + 1;
+	            }
+	            else {
 	                return 0;
 	            }
-	        })
-	    ];
+	        });
+	    }
 	}
 
 	function useToggle(initialState = false) {
 	    const [state, setState] = react.exports.useState(initialState);
-	    const toggle = () => setState(state => !state);
-	    return [state, toggle];
+	    return [state, react.exports.useCallback(toggle, [])];
+	    function toggle() {
+	        setState(state => !state);
+	    }
 	}
 
 	function useResizeObserver(callback, refs) {
@@ -5445,7 +5867,7 @@
 	        const observer = new ResizeObserver(callback);
 	        refs
 	            .map(x => x.current)
-	            .filter(es2018$7.isntNull)
+	            .filter(es2018$5.isntNull)
 	            .forEach(x => observer.observe(x));
 	        return () => observer.disconnect();
 	    }, deps);
@@ -5453,37 +5875,38 @@
 
 	function useStep(steps, initialStepIndex = 0) {
 	    const [index, setIndex] = react.exports.useState(initialStepIndex);
-	    return [
-	        steps[index],
-	        () => {
-	            setIndex(index => {
-	                if (index === steps.length - 1) {
-	                    return index;
-	                }
-	                else {
-	                    return index + 1;
-	                }
-	            });
-	        },
-	        () => {
-	            setIndex(index => {
-	                if (index === 0) {
-	                    return index;
-	                }
-	                else {
-	                    return index - 1;
-	                }
-	            });
-	        }
-	    ];
+	    return [steps[index], react.exports.useCallback(next, [steps]), react.exports.useCallback(previous, [])];
+	    function next() {
+	        setIndex(index => {
+	            if (index === steps.length - 1) {
+	                return index;
+	            }
+	            else {
+	                return index + 1;
+	            }
+	        });
+	    }
+	    function previous() {
+	        setIndex(index => {
+	            if (index === 0) {
+	                return index;
+	            }
+	            else {
+	                return index - 1;
+	            }
+	        });
+	    }
 	}
 
 	function useForceUpdate() {
 	    const [, setState] = react.exports.useState({});
-	    return () => setState({});
+	    return react.exports.useCallback(forceUpdate, []);
+	    function forceUpdate() {
+	        setState({});
+	    }
 	}
 
-	var es2018$2 = {};
+	var es2018$3 = {};
 
 	var box = {};
 
@@ -5717,11 +6140,11 @@
 
 	var expirableMap = {};
 
-	var es2018$1 = {};
+	var es2018$2 = {};
 
 	var exponentialBackoff = {};
 
-	var es2018 = {};
+	var es2018$1 = {};
 
 	var random$1 = {};
 
@@ -5765,10 +6188,10 @@
 		__exportStar(randomInt$1, exports);
 		__exportStar(randomIntInclusive$1, exports);
 		
-	} (es2018));
+	} (es2018$1));
 
 	exponentialBackoff.calculateExponentialBackoffTimeout = void 0;
-	const extra_rand_1 = es2018;
+	const extra_rand_1 = es2018$1;
 	function calculateExponentialBackoffTimeout({ baseTimeout, retries, maxTimeout = Infinity, factor = 2, jitter = true }) {
 	    const timeout = Math.min(factor ** retries * baseTimeout, maxTimeout);
 	    if (jitter) {
@@ -5883,10 +6306,10 @@
 		__exportStar(setTimeoutLoop$1, exports);
 		__exportStar(setDynamicTimeoutLoop$1, exports);
 		
-	} (es2018$1));
+	} (es2018$2));
 
 	expirableMap.ExpirableMap = void 0;
-	const extra_timers_1$1 = es2018$1;
+	const extra_timers_1$1 = es2018$2;
 	class ExpirableMap {
 	    constructor() {
 	        this.map = new Map();
@@ -5984,7 +6407,7 @@
 	tlruMap.TLRUMap = void 0;
 	const errors_1$1 = requireEs2018();
 	const iterable_operator_1$1 = requireEs2018$1();
-	const extra_timers_1 = es2018$1;
+	const extra_timers_1 = es2018$2;
 	class TLRUMap {
 	    constructor(limit) {
 	        this.map = new Map();
@@ -6223,13 +6646,13 @@
 
 	var Subscriber = {};
 
-	var isFunction$1 = {};
+	var isFunction$2 = {};
 
-	isFunction$1.isFunction = void 0;
-	function isFunction(value) {
+	isFunction$2.isFunction = void 0;
+	function isFunction$1(value) {
 	    return typeof value === 'function';
 	}
-	isFunction$1.isFunction = isFunction;
+	isFunction$2.isFunction = isFunction$1;
 
 	var Subscription$1 = {};
 
@@ -6306,7 +6729,7 @@
 	        to[j] = from[i];
 	    return to;
 	};Subscription$1.isSubscription = Subscription$1.EMPTY_SUBSCRIPTION = Subscription$1.Subscription = void 0;
-	var isFunction_1$p = isFunction$1;
+	var isFunction_1$p = isFunction$2;
 	var UnsubscriptionError_1 = UnsubscriptionError;
 	var arrRemove_1$7 = arrRemove$1;
 	var Subscription = (function () {
@@ -6599,7 +7022,7 @@
 		        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
 		    };
 		})();exports.EMPTY_OBSERVER = exports.SafeSubscriber = exports.Subscriber = void 0;
-		var isFunction_1 = isFunction$1;
+		var isFunction_1 = isFunction$2;
 		var Subscription_1 = Subscription$1;
 		var config_1 = config;
 		var reportUnhandledError_1 = reportUnhandledError$1;
@@ -6828,7 +7251,7 @@
 	var observable_1$2 = observable;
 	var pipe_1$2 = pipe$1;
 	var config_1 = config;
-	var isFunction_1$o = isFunction$1;
+	var isFunction_1$o = isFunction$2;
 	var errorContext_1$1 = errorContext$1;
 	var Observable = (function () {
 	    function Observable(subscribe) {
@@ -6932,7 +7355,7 @@
 	var lift = {};
 
 	lift.operate = lift.hasLift = void 0;
-	var isFunction_1$n = isFunction$1;
+	var isFunction_1$n = isFunction$2;
 	function hasLift(source) {
 	    return isFunction_1$n.isFunction(source === null || source === void 0 ? void 0 : source.lift);
 	}
@@ -8427,14 +8850,14 @@
 	var isScheduler$1 = {};
 
 	isScheduler$1.isScheduler = void 0;
-	var isFunction_1$m = isFunction$1;
+	var isFunction_1$m = isFunction$2;
 	function isScheduler(value) {
 	    return value && isFunction_1$m.isFunction(value.schedule);
 	}
 	isScheduler$1.isScheduler = isScheduler;
 
 	args.popNumber = args.popScheduler = args.popResultSelector = void 0;
-	var isFunction_1$l = isFunction$1;
+	var isFunction_1$l = isFunction$2;
 	var isScheduler_1$3 = isScheduler$1;
 	function last$2(arr) {
 	    return arr[arr.length - 1];
@@ -8465,33 +8888,33 @@
 	isArrayLike.isArrayLike = void 0;
 	isArrayLike.isArrayLike = (function (x) { return x && typeof x.length === 'number' && typeof x !== 'function'; });
 
-	var isPromise$1 = {};
+	var isPromise$2 = {};
 
-	isPromise$1.isPromise = void 0;
-	var isFunction_1$k = isFunction$1;
-	function isPromise(value) {
+	isPromise$2.isPromise = void 0;
+	var isFunction_1$k = isFunction$2;
+	function isPromise$1(value) {
 	    return isFunction_1$k.isFunction(value === null || value === void 0 ? void 0 : value.then);
 	}
-	isPromise$1.isPromise = isPromise;
+	isPromise$2.isPromise = isPromise$1;
 
 	var isInteropObservable$1 = {};
 
 	isInteropObservable$1.isInteropObservable = void 0;
 	var observable_1$1 = observable;
-	var isFunction_1$j = isFunction$1;
+	var isFunction_1$j = isFunction$2;
 	function isInteropObservable(input) {
 	    return isFunction_1$j.isFunction(input[observable_1$1.observable]);
 	}
 	isInteropObservable$1.isInteropObservable = isInteropObservable;
 
-	var isAsyncIterable$1 = {};
+	var isAsyncIterable$2 = {};
 
-	isAsyncIterable$1.isAsyncIterable = void 0;
-	var isFunction_1$i = isFunction$1;
-	function isAsyncIterable(obj) {
+	isAsyncIterable$2.isAsyncIterable = void 0;
+	var isFunction_1$i = isFunction$2;
+	function isAsyncIterable$1(obj) {
 	    return Symbol.asyncIterator && isFunction_1$i.isFunction(obj === null || obj === void 0 ? void 0 : obj[Symbol.asyncIterator]);
 	}
-	isAsyncIterable$1.isAsyncIterable = isAsyncIterable;
+	isAsyncIterable$2.isAsyncIterable = isAsyncIterable$1;
 
 	var throwUnobservableError = {};
 
@@ -8501,7 +8924,7 @@
 	}
 	throwUnobservableError.createInvalidObservableTypeError = createInvalidObservableTypeError;
 
-	var isIterable$1 = {};
+	var isIterable$2 = {};
 
 	var iterator = {};
 
@@ -8515,13 +8938,13 @@
 	iterator.getSymbolIterator = getSymbolIterator;
 	iterator.iterator = getSymbolIterator();
 
-	isIterable$1.isIterable = void 0;
+	isIterable$2.isIterable = void 0;
 	var iterator_1$1 = iterator;
-	var isFunction_1$h = isFunction$1;
-	function isIterable(input) {
+	var isFunction_1$h = isFunction$2;
+	function isIterable$1(input) {
 	    return isFunction_1$h.isFunction(input === null || input === void 0 ? void 0 : input[iterator_1$1.iterator]);
 	}
-	isIterable$1.isIterable = isIterable;
+	isIterable$2.isIterable = isIterable$1;
 
 	var isReadableStreamLike$1 = {};
 
@@ -8564,7 +8987,7 @@
 	    function reject(value) { resume("throw", value); }
 	    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
 	};isReadableStreamLike$1.isReadableStreamLike = isReadableStreamLike$1.readableStreamLikeToAsyncGenerator = void 0;
-	var isFunction_1$g = isFunction$1;
+	var isFunction_1$g = isFunction$2;
 	function readableStreamLikeToAsyncGenerator(readableStream) {
 	    return __asyncGenerator(this, arguments, function readableStreamLikeToAsyncGenerator_1() {
 	        var reader, _a, value, done;
@@ -8658,14 +9081,14 @@
 	    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 	};innerFrom$1.fromReadableStreamLike = innerFrom$1.fromAsyncIterable = innerFrom$1.fromIterable = innerFrom$1.fromPromise = innerFrom$1.fromArrayLike = innerFrom$1.fromInteropObservable = innerFrom$1.innerFrom = void 0;
 	var isArrayLike_1$2 = isArrayLike;
-	var isPromise_1$1 = isPromise$1;
+	var isPromise_1$1 = isPromise$2;
 	var Observable_1$j = Observable$1;
 	var isInteropObservable_1$1 = isInteropObservable$1;
-	var isAsyncIterable_1$1 = isAsyncIterable$1;
+	var isAsyncIterable_1$1 = isAsyncIterable$2;
 	var throwUnobservableError_1$1 = throwUnobservableError;
-	var isIterable_1$1 = isIterable$1;
+	var isIterable_1$1 = isIterable$2;
 	var isReadableStreamLike_1$2 = isReadableStreamLike$1;
-	var isFunction_1$f = isFunction$1;
+	var isFunction_1$f = isFunction$2;
 	var reportUnhandledError_1 = reportUnhandledError$1;
 	var observable_1 = observable;
 	function innerFrom(input) {
@@ -8901,7 +9324,7 @@
 	scheduleIterable$1.scheduleIterable = void 0;
 	var Observable_1$h = Observable$1;
 	var iterator_1 = iterator;
-	var isFunction_1$e = isFunction$1;
+	var isFunction_1$e = isFunction$2;
 	var executeSchedule_1$5 = executeSchedule$1;
 	function scheduleIterable(input, scheduler) {
 	    return new Observable_1$h.Observable(function (subscriber) {
@@ -8976,10 +9399,10 @@
 	var scheduleIterable_1$1 = scheduleIterable$1;
 	var scheduleAsyncIterable_1 = scheduleAsyncIterable$1;
 	var isInteropObservable_1 = isInteropObservable$1;
-	var isPromise_1 = isPromise$1;
+	var isPromise_1 = isPromise$2;
 	var isArrayLike_1$1 = isArrayLike;
-	var isIterable_1 = isIterable$1;
-	var isAsyncIterable_1 = isAsyncIterable$1;
+	var isIterable_1 = isIterable$2;
+	var isAsyncIterable_1 = isAsyncIterable$2;
 	var throwUnobservableError_1 = throwUnobservableError;
 	var isReadableStreamLike_1 = isReadableStreamLike$1;
 	var scheduleReadableStreamLike_1 = scheduleReadableStreamLike$1;
@@ -9033,7 +9456,7 @@
 
 	throwError$1.throwError = void 0;
 	var Observable_1$f = Observable$1;
-	var isFunction_1$d = isFunction$1;
+	var isFunction_1$d = isFunction$2;
 	function throwError(errorOrErrorFactory, scheduler) {
 	    var errorFactory = isFunction_1$d.isFunction(errorOrErrorFactory) ? errorOrErrorFactory : function () { return errorOrErrorFactory; };
 	    var init = function (subscriber) { return subscriber.error(errorFactory()); };
@@ -9046,7 +9469,7 @@
 		var empty_1 = empty;
 		var of_1 = of$1;
 		var throwError_1 = throwError$1;
-		var isFunction_1 = isFunction$1;
+		var isFunction_1 = isFunction$2;
 		(function (NotificationKind) {
 		    NotificationKind["NEXT"] = "N";
 		    NotificationKind["ERROR"] = "E";
@@ -9121,7 +9544,7 @@
 
 	isObservable$1.isObservable = void 0;
 	var Observable_1$e = Observable$1;
-	var isFunction_1$c = isFunction$1;
+	var isFunction_1$c = isFunction$2;
 	function isObservable(obj) {
 	    return !!obj && (obj instanceof Observable_1$e.Observable || (isFunction_1$c.isFunction(obj.lift) && isFunction_1$c.isFunction(obj.subscribe)));
 	}
@@ -9234,18 +9657,18 @@
 
 	var timeout = {};
 
-	var isDate = {};
+	var isDate$1 = {};
 
-	isDate.isValidDate = void 0;
+	isDate$1.isValidDate = void 0;
 	function isValidDate(value) {
 	    return value instanceof Date && !isNaN(value);
 	}
-	isDate.isValidDate = isValidDate;
+	isDate$1.isValidDate = isValidDate;
 
 	(function (exports) {
 	exports.timeout = exports.TimeoutError = void 0;
 		var async_1 = async;
-		var isDate_1 = isDate;
+		var isDate_1 = isDate$1;
 		var lift_1 = lift;
 		var innerFrom_1 = innerFrom$1;
 		var createErrorClass_1 = createErrorClass$1;
@@ -9349,9 +9772,9 @@
 	    return to;
 	};mapOneOrManyArgs$1.mapOneOrManyArgs = void 0;
 	var map_1$5 = map$1;
-	var isArray$2 = Array.isArray;
+	var isArray$3 = Array.isArray;
 	function callOrApply(fn, args) {
-	    return isArray$2(args) ? fn.apply(void 0, __spreadArray$f([], __read$g(args))) : fn(args);
+	    return isArray$3(args) ? fn.apply(void 0, __spreadArray$f([], __read$g(args))) : fn(args);
 	}
 	function mapOneOrManyArgs(fn) {
 	    return map_1$5.map(function (args) { return callOrApply(fn, args); });
@@ -9479,12 +9902,12 @@
 	var argsArgArrayOrObject$1 = {};
 
 	argsArgArrayOrObject$1.argsArgArrayOrObject = void 0;
-	var isArray$1 = Array.isArray;
+	var isArray$2 = Array.isArray;
 	var getPrototypeOf = Object.getPrototypeOf, objectProto = Object.prototype, getKeys = Object.keys;
 	function argsArgArrayOrObject(args) {
 	    if (args.length === 1) {
 	        var first_1 = args[0];
-	        if (isArray$1(first_1)) {
+	        if (isArray$2(first_1)) {
 	            return { args: first_1, keys: null };
 	        }
 	        if (isPOJO(first_1)) {
@@ -9661,7 +10084,7 @@
 	var innerFrom_1$p = innerFrom$1;
 	var lift_1$10 = lift;
 	var mergeInternals_1$2 = mergeInternals$1;
-	var isFunction_1$b = isFunction$1;
+	var isFunction_1$b = isFunction$2;
 	function mergeMap(project, resultSelector, concurrent) {
 	    if (concurrent === void 0) { concurrent = Infinity; }
 	    if (isFunction_1$b.isFunction(resultSelector)) {
@@ -9819,7 +10242,7 @@
 	var Observable_1$8 = Observable$1;
 	var mergeMap_1$5 = mergeMap$1;
 	var isArrayLike_1 = isArrayLike;
-	var isFunction_1$a = isFunction$1;
+	var isFunction_1$a = isFunction$2;
 	var mapOneOrManyArgs_1$3 = mapOneOrManyArgs$1;
 	var nodeEventEmitterMethods = ['addListener', 'removeListener'];
 	var eventTargetMethods = ['addEventListener', 'removeEventListener'];
@@ -9878,7 +10301,7 @@
 
 	fromEventPattern$1.fromEventPattern = void 0;
 	var Observable_1$7 = Observable$1;
-	var isFunction_1$9 = isFunction$1;
+	var isFunction_1$9 = isFunction$2;
 	var mapOneOrManyArgs_1$2 = mapOneOrManyArgs$1;
 	function fromEventPattern(addHandler, removeHandler, resultSelector) {
 	    if (resultSelector) {
@@ -9993,7 +10416,7 @@
 	var Observable_1$6 = Observable$1;
 	var async_1$a = async;
 	var isScheduler_1 = isScheduler$1;
-	var isDate_1$1 = isDate;
+	var isDate_1$1 = isDate$1;
 	function timer(dueTime, intervalOrScheduler, scheduler) {
 	    if (dueTime === void 0) { dueTime = 0; }
 	    if (scheduler === void 0) { scheduler = async_1$a.async; }
@@ -10088,9 +10511,9 @@
 	var argsOrArgArray$1 = {};
 
 	argsOrArgArray$1.argsOrArgArray = void 0;
-	var isArray = Array.isArray;
+	var isArray$1 = Array.isArray;
 	function argsOrArgArray(args) {
-	    return args.length === 1 && isArray(args[0]) ? args[0] : args;
+	    return args.length === 1 && isArray$1(args[0]) ? args[0] : args;
 	}
 	argsOrArgArray$1.argsOrArgArray = argsOrArgArray;
 
@@ -10901,7 +11324,7 @@
 
 	concatMap$1.concatMap = void 0;
 	var mergeMap_1$3 = mergeMap$1;
-	var isFunction_1$8 = isFunction$1;
+	var isFunction_1$8 = isFunction$2;
 	function concatMap(project, resultSelector) {
 	    return isFunction_1$8.isFunction(resultSelector) ? mergeMap_1$3.mergeMap(project, resultSelector, 1) : mergeMap_1$3.mergeMap(project, 1);
 	}
@@ -10911,7 +11334,7 @@
 
 	concatMapTo$1.concatMapTo = void 0;
 	var concatMap_1 = concatMap$1;
-	var isFunction_1$7 = isFunction$1;
+	var isFunction_1$7 = isFunction$2;
 	function concatMapTo(innerObservable, resultSelector) {
 	    return isFunction_1$7.isFunction(resultSelector) ? concatMap_1.concatMap(function () { return innerObservable; }, resultSelector) : concatMap_1.concatMap(function () { return innerObservable; });
 	}
@@ -11699,7 +12122,7 @@
 
 	max$1.max = void 0;
 	var reduce_1$1 = reduce$1;
-	var isFunction_1$6 = isFunction$1;
+	var isFunction_1$6 = isFunction$2;
 	function max(comparer) {
 	    return reduce_1$1.reduce(isFunction_1$6.isFunction(comparer) ? function (x, y) { return (comparer(x, y) > 0 ? x : y); } : function (x, y) { return (x > y ? x : y); });
 	}
@@ -11715,7 +12138,7 @@
 
 	mergeMapTo$1.mergeMapTo = void 0;
 	var mergeMap_1 = mergeMap$1;
-	var isFunction_1$5 = isFunction$1;
+	var isFunction_1$5 = isFunction$2;
 	function mergeMapTo(innerObservable, resultSelector, concurrent) {
 	    if (concurrent === void 0) { concurrent = Infinity; }
 	    if (isFunction_1$5.isFunction(resultSelector)) {
@@ -11823,7 +12246,7 @@
 
 	min$1.min = void 0;
 	var reduce_1 = reduce$1;
-	var isFunction_1$4 = isFunction$1;
+	var isFunction_1$4 = isFunction$2;
 	function min(comparer) {
 	    return reduce_1.reduce(isFunction_1$4.isFunction(comparer) ? function (x, y) { return (comparer(x, y) < 0 ? x : y); } : function (x, y) { return (x < y ? x : y); });
 	}
@@ -11833,7 +12256,7 @@
 
 	multicast$1.multicast = void 0;
 	var ConnectableObservable_1$2 = ConnectableObservable$1;
-	var isFunction_1$3 = isFunction$1;
+	var isFunction_1$3 = isFunction$2;
 	var connect_1$1 = connect$1;
 	function multicast(subjectOrSubjectFactory, selector) {
 	    var subjectFactory = isFunction_1$3.isFunction(subjectOrSubjectFactory) ? subjectOrSubjectFactory : function () { return subjectOrSubjectFactory; };
@@ -11936,7 +12359,7 @@
 	publishReplay$1.publishReplay = void 0;
 	var ReplaySubject_1$1 = ReplaySubject$1;
 	var multicast_1 = multicast$1;
-	var isFunction_1$2 = isFunction$1;
+	var isFunction_1$2 = isFunction$2;
 	function publishReplay(bufferSize, windowTime, selectorOrScheduler, timestampProvider) {
 	    if (selectorOrScheduler && !isFunction_1$2.isFunction(selectorOrScheduler)) {
 	        timestampProvider = selectorOrScheduler;
@@ -12593,7 +13016,7 @@
 
 	switchMapTo$1.switchMapTo = void 0;
 	var switchMap_1$1 = switchMap$1;
-	var isFunction_1$1 = isFunction$1;
+	var isFunction_1$1 = isFunction$2;
 	function switchMapTo(innerObservable, resultSelector) {
 	    return isFunction_1$1.isFunction(resultSelector) ? switchMap_1$1.switchMap(function () { return innerObservable; }, resultSelector) : switchMap_1$1.switchMap(function () { return innerObservable; });
 	}
@@ -12651,7 +13074,7 @@
 	var tap$1 = {};
 
 	tap$1.tap = void 0;
-	var isFunction_1 = isFunction$1;
+	var isFunction_1 = isFunction$2;
 	var lift_1$8 = lift;
 	var OperatorSubscriber_1$7 = OperatorSubscriber$1;
 	var identity_1$1 = identity$1;
@@ -12795,7 +13218,7 @@
 
 	timeoutWith$1.timeoutWith = void 0;
 	var async_1$1 = async;
-	var isDate_1 = isDate;
+	var isDate_1 = isDate$1;
 	var timeout_1 = timeout;
 	function timeoutWith(due, withObservable, scheduler) {
 	    var first;
@@ -13624,11 +14047,371 @@
 		
 	} (cjs));
 
+	var es2018 = {};
+
+	var array = {};
+
+	array.isntEmptyArray = array.isEmptyArray = array.isntArray = array.isArray = void 0;
+	function isArray(val) {
+	    return Array.isArray(val);
+	}
+	array.isArray = isArray;
+	function isntArray(val) {
+	    return !isArray(val);
+	}
+	array.isntArray = isntArray;
+	function isEmptyArray(val) {
+	    return val.length === 0;
+	}
+	array.isEmptyArray = isEmptyArray;
+	function isntEmptyArray(val) {
+	    return val.length !== 0;
+	}
+	array.isntEmptyArray = isntEmptyArray;
+
+	var asyncIterable = {};
+
+	var _null = {};
+
+	_null.isntNull = _null.isNull = void 0;
+	function isNull(val) {
+	    return val === null;
+	}
+	_null.isNull = isNull;
+	function isntNull(val) {
+	    return !isNull(val);
+	}
+	_null.isntNull = isntNull;
+
+	var _undefined = {};
+
+	_undefined.isntUndefined = _undefined.isUndefined = void 0;
+	function isUndefined(val) {
+	    return val === undefined;
+	}
+	_undefined.isUndefined = isUndefined;
+	function isntUndefined(val) {
+	    return !isUndefined(val);
+	}
+	_undefined.isntUndefined = isntUndefined;
+
+	var _function = {};
+
+	_function.isntFunction = _function.isFunction = void 0;
+	function isFunction(val) {
+	    return typeof val === 'function';
+	}
+	_function.isFunction = isFunction;
+	function isntFunction(val) {
+	    return !isFunction(val);
+	}
+	_function.isntFunction = isntFunction;
+
+	asyncIterable.isntAsyncIterable = asyncIterable.isAsyncIterable = void 0;
+	const null_1$2 = _null;
+	const undefined_1$1 = _undefined;
+	const function_1$2 = _function;
+	function isAsyncIterable(val) {
+	    return (0, null_1$2.isntNull)(val)
+	        && (0, undefined_1$1.isntUndefined)(val)
+	        && (0, function_1$2.isFunction)(val[Symbol.asyncIterator]);
+	}
+	asyncIterable.isAsyncIterable = isAsyncIterable;
+	function isntAsyncIterable(val) {
+	    return !isAsyncIterable(val);
+	}
+	asyncIterable.isntAsyncIterable = isntAsyncIterable;
+
+	var bigint = {};
+
+	bigint.isntBigInt = bigint.isBigInt = void 0;
+	function isBigInt(val) {
+	    return typeof val === 'bigint';
+	}
+	bigint.isBigInt = isBigInt;
+	function isntBigInt(val) {
+	    return !isBigInt(val);
+	}
+	bigint.isntBigInt = isntBigInt;
+
+	var boolean = {};
+
+	boolean.isntBoolean = boolean.isBoolean = void 0;
+	function isBoolean(val) {
+	    return typeof val === 'boolean';
+	}
+	boolean.isBoolean = isBoolean;
+	function isntBoolean(val) {
+	    return !isBoolean(val);
+	}
+	boolean.isntBoolean = isntBoolean;
+
+	var char = {};
+
+	var string = {};
+
+	string.isntString = string.isString = void 0;
+	function isString(val) {
+	    return typeof val === 'string';
+	}
+	string.isString = isString;
+	function isntString(val) {
+	    return !isString(val);
+	}
+	string.isntString = isntString;
+
+	char.isntChar = char.isChar = void 0;
+	const string_1$1 = string;
+	function isChar(val) {
+	    return (0, string_1$1.isString)(val)
+	        && val.length === 1;
+	}
+	char.isChar = isChar;
+	function isntChar(val) {
+	    return !isChar(val);
+	}
+	char.isntChar = isntChar;
+
+	var date = {};
+
+	date.isntDate = date.isDate = void 0;
+	function isDate(val) {
+	    return val instanceof Date;
+	}
+	date.isDate = isDate;
+	function isntDate(val) {
+	    return !isDate(val);
+	}
+	date.isntDate = isntDate;
+
+	var _enum = {};
+
+	_enum.inEnum = void 0;
+	function inEnum(val, _enum) {
+	    return Object.values(_enum).includes(val);
+	}
+	_enum.inEnum = inEnum;
+
+	var error = {};
+
+	error.isntError = error.isError = void 0;
+	function isError(val) {
+	    return val instanceof Error;
+	}
+	error.isError = isError;
+	function isntError(val) {
+	    return !isError(val);
+	}
+	error.isntError = isntError;
+
+	var falsy = {};
+
+	falsy.isntFalsy = falsy.isFalsy = void 0;
+	function isFalsy(val) {
+	    return !val;
+	}
+	falsy.isFalsy = isFalsy;
+	function isntFalsy(val) {
+	    return !isFalsy(val);
+	}
+	falsy.isntFalsy = isntFalsy;
+
+	var iterable = {};
+
+	iterable.isntIterable = iterable.isIterable = void 0;
+	const null_1$1 = _null;
+	const undefined_1 = _undefined;
+	const function_1$1 = _function;
+	function isIterable(val) {
+	    return (0, null_1$1.isntNull)(val)
+	        && (0, undefined_1.isntUndefined)(val)
+	        && (0, function_1$1.isFunction)(val[Symbol.iterator]);
+	}
+	iterable.isIterable = isIterable;
+	function isntIterable(val) {
+	    return !isIterable(val);
+	}
+	iterable.isntIterable = isntIterable;
+
+	var json = {};
+
+	var number = {};
+
+	number.isntNaN = number.isNaN = number.isNegativeInfinity = number.isPositiveInfinity = number.isFinite = number.isntNumber = number.isNumber = void 0;
+	function isNumber(val) {
+	    return typeof val === 'number';
+	}
+	number.isNumber = isNumber;
+	function isntNumber(val) {
+	    return !isNumber(val);
+	}
+	number.isntNumber = isntNumber;
+	function isFinite(val) {
+	    return Number.isFinite(val);
+	}
+	number.isFinite = isFinite;
+	function isPositiveInfinity(val) {
+	    return val === Infinity;
+	}
+	number.isPositiveInfinity = isPositiveInfinity;
+	function isNegativeInfinity(val) {
+	    return val === -Infinity;
+	}
+	number.isNegativeInfinity = isNegativeInfinity;
+	function isNaN$1(val) {
+	    return Number.isNaN(val);
+	}
+	number.isNaN = isNaN$1;
+	function isntNaN(val) {
+	    return !isNaN$1(val);
+	}
+	number.isntNaN = isntNaN;
+
+	var object = {};
+
+	var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+	    return (mod && mod.__esModule) ? mod : { "default": mod };
+	};object.isntEmptyObject = object.isEmptyObject = object.isntPlainObject = object.isPlainObject = object.isntObject = object.isObject = void 0;
+	const isPlainObject_1 = __importDefault(isPlainObject_1$3);
+	function isObject(val) {
+	    return val !== null
+	        && typeof val === 'object';
+	}
+	object.isObject = isObject;
+	function isntObject(val) {
+	    return !isObject(val);
+	}
+	object.isntObject = isntObject;
+	function isPlainObject(val) {
+	    return (0, isPlainObject_1.default)(val);
+	}
+	object.isPlainObject = isPlainObject;
+	function isntPlainObject(val) {
+	    return !isPlainObject(val);
+	}
+	object.isntPlainObject = isntPlainObject;
+	function isEmptyObject(val) {
+	    return Object.keys(val).length === 0;
+	}
+	object.isEmptyObject = isEmptyObject;
+	function isntEmptyObject(val) {
+	    return Object.keys(val).length !== 0;
+	}
+	object.isntEmptyObject = isntEmptyObject;
+
+	json.isntJsonable = json.isJsonable = json.isntJson = json.isJson = void 0;
+	const null_1 = _null;
+	const boolean_1 = boolean;
+	const string_1 = string;
+	const number_1 = number;
+	const array_1 = array;
+	const object_1$1 = object;
+	function isJson(val) {
+	    return (0, null_1.isNull)(val)
+	        || (0, boolean_1.isBoolean)(val)
+	        || (0, string_1.isString)(val)
+	        || (0, number_1.isNumber)(val)
+	        || ((0, array_1.isArray)(val) && val.every(isJson))
+	        || ((0, object_1$1.isPlainObject)(val) && Object.values(val).every(isJson));
+	}
+	json.isJson = isJson;
+	function isntJson(val) {
+	    return !isJson(val);
+	}
+	json.isntJson = isntJson;
+	function isJsonable(val) {
+	    try {
+	        JSON.stringify(val);
+	        return true;
+	    }
+	    catch (_a) {
+	        return false;
+	    }
+	}
+	json.isJsonable = isJsonable;
+	function isntJsonable(val) {
+	    return !isntJsonable();
+	}
+	json.isntJsonable = isntJsonable;
+
+	var promise = {};
+
+	promise.isPromiseLike = promise.isntPromiseLike = promise.isntPromise = promise.isPromise = void 0;
+	const object_1 = object;
+	const function_1 = _function;
+	function isPromise(val) {
+	    return val instanceof Promise;
+	}
+	promise.isPromise = isPromise;
+	function isntPromise(val) {
+	    return !isPromise(val);
+	}
+	promise.isntPromise = isntPromise;
+	function isntPromiseLike(val) {
+	    return !isPromiseLike(val);
+	}
+	promise.isntPromiseLike = isntPromiseLike;
+	function isPromiseLike(val) {
+	    return (0, object_1.isObject)(val)
+	        && (0, function_1.isFunction)(val.then);
+	}
+	promise.isPromiseLike = isPromiseLike;
+
+	var url = {};
+
+	url.isAbsoluteURL = void 0;
+	function isAbsoluteURL(str) {
+	    try {
+	        new URL(str);
+	        return true;
+	    }
+	    catch (_a) {
+	        return false;
+	    }
+	}
+	url.isAbsoluteURL = isAbsoluteURL;
+
+	(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, exports);
+		__exportStar(asyncIterable, exports);
+		__exportStar(bigint, exports);
+		__exportStar(boolean, exports);
+		__exportStar(char, exports);
+		__exportStar(date, exports);
+		__exportStar(_enum, exports);
+		__exportStar(error, exports);
+		__exportStar(falsy, exports);
+		__exportStar(_function, exports);
+		__exportStar(iterable, exports);
+		__exportStar(json, exports);
+		__exportStar(_null, exports);
+		__exportStar(number, exports);
+		__exportStar(object, exports);
+		__exportStar(promise, exports);
+		__exportStar(string, exports);
+		__exportStar(_undefined, exports);
+		__exportStar(url, exports);
+		
+	} (es2018));
+
 	(function (exports) {
 	exports.BadEventError = exports.ObservableFiniteStateMachine = void 0;
 		const finite_state_machine_1 = finiteStateMachine;
 		const rxjs_1 = cjs;
-		const types_1 = es2018$7;
+		const types_1 = es2018;
 		class ObservableFiniteStateMachine extends finite_state_machine_1.FiniteStateMachine {
 		    constructor() {
 		        super(...arguments);
@@ -13680,11 +14463,11 @@
 		__exportStar(finiteStateMachine, exports);
 		__exportStar(observableFiniteStateMachine, exports);
 		
-	} (es2018$2));
+	} (es2018$3));
 
 	function useFiniteStateMachine(schema, initialState) {
 	    const forceUpdate = useForceUpdate();
-	    const fsm = react.exports.useMemo(() => new es2018$2.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());
@@ -13693,9 +14476,10 @@
 	    return fsm;
 	}
 
-	exports.ObservableFiniteStateMachine = es2018$2.ObservableFiniteStateMachine;
+	exports.ObservableFiniteStateMachine = es2018$3.ObservableFiniteStateMachine;
 	exports.useFiniteStateMachine = useFiniteStateMachine;
 	exports.useForceUpdate = useForceUpdate;
+	exports.useIIFE = useIIFE;
 	exports.useIncrement = useIncrement;
 	exports.useIsFirstRender = useIsFirstRender;
 	exports.useIsMounted = useIsMounted;
@@ -13707,6 +14491,7 @@
 	exports.useStateCycle = useStateCycle;
 	exports.useStep = useStep;
 	exports.useToggle = useToggle;
+	exports.useUnmount = useUnmount;
 	exports.useUpdateEffect = useUpdateEffect;
 
 	Object.defineProperty(exports, '__esModule', { value: true });