remix-validated-form 4.3.1-beta.0 → 4.4.0

package/dist/remix-validated-form.es.js

@@ -5,18 +5,18 @@ var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
+var __spreadValues = (a2, b2) => {
+  for (var prop in b2 || (b2 = {}))
+    if (__hasOwnProp.call(b2, prop))
+      __defNormalProp(a2, prop, b2[prop]);
   if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
+    for (var prop of __getOwnPropSymbols(b2)) {
+      if (__propIsEnum.call(b2, prop))
+        __defNormalProp(a2, prop, b2[prop]);
     }
-  return a;
+  return a2;
 };
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __spreadProps = (a2, b2) => __defProps(a2, __getOwnPropDescs(b2));
 var __objRest = (source, exclude) => {
   var target = {};
   for (var prop in source)
@@ -29,7 +29,7 @@ var __objRest = (source, exclude) => {
     }
   return target;
 };
-import React, { useContext, useCallback, useReducer, useEffect, useDebugValue, createContext, useMemo, useRef, useLayoutEffect, useState } from "react";
+import React, { createContext, useDebugValue, useContext, useCallback, useEffect, useMemo, useRef, useLayoutEffect, useState } from "react";
 import { useActionData, useMatches, useTransition, Form, useSubmit } from "@remix-run/react";
 import { json } from "@remix-run/server-runtime";
 var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
@@ -136,19 +136,19 @@ var freeSelf = typeof self == "object" && self && self.Object === Object && self
 var root$8 = freeGlobal || freeSelf || Function("return this")();
 var _root = root$8;
 var root$7 = _root;
-var Symbol$7 = root$7.Symbol;
-var _Symbol = Symbol$7;
-var Symbol$6 = _Symbol;
-var objectProto$f = Object.prototype;
-var hasOwnProperty$c = objectProto$f.hasOwnProperty;
-var nativeObjectToString$1 = objectProto$f.toString;
-var symToStringTag$1 = Symbol$6 ? Symbol$6.toStringTag : void 0;
+var Symbol$5 = root$7.Symbol;
+var _Symbol = Symbol$5;
+var Symbol$4 = _Symbol;
+var objectProto$d = Object.prototype;
+var hasOwnProperty$a = objectProto$d.hasOwnProperty;
+var nativeObjectToString$1 = objectProto$d.toString;
+var symToStringTag$1 = Symbol$4 ? Symbol$4.toStringTag : void 0;
 function getRawTag$1(value) {
-  var isOwn = hasOwnProperty$c.call(value, symToStringTag$1), tag = value[symToStringTag$1];
+  var isOwn = hasOwnProperty$a.call(value, symToStringTag$1), tag = value[symToStringTag$1];
   try {
     value[symToStringTag$1] = void 0;
     var unmasked = true;
-  } catch (e) {
+  } catch (e2) {
   }
   var result = nativeObjectToString$1.call(value);
   if (unmasked) {
@@ -161,35 +161,35 @@ function getRawTag$1(value) {
   return result;
 }
 var _getRawTag = getRawTag$1;
-var objectProto$e = Object.prototype;
-var nativeObjectToString = objectProto$e.toString;
+var objectProto$c = Object.prototype;
+var nativeObjectToString = objectProto$c.toString;
 function objectToString$1(value) {
   return nativeObjectToString.call(value);
 }
 var _objectToString = objectToString$1;
-var Symbol$5 = _Symbol, getRawTag = _getRawTag, objectToString = _objectToString;
+var Symbol$3 = _Symbol, getRawTag = _getRawTag, objectToString = _objectToString;
 var nullTag = "[object Null]", undefinedTag = "[object Undefined]";
-var symToStringTag = Symbol$5 ? Symbol$5.toStringTag : void 0;
-function baseGetTag$6(value) {
+var symToStringTag = Symbol$3 ? Symbol$3.toStringTag : void 0;
+function baseGetTag$5(value) {
   if (value == null) {
     return value === void 0 ? undefinedTag : nullTag;
   }
   return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
 }
-var _baseGetTag = baseGetTag$6;
-function isObject$7(value) {
+var _baseGetTag = baseGetTag$5;
+function isObject$5(value) {
   var type = typeof value;
   return value != null && (type == "object" || type == "function");
 }
-var isObject_1 = isObject$7;
-var baseGetTag$5 = _baseGetTag, isObject$6 = isObject_1;
-var asyncTag = "[object AsyncFunction]", funcTag$2 = "[object Function]", genTag$1 = "[object GeneratorFunction]", proxyTag = "[object Proxy]";
+var isObject_1 = isObject$5;
+var baseGetTag$4 = _baseGetTag, isObject$4 = isObject_1;
+var asyncTag = "[object AsyncFunction]", funcTag$1 = "[object Function]", genTag = "[object GeneratorFunction]", proxyTag = "[object Proxy]";
 function isFunction$2(value) {
-  if (!isObject$6(value)) {
+  if (!isObject$4(value)) {
     return false;
   }
-  var tag = baseGetTag$5(value);
-  return tag == funcTag$2 || tag == genTag$1 || tag == asyncTag || tag == proxyTag;
+  var tag = baseGetTag$4(value);
+  return tag == funcTag$1 || tag == genTag || tag == asyncTag || tag == proxyTag;
 }
 var isFunction_1 = isFunction$2;
 var root$6 = _root;
@@ -204,31 +204,31 @@ function isMasked$1(func) {
   return !!maskSrcKey && maskSrcKey in func;
 }
 var _isMasked = isMasked$1;
-var funcProto$2 = Function.prototype;
-var funcToString$2 = funcProto$2.toString;
+var funcProto$1 = Function.prototype;
+var funcToString$1 = funcProto$1.toString;
 function toSource$2(func) {
   if (func != null) {
     try {
-      return funcToString$2.call(func);
-    } catch (e) {
+      return funcToString$1.call(func);
+    } catch (e2) {
     }
     try {
       return func + "";
-    } catch (e) {
+    } catch (e2) {
     }
   }
   return "";
 }
 var _toSource = toSource$2;
-var isFunction$1 = isFunction_1, isMasked = _isMasked, isObject$5 = isObject_1, toSource$1 = _toSource;
+var isFunction$1 = isFunction_1, isMasked = _isMasked, isObject$3 = isObject_1, toSource$1 = _toSource;
 var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
 var reIsHostCtor = /^\[object .+?Constructor\]$/;
-var funcProto$1 = Function.prototype, objectProto$d = Object.prototype;
-var funcToString$1 = funcProto$1.toString;
-var hasOwnProperty$b = objectProto$d.hasOwnProperty;
-var reIsNative = RegExp("^" + funcToString$1.call(hasOwnProperty$b).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");
+var funcProto = Function.prototype, objectProto$b = Object.prototype;
+var funcToString = funcProto.toString;
+var hasOwnProperty$9 = objectProto$b.hasOwnProperty;
+var reIsNative = RegExp("^" + funcToString.call(hasOwnProperty$9).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");
 function baseIsNative$1(value) {
-  if (!isObject$5(value) || isMasked(value)) {
+  if (!isObject$3(value) || isMasked(value)) {
     return false;
   }
   var pattern = isFunction$1(value) ? reIsNative : reIsHostCtor;
@@ -265,23 +265,23 @@ function hashDelete$1(key) {
 var _hashDelete = hashDelete$1;
 var nativeCreate$2 = _nativeCreate;
 var HASH_UNDEFINED$2 = "__lodash_hash_undefined__";
-var objectProto$c = Object.prototype;
-var hasOwnProperty$a = objectProto$c.hasOwnProperty;
+var objectProto$a = Object.prototype;
+var hasOwnProperty$8 = objectProto$a.hasOwnProperty;
 function hashGet$1(key) {
   var data = this.__data__;
   if (nativeCreate$2) {
     var result = data[key];
     return result === HASH_UNDEFINED$2 ? void 0 : result;
   }
-  return hasOwnProperty$a.call(data, key) ? data[key] : void 0;
+  return hasOwnProperty$8.call(data, key) ? data[key] : void 0;
 }
 var _hashGet = hashGet$1;
 var nativeCreate$1 = _nativeCreate;
-var objectProto$b = Object.prototype;
-var hasOwnProperty$9 = objectProto$b.hasOwnProperty;
+var objectProto$9 = Object.prototype;
+var hasOwnProperty$7 = objectProto$9.hasOwnProperty;
 function hashHas$1(key) {
   var data = this.__data__;
-  return nativeCreate$1 ? data[key] !== void 0 : hasOwnProperty$9.call(data, key);
+  return nativeCreate$1 ? data[key] !== void 0 : hasOwnProperty$7.call(data, key);
 }
 var _hashHas = hashHas$1;
 var nativeCreate = _nativeCreate;
@@ -388,16 +388,16 @@ function stackSet$1(key, value) {
 }
 var _stackSet = stackSet$1;
 var ListCache = _ListCache, stackClear = _stackClear, stackDelete = _stackDelete, stackGet = _stackGet, stackHas = _stackHas, stackSet = _stackSet;
-function Stack$3(entries) {
+function Stack$2(entries) {
   var data = this.__data__ = new ListCache(entries);
   this.size = data.size;
 }
-Stack$3.prototype.clear = stackClear;
-Stack$3.prototype["delete"] = stackDelete;
-Stack$3.prototype.get = stackGet;
-Stack$3.prototype.has = stackHas;
-Stack$3.prototype.set = stackSet;
-var _Stack = Stack$3;
+Stack$2.prototype.clear = stackClear;
+Stack$2.prototype["delete"] = stackDelete;
+Stack$2.prototype.get = stackGet;
+Stack$2.prototype.has = stackHas;
+Stack$2.prototype.set = stackSet;
+var _Stack = Stack$2;
 var HASH_UNDEFINED = "__lodash_hash_undefined__";
 function setCacheAdd$1(value) {
   this.__data__.set(value, HASH_UNDEFINED);
@@ -480,8 +480,8 @@ function equalArrays$2(array, other, bitmask, customizer, equalFunc, stack) {
 }
 var _equalArrays = equalArrays$2;
 var root$4 = _root;
-var Uint8Array$2 = root$4.Uint8Array;
-var _Uint8Array = Uint8Array$2;
+var Uint8Array$1 = root$4.Uint8Array;
+var _Uint8Array = Uint8Array$1;
 function mapToArray$1(map) {
   var index = -1, result = Array(map.size);
   map.forEach(function(value, key) {
@@ -498,36 +498,36 @@ function setToArray$3(set2) {
   return result;
 }
 var _setToArray = setToArray$3;
-var Symbol$4 = _Symbol, Uint8Array$1 = _Uint8Array, eq$1 = eq_1, equalArrays$1 = _equalArrays, mapToArray = _mapToArray, setToArray$2 = _setToArray;
+var Symbol$2 = _Symbol, Uint8Array2 = _Uint8Array, eq$1 = eq_1, equalArrays$1 = _equalArrays, mapToArray = _mapToArray, setToArray$2 = _setToArray;
 var COMPARE_PARTIAL_FLAG$4 = 1, COMPARE_UNORDERED_FLAG$2 = 2;
-var boolTag$3 = "[object Boolean]", dateTag$3 = "[object Date]", errorTag$2 = "[object Error]", mapTag$5 = "[object Map]", numberTag$3 = "[object Number]", regexpTag$3 = "[object RegExp]", setTag$5 = "[object Set]", stringTag$3 = "[object String]", symbolTag$3 = "[object Symbol]";
-var arrayBufferTag$3 = "[object ArrayBuffer]", dataViewTag$4 = "[object DataView]";
-var symbolProto$2 = Symbol$4 ? Symbol$4.prototype : void 0, symbolValueOf$1 = symbolProto$2 ? symbolProto$2.valueOf : void 0;
+var boolTag$1 = "[object Boolean]", dateTag$1 = "[object Date]", errorTag$1 = "[object Error]", mapTag$2 = "[object Map]", numberTag$1 = "[object Number]", regexpTag$1 = "[object RegExp]", setTag$2 = "[object Set]", stringTag$1 = "[object String]", symbolTag$1 = "[object Symbol]";
+var arrayBufferTag$1 = "[object ArrayBuffer]", dataViewTag$2 = "[object DataView]";
+var symbolProto$1 = Symbol$2 ? Symbol$2.prototype : void 0, symbolValueOf = symbolProto$1 ? symbolProto$1.valueOf : void 0;
 function equalByTag$1(object, other, tag, bitmask, customizer, equalFunc, stack) {
   switch (tag) {
-    case dataViewTag$4:
+    case dataViewTag$2:
       if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
         return false;
       }
       object = object.buffer;
       other = other.buffer;
-    case arrayBufferTag$3:
-      if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array$1(object), new Uint8Array$1(other))) {
+    case arrayBufferTag$1:
+      if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array2(object), new Uint8Array2(other))) {
         return false;
       }
       return true;
-    case boolTag$3:
-    case dateTag$3:
-    case numberTag$3:
+    case boolTag$1:
+    case dateTag$1:
+    case numberTag$1:
       return eq$1(+object, +other);
-    case errorTag$2:
+    case errorTag$1:
       return object.name == other.name && object.message == other.message;
-    case regexpTag$3:
-    case stringTag$3:
+    case regexpTag$1:
+    case stringTag$1:
       return object == other + "";
-    case mapTag$5:
+    case mapTag$2:
       var convert = mapToArray;
-    case setTag$5:
+    case setTag$2:
       var isPartial = bitmask & COMPARE_PARTIAL_FLAG$4;
       convert || (convert = setToArray$2);
       if (object.size != other.size && !isPartial) {
@@ -542,28 +542,28 @@ function equalByTag$1(object, other, tag, bitmask, customizer, equalFunc, stack)
       var result = equalArrays$1(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
       stack["delete"](object);
       return result;
-    case symbolTag$3:
-      if (symbolValueOf$1) {
-        return symbolValueOf$1.call(object) == symbolValueOf$1.call(other);
+    case symbolTag$1:
+      if (symbolValueOf) {
+        return symbolValueOf.call(object) == symbolValueOf.call(other);
       }
   }
   return false;
 }
 var _equalByTag = equalByTag$1;
-function arrayPush$3(array, values) {
+function arrayPush$2(array, values) {
   var index = -1, length = values.length, offset = array.length;
   while (++index < length) {
     array[offset + index] = values[index];
   }
   return array;
 }
-var _arrayPush = arrayPush$3;
-var isArray$a = Array.isArray;
-var isArray_1 = isArray$a;
-var arrayPush$2 = _arrayPush, isArray$9 = isArray_1;
+var _arrayPush = arrayPush$2;
+var isArray$8 = Array.isArray;
+var isArray_1 = isArray$8;
+var arrayPush$1 = _arrayPush, isArray$7 = isArray_1;
 function baseGetAllKeys$2(object, keysFunc, symbolsFunc) {
   var result = keysFunc(object);
-  return isArray$9(object) ? result : arrayPush$2(result, symbolsFunc(object));
+  return isArray$7(object) ? result : arrayPush$1(result, symbolsFunc(object));
 }
 var _baseGetAllKeys = baseGetAllKeys$2;
 function arrayFilter$1(array, predicate) {
@@ -582,10 +582,10 @@ function stubArray$2() {
 }
 var stubArray_1 = stubArray$2;
 var arrayFilter = _arrayFilter, stubArray$1 = stubArray_1;
-var objectProto$a = Object.prototype;
-var propertyIsEnumerable$1 = objectProto$a.propertyIsEnumerable;
+var objectProto$8 = Object.prototype;
+var propertyIsEnumerable$1 = objectProto$8.propertyIsEnumerable;
 var nativeGetSymbols$1 = Object.getOwnPropertySymbols;
-var getSymbols$3 = !nativeGetSymbols$1 ? stubArray$1 : function(object) {
+var getSymbols$2 = !nativeGetSymbols$1 ? stubArray$1 : function(object) {
   if (object == null) {
     return [];
   }
@@ -594,36 +594,36 @@ var getSymbols$3 = !nativeGetSymbols$1 ? stubArray$1 : function(object) {
     return propertyIsEnumerable$1.call(object, symbol);
   });
 };
-var _getSymbols = getSymbols$3;
-function baseTimes$1(n, iteratee) {
-  var index = -1, result = Array(n);
-  while (++index < n) {
+var _getSymbols = getSymbols$2;
+function baseTimes$1(n2, iteratee) {
+  var index = -1, result = Array(n2);
+  while (++index < n2) {
     result[index] = iteratee(index);
   }
   return result;
 }
 var _baseTimes = baseTimes$1;
-function isObjectLike$8(value) {
+function isObjectLike$5(value) {
   return value != null && typeof value == "object";
 }
-var isObjectLike_1 = isObjectLike$8;
-var baseGetTag$4 = _baseGetTag, isObjectLike$7 = isObjectLike_1;
-var argsTag$3 = "[object Arguments]";
+var isObjectLike_1 = isObjectLike$5;
+var baseGetTag$3 = _baseGetTag, isObjectLike$4 = isObjectLike_1;
+var argsTag$2 = "[object Arguments]";
 function baseIsArguments$1(value) {
-  return isObjectLike$7(value) && baseGetTag$4(value) == argsTag$3;
+  return isObjectLike$4(value) && baseGetTag$3(value) == argsTag$2;
 }
 var _baseIsArguments = baseIsArguments$1;
-var baseIsArguments = _baseIsArguments, isObjectLike$6 = isObjectLike_1;
-var objectProto$9 = Object.prototype;
-var hasOwnProperty$8 = objectProto$9.hasOwnProperty;
-var propertyIsEnumerable = objectProto$9.propertyIsEnumerable;
-var isArguments$3 = baseIsArguments(function() {
+var baseIsArguments = _baseIsArguments, isObjectLike$3 = isObjectLike_1;
+var objectProto$7 = Object.prototype;
+var hasOwnProperty$6 = objectProto$7.hasOwnProperty;
+var propertyIsEnumerable = objectProto$7.propertyIsEnumerable;
+var isArguments$2 = baseIsArguments(function() {
   return arguments;
 }()) ? baseIsArguments : function(value) {
-  return isObjectLike$6(value) && hasOwnProperty$8.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
+  return isObjectLike$3(value) && hasOwnProperty$6.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
 };
-var isArguments_1 = isArguments$3;
-var isBuffer$3 = { exports: {} };
+var isArguments_1 = isArguments$2;
+var isBuffer$2 = { exports: {} };
 function stubFalse() {
   return false;
 }
@@ -637,7 +637,7 @@ var stubFalse_1 = stubFalse;
   var nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : void 0;
   var isBuffer2 = nativeIsBuffer || stubFalse2;
   module.exports = isBuffer2;
-})(isBuffer$3, isBuffer$3.exports);
+})(isBuffer$2, isBuffer$2.exports);
 var MAX_SAFE_INTEGER$1 = 9007199254740991;
 var reIsUint = /^(?:0|[1-9]\d*)$/;
 function isIndex$3(value, length) {
@@ -651,22 +651,22 @@ function isLength$3(value) {
   return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
 }
 var isLength_1 = isLength$3;
-var baseGetTag$3 = _baseGetTag, isLength$2 = isLength_1, isObjectLike$5 = isObjectLike_1;
-var argsTag$2 = "[object Arguments]", arrayTag$2 = "[object Array]", boolTag$2 = "[object Boolean]", dateTag$2 = "[object Date]", errorTag$1 = "[object Error]", funcTag$1 = "[object Function]", mapTag$4 = "[object Map]", numberTag$2 = "[object Number]", objectTag$4 = "[object Object]", regexpTag$2 = "[object RegExp]", setTag$4 = "[object Set]", stringTag$2 = "[object String]", weakMapTag$2 = "[object WeakMap]";
-var arrayBufferTag$2 = "[object ArrayBuffer]", dataViewTag$3 = "[object DataView]", float32Tag$2 = "[object Float32Array]", float64Tag$2 = "[object Float64Array]", int8Tag$2 = "[object Int8Array]", int16Tag$2 = "[object Int16Array]", int32Tag$2 = "[object Int32Array]", uint8Tag$2 = "[object Uint8Array]", uint8ClampedTag$2 = "[object Uint8ClampedArray]", uint16Tag$2 = "[object Uint16Array]", uint32Tag$2 = "[object Uint32Array]";
+var baseGetTag$2 = _baseGetTag, isLength$2 = isLength_1, isObjectLike$2 = isObjectLike_1;
+var argsTag$1 = "[object Arguments]", arrayTag$1 = "[object Array]", boolTag = "[object Boolean]", dateTag = "[object Date]", errorTag = "[object Error]", funcTag = "[object Function]", mapTag$1 = "[object Map]", numberTag = "[object Number]", objectTag$2 = "[object Object]", regexpTag = "[object RegExp]", setTag$1 = "[object Set]", stringTag = "[object String]", weakMapTag$1 = "[object WeakMap]";
+var arrayBufferTag = "[object ArrayBuffer]", dataViewTag$1 = "[object DataView]", float32Tag = "[object Float32Array]", float64Tag = "[object Float64Array]", int8Tag = "[object Int8Array]", int16Tag = "[object Int16Array]", int32Tag = "[object Int32Array]", uint8Tag = "[object Uint8Array]", uint8ClampedTag = "[object Uint8ClampedArray]", uint16Tag = "[object Uint16Array]", uint32Tag = "[object Uint32Array]";
 var typedArrayTags = {};
-typedArrayTags[float32Tag$2] = typedArrayTags[float64Tag$2] = typedArrayTags[int8Tag$2] = typedArrayTags[int16Tag$2] = typedArrayTags[int32Tag$2] = typedArrayTags[uint8Tag$2] = typedArrayTags[uint8ClampedTag$2] = typedArrayTags[uint16Tag$2] = typedArrayTags[uint32Tag$2] = true;
-typedArrayTags[argsTag$2] = typedArrayTags[arrayTag$2] = typedArrayTags[arrayBufferTag$2] = typedArrayTags[boolTag$2] = typedArrayTags[dataViewTag$3] = typedArrayTags[dateTag$2] = typedArrayTags[errorTag$1] = typedArrayTags[funcTag$1] = typedArrayTags[mapTag$4] = typedArrayTags[numberTag$2] = typedArrayTags[objectTag$4] = typedArrayTags[regexpTag$2] = typedArrayTags[setTag$4] = typedArrayTags[stringTag$2] = typedArrayTags[weakMapTag$2] = false;
+typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
+typedArrayTags[argsTag$1] = typedArrayTags[arrayTag$1] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag$1] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag$1] = typedArrayTags[numberTag] = typedArrayTags[objectTag$2] = typedArrayTags[regexpTag] = typedArrayTags[setTag$1] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag$1] = false;
 function baseIsTypedArray$1(value) {
-  return isObjectLike$5(value) && isLength$2(value.length) && !!typedArrayTags[baseGetTag$3(value)];
+  return isObjectLike$2(value) && isLength$2(value.length) && !!typedArrayTags[baseGetTag$2(value)];
 }
 var _baseIsTypedArray = baseIsTypedArray$1;
-function baseUnary$3(func) {
+function baseUnary$1(func) {
   return function(value) {
     return func(value);
   };
 }
-var _baseUnary = baseUnary$3;
+var _baseUnary = baseUnary$1;
 var _nodeUtil = { exports: {} };
 (function(module, exports) {
   var freeGlobal2 = _freeGlobal;
@@ -681,34 +681,34 @@ var _nodeUtil = { exports: {} };
         return types;
       }
       return freeProcess && freeProcess.binding && freeProcess.binding("util");
-    } catch (e) {
+    } catch (e2) {
     }
   }();
   module.exports = nodeUtil2;
 })(_nodeUtil, _nodeUtil.exports);
-var baseIsTypedArray = _baseIsTypedArray, baseUnary$2 = _baseUnary, nodeUtil$2 = _nodeUtil.exports;
-var nodeIsTypedArray = nodeUtil$2 && nodeUtil$2.isTypedArray;
-var isTypedArray$2 = nodeIsTypedArray ? baseUnary$2(nodeIsTypedArray) : baseIsTypedArray;
+var baseIsTypedArray = _baseIsTypedArray, baseUnary = _baseUnary, nodeUtil = _nodeUtil.exports;
+var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
+var isTypedArray$2 = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
 var isTypedArray_1 = isTypedArray$2;
-var baseTimes = _baseTimes, isArguments$2 = isArguments_1, isArray$8 = isArray_1, isBuffer$2 = isBuffer$3.exports, isIndex$2 = _isIndex, isTypedArray$1 = isTypedArray_1;
-var objectProto$8 = Object.prototype;
-var hasOwnProperty$7 = objectProto$8.hasOwnProperty;
+var baseTimes = _baseTimes, isArguments$1 = isArguments_1, isArray$6 = isArray_1, isBuffer$1 = isBuffer$2.exports, isIndex$2 = _isIndex, isTypedArray$1 = isTypedArray_1;
+var objectProto$6 = Object.prototype;
+var hasOwnProperty$5 = objectProto$6.hasOwnProperty;
 function arrayLikeKeys$2(value, inherited) {
-  var isArr = isArray$8(value), isArg = !isArr && isArguments$2(value), isBuff = !isArr && !isArg && isBuffer$2(value), isType = !isArr && !isArg && !isBuff && isTypedArray$1(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes(value.length, String) : [], length = result.length;
+  var isArr = isArray$6(value), isArg = !isArr && isArguments$1(value), isBuff = !isArr && !isArg && isBuffer$1(value), isType = !isArr && !isArg && !isBuff && isTypedArray$1(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes(value.length, String) : [], length = result.length;
   for (var key in value) {
-    if ((inherited || hasOwnProperty$7.call(value, key)) && !(skipIndexes && (key == "length" || isBuff && (key == "offset" || key == "parent") || isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || isIndex$2(key, length)))) {
+    if ((inherited || hasOwnProperty$5.call(value, key)) && !(skipIndexes && (key == "length" || isBuff && (key == "offset" || key == "parent") || isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || isIndex$2(key, length)))) {
       result.push(key);
     }
   }
   return result;
 }
 var _arrayLikeKeys = arrayLikeKeys$2;
-var objectProto$7 = Object.prototype;
-function isPrototype$3(value) {
-  var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto$7;
+var objectProto$5 = Object.prototype;
+function isPrototype$2(value) {
+  var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto$5;
   return value === proto;
 }
-var _isPrototype = isPrototype$3;
+var _isPrototype = isPrototype$2;
 function overArg$2(func, transform) {
   return function(arg) {
     return func(transform(arg));
@@ -718,16 +718,16 @@ var _overArg = overArg$2;
 var overArg$1 = _overArg;
 var nativeKeys$1 = overArg$1(Object.keys, Object);
 var _nativeKeys = nativeKeys$1;
-var isPrototype$2 = _isPrototype, nativeKeys = _nativeKeys;
-var objectProto$6 = Object.prototype;
-var hasOwnProperty$6 = objectProto$6.hasOwnProperty;
+var isPrototype$1 = _isPrototype, nativeKeys = _nativeKeys;
+var objectProto$4 = Object.prototype;
+var hasOwnProperty$4 = objectProto$4.hasOwnProperty;
 function baseKeys$1(object) {
-  if (!isPrototype$2(object)) {
+  if (!isPrototype$1(object)) {
     return nativeKeys(object);
   }
   var result = [];
   for (var key in Object(object)) {
-    if (hasOwnProperty$6.call(object, key) && key != "constructor") {
+    if (hasOwnProperty$4.call(object, key) && key != "constructor") {
       result.push(key);
     }
   }
@@ -740,28 +740,28 @@ function isArrayLike$2(value) {
 }
 var isArrayLike_1 = isArrayLike$2;
 var arrayLikeKeys$1 = _arrayLikeKeys, baseKeys = _baseKeys, isArrayLike$1 = isArrayLike_1;
-function keys$4(object) {
+function keys$2(object) {
   return isArrayLike$1(object) ? arrayLikeKeys$1(object) : baseKeys(object);
 }
-var keys_1 = keys$4;
-var baseGetAllKeys$1 = _baseGetAllKeys, getSymbols$2 = _getSymbols, keys$3 = keys_1;
-function getAllKeys$2(object) {
-  return baseGetAllKeys$1(object, keys$3, getSymbols$2);
+var keys_1 = keys$2;
+var baseGetAllKeys$1 = _baseGetAllKeys, getSymbols$1 = _getSymbols, keys$1 = keys_1;
+function getAllKeys$1(object) {
+  return baseGetAllKeys$1(object, keys$1, getSymbols$1);
 }
-var _getAllKeys = getAllKeys$2;
-var getAllKeys$1 = _getAllKeys;
+var _getAllKeys = getAllKeys$1;
+var getAllKeys = _getAllKeys;
 var COMPARE_PARTIAL_FLAG$3 = 1;
-var objectProto$5 = Object.prototype;
-var hasOwnProperty$5 = objectProto$5.hasOwnProperty;
+var objectProto$3 = Object.prototype;
+var hasOwnProperty$3 = objectProto$3.hasOwnProperty;
 function equalObjects$1(object, other, bitmask, customizer, equalFunc, stack) {
-  var isPartial = bitmask & COMPARE_PARTIAL_FLAG$3, objProps = getAllKeys$1(object), objLength = objProps.length, othProps = getAllKeys$1(other), othLength = othProps.length;
+  var isPartial = bitmask & COMPARE_PARTIAL_FLAG$3, objProps = getAllKeys(object), objLength = objProps.length, othProps = getAllKeys(other), othLength = othProps.length;
   if (objLength != othLength && !isPartial) {
     return false;
   }
   var index = objLength;
   while (index--) {
     var key = objProps[index];
-    if (!(isPartial ? key in other : hasOwnProperty$5.call(other, key))) {
+    if (!(isPartial ? key in other : hasOwnProperty$3.call(other, key))) {
       return false;
     }
   }
@@ -807,82 +807,82 @@ var getNative$2 = _getNative, root$1 = _root;
 var Set$3 = getNative$2(root$1, "Set");
 var _Set = Set$3;
 var getNative$1 = _getNative, root = _root;
-var WeakMap$2 = getNative$1(root, "WeakMap");
-var _WeakMap = WeakMap$2;
-var DataView = _DataView, Map$1 = _Map, Promise$1 = _Promise, Set$2 = _Set, WeakMap$1 = _WeakMap, baseGetTag$2 = _baseGetTag, toSource = _toSource;
-var mapTag$3 = "[object Map]", objectTag$3 = "[object Object]", promiseTag = "[object Promise]", setTag$3 = "[object Set]", weakMapTag$1 = "[object WeakMap]";
-var dataViewTag$2 = "[object DataView]";
-var dataViewCtorString = toSource(DataView), mapCtorString = toSource(Map$1), promiseCtorString = toSource(Promise$1), setCtorString = toSource(Set$2), weakMapCtorString = toSource(WeakMap$1);
-var getTag$4 = baseGetTag$2;
-if (DataView && getTag$4(new DataView(new ArrayBuffer(1))) != dataViewTag$2 || Map$1 && getTag$4(new Map$1()) != mapTag$3 || Promise$1 && getTag$4(Promise$1.resolve()) != promiseTag || Set$2 && getTag$4(new Set$2()) != setTag$3 || WeakMap$1 && getTag$4(new WeakMap$1()) != weakMapTag$1) {
-  getTag$4 = function(value) {
-    var result = baseGetTag$2(value), Ctor = result == objectTag$3 ? value.constructor : void 0, ctorString = Ctor ? toSource(Ctor) : "";
+var WeakMap$1 = getNative$1(root, "WeakMap");
+var _WeakMap = WeakMap$1;
+var DataView = _DataView, Map$1 = _Map, Promise$1 = _Promise, Set$2 = _Set, WeakMap = _WeakMap, baseGetTag$1 = _baseGetTag, toSource = _toSource;
+var mapTag = "[object Map]", objectTag$1 = "[object Object]", promiseTag = "[object Promise]", setTag = "[object Set]", weakMapTag = "[object WeakMap]";
+var dataViewTag = "[object DataView]";
+var dataViewCtorString = toSource(DataView), mapCtorString = toSource(Map$1), promiseCtorString = toSource(Promise$1), setCtorString = toSource(Set$2), weakMapCtorString = toSource(WeakMap);
+var getTag$1 = baseGetTag$1;
+if (DataView && getTag$1(new DataView(new ArrayBuffer(1))) != dataViewTag || Map$1 && getTag$1(new Map$1()) != mapTag || Promise$1 && getTag$1(Promise$1.resolve()) != promiseTag || Set$2 && getTag$1(new Set$2()) != setTag || WeakMap && getTag$1(new WeakMap()) != weakMapTag) {
+  getTag$1 = function(value) {
+    var result = baseGetTag$1(value), Ctor = result == objectTag$1 ? value.constructor : void 0, ctorString = Ctor ? toSource(Ctor) : "";
     if (ctorString) {
       switch (ctorString) {
         case dataViewCtorString:
-          return dataViewTag$2;
+          return dataViewTag;
         case mapCtorString:
-          return mapTag$3;
+          return mapTag;
         case promiseCtorString:
           return promiseTag;
         case setCtorString:
-          return setTag$3;
+          return setTag;
         case weakMapCtorString:
-          return weakMapTag$1;
+          return weakMapTag;
       }
     }
     return result;
   };
 }
-var _getTag = getTag$4;
-var Stack$2 = _Stack, equalArrays = _equalArrays, equalByTag = _equalByTag, equalObjects = _equalObjects, getTag$3 = _getTag, isArray$7 = isArray_1, isBuffer$1 = isBuffer$3.exports, isTypedArray = isTypedArray_1;
+var _getTag = getTag$1;
+var Stack$1 = _Stack, equalArrays = _equalArrays, equalByTag = _equalByTag, equalObjects = _equalObjects, getTag = _getTag, isArray$5 = isArray_1, isBuffer = isBuffer$2.exports, isTypedArray = isTypedArray_1;
 var COMPARE_PARTIAL_FLAG$2 = 1;
-var argsTag$1 = "[object Arguments]", arrayTag$1 = "[object Array]", objectTag$2 = "[object Object]";
-var objectProto$4 = Object.prototype;
-var hasOwnProperty$4 = objectProto$4.hasOwnProperty;
+var argsTag = "[object Arguments]", arrayTag = "[object Array]", objectTag = "[object Object]";
+var objectProto$2 = Object.prototype;
+var hasOwnProperty$2 = objectProto$2.hasOwnProperty;
 function baseIsEqualDeep$1(object, other, bitmask, customizer, equalFunc, stack) {
-  var objIsArr = isArray$7(object), othIsArr = isArray$7(other), objTag = objIsArr ? arrayTag$1 : getTag$3(object), othTag = othIsArr ? arrayTag$1 : getTag$3(other);
-  objTag = objTag == argsTag$1 ? objectTag$2 : objTag;
-  othTag = othTag == argsTag$1 ? objectTag$2 : othTag;
-  var objIsObj = objTag == objectTag$2, othIsObj = othTag == objectTag$2, isSameTag = objTag == othTag;
-  if (isSameTag && isBuffer$1(object)) {
-    if (!isBuffer$1(other)) {
+  var objIsArr = isArray$5(object), othIsArr = isArray$5(other), objTag = objIsArr ? arrayTag : getTag(object), othTag = othIsArr ? arrayTag : getTag(other);
+  objTag = objTag == argsTag ? objectTag : objTag;
+  othTag = othTag == argsTag ? objectTag : othTag;
+  var objIsObj = objTag == objectTag, othIsObj = othTag == objectTag, isSameTag = objTag == othTag;
+  if (isSameTag && isBuffer(object)) {
+    if (!isBuffer(other)) {
       return false;
     }
     objIsArr = true;
     objIsObj = false;
   }
   if (isSameTag && !objIsObj) {
-    stack || (stack = new Stack$2());
+    stack || (stack = new Stack$1());
     return objIsArr || isTypedArray(object) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
   }
   if (!(bitmask & COMPARE_PARTIAL_FLAG$2)) {
-    var objIsWrapped = objIsObj && hasOwnProperty$4.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty$4.call(other, "__wrapped__");
+    var objIsWrapped = objIsObj && hasOwnProperty$2.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty$2.call(other, "__wrapped__");
     if (objIsWrapped || othIsWrapped) {
       var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
-      stack || (stack = new Stack$2());
+      stack || (stack = new Stack$1());
       return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
     }
   }
   if (!isSameTag) {
     return false;
   }
-  stack || (stack = new Stack$2());
+  stack || (stack = new Stack$1());
   return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
 }
 var _baseIsEqualDeep = baseIsEqualDeep$1;
-var baseIsEqualDeep = _baseIsEqualDeep, isObjectLike$4 = isObjectLike_1;
+var baseIsEqualDeep = _baseIsEqualDeep, isObjectLike$1 = isObjectLike_1;
 function baseIsEqual$3(value, other, bitmask, customizer, stack) {
   if (value === other) {
     return true;
   }
-  if (value == null || other == null || !isObjectLike$4(value) && !isObjectLike$4(other)) {
+  if (value == null || other == null || !isObjectLike$1(value) && !isObjectLike$1(other)) {
     return value !== value && other !== other;
   }
   return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual$3, stack);
 }
 var _baseIsEqual = baseIsEqual$3;
-var Stack$1 = _Stack, baseIsEqual$2 = _baseIsEqual;
+var Stack = _Stack, baseIsEqual$2 = _baseIsEqual;
 var COMPARE_PARTIAL_FLAG$1 = 1, COMPARE_UNORDERED_FLAG$1 = 2;
 function baseIsMatch$1(object, source, matchData, customizer) {
   var index = matchData.length, length = index, noCustomizer = !customizer;
@@ -904,7 +904,7 @@ function baseIsMatch$1(object, source, matchData, customizer) {
         return false;
       }
     } else {
-      var stack = new Stack$1();
+      var stack = new Stack();
       if (customizer) {
         var result = customizer(objValue, srcValue, key, object, source, stack);
       }
@@ -916,14 +916,14 @@ function baseIsMatch$1(object, source, matchData, customizer) {
   return true;
 }
 var _baseIsMatch = baseIsMatch$1;
-var isObject$4 = isObject_1;
+var isObject$2 = isObject_1;
 function isStrictComparable$2(value) {
-  return value === value && !isObject$4(value);
+  return value === value && !isObject$2(value);
 }
 var _isStrictComparable = isStrictComparable$2;
-var isStrictComparable$1 = _isStrictComparable, keys$2 = keys_1;
+var isStrictComparable$1 = _isStrictComparable, keys = keys_1;
 function getMatchData$1(object) {
-  var result = keys$2(object), length = result.length;
+  var result = keys(object), length = result.length;
   while (length--) {
     var key = result[length], value = object[key];
     result[length] = [key, value, isStrictComparable$1(value)];
@@ -951,16 +951,16 @@ function baseMatches$1(source) {
   };
 }
 var _baseMatches = baseMatches$1;
-var baseGetTag$1 = _baseGetTag, isObjectLike$3 = isObjectLike_1;
-var symbolTag$2 = "[object Symbol]";
+var baseGetTag = _baseGetTag, isObjectLike = isObjectLike_1;
+var symbolTag = "[object Symbol]";
 function isSymbol$3(value) {
-  return typeof value == "symbol" || isObjectLike$3(value) && baseGetTag$1(value) == symbolTag$2;
+  return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag;
 }
 var isSymbol_1 = isSymbol$3;
-var isArray$6 = isArray_1, isSymbol$2 = isSymbol_1;
+var isArray$4 = isArray_1, isSymbol$2 = isSymbol_1;
 var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, reIsPlainProp = /^\w*$/;
 function isKey$3(value, object) {
-  if (isArray$6(value)) {
+  if (isArray$4(value)) {
     return false;
   }
   var type = typeof value;
@@ -1017,23 +1017,23 @@ var stringToPath$1 = memoizeCapped(function(string) {
   return result;
 });
 var _stringToPath = stringToPath$1;
-function arrayMap$3(array, iteratee) {
+function arrayMap$2(array, iteratee) {
   var index = -1, length = array == null ? 0 : array.length, result = Array(length);
   while (++index < length) {
     result[index] = iteratee(array[index], index, array);
   }
   return result;
 }
-var _arrayMap = arrayMap$3;
-var Symbol$3 = _Symbol, arrayMap$2 = _arrayMap, isArray$5 = isArray_1, isSymbol$1 = isSymbol_1;
+var _arrayMap = arrayMap$2;
+var Symbol$1 = _Symbol, arrayMap$1 = _arrayMap, isArray$3 = isArray_1, isSymbol$1 = isSymbol_1;
 var INFINITY$2 = 1 / 0;
-var symbolProto$1 = Symbol$3 ? Symbol$3.prototype : void 0, symbolToString = symbolProto$1 ? symbolProto$1.toString : void 0;
+var symbolProto = Symbol$1 ? Symbol$1.prototype : void 0, symbolToString = symbolProto ? symbolProto.toString : void 0;
 function baseToString$1(value) {
   if (typeof value == "string") {
     return value;
   }
-  if (isArray$5(value)) {
-    return arrayMap$2(value, baseToString$1) + "";
+  if (isArray$3(value)) {
+    return arrayMap$1(value, baseToString$1) + "";
   }
   if (isSymbol$1(value)) {
     return symbolToString ? symbolToString.call(value) : "";
@@ -1047,37 +1047,37 @@ function toString$1(value) {
   return value == null ? "" : baseToString(value);
 }
 var toString_1 = toString$1;
-var isArray$4 = isArray_1, isKey$2 = _isKey, stringToPath = _stringToPath, toString = toString_1;
-function castPath$6(value, object) {
-  if (isArray$4(value)) {
+var isArray$2 = isArray_1, isKey$2 = _isKey, stringToPath = _stringToPath, toString = toString_1;
+function castPath$4(value, object) {
+  if (isArray$2(value)) {
     return value;
   }
   return isKey$2(value, object) ? [value] : stringToPath(toString(value));
 }
-var _castPath = castPath$6;
+var _castPath = castPath$4;
 var isSymbol = isSymbol_1;
 var INFINITY$1 = 1 / 0;
-function toKey$6(value) {
+function toKey$5(value) {
   if (typeof value == "string" || isSymbol(value)) {
     return value;
   }
   var result = value + "";
   return result == "0" && 1 / value == -INFINITY$1 ? "-0" : result;
 }
-var _toKey = toKey$6;
-var castPath$5 = _castPath, toKey$5 = _toKey;
-function baseGet$4(object, path) {
-  path = castPath$5(path, object);
+var _toKey = toKey$5;
+var castPath$3 = _castPath, toKey$4 = _toKey;
+function baseGet$3(object, path) {
+  path = castPath$3(path, object);
   var index = 0, length = path.length;
   while (object != null && index < length) {
-    object = object[toKey$5(path[index++])];
+    object = object[toKey$4(path[index++])];
   }
   return index && index == length ? object : void 0;
 }
-var _baseGet = baseGet$4;
-var baseGet$3 = _baseGet;
+var _baseGet = baseGet$3;
+var baseGet$2 = _baseGet;
 function get$1(object, path, defaultValue) {
-  var result = object == null ? void 0 : baseGet$3(object, path);
+  var result = object == null ? void 0 : baseGet$2(object, path);
   return result === void 0 ? defaultValue : result;
 }
 var get_1 = get$1;
@@ -1085,12 +1085,12 @@ function baseHasIn$1(object, key) {
   return object != null && key in Object(object);
 }
 var _baseHasIn = baseHasIn$1;
-var castPath$4 = _castPath, isArguments$1 = isArguments_1, isArray$3 = isArray_1, isIndex$1 = _isIndex, isLength = isLength_1, toKey$4 = _toKey;
+var castPath$2 = _castPath, isArguments = isArguments_1, isArray$1 = isArray_1, isIndex$1 = _isIndex, isLength = isLength_1, toKey$3 = _toKey;
 function hasPath$1(object, path, hasFunc) {
-  path = castPath$4(path, object);
+  path = castPath$2(path, object);
   var index = -1, length = path.length, result = false;
   while (++index < length) {
-    var key = toKey$4(path[index]);
+    var key = toKey$3(path[index]);
     if (!(result = object != null && hasFunc(object, key))) {
       break;
     }
@@ -1100,7 +1100,7 @@ function hasPath$1(object, path, hasFunc) {
     return result;
   }
   length = object == null ? 0 : object.length;
-  return !!length && isLength(length) && isIndex$1(key, length) && (isArray$3(object) || isArguments$1(object));
+  return !!length && isLength(length) && isIndex$1(key, length) && (isArray$1(object) || isArguments(object));
 }
 var _hasPath = hasPath$1;
 var baseHasIn = _baseHasIn, hasPath = _hasPath;
@@ -1108,11 +1108,11 @@ function hasIn$1(object, path) {
   return object != null && hasPath(object, path, baseHasIn);
 }
 var hasIn_1 = hasIn$1;
-var baseIsEqual$1 = _baseIsEqual, get = get_1, hasIn = hasIn_1, isKey$1 = _isKey, isStrictComparable = _isStrictComparable, matchesStrictComparable = _matchesStrictComparable, toKey$3 = _toKey;
+var baseIsEqual$1 = _baseIsEqual, get = get_1, hasIn = hasIn_1, isKey$1 = _isKey, isStrictComparable = _isStrictComparable, matchesStrictComparable = _matchesStrictComparable, toKey$2 = _toKey;
 var COMPARE_PARTIAL_FLAG = 1, COMPARE_UNORDERED_FLAG = 2;
 function baseMatchesProperty$1(path, srcValue) {
   if (isKey$1(path) && isStrictComparable(srcValue)) {
-    return matchesStrictComparable(toKey$3(path), srcValue);
+    return matchesStrictComparable(toKey$2(path), srcValue);
   }
   return function(object) {
     var objValue = get(object, path);
@@ -1120,38 +1120,38 @@ function baseMatchesProperty$1(path, srcValue) {
   };
 }
 var _baseMatchesProperty = baseMatchesProperty$1;
-function identity$2(value) {
+function identity$1(value) {
   return value;
 }
-var identity_1 = identity$2;
+var identity_1 = identity$1;
 function baseProperty$1(key) {
   return function(object) {
     return object == null ? void 0 : object[key];
   };
 }
 var _baseProperty = baseProperty$1;
-var baseGet$2 = _baseGet;
+var baseGet$1 = _baseGet;
 function basePropertyDeep$1(path) {
   return function(object) {
-    return baseGet$2(object, path);
+    return baseGet$1(object, path);
   };
 }
 var _basePropertyDeep = basePropertyDeep$1;
-var baseProperty = _baseProperty, basePropertyDeep = _basePropertyDeep, isKey = _isKey, toKey$2 = _toKey;
+var baseProperty = _baseProperty, basePropertyDeep = _basePropertyDeep, isKey = _isKey, toKey$1 = _toKey;
 function property$1(path) {
-  return isKey(path) ? baseProperty(toKey$2(path)) : basePropertyDeep(path);
+  return isKey(path) ? baseProperty(toKey$1(path)) : basePropertyDeep(path);
 }
 var property_1 = property$1;
-var baseMatches = _baseMatches, baseMatchesProperty = _baseMatchesProperty, identity$1 = identity_1, isArray$2 = isArray_1, property = property_1;
+var baseMatches = _baseMatches, baseMatchesProperty = _baseMatchesProperty, identity = identity_1, isArray = isArray_1, property = property_1;
 function baseIteratee$2(value) {
   if (typeof value == "function") {
     return value;
   }
   if (value == null) {
-    return identity$1;
+    return identity;
   }
   if (typeof value == "object") {
-    return isArray$2(value) ? baseMatchesProperty(value[0], value[1]) : baseMatches(value);
+    return isArray(value) ? baseMatchesProperty(value[0], value[1]) : baseMatches(value);
   }
   return property(value);
 }
@@ -1178,19 +1178,19 @@ function negate$1(predicate) {
 }
 var negate_1 = negate$1;
 var getNative = _getNative;
-var defineProperty$2 = function() {
+var defineProperty$1 = function() {
   try {
     var func = getNative(Object, "defineProperty");
     func({}, "", {});
     return func;
-  } catch (e) {
+  } catch (e2) {
   }
 }();
-var _defineProperty = defineProperty$2;
-var defineProperty$1 = _defineProperty;
-function baseAssignValue$2(object, key, value) {
-  if (key == "__proto__" && defineProperty$1) {
-    defineProperty$1(object, key, {
+var _defineProperty = defineProperty$1;
+var defineProperty = _defineProperty;
+function baseAssignValue$1(object, key, value) {
+  if (key == "__proto__" && defineProperty) {
+    defineProperty(object, key, {
       "configurable": true,
       "enumerable": true,
       "value": value,
@@ -1200,26 +1200,26 @@ function baseAssignValue$2(object, key, value) {
     object[key] = value;
   }
 }
-var _baseAssignValue = baseAssignValue$2;
-var baseAssignValue$1 = _baseAssignValue, eq = eq_1;
-var objectProto$3 = Object.prototype;
-var hasOwnProperty$3 = objectProto$3.hasOwnProperty;
-function assignValue$3(object, key, value) {
+var _baseAssignValue = baseAssignValue$1;
+var baseAssignValue = _baseAssignValue, eq = eq_1;
+var objectProto$1 = Object.prototype;
+var hasOwnProperty$1 = objectProto$1.hasOwnProperty;
+function assignValue$1(object, key, value) {
   var objValue = object[key];
-  if (!(hasOwnProperty$3.call(object, key) && eq(objValue, value)) || value === void 0 && !(key in object)) {
-    baseAssignValue$1(object, key, value);
+  if (!(hasOwnProperty$1.call(object, key) && eq(objValue, value)) || value === void 0 && !(key in object)) {
+    baseAssignValue(object, key, value);
   }
 }
-var _assignValue = assignValue$3;
-var assignValue$2 = _assignValue, castPath$3 = _castPath, isIndex = _isIndex, isObject$3 = isObject_1, toKey$1 = _toKey;
+var _assignValue = assignValue$1;
+var assignValue = _assignValue, castPath$1 = _castPath, isIndex = _isIndex, isObject$1 = isObject_1, toKey = _toKey;
 function baseSet$2(object, path, value, customizer) {
-  if (!isObject$3(object)) {
+  if (!isObject$1(object)) {
     return object;
   }
-  path = castPath$3(path, object);
+  path = castPath$1(path, object);
   var index = -1, length = path.length, lastIndex = length - 1, nested = object;
   while (nested != null && ++index < length) {
-    var key = toKey$1(path[index]), newValue = value;
+    var key = toKey(path[index]), newValue = value;
     if (key === "__proto__" || key === "constructor" || key === "prototype") {
       return object;
     }
@@ -1227,41 +1227,41 @@ function baseSet$2(object, path, value, customizer) {
       var objValue = nested[key];
       newValue = customizer ? customizer(objValue, key, nested) : void 0;
       if (newValue === void 0) {
-        newValue = isObject$3(objValue) ? objValue : isIndex(path[index + 1]) ? [] : {};
+        newValue = isObject$1(objValue) ? objValue : isIndex(path[index + 1]) ? [] : {};
       }
     }
-    assignValue$2(nested, key, newValue);
+    assignValue(nested, key, newValue);
     nested = nested[key];
   }
   return object;
 }
 var _baseSet = baseSet$2;
-var baseGet$1 = _baseGet, baseSet$1 = _baseSet, castPath$2 = _castPath;
+var baseGet = _baseGet, baseSet$1 = _baseSet, castPath = _castPath;
 function basePickBy$1(object, paths, predicate) {
   var index = -1, length = paths.length, result = {};
   while (++index < length) {
-    var path = paths[index], value = baseGet$1(object, path);
+    var path = paths[index], value = baseGet(object, path);
     if (predicate(value, path)) {
-      baseSet$1(result, castPath$2(path, object), value);
+      baseSet$1(result, castPath(path, object), value);
     }
   }
   return result;
 }
 var _basePickBy = basePickBy$1;
 var overArg = _overArg;
-var getPrototype$3 = overArg(Object.getPrototypeOf, Object);
-var _getPrototype = getPrototype$3;
-var arrayPush$1 = _arrayPush, getPrototype$2 = _getPrototype, getSymbols$1 = _getSymbols, stubArray = stubArray_1;
+var getPrototype$1 = overArg(Object.getPrototypeOf, Object);
+var _getPrototype = getPrototype$1;
+var arrayPush = _arrayPush, getPrototype = _getPrototype, getSymbols = _getSymbols, stubArray = stubArray_1;
 var nativeGetSymbols = Object.getOwnPropertySymbols;
-var getSymbolsIn$2 = !nativeGetSymbols ? stubArray : function(object) {
+var getSymbolsIn$1 = !nativeGetSymbols ? stubArray : function(object) {
   var result = [];
   while (object) {
-    arrayPush$1(result, getSymbols$1(object));
-    object = getPrototype$2(object);
+    arrayPush(result, getSymbols(object));
+    object = getPrototype(object);
   }
   return result;
 };
-var _getSymbolsIn = getSymbolsIn$2;
+var _getSymbolsIn = getSymbolsIn$1;
 function nativeKeysIn$1(object) {
   var result = [];
   if (object != null) {
@@ -1272,16 +1272,16 @@ function nativeKeysIn$1(object) {
   return result;
 }
 var _nativeKeysIn = nativeKeysIn$1;
-var isObject$2 = isObject_1, isPrototype$1 = _isPrototype, nativeKeysIn = _nativeKeysIn;
-var objectProto$2 = Object.prototype;
-var hasOwnProperty$2 = objectProto$2.hasOwnProperty;
+var isObject = isObject_1, isPrototype = _isPrototype, nativeKeysIn = _nativeKeysIn;
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
 function baseKeysIn$1(object) {
-  if (!isObject$2(object)) {
+  if (!isObject(object)) {
     return nativeKeysIn(object);
   }
-  var isProto = isPrototype$1(object), result = [];
+  var isProto = isPrototype(object), result = [];
   for (var key in object) {
-    if (!(key == "constructor" && (isProto || !hasOwnProperty$2.call(object, key)))) {
+    if (!(key == "constructor" && (isProto || !hasOwnProperty.call(object, key)))) {
       result.push(key);
     }
   }
@@ -1289,21 +1289,21 @@ function baseKeysIn$1(object) {
 }
 var _baseKeysIn = baseKeysIn$1;
 var arrayLikeKeys = _arrayLikeKeys, baseKeysIn = _baseKeysIn, isArrayLike = isArrayLike_1;
-function keysIn$3(object) {
+function keysIn$1(object) {
   return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
 }
-var keysIn_1 = keysIn$3;
-var baseGetAllKeys = _baseGetAllKeys, getSymbolsIn$1 = _getSymbolsIn, keysIn$2 = keysIn_1;
-function getAllKeysIn$3(object) {
-  return baseGetAllKeys(object, keysIn$2, getSymbolsIn$1);
+var keysIn_1 = keysIn$1;
+var baseGetAllKeys = _baseGetAllKeys, getSymbolsIn = _getSymbolsIn, keysIn = keysIn_1;
+function getAllKeysIn$1(object) {
+  return baseGetAllKeys(object, keysIn, getSymbolsIn);
 }
-var _getAllKeysIn = getAllKeysIn$3;
-var arrayMap$1 = _arrayMap, baseIteratee$1 = _baseIteratee, basePickBy = _basePickBy, getAllKeysIn$2 = _getAllKeysIn;
+var _getAllKeysIn = getAllKeysIn$1;
+var arrayMap = _arrayMap, baseIteratee$1 = _baseIteratee, basePickBy = _basePickBy, getAllKeysIn = _getAllKeysIn;
 function pickBy$1(object, predicate) {
   if (object == null) {
     return {};
   }
-  var props = arrayMap$1(getAllKeysIn$2(object), function(prop) {
+  var props = arrayMap(getAllKeysIn(object), function(prop) {
     return [prop];
   });
   predicate = baseIteratee$1(predicate);
@@ -1377,821 +1377,6 @@ const createGetInputProps = ({
     return omitBy_1(inputProps, (value) => value === void 0);
   };
 };
-const SUSPENSE_PROMISE = Symbol();
-const isSuspensePromise = (promise) => !!promise[SUSPENSE_PROMISE];
-const isSuspensePromiseAlreadyCancelled = (suspensePromise) => !suspensePromise[SUSPENSE_PROMISE].c;
-const cancelSuspensePromise = (suspensePromise) => {
-  var _a, _b;
-  (_b = (_a = suspensePromise[SUSPENSE_PROMISE]).c) == null ? void 0 : _b.call(_a);
-};
-const isEqualSuspensePromise = (oldSuspensePromise, newSuspensePromise) => {
-  const oldOriginalPromise = oldSuspensePromise[SUSPENSE_PROMISE].o;
-  const newOriginalPromise = newSuspensePromise[SUSPENSE_PROMISE].o;
-  return oldOriginalPromise === newOriginalPromise || oldSuspensePromise === newOriginalPromise || isSuspensePromise(oldOriginalPromise) && isEqualSuspensePromise(oldOriginalPromise, newSuspensePromise);
-};
-const createSuspensePromise = (promise) => {
-  const objectToAttach = {
-    o: promise,
-    c: null
-  };
-  const suspensePromise = new Promise((resolve) => {
-    objectToAttach.c = () => {
-      objectToAttach.c = null;
-      resolve();
-    };
-    promise.then(objectToAttach.c, objectToAttach.c);
-  });
-  suspensePromise[SUSPENSE_PROMISE] = objectToAttach;
-  return suspensePromise;
-};
-var __defProp$1 = Object.defineProperty;
-var __defProps$1 = Object.defineProperties;
-var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
-var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
-var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$1 = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp$1.call(b, prop))
-      __defNormalProp$1(a, prop, b[prop]);
-  if (__getOwnPropSymbols$1)
-    for (var prop of __getOwnPropSymbols$1(b)) {
-      if (__propIsEnum$1.call(b, prop))
-        __defNormalProp$1(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
-const hasInitialValue = (atom2) => "init" in atom2;
-const READ_ATOM = "r";
-const WRITE_ATOM$1 = "w";
-const COMMIT_ATOM = "c";
-const SUBSCRIBE_ATOM = "s";
-const RESTORE_ATOMS = "h";
-const DEV_SUBSCRIBE_STATE = "n";
-const DEV_GET_MOUNTED_ATOMS = "l";
-const DEV_GET_ATOM_STATE = "a";
-const DEV_GET_MOUNTED = "m";
-const createStore = (initialValues) => {
-  const committedAtomStateMap = /* @__PURE__ */ new WeakMap();
-  const mountedMap = /* @__PURE__ */ new WeakMap();
-  const pendingMap = /* @__PURE__ */ new Map();
-  let stateListeners;
-  let mountedAtoms;
-  if (typeof process === "object" && false) {
-    stateListeners = /* @__PURE__ */ new Set();
-    mountedAtoms = /* @__PURE__ */ new Set();
-  }
-  if (initialValues) {
-    for (const [atom2, value] of initialValues) {
-      const atomState = { v: value, r: 0, d: /* @__PURE__ */ new Map() };
-      if (typeof process === "object" && false) {
-        Object.freeze(atomState);
-        if (!hasInitialValue(atom2)) {
-          console.warn("Found initial value for derived atom which can cause unexpected behavior", atom2);
-        }
-      }
-      committedAtomStateMap.set(atom2, atomState);
-    }
-  }
-  const suspensePromiseCacheMap = /* @__PURE__ */ new WeakMap();
-  const addSuspensePromiseToCache = (version, atom2, suspensePromise) => {
-    let cache = suspensePromiseCacheMap.get(atom2);
-    if (!cache) {
-      cache = /* @__PURE__ */ new Map();
-      suspensePromiseCacheMap.set(atom2, cache);
-    }
-    suspensePromise.then(() => {
-      if (cache.get(version) === suspensePromise) {
-        cache.delete(version);
-        if (!cache.size) {
-          suspensePromiseCacheMap.delete(atom2);
-        }
-      }
-    });
-    cache.set(version, suspensePromise);
-  };
-  const cancelAllSuspensePromiseInCache = (atom2) => {
-    const versionSet = /* @__PURE__ */ new Set();
-    const cache = suspensePromiseCacheMap.get(atom2);
-    if (cache) {
-      suspensePromiseCacheMap.delete(atom2);
-      cache.forEach((suspensePromise, version) => {
-        cancelSuspensePromise(suspensePromise);
-        versionSet.add(version);
-      });
-    }
-    return versionSet;
-  };
-  const versionedAtomStateMapMap = /* @__PURE__ */ new WeakMap();
-  const getVersionedAtomStateMap = (version) => {
-    let versionedAtomStateMap = versionedAtomStateMapMap.get(version);
-    if (!versionedAtomStateMap) {
-      versionedAtomStateMap = /* @__PURE__ */ new Map();
-      versionedAtomStateMapMap.set(version, versionedAtomStateMap);
-    }
-    return versionedAtomStateMap;
-  };
-  const getAtomState = (version, atom2) => {
-    if (version) {
-      const versionedAtomStateMap = getVersionedAtomStateMap(version);
-      let atomState = versionedAtomStateMap.get(atom2);
-      if (!atomState) {
-        atomState = getAtomState(version.p, atom2);
-        if (atomState) {
-          if ("p" in atomState) {
-            atomState.p.then(() => versionedAtomStateMap.delete(atom2));
-          }
-          versionedAtomStateMap.set(atom2, atomState);
-        }
-      }
-      return atomState;
-    }
-    return committedAtomStateMap.get(atom2);
-  };
-  const setAtomState = (version, atom2, atomState) => {
-    if (typeof process === "object" && false) {
-      Object.freeze(atomState);
-    }
-    if (version) {
-      const versionedAtomStateMap = getVersionedAtomStateMap(version);
-      versionedAtomStateMap.set(atom2, atomState);
-    } else {
-      const prevAtomState = committedAtomStateMap.get(atom2);
-      committedAtomStateMap.set(atom2, atomState);
-      if (!pendingMap.has(atom2)) {
-        pendingMap.set(atom2, prevAtomState);
-      }
-    }
-  };
-  const createReadDependencies = (version, prevReadDependencies = /* @__PURE__ */ new Map(), dependencies) => {
-    if (!dependencies) {
-      return prevReadDependencies;
-    }
-    const readDependencies = /* @__PURE__ */ new Map();
-    let changed = false;
-    dependencies.forEach((atom2) => {
-      var _a;
-      const revision = ((_a = getAtomState(version, atom2)) == null ? void 0 : _a.r) || 0;
-      readDependencies.set(atom2, revision);
-      if (prevReadDependencies.get(atom2) !== revision) {
-        changed = true;
-      }
-    });
-    if (prevReadDependencies.size === readDependencies.size && !changed) {
-      return prevReadDependencies;
-    }
-    return readDependencies;
-  };
-  const setAtomValue = (version, atom2, value, dependencies, suspensePromise) => {
-    const atomState = getAtomState(version, atom2);
-    if (atomState) {
-      if (suspensePromise && (!("p" in atomState) || !isEqualSuspensePromise(atomState.p, suspensePromise))) {
-        return atomState;
-      }
-      if ("p" in atomState) {
-        cancelSuspensePromise(atomState.p);
-      }
-    }
-    const nextAtomState = {
-      v: value,
-      r: (atomState == null ? void 0 : atomState.r) || 0,
-      d: createReadDependencies(version, atomState == null ? void 0 : atomState.d, dependencies)
-    };
-    if (!atomState || !("v" in atomState) || !Object.is(atomState.v, value)) {
-      ++nextAtomState.r;
-      if (nextAtomState.d.has(atom2)) {
-        nextAtomState.d = new Map(nextAtomState.d).set(atom2, nextAtomState.r);
-      }
-    } else if (nextAtomState.d !== atomState.d && (nextAtomState.d.size !== atomState.d.size || !Array.from(nextAtomState.d.keys()).every((a) => atomState.d.has(a)))) {
-      Promise.resolve().then(() => {
-        flushPending(version);
-      });
-    }
-    setAtomState(version, atom2, nextAtomState);
-    return nextAtomState;
-  };
-  const setAtomReadError = (version, atom2, error, dependencies, suspensePromise) => {
-    const atomState = getAtomState(version, atom2);
-    if (atomState) {
-      if (suspensePromise && (!("p" in atomState) || !isEqualSuspensePromise(atomState.p, suspensePromise))) {
-        return atomState;
-      }
-      if ("p" in atomState) {
-        cancelSuspensePromise(atomState.p);
-      }
-    }
-    const nextAtomState = {
-      e: error,
-      r: (atomState == null ? void 0 : atomState.r) || 0,
-      d: createReadDependencies(version, atomState == null ? void 0 : atomState.d, dependencies)
-    };
-    setAtomState(version, atom2, nextAtomState);
-    return nextAtomState;
-  };
-  const setAtomSuspensePromise = (version, atom2, suspensePromise, dependencies) => {
-    const atomState = getAtomState(version, atom2);
-    if (atomState && "p" in atomState) {
-      if (isEqualSuspensePromise(atomState.p, suspensePromise)) {
-        return atomState;
-      }
-      cancelSuspensePromise(atomState.p);
-    }
-    addSuspensePromiseToCache(version, atom2, suspensePromise);
-    const nextAtomState = {
-      p: suspensePromise,
-      r: (atomState == null ? void 0 : atomState.r) || 0,
-      d: createReadDependencies(version, atomState == null ? void 0 : atomState.d, dependencies)
-    };
-    setAtomState(version, atom2, nextAtomState);
-    return nextAtomState;
-  };
-  const setAtomPromiseOrValue = (version, atom2, promiseOrValue, dependencies) => {
-    if (promiseOrValue instanceof Promise) {
-      const suspensePromise = createSuspensePromise(promiseOrValue.then((value) => {
-        setAtomValue(version, atom2, value, dependencies, suspensePromise);
-        flushPending(version);
-      }).catch((e) => {
-        if (e instanceof Promise) {
-          if (isSuspensePromise(e)) {
-            return e.then(() => {
-              readAtomState(version, atom2, true);
-            });
-          }
-          return e;
-        }
-        setAtomReadError(version, atom2, e, dependencies, suspensePromise);
-        flushPending(version);
-      }));
-      return setAtomSuspensePromise(version, atom2, suspensePromise, dependencies);
-    }
-    return setAtomValue(version, atom2, promiseOrValue, dependencies);
-  };
-  const setAtomInvalidated = (version, atom2) => {
-    const atomState = getAtomState(version, atom2);
-    if (atomState) {
-      const nextAtomState = __spreadProps$1(__spreadValues$1({}, atomState), {
-        i: atomState.r
-      });
-      setAtomState(version, atom2, nextAtomState);
-    } else if (typeof process === "object" && false) {
-      console.warn("[Bug] could not invalidate non existing atom", atom2);
-    }
-  };
-  const readAtomState = (version, atom2, force) => {
-    if (!force) {
-      const atomState = getAtomState(version, atom2);
-      if (atomState) {
-        if (atomState.r !== atomState.i && "p" in atomState && !isSuspensePromiseAlreadyCancelled(atomState.p)) {
-          return atomState;
-        }
-        atomState.d.forEach((_, a) => {
-          if (a !== atom2) {
-            if (!mountedMap.has(a)) {
-              readAtomState(version, a);
-            } else {
-              const aState = getAtomState(version, a);
-              if (aState && aState.r === aState.i) {
-                readAtomState(version, a);
-              }
-            }
-          }
-        });
-        if (Array.from(atomState.d).every(([a, r]) => {
-          const aState = getAtomState(version, a);
-          return aState && "v" in aState && aState.r === r;
-        })) {
-          return atomState;
-        }
-      }
-    }
-    const dependencies = /* @__PURE__ */ new Set();
-    try {
-      const promiseOrValue = atom2.read((a) => {
-        dependencies.add(a);
-        const aState = a === atom2 ? getAtomState(version, a) : readAtomState(version, a);
-        if (aState) {
-          if ("e" in aState) {
-            throw aState.e;
-          }
-          if ("p" in aState) {
-            throw aState.p;
-          }
-          return aState.v;
-        }
-        if (hasInitialValue(a)) {
-          return a.init;
-        }
-        throw new Error("no atom init");
-      });
-      return setAtomPromiseOrValue(version, atom2, promiseOrValue, dependencies);
-    } catch (errorOrPromise) {
-      if (errorOrPromise instanceof Promise) {
-        const suspensePromise = createSuspensePromise(errorOrPromise);
-        return setAtomSuspensePromise(version, atom2, suspensePromise, dependencies);
-      }
-      return setAtomReadError(version, atom2, errorOrPromise, dependencies);
-    }
-  };
-  const readAtom = (readingAtom, version) => {
-    const atomState = readAtomState(version, readingAtom);
-    return atomState;
-  };
-  const addAtom = (addingAtom) => {
-    let mounted = mountedMap.get(addingAtom);
-    if (!mounted) {
-      mounted = mountAtom(addingAtom);
-    }
-    return mounted;
-  };
-  const canUnmountAtom = (atom2, mounted) => !mounted.l.size && (!mounted.t.size || mounted.t.size === 1 && mounted.t.has(atom2));
-  const delAtom = (deletingAtom) => {
-    const mounted = mountedMap.get(deletingAtom);
-    if (mounted && canUnmountAtom(deletingAtom, mounted)) {
-      unmountAtom(deletingAtom);
-    }
-  };
-  const invalidateDependents = (version, atom2) => {
-    const mounted = mountedMap.get(atom2);
-    mounted == null ? void 0 : mounted.t.forEach((dependent) => {
-      if (dependent !== atom2) {
-        setAtomInvalidated(version, dependent);
-        invalidateDependents(version, dependent);
-      }
-    });
-  };
-  const writeAtomState = (version, atom2, update) => {
-    let isSync = true;
-    const writeGetter = (a, options) => {
-      if (typeof options === "boolean") {
-        console.warn("[DEPRECATED] Please use { unstable_promise: true }");
-        options = { unstable_promise: options };
-      }
-      const aState = readAtomState(version, a);
-      if ("e" in aState) {
-        throw aState.e;
-      }
-      if ("p" in aState) {
-        if (options == null ? void 0 : options.unstable_promise) {
-          return aState.p.then(() => writeGetter(a, options));
-        }
-        if (typeof process === "object" && false) {
-          console.info("Reading pending atom state in write operation. We throw a promise for now.", a);
-        }
-        throw aState.p;
-      }
-      if ("v" in aState) {
-        return aState.v;
-      }
-      if (typeof process === "object" && false) {
-        console.warn("[Bug] no value found while reading atom in write operation. This is probably a bug.", a);
-      }
-      throw new Error("no value found");
-    };
-    const setter = (a, v) => {
-      let promiseOrVoid2;
-      if (a === atom2) {
-        if (!hasInitialValue(a)) {
-          throw new Error("atom not writable");
-        }
-        const versionSet = cancelAllSuspensePromiseInCache(a);
-        versionSet.forEach((cancelledVersion) => {
-          if (cancelledVersion !== version) {
-            setAtomPromiseOrValue(cancelledVersion, a, v);
-          }
-        });
-        setAtomPromiseOrValue(version, a, v);
-        invalidateDependents(version, a);
-      } else {
-        promiseOrVoid2 = writeAtomState(version, a, v);
-      }
-      if (!isSync) {
-        flushPending(version);
-      }
-      return promiseOrVoid2;
-    };
-    const promiseOrVoid = atom2.write(writeGetter, setter, update);
-    isSync = false;
-    version = void 0;
-    return promiseOrVoid;
-  };
-  const writeAtom = (writingAtom, update, version) => {
-    const promiseOrVoid = writeAtomState(version, writingAtom, update);
-    flushPending(version);
-    return promiseOrVoid;
-  };
-  const isActuallyWritableAtom = (atom2) => !!atom2.write;
-  const mountAtom = (atom2, initialDependent) => {
-    const mounted = {
-      t: new Set(initialDependent && [initialDependent]),
-      l: /* @__PURE__ */ new Set()
-    };
-    mountedMap.set(atom2, mounted);
-    if (typeof process === "object" && false) {
-      mountedAtoms.add(atom2);
-    }
-    const atomState = readAtomState(void 0, atom2);
-    atomState.d.forEach((_, a) => {
-      const aMounted = mountedMap.get(a);
-      if (aMounted) {
-        aMounted.t.add(atom2);
-      } else {
-        if (a !== atom2) {
-          mountAtom(a, atom2);
-        }
-      }
-    });
-    if (isActuallyWritableAtom(atom2) && atom2.onMount) {
-      const setAtom = (update) => writeAtom(atom2, update);
-      const onUnmount = atom2.onMount(setAtom);
-      if (onUnmount) {
-        mounted.u = onUnmount;
-      }
-    }
-    return mounted;
-  };
-  const unmountAtom = (atom2) => {
-    var _a;
-    const onUnmount = (_a = mountedMap.get(atom2)) == null ? void 0 : _a.u;
-    if (onUnmount) {
-      onUnmount();
-    }
-    mountedMap.delete(atom2);
-    if (typeof process === "object" && false) {
-      mountedAtoms.delete(atom2);
-    }
-    const atomState = getAtomState(void 0, atom2);
-    if (atomState) {
-      atomState.d.forEach((_, a) => {
-        if (a !== atom2) {
-          const mounted = mountedMap.get(a);
-          if (mounted) {
-            mounted.t.delete(atom2);
-            if (canUnmountAtom(a, mounted)) {
-              unmountAtom(a);
-            }
-          }
-        }
-      });
-    } else if (typeof process === "object" && false) {
-      console.warn("[Bug] could not find atom state to unmount", atom2);
-    }
-  };
-  const mountDependencies = (atom2, atomState, prevReadDependencies) => {
-    const dependencies = new Set(atomState.d.keys());
-    prevReadDependencies == null ? void 0 : prevReadDependencies.forEach((_, a) => {
-      if (dependencies.has(a)) {
-        dependencies.delete(a);
-        return;
-      }
-      const mounted = mountedMap.get(a);
-      if (mounted) {
-        mounted.t.delete(atom2);
-        if (canUnmountAtom(a, mounted)) {
-          unmountAtom(a);
-        }
-      }
-    });
-    dependencies.forEach((a) => {
-      const mounted = mountedMap.get(a);
-      if (mounted) {
-        mounted.t.add(atom2);
-      } else if (mountedMap.has(atom2)) {
-        mountAtom(a, atom2);
-      }
-    });
-  };
-  const flushPending = (version) => {
-    if (version) {
-      const versionedAtomStateMap = getVersionedAtomStateMap(version);
-      versionedAtomStateMap.forEach((atomState, atom2) => {
-        if (atomState !== committedAtomStateMap.get(atom2)) {
-          const mounted = mountedMap.get(atom2);
-          mounted == null ? void 0 : mounted.l.forEach((listener) => listener(version));
-        }
-      });
-      return;
-    }
-    while (pendingMap.size) {
-      const pending = Array.from(pendingMap);
-      pendingMap.clear();
-      pending.forEach(([atom2, prevAtomState]) => {
-        const atomState = getAtomState(void 0, atom2);
-        if (atomState && atomState.d !== (prevAtomState == null ? void 0 : prevAtomState.d)) {
-          mountDependencies(atom2, atomState, prevAtomState == null ? void 0 : prevAtomState.d);
-        }
-        const mounted = mountedMap.get(atom2);
-        mounted == null ? void 0 : mounted.l.forEach((listener) => listener());
-      });
-    }
-    if (typeof process === "object" && false) {
-      stateListeners.forEach((l) => l());
-    }
-  };
-  const commitVersionedAtomStateMap = (version) => {
-    const versionedAtomStateMap = getVersionedAtomStateMap(version);
-    versionedAtomStateMap.forEach((atomState, atom2) => {
-      const prevAtomState = committedAtomStateMap.get(atom2);
-      if (atomState.r > ((prevAtomState == null ? void 0 : prevAtomState.r) || 0) || "v" in atomState && atomState.r === (prevAtomState == null ? void 0 : prevAtomState.r) && atomState.d !== (prevAtomState == null ? void 0 : prevAtomState.d)) {
-        committedAtomStateMap.set(atom2, atomState);
-        if (atomState.d !== (prevAtomState == null ? void 0 : prevAtomState.d)) {
-          mountDependencies(atom2, atomState, prevAtomState == null ? void 0 : prevAtomState.d);
-        }
-      }
-    });
-  };
-  const commitAtom = (_atom, version) => {
-    if (version) {
-      commitVersionedAtomStateMap(version);
-    }
-    flushPending(void 0);
-  };
-  const subscribeAtom = (atom2, callback) => {
-    const mounted = addAtom(atom2);
-    const listeners = mounted.l;
-    listeners.add(callback);
-    return () => {
-      listeners.delete(callback);
-      delAtom(atom2);
-    };
-  };
-  const restoreAtoms = (values, version) => {
-    for (const [atom2, value] of values) {
-      if (hasInitialValue(atom2)) {
-        setAtomPromiseOrValue(version, atom2, value);
-        invalidateDependents(version, atom2);
-      }
-    }
-    flushPending(version);
-  };
-  if (typeof process === "object" && false) {
-    return {
-      [READ_ATOM]: readAtom,
-      [WRITE_ATOM$1]: writeAtom,
-      [COMMIT_ATOM]: commitAtom,
-      [SUBSCRIBE_ATOM]: subscribeAtom,
-      [RESTORE_ATOMS]: restoreAtoms,
-      [DEV_SUBSCRIBE_STATE]: (l) => {
-        stateListeners.add(l);
-        return () => {
-          stateListeners.delete(l);
-        };
-      },
-      [DEV_GET_MOUNTED_ATOMS]: () => mountedAtoms.values(),
-      [DEV_GET_ATOM_STATE]: (a) => committedAtomStateMap.get(a),
-      [DEV_GET_MOUNTED]: (a) => mountedMap.get(a)
-    };
-  }
-  return {
-    [READ_ATOM]: readAtom,
-    [WRITE_ATOM$1]: writeAtom,
-    [COMMIT_ATOM]: commitAtom,
-    [SUBSCRIBE_ATOM]: subscribeAtom,
-    [RESTORE_ATOMS]: restoreAtoms
-  };
-};
-const createScopeContainer = (initialValues) => {
-  const store = createStore(initialValues);
-  return { s: store };
-};
-const ScopeContextMap = /* @__PURE__ */ new Map();
-const getScopeContext = (scope) => {
-  if (!ScopeContextMap.has(scope)) {
-    ScopeContextMap.set(scope, createContext(createScopeContainer()));
-  }
-  return ScopeContextMap.get(scope);
-};
-let keyCount = 0;
-function atom(read, write) {
-  const key = `atom${++keyCount}`;
-  const config = {
-    toString: () => key
-  };
-  if (typeof read === "function") {
-    config.read = read;
-  } else {
-    config.init = read;
-    config.read = (get2) => get2(config);
-    config.write = (get2, set2, update) => set2(config, typeof update === "function" ? update(get2(config)) : update);
-  }
-  if (write) {
-    config.write = write;
-  }
-  return config;
-}
-const isWritable = (atom2) => !!atom2.write;
-function useAtom(atom2, scope) {
-  if ("scope" in atom2) {
-    console.warn("atom.scope is deprecated. Please do useAtom(atom, scope) instead.");
-    scope = atom2.scope;
-  }
-  const ScopeContext = getScopeContext(scope);
-  const { s: store, w: versionedWrite } = useContext(ScopeContext);
-  const getAtomValue = useCallback((version2) => {
-    const atomState = store[READ_ATOM](atom2, version2);
-    if ("e" in atomState) {
-      throw atomState.e;
-    }
-    if ("p" in atomState) {
-      throw atomState.p;
-    }
-    if ("v" in atomState) {
-      return atomState.v;
-    }
-    throw new Error("no atom value");
-  }, [store, atom2]);
-  const [[version, value, atomFromUseReducer], rerenderIfChanged] = useReducer(useCallback((prev, nextVersion) => {
-    const nextValue = getAtomValue(nextVersion);
-    if (Object.is(prev[1], nextValue) && prev[2] === atom2) {
-      return prev;
-    }
-    return [nextVersion, nextValue, atom2];
-  }, [getAtomValue, atom2]), void 0, () => {
-    const initialVersion = void 0;
-    const initialValue = getAtomValue(initialVersion);
-    return [initialVersion, initialValue, atom2];
-  });
-  if (atomFromUseReducer !== atom2) {
-    rerenderIfChanged(void 0);
-  }
-  useEffect(() => {
-    const unsubscribe = store[SUBSCRIBE_ATOM](atom2, rerenderIfChanged);
-    rerenderIfChanged(void 0);
-    return unsubscribe;
-  }, [store, atom2]);
-  useEffect(() => {
-    store[COMMIT_ATOM](atom2, version);
-  });
-  const setAtom = useCallback((update) => {
-    if (isWritable(atom2)) {
-      const write = (version2) => store[WRITE_ATOM$1](atom2, update, version2);
-      return versionedWrite ? versionedWrite(write) : write();
-    } else {
-      throw new Error("not writable atom");
-    }
-  }, [store, versionedWrite, atom2]);
-  useDebugValue(value);
-  return [value, setAtom];
-}
-const WRITE_ATOM = "w";
-function useUpdateAtom(anAtom, scope) {
-  const ScopeContext = getScopeContext(scope);
-  const { s: store, w: versionedWrite } = useContext(ScopeContext);
-  const setAtom = useCallback((update) => {
-    const write = (version) => store[WRITE_ATOM](anAtom, update, version);
-    return versionedWrite ? versionedWrite(write) : write();
-  }, [store, versionedWrite, anAtom]);
-  return setAtom;
-}
-function useAtomValue(anAtom, scope) {
-  return useAtom(anAtom, scope)[0];
-}
-function atomFamily(initializeAtom, areEqual) {
-  let shouldRemove = null;
-  const atoms = /* @__PURE__ */ new Map();
-  const createAtom = (param) => {
-    let item;
-    if (areEqual === void 0) {
-      item = atoms.get(param);
-    } else {
-      for (const [key, value] of atoms) {
-        if (areEqual(key, param)) {
-          item = value;
-          break;
-        }
-      }
-    }
-    if (item !== void 0) {
-      if (shouldRemove == null ? void 0 : shouldRemove(item[1], param)) {
-        atoms.delete(param);
-      } else {
-        return item[0];
-      }
-    }
-    const newAtom = initializeAtom(param);
-    atoms.set(param, [newAtom, Date.now()]);
-    return newAtom;
-  };
-  createAtom.remove = (param) => {
-    if (areEqual === void 0) {
-      atoms.delete(param);
-    } else {
-      for (const [key] of atoms) {
-        if (areEqual(key, param)) {
-          atoms.delete(key);
-          break;
-        }
-      }
-    }
-  };
-  createAtom.setShouldRemove = (fn) => {
-    shouldRemove = fn;
-    if (!shouldRemove)
-      return;
-    for (const [key, value] of atoms) {
-      if (shouldRemove(value[1], key)) {
-        atoms.delete(key);
-      }
-    }
-  };
-  return createAtom;
-}
-const getWeakCacheItem = (cache, deps) => {
-  do {
-    const [dep, ...rest] = deps;
-    const entry = cache.get(dep);
-    if (!entry) {
-      return;
-    }
-    if (!rest.length) {
-      return entry[1];
-    }
-    cache = entry[0];
-    deps = rest;
-  } while (deps.length);
-};
-const setWeakCacheItem = (cache, deps, item) => {
-  do {
-    const [dep, ...rest] = deps;
-    let entry = cache.get(dep);
-    if (!entry) {
-      entry = [/* @__PURE__ */ new WeakMap()];
-      cache.set(dep, entry);
-    }
-    if (!rest.length) {
-      entry[1] = item;
-      return;
-    }
-    cache = entry[0];
-    deps = rest;
-  } while (deps.length);
-};
-const createMemoizeAtom = () => {
-  const cache = /* @__PURE__ */ new WeakMap();
-  const memoizeAtom = (createAtom, deps) => {
-    const cachedAtom = getWeakCacheItem(cache, deps);
-    if (cachedAtom) {
-      return cachedAtom;
-    }
-    const createdAtom = createAtom();
-    setWeakCacheItem(cache, deps, createdAtom);
-    return createdAtom;
-  };
-  return memoizeAtom;
-};
-const memoizeAtom$4 = createMemoizeAtom();
-function selectAtom(anAtom, selector, equalityFn = Object.is) {
-  return memoizeAtom$4(() => {
-    const refAtom = atom(() => ({}));
-    const derivedAtom = atom((get2) => {
-      const slice = selector(get2(anAtom));
-      const ref = get2(refAtom);
-      if ("prev" in ref && equalityFn(ref.prev, slice)) {
-        return ref.prev;
-      }
-      ref.prev = slice;
-      return slice;
-    });
-    return derivedAtom;
-  }, [anAtom, selector, equalityFn]);
-}
-function useAtomCallback(callback, scope) {
-  const anAtom = useMemo(() => atom(null, (get2, set2, [arg, resolve, reject]) => {
-    try {
-      resolve(callback(get2, set2, arg));
-    } catch (e) {
-      reject(e);
-    }
-  }), [callback]);
-  const invoke = useUpdateAtom(anAtom, scope);
-  return useCallback((arg) => new Promise((resolve, reject) => {
-    invoke([arg, resolve, reject]);
-  }), [invoke]);
-}
-function createJSONStorage(getStringStorage) {
-  try {
-    if (!getStringStorage().removeItem) {
-      console.warn("Missing removeItem. In the next version, it will be required.");
-    }
-  } catch {
-  }
-  return {
-    getItem: (key) => {
-      const value = getStringStorage().getItem(key);
-      if (value instanceof Promise) {
-        return value.then((v) => JSON.parse(v || ""));
-      }
-      return JSON.parse(value || "");
-    },
-    setItem: (key, newValue) => getStringStorage().setItem(key, JSON.stringify(newValue)),
-    removeItem: (key) => {
-      var _a, _b;
-      return (_b = (_a = getStringStorage()).removeItem) == null ? void 0 : _b.call(_a, key);
-    }
-  };
-}
-createJSONStorage(() => localStorage);
 var prefix = "Invariant failed";
 function invariant(condition, message) {
   if (condition) {
@@ -2207,7 +1392,7 @@ const formDefaultValuesKey = (formId) => `${FORM_DEFAULTS_FIELD}_${formId}`;
 const InternalFormContext = createContext(null);
 const serverData = (data) => ({
   hydrateTo: () => data,
-  map: (fn) => serverData(fn(data))
+  map: (fn2) => serverData(fn2(data))
 });
 const hydratedData = () => ({
   hydrateTo: (hydratedData2) => hydratedData2,
@@ -2219,530 +1404,656 @@ const hydratable = {
   hydratedData,
   from
 };
-function arrayEach$1(array, iteratee) {
-  var index = -1, length = array == null ? 0 : array.length;
-  while (++index < length) {
-    if (iteratee(array[index], index, array) === false) {
-      break;
-    }
-  }
-  return array;
-}
-var _arrayEach = arrayEach$1;
-var assignValue$1 = _assignValue, baseAssignValue = _baseAssignValue;
-function copyObject$5(source, props, object, customizer) {
-  var isNew = !object;
-  object || (object = {});
-  var index = -1, length = props.length;
-  while (++index < length) {
-    var key = props[index];
-    var newValue = customizer ? customizer(object[key], source[key], key, object, source) : void 0;
-    if (newValue === void 0) {
-      newValue = source[key];
-    }
-    if (isNew) {
-      baseAssignValue(object, key, newValue);
-    } else {
-      assignValue$1(object, key, newValue);
-    }
-  }
-  return object;
-}
-var _copyObject = copyObject$5;
-var copyObject$4 = _copyObject, keys$1 = keys_1;
-function baseAssign$1(object, source) {
-  return object && copyObject$4(source, keys$1(source), object);
-}
-var _baseAssign = baseAssign$1;
-var copyObject$3 = _copyObject, keysIn$1 = keysIn_1;
-function baseAssignIn$1(object, source) {
-  return object && copyObject$3(source, keysIn$1(source), object);
-}
-var _baseAssignIn = baseAssignIn$1;
-var _cloneBuffer = { exports: {} };
-(function(module, exports) {
-  var root2 = _root;
-  var freeExports = exports && !exports.nodeType && exports;
-  var freeModule = freeExports && true && module && !module.nodeType && module;
-  var moduleExports = freeModule && freeModule.exports === freeExports;
-  var Buffer2 = moduleExports ? root2.Buffer : void 0, allocUnsafe = Buffer2 ? Buffer2.allocUnsafe : void 0;
-  function cloneBuffer2(buffer, isDeep) {
-    if (isDeep) {
-      return buffer.slice();
+const createStoreImpl = (createState) => {
+  let state;
+  const listeners = /* @__PURE__ */ new Set();
+  const setState = (partial, replace) => {
+    const nextState = typeof partial === "function" ? partial(state) : partial;
+    if (nextState !== state) {
+      const previousState = state;
+      state = replace ? nextState : Object.assign({}, state, nextState);
+      listeners.forEach((listener) => listener(state, previousState));
     }
-    var length = buffer.length, result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
-    buffer.copy(result);
-    return result;
-  }
-  module.exports = cloneBuffer2;
-})(_cloneBuffer, _cloneBuffer.exports);
-function copyArray$1(source, array) {
-  var index = -1, length = source.length;
-  array || (array = Array(length));
-  while (++index < length) {
-    array[index] = source[index];
-  }
-  return array;
-}
-var _copyArray = copyArray$1;
-var copyObject$2 = _copyObject, getSymbols = _getSymbols;
-function copySymbols$1(source, object) {
-  return copyObject$2(source, getSymbols(source), object);
-}
-var _copySymbols = copySymbols$1;
-var copyObject$1 = _copyObject, getSymbolsIn = _getSymbolsIn;
-function copySymbolsIn$1(source, object) {
-  return copyObject$1(source, getSymbolsIn(source), object);
-}
-var _copySymbolsIn = copySymbolsIn$1;
-var objectProto$1 = Object.prototype;
-var hasOwnProperty$1 = objectProto$1.hasOwnProperty;
-function initCloneArray$1(array) {
-  var length = array.length, result = new array.constructor(length);
-  if (length && typeof array[0] == "string" && hasOwnProperty$1.call(array, "index")) {
-    result.index = array.index;
-    result.input = array.input;
-  }
-  return result;
-}
-var _initCloneArray = initCloneArray$1;
-var Uint8Array2 = _Uint8Array;
-function cloneArrayBuffer$3(arrayBuffer) {
-  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
-  new Uint8Array2(result).set(new Uint8Array2(arrayBuffer));
-  return result;
-}
-var _cloneArrayBuffer = cloneArrayBuffer$3;
-var cloneArrayBuffer$2 = _cloneArrayBuffer;
-function cloneDataView$1(dataView, isDeep) {
-  var buffer = isDeep ? cloneArrayBuffer$2(dataView.buffer) : dataView.buffer;
-  return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
-}
-var _cloneDataView = cloneDataView$1;
-var reFlags = /\w*$/;
-function cloneRegExp$1(regexp) {
-  var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
-  result.lastIndex = regexp.lastIndex;
-  return result;
-}
-var _cloneRegExp = cloneRegExp$1;
-var Symbol$2 = _Symbol;
-var symbolProto = Symbol$2 ? Symbol$2.prototype : void 0, symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
-function cloneSymbol$1(symbol) {
-  return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
-}
-var _cloneSymbol = cloneSymbol$1;
-var cloneArrayBuffer$1 = _cloneArrayBuffer;
-function cloneTypedArray$1(typedArray, isDeep) {
-  var buffer = isDeep ? cloneArrayBuffer$1(typedArray.buffer) : typedArray.buffer;
-  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
-}
-var _cloneTypedArray = cloneTypedArray$1;
-var cloneArrayBuffer = _cloneArrayBuffer, cloneDataView = _cloneDataView, cloneRegExp = _cloneRegExp, cloneSymbol = _cloneSymbol, cloneTypedArray = _cloneTypedArray;
-var boolTag$1 = "[object Boolean]", dateTag$1 = "[object Date]", mapTag$2 = "[object Map]", numberTag$1 = "[object Number]", regexpTag$1 = "[object RegExp]", setTag$2 = "[object Set]", stringTag$1 = "[object String]", symbolTag$1 = "[object Symbol]";
-var arrayBufferTag$1 = "[object ArrayBuffer]", dataViewTag$1 = "[object DataView]", float32Tag$1 = "[object Float32Array]", float64Tag$1 = "[object Float64Array]", int8Tag$1 = "[object Int8Array]", int16Tag$1 = "[object Int16Array]", int32Tag$1 = "[object Int32Array]", uint8Tag$1 = "[object Uint8Array]", uint8ClampedTag$1 = "[object Uint8ClampedArray]", uint16Tag$1 = "[object Uint16Array]", uint32Tag$1 = "[object Uint32Array]";
-function initCloneByTag$1(object, tag, isDeep) {
-  var Ctor = object.constructor;
-  switch (tag) {
-    case arrayBufferTag$1:
-      return cloneArrayBuffer(object);
-    case boolTag$1:
-    case dateTag$1:
-      return new Ctor(+object);
-    case dataViewTag$1:
-      return cloneDataView(object, isDeep);
-    case float32Tag$1:
-    case float64Tag$1:
-    case int8Tag$1:
-    case int16Tag$1:
-    case int32Tag$1:
-    case uint8Tag$1:
-    case uint8ClampedTag$1:
-    case uint16Tag$1:
-    case uint32Tag$1:
-      return cloneTypedArray(object, isDeep);
-    case mapTag$2:
-      return new Ctor();
-    case numberTag$1:
-    case stringTag$1:
-      return new Ctor(object);
-    case regexpTag$1:
-      return cloneRegExp(object);
-    case setTag$2:
-      return new Ctor();
-    case symbolTag$1:
-      return cloneSymbol(object);
-  }
-}
-var _initCloneByTag = initCloneByTag$1;
-var isObject$1 = isObject_1;
-var objectCreate = Object.create;
-var baseCreate$1 = function() {
-  function object() {
-  }
-  return function(proto) {
-    if (!isObject$1(proto)) {
-      return {};
-    }
-    if (objectCreate) {
-      return objectCreate(proto);
-    }
-    object.prototype = proto;
-    var result = new object();
-    object.prototype = void 0;
-    return result;
   };
-}();
-var _baseCreate = baseCreate$1;
-var baseCreate = _baseCreate, getPrototype$1 = _getPrototype, isPrototype = _isPrototype;
-function initCloneObject$1(object) {
-  return typeof object.constructor == "function" && !isPrototype(object) ? baseCreate(getPrototype$1(object)) : {};
-}
-var _initCloneObject = initCloneObject$1;
-var getTag$2 = _getTag, isObjectLike$2 = isObjectLike_1;
-var mapTag$1 = "[object Map]";
-function baseIsMap$1(value) {
-  return isObjectLike$2(value) && getTag$2(value) == mapTag$1;
-}
-var _baseIsMap = baseIsMap$1;
-var baseIsMap = _baseIsMap, baseUnary$1 = _baseUnary, nodeUtil$1 = _nodeUtil.exports;
-var nodeIsMap = nodeUtil$1 && nodeUtil$1.isMap;
-var isMap$1 = nodeIsMap ? baseUnary$1(nodeIsMap) : baseIsMap;
-var isMap_1 = isMap$1;
-var getTag$1 = _getTag, isObjectLike$1 = isObjectLike_1;
-var setTag$1 = "[object Set]";
-function baseIsSet$1(value) {
-  return isObjectLike$1(value) && getTag$1(value) == setTag$1;
-}
-var _baseIsSet = baseIsSet$1;
-var baseIsSet = _baseIsSet, baseUnary = _baseUnary, nodeUtil = _nodeUtil.exports;
-var nodeIsSet = nodeUtil && nodeUtil.isSet;
-var isSet$1 = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;
-var isSet_1 = isSet$1;
-var Stack = _Stack, arrayEach = _arrayEach, assignValue = _assignValue, baseAssign = _baseAssign, baseAssignIn = _baseAssignIn, cloneBuffer = _cloneBuffer.exports, copyArray = _copyArray, copySymbols = _copySymbols, copySymbolsIn = _copySymbolsIn, getAllKeys = _getAllKeys, getAllKeysIn$1 = _getAllKeysIn, getTag = _getTag, initCloneArray = _initCloneArray, initCloneByTag = _initCloneByTag, initCloneObject = _initCloneObject, isArray$1 = isArray_1, isBuffer = isBuffer$3.exports, isMap = isMap_1, isObject = isObject_1, isSet = isSet_1, keys = keys_1, keysIn = keysIn_1;
-var CLONE_DEEP_FLAG$1 = 1, CLONE_FLAT_FLAG$1 = 2, CLONE_SYMBOLS_FLAG$1 = 4;
-var argsTag = "[object Arguments]", arrayTag = "[object Array]", boolTag = "[object Boolean]", dateTag = "[object Date]", errorTag = "[object Error]", funcTag = "[object Function]", genTag = "[object GeneratorFunction]", mapTag = "[object Map]", numberTag = "[object Number]", objectTag$1 = "[object Object]", regexpTag = "[object RegExp]", setTag = "[object Set]", stringTag = "[object String]", symbolTag = "[object Symbol]", weakMapTag = "[object WeakMap]";
-var arrayBufferTag = "[object ArrayBuffer]", dataViewTag = "[object DataView]", float32Tag = "[object Float32Array]", float64Tag = "[object Float64Array]", int8Tag = "[object Int8Array]", int16Tag = "[object Int16Array]", int32Tag = "[object Int32Array]", uint8Tag = "[object Uint8Array]", uint8ClampedTag = "[object Uint8ClampedArray]", uint16Tag = "[object Uint16Array]", uint32Tag = "[object Uint32Array]";
-var cloneableTags = {};
-cloneableTags[argsTag] = cloneableTags[arrayTag] = cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] = cloneableTags[boolTag] = cloneableTags[dateTag] = cloneableTags[float32Tag] = cloneableTags[float64Tag] = cloneableTags[int8Tag] = cloneableTags[int16Tag] = cloneableTags[int32Tag] = cloneableTags[mapTag] = cloneableTags[numberTag] = cloneableTags[objectTag$1] = cloneableTags[regexpTag] = cloneableTags[setTag] = cloneableTags[stringTag] = cloneableTags[symbolTag] = cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] = cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
-cloneableTags[errorTag] = cloneableTags[funcTag] = cloneableTags[weakMapTag] = false;
-function baseClone$1(value, bitmask, customizer, key, object, stack) {
-  var result, isDeep = bitmask & CLONE_DEEP_FLAG$1, isFlat = bitmask & CLONE_FLAT_FLAG$1, isFull = bitmask & CLONE_SYMBOLS_FLAG$1;
-  if (customizer) {
-    result = object ? customizer(value, key, object, stack) : customizer(value);
-  }
-  if (result !== void 0) {
-    return result;
-  }
-  if (!isObject(value)) {
-    return value;
-  }
-  var isArr = isArray$1(value);
-  if (isArr) {
-    result = initCloneArray(value);
-    if (!isDeep) {
-      return copyArray(value, result);
-    }
-  } else {
-    var tag = getTag(value), isFunc = tag == funcTag || tag == genTag;
-    if (isBuffer(value)) {
-      return cloneBuffer(value, isDeep);
-    }
-    if (tag == objectTag$1 || tag == argsTag || isFunc && !object) {
-      result = isFlat || isFunc ? {} : initCloneObject(value);
-      if (!isDeep) {
-        return isFlat ? copySymbolsIn(value, baseAssignIn(result, value)) : copySymbols(value, baseAssign(result, value));
-      }
-    } else {
-      if (!cloneableTags[tag]) {
-        return object ? value : {};
-      }
-      result = initCloneByTag(value, tag, isDeep);
-    }
-  }
-  stack || (stack = new Stack());
-  var stacked = stack.get(value);
-  if (stacked) {
-    return stacked;
-  }
-  stack.set(value, result);
-  if (isSet(value)) {
-    value.forEach(function(subValue) {
-      result.add(baseClone$1(subValue, bitmask, customizer, subValue, value, stack));
-    });
-  } else if (isMap(value)) {
-    value.forEach(function(subValue, key2) {
-      result.set(key2, baseClone$1(subValue, bitmask, customizer, key2, value, stack));
+  const getState = () => state;
+  const subscribe = (listener) => {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+  };
+  const destroy = () => listeners.clear();
+  const api = { setState, getState, subscribe, destroy };
+  state = createState(setState, getState, api);
+  return api;
+};
+const createStore = (createState) => createState ? createStoreImpl(createState) : createStoreImpl;
+var withSelector = { exports: {} };
+var withSelector_production_min = {};
+var shim = { exports: {} };
+var useSyncExternalStoreShim_production_min = {};
+/**
+ * @license React
+ * use-sync-external-store-shim.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var e = React;
+function h$2(a2, b2) {
+  return a2 === b2 && (a2 !== 0 || 1 / a2 === 1 / b2) || a2 !== a2 && b2 !== b2;
+}
+var k$1 = typeof Object.is === "function" ? Object.is : h$2, l$1 = e.useState, m = e.useEffect, n$2 = e.useLayoutEffect, p$2 = e.useDebugValue;
+function q$2(a2, b2) {
+  var d2 = b2(), f2 = l$1({ inst: { value: d2, getSnapshot: b2 } }), c2 = f2[0].inst, g2 = f2[1];
+  n$2(function() {
+    c2.value = d2;
+    c2.getSnapshot = b2;
+    r$2(c2) && g2({ inst: c2 });
+  }, [a2, d2, b2]);
+  m(function() {
+    r$2(c2) && g2({ inst: c2 });
+    return a2(function() {
+      r$2(c2) && g2({ inst: c2 });
     });
-  }
-  var keysFunc = isFull ? isFlat ? getAllKeysIn$1 : getAllKeys : isFlat ? keysIn : keys;
-  var props = isArr ? void 0 : keysFunc(value);
-  arrayEach(props || value, function(subValue, key2) {
-    if (props) {
-      key2 = subValue;
-      subValue = value[key2];
-    }
-    assignValue(result, key2, baseClone$1(subValue, bitmask, customizer, key2, value, stack));
-  });
-  return result;
-}
-var _baseClone = baseClone$1;
-function last$1(array) {
-  var length = array == null ? 0 : array.length;
-  return length ? array[length - 1] : void 0;
+  }, [a2]);
+  p$2(d2);
+  return d2;
 }
-var last_1 = last$1;
-function baseSlice$1(array, start, end) {
-  var index = -1, length = array.length;
-  if (start < 0) {
-    start = -start > length ? 0 : length + start;
-  }
-  end = end > length ? length : end;
-  if (end < 0) {
-    end += length;
-  }
-  length = start > end ? 0 : end - start >>> 0;
-  start >>>= 0;
-  var result = Array(length);
-  while (++index < length) {
-    result[index] = array[index + start];
-  }
-  return result;
-}
-var _baseSlice = baseSlice$1;
-var baseGet = _baseGet, baseSlice = _baseSlice;
-function parent$1(object, path) {
-  return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));
-}
-var _parent = parent$1;
-var castPath$1 = _castPath, last = last_1, parent = _parent, toKey = _toKey;
-function baseUnset$1(object, path) {
-  path = castPath$1(path, object);
-  object = parent(object, path);
-  return object == null || delete object[toKey(last(path))];
-}
-var _baseUnset = baseUnset$1;
-var baseGetTag = _baseGetTag, getPrototype = _getPrototype, isObjectLike = isObjectLike_1;
-var objectTag = "[object Object]";
-var funcProto = Function.prototype, objectProto = Object.prototype;
-var funcToString = funcProto.toString;
-var hasOwnProperty = objectProto.hasOwnProperty;
-var objectCtorString = funcToString.call(Object);
-function isPlainObject$1(value) {
-  if (!isObjectLike(value) || baseGetTag(value) != objectTag) {
-    return false;
-  }
-  var proto = getPrototype(value);
-  if (proto === null) {
+function r$2(a2) {
+  var b2 = a2.getSnapshot;
+  a2 = a2.value;
+  try {
+    var d2 = b2();
+    return !k$1(a2, d2);
+  } catch (f2) {
     return true;
   }
-  var Ctor = hasOwnProperty.call(proto, "constructor") && proto.constructor;
-  return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString;
-}
-var isPlainObject_1 = isPlainObject$1;
-var isPlainObject = isPlainObject_1;
-function customOmitClone$1(value) {
-  return isPlainObject(value) ? void 0 : value;
-}
-var _customOmitClone = customOmitClone$1;
-var Symbol$1 = _Symbol, isArguments = isArguments_1, isArray = isArray_1;
-var spreadableSymbol = Symbol$1 ? Symbol$1.isConcatSpreadable : void 0;
-function isFlattenable$1(value) {
-  return isArray(value) || isArguments(value) || !!(spreadableSymbol && value && value[spreadableSymbol]);
-}
-var _isFlattenable = isFlattenable$1;
-var arrayPush = _arrayPush, isFlattenable = _isFlattenable;
-function baseFlatten$1(array, depth, predicate, isStrict, result) {
-  var index = -1, length = array.length;
-  predicate || (predicate = isFlattenable);
-  result || (result = []);
-  while (++index < length) {
-    var value = array[index];
-    if (depth > 0 && predicate(value)) {
-      if (depth > 1) {
-        baseFlatten$1(value, depth - 1, predicate, isStrict, result);
-      } else {
-        arrayPush(result, value);
+}
+function t$2(a2, b2) {
+  return b2();
+}
+var u$2 = typeof window === "undefined" || typeof window.document === "undefined" || typeof window.document.createElement === "undefined" ? t$2 : q$2;
+useSyncExternalStoreShim_production_min.useSyncExternalStore = e.useSyncExternalStore !== void 0 ? e.useSyncExternalStore : u$2;
+{
+  shim.exports = useSyncExternalStoreShim_production_min;
+}
+/**
+ * @license React
+ * use-sync-external-store-shim/with-selector.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var h$1 = React, n$1 = shim.exports;
+function p$1(a2, b2) {
+  return a2 === b2 && (a2 !== 0 || 1 / a2 === 1 / b2) || a2 !== a2 && b2 !== b2;
+}
+var q$1 = typeof Object.is === "function" ? Object.is : p$1, r$1 = n$1.useSyncExternalStore, t$1 = h$1.useRef, u$1 = h$1.useEffect, v$1 = h$1.useMemo, w$1 = h$1.useDebugValue;
+withSelector_production_min.useSyncExternalStoreWithSelector = function(a2, b2, e2, l2, g2) {
+  var c2 = t$1(null);
+  if (c2.current === null) {
+    var f2 = { hasValue: false, value: null };
+    c2.current = f2;
+  } else
+    f2 = c2.current;
+  c2 = v$1(function() {
+    function a3(a4) {
+      if (!c3) {
+        c3 = true;
+        d3 = a4;
+        a4 = l2(a4);
+        if (g2 !== void 0 && f2.hasValue) {
+          var b3 = f2.value;
+          if (g2(b3, a4))
+            return k2 = b3;
+        }
+        return k2 = a4;
       }
-    } else if (!isStrict) {
-      result[result.length] = value;
-    }
-  }
-  return result;
+      b3 = k2;
+      if (q$1(d3, a4))
+        return b3;
+      var e3 = l2(a4);
+      if (g2 !== void 0 && g2(b3, e3))
+        return b3;
+      d3 = a4;
+      return k2 = e3;
+    }
+    var c3 = false, d3, k2, m2 = e2 === void 0 ? null : e2;
+    return [function() {
+      return a3(b2());
+    }, m2 === null ? void 0 : function() {
+      return a3(m2());
+    }];
+  }, [b2, e2, l2, g2]);
+  var d2 = r$1(a2, c2[0], c2[1]);
+  u$1(function() {
+    f2.hasValue = true;
+    f2.value = d2;
+  }, [d2]);
+  w$1(d2);
+  return d2;
+};
+{
+  withSelector.exports = withSelector_production_min;
+}
+function useStore(api, selector = api.getState, equalityFn) {
+  const slice = withSelector.exports.useSyncExternalStoreWithSelector(api.subscribe, api.getState, api.getServerState || api.getState, selector, equalityFn);
+  useDebugValue(slice);
+  return slice;
+}
+const createImpl = (createState) => {
+  const api = typeof createState === "function" ? createStore(createState) : createState;
+  const useBoundStore = (selector, equalityFn) => useStore(api, selector, equalityFn);
+  Object.assign(useBoundStore, api);
+  return useBoundStore;
+};
+const create = (createState) => createState ? createImpl(createState) : createImpl;
+var create$1 = create;
+function n(n2) {
+  for (var r2 = arguments.length, t2 = Array(r2 > 1 ? r2 - 1 : 0), e2 = 1; e2 < r2; e2++)
+    t2[e2 - 1] = arguments[e2];
+  throw Error("[Immer] minified error nr: " + n2 + (t2.length ? " " + t2.map(function(n3) {
+    return "'" + n3 + "'";
+  }).join(",") : "") + ". Find the full error at: https://bit.ly/3cXEKWf");
+}
+function r(n2) {
+  return !!n2 && !!n2[Q];
+}
+function t(n2) {
+  return !!n2 && (function(n3) {
+    if (!n3 || typeof n3 != "object")
+      return false;
+    var r2 = Object.getPrototypeOf(n3);
+    if (r2 === null)
+      return true;
+    var t2 = Object.hasOwnProperty.call(r2, "constructor") && r2.constructor;
+    return t2 === Object || typeof t2 == "function" && Function.toString.call(t2) === Z;
+  }(n2) || Array.isArray(n2) || !!n2[L] || !!n2.constructor[L] || s(n2) || v(n2));
+}
+function i(n2, r2, t2) {
+  t2 === void 0 && (t2 = false), o(n2) === 0 ? (t2 ? Object.keys : nn)(n2).forEach(function(e2) {
+    t2 && typeof e2 == "symbol" || r2(e2, n2[e2], n2);
+  }) : n2.forEach(function(t3, e2) {
+    return r2(e2, t3, n2);
+  });
 }
-var _baseFlatten = baseFlatten$1;
-var baseFlatten = _baseFlatten;
-function flatten$1(array) {
-  var length = array == null ? 0 : array.length;
-  return length ? baseFlatten(array, 1) : [];
-}
-var flatten_1 = flatten$1;
-function apply$1(func, thisArg, args) {
-  switch (args.length) {
-    case 0:
-      return func.call(thisArg);
-    case 1:
-      return func.call(thisArg, args[0]);
+function o(n2) {
+  var r2 = n2[Q];
+  return r2 ? r2.i > 3 ? r2.i - 4 : r2.i : Array.isArray(n2) ? 1 : s(n2) ? 2 : v(n2) ? 3 : 0;
+}
+function u(n2, r2) {
+  return o(n2) === 2 ? n2.has(r2) : Object.prototype.hasOwnProperty.call(n2, r2);
+}
+function a(n2, r2) {
+  return o(n2) === 2 ? n2.get(r2) : n2[r2];
+}
+function f(n2, r2, t2) {
+  var e2 = o(n2);
+  e2 === 2 ? n2.set(r2, t2) : e2 === 3 ? (n2.delete(r2), n2.add(t2)) : n2[r2] = t2;
+}
+function c(n2, r2) {
+  return n2 === r2 ? n2 !== 0 || 1 / n2 == 1 / r2 : n2 != n2 && r2 != r2;
+}
+function s(n2) {
+  return X && n2 instanceof Map;
+}
+function v(n2) {
+  return q && n2 instanceof Set;
+}
+function p(n2) {
+  return n2.o || n2.t;
+}
+function l(n2) {
+  if (Array.isArray(n2))
+    return Array.prototype.slice.call(n2);
+  var r2 = rn(n2);
+  delete r2[Q];
+  for (var t2 = nn(r2), e2 = 0; e2 < t2.length; e2++) {
+    var i2 = t2[e2], o2 = r2[i2];
+    o2.writable === false && (o2.writable = true, o2.configurable = true), (o2.get || o2.set) && (r2[i2] = { configurable: true, writable: true, enumerable: o2.enumerable, value: n2[i2] });
+  }
+  return Object.create(Object.getPrototypeOf(n2), r2);
+}
+function d(n2, e2) {
+  return e2 === void 0 && (e2 = false), y(n2) || r(n2) || !t(n2) ? n2 : (o(n2) > 1 && (n2.set = n2.add = n2.clear = n2.delete = h), Object.freeze(n2), e2 && i(n2, function(n3, r2) {
+    return d(r2, true);
+  }, true), n2);
+}
+function h() {
+  n(2);
+}
+function y(n2) {
+  return n2 == null || typeof n2 != "object" || Object.isFrozen(n2);
+}
+function b(r2) {
+  var t2 = tn[r2];
+  return t2 || n(18, r2), t2;
+}
+function _() {
+  return U;
+}
+function j(n2, r2) {
+  r2 && (b("Patches"), n2.u = [], n2.s = [], n2.v = r2);
+}
+function O(n2) {
+  g(n2), n2.p.forEach(S), n2.p = null;
+}
+function g(n2) {
+  n2 === U && (U = n2.l);
+}
+function w(n2) {
+  return U = { p: [], l: U, h: n2, m: true, _: 0 };
+}
+function S(n2) {
+  var r2 = n2[Q];
+  r2.i === 0 || r2.i === 1 ? r2.j() : r2.O = true;
+}
+function P(r2, e2) {
+  e2._ = e2.p.length;
+  var i2 = e2.p[0], o2 = r2 !== void 0 && r2 !== i2;
+  return e2.h.g || b("ES5").S(e2, r2, o2), o2 ? (i2[Q].P && (O(e2), n(4)), t(r2) && (r2 = M(e2, r2), e2.l || x(e2, r2)), e2.u && b("Patches").M(i2[Q].t, r2, e2.u, e2.s)) : r2 = M(e2, i2, []), O(e2), e2.u && e2.v(e2.u, e2.s), r2 !== H ? r2 : void 0;
+}
+function M(n2, r2, t2) {
+  if (y(r2))
+    return r2;
+  var e2 = r2[Q];
+  if (!e2)
+    return i(r2, function(i2, o3) {
+      return A(n2, e2, r2, i2, o3, t2);
+    }, true), r2;
+  if (e2.A !== n2)
+    return r2;
+  if (!e2.P)
+    return x(n2, e2.t, true), e2.t;
+  if (!e2.I) {
+    e2.I = true, e2.A._--;
+    var o2 = e2.i === 4 || e2.i === 5 ? e2.o = l(e2.k) : e2.o;
+    i(e2.i === 3 ? new Set(o2) : o2, function(r3, i2) {
+      return A(n2, e2, o2, r3, i2, t2);
+    }), x(n2, o2, false), t2 && n2.u && b("Patches").R(e2, t2, n2.u, n2.s);
+  }
+  return e2.o;
+}
+function A(e2, i2, o2, a2, c2, s2) {
+  if (r(c2)) {
+    var v2 = M(e2, c2, s2 && i2 && i2.i !== 3 && !u(i2.D, a2) ? s2.concat(a2) : void 0);
+    if (f(o2, a2, v2), !r(v2))
+      return;
+    e2.m = false;
+  }
+  if (t(c2) && !y(c2)) {
+    if (!e2.h.F && e2._ < 1)
+      return;
+    M(e2, c2), i2 && i2.A.l || x(e2, c2);
+  }
+}
+function x(n2, r2, t2) {
+  t2 === void 0 && (t2 = false), n2.h.F && n2.m && d(r2, t2);
+}
+function z(n2, r2) {
+  var t2 = n2[Q];
+  return (t2 ? p(t2) : n2)[r2];
+}
+function I(n2, r2) {
+  if (r2 in n2)
+    for (var t2 = Object.getPrototypeOf(n2); t2; ) {
+      var e2 = Object.getOwnPropertyDescriptor(t2, r2);
+      if (e2)
+        return e2;
+      t2 = Object.getPrototypeOf(t2);
+    }
+}
+function k(n2) {
+  n2.P || (n2.P = true, n2.l && k(n2.l));
+}
+function E(n2) {
+  n2.o || (n2.o = l(n2.t));
+}
+function R(n2, r2, t2) {
+  var e2 = s(r2) ? b("MapSet").N(r2, t2) : v(r2) ? b("MapSet").T(r2, t2) : n2.g ? function(n3, r3) {
+    var t3 = Array.isArray(n3), e3 = { i: t3 ? 1 : 0, A: r3 ? r3.A : _(), P: false, I: false, D: {}, l: r3, t: n3, k: null, o: null, j: null, C: false }, i2 = e3, o2 = en;
+    t3 && (i2 = [e3], o2 = on);
+    var u2 = Proxy.revocable(i2, o2), a2 = u2.revoke, f2 = u2.proxy;
+    return e3.k = f2, e3.j = a2, f2;
+  }(r2, t2) : b("ES5").J(r2, t2);
+  return (t2 ? t2.A : _()).p.push(e2), e2;
+}
+function D(e2) {
+  return r(e2) || n(22, e2), function n2(r2) {
+    if (!t(r2))
+      return r2;
+    var e3, u2 = r2[Q], c2 = o(r2);
+    if (u2) {
+      if (!u2.P && (u2.i < 4 || !b("ES5").K(u2)))
+        return u2.t;
+      u2.I = true, e3 = F(r2, c2), u2.I = false;
+    } else
+      e3 = F(r2, c2);
+    return i(e3, function(r3, t2) {
+      u2 && a(u2.t, r3) === t2 || f(e3, r3, n2(t2));
+    }), c2 === 3 ? new Set(e3) : e3;
+  }(e2);
+}
+function F(n2, r2) {
+  switch (r2) {
     case 2:
-      return func.call(thisArg, args[0], args[1]);
+      return new Map(n2);
     case 3:
-      return func.call(thisArg, args[0], args[1], args[2]);
-  }
-  return func.apply(thisArg, args);
-}
-var _apply = apply$1;
-var apply = _apply;
-var nativeMax = Math.max;
-function overRest$1(func, start, transform) {
-  start = nativeMax(start === void 0 ? func.length - 1 : start, 0);
-  return function() {
-    var args = arguments, index = -1, length = nativeMax(args.length - start, 0), array = Array(length);
-    while (++index < length) {
-      array[index] = args[start + index];
-    }
-    index = -1;
-    var otherArgs = Array(start + 1);
-    while (++index < start) {
-      otherArgs[index] = args[index];
+      return Array.from(n2);
+  }
+  return l(n2);
+}
+var G, U, W = typeof Symbol != "undefined" && typeof Symbol("x") == "symbol", X = typeof Map != "undefined", q = typeof Set != "undefined", B = typeof Proxy != "undefined" && Proxy.revocable !== void 0 && typeof Reflect != "undefined", H = W ? Symbol.for("immer-nothing") : ((G = {})["immer-nothing"] = true, G), L = W ? Symbol.for("immer-draftable") : "__$immer_draftable", Q = W ? Symbol.for("immer-state") : "__$immer_state", Z = "" + Object.prototype.constructor, nn = typeof Reflect != "undefined" && Reflect.ownKeys ? Reflect.ownKeys : Object.getOwnPropertySymbols !== void 0 ? function(n2) {
+  return Object.getOwnPropertyNames(n2).concat(Object.getOwnPropertySymbols(n2));
+} : Object.getOwnPropertyNames, rn = Object.getOwnPropertyDescriptors || function(n2) {
+  var r2 = {};
+  return nn(n2).forEach(function(t2) {
+    r2[t2] = Object.getOwnPropertyDescriptor(n2, t2);
+  }), r2;
+}, tn = {}, en = { get: function(n2, r2) {
+  if (r2 === Q)
+    return n2;
+  var e2 = p(n2);
+  if (!u(e2, r2))
+    return function(n3, r3, t2) {
+      var e3, i3 = I(r3, t2);
+      return i3 ? "value" in i3 ? i3.value : (e3 = i3.get) === null || e3 === void 0 ? void 0 : e3.call(n3.k) : void 0;
+    }(n2, e2, r2);
+  var i2 = e2[r2];
+  return n2.I || !t(i2) ? i2 : i2 === z(n2.t, r2) ? (E(n2), n2.o[r2] = R(n2.A.h, i2, n2)) : i2;
+}, has: function(n2, r2) {
+  return r2 in p(n2);
+}, ownKeys: function(n2) {
+  return Reflect.ownKeys(p(n2));
+}, set: function(n2, r2, t2) {
+  var e2 = I(p(n2), r2);
+  if (e2 == null ? void 0 : e2.set)
+    return e2.set.call(n2.k, t2), true;
+  if (!n2.P) {
+    var i2 = z(p(n2), r2), o2 = i2 == null ? void 0 : i2[Q];
+    if (o2 && o2.t === t2)
+      return n2.o[r2] = t2, n2.D[r2] = false, true;
+    if (c(t2, i2) && (t2 !== void 0 || u(n2.t, r2)))
+      return true;
+    E(n2), k(n2);
+  }
+  return n2.o[r2] === t2 && typeof t2 != "number" && (t2 !== void 0 || r2 in n2.o) || (n2.o[r2] = t2, n2.D[r2] = true, true);
+}, deleteProperty: function(n2, r2) {
+  return z(n2.t, r2) !== void 0 || r2 in n2.t ? (n2.D[r2] = false, E(n2), k(n2)) : delete n2.D[r2], n2.o && delete n2.o[r2], true;
+}, getOwnPropertyDescriptor: function(n2, r2) {
+  var t2 = p(n2), e2 = Reflect.getOwnPropertyDescriptor(t2, r2);
+  return e2 ? { writable: true, configurable: n2.i !== 1 || r2 !== "length", enumerable: e2.enumerable, value: t2[r2] } : e2;
+}, defineProperty: function() {
+  n(11);
+}, getPrototypeOf: function(n2) {
+  return Object.getPrototypeOf(n2.t);
+}, setPrototypeOf: function() {
+  n(12);
+} }, on = {};
+i(en, function(n2, r2) {
+  on[n2] = function() {
+    return arguments[0] = arguments[0][0], r2.apply(this, arguments);
+  };
+}), on.deleteProperty = function(r2, t2) {
+  return on.set.call(this, r2, t2, void 0);
+}, on.set = function(r2, t2, e2) {
+  return en.set.call(this, r2[0], t2, e2, r2[0]);
+};
+var un = function() {
+  function e2(r2) {
+    var e3 = this;
+    this.g = B, this.F = true, this.produce = function(r3, i3, o2) {
+      if (typeof r3 == "function" && typeof i3 != "function") {
+        var u2 = i3;
+        i3 = r3;
+        var a2 = e3;
+        return function(n2) {
+          var r4 = this;
+          n2 === void 0 && (n2 = u2);
+          for (var t2 = arguments.length, e4 = Array(t2 > 1 ? t2 - 1 : 0), o3 = 1; o3 < t2; o3++)
+            e4[o3 - 1] = arguments[o3];
+          return a2.produce(n2, function(n3) {
+            var t3;
+            return (t3 = i3).call.apply(t3, [r4, n3].concat(e4));
+          });
+        };
+      }
+      var f2;
+      if (typeof i3 != "function" && n(6), o2 !== void 0 && typeof o2 != "function" && n(7), t(r3)) {
+        var c2 = w(e3), s2 = R(e3, r3, void 0), v2 = true;
+        try {
+          f2 = i3(s2), v2 = false;
+        } finally {
+          v2 ? O(c2) : g(c2);
+        }
+        return typeof Promise != "undefined" && f2 instanceof Promise ? f2.then(function(n2) {
+          return j(c2, o2), P(n2, c2);
+        }, function(n2) {
+          throw O(c2), n2;
+        }) : (j(c2, o2), P(f2, c2));
+      }
+      if (!r3 || typeof r3 != "object") {
+        if ((f2 = i3(r3)) === void 0 && (f2 = r3), f2 === H && (f2 = void 0), e3.F && d(f2, true), o2) {
+          var p2 = [], l2 = [];
+          b("Patches").M(r3, f2, p2, l2), o2(p2, l2);
+        }
+        return f2;
+      }
+      n(21, r3);
+    }, this.produceWithPatches = function(n2, r3) {
+      if (typeof n2 == "function")
+        return function(r4) {
+          for (var t3 = arguments.length, i4 = Array(t3 > 1 ? t3 - 1 : 0), o3 = 1; o3 < t3; o3++)
+            i4[o3 - 1] = arguments[o3];
+          return e3.produceWithPatches(r4, function(r5) {
+            return n2.apply(void 0, [r5].concat(i4));
+          });
+        };
+      var t2, i3, o2 = e3.produce(n2, r3, function(n3, r4) {
+        t2 = n3, i3 = r4;
+      });
+      return typeof Promise != "undefined" && o2 instanceof Promise ? o2.then(function(n3) {
+        return [n3, t2, i3];
+      }) : [o2, t2, i3];
+    }, typeof (r2 == null ? void 0 : r2.useProxies) == "boolean" && this.setUseProxies(r2.useProxies), typeof (r2 == null ? void 0 : r2.autoFreeze) == "boolean" && this.setAutoFreeze(r2.autoFreeze);
+  }
+  var i2 = e2.prototype;
+  return i2.createDraft = function(e3) {
+    t(e3) || n(8), r(e3) && (e3 = D(e3));
+    var i3 = w(this), o2 = R(this, e3, void 0);
+    return o2[Q].C = true, g(i3), o2;
+  }, i2.finishDraft = function(r2, t2) {
+    var e3 = r2 && r2[Q];
+    var i3 = e3.A;
+    return j(i3, t2), P(void 0, i3);
+  }, i2.setAutoFreeze = function(n2) {
+    this.F = n2;
+  }, i2.setUseProxies = function(r2) {
+    r2 && !B && n(20), this.g = r2;
+  }, i2.applyPatches = function(n2, t2) {
+    var e3;
+    for (e3 = t2.length - 1; e3 >= 0; e3--) {
+      var i3 = t2[e3];
+      if (i3.path.length === 0 && i3.op === "replace") {
+        n2 = i3.value;
+        break;
+      }
     }
-    otherArgs[start] = transform(array);
-    return apply(func, this, otherArgs);
+    e3 > -1 && (t2 = t2.slice(e3 + 1));
+    var o2 = b("Patches").$;
+    return r(n2) ? o2(n2, t2) : this.produce(n2, function(n3) {
+      return o2(n3, t2);
+    });
+  }, e2;
+}(), an = new un(), fn = an.produce;
+an.produceWithPatches.bind(an);
+an.setAutoFreeze.bind(an);
+an.setUseProxies.bind(an);
+an.applyPatches.bind(an);
+an.createDraft.bind(an);
+an.finishDraft.bind(an);
+const immerImpl = (initializer) => (set2, get2, store) => {
+  store.setState = (updater, replace, ...a2) => {
+    const nextState = typeof updater === "function" ? fn(updater) : updater;
+    return set2(nextState, replace, ...a2);
   };
-}
-var _overRest = overRest$1;
-function constant$1(value) {
-  return function() {
-    return value;
+  return initializer(store.setState, get2, store);
+};
+const immer = immerImpl;
+const storeFamily = (create2) => {
+  const stores = /* @__PURE__ */ new Map();
+  const family = (formId) => {
+    if (stores.has(formId))
+      return stores.get(formId);
+    const store = create2(formId);
+    stores.set(formId, store);
+    return store;
   };
-}
-var constant_1 = constant$1;
-var constant = constant_1, defineProperty = _defineProperty, identity = identity_1;
-var baseSetToString$1 = !defineProperty ? identity : function(func, string) {
-  return defineProperty(func, "toString", {
-    "configurable": true,
-    "enumerable": false,
-    "value": constant(string),
-    "writable": true
-  });
+  family.remove = (formId) => {
+    stores.delete(formId);
+  };
+  return family;
 };
-var _baseSetToString = baseSetToString$1;
-var HOT_COUNT = 800, HOT_SPAN = 16;
-var nativeNow = Date.now;
-function shortOut$1(func) {
-  var count = 0, lastCalled = 0;
-  return function() {
-    var stamp = nativeNow(), remaining = HOT_SPAN - (stamp - lastCalled);
-    lastCalled = stamp;
-    if (remaining > 0) {
-      if (++count >= HOT_COUNT) {
-        return arguments[0];
-      }
+const controlledFieldStore = storeFamily(() => create$1()(immer((set2, get2, api) => ({
+  fields: {},
+  register: (field) => set2((state) => {
+    if (state.fields[field]) {
+      state.fields[field].refCount++;
     } else {
-      count = 0;
+      state.fields[field] = {
+        refCount: 1,
+        value: void 0,
+        hydrated: false,
+        valueUpdatePromise: void 0,
+        resolveValueUpdate: void 0
+      };
     }
-    return func.apply(void 0, arguments);
-  };
-}
-var _shortOut = shortOut$1;
-var baseSetToString = _baseSetToString, shortOut = _shortOut;
-var setToString$1 = shortOut(baseSetToString);
-var _setToString = setToString$1;
-var flatten = flatten_1, overRest = _overRest, setToString = _setToString;
-function flatRest$1(func) {
-  return setToString(overRest(func, void 0, flatten), func + "");
-}
-var _flatRest = flatRest$1;
-var arrayMap = _arrayMap, baseClone = _baseClone, baseUnset = _baseUnset, castPath = _castPath, copyObject = _copyObject, customOmitClone = _customOmitClone, flatRest = _flatRest, getAllKeysIn = _getAllKeysIn;
-var CLONE_DEEP_FLAG = 1, CLONE_FLAT_FLAG = 2, CLONE_SYMBOLS_FLAG = 4;
-var omit = flatRest(function(object, paths) {
-  var result = {};
-  if (object == null) {
-    return result;
-  }
-  var isDeep = false;
-  paths = arrayMap(paths, function(path) {
-    path = castPath(path, object);
-    isDeep || (isDeep = path.length > 1);
-    return path;
-  });
-  copyObject(object, getAllKeysIn(object), result);
-  if (isDeep) {
-    result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone);
-  }
-  var length = paths.length;
-  while (length--) {
-    baseUnset(result, paths[length]);
-  }
-  return result;
-});
-var omit_1 = omit;
-var baseIsEqual = _baseIsEqual;
-function isEqual(value, other) {
-  return baseIsEqual(value, other);
-}
-var isEqual_1 = isEqual;
-const formAtomFamily = (data) => atomFamily((_) => atom(data));
-const fieldAtomFamily = (func) => atomFamily(func, isEqual_1);
-const ATOM_SCOPE = Symbol("remix-validated-form-scope");
-const isHydratedAtom = formAtomFamily(false);
-const isSubmittingAtom = formAtomFamily(false);
-const hasBeenSubmittedAtom = formAtomFamily(false);
-const fieldErrorsAtom = formAtomFamily({});
-const touchedFieldsAtom = formAtomFamily({});
-const formPropsAtom = formAtomFamily({
-  validateField: () => Promise.resolve(null),
-  registerReceiveFocus: () => () => {
+  }),
+  unregister: (field) => set2((state) => {
+    const fieldState = state.fields[field];
+    if (!fieldState)
+      return;
+    fieldState.refCount--;
+    if (fieldState.refCount === 0)
+      delete state.fields[field];
+  }),
+  setValue: (field, value) => set2((state) => {
+    const fieldState = state.fields[field];
+    if (!fieldState)
+      return;
+    fieldState.value = value;
+    const promise = new Promise((resolve) => {
+      fieldState.resolveValueUpdate = resolve;
+    });
+    fieldState.valueUpdatePromise = promise;
+  }),
+  hydrateWithDefault: (field, defaultValue) => set2((state) => {
+    const fieldState = state.fields[field];
+    if (!fieldState)
+      return;
+    fieldState.value = defaultValue;
+    fieldState.defaultValue = defaultValue;
+    fieldState.hydrated = true;
+  }),
+  awaitValueUpdate: async (field) => {
+    var _a;
+    await ((_a = get2().fields[field]) == null ? void 0 : _a.valueUpdatePromise);
   },
-  defaultValues: {}
-});
-const formElementAtom = formAtomFamily(null);
-const cleanupFormState = (formId) => {
-  [
-    isHydratedAtom,
-    isSubmittingAtom,
-    hasBeenSubmittedAtom,
-    fieldErrorsAtom,
-    touchedFieldsAtom,
-    formPropsAtom
-  ].forEach((formAtom) => formAtom.remove(formId));
-};
-const isValidAtom = atomFamily((formId) => atom((get2) => Object.keys(get2(fieldErrorsAtom(formId))).length === 0));
-const startSubmitAtom = atomFamily((formId) => atom(null, (_get, set2) => {
-  set2(isSubmittingAtom(formId), true);
-  set2(hasBeenSubmittedAtom(formId), true);
-}));
-const endSubmitAtom = atomFamily((formId) => atom(null, (_get, set2) => {
-  set2(isSubmittingAtom(formId), false);
-}));
-const setTouchedAtom = atomFamily((formId) => atom(null, (get2, set2, { field, touched }) => {
-  const prev = get2(touchedFieldsAtom(formId));
-  if (prev[field] !== touched) {
-    set2(touchedFieldsAtom(formId), __spreadProps(__spreadValues({}, prev), {
-      [field]: touched
-    }));
-  }
-}));
-const setFieldErrorAtom = atomFamily((formId) => atom(null, (get2, set2, { field, error }) => {
-  const prev = get2(fieldErrorsAtom(formId));
-  if (error === void 0 && field in prev) {
-    set2(fieldErrorsAtom(formId), omit_1(prev, field));
-  }
-  if (error !== void 0 && prev[field] !== error) {
-    set2(fieldErrorsAtom(formId), __spreadProps(__spreadValues({}, get2(fieldErrorsAtom(formId))), {
-      [field]: error
-    }));
+  reset: () => set2((state) => {
+    Object.values(state.fields).forEach((field) => {
+      if (!field)
+        return;
+      field.value = field.defaultValue;
+    });
+  })
+}))));
+const formStore = storeFamily((formId) => create$1()(immer((set2, get2, api) => ({
+  isHydrated: false,
+  isSubmitting: false,
+  hasBeenSubmitted: false,
+  touchedFields: {},
+  fieldErrors: {},
+  formElement: null,
+  isValid: () => Object.keys(get2().fieldErrors).length === 0,
+  startSubmit: () => set2((state) => {
+    state.isSubmitting = true;
+    state.hasBeenSubmitted = true;
+  }),
+  endSubmit: () => set2((state) => {
+    state.isSubmitting = false;
+  }),
+  setTouched: (fieldName, touched) => set2((state) => {
+    state.touchedFields[fieldName] = touched;
+  }),
+  setFieldError: (fieldName, error) => set2((state) => {
+    state.fieldErrors[fieldName] = error;
+  }),
+  setFieldErrors: (errors) => set2((state) => {
+    state.fieldErrors = errors;
+  }),
+  clearFieldError: (fieldName) => set2((state) => {
+    delete state.fieldErrors[fieldName];
+  }),
+  reset: () => set2((state) => {
+    state.fieldErrors = {};
+    state.touchedFields = {};
+    state.hasBeenSubmitted = false;
+  }),
+  syncFormProps: (props) => set2((state) => {
+    state.formProps = props;
+  }),
+  setHydrated: () => set2((state) => {
+    state.isHydrated = true;
+  }),
+  setFormElement: (formElement) => {
+    if (get2().formElement === formElement)
+      return;
+    set2((state) => {
+      state.formElement = formElement;
+    });
+  },
+  validateField: async (field) => {
+    var _a, _b, _c;
+    const formElement = get2().formElement;
+    invariant(formElement);
+    const validator = (_a = get2().formProps) == null ? void 0 : _a.validator;
+    invariant(validator);
+    await ((_c = (_b = controlledFieldStore(formId).getState()).awaitValueUpdate) == null ? void 0 : _c.call(_b, field));
+    const { error } = await validator.validateField(new FormData(formElement), field);
+    if (error) {
+      get2().setFieldError(field, error);
+      return error;
+    } else {
+      get2().clearFieldError(field);
+      return null;
+    }
+  },
+  validate: async () => {
+    var _a;
+    const formElement = get2().formElement;
+    invariant(formElement);
+    const validator = (_a = get2().formProps) == null ? void 0 : _a.validator;
+    invariant(validator);
+    const { error } = await validator.validate(new FormData(formElement));
+    if (error)
+      get2().setFieldErrors(error.fieldErrors);
+  },
+  resetFormElement: () => {
+    var _a;
+    return (_a = get2().formElement) == null ? void 0 : _a.reset();
   }
-}));
-const fieldTouchedAtom = fieldAtomFamily(({ formId, field }) => atom((get2) => get2(touchedFieldsAtom(formId))[field], (_get, set2, touched) => {
-  set2(setTouchedAtom(formId), { field, touched });
-}));
-const fieldErrorAtom = fieldAtomFamily(({ formId, field }) => atom((get2) => get2(fieldErrorsAtom(formId))[field], (_get, set2, error) => {
-  set2(setFieldErrorAtom(formId), { field, error });
-}));
-fieldAtomFamily(({ formId, field }) => selectAtom(formPropsAtom(formId), (state) => state.defaultValues[field]));
-const useFormUpdateAtom = (atom2) => useUpdateAtom(atom2, ATOM_SCOPE);
-const useFormAtom = (anAtom) => useAtom(anAtom, ATOM_SCOPE);
-const useFormAtomValue = (anAtom) => useAtomValue(anAtom, ATOM_SCOPE);
+}))));
+const useFormStore = (formId, selector) => {
+  const useStore2 = formStore(formId);
+  return useStore2(selector);
+};
+const useControlledFieldStore = (formId, selector) => {
+  const useStore2 = controlledFieldStore(formId);
+  return useStore2(selector);
+};
 const useInternalFormContext = (formId, hookName) => {
   const formContext = useContext(InternalFormContext);
   if (formId)
@@ -2773,7 +2084,7 @@ function useErrorResponseForForm({
 }
 const useFieldErrorsForForm = (context) => {
   const response = useErrorResponseForForm(context);
-  const hydrated = useFormAtomValue(isHydratedAtom(context.formId));
+  const hydrated = useFormStore(context.formId, (state) => state.isHydrated);
   return hydratable.from(response == null ? void 0 : response.fieldErrors, hydrated);
 };
 const useDefaultValuesFromLoader = ({
@@ -2789,7 +2100,7 @@ const useDefaultValuesFromLoader = ({
 };
 const useDefaultValuesForForm = (context) => {
   const { formId, defaultValuesProp } = context;
-  const hydrated = useFormAtomValue(isHydratedAtom(formId));
+  const hydrated = useFormStore(formId, (state) => state.isHydrated);
   const errorResponse = useErrorResponseForForm(context);
   const defaultValuesFromLoader = useDefaultValuesFromLoader(context);
   if (hydrated)
@@ -2809,131 +2120,124 @@ const useHasActiveFormSubmit = ({
   const hasActiveSubmission = fetcher ? fetcher.state === "submitting" : !!transition.submission;
   return hasActiveSubmission;
 };
-const useFieldTouched = (field, { formId }) => useFormAtom(fieldTouchedAtom({ formId, field }));
+const useFieldTouched = (field, { formId }) => {
+  const touched = useFormStore(formId, (state) => state.touchedFields[field]);
+  const setFieldTouched = useFormStore(formId, (state) => state.setTouched);
+  const setTouched = useCallback((touched2) => setFieldTouched(field, touched2), [field, setFieldTouched]);
+  return [touched, setTouched];
+};
 const useFieldError = (name, context) => {
   const fieldErrors = useFieldErrorsForForm(context);
-  const [state, set2] = useFormAtom(fieldErrorAtom({ formId: context.formId, field: name }));
-  return [
-    fieldErrors.map((fieldErrors2) => fieldErrors2 == null ? void 0 : fieldErrors2[name]).hydrateTo(state),
-    set2
-  ];
+  const state = useFormStore(context.formId, (state2) => state2.fieldErrors[name]);
+  return fieldErrors.map((fieldErrors2) => fieldErrors2 == null ? void 0 : fieldErrors2[name]).hydrateTo(state);
+};
+const useClearError = (context) => {
+  const { formId } = context;
+  return useFormStore(formId, (state) => state.clearFieldError);
 };
 const useFieldDefaultValue = (name, context) => {
   const defaultValues = useDefaultValuesForForm(context);
-  const { defaultValues: state } = useFormAtomValue(formPropsAtom(context.formId));
+  const state = useSyncedDefaultValues(context.formId);
   return defaultValues.map((val) => get_1(val, name)).hydrateTo(get_1(state, name));
 };
-const useClearError = ({ formId }) => {
-  const updateError = useFormUpdateAtom(setFieldErrorAtom(formId));
-  return useCallback((name) => updateError({ field: name, error: void 0 }), [updateError]);
+const useInternalIsSubmitting = (formId) => useFormStore(formId, (state) => state.isSubmitting);
+const useInternalIsValid = (formId) => useFormStore(formId, (state) => state.isValid());
+const useInternalHasBeenSubmitted = (formId) => useFormStore(formId, (state) => state.hasBeenSubmitted);
+const useValidateField = (formId) => useFormStore(formId, (state) => state.validateField);
+const useValidate = (formId) => useFormStore(formId, (state) => state.validate);
+const noOpReceiver = () => () => {
 };
-const useSetTouched = ({ formId }) => {
-  const setTouched = useFormUpdateAtom(setTouchedAtom(formId));
-  return useCallback((name, touched) => setTouched({ field: name, touched }), [setTouched]);
-};
-const controlledFieldsAtom = formAtomFamily({});
-const refCountAtom = fieldAtomFamily(() => atom(0));
-const fieldValueAtom = fieldAtomFamily(() => atom(void 0));
-const fieldValueHydratedAtom = fieldAtomFamily(() => atom(false));
-const valueUpdatePromiseAtom = fieldAtomFamily(() => atom(void 0));
-const resolveValueUpdateAtom = fieldAtomFamily(() => atom(void 0));
-const registerAtom = atom(null, (get2, set2, { formId, field }) => {
-  set2(refCountAtom({ formId, field }), (prev) => prev + 1);
-  const newRefCount = get2(refCountAtom({ formId, field }));
-  if (newRefCount === 1) {
-    set2(controlledFieldsAtom(formId), (prev) => __spreadProps(__spreadValues({}, prev), {
-      [field]: fieldValueAtom({ formId, field })
-    }));
-  }
+const useRegisterReceiveFocus = (formId) => useFormStore(formId, (state) => {
+  var _a, _b;
+  return (_b = (_a = state.formProps) == null ? void 0 : _a.registerReceiveFocus) != null ? _b : noOpReceiver;
 });
-const unregisterAtom = atom(null, (get2, set2, { formId, field }) => {
-  set2(refCountAtom({ formId, field }), (prev) => prev - 1);
-  const newRefCount = get2(refCountAtom({ formId, field }));
-  if (newRefCount === 0) {
-    set2(controlledFieldsAtom(formId), (prev) => omit_1(prev, field));
-    fieldValueAtom.remove({ formId, field });
-    resolveValueUpdateAtom.remove({ formId, field });
-    fieldValueHydratedAtom.remove({ formId, field });
-  }
+const defaultDefaultValues = {};
+const useSyncedDefaultValues = (formId) => useFormStore(formId, (state) => {
+  var _a, _b;
+  return (_b = (_a = state.formProps) == null ? void 0 : _a.defaultValues) != null ? _b : defaultDefaultValues;
 });
-const setControlledFieldValueAtom = atom(null, (_get, set2, {
-  formId,
-  field,
-  value
-}) => {
-  set2(fieldValueAtom({ formId, field }), value);
-  const resolveAtom = resolveValueUpdateAtom({ formId, field });
-  const promiseAtom = valueUpdatePromiseAtom({ formId, field });
-  const promise = new Promise((resolve) => set2(resolveAtom, () => {
-    resolve();
-    set2(resolveAtom, void 0);
-    set2(promiseAtom, void 0);
-  }));
-  set2(promiseAtom, promise);
+const useSetTouched = ({ formId }) => useFormStore(formId, (state) => state.setTouched);
+const useTouchedFields = (formId) => useFormStore(formId, (state) => state.touchedFields);
+const useFieldErrors = (formId) => useFormStore(formId, (state) => state.fieldErrors);
+const useSetFieldErrors = (formId) => useFormStore(formId, (state) => state.setFieldErrors);
+const useResetFormElement = (formId) => useFormStore(formId, (state) => state.resetFormElement);
+const useFormActionProp = (formId) => useFormStore(formId, (state) => {
+  var _a;
+  return (_a = state.formProps) == null ? void 0 : _a.action;
+});
+const useFormSubactionProp = (formId) => useFormStore(formId, (state) => {
+  var _a;
+  return (_a = state.formProps) == null ? void 0 : _a.subaction;
 });
 const useControlledFieldValue = (context, field) => {
-  const fieldAtom = fieldValueAtom({ formId: context.formId, field });
-  const [value, setValue] = useFormAtom(fieldAtom);
+  const useValueStore = controlledFieldStore(context.formId);
+  const value = useValueStore((state) => {
+    var _a;
+    return (_a = state.fields[field]) == null ? void 0 : _a.value;
+  });
+  const useFormStore2 = formStore(context.formId);
+  const isFormHydrated = useFormStore2((state) => state.isHydrated);
   const defaultValue = useFieldDefaultValue(field, context);
-  const isHydrated = useFormAtomValue(isHydratedAtom(context.formId));
-  const [isFieldHydrated, setIsFieldHydrated] = useFormAtom(fieldValueHydratedAtom({ formId: context.formId, field }));
+  const isFieldHydrated = useValueStore((state) => {
+    var _a, _b;
+    return (_b = (_a = state.fields[field]) == null ? void 0 : _a.hydrated) != null ? _b : false;
+  });
+  const hydrateWithDefault = useValueStore((state) => state.hydrateWithDefault);
   useEffect(() => {
-    if (isHydrated && !isFieldHydrated) {
-      setValue(defaultValue);
-      setIsFieldHydrated(true);
+    if (isFormHydrated && !isFieldHydrated) {
+      hydrateWithDefault(field, defaultValue);
     }
   }, [
     defaultValue,
     field,
-    context.formId,
+    hydrateWithDefault,
     isFieldHydrated,
-    isHydrated,
-    setIsFieldHydrated,
-    setValue
+    isFormHydrated
   ]);
   return isFieldHydrated ? value : defaultValue;
 };
 const useControllableValue = (context, field) => {
-  const resolveUpdate = useFormAtomValue(resolveValueUpdateAtom({ formId: context.formId, field }));
+  const useValueStore = controlledFieldStore(context.formId);
+  const resolveUpdate = useValueStore((state) => {
+    var _a;
+    return (_a = state.fields[field]) == null ? void 0 : _a.resolveValueUpdate;
+  });
   useEffect(() => {
     resolveUpdate == null ? void 0 : resolveUpdate();
   }, [resolveUpdate]);
-  const register = useFormUpdateAtom(registerAtom);
-  const unregister = useFormUpdateAtom(unregisterAtom);
+  const register = useValueStore((state) => state.register);
+  const unregister = useValueStore((state) => state.unregister);
   useEffect(() => {
-    register({ formId: context.formId, field });
-    return () => unregister({ formId: context.formId, field });
+    register(field);
+    return () => unregister(field);
   }, [context.formId, field, register, unregister]);
-  const setControlledFieldValue = useFormUpdateAtom(setControlledFieldValueAtom);
-  const setValue = useCallback((value2) => setControlledFieldValue({ formId: context.formId, field, value: value2 }), [field, context.formId, setControlledFieldValue]);
+  const setControlledFieldValue = useValueStore((state) => state.setValue);
+  const setValue = useCallback((value2) => setControlledFieldValue(field, value2), [field, setControlledFieldValue]);
   const value = useControlledFieldValue(context, field);
   return [value, setValue];
 };
 const useUpdateControllableValue = (formId) => {
-  const setControlledFieldValue = useFormUpdateAtom(setControlledFieldValueAtom);
-  return useCallback((field, value) => setControlledFieldValue({ formId, field, value }), [formId, setControlledFieldValue]);
-};
-const useAwaitValue = (formId) => {
-  return useAtomCallback(useCallback(async (get2, _set, field) => {
-    await get2(valueUpdatePromiseAtom({ formId, field }));
-  }, [formId]));
+  const useValueStore = controlledFieldStore(formId);
+  return useValueStore((state) => state.setValue);
 };
 const useIsSubmitting = (formId) => {
   const formContext = useInternalFormContext(formId, "useIsSubmitting");
-  return useFormAtomValue(isSubmittingAtom(formContext.formId));
+  return useInternalIsSubmitting(formContext.formId);
 };
 const useIsValid = (formId) => {
   const formContext = useInternalFormContext(formId, "useIsValid");
-  return useFormAtomValue(isValidAtom(formContext.formId));
+  return useInternalIsValid(formContext.formId);
 };
 const useField = (name, options) => {
   const { formId: providedFormId, handleReceiveFocus } = options != null ? options : {};
   const formContext = useInternalFormContext(providedFormId, "useField");
   const defaultValue = useFieldDefaultValue(name, formContext);
   const [touched, setTouched] = useFieldTouched(name, formContext);
-  const [error, setError] = useFieldError(name, formContext);
-  const hasBeenSubmitted = useFormAtomValue(hasBeenSubmittedAtom(formContext.formId));
-  const { validateField, registerReceiveFocus } = useFormAtomValue(formPropsAtom(formContext.formId));
+  const error = useFieldError(name, formContext);
+  const clearError = useClearError(formContext);
+  const hasBeenSubmitted = useInternalHasBeenSubmitted(formContext.formId);
+  const validateField = useValidateField(formContext.formId);
+  const registerReceiveFocus = useRegisterReceiveFocus(formContext.formId);
   useEffect(() => {
     if (handleReceiveFocus)
       return registerReceiveFocus(name, handleReceiveFocus);
@@ -2941,7 +2245,7 @@ const useField = (name, options) => {
   const field = useMemo(() => {
     const helpers = {
       error,
-      clearError: () => setError(void 0),
+      clearError: () => clearError(name),
       validate: () => {
         validateField(name);
       },
@@ -2959,13 +2263,13 @@ const useField = (name, options) => {
     });
   }, [
     error,
+    clearError,
     defaultValue,
     touched,
     setTouched,
     name,
     hasBeenSubmitted,
     options == null ? void 0 : options.validationBehavior,
-    setError,
     validateField
   ]);
   return field;
@@ -3133,14 +2437,10 @@ const useMultiValueMap = () => {
     return ref.current;
   }, []);
 };
-const resetAtom = atomFamily((formId) => atom(null, (get2, set2) => {
-  set2(fieldErrorsAtom(formId), {});
-  set2(touchedFieldsAtom(formId), {});
-  set2(hasBeenSubmittedAtom(formId), false);
-  const { defaultValues } = get2(formPropsAtom(formId));
-  const controlledFields = get2(controlledFieldsAtom(formId));
-  Object.entries(controlledFields).forEach(([name, atom2]) => set2(atom2, get_1(defaultValues, name)));
-}));
+const cleanupFormState = (formId) => {
+  formStore.remove(formId);
+  controlledFieldStore.remove(formId);
+};
 function useSubmitComplete(isSubmitting, callback) {
   const isPending = useRef(false);
   useEffect(() => {
@@ -3153,6 +2453,11 @@ function useSubmitComplete(isSubmitting, callback) {
     }
   });
 }
+var baseIsEqual = _baseIsEqual;
+function isEqual(value, other) {
+  return baseIsEqual(value, other);
+}
+var isEqual_1 = isEqual;
 const mergeRefs = (refs) => {
   return (value) => {
     refs.filter(Boolean).forEach((ref) => {
@@ -3296,31 +2601,19 @@ function ValidatedForm(_a) {
   const formRef = useRef(null);
   const Form$1 = (_a2 = fetcher == null ? void 0 : fetcher.Form) != null ? _a2 : Form;
   const submit = useSubmit();
-  const setFieldErrors = useFormUpdateAtom(fieldErrorsAtom(formId));
-  const setFieldError = useFormUpdateAtom(setFieldErrorAtom(formId));
-  const reset = useFormUpdateAtom(resetAtom(formId));
-  const startSubmit = useFormUpdateAtom(startSubmitAtom(formId));
-  const endSubmit = useFormUpdateAtom(endSubmitAtom(formId));
-  const syncFormProps = useFormUpdateAtom(formPropsAtom(formId));
-  const setHydrated = useFormUpdateAtom(isHydratedAtom(formId));
-  const setFormElementInState = useFormUpdateAtom(formElementAtom(formId));
+  const setFieldErrors = useSetFieldErrors(formId);
+  const setFieldError = useFormStore(formId, (state) => state.setFieldError);
+  const reset = useFormStore(formId, (state) => state.reset);
+  const resetControlledFields = useControlledFieldStore(formId, (state) => state.reset);
+  const startSubmit = useFormStore(formId, (state) => state.startSubmit);
+  const endSubmit = useFormStore(formId, (state) => state.endSubmit);
+  const syncFormProps = useFormStore(formId, (state) => state.syncFormProps);
+  const setHydrated = useFormStore(formId, (state) => state.setHydrated);
+  const setFormElementInState = useFormStore(formId, (state) => state.setFormElement);
   useEffect(() => {
-    setHydrated(true);
+    setHydrated();
     return () => cleanupFormState(formId);
   }, [formId, setHydrated]);
-  const awaitValue = useAwaitValue(formId);
-  const validateField = useCallback(async (field) => {
-    invariant(formRef.current);
-    await awaitValue(field);
-    const { error } = await validator.validateField(getDataFromForm(formRef.current), field);
-    if (error) {
-      setFieldError({ field, error });
-      return error;
-    } else {
-      setFieldError({ field, error: void 0 });
-      return null;
-    }
-  }, [awaitValue, setFieldError, validator]);
   const customFocusHandlers = useMultiValueMap();
   const registerReceiveFocus = useCallback((fieldName, handler) => {
     customFocusHandlers().add(fieldName, handler);
@@ -3334,8 +2627,8 @@ function ValidatedForm(_a) {
       action,
       defaultValues: (_a3 = providedDefaultValues != null ? providedDefaultValues : backendDefaultValues) != null ? _a3 : {},
       subaction,
-      validateField,
-      registerReceiveFocus
+      registerReceiveFocus,
+      validator
     });
   }, [
     action,
@@ -3343,8 +2636,8 @@ function ValidatedForm(_a) {
     registerReceiveFocus,
     subaction,
     syncFormProps,
-    validateField,
-    backendDefaultValues
+    backendDefaultValues,
+    validator
   ]);
   useEffect(() => {
     var _a3;
@@ -3371,9 +2664,9 @@ function ValidatedForm(_a) {
       window.removeEventListener("click", handleClick, { capture: true });
     };
   }, []);
-  const handleSubmit = async (e) => {
+  const handleSubmit = async (e2) => {
     startSubmit();
-    const result = await validator.validate(getDataFromForm(e.currentTarget));
+    const result = await validator.validate(getDataFromForm(e2.currentTarget));
     if (result.error) {
       endSubmit();
       setFieldErrors(result.error.fieldErrors);
@@ -3381,7 +2674,7 @@ function ValidatedForm(_a) {
         focusFirstInvalidInput(result.error.fieldErrors, customFocusHandlers(), formRef.current);
       }
     } else {
-      const eventProxy = formEventProxy(e);
+      const eventProxy = formEventProxy(e2);
       await (onSubmit == null ? void 0 : onSubmit(result.data, eventProxy));
       if (eventProxy.defaultPrevented) {
         endSubmit();
@@ -3404,15 +2697,16 @@ function ValidatedForm(_a) {
     action,
     method,
     replace,
-    onSubmit: (e) => {
-      e.preventDefault();
-      handleSubmit(e);
+    onSubmit: (e2) => {
+      e2.preventDefault();
+      handleSubmit(e2);
     },
     onReset: (event) => {
       onReset == null ? void 0 : onReset(event);
       if (event.defaultPrevented)
         return;
       reset();
+      resetControlledFields();
     }
   }), /* @__PURE__ */ React.createElement(InternalFormContext.Provider, {
     value: contextValue
@@ -3472,18 +2766,22 @@ function createValidator(validator) {
   };
 }
 const useFormState = (formId) => {
-  const formContext = useInternalFormContext(formId, "useIsValid");
-  const formProps = useFormAtomValue(formPropsAtom(formContext.formId));
-  const isSubmitting = useFormAtomValue(isSubmittingAtom(formContext.formId));
-  const hasBeenSubmitted = useFormAtomValue(hasBeenSubmittedAtom(formContext.formId));
-  const touchedFields = useFormAtomValue(touchedFieldsAtom(formContext.formId));
-  const isValid = useFormAtomValue(isValidAtom(formContext.formId));
+  const formContext = useInternalFormContext(formId, "useFormState");
+  const isSubmitting = useInternalIsSubmitting(formContext.formId);
+  const hasBeenSubmitted = useInternalHasBeenSubmitted(formContext.formId);
+  const touchedFields = useTouchedFields(formContext.formId);
+  const isValid = useInternalIsValid(formContext.formId);
+  const action = useFormActionProp(formContext.formId);
+  const subaction = useFormSubactionProp(formContext.formId);
+  const syncedDefaultValues = useSyncedDefaultValues(formContext.formId);
   const defaultValuesToUse = useDefaultValuesForForm(formContext);
-  const hydratedDefaultValues = defaultValuesToUse.hydrateTo(formProps.defaultValues);
-  const fieldErrorsFromState = useFormAtomValue(fieldErrorsAtom(formContext.formId));
+  const hydratedDefaultValues = defaultValuesToUse.hydrateTo(syncedDefaultValues);
+  const fieldErrorsFromState = useFieldErrors(formContext.formId);
   const fieldErrorsToUse = useFieldErrorsForForm(formContext);
   const hydratedFieldErrors = fieldErrorsToUse.hydrateTo(fieldErrorsFromState);
-  return useMemo(() => __spreadProps(__spreadValues({}, formProps), {
+  return useMemo(() => ({
+    action,
+    subaction,
     defaultValues: hydratedDefaultValues,
     fieldErrors: hydratedFieldErrors != null ? hydratedFieldErrors : {},
     hasBeenSubmitted,
@@ -3491,25 +2789,32 @@ const useFormState = (formId) => {
     touchedFields,
     isValid
   }), [
-    formProps,
+    action,
     hasBeenSubmitted,
     hydratedDefaultValues,
     hydratedFieldErrors,
     isSubmitting,
     isValid,
+    subaction,
     touchedFields
   ]);
 };
 const useFormHelpers = (formId) => {
   const formContext = useInternalFormContext(formId, "useFormHelpers");
   const setTouched = useSetTouched(formContext);
-  const { validateField } = useFormAtomValue(formPropsAtom(formContext.formId));
+  const validateField = useValidateField(formContext.formId);
+  const validate = useValidate(formContext.formId);
   const clearError = useClearError(formContext);
+  const setFieldErrors = useSetFieldErrors(formContext.formId);
+  const reset = useResetFormElement(formContext.formId);
   return useMemo(() => ({
     setTouched,
     validateField,
-    clearError
-  }), [clearError, setTouched, validateField]);
+    clearError,
+    validate,
+    clearAllErrors: () => setFieldErrors({}),
+    reset
+  }), [clearError, reset, setFieldErrors, setTouched, validate, validateField]);
 };
 const useFormContext = (formId) => {
   const context = useInternalFormContext(formId, "useFormContext");
@@ -3517,9 +2822,11 @@ const useFormContext = (formId) => {
   const {
     clearError: internalClearError,
     setTouched,
-    validateField
+    validateField,
+    clearAllErrors,
+    validate
   } = useFormHelpers(formId);
-  const { registerReceiveFocus } = useFormAtomValue(formPropsAtom(context.formId));
+  const registerReceiveFocus = useRegisterReceiveFocus(context.formId);
   const clearError = useCallback((...names) => {
     names.forEach((name) => {
       internalClearError(name);
@@ -3529,7 +2836,9 @@ const useFormContext = (formId) => {
     setFieldTouched: setTouched,
     validateField,
     clearError,
-    registerReceiveFocus
+    registerReceiveFocus,
+    clearAllErrors,
+    validate
   });
 };
 export { ValidatedForm, createValidator, setFormDefaults, useControlField, useField, useFormContext, useIsSubmitting, useIsValid, useUpdateControlledField, validationError };