remix-validated-form 4.2.0 → 4.4.0

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

@@ -0,0 +1,2844 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+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 = (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(b2)) {
+      if (__propIsEnum.call(b2, prop))
+        __defNormalProp(a2, prop, b2[prop]);
+    }
+  return a2;
+};
+var __spreadProps = (a2, b2) => __defProps(a2, __getOwnPropDescs(b2));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+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 : {};
+function listCacheClear$1() {
+  this.__data__ = [];
+  this.size = 0;
+}
+var _listCacheClear = listCacheClear$1;
+function eq$3(value, other) {
+  return value === other || value !== value && other !== other;
+}
+var eq_1 = eq$3;
+var eq$2 = eq_1;
+function assocIndexOf$4(array, key) {
+  var length = array.length;
+  while (length--) {
+    if (eq$2(array[length][0], key)) {
+      return length;
+    }
+  }
+  return -1;
+}
+var _assocIndexOf = assocIndexOf$4;
+var assocIndexOf$3 = _assocIndexOf;
+var arrayProto = Array.prototype;
+var splice = arrayProto.splice;
+function listCacheDelete$1(key) {
+  var data = this.__data__, index = assocIndexOf$3(data, key);
+  if (index < 0) {
+    return false;
+  }
+  var lastIndex = data.length - 1;
+  if (index == lastIndex) {
+    data.pop();
+  } else {
+    splice.call(data, index, 1);
+  }
+  --this.size;
+  return true;
+}
+var _listCacheDelete = listCacheDelete$1;
+var assocIndexOf$2 = _assocIndexOf;
+function listCacheGet$1(key) {
+  var data = this.__data__, index = assocIndexOf$2(data, key);
+  return index < 0 ? void 0 : data[index][1];
+}
+var _listCacheGet = listCacheGet$1;
+var assocIndexOf$1 = _assocIndexOf;
+function listCacheHas$1(key) {
+  return assocIndexOf$1(this.__data__, key) > -1;
+}
+var _listCacheHas = listCacheHas$1;
+var assocIndexOf = _assocIndexOf;
+function listCacheSet$1(key, value) {
+  var data = this.__data__, index = assocIndexOf(data, key);
+  if (index < 0) {
+    ++this.size;
+    data.push([key, value]);
+  } else {
+    data[index][1] = value;
+  }
+  return this;
+}
+var _listCacheSet = listCacheSet$1;
+var listCacheClear = _listCacheClear, listCacheDelete = _listCacheDelete, listCacheGet = _listCacheGet, listCacheHas = _listCacheHas, listCacheSet = _listCacheSet;
+function ListCache$4(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+ListCache$4.prototype.clear = listCacheClear;
+ListCache$4.prototype["delete"] = listCacheDelete;
+ListCache$4.prototype.get = listCacheGet;
+ListCache$4.prototype.has = listCacheHas;
+ListCache$4.prototype.set = listCacheSet;
+var _ListCache = ListCache$4;
+var ListCache$3 = _ListCache;
+function stackClear$1() {
+  this.__data__ = new ListCache$3();
+  this.size = 0;
+}
+var _stackClear = stackClear$1;
+function stackDelete$1(key) {
+  var data = this.__data__, result = data["delete"](key);
+  this.size = data.size;
+  return result;
+}
+var _stackDelete = stackDelete$1;
+function stackGet$1(key) {
+  return this.__data__.get(key);
+}
+var _stackGet = stackGet$1;
+function stackHas$1(key) {
+  return this.__data__.has(key);
+}
+var _stackHas = stackHas$1;
+var freeGlobal$1 = typeof commonjsGlobal == "object" && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
+var _freeGlobal = freeGlobal$1;
+var freeGlobal = _freeGlobal;
+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$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$a.call(value, symToStringTag$1), tag = value[symToStringTag$1];
+  try {
+    value[symToStringTag$1] = void 0;
+    var unmasked = true;
+  } catch (e2) {
+  }
+  var result = nativeObjectToString$1.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag$1] = tag;
+    } else {
+      delete value[symToStringTag$1];
+    }
+  }
+  return result;
+}
+var _getRawTag = getRawTag$1;
+var objectProto$c = Object.prototype;
+var nativeObjectToString = objectProto$c.toString;
+function objectToString$1(value) {
+  return nativeObjectToString.call(value);
+}
+var _objectToString = objectToString$1;
+var Symbol$3 = _Symbol, getRawTag = _getRawTag, objectToString = _objectToString;
+var nullTag = "[object Null]", undefinedTag = "[object Undefined]";
+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$5;
+function isObject$5(value) {
+  var type = typeof value;
+  return value != null && (type == "object" || type == "function");
+}
+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$4(value)) {
+    return false;
+  }
+  var tag = baseGetTag$4(value);
+  return tag == funcTag$1 || tag == genTag || tag == asyncTag || tag == proxyTag;
+}
+var isFunction_1 = isFunction$2;
+var root$6 = _root;
+var coreJsData$1 = root$6["__core-js_shared__"];
+var _coreJsData = coreJsData$1;
+var coreJsData = _coreJsData;
+var maskSrcKey = function() {
+  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
+  return uid ? "Symbol(src)_1." + uid : "";
+}();
+function isMasked$1(func) {
+  return !!maskSrcKey && maskSrcKey in func;
+}
+var _isMasked = isMasked$1;
+var funcProto$1 = Function.prototype;
+var funcToString$1 = funcProto$1.toString;
+function toSource$2(func) {
+  if (func != null) {
+    try {
+      return funcToString$1.call(func);
+    } catch (e2) {
+    }
+    try {
+      return func + "";
+    } catch (e2) {
+    }
+  }
+  return "";
+}
+var _toSource = toSource$2;
+var isFunction$1 = isFunction_1, isMasked = _isMasked, isObject$3 = isObject_1, toSource$1 = _toSource;
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+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$3(value) || isMasked(value)) {
+    return false;
+  }
+  var pattern = isFunction$1(value) ? reIsNative : reIsHostCtor;
+  return pattern.test(toSource$1(value));
+}
+var _baseIsNative = baseIsNative$1;
+function getValue$1(object, key) {
+  return object == null ? void 0 : object[key];
+}
+var _getValue = getValue$1;
+var baseIsNative = _baseIsNative, getValue = _getValue;
+function getNative$7(object, key) {
+  var value = getValue(object, key);
+  return baseIsNative(value) ? value : void 0;
+}
+var _getNative = getNative$7;
+var getNative$6 = _getNative, root$5 = _root;
+var Map$4 = getNative$6(root$5, "Map");
+var _Map = Map$4;
+var getNative$5 = _getNative;
+var nativeCreate$4 = getNative$5(Object, "create");
+var _nativeCreate = nativeCreate$4;
+var nativeCreate$3 = _nativeCreate;
+function hashClear$1() {
+  this.__data__ = nativeCreate$3 ? nativeCreate$3(null) : {};
+  this.size = 0;
+}
+var _hashClear = hashClear$1;
+function hashDelete$1(key) {
+  var result = this.has(key) && delete this.__data__[key];
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var _hashDelete = hashDelete$1;
+var nativeCreate$2 = _nativeCreate;
+var HASH_UNDEFINED$2 = "__lodash_hash_undefined__";
+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$8.call(data, key) ? data[key] : void 0;
+}
+var _hashGet = hashGet$1;
+var nativeCreate$1 = _nativeCreate;
+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$7.call(data, key);
+}
+var _hashHas = hashHas$1;
+var nativeCreate = _nativeCreate;
+var HASH_UNDEFINED$1 = "__lodash_hash_undefined__";
+function hashSet$1(key, value) {
+  var data = this.__data__;
+  this.size += this.has(key) ? 0 : 1;
+  data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED$1 : value;
+  return this;
+}
+var _hashSet = hashSet$1;
+var hashClear = _hashClear, hashDelete = _hashDelete, hashGet = _hashGet, hashHas = _hashHas, hashSet = _hashSet;
+function Hash$1(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+Hash$1.prototype.clear = hashClear;
+Hash$1.prototype["delete"] = hashDelete;
+Hash$1.prototype.get = hashGet;
+Hash$1.prototype.has = hashHas;
+Hash$1.prototype.set = hashSet;
+var _Hash = Hash$1;
+var Hash = _Hash, ListCache$2 = _ListCache, Map$3 = _Map;
+function mapCacheClear$1() {
+  this.size = 0;
+  this.__data__ = {
+    "hash": new Hash(),
+    "map": new (Map$3 || ListCache$2)(),
+    "string": new Hash()
+  };
+}
+var _mapCacheClear = mapCacheClear$1;
+function isKeyable$1(value) {
+  var type = typeof value;
+  return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+}
+var _isKeyable = isKeyable$1;
+var isKeyable = _isKeyable;
+function getMapData$4(map, key) {
+  var data = map.__data__;
+  return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+}
+var _getMapData = getMapData$4;
+var getMapData$3 = _getMapData;
+function mapCacheDelete$1(key) {
+  var result = getMapData$3(this, key)["delete"](key);
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var _mapCacheDelete = mapCacheDelete$1;
+var getMapData$2 = _getMapData;
+function mapCacheGet$1(key) {
+  return getMapData$2(this, key).get(key);
+}
+var _mapCacheGet = mapCacheGet$1;
+var getMapData$1 = _getMapData;
+function mapCacheHas$1(key) {
+  return getMapData$1(this, key).has(key);
+}
+var _mapCacheHas = mapCacheHas$1;
+var getMapData = _getMapData;
+function mapCacheSet$1(key, value) {
+  var data = getMapData(this, key), size = data.size;
+  data.set(key, value);
+  this.size += data.size == size ? 0 : 1;
+  return this;
+}
+var _mapCacheSet = mapCacheSet$1;
+var mapCacheClear = _mapCacheClear, mapCacheDelete = _mapCacheDelete, mapCacheGet = _mapCacheGet, mapCacheHas = _mapCacheHas, mapCacheSet = _mapCacheSet;
+function MapCache$3(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+MapCache$3.prototype.clear = mapCacheClear;
+MapCache$3.prototype["delete"] = mapCacheDelete;
+MapCache$3.prototype.get = mapCacheGet;
+MapCache$3.prototype.has = mapCacheHas;
+MapCache$3.prototype.set = mapCacheSet;
+var _MapCache = MapCache$3;
+var ListCache$1 = _ListCache, Map$2 = _Map, MapCache$2 = _MapCache;
+var LARGE_ARRAY_SIZE$1 = 200;
+function stackSet$1(key, value) {
+  var data = this.__data__;
+  if (data instanceof ListCache$1) {
+    var pairs = data.__data__;
+    if (!Map$2 || pairs.length < LARGE_ARRAY_SIZE$1 - 1) {
+      pairs.push([key, value]);
+      this.size = ++data.size;
+      return this;
+    }
+    data = this.__data__ = new MapCache$2(pairs);
+  }
+  data.set(key, value);
+  this.size = data.size;
+  return this;
+}
+var _stackSet = stackSet$1;
+var ListCache = _ListCache, stackClear = _stackClear, stackDelete = _stackDelete, stackGet = _stackGet, stackHas = _stackHas, stackSet = _stackSet;
+function Stack$2(entries) {
+  var data = this.__data__ = new ListCache(entries);
+  this.size = data.size;
+}
+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);
+  return this;
+}
+var _setCacheAdd = setCacheAdd$1;
+function setCacheHas$1(value) {
+  return this.__data__.has(value);
+}
+var _setCacheHas = setCacheHas$1;
+var MapCache$1 = _MapCache, setCacheAdd = _setCacheAdd, setCacheHas = _setCacheHas;
+function SetCache$2(values) {
+  var index = -1, length = values == null ? 0 : values.length;
+  this.__data__ = new MapCache$1();
+  while (++index < length) {
+    this.add(values[index]);
+  }
+}
+SetCache$2.prototype.add = SetCache$2.prototype.push = setCacheAdd;
+SetCache$2.prototype.has = setCacheHas;
+var _SetCache = SetCache$2;
+function arraySome$1(array, predicate) {
+  var index = -1, length = array == null ? 0 : array.length;
+  while (++index < length) {
+    if (predicate(array[index], index, array)) {
+      return true;
+    }
+  }
+  return false;
+}
+var _arraySome = arraySome$1;
+function cacheHas$2(cache, key) {
+  return cache.has(key);
+}
+var _cacheHas = cacheHas$2;
+var SetCache$1 = _SetCache, arraySome = _arraySome, cacheHas$1 = _cacheHas;
+var COMPARE_PARTIAL_FLAG$5 = 1, COMPARE_UNORDERED_FLAG$3 = 2;
+function equalArrays$2(array, other, bitmask, customizer, equalFunc, stack) {
+  var isPartial = bitmask & COMPARE_PARTIAL_FLAG$5, arrLength = array.length, othLength = other.length;
+  if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
+    return false;
+  }
+  var arrStacked = stack.get(array);
+  var othStacked = stack.get(other);
+  if (arrStacked && othStacked) {
+    return arrStacked == other && othStacked == array;
+  }
+  var index = -1, result = true, seen = bitmask & COMPARE_UNORDERED_FLAG$3 ? new SetCache$1() : void 0;
+  stack.set(array, other);
+  stack.set(other, array);
+  while (++index < arrLength) {
+    var arrValue = array[index], othValue = other[index];
+    if (customizer) {
+      var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
+    }
+    if (compared !== void 0) {
+      if (compared) {
+        continue;
+      }
+      result = false;
+      break;
+    }
+    if (seen) {
+      if (!arraySome(other, function(othValue2, othIndex) {
+        if (!cacheHas$1(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack))) {
+          return seen.push(othIndex);
+        }
+      })) {
+        result = false;
+        break;
+      }
+    } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
+      result = false;
+      break;
+    }
+  }
+  stack["delete"](array);
+  stack["delete"](other);
+  return result;
+}
+var _equalArrays = equalArrays$2;
+var root$4 = _root;
+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) {
+    result[++index] = [key, value];
+  });
+  return result;
+}
+var _mapToArray = mapToArray$1;
+function setToArray$3(set2) {
+  var index = -1, result = Array(set2.size);
+  set2.forEach(function(value) {
+    result[++index] = value;
+  });
+  return result;
+}
+var _setToArray = setToArray$3;
+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$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$2:
+      if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
+        return false;
+      }
+      object = object.buffer;
+      other = other.buffer;
+    case arrayBufferTag$1:
+      if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array2(object), new Uint8Array2(other))) {
+        return false;
+      }
+      return true;
+    case boolTag$1:
+    case dateTag$1:
+    case numberTag$1:
+      return eq$1(+object, +other);
+    case errorTag$1:
+      return object.name == other.name && object.message == other.message;
+    case regexpTag$1:
+    case stringTag$1:
+      return object == other + "";
+    case mapTag$2:
+      var convert = mapToArray;
+    case setTag$2:
+      var isPartial = bitmask & COMPARE_PARTIAL_FLAG$4;
+      convert || (convert = setToArray$2);
+      if (object.size != other.size && !isPartial) {
+        return false;
+      }
+      var stacked = stack.get(object);
+      if (stacked) {
+        return stacked == other;
+      }
+      bitmask |= COMPARE_UNORDERED_FLAG$2;
+      stack.set(object, other);
+      var result = equalArrays$1(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
+      stack["delete"](object);
+      return result;
+    case symbolTag$1:
+      if (symbolValueOf) {
+        return symbolValueOf.call(object) == symbolValueOf.call(other);
+      }
+  }
+  return false;
+}
+var _equalByTag = equalByTag$1;
+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$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$7(object) ? result : arrayPush$1(result, symbolsFunc(object));
+}
+var _baseGetAllKeys = baseGetAllKeys$2;
+function arrayFilter$1(array, predicate) {
+  var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
+  while (++index < length) {
+    var value = array[index];
+    if (predicate(value, index, array)) {
+      result[resIndex++] = value;
+    }
+  }
+  return result;
+}
+var _arrayFilter = arrayFilter$1;
+function stubArray$2() {
+  return [];
+}
+var stubArray_1 = stubArray$2;
+var arrayFilter = _arrayFilter, stubArray$1 = stubArray_1;
+var objectProto$8 = Object.prototype;
+var propertyIsEnumerable$1 = objectProto$8.propertyIsEnumerable;
+var nativeGetSymbols$1 = Object.getOwnPropertySymbols;
+var getSymbols$2 = !nativeGetSymbols$1 ? stubArray$1 : function(object) {
+  if (object == null) {
+    return [];
+  }
+  object = Object(object);
+  return arrayFilter(nativeGetSymbols$1(object), function(symbol) {
+    return propertyIsEnumerable$1.call(object, symbol);
+  });
+};
+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$5(value) {
+  return value != null && typeof value == "object";
+}
+var isObjectLike_1 = isObjectLike$5;
+var baseGetTag$3 = _baseGetTag, isObjectLike$4 = isObjectLike_1;
+var argsTag$2 = "[object Arguments]";
+function baseIsArguments$1(value) {
+  return isObjectLike$4(value) && baseGetTag$3(value) == argsTag$2;
+}
+var _baseIsArguments = baseIsArguments$1;
+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$3(value) && hasOwnProperty$6.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
+};
+var isArguments_1 = isArguments$2;
+var isBuffer$2 = { exports: {} };
+function stubFalse() {
+  return false;
+}
+var stubFalse_1 = stubFalse;
+(function(module, exports) {
+  var root2 = _root, stubFalse2 = stubFalse_1;
+  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;
+  var nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : void 0;
+  var isBuffer2 = nativeIsBuffer || stubFalse2;
+  module.exports = isBuffer2;
+})(isBuffer$2, isBuffer$2.exports);
+var MAX_SAFE_INTEGER$1 = 9007199254740991;
+var reIsUint = /^(?:0|[1-9]\d*)$/;
+function isIndex$3(value, length) {
+  var type = typeof value;
+  length = length == null ? MAX_SAFE_INTEGER$1 : length;
+  return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
+}
+var _isIndex = isIndex$3;
+var MAX_SAFE_INTEGER = 9007199254740991;
+function isLength$3(value) {
+  return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+}
+var isLength_1 = isLength$3;
+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] = 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$2(value) && isLength$2(value.length) && !!typedArrayTags[baseGetTag$2(value)];
+}
+var _baseIsTypedArray = baseIsTypedArray$1;
+function baseUnary$1(func) {
+  return function(value) {
+    return func(value);
+  };
+}
+var _baseUnary = baseUnary$1;
+var _nodeUtil = { exports: {} };
+(function(module, exports) {
+  var freeGlobal2 = _freeGlobal;
+  var freeExports = exports && !exports.nodeType && exports;
+  var freeModule = freeExports && true && module && !module.nodeType && module;
+  var moduleExports = freeModule && freeModule.exports === freeExports;
+  var freeProcess = moduleExports && freeGlobal2.process;
+  var nodeUtil2 = function() {
+    try {
+      var types = freeModule && freeModule.require && freeModule.require("util").types;
+      if (types) {
+        return types;
+      }
+      return freeProcess && freeProcess.binding && freeProcess.binding("util");
+    } catch (e2) {
+    }
+  }();
+  module.exports = nodeUtil2;
+})(_nodeUtil, _nodeUtil.exports);
+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$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$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$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$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$2;
+function overArg$2(func, transform) {
+  return function(arg) {
+    return func(transform(arg));
+  };
+}
+var _overArg = overArg$2;
+var overArg$1 = _overArg;
+var nativeKeys$1 = overArg$1(Object.keys, Object);
+var _nativeKeys = nativeKeys$1;
+var isPrototype$1 = _isPrototype, nativeKeys = _nativeKeys;
+var objectProto$4 = Object.prototype;
+var hasOwnProperty$4 = objectProto$4.hasOwnProperty;
+function baseKeys$1(object) {
+  if (!isPrototype$1(object)) {
+    return nativeKeys(object);
+  }
+  var result = [];
+  for (var key in Object(object)) {
+    if (hasOwnProperty$4.call(object, key) && key != "constructor") {
+      result.push(key);
+    }
+  }
+  return result;
+}
+var _baseKeys = baseKeys$1;
+var isFunction = isFunction_1, isLength$1 = isLength_1;
+function isArrayLike$2(value) {
+  return value != null && isLength$1(value.length) && !isFunction(value);
+}
+var isArrayLike_1 = isArrayLike$2;
+var arrayLikeKeys$1 = _arrayLikeKeys, baseKeys = _baseKeys, isArrayLike$1 = isArrayLike_1;
+function keys$2(object) {
+  return isArrayLike$1(object) ? arrayLikeKeys$1(object) : baseKeys(object);
+}
+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$1;
+var getAllKeys = _getAllKeys;
+var COMPARE_PARTIAL_FLAG$3 = 1;
+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(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$3.call(other, key))) {
+      return false;
+    }
+  }
+  var objStacked = stack.get(object);
+  var othStacked = stack.get(other);
+  if (objStacked && othStacked) {
+    return objStacked == other && othStacked == object;
+  }
+  var result = true;
+  stack.set(object, other);
+  stack.set(other, object);
+  var skipCtor = isPartial;
+  while (++index < objLength) {
+    key = objProps[index];
+    var objValue = object[key], othValue = other[key];
+    if (customizer) {
+      var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
+    }
+    if (!(compared === void 0 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
+      result = false;
+      break;
+    }
+    skipCtor || (skipCtor = key == "constructor");
+  }
+  if (result && !skipCtor) {
+    var objCtor = object.constructor, othCtor = other.constructor;
+    if (objCtor != othCtor && ("constructor" in object && "constructor" in other) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) {
+      result = false;
+    }
+  }
+  stack["delete"](object);
+  stack["delete"](other);
+  return result;
+}
+var _equalObjects = equalObjects$1;
+var getNative$4 = _getNative, root$3 = _root;
+var DataView$1 = getNative$4(root$3, "DataView");
+var _DataView = DataView$1;
+var getNative$3 = _getNative, root$2 = _root;
+var Promise$2 = getNative$3(root$2, "Promise");
+var _Promise = Promise$2;
+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$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;
+        case mapCtorString:
+          return mapTag;
+        case promiseCtorString:
+          return promiseTag;
+        case setCtorString:
+          return setTag;
+        case weakMapCtorString:
+          return weakMapTag;
+      }
+    }
+    return result;
+  };
+}
+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 = "[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$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$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$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$1());
+      return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
+    }
+  }
+  if (!isSameTag) {
+    return false;
+  }
+  stack || (stack = new Stack$1());
+  return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
+}
+var _baseIsEqualDeep = baseIsEqualDeep$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$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 = _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;
+  if (object == null) {
+    return !length;
+  }
+  object = Object(object);
+  while (index--) {
+    var data = matchData[index];
+    if (noCustomizer && data[2] ? data[1] !== object[data[0]] : !(data[0] in object)) {
+      return false;
+    }
+  }
+  while (++index < length) {
+    data = matchData[index];
+    var key = data[0], objValue = object[key], srcValue = data[1];
+    if (noCustomizer && data[2]) {
+      if (objValue === void 0 && !(key in object)) {
+        return false;
+      }
+    } else {
+      var stack = new Stack();
+      if (customizer) {
+        var result = customizer(objValue, srcValue, key, object, source, stack);
+      }
+      if (!(result === void 0 ? baseIsEqual$2(srcValue, objValue, COMPARE_PARTIAL_FLAG$1 | COMPARE_UNORDERED_FLAG$1, customizer, stack) : result)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+var _baseIsMatch = baseIsMatch$1;
+var isObject$2 = isObject_1;
+function isStrictComparable$2(value) {
+  return value === value && !isObject$2(value);
+}
+var _isStrictComparable = isStrictComparable$2;
+var isStrictComparable$1 = _isStrictComparable, keys = keys_1;
+function getMatchData$1(object) {
+  var result = keys(object), length = result.length;
+  while (length--) {
+    var key = result[length], value = object[key];
+    result[length] = [key, value, isStrictComparable$1(value)];
+  }
+  return result;
+}
+var _getMatchData = getMatchData$1;
+function matchesStrictComparable$2(key, srcValue) {
+  return function(object) {
+    if (object == null) {
+      return false;
+    }
+    return object[key] === srcValue && (srcValue !== void 0 || key in Object(object));
+  };
+}
+var _matchesStrictComparable = matchesStrictComparable$2;
+var baseIsMatch = _baseIsMatch, getMatchData = _getMatchData, matchesStrictComparable$1 = _matchesStrictComparable;
+function baseMatches$1(source) {
+  var matchData = getMatchData(source);
+  if (matchData.length == 1 && matchData[0][2]) {
+    return matchesStrictComparable$1(matchData[0][0], matchData[0][1]);
+  }
+  return function(object) {
+    return object === source || baseIsMatch(object, source, matchData);
+  };
+}
+var _baseMatches = baseMatches$1;
+var baseGetTag = _baseGetTag, isObjectLike = isObjectLike_1;
+var symbolTag = "[object Symbol]";
+function isSymbol$3(value) {
+  return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag;
+}
+var isSymbol_1 = isSymbol$3;
+var isArray$4 = isArray_1, isSymbol$2 = isSymbol_1;
+var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, reIsPlainProp = /^\w*$/;
+function isKey$3(value, object) {
+  if (isArray$4(value)) {
+    return false;
+  }
+  var type = typeof value;
+  if (type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol$2(value)) {
+    return true;
+  }
+  return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object);
+}
+var _isKey = isKey$3;
+var MapCache = _MapCache;
+var FUNC_ERROR_TEXT$1 = "Expected a function";
+function memoize$1(func, resolver) {
+  if (typeof func != "function" || resolver != null && typeof resolver != "function") {
+    throw new TypeError(FUNC_ERROR_TEXT$1);
+  }
+  var memoized = function() {
+    var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    var result = func.apply(this, args);
+    memoized.cache = cache.set(key, result) || cache;
+    return result;
+  };
+  memoized.cache = new (memoize$1.Cache || MapCache)();
+  return memoized;
+}
+memoize$1.Cache = MapCache;
+var memoize_1 = memoize$1;
+var memoize = memoize_1;
+var MAX_MEMOIZE_SIZE = 500;
+function memoizeCapped$1(func) {
+  var result = memoize(func, function(key) {
+    if (cache.size === MAX_MEMOIZE_SIZE) {
+      cache.clear();
+    }
+    return key;
+  });
+  var cache = result.cache;
+  return result;
+}
+var _memoizeCapped = memoizeCapped$1;
+var memoizeCapped = _memoizeCapped;
+var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+var reEscapeChar = /\\(\\)?/g;
+var stringToPath$1 = memoizeCapped(function(string) {
+  var result = [];
+  if (string.charCodeAt(0) === 46) {
+    result.push("");
+  }
+  string.replace(rePropName, function(match, number, quote, subString) {
+    result.push(quote ? subString.replace(reEscapeChar, "$1") : number || match);
+  });
+  return result;
+});
+var _stringToPath = stringToPath$1;
+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$2;
+var Symbol$1 = _Symbol, arrayMap$1 = _arrayMap, isArray$3 = isArray_1, isSymbol$1 = isSymbol_1;
+var INFINITY$2 = 1 / 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$3(value)) {
+    return arrayMap$1(value, baseToString$1) + "";
+  }
+  if (isSymbol$1(value)) {
+    return symbolToString ? symbolToString.call(value) : "";
+  }
+  var result = value + "";
+  return result == "0" && 1 / value == -INFINITY$2 ? "-0" : result;
+}
+var _baseToString = baseToString$1;
+var baseToString = _baseToString;
+function toString$1(value) {
+  return value == null ? "" : baseToString(value);
+}
+var toString_1 = toString$1;
+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$4;
+var isSymbol = isSymbol_1;
+var INFINITY$1 = 1 / 0;
+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$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$4(path[index++])];
+  }
+  return index && index == length ? object : void 0;
+}
+var _baseGet = baseGet$3;
+var baseGet$2 = _baseGet;
+function get$1(object, path, defaultValue) {
+  var result = object == null ? void 0 : baseGet$2(object, path);
+  return result === void 0 ? defaultValue : result;
+}
+var get_1 = get$1;
+function baseHasIn$1(object, key) {
+  return object != null && key in Object(object);
+}
+var _baseHasIn = baseHasIn$1;
+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$2(path, object);
+  var index = -1, length = path.length, result = false;
+  while (++index < length) {
+    var key = toKey$3(path[index]);
+    if (!(result = object != null && hasFunc(object, key))) {
+      break;
+    }
+    object = object[key];
+  }
+  if (result || ++index != length) {
+    return result;
+  }
+  length = object == null ? 0 : object.length;
+  return !!length && isLength(length) && isIndex$1(key, length) && (isArray$1(object) || isArguments(object));
+}
+var _hasPath = hasPath$1;
+var baseHasIn = _baseHasIn, hasPath = _hasPath;
+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$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$2(path), srcValue);
+  }
+  return function(object) {
+    var objValue = get(object, path);
+    return objValue === void 0 && objValue === srcValue ? hasIn(object, path) : baseIsEqual$1(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
+  };
+}
+var _baseMatchesProperty = baseMatchesProperty$1;
+function identity$1(value) {
+  return value;
+}
+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$1 = _baseGet;
+function basePropertyDeep$1(path) {
+  return function(object) {
+    return baseGet$1(object, path);
+  };
+}
+var _basePropertyDeep = basePropertyDeep$1;
+var baseProperty = _baseProperty, basePropertyDeep = _basePropertyDeep, isKey = _isKey, toKey$1 = _toKey;
+function property$1(path) {
+  return isKey(path) ? baseProperty(toKey$1(path)) : basePropertyDeep(path);
+}
+var property_1 = 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;
+  }
+  if (typeof value == "object") {
+    return isArray(value) ? baseMatchesProperty(value[0], value[1]) : baseMatches(value);
+  }
+  return property(value);
+}
+var _baseIteratee = baseIteratee$2;
+var FUNC_ERROR_TEXT = "Expected a function";
+function negate$1(predicate) {
+  if (typeof predicate != "function") {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  return function() {
+    var args = arguments;
+    switch (args.length) {
+      case 0:
+        return !predicate.call(this);
+      case 1:
+        return !predicate.call(this, args[0]);
+      case 2:
+        return !predicate.call(this, args[0], args[1]);
+      case 3:
+        return !predicate.call(this, args[0], args[1], args[2]);
+    }
+    return !predicate.apply(this, args);
+  };
+}
+var negate_1 = negate$1;
+var getNative = _getNative;
+var defineProperty$1 = function() {
+  try {
+    var func = getNative(Object, "defineProperty");
+    func({}, "", {});
+    return func;
+  } catch (e2) {
+  }
+}();
+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,
+      "writable": true
+    });
+  } else {
+    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$1.call(object, key) && eq(objValue, value)) || value === void 0 && !(key in object)) {
+    baseAssignValue(object, key, value);
+  }
+}
+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$1(object)) {
+    return 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(path[index]), newValue = value;
+    if (key === "__proto__" || key === "constructor" || key === "prototype") {
+      return object;
+    }
+    if (index != lastIndex) {
+      var objValue = nested[key];
+      newValue = customizer ? customizer(objValue, key, nested) : void 0;
+      if (newValue === void 0) {
+        newValue = isObject$1(objValue) ? objValue : isIndex(path[index + 1]) ? [] : {};
+      }
+    }
+    assignValue(nested, key, newValue);
+    nested = nested[key];
+  }
+  return object;
+}
+var _baseSet = baseSet$2;
+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(object, path);
+    if (predicate(value, path)) {
+      baseSet$1(result, castPath(path, object), value);
+    }
+  }
+  return result;
+}
+var _basePickBy = basePickBy$1;
+var overArg = _overArg;
+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$1 = !nativeGetSymbols ? stubArray : function(object) {
+  var result = [];
+  while (object) {
+    arrayPush(result, getSymbols(object));
+    object = getPrototype(object);
+  }
+  return result;
+};
+var _getSymbolsIn = getSymbolsIn$1;
+function nativeKeysIn$1(object) {
+  var result = [];
+  if (object != null) {
+    for (var key in Object(object)) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+var _nativeKeysIn = nativeKeysIn$1;
+var isObject = isObject_1, isPrototype = _isPrototype, nativeKeysIn = _nativeKeysIn;
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+function baseKeysIn$1(object) {
+  if (!isObject(object)) {
+    return nativeKeysIn(object);
+  }
+  var isProto = isPrototype(object), result = [];
+  for (var key in object) {
+    if (!(key == "constructor" && (isProto || !hasOwnProperty.call(object, key)))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+var _baseKeysIn = baseKeysIn$1;
+var arrayLikeKeys = _arrayLikeKeys, baseKeysIn = _baseKeysIn, isArrayLike = isArrayLike_1;
+function keysIn$1(object) {
+  return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
+}
+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$1;
+var arrayMap = _arrayMap, baseIteratee$1 = _baseIteratee, basePickBy = _basePickBy, getAllKeysIn = _getAllKeysIn;
+function pickBy$1(object, predicate) {
+  if (object == null) {
+    return {};
+  }
+  var props = arrayMap(getAllKeysIn(object), function(prop) {
+    return [prop];
+  });
+  predicate = baseIteratee$1(predicate);
+  return basePickBy(object, props, function(value, path) {
+    return predicate(value, path[0]);
+  });
+}
+var pickBy_1 = pickBy$1;
+var baseIteratee = _baseIteratee, negate = negate_1, pickBy = pickBy_1;
+function omitBy(object, predicate) {
+  return pickBy(object, negate(baseIteratee(predicate)));
+}
+var omitBy_1 = omitBy;
+const getCheckboxChecked = (checkboxValue = "on", newValue) => {
+  if (Array.isArray(newValue))
+    return newValue.some((val) => val === true || val === checkboxValue);
+  if (typeof newValue === "boolean")
+    return newValue;
+  if (typeof newValue === "string")
+    return newValue === checkboxValue;
+  return void 0;
+};
+const getRadioChecked = (radioValue = "on", newValue) => {
+  if (typeof newValue === "string")
+    return newValue === radioValue;
+  return void 0;
+};
+const defaultValidationBehavior = {
+  initial: "onBlur",
+  whenTouched: "onChange",
+  whenSubmitted: "onChange"
+};
+const createGetInputProps = ({
+  clearError,
+  validate,
+  defaultValue,
+  touched,
+  setTouched,
+  hasBeenSubmitted,
+  validationBehavior,
+  name
+}) => {
+  const validationBehaviors = __spreadValues(__spreadValues({}, defaultValidationBehavior), validationBehavior);
+  return (props = {}) => {
+    const behavior = hasBeenSubmitted ? validationBehaviors.whenSubmitted : touched ? validationBehaviors.whenTouched : validationBehaviors.initial;
+    const inputProps = __spreadProps(__spreadValues({}, props), {
+      onChange: (...args) => {
+        var _a;
+        if (behavior === "onChange")
+          validate();
+        else
+          clearError();
+        return (_a = props == null ? void 0 : props.onChange) == null ? void 0 : _a.call(props, ...args);
+      },
+      onBlur: (...args) => {
+        var _a;
+        if (behavior === "onBlur")
+          validate();
+        setTouched(true);
+        return (_a = props == null ? void 0 : props.onBlur) == null ? void 0 : _a.call(props, ...args);
+      },
+      name
+    });
+    if (props.type === "checkbox") {
+      inputProps.defaultChecked = getCheckboxChecked(props.value, defaultValue);
+    } else if (props.type === "radio") {
+      inputProps.defaultChecked = getRadioChecked(props.value, defaultValue);
+    } else if (props.value === void 0) {
+      inputProps.defaultValue = defaultValue;
+    }
+    return omitBy_1(inputProps, (value) => value === void 0);
+  };
+};
+var prefix = "Invariant failed";
+function invariant(condition, message) {
+  if (condition) {
+    return;
+  }
+  {
+    throw new Error(prefix);
+  }
+}
+const FORM_ID_FIELD = "__rvfInternalFormId";
+const FORM_DEFAULTS_FIELD = "__rvfInternalFormDefaults";
+const formDefaultValuesKey = (formId) => `${FORM_DEFAULTS_FIELD}_${formId}`;
+const InternalFormContext = createContext(null);
+const serverData = (data) => ({
+  hydrateTo: () => data,
+  map: (fn2) => serverData(fn2(data))
+});
+const hydratedData = () => ({
+  hydrateTo: (hydratedData2) => hydratedData2,
+  map: () => hydratedData()
+});
+const from = (data, hydrated) => hydrated ? hydratedData() : serverData(data);
+const hydratable = {
+  serverData,
+  hydratedData,
+  from
+};
+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));
+    }
+  };
+  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 });
+    });
+  }, [a2]);
+  p$2(d2);
+  return d2;
+}
+function r$2(a2) {
+  var b2 = a2.getSnapshot;
+  a2 = a2.value;
+  try {
+    var d2 = b2();
+    return !k$1(a2, d2);
+  } catch (f2) {
+    return true;
+  }
+}
+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;
+      }
+      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);
+  });
+}
+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 new Map(n2);
+    case 3:
+      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;
+      }
+    }
+    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);
+  };
+  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;
+  };
+  family.remove = (formId) => {
+    stores.delete(formId);
+  };
+  return family;
+};
+const controlledFieldStore = storeFamily(() => create$1()(immer((set2, get2, api) => ({
+  fields: {},
+  register: (field) => set2((state) => {
+    if (state.fields[field]) {
+      state.fields[field].refCount++;
+    } else {
+      state.fields[field] = {
+        refCount: 1,
+        value: void 0,
+        hydrated: false,
+        valueUpdatePromise: void 0,
+        resolveValueUpdate: void 0
+      };
+    }
+  }),
+  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);
+  },
+  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 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)
+    return { formId };
+  if (formContext)
+    return formContext;
+  throw new Error(`Unable to determine form for ${hookName}. Please use it inside a ValidatedForm or pass a 'formId'.`);
+};
+function useErrorResponseForForm({
+  fetcher,
+  subaction,
+  formId
+}) {
+  var _a;
+  const actionData = useActionData();
+  if (fetcher) {
+    if ((_a = fetcher.data) == null ? void 0 : _a.fieldErrors)
+      return fetcher.data;
+    return null;
+  }
+  if (!(actionData == null ? void 0 : actionData.fieldErrors))
+    return null;
+  if (typeof formId === "string" && actionData.formId)
+    return actionData.formId === formId ? actionData : null;
+  if (!subaction && !actionData.subaction || actionData.subaction === subaction)
+    return actionData;
+  return null;
+}
+const useFieldErrorsForForm = (context) => {
+  const response = useErrorResponseForForm(context);
+  const hydrated = useFormStore(context.formId, (state) => state.isHydrated);
+  return hydratable.from(response == null ? void 0 : response.fieldErrors, hydrated);
+};
+const useDefaultValuesFromLoader = ({
+  formId
+}) => {
+  const matches = useMatches();
+  if (typeof formId === "string") {
+    const dataKey = formDefaultValuesKey(formId);
+    const match = matches.reverse().find((match2) => match2.data && dataKey in match2.data);
+    return match == null ? void 0 : match.data[dataKey];
+  }
+  return null;
+};
+const useDefaultValuesForForm = (context) => {
+  const { formId, defaultValuesProp } = context;
+  const hydrated = useFormStore(formId, (state) => state.isHydrated);
+  const errorResponse = useErrorResponseForForm(context);
+  const defaultValuesFromLoader = useDefaultValuesFromLoader(context);
+  if (hydrated)
+    return hydratable.hydratedData();
+  if (errorResponse == null ? void 0 : errorResponse.repopulateFields) {
+    invariant(typeof errorResponse.repopulateFields === "object");
+    return hydratable.serverData(errorResponse.repopulateFields);
+  }
+  if (defaultValuesProp)
+    return hydratable.serverData(defaultValuesProp);
+  return hydratable.serverData(defaultValuesFromLoader);
+};
+const useHasActiveFormSubmit = ({
+  fetcher
+}) => {
+  const transition = useTransition();
+  const hasActiveSubmission = fetcher ? fetcher.state === "submitting" : !!transition.submission;
+  return hasActiveSubmission;
+};
+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 = 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 state = useSyncedDefaultValues(context.formId);
+  return defaultValues.map((val) => get_1(val, name)).hydrateTo(get_1(state, name));
+};
+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 useRegisterReceiveFocus = (formId) => useFormStore(formId, (state) => {
+  var _a, _b;
+  return (_b = (_a = state.formProps) == null ? void 0 : _a.registerReceiveFocus) != null ? _b : noOpReceiver;
+});
+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 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 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 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 (isFormHydrated && !isFieldHydrated) {
+      hydrateWithDefault(field, defaultValue);
+    }
+  }, [
+    defaultValue,
+    field,
+    hydrateWithDefault,
+    isFieldHydrated,
+    isFormHydrated
+  ]);
+  return isFieldHydrated ? value : defaultValue;
+};
+const useControllableValue = (context, 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 = useValueStore((state) => state.register);
+  const unregister = useValueStore((state) => state.unregister);
+  useEffect(() => {
+    register(field);
+    return () => unregister(field);
+  }, [context.formId, field, register, unregister]);
+  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 useValueStore = controlledFieldStore(formId);
+  return useValueStore((state) => state.setValue);
+};
+const useIsSubmitting = (formId) => {
+  const formContext = useInternalFormContext(formId, "useIsSubmitting");
+  return useInternalIsSubmitting(formContext.formId);
+};
+const useIsValid = (formId) => {
+  const formContext = useInternalFormContext(formId, "useIsValid");
+  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 = 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);
+  }, [handleReceiveFocus, name, registerReceiveFocus]);
+  const field = useMemo(() => {
+    const helpers = {
+      error,
+      clearError: () => clearError(name),
+      validate: () => {
+        validateField(name);
+      },
+      defaultValue,
+      touched,
+      setTouched
+    };
+    const getInputProps = createGetInputProps(__spreadProps(__spreadValues({}, helpers), {
+      name,
+      hasBeenSubmitted,
+      validationBehavior: options == null ? void 0 : options.validationBehavior
+    }));
+    return __spreadProps(__spreadValues({}, helpers), {
+      getInputProps
+    });
+  }, [
+    error,
+    clearError,
+    defaultValue,
+    touched,
+    setTouched,
+    name,
+    hasBeenSubmitted,
+    options == null ? void 0 : options.validationBehavior,
+    validateField
+  ]);
+  return field;
+};
+const useControlField = (name, formId) => {
+  const context = useInternalFormContext(formId, "useControlField");
+  const [value, setValue] = useControllableValue(context, name);
+  return [value, setValue];
+};
+const useUpdateControlledField = (formId) => {
+  const context = useInternalFormContext(formId, "useControlField");
+  return useUpdateControllableValue(context.formId);
+};
+function validationError(error, repopulateFields, init) {
+  return json({
+    fieldErrors: error.fieldErrors,
+    subaction: error.subaction,
+    repopulateFields,
+    formId: error.formId
+  }, __spreadValues({ status: 422 }, init));
+}
+const setFormDefaults = (formId, defaultValues) => ({
+  [formDefaultValuesKey(formId)]: defaultValues
+});
+function baseFindIndex$1(array, predicate, fromIndex, fromRight) {
+  var length = array.length, index = fromIndex + (fromRight ? 1 : -1);
+  while (fromRight ? index-- : ++index < length) {
+    if (predicate(array[index], index, array)) {
+      return index;
+    }
+  }
+  return -1;
+}
+var _baseFindIndex = baseFindIndex$1;
+function baseIsNaN$1(value) {
+  return value !== value;
+}
+var _baseIsNaN = baseIsNaN$1;
+function strictIndexOf$1(array, value, fromIndex) {
+  var index = fromIndex - 1, length = array.length;
+  while (++index < length) {
+    if (array[index] === value) {
+      return index;
+    }
+  }
+  return -1;
+}
+var _strictIndexOf = strictIndexOf$1;
+var baseFindIndex = _baseFindIndex, baseIsNaN = _baseIsNaN, strictIndexOf = _strictIndexOf;
+function baseIndexOf$1(array, value, fromIndex) {
+  return value === value ? strictIndexOf(array, value, fromIndex) : baseFindIndex(array, baseIsNaN, fromIndex);
+}
+var _baseIndexOf = baseIndexOf$1;
+var baseIndexOf = _baseIndexOf;
+function arrayIncludes$1(array, value) {
+  var length = array == null ? 0 : array.length;
+  return !!length && baseIndexOf(array, value, 0) > -1;
+}
+var _arrayIncludes = arrayIncludes$1;
+function arrayIncludesWith$1(array, value, comparator) {
+  var index = -1, length = array == null ? 0 : array.length;
+  while (++index < length) {
+    if (comparator(value, array[index])) {
+      return true;
+    }
+  }
+  return false;
+}
+var _arrayIncludesWith = arrayIncludesWith$1;
+function noop$1() {
+}
+var noop_1 = noop$1;
+var Set$1 = _Set, noop = noop_1, setToArray$1 = _setToArray;
+var INFINITY = 1 / 0;
+var createSet$1 = !(Set$1 && 1 / setToArray$1(new Set$1([, -0]))[1] == INFINITY) ? noop : function(values) {
+  return new Set$1(values);
+};
+var _createSet = createSet$1;
+var SetCache = _SetCache, arrayIncludes = _arrayIncludes, arrayIncludesWith = _arrayIncludesWith, cacheHas = _cacheHas, createSet = _createSet, setToArray = _setToArray;
+var LARGE_ARRAY_SIZE = 200;
+function baseUniq$1(array, iteratee, comparator) {
+  var index = -1, includes = arrayIncludes, length = array.length, isCommon = true, result = [], seen = result;
+  if (comparator) {
+    isCommon = false;
+    includes = arrayIncludesWith;
+  } else if (length >= LARGE_ARRAY_SIZE) {
+    var set2 = iteratee ? null : createSet(array);
+    if (set2) {
+      return setToArray(set2);
+    }
+    isCommon = false;
+    includes = cacheHas;
+    seen = new SetCache();
+  } else {
+    seen = iteratee ? [] : result;
+  }
+  outer:
+    while (++index < length) {
+      var value = array[index], computed = iteratee ? iteratee(value) : value;
+      value = comparator || value !== 0 ? value : 0;
+      if (isCommon && computed === computed) {
+        var seenIndex = seen.length;
+        while (seenIndex--) {
+          if (seen[seenIndex] === computed) {
+            continue outer;
+          }
+        }
+        if (iteratee) {
+          seen.push(computed);
+        }
+        result.push(value);
+      } else if (!includes(seen, computed, comparator)) {
+        if (seen !== result) {
+          seen.push(computed);
+        }
+        result.push(value);
+      }
+    }
+  return result;
+}
+var _baseUniq = baseUniq$1;
+var baseUniq = _baseUniq;
+function uniq(array) {
+  return array && array.length ? baseUniq(array) : [];
+}
+var uniq_1 = uniq;
+class MultiValueMap {
+  constructor() {
+    this.dict = /* @__PURE__ */ new Map();
+    this.add = (key, value) => {
+      if (this.dict.has(key)) {
+        this.dict.get(key).push(value);
+      } else {
+        this.dict.set(key, [value]);
+      }
+    };
+    this.delete = (key) => {
+      this.dict.delete(key);
+    };
+    this.remove = (key, value) => {
+      if (!this.dict.has(key))
+        return;
+      const array = this.dict.get(key);
+      const index = array.indexOf(value);
+      if (index !== -1)
+        array.splice(index, 1);
+      if (array.length === 0)
+        this.dict.delete(key);
+    };
+    this.getAll = (key) => {
+      var _a;
+      return (_a = this.dict.get(key)) != null ? _a : [];
+    };
+    this.entries = () => this.dict.entries();
+    this.values = () => this.dict.values();
+    this.has = (key) => this.dict.has(key);
+  }
+}
+const useMultiValueMap = () => {
+  const ref = useRef(null);
+  return useCallback(() => {
+    if (ref.current)
+      return ref.current;
+    ref.current = new MultiValueMap();
+    return ref.current;
+  }, []);
+};
+const cleanupFormState = (formId) => {
+  formStore.remove(formId);
+  controlledFieldStore.remove(formId);
+};
+function useSubmitComplete(isSubmitting, callback) {
+  const isPending = useRef(false);
+  useEffect(() => {
+    if (isSubmitting) {
+      isPending.current = true;
+    }
+    if (!isSubmitting && isPending.current) {
+      isPending.current = false;
+      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) => {
+      if (typeof ref === "function") {
+        ref(value);
+      } else if (ref != null) {
+        ref.current = value;
+      }
+    });
+  };
+};
+const useIsomorphicLayoutEffect = typeof window !== "undefined" ? useLayoutEffect : useEffect;
+const useDeepEqualsMemo = (item) => {
+  const ref = useRef(item);
+  const areEqual = ref.current === item || isEqual_1(ref.current, item);
+  useEffect(() => {
+    if (!areEqual) {
+      ref.current = item;
+    }
+  });
+  return areEqual ? ref.current : item;
+};
+const getDataFromForm = (el) => new FormData(el);
+function nonNull(value) {
+  return value !== null;
+}
+const focusFirstInvalidInput = (fieldErrors, customFocusHandlers, formElement) => {
+  var _a;
+  const namesInOrder = [...formElement.elements].map((el) => {
+    const input = el instanceof RadioNodeList ? el[0] : el;
+    if (input instanceof HTMLInputElement)
+      return input.name;
+    return null;
+  }).filter(nonNull).filter((name) => name in fieldErrors);
+  const uniqueNamesInOrder = uniq_1(namesInOrder);
+  for (const fieldName of uniqueNamesInOrder) {
+    if (customFocusHandlers.has(fieldName)) {
+      customFocusHandlers.getAll(fieldName).forEach((handler) => {
+        handler();
+      });
+      break;
+    }
+    const elem = formElement.elements.namedItem(fieldName);
+    if (!elem)
+      continue;
+    if (elem instanceof RadioNodeList) {
+      const selectedRadio = (_a = [...elem].filter((item) => item instanceof HTMLInputElement).find((item) => item.value === elem.value)) != null ? _a : elem[0];
+      if (selectedRadio && selectedRadio instanceof HTMLInputElement) {
+        selectedRadio.focus();
+        break;
+      }
+    }
+    if (elem instanceof HTMLInputElement) {
+      if (elem.type === "hidden") {
+        continue;
+      }
+      elem.focus();
+      break;
+    }
+  }
+};
+const useFormId = (providedId) => {
+  const [symbolId] = useState(() => Symbol("remix-validated-form-id"));
+  return providedId != null ? providedId : symbolId;
+};
+const FormResetter = ({
+  resetAfterSubmit,
+  formRef
+}) => {
+  const isSubmitting = useIsSubmitting();
+  const isValid = useIsValid();
+  useSubmitComplete(isSubmitting, () => {
+    var _a;
+    if (isValid && resetAfterSubmit) {
+      (_a = formRef.current) == null ? void 0 : _a.reset();
+    }
+  });
+  return null;
+};
+function formEventProxy(event) {
+  let defaultPrevented = false;
+  return new Proxy(event, {
+    get: (target, prop) => {
+      if (prop === "preventDefault") {
+        return () => {
+          defaultPrevented = true;
+        };
+      }
+      if (prop === "defaultPrevented") {
+        return defaultPrevented;
+      }
+      return target[prop];
+    }
+  });
+}
+function ValidatedForm(_a) {
+  var _b = _a, {
+    validator,
+    onSubmit,
+    children,
+    fetcher,
+    action,
+    defaultValues: unMemoizedDefaults,
+    formRef: formRefProp,
+    onReset,
+    subaction,
+    resetAfterSubmit = false,
+    disableFocusOnError,
+    method,
+    replace,
+    id
+  } = _b, rest = __objRest(_b, [
+    "validator",
+    "onSubmit",
+    "children",
+    "fetcher",
+    "action",
+    "defaultValues",
+    "formRef",
+    "onReset",
+    "subaction",
+    "resetAfterSubmit",
+    "disableFocusOnError",
+    "method",
+    "replace",
+    "id"
+  ]);
+  var _a2;
+  const formId = useFormId(id);
+  const providedDefaultValues = useDeepEqualsMemo(unMemoizedDefaults);
+  const contextValue = useMemo(() => ({
+    formId,
+    action,
+    subaction,
+    defaultValuesProp: providedDefaultValues,
+    fetcher
+  }), [action, fetcher, formId, providedDefaultValues, subaction]);
+  const backendError = useErrorResponseForForm(contextValue);
+  const backendDefaultValues = useDefaultValuesFromLoader(contextValue);
+  const hasActiveSubmission = useHasActiveFormSubmit(contextValue);
+  const formRef = useRef(null);
+  const Form$1 = (_a2 = fetcher == null ? void 0 : fetcher.Form) != null ? _a2 : Form;
+  const submit = useSubmit();
+  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();
+    return () => cleanupFormState(formId);
+  }, [formId, setHydrated]);
+  const customFocusHandlers = useMultiValueMap();
+  const registerReceiveFocus = useCallback((fieldName, handler) => {
+    customFocusHandlers().add(fieldName, handler);
+    return () => {
+      customFocusHandlers().remove(fieldName, handler);
+    };
+  }, [customFocusHandlers]);
+  useIsomorphicLayoutEffect(() => {
+    var _a3;
+    syncFormProps({
+      action,
+      defaultValues: (_a3 = providedDefaultValues != null ? providedDefaultValues : backendDefaultValues) != null ? _a3 : {},
+      subaction,
+      registerReceiveFocus,
+      validator
+    });
+  }, [
+    action,
+    providedDefaultValues,
+    registerReceiveFocus,
+    subaction,
+    syncFormProps,
+    backendDefaultValues,
+    validator
+  ]);
+  useEffect(() => {
+    var _a3;
+    setFieldErrors((_a3 = backendError == null ? void 0 : backendError.fieldErrors) != null ? _a3 : {});
+  }, [backendError == null ? void 0 : backendError.fieldErrors, setFieldErrors, setFieldError]);
+  useSubmitComplete(hasActiveSubmission, () => {
+    endSubmit();
+  });
+  let clickedButtonRef = React.useRef();
+  useEffect(() => {
+    let form = formRef.current;
+    if (!form)
+      return;
+    function handleClick(event) {
+      if (!(event.target instanceof HTMLElement))
+        return;
+      let submitButton = event.target.closest("button,input[type=submit]");
+      if (submitButton && submitButton.form === form && submitButton.type === "submit") {
+        clickedButtonRef.current = submitButton;
+      }
+    }
+    window.addEventListener("click", handleClick, { capture: true });
+    return () => {
+      window.removeEventListener("click", handleClick, { capture: true });
+    };
+  }, []);
+  const handleSubmit = async (e2) => {
+    startSubmit();
+    const result = await validator.validate(getDataFromForm(e2.currentTarget));
+    if (result.error) {
+      endSubmit();
+      setFieldErrors(result.error.fieldErrors);
+      if (!disableFocusOnError) {
+        focusFirstInvalidInput(result.error.fieldErrors, customFocusHandlers(), formRef.current);
+      }
+    } else {
+      const eventProxy = formEventProxy(e2);
+      await (onSubmit == null ? void 0 : onSubmit(result.data, eventProxy));
+      if (eventProxy.defaultPrevented) {
+        endSubmit();
+        return;
+      }
+      if (fetcher)
+        fetcher.submit(clickedButtonRef.current || formRef.current);
+      else
+        submit(clickedButtonRef.current || formRef.current, {
+          method,
+          replace
+        });
+      clickedButtonRef.current = null;
+    }
+  };
+  return /* @__PURE__ */ React.createElement(Form$1, __spreadProps(__spreadValues({
+    ref: mergeRefs([formRef, formRefProp, setFormElementInState])
+  }, rest), {
+    id,
+    action,
+    method,
+    replace,
+    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
+  }, /* @__PURE__ */ React.createElement(FormResetter, {
+    formRef,
+    resetAfterSubmit
+  }), subaction && /* @__PURE__ */ React.createElement("input", {
+    type: "hidden",
+    value: subaction,
+    name: "subaction"
+  }), id && /* @__PURE__ */ React.createElement("input", {
+    type: "hidden",
+    value: id,
+    name: FORM_ID_FIELD
+  }), children));
+}
+var baseSet = _baseSet;
+function set(object, path, value) {
+  return object == null ? object : baseSet(object, path, value);
+}
+var set_1 = set;
+const objectFromPathEntries = (entries) => {
+  const map = new MultiValueMap();
+  entries.forEach(([key, value]) => map.add(key, value));
+  return [...map.entries()].reduce((acc, [key, value]) => set_1(acc, key, value.length === 1 ? value[0] : value), {});
+};
+const preprocessFormData = (data) => {
+  if ("entries" in data && typeof data.entries === "function")
+    return objectFromPathEntries([...data.entries()]);
+  return objectFromPathEntries(Object.entries(data));
+};
+function createValidator(validator) {
+  return {
+    validate: async (value) => {
+      const data = preprocessFormData(value);
+      const result = await validator.validate(data);
+      if (result.error) {
+        return {
+          data: void 0,
+          error: {
+            fieldErrors: result.error,
+            subaction: data.subaction,
+            formId: data[FORM_ID_FIELD]
+          },
+          submittedData: data,
+          formId: data[FORM_ID_FIELD]
+        };
+      }
+      return {
+        data: result.data,
+        error: void 0,
+        submittedData: data,
+        formId: data[FORM_ID_FIELD]
+      };
+    },
+    validateField: (data, field) => validator.validateField(preprocessFormData(data), field)
+  };
+}
+const useFormState = (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(syncedDefaultValues);
+  const fieldErrorsFromState = useFieldErrors(formContext.formId);
+  const fieldErrorsToUse = useFieldErrorsForForm(formContext);
+  const hydratedFieldErrors = fieldErrorsToUse.hydrateTo(fieldErrorsFromState);
+  return useMemo(() => ({
+    action,
+    subaction,
+    defaultValues: hydratedDefaultValues,
+    fieldErrors: hydratedFieldErrors != null ? hydratedFieldErrors : {},
+    hasBeenSubmitted,
+    isSubmitting,
+    touchedFields,
+    isValid
+  }), [
+    action,
+    hasBeenSubmitted,
+    hydratedDefaultValues,
+    hydratedFieldErrors,
+    isSubmitting,
+    isValid,
+    subaction,
+    touchedFields
+  ]);
+};
+const useFormHelpers = (formId) => {
+  const formContext = useInternalFormContext(formId, "useFormHelpers");
+  const setTouched = useSetTouched(formContext);
+  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,
+    validate,
+    clearAllErrors: () => setFieldErrors({}),
+    reset
+  }), [clearError, reset, setFieldErrors, setTouched, validate, validateField]);
+};
+const useFormContext = (formId) => {
+  const context = useInternalFormContext(formId, "useFormContext");
+  const state = useFormState(formId);
+  const {
+    clearError: internalClearError,
+    setTouched,
+    validateField,
+    clearAllErrors,
+    validate
+  } = useFormHelpers(formId);
+  const registerReceiveFocus = useRegisterReceiveFocus(context.formId);
+  const clearError = useCallback((...names) => {
+    names.forEach((name) => {
+      internalClearError(name);
+    });
+  }, [internalClearError]);
+  return __spreadProps(__spreadValues({}, state), {
+    setFieldTouched: setTouched,
+    validateField,
+    clearError,
+    registerReceiveFocus,
+    clearAllErrors,
+    validate
+  });
+};
+export { ValidatedForm, createValidator, setFormDefaults, useControlField, useField, useFormContext, useIsSubmitting, useIsValid, useUpdateControlledField, validationError };