extra-react-hooks 0.1.14 → 0.2.1

package/dist/es2018/index.mjs

@@ -2485,13 +2485,13 @@ function requireReact_development () {
 
 function useIncrement(initialValue) {
     const [value, setValue] = react.exports.useState(initialValue);
-    const increment = react.exports.useCallback((step = 1) => {
+    return [value, increment, 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) {
@@ -2529,6 +2529,12 @@ function useIsFirstRender() {
     return () => state.current === State.First;
 }
 
+function useRenderCounter() {
+    const counter = react.exports.useRef(0);
+    counter.current++;
+    return counter.current;
+}
+
 function useUpdateEffect(effect, deps) {
     const isFirstRender = useIsFirstRender();
     react.exports.useEffect(() => {
@@ -2538,227 +2544,227 @@ function useUpdateEffect(effect, deps) {
     }, deps);
 }
 
-var es2018$7 = {};
+var es2018$9 = {};
 
-var array = {};
+var array$2 = {};
 
-array.isntEmptyArray = array.isEmptyArray = array.isntArray = array.isArray = void 0;
-function isArray$3(val) {
+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. */
 
@@ -2986,7 +2992,7 @@ var objectCtorString = funcToString.call(Object);
  * _.isPlainObject(Object.create(null));
  * // => true
  */
-function isPlainObject$1(value) {
+function isPlainObject$3(value) {
   if (!isObjectLike(value) || baseGetTag(value) != objectTag) {
     return false;
   }
@@ -2999,59 +3005,59 @@ function isPlainObject$1(value) {
     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;
@@ -3060,39 +3066,39 @@ function isJsonable(val) {
         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;
@@ -3101,7 +3107,19 @@ function isAbsoluteURL(str) {
         return false;
     }
 }
-url.isAbsoluteURL = isAbsoluteURL;
+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) {
@@ -3117,39 +3135,40 @@ url.isAbsoluteURL = isAbsoluteURL;
 	}));
 	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);
+	};__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);
+	__exportStar(regexp, exports);
 	
-} (es2018$7));
+} (es2018$9));
 
-var es2018$6 = {};
+var es2018$8 = {};
 
 var customError = {};
 
-var es2018$5 = {};
+var es2018$7 = {};
 
 var middleware = {};
 
 var chunkAsync = {};
 
-var es2018$4 = {};
+var es2018$6 = {};
 
 var go$1 = {};
 
@@ -3171,7 +3190,7 @@ go$1.go = go;
 	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 	};__exportStar(go$1, exports);
 	
-} (es2018$4));
+} (es2018$6));
 
 var hasRequiredChunkAsync;
 
@@ -3179,7 +3198,7 @@ function requireChunkAsync () {
 	if (hasRequiredChunkAsync) return chunkAsync;
 	hasRequiredChunkAsync = 1;
 chunkAsync.chunkAsync = void 0;
-	const go_1 = es2018$4;
+	const go_1 = es2018$6;
 	const errors_1 = requireEs2018();
 	function chunkAsync$1(iterable, size) {
 	    (0, errors_1.assert)(Number.isInteger(size), 'The parameter size must be an integer');
@@ -3204,47 +3223,407 @@ chunkAsync.chunkAsync = void 0;
 
 var chunkByAsync$1 = {};
 
-chunkByAsync$1.chunkByAsync = void 0;
-const types_1$j = es2018$7;
-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 es2018$5 = {};
 
-var chunkBy$1 = {};
+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;
+
+(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);
+	
+} (es2018$5));
+
+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);
+    }
+    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 chunkBy$1 = {};
 
 chunkBy$1.chunkBy = void 0;
 function* chunkBy(iterable, predicate) {
@@ -3271,7 +3650,7 @@ function requireChunk () {
 	if (hasRequiredChunk) return chunk;
 	hasRequiredChunk = 1;
 chunk.chunk = void 0;
-	const go_1 = es2018$4;
+	const go_1 = es2018$6;
 	const errors_1 = requireEs2018();
 	function chunk$1(iterable, size) {
 	    (0, errors_1.assert)(Number.isInteger(size), 'The parameter size must be an integer');
@@ -3297,8 +3676,8 @@ chunk.chunk = void 0;
 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$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]) {
@@ -3320,7 +3699,7 @@ concatAsync$1.concatAsync = concatAsync;
 var concat$5 = {};
 
 concat$5.concat = void 0;
-const go_1 = es2018$4;
+const go_1 = es2018$6;
 function concat$4(iterable, ...otherIterables) {
     return (0, go_1.go)(function* () {
         for (const iter of [iterable, ...otherIterables]) {
@@ -3354,7 +3733,7 @@ function requireDropAsync () {
 	if (hasRequiredDropAsync) return dropAsync;
 	hasRequiredDropAsync = 1;
 dropAsync.dropAsync = void 0;
-	const go_1 = es2018$4;
+	const go_1 = es2018$6;
 	const utils_1 = utils;
 	const errors_1 = requireEs2018();
 	function dropAsync$1(iterable, count) {
@@ -3397,7 +3776,7 @@ function requireDropRightAsync () {
 	if (hasRequiredDropRightAsync) return dropRightAsync;
 	hasRequiredDropRightAsync = 1;
 dropRightAsync.dropRightAsync = void 0;
-	const go_1 = es2018$4;
+	const go_1 = es2018$6;
 	const utils_1 = utils;
 	const errors_1 = requireEs2018();
 	function dropRightAsync$1(iterable, count) {
@@ -3433,7 +3812,7 @@ function requireDropRight () {
 	if (hasRequiredDropRight) return dropRight;
 	hasRequiredDropRight = 1;
 dropRight.dropRight = void 0;
-	const go_1 = es2018$4;
+	const go_1 = es2018$6;
 	const utils_1 = utils;
 	const errors_1 = requireEs2018();
 	function dropRight$1(iterable, count) {
@@ -3454,7 +3833,7 @@ dropRight.dropRight = void 0;
 var dropUntilAsync$1 = {};
 
 dropUntilAsync$1.dropUntilAsync = void 0;
-const types_1$h = es2018$7;
+const types_1$h = es2018$5;
 function dropUntilAsync(iterable, predicate) {
     if ((0, types_1$h.isAsyncIterable)(iterable)) {
         return dropUntilAsyncIterable(iterable);
@@ -3541,7 +3920,7 @@ function requireDrop () {
 	if (hasRequiredDrop) return drop;
 	hasRequiredDrop = 1;
 drop.drop = void 0;
-	const go_1 = es2018$4;
+	const go_1 = es2018$6;
 	const utils_1 = utils;
 	const errors_1 = requireEs2018();
 	function drop$1(iterable, count) {
@@ -3579,7 +3958,7 @@ drop.drop = void 0;
 var filterAsync$1 = {};
 
 filterAsync$1.filterAsync = void 0;
-const types_1$g = es2018$7;
+const types_1$g = es2018$5;
 function filterAsync(iterable, predicate) {
     if ((0, types_1$g.isAsyncIterable)(iterable)) {
         return filterAsyncIterable(iterable);
@@ -3626,7 +4005,7 @@ var flattenDeepAsync = {};
 var flattenByAsync$1 = {};
 
 flattenByAsync$1.flattenByAsync = void 0;
-const types_1$f = es2018$7;
+const types_1$f = es2018$5;
 function flattenByAsync(iterable, predicate) {
     if ((0, types_1$f.isAsyncIterable)(iterable)) {
         return flattenByAsyncIterable(iterable);
@@ -3700,7 +4079,7 @@ flattenAsync.flattenAsync = void 0;
 var flattenBy$1 = {};
 
 flattenBy$1.flattenBy = void 0;
-const types_1$e = es2018$7;
+const types_1$e = es2018$5;
 function flattenBy(iterable, predicate) {
     return flatten(iterable, 1);
     function* flatten(iterable, level) {
@@ -3759,7 +4138,7 @@ flatten.flatten = void 0;
 var mapAsync$1 = {};
 
 mapAsync$1.mapAsync = void 0;
-const types_1$d = es2018$7;
+const types_1$d = es2018$5;
 function mapAsync(iterable, fn) {
     if ((0, types_1$d.isAsyncIterable)(iterable)) {
         return mapAsyncIterable(iterable);
@@ -3804,7 +4183,7 @@ function requireRepeatAsync () {
 	if (hasRequiredRepeatAsync) return repeatAsync;
 	hasRequiredRepeatAsync = 1;
 repeatAsync.repeatAsync = void 0;
-	const go_1 = es2018$4;
+	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');
@@ -3847,7 +4226,7 @@ function requireRepeat () {
 	if (hasRequiredRepeat) return repeat$2;
 	hasRequiredRepeat = 1;
 repeat$2.repeat = void 0;
-	const go_1 = es2018$4;
+	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');
@@ -3890,7 +4269,7 @@ function requireSliceAsync () {
 	if (hasRequiredSliceAsync) return sliceAsync;
 	hasRequiredSliceAsync = 1;
 sliceAsync.sliceAsync = void 0;
-	const go_1 = es2018$4;
+	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');
@@ -3921,7 +4300,7 @@ function requireSlice () {
 	if (hasRequiredSlice) return slice;
 	hasRequiredSlice = 1;
 slice.slice = void 0;
-	const go_1 = es2018$4;
+	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');
@@ -3965,7 +4344,7 @@ splitAsync$1.splitAsync = splitAsync;
 var splitByAsync$1 = {};
 
 splitByAsync$1.splitByAsync = void 0;
-const types_1$c = es2018$7;
+const types_1$c = es2018$5;
 function splitByAsync(iterable, predicate) {
     if ((0, types_1$c.isAsyncIterable)(iterable)) {
         return splitByAsyncIterable(iterable);
@@ -4052,7 +4431,7 @@ function requireTakeAsync () {
 	if (hasRequiredTakeAsync) return takeAsync;
 	hasRequiredTakeAsync = 1;
 takeAsync.takeAsync = void 0;
-	const go_1 = es2018$4;
+	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');
@@ -4081,7 +4460,7 @@ function requireTakeRightAsync () {
 	if (hasRequiredTakeRightAsync) return takeRightAsync;
 	hasRequiredTakeRightAsync = 1;
 takeRightAsync.takeRightAsync = void 0;
-	const go_1 = es2018$4;
+	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');
@@ -4119,7 +4498,7 @@ function requireTakeRight () {
 	if (hasRequiredTakeRight) return takeRight;
 	hasRequiredTakeRight = 1;
 takeRight.takeRight = void 0;
-	const go_1 = es2018$4;
+	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');
@@ -4152,7 +4531,7 @@ takeRight.takeRight = void 0;
 var takeUntilAsync$1 = {};
 
 takeUntilAsync$1.takeUntilAsync = void 0;
-const types_1$b = es2018$7;
+const types_1$b = es2018$5;
 function takeUntilAsync(iterable, predicate) {
     if ((0, types_1$b.isAsyncIterable)(iterable)) {
         return takeUntilAsyncIterable(iterable);
@@ -4203,7 +4582,7 @@ function requireTake () {
 	if (hasRequiredTake) return take$2;
 	hasRequiredTake = 1;
 take$2.take = void 0;
-	const go_1 = es2018$4;
+	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');
@@ -4227,7 +4606,7 @@ take$2.take = void 0;
 var tapAsync$1 = {};
 
 tapAsync$1.tapAsync = void 0;
-const types_1$a = es2018$7;
+const types_1$a = es2018$5;
 function tapAsync(iterable, fn) {
     if ((0, types_1$a.isAsyncIterable)(iterable)) {
         return tapAsyncIterable(iterable);
@@ -4310,7 +4689,7 @@ uniqAsync$1.uniqAsync = uniqAsync;
 var uniqByAsync$1 = {};
 
 uniqByAsync$1.uniqByAsync = void 0;
-const types_1$9 = es2018$7;
+const types_1$9 = es2018$5;
 function uniqByAsync(iterable, fn) {
     if ((0, types_1$9.isAsyncIterable)(iterable)) {
         return uniqByAsyncIterable(iterable);
@@ -4379,7 +4758,7 @@ uniq$1.uniq = uniq;
 var zipAsync$1 = {};
 
 zipAsync$1.zipAsync = void 0;
-const types_1$8 = es2018$7;
+const types_1$8 = es2018$5;
 var Kind;
 (function (Kind) {
     Kind[Kind["Sync"] = 0] = "Sync";
@@ -4550,7 +4929,7 @@ consume$1.consume = consume;
 var eachAsync$1 = {};
 
 eachAsync$1.eachAsync = void 0;
-const types_1$7 = es2018$7;
+const types_1$7 = es2018$5;
 function eachAsync(iterable, fn) {
     if ((0, types_1$7.isAsyncIterable)(iterable)) {
         return eachAsyncIterable(iterable);
@@ -4590,7 +4969,7 @@ each$1.each = each;
 var everyAsync$1 = {};
 
 everyAsync$1.everyAsync = void 0;
-const types_1$6 = es2018$7;
+const types_1$6 = es2018$5;
 function everyAsync(iterable, predicate) {
     if ((0, types_1$6.isAsyncIterable)(iterable)) {
         return everyAsyncIterable(iterable);
@@ -4636,7 +5015,7 @@ every$3.every = every$2;
 var findAsync$1 = {};
 
 findAsync$1.findAsync = void 0;
-const types_1$5 = es2018$7;
+const types_1$5 = es2018$5;
 function findAsync(iterable, predicate) {
     if ((0, types_1$5.isAsyncIterable)(iterable)) {
         return findAsyncIterable(iterable);
@@ -4760,7 +5139,7 @@ match$1.match = match;
 var reduceAsync$1 = {};
 
 reduceAsync$1.reduceAsync = void 0;
-const types_1$4 = es2018$7;
+const types_1$4 = es2018$5;
 function reduceAsync(iterable, fn, initialValue) {
     if ((0, types_1$4.isUndefined)(initialValue)) {
         return reduceAsyncWithoutInitialValue(iterable, fn);
@@ -4856,7 +5235,7 @@ function reduceAsyncWithoutInitialValue(iterable, fn) {
 var reduce$3 = {};
 
 reduce$3.reduce = void 0;
-const types_1$3 = es2018$7;
+const types_1$3 = es2018$5;
 function reduce$2(iterable, fn, initialValue) {
     if ((0, types_1$3.isUndefined)(initialValue)) {
         return reduceWithoutInitialValue(iterable, fn);
@@ -4903,7 +5282,7 @@ function reduceWithoutInitialValue(iterable, fn) {
 var someAsync$1 = {};
 
 someAsync$1.someAsync = void 0;
-const types_1$2 = es2018$7;
+const types_1$2 = es2018$5;
 function someAsync(iterable, predicate) {
     if ((0, types_1$2.isAsyncIterable)(iterable)) {
         return someAsyncIterable(iterable);
@@ -5107,7 +5486,7 @@ countAsync$1.countAsync = countAsync;
 var hasRequiredEs2018$1;
 
 function requireEs2018$1 () {
-	if (hasRequiredEs2018$1) return es2018$5;
+	if (hasRequiredEs2018$1) return es2018$7;
 	hasRequiredEs2018$1 = 1;
 	(function (exports) {
 		var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -5126,8 +5505,8 @@ function requireEs2018$1 () {
 		};__exportStar(requireMiddleware(), exports);
 		__exportStar(output, exports);
 		
-} (es2018$5));
-	return es2018$5;
+} (es2018$7));
+	return es2018$7;
 }
 
 var getErrorNames$1 = {};
@@ -5146,7 +5525,7 @@ function* traverseErrorPrototypeChain(err) {
 traverseErrorPrototypeChain$1.traverseErrorPrototypeChain = traverseErrorPrototypeChain;
 
 getErrorNames$1.getErrorNames = void 0;
-const types_1$1 = es2018$7;
+const types_1$1 = es2018$9;
 const traverse_error_prototype_chain_1 = traverseErrorPrototypeChain$1;
 function* getErrorNames(err) {
     var _a;
@@ -5167,7 +5546,7 @@ getErrorNames$1.getErrorNames = getErrorNames;
 var serializableError = {};
 
 serializableError.isSerializableError = void 0;
-const types_1 = es2018$7;
+const types_1 = es2018$9;
 function isSerializableError(val) {
     return (0, types_1.isObject)(val)
         && (0, types_1.isString)(val.name)
@@ -5185,7 +5564,7 @@ function requireCustomError () {
 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$9;
 	const serializable_error_1 = serializableError;
 	class CustomError extends Error {
 	    get name() {
@@ -5255,7 +5634,7 @@ normalize.normalize = void 0;
 
 var hydrate$1 = {};
 
-var es2018$3 = {};
+var es2018$4 = {};
 
 var pass$1 = {};
 
@@ -5275,10 +5654,10 @@ pass$1.pass = pass;
 	    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]
@@ -5324,7 +5703,7 @@ assert.assert = void 0;
 var hasRequiredEs2018;
 
 function requireEs2018 () {
-	if (hasRequiredEs2018) return es2018$6;
+	if (hasRequiredEs2018) return es2018$8;
 	hasRequiredEs2018 = 1;
 	(function (exports) {
 		var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -5349,27 +5728,27 @@ function requireEs2018 () {
 		__exportStar(getErrorNames$1, exports);
 		__exportStar(traverseErrorPrototypeChain$1, exports);
 		
-} (es2018$6));
-	return es2018$6;
+} (es2018$8));
+	return es2018$8;
 }
 
 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)) {
+    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');
     }
     const [selectedIndex, setSelectedIndex] = react.exports.useState(defaultSelectedIndex);
-    return {
-        value: es2018$7.isUndefined(selectedIndex) ? undefined : values[selectedIndex],
+    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]);
 }
 
 var es2018Exports = requireEs2018$1();
@@ -5380,8 +5759,8 @@ function useMultipleSelection(values, defaultSelectedIndexes = []) {
         es2018Exports$1.assert(index >= 0 && index < values.length, 'The index of parameter defaultSelectedIndexes must be in the range of 0 to values.length');
     }
     const [selectedIndexes, setSelectedIndexes] = react.exports.useState(new Set(defaultSelectedIndexes));
-    return {
-        values: es2018Exports.toArray(es2018Exports.map(selectedIndexes, i => values[i])),
+    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 = () => {
@@ -5403,28 +5782,30 @@ function useMultipleSelection(values, defaultSelectedIndexes = []) {
                 toggle: selected ? unselect : select
             };
         })
-    };
+    }), [selectedIndexes]);
 }
 
 function useStateCycle(stateList, initialStateIndex = 0) {
     const [index, setIndex] = react.exports.useState(initialStateIndex);
-    return [
-        stateList[index],
-        () => setIndex(index => {
+    return [stateList[index], next];
+    function next() {
+        setIndex(index => {
             if (index + 1 < stateList.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];
+    function toggle() {
+        setState(state => !state);
+    }
 }
 
 function useResizeObserver(callback, refs) {
@@ -5433,7 +5814,7 @@ function useResizeObserver(callback, refs) {
         const observer = new ResizeObserver(callback);
         refs
             .map(x => x.current)
-            .filter(es2018$7.isntNull)
+            .filter(es2018$9.isntNull)
             .forEach(x => observer.observe(x));
         return () => observer.disconnect();
     }, deps);
@@ -5441,29 +5822,27 @@ function useResizeObserver(callback, refs) {
 
 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], next, 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() {
@@ -5471,7 +5850,7 @@ function useForceUpdate() {
     return () => setState({});
 }
 
-var es2018$2 = {};
+var es2018$3 = {};
 
 var box = {};
 
@@ -5705,11 +6084,11 @@ lruMap.LRUMap = LRUMap;
 
 var expirableMap = {};
 
-var es2018$1 = {};
+var es2018$2 = {};
 
 var exponentialBackoff = {};
 
-var es2018 = {};
+var es2018$1 = {};
 
 var random$1 = {};
 
@@ -5753,10 +6132,10 @@ randomIntInclusive$1.randomIntInclusive = randomIntInclusive;
 	__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) {
@@ -5871,10 +6250,10 @@ setDynamicTimeoutLoop$1.setDynamicTimeoutLoop = setDynamicTimeoutLoop;
 	__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();
@@ -5972,7 +6351,7 @@ var tlruMap = {};
 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();
@@ -6211,13 +6590,13 @@ var Observable$1 = {};
 
 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 = {};
 
@@ -6294,7 +6673,7 @@ var __spreadArray$g = (commonjsGlobal && commonjsGlobal.__spreadArray) || functi
         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 () {
@@ -6587,7 +6966,7 @@ errorContext$1.captureError = captureError;
 	        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;
@@ -6816,7 +7195,7 @@ var Subscription_1$9 = Subscription$1;
 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) {
@@ -6920,7 +7299,7 @@ var refCount$1 = {};
 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);
 }
@@ -8415,14 +8794,14 @@ var args = {};
 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];
@@ -8453,33 +8832,33 @@ var isArrayLike = {};
 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 = {};
 
@@ -8489,7 +8868,7 @@ function createInvalidObservableTypeError(input) {
 }
 throwUnobservableError.createInvalidObservableTypeError = createInvalidObservableTypeError;
 
-var isIterable$1 = {};
+var isIterable$2 = {};
 
 var iterator = {};
 
@@ -8503,13 +8882,13 @@ function getSymbolIterator() {
 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 = {};
 
@@ -8552,7 +8931,7 @@ var __asyncGenerator = (commonjsGlobal && commonjsGlobal.__asyncGenerator) || fu
     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;
@@ -8646,14 +9025,14 @@ var __values$6 = (commonjsGlobal && commonjsGlobal.__values) || function(o) {
     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) {
@@ -8889,7 +9268,7 @@ var scheduleIterable$1 = {};
 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) {
@@ -8964,10 +9343,10 @@ var scheduleArray_1 = scheduleArray$1;
 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;
@@ -9021,7 +9400,7 @@ var throwError$1 = {};
 
 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()); };
@@ -9034,7 +9413,7 @@ exports.observeNotification = exports.Notification = exports.NotificationKind =
 	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";
@@ -9109,7 +9488,7 @@ var isObservable$1 = {};
 
 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)));
 }
@@ -9222,18 +9601,18 @@ SequenceError.SequenceError = createErrorClass_1.createErrorClass(function (_sup
 
 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;
@@ -9337,9 +9716,9 @@ var __spreadArray$f = (commonjsGlobal && commonjsGlobal.__spreadArray) || functi
     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); });
@@ -9467,12 +9846,12 @@ var combineLatest$3 = {};
 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)) {
@@ -9649,7 +10028,7 @@ var map_1$4 = map$1;
 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)) {
@@ -9807,7 +10186,7 @@ var innerFrom_1$m = innerFrom$1;
 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'];
@@ -9866,7 +10245,7 @@ var fromEventPattern$1 = {};
 
 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) {
@@ -9981,7 +10360,7 @@ timer$1.timer = void 0;
 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; }
@@ -10076,9 +10455,9 @@ var onErrorResumeNext$2 = {};
 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;
 
@@ -10889,7 +11268,7 @@ var concatMap$1 = {};
 
 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);
 }
@@ -10899,7 +11278,7 @@ var concatMapTo$1 = {};
 
 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; });
 }
@@ -11687,7 +12066,7 @@ var max$1 = {};
 
 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); });
 }
@@ -11703,7 +12082,7 @@ var mergeMapTo$1 = {};
 
 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)) {
@@ -11811,7 +12190,7 @@ var min$1 = {};
 
 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); });
 }
@@ -11821,7 +12200,7 @@ var multicast$1 = {};
 
 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; };
@@ -11924,7 +12303,7 @@ var publishReplay$1 = {};
 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;
@@ -12581,7 +12960,7 @@ var switchMapTo$1 = {};
 
 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; });
 }
@@ -12639,7 +13018,7 @@ takeWhile$1.takeWhile = takeWhile;
 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;
@@ -12783,7 +13162,7 @@ var timeoutWith$1 = {};
 
 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;
@@ -13612,30 +13991,390 @@ zipWith$1.zipWith = zipWith;
 	
 } (cjs));
 
-(function (exports) {
-exports.BadEventError = exports.ObservableFiniteStateMachine = void 0;
-	const finite_state_machine_1 = finiteStateMachine;
-	const rxjs_1 = cjs;
-	const types_1 = es2018$7;
-	class ObservableFiniteStateMachine extends finite_state_machine_1.FiniteStateMachine {
-	    constructor() {
-	        super(...arguments);
-	        this.stateChanges = new rxjs_1.Subject();
-	    }
-	    observeStateChanges() {
-	        return this.stateChanges;
-	    }
-	    send(event) {
-	        const oldState = this.state;
-	        super.send(event);
-	        const newState = this.state;
-	        this.stateChanges.next({ event, oldState, newState });
-	        if ((0, types_1.isEmptyObject)(this.schema[newState])) {
-	            this.stateChanges.complete();
-	        }
-	    }
-	}
-	exports.ObservableFiniteStateMachine = ObservableFiniteStateMachine;
+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;
+	class ObservableFiniteStateMachine extends finite_state_machine_1.FiniteStateMachine {
+	    constructor() {
+	        super(...arguments);
+	        this.stateChanges = new rxjs_1.Subject();
+	    }
+	    observeStateChanges() {
+	        return this.stateChanges;
+	    }
+	    send(event) {
+	        const oldState = this.state;
+	        super.send(event);
+	        const newState = this.state;
+	        this.stateChanges.next({ event, oldState, newState });
+	        if ((0, types_1.isEmptyObject)(this.schema[newState])) {
+	            this.stateChanges.complete();
+	        }
+	    }
+	}
+	exports.ObservableFiniteStateMachine = ObservableFiniteStateMachine;
 	var finite_state_machine_2 = finiteStateMachine;
 	Object.defineProperty(exports, "BadEventError", { enumerable: true, get: function () { return finite_state_machine_2.BadEventError; } });
 	
@@ -13668,11 +14407,11 @@ exports.BadEventError = exports.ObservableFiniteStateMachine = void 0;
 	__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]);
     react.exports.useEffect(() => {
         const observable = fsm.observeStateChanges();
         const subscription = observable.subscribe(() => forceUpdate());
@@ -13681,6 +14420,6 @@ function useFiniteStateMachine(schema, initialState) {
     return fsm;
 }
 
-var ObservableFiniteStateMachine = es2018$2.ObservableFiniteStateMachine;
-export { ObservableFiniteStateMachine, useFiniteStateMachine, useForceUpdate, useIncrement, useIsFirstRender, useIsMounted, useMount, useMultipleSelection, useResizeObserver, useSingleSelection, useStateCycle, useStep, useToggle, useUpdateEffect };
+var ObservableFiniteStateMachine = es2018$3.ObservableFiniteStateMachine;
+export { ObservableFiniteStateMachine, useFiniteStateMachine, useForceUpdate, useIncrement, useIsFirstRender, useIsMounted, useMount, useMultipleSelection, useRenderCounter, useResizeObserver, useSingleSelection, useStateCycle, useStep, useToggle, useUpdateEffect };
 //# sourceMappingURL=index.mjs.map