{"version":3,"file":"static/js/vendor-react-hook-form.a8703fca.js","mappings":"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","sources":["../node_modules/react-hook-form/dist/index.esm.mjs"],"sourcesContent":["import React from 'react';\nvar isCheckBoxInput = element => element.type === 'checkbox';\nvar isDateObject = value => value instanceof Date;\nvar isNullOrUndefined = value => value == null;\nconst isObjectType = value => typeof value === 'object';\nvar isObject = value => !isNullOrUndefined(value) && !Array.isArray(value) && isObjectType(value) && !isDateObject(value);\nvar getEventValue = event => isObject(event) && event.target ? isCheckBoxInput(event.target) ? event.target.checked : event.target.value : event;\nvar getNodeParentName = name => name.substring(0, name.search(/\\.\\d+(\\.|$)/)) || name;\nvar isNameInFieldArray = (names, name) => names.has(getNodeParentName(name));\nvar isPlainObject = tempObject => {\n  const prototypeCopy = tempObject.constructor && tempObject.constructor.prototype;\n  return isObject(prototypeCopy) && prototypeCopy.hasOwnProperty('isPrototypeOf');\n};\nvar isWeb = typeof window !== 'undefined' && typeof window.HTMLElement !== 'undefined' && typeof document !== 'undefined';\nfunction cloneObject(data) {\n  let copy;\n  const isArray = Array.isArray(data);\n  if (data instanceof Date) {\n    copy = new Date(data);\n  } else if (data instanceof Set) {\n    copy = new Set(data);\n  } else if (!(isWeb && (data instanceof Blob || data instanceof FileList)) && (isArray || isObject(data))) {\n    copy = isArray ? [] : {};\n    if (!isArray && !isPlainObject(data)) {\n      copy = data;\n    } else {\n      for (const key in data) {\n        if (data.hasOwnProperty(key)) {\n          copy[key] = cloneObject(data[key]);\n        }\n      }\n    }\n  } else {\n    return data;\n  }\n  return copy;\n}\nvar compact = value => Array.isArray(value) ? value.filter(Boolean) : [];\nvar isUndefined = val => val === undefined;\nvar get = (object, path, defaultValue) => {\n  if (!path || !isObject(object)) {\n    return defaultValue;\n  }\n  const result = compact(path.split(/[,[\\].]+?/)).reduce((result, key) => isNullOrUndefined(result) ? result : result[key], object);\n  return isUndefined(result) || result === object ? isUndefined(object[path]) ? defaultValue : object[path] : result;\n};\nvar isBoolean = value => typeof value === 'boolean';\nconst EVENTS = {\n  BLUR: 'blur',\n  FOCUS_OUT: 'focusout',\n  CHANGE: 'change'\n};\nconst VALIDATION_MODE = {\n  onBlur: 'onBlur',\n  onChange: 'onChange',\n  onSubmit: 'onSubmit',\n  onTouched: 'onTouched',\n  all: 'all'\n};\nconst INPUT_VALIDATION_RULES = {\n  max: 'max',\n  min: 'min',\n  maxLength: 'maxLength',\n  minLength: 'minLength',\n  pattern: 'pattern',\n  required: 'required',\n  validate: 'validate'\n};\nconst HookFormContext = React.createContext(null);\n/**\n * This custom hook allows you to access the form context. useFormContext is intended to be used in deeply nested structures, where it would become inconvenient to pass the context as a prop. To be used with {@link FormProvider}.\n *\n * @remarks\n * [API](https://react-hook-form.com/docs/useformcontext) • [Demo](https://codesandbox.io/s/react-hook-form-v7-form-context-ytudi)\n *\n * @returns return all useForm methods\n *\n * @example\n * ```tsx\n * function App() {\n *   const methods = useForm();\n *   const onSubmit = data => console.log(data);\n *\n *   return (\n *     <FormProvider {...methods} >\n *       <form onSubmit={methods.handleSubmit(onSubmit)}>\n *         <NestedInput />\n *         <input type=\"submit\" />\n *       </form>\n *     </FormProvider>\n *   );\n * }\n *\n *  function NestedInput() {\n *   const { register } = useFormContext(); // retrieve all hook methods\n *   return <input {...register(\"test\")} />;\n * }\n * ```\n */\nconst useFormContext = () => React.useContext(HookFormContext);\n/**\n * A provider component that propagates the `useForm` methods to all children components via [React Context](https://reactjs.org/docs/context.html) API. To be used with {@link useFormContext}.\n *\n * @remarks\n * [API](https://react-hook-form.com/docs/useformcontext) • [Demo](https://codesandbox.io/s/react-hook-form-v7-form-context-ytudi)\n *\n * @param props - all useForm methods\n *\n * @example\n * ```tsx\n * function App() {\n *   const methods = useForm();\n *   const onSubmit = data => console.log(data);\n *\n *   return (\n *     <FormProvider {...methods} >\n *       <form onSubmit={methods.handleSubmit(onSubmit)}>\n *         <NestedInput />\n *         <input type=\"submit\" />\n *       </form>\n *     </FormProvider>\n *   );\n * }\n *\n *  function NestedInput() {\n *   const { register } = useFormContext(); // retrieve all hook methods\n *   return <input {...register(\"test\")} />;\n * }\n * ```\n */\nconst FormProvider = props => {\n  const {\n    children,\n    ...data\n  } = props;\n  return React.createElement(HookFormContext.Provider, {\n    value: data\n  }, children);\n};\nvar getProxyFormState = (formState, control, localProxyFormState, isRoot = true) => {\n  const result = {\n    defaultValues: control._defaultValues\n  };\n  for (const key in formState) {\n    Object.defineProperty(result, key, {\n      get: () => {\n        const _key = key;\n        if (control._proxyFormState[_key] !== VALIDATION_MODE.all) {\n          control._proxyFormState[_key] = !isRoot || VALIDATION_MODE.all;\n        }\n        localProxyFormState && (localProxyFormState[_key] = true);\n        return formState[_key];\n      }\n    });\n  }\n  return result;\n};\nvar isEmptyObject = value => isObject(value) && !Object.keys(value).length;\nvar shouldRenderFormState = (formStateData, _proxyFormState, updateFormState, isRoot) => {\n  updateFormState(formStateData);\n  const {\n    name,\n    ...formState\n  } = formStateData;\n  return isEmptyObject(formState) || Object.keys(formState).length >= Object.keys(_proxyFormState).length || Object.keys(formState).find(key => _proxyFormState[key] === (!isRoot || VALIDATION_MODE.all));\n};\nvar convertToArrayPayload = value => Array.isArray(value) ? value : [value];\nvar shouldSubscribeByName = (name, signalName, exact) => !name || !signalName || name === signalName || convertToArrayPayload(name).some(currentName => currentName && (exact ? currentName === signalName : currentName.startsWith(signalName) || signalName.startsWith(currentName)));\nfunction useSubscribe(props) {\n  const _props = React.useRef(props);\n  _props.current = props;\n  React.useEffect(() => {\n    const subscription = !props.disabled && _props.current.subject && _props.current.subject.subscribe({\n      next: _props.current.next\n    });\n    return () => {\n      subscription && subscription.unsubscribe();\n    };\n  }, [props.disabled]);\n}\n\n/**\n * This custom hook allows you to subscribe to each form state, and isolate the re-render at the custom hook level. It has its scope in terms of form state subscription, so it would not affect other useFormState and useForm. Using this hook can reduce the re-render impact on large and complex form application.\n *\n * @remarks\n * [API](https://react-hook-form.com/docs/useformstate) • [Demo](https://codesandbox.io/s/useformstate-75xly)\n *\n * @param props - include options on specify fields to subscribe. {@link UseFormStateReturn}\n *\n * @example\n * ```tsx\n * function App() {\n *   const { register, handleSubmit, control } = useForm({\n *     defaultValues: {\n *     firstName: \"firstName\"\n *   }});\n *   const { dirtyFields } = useFormState({\n *     control\n *   });\n *   const onSubmit = (data) => console.log(data);\n *\n *   return (\n *     <form onSubmit={handleSubmit(onSubmit)}>\n *       <input {...register(\"firstName\")} placeholder=\"First Name\" />\n *       {dirtyFields.firstName && <p>Field is dirty.</p>}\n *       <input type=\"submit\" />\n *     </form>\n *   );\n * }\n * ```\n */\nfunction useFormState(props) {\n  const methods = useFormContext();\n  const {\n    control = methods.control,\n    disabled,\n    name,\n    exact\n  } = props || {};\n  const [formState, updateFormState] = React.useState(control._formState);\n  const _mounted = React.useRef(true);\n  const _localProxyFormState = React.useRef({\n    isDirty: false,\n    isLoading: false,\n    dirtyFields: false,\n    touchedFields: false,\n    isValidating: false,\n    isValid: false,\n    errors: false\n  });\n  const _name = React.useRef(name);\n  _name.current = name;\n  useSubscribe({\n    disabled,\n    next: value => _mounted.current && shouldSubscribeByName(_name.current, value.name, exact) && shouldRenderFormState(value, _localProxyFormState.current, control._updateFormState) && updateFormState({\n      ...control._formState,\n      ...value\n    }),\n    subject: control._subjects.state\n  });\n  React.useEffect(() => {\n    _mounted.current = true;\n    _localProxyFormState.current.isValid && control._updateValid(true);\n    return () => {\n      _mounted.current = false;\n    };\n  }, [control]);\n  return getProxyFormState(formState, control, _localProxyFormState.current, false);\n}\nvar isString = value => typeof value === 'string';\nvar generateWatchOutput = (names, _names, formValues, isGlobal, defaultValue) => {\n  if (isString(names)) {\n    isGlobal && _names.watch.add(names);\n    return get(formValues, names, defaultValue);\n  }\n  if (Array.isArray(names)) {\n    return names.map(fieldName => (isGlobal && _names.watch.add(fieldName), get(formValues, fieldName)));\n  }\n  isGlobal && (_names.watchAll = true);\n  return formValues;\n};\n\n/**\n * Custom hook to subscribe to field change and isolate re-rendering at the component level.\n *\n * @remarks\n *\n * [API](https://react-hook-form.com/docs/usewatch) • [Demo](https://codesandbox.io/s/react-hook-form-v7-ts-usewatch-h9i5e)\n *\n * @example\n * ```tsx\n * const { control } = useForm();\n * const values = useWatch({\n *   name: \"fieldName\"\n *   control,\n * })\n * ```\n */\nfunction useWatch(props) {\n  const methods = useFormContext();\n  const {\n    control = methods.control,\n    name,\n    defaultValue,\n    disabled,\n    exact\n  } = props || {};\n  const _name = React.useRef(name);\n  _name.current = name;\n  useSubscribe({\n    disabled,\n    subject: control._subjects.values,\n    next: formState => {\n      if (shouldSubscribeByName(_name.current, formState.name, exact)) {\n        updateValue(cloneObject(generateWatchOutput(_name.current, control._names, formState.values || control._formValues, false, defaultValue)));\n      }\n    }\n  });\n  const [value, updateValue] = React.useState(control._getWatch(name, defaultValue));\n  React.useEffect(() => control._removeUnmounted());\n  return value;\n}\nvar isKey = value => /^\\w*$/.test(value);\nvar stringToPath = input => compact(input.replace(/[\"|']|\\]/g, '').split(/\\.|\\[/));\nvar set = (object, path, value) => {\n  let index = -1;\n  const tempPath = isKey(path) ? [path] : stringToPath(path);\n  const length = tempPath.length;\n  const lastIndex = length - 1;\n  while (++index < length) {\n    const key = tempPath[index];\n    let newValue = value;\n    if (index !== lastIndex) {\n      const objValue = object[key];\n      newValue = isObject(objValue) || Array.isArray(objValue) ? objValue : !isNaN(+tempPath[index + 1]) ? [] : {};\n    }\n    object[key] = newValue;\n    object = object[key];\n  }\n  return object;\n};\n\n/**\n * Custom hook to work with controlled component, this function provide you with both form and field level state. Re-render is isolated at the hook level.\n *\n * @remarks\n * [API](https://react-hook-form.com/docs/usecontroller) • [Demo](https://codesandbox.io/s/usecontroller-0o8px)\n *\n * @param props - the path name to the form field value, and validation rules.\n *\n * @returns field properties, field and form state. {@link UseControllerReturn}\n *\n * @example\n * ```tsx\n * function Input(props) {\n *   const { field, fieldState, formState } = useController(props);\n *   return (\n *     <div>\n *       <input {...field} placeholder={props.name} />\n *       <p>{fieldState.isTouched && \"Touched\"}</p>\n *       <p>{formState.isSubmitted ? \"submitted\" : \"\"}</p>\n *     </div>\n *   );\n * }\n * ```\n */\nfunction useController(props) {\n  const methods = useFormContext();\n  const {\n    name,\n    disabled,\n    control = methods.control,\n    shouldUnregister\n  } = props;\n  const isArrayField = isNameInFieldArray(control._names.array, name);\n  const value = useWatch({\n    control,\n    name,\n    defaultValue: get(control._formValues, name, get(control._defaultValues, name, props.defaultValue)),\n    exact: true\n  });\n  const formState = useFormState({\n    control,\n    name\n  });\n  const _registerProps = React.useRef(control.register(name, {\n    ...props.rules,\n    value,\n    ...(isBoolean(props.disabled) ? {\n      disabled: props.disabled\n    } : {})\n  }));\n  React.useEffect(() => {\n    const _shouldUnregisterField = control._options.shouldUnregister || shouldUnregister;\n    const updateMounted = (name, value) => {\n      const field = get(control._fields, name);\n      if (field) {\n        field._f.mount = value;\n      }\n    };\n    updateMounted(name, true);\n    if (_shouldUnregisterField) {\n      const value = cloneObject(get(control._options.defaultValues, name));\n      set(control._defaultValues, name, value);\n      if (isUndefined(get(control._formValues, name))) {\n        set(control._formValues, name, value);\n      }\n    }\n    return () => {\n      (isArrayField ? _shouldUnregisterField && !control._state.action : _shouldUnregisterField) ? control.unregister(name) : updateMounted(name, false);\n    };\n  }, [name, control, isArrayField, shouldUnregister]);\n  React.useEffect(() => {\n    if (get(control._fields, name)) {\n      control._updateDisabledField({\n        disabled,\n        fields: control._fields,\n        name,\n        value: get(control._fields, name)._f.value\n      });\n    }\n  }, [disabled, name, control]);\n  return {\n    field: {\n      name,\n      value,\n      ...(isBoolean(disabled) || formState.disabled ? {\n        disabled: formState.disabled || disabled\n      } : {}),\n      onChange: React.useCallback(event => _registerProps.current.onChange({\n        target: {\n          value: getEventValue(event),\n          name: name\n        },\n        type: EVENTS.CHANGE\n      }), [name]),\n      onBlur: React.useCallback(() => _registerProps.current.onBlur({\n        target: {\n          value: get(control._formValues, name),\n          name: name\n        },\n        type: EVENTS.BLUR\n      }), [name, control]),\n      ref: elm => {\n        const field = get(control._fields, name);\n        if (field && elm) {\n          field._f.ref = {\n            focus: () => elm.focus(),\n            select: () => elm.select(),\n            setCustomValidity: message => elm.setCustomValidity(message),\n            reportValidity: () => elm.reportValidity()\n          };\n        }\n      }\n    },\n    formState,\n    fieldState: Object.defineProperties({}, {\n      invalid: {\n        enumerable: true,\n        get: () => !!get(formState.errors, name)\n      },\n      isDirty: {\n        enumerable: true,\n        get: () => !!get(formState.dirtyFields, name)\n      },\n      isTouched: {\n        enumerable: true,\n        get: () => !!get(formState.touchedFields, name)\n      },\n      error: {\n        enumerable: true,\n        get: () => get(formState.errors, name)\n      }\n    })\n  };\n}\n\n/**\n * Component based on `useController` hook to work with controlled component.\n *\n * @remarks\n * [API](https://react-hook-form.com/docs/usecontroller/controller) • [Demo](https://codesandbox.io/s/react-hook-form-v6-controller-ts-jwyzw) • [Video](https://www.youtube.com/watch?v=N2UNk_UCVyA)\n *\n * @param props - the path name to the form field value, and validation rules.\n *\n * @returns provide field handler functions, field and form state.\n *\n * @example\n * ```tsx\n * function App() {\n *   const { control } = useForm<FormValues>({\n *     defaultValues: {\n *       test: \"\"\n *     }\n *   });\n *\n *   return (\n *     <form>\n *       <Controller\n *         control={control}\n *         name=\"test\"\n *         render={({ field: { onChange, onBlur, value, ref }, formState, fieldState }) => (\n *           <>\n *             <input\n *               onChange={onChange} // send value to hook form\n *               onBlur={onBlur} // notify when input is touched\n *               value={value} // return updated value\n *               ref={ref} // set ref for focus management\n *             />\n *             <p>{formState.isSubmitted ? \"submitted\" : \"\"}</p>\n *             <p>{fieldState.isTouched ? \"touched\" : \"\"}</p>\n *           </>\n *         )}\n *       />\n *     </form>\n *   );\n * }\n * ```\n */\nconst Controller = props => props.render(useController(props));\nconst POST_REQUEST = 'post';\n/**\n * Form component to manage submission.\n *\n * @param props - to setup submission detail. {@link FormProps}\n *\n * @returns form component or headless render prop.\n *\n * @example\n * ```tsx\n * function App() {\n *   const { control, formState: { errors } } = useForm();\n *\n *   return (\n *     <Form action=\"/api\" control={control}>\n *       <input {...register(\"name\")} />\n *       <p>{errors?.root?.server && 'Server error'}</p>\n *       <button>Submit</button>\n *     </Form>\n *   );\n * }\n * ```\n */\nfunction Form(props) {\n  const methods = useFormContext();\n  const [mounted, setMounted] = React.useState(false);\n  const {\n    control = methods.control,\n    onSubmit,\n    children,\n    action,\n    method = POST_REQUEST,\n    headers,\n    encType,\n    onError,\n    render,\n    onSuccess,\n    validateStatus,\n    ...rest\n  } = props;\n  const submit = async event => {\n    let hasError = false;\n    let type = '';\n    await control.handleSubmit(async data => {\n      const formData = new FormData();\n      let formDataJson = '';\n      try {\n        formDataJson = JSON.stringify(data);\n      } catch (_a) {}\n      for (const name of control._names.mount) {\n        formData.append(name, get(data, name));\n      }\n      if (onSubmit) {\n        await onSubmit({\n          data,\n          event,\n          method,\n          formData,\n          formDataJson\n        });\n      }\n      if (action) {\n        try {\n          const shouldStringifySubmissionData = [headers && headers['Content-Type'], encType].some(value => value && value.includes('json'));\n          const response = await fetch(action, {\n            method,\n            headers: {\n              ...headers,\n              ...(encType ? {\n                'Content-Type': encType\n              } : {})\n            },\n            body: shouldStringifySubmissionData ? formDataJson : formData\n          });\n          if (response && (validateStatus ? !validateStatus(response.status) : response.status < 200 || response.status >= 300)) {\n            hasError = true;\n            onError && onError({\n              response\n            });\n            type = String(response.status);\n          } else {\n            onSuccess && onSuccess({\n              response\n            });\n          }\n        } catch (error) {\n          hasError = true;\n          onError && onError({\n            error\n          });\n        }\n      }\n    })(event);\n    if (hasError && props.control) {\n      props.control._subjects.state.next({\n        isSubmitSuccessful: false\n      });\n      props.control.setError('root.server', {\n        type\n      });\n    }\n  };\n  React.useEffect(() => {\n    setMounted(true);\n  }, []);\n  return render ? React.createElement(React.Fragment, null, render({\n    submit\n  })) : React.createElement(\"form\", {\n    noValidate: mounted,\n    action: action,\n    method: method,\n    encType: encType,\n    onSubmit: submit,\n    ...rest\n  }, children);\n}\nvar appendErrors = (name, validateAllFieldCriteria, errors, type, message) => validateAllFieldCriteria ? {\n  ...errors[name],\n  types: {\n    ...(errors[name] && errors[name].types ? errors[name].types : {}),\n    [type]: message || true\n  }\n} : {};\nvar generateId = () => {\n  const d = typeof performance === 'undefined' ? Date.now() : performance.now() * 1000;\n  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {\n    const r = (Math.random() * 16 + d) % 16 | 0;\n    return (c == 'x' ? r : r & 0x3 | 0x8).toString(16);\n  });\n};\nvar getFocusFieldName = (name, index, options = {}) => options.shouldFocus || isUndefined(options.shouldFocus) ? options.focusName || `${name}.${isUndefined(options.focusIndex) ? index : options.focusIndex}.` : '';\nvar getValidationModes = mode => ({\n  isOnSubmit: !mode || mode === VALIDATION_MODE.onSubmit,\n  isOnBlur: mode === VALIDATION_MODE.onBlur,\n  isOnChange: mode === VALIDATION_MODE.onChange,\n  isOnAll: mode === VALIDATION_MODE.all,\n  isOnTouch: mode === VALIDATION_MODE.onTouched\n});\nvar isWatched = (name, _names, isBlurEvent) => !isBlurEvent && (_names.watchAll || _names.watch.has(name) || [..._names.watch].some(watchName => name.startsWith(watchName) && /^\\.\\w+/.test(name.slice(watchName.length))));\nconst iterateFieldsByAction = (fields, action, fieldsNames, abortEarly) => {\n  for (const key of fieldsNames || Object.keys(fields)) {\n    const field = get(fields, key);\n    if (field) {\n      const {\n        _f,\n        ...currentField\n      } = field;\n      if (_f) {\n        if (_f.refs && _f.refs[0] && action(_f.refs[0], key) && !abortEarly) {\n          break;\n        } else if (_f.ref && action(_f.ref, _f.name) && !abortEarly) {\n          break;\n        } else {\n          iterateFieldsByAction(currentField, action);\n        }\n      } else if (isObject(currentField)) {\n        iterateFieldsByAction(currentField, action);\n      }\n    }\n  }\n};\nvar updateFieldArrayRootError = (errors, error, name) => {\n  const fieldArrayErrors = compact(get(errors, name));\n  set(fieldArrayErrors, 'root', error[name]);\n  set(errors, name, fieldArrayErrors);\n  return errors;\n};\nvar isFileInput = element => element.type === 'file';\nvar isFunction = value => typeof value === 'function';\nvar isHTMLElement = value => {\n  if (!isWeb) {\n    return false;\n  }\n  const owner = value ? value.ownerDocument : 0;\n  return value instanceof (owner && owner.defaultView ? owner.defaultView.HTMLElement : HTMLElement);\n};\nvar isMessage = value => isString(value);\nvar isRadioInput = element => element.type === 'radio';\nvar isRegex = value => value instanceof RegExp;\nconst defaultResult = {\n  value: false,\n  isValid: false\n};\nconst validResult = {\n  value: true,\n  isValid: true\n};\nvar getCheckboxValue = options => {\n  if (Array.isArray(options)) {\n    if (options.length > 1) {\n      const values = options.filter(option => option && option.checked && !option.disabled).map(option => option.value);\n      return {\n        value: values,\n        isValid: !!values.length\n      };\n    }\n    return options[0].checked && !options[0].disabled ?\n    // @ts-expect-error expected to work in the browser\n    options[0].attributes && !isUndefined(options[0].attributes.value) ? isUndefined(options[0].value) || options[0].value === '' ? validResult : {\n      value: options[0].value,\n      isValid: true\n    } : validResult : defaultResult;\n  }\n  return defaultResult;\n};\nconst defaultReturn = {\n  isValid: false,\n  value: null\n};\nvar getRadioValue = options => Array.isArray(options) ? options.reduce((previous, option) => option && option.checked && !option.disabled ? {\n  isValid: true,\n  value: option.value\n} : previous, defaultReturn) : defaultReturn;\nfunction getValidateError(result, ref, type = 'validate') {\n  if (isMessage(result) || Array.isArray(result) && result.every(isMessage) || isBoolean(result) && !result) {\n    return {\n      type,\n      message: isMessage(result) ? result : '',\n      ref\n    };\n  }\n}\nvar getValueAndMessage = validationData => isObject(validationData) && !isRegex(validationData) ? validationData : {\n  value: validationData,\n  message: ''\n};\nvar validateField = async (field, formValues, validateAllFieldCriteria, shouldUseNativeValidation, isFieldArray) => {\n  const {\n    ref,\n    refs,\n    required,\n    maxLength,\n    minLength,\n    min,\n    max,\n    pattern,\n    validate,\n    name,\n    valueAsNumber,\n    mount,\n    disabled\n  } = field._f;\n  const inputValue = get(formValues, name);\n  if (!mount || disabled) {\n    return {};\n  }\n  const inputRef = refs ? refs[0] : ref;\n  const setCustomValidity = message => {\n    if (shouldUseNativeValidation && inputRef.reportValidity) {\n      inputRef.setCustomValidity(isBoolean(message) ? '' : message || '');\n      inputRef.reportValidity();\n    }\n  };\n  const error = {};\n  const isRadio = isRadioInput(ref);\n  const isCheckBox = isCheckBoxInput(ref);\n  const isRadioOrCheckbox = isRadio || isCheckBox;\n  const isEmpty = (valueAsNumber || isFileInput(ref)) && isUndefined(ref.value) && isUndefined(inputValue) || isHTMLElement(ref) && ref.value === '' || inputValue === '' || Array.isArray(inputValue) && !inputValue.length;\n  const appendErrorsCurry = appendErrors.bind(null, name, validateAllFieldCriteria, error);\n  const getMinMaxMessage = (exceedMax, maxLengthMessage, minLengthMessage, maxType = INPUT_VALIDATION_RULES.maxLength, minType = INPUT_VALIDATION_RULES.minLength) => {\n    const message = exceedMax ? maxLengthMessage : minLengthMessage;\n    error[name] = {\n      type: exceedMax ? maxType : minType,\n      message,\n      ref,\n      ...appendErrorsCurry(exceedMax ? maxType : minType, message)\n    };\n  };\n  if (isFieldArray ? !Array.isArray(inputValue) || !inputValue.length : required && (!isRadioOrCheckbox && (isEmpty || isNullOrUndefined(inputValue)) || isBoolean(inputValue) && !inputValue || isCheckBox && !getCheckboxValue(refs).isValid || isRadio && !getRadioValue(refs).isValid)) {\n    const {\n      value,\n      message\n    } = isMessage(required) ? {\n      value: !!required,\n      message: required\n    } : getValueAndMessage(required);\n    if (value) {\n      error[name] = {\n        type: INPUT_VALIDATION_RULES.required,\n        message,\n        ref: inputRef,\n        ...appendErrorsCurry(INPUT_VALIDATION_RULES.required, message)\n      };\n      if (!validateAllFieldCriteria) {\n        setCustomValidity(message);\n        return error;\n      }\n    }\n  }\n  if (!isEmpty && (!isNullOrUndefined(min) || !isNullOrUndefined(max))) {\n    let exceedMax;\n    let exceedMin;\n    const maxOutput = getValueAndMessage(max);\n    const minOutput = getValueAndMessage(min);\n    if (!isNullOrUndefined(inputValue) && !isNaN(inputValue)) {\n      const valueNumber = ref.valueAsNumber || (inputValue ? +inputValue : inputValue);\n      if (!isNullOrUndefined(maxOutput.value)) {\n        exceedMax = valueNumber > maxOutput.value;\n      }\n      if (!isNullOrUndefined(minOutput.value)) {\n        exceedMin = valueNumber < minOutput.value;\n      }\n    } else {\n      const valueDate = ref.valueAsDate || new Date(inputValue);\n      const convertTimeToDate = time => new Date(new Date().toDateString() + ' ' + time);\n      const isTime = ref.type == 'time';\n      const isWeek = ref.type == 'week';\n      if (isString(maxOutput.value) && inputValue) {\n        exceedMax = isTime ? convertTimeToDate(inputValue) > convertTimeToDate(maxOutput.value) : isWeek ? inputValue > maxOutput.value : valueDate > new Date(maxOutput.value);\n      }\n      if (isString(minOutput.value) && inputValue) {\n        exceedMin = isTime ? convertTimeToDate(inputValue) < convertTimeToDate(minOutput.value) : isWeek ? inputValue < minOutput.value : valueDate < new Date(minOutput.value);\n      }\n    }\n    if (exceedMax || exceedMin) {\n      getMinMaxMessage(!!exceedMax, maxOutput.message, minOutput.message, INPUT_VALIDATION_RULES.max, INPUT_VALIDATION_RULES.min);\n      if (!validateAllFieldCriteria) {\n        setCustomValidity(error[name].message);\n        return error;\n      }\n    }\n  }\n  if ((maxLength || minLength) && !isEmpty && (isString(inputValue) || isFieldArray && Array.isArray(inputValue))) {\n    const maxLengthOutput = getValueAndMessage(maxLength);\n    const minLengthOutput = getValueAndMessage(minLength);\n    const exceedMax = !isNullOrUndefined(maxLengthOutput.value) && inputValue.length > +maxLengthOutput.value;\n    const exceedMin = !isNullOrUndefined(minLengthOutput.value) && inputValue.length < +minLengthOutput.value;\n    if (exceedMax || exceedMin) {\n      getMinMaxMessage(exceedMax, maxLengthOutput.message, minLengthOutput.message);\n      if (!validateAllFieldCriteria) {\n        setCustomValidity(error[name].message);\n        return error;\n      }\n    }\n  }\n  if (pattern && !isEmpty && isString(inputValue)) {\n    const {\n      value: patternValue,\n      message\n    } = getValueAndMessage(pattern);\n    if (isRegex(patternValue) && !inputValue.match(patternValue)) {\n      error[name] = {\n        type: INPUT_VALIDATION_RULES.pattern,\n        message,\n        ref,\n        ...appendErrorsCurry(INPUT_VALIDATION_RULES.pattern, message)\n      };\n      if (!validateAllFieldCriteria) {\n        setCustomValidity(message);\n        return error;\n      }\n    }\n  }\n  if (validate) {\n    if (isFunction(validate)) {\n      const result = await validate(inputValue, formValues);\n      const validateError = getValidateError(result, inputRef);\n      if (validateError) {\n        error[name] = {\n          ...validateError,\n          ...appendErrorsCurry(INPUT_VALIDATION_RULES.validate, validateError.message)\n        };\n        if (!validateAllFieldCriteria) {\n          setCustomValidity(validateError.message);\n          return error;\n        }\n      }\n    } else if (isObject(validate)) {\n      let validationResult = {};\n      for (const key in validate) {\n        if (!isEmptyObject(validationResult) && !validateAllFieldCriteria) {\n          break;\n        }\n        const validateError = getValidateError(await validate[key](inputValue, formValues), inputRef, key);\n        if (validateError) {\n          validationResult = {\n            ...validateError,\n            ...appendErrorsCurry(key, validateError.message)\n          };\n          setCustomValidity(validateError.message);\n          if (validateAllFieldCriteria) {\n            error[name] = validationResult;\n          }\n        }\n      }\n      if (!isEmptyObject(validationResult)) {\n        error[name] = {\n          ref: inputRef,\n          ...validationResult\n        };\n        if (!validateAllFieldCriteria) {\n          return error;\n        }\n      }\n    }\n  }\n  setCustomValidity(true);\n  return error;\n};\nvar appendAt = (data, value) => [...data, ...convertToArrayPayload(value)];\nvar fillEmptyArray = value => Array.isArray(value) ? value.map(() => undefined) : undefined;\nfunction insert(data, index, value) {\n  return [...data.slice(0, index), ...convertToArrayPayload(value), ...data.slice(index)];\n}\nvar moveArrayAt = (data, from, to) => {\n  if (!Array.isArray(data)) {\n    return [];\n  }\n  if (isUndefined(data[to])) {\n    data[to] = undefined;\n  }\n  data.splice(to, 0, data.splice(from, 1)[0]);\n  return data;\n};\nvar prependAt = (data, value) => [...convertToArrayPayload(value), ...convertToArrayPayload(data)];\nfunction removeAtIndexes(data, indexes) {\n  let i = 0;\n  const temp = [...data];\n  for (const index of indexes) {\n    temp.splice(index - i, 1);\n    i++;\n  }\n  return compact(temp).length ? temp : [];\n}\nvar removeArrayAt = (data, index) => isUndefined(index) ? [] : removeAtIndexes(data, convertToArrayPayload(index).sort((a, b) => a - b));\nvar swapArrayAt = (data, indexA, indexB) => {\n  [data[indexA], data[indexB]] = [data[indexB], data[indexA]];\n};\nfunction baseGet(object, updatePath) {\n  const length = updatePath.slice(0, -1).length;\n  let index = 0;\n  while (index < length) {\n    object = isUndefined(object) ? index++ : object[updatePath[index++]];\n  }\n  return object;\n}\nfunction isEmptyArray(obj) {\n  for (const key in obj) {\n    if (obj.hasOwnProperty(key) && !isUndefined(obj[key])) {\n      return false;\n    }\n  }\n  return true;\n}\nfunction unset(object, path) {\n  const paths = Array.isArray(path) ? path : isKey(path) ? [path] : stringToPath(path);\n  const childObject = paths.length === 1 ? object : baseGet(object, paths);\n  const index = paths.length - 1;\n  const key = paths[index];\n  if (childObject) {\n    delete childObject[key];\n  }\n  if (index !== 0 && (isObject(childObject) && isEmptyObject(childObject) || Array.isArray(childObject) && isEmptyArray(childObject))) {\n    unset(object, paths.slice(0, -1));\n  }\n  return object;\n}\nvar updateAt = (fieldValues, index, value) => {\n  fieldValues[index] = value;\n  return fieldValues;\n};\n\n/**\n * A custom hook that exposes convenient methods to perform operations with a list of dynamic inputs that need to be appended, updated, removed etc. • [Demo](https://codesandbox.io/s/react-hook-form-usefieldarray-ssugn) • [Video](https://youtu.be/4MrbfGSFY2A)\n *\n * @remarks\n * [API](https://react-hook-form.com/docs/usefieldarray) • [Demo](https://codesandbox.io/s/react-hook-form-usefieldarray-ssugn)\n *\n * @param props - useFieldArray props\n *\n * @returns methods - functions to manipulate with the Field Arrays (dynamic inputs) {@link UseFieldArrayReturn}\n *\n * @example\n * ```tsx\n * function App() {\n *   const { register, control, handleSubmit, reset, trigger, setError } = useForm({\n *     defaultValues: {\n *       test: []\n *     }\n *   });\n *   const { fields, append } = useFieldArray({\n *     control,\n *     name: \"test\"\n *   });\n *\n *   return (\n *     <form onSubmit={handleSubmit(data => console.log(data))}>\n *       {fields.map((item, index) => (\n *          <input key={item.id} {...register(`test.${index}.firstName`)}  />\n *       ))}\n *       <button type=\"button\" onClick={() => append({ firstName: \"bill\" })}>\n *         append\n *       </button>\n *       <input type=\"submit\" />\n *     </form>\n *   );\n * }\n * ```\n */\nfunction useFieldArray(props) {\n  const methods = useFormContext();\n  const {\n    control = methods.control,\n    name,\n    keyName = 'id',\n    shouldUnregister\n  } = props;\n  const [fields, setFields] = React.useState(control._getFieldArray(name));\n  const ids = React.useRef(control._getFieldArray(name).map(generateId));\n  const _fieldIds = React.useRef(fields);\n  const _name = React.useRef(name);\n  const _actioned = React.useRef(false);\n  _name.current = name;\n  _fieldIds.current = fields;\n  control._names.array.add(name);\n  props.rules && control.register(name, props.rules);\n  useSubscribe({\n    next: ({\n      values,\n      name: fieldArrayName\n    }) => {\n      if (fieldArrayName === _name.current || !fieldArrayName) {\n        const fieldValues = get(values, _name.current);\n        if (Array.isArray(fieldValues)) {\n          setFields(fieldValues);\n          ids.current = fieldValues.map(generateId);\n        }\n      }\n    },\n    subject: control._subjects.array\n  });\n  const updateValues = React.useCallback(updatedFieldArrayValues => {\n    _actioned.current = true;\n    control._updateFieldArray(name, updatedFieldArrayValues);\n  }, [control, name]);\n  const append = (value, options) => {\n    const appendValue = convertToArrayPayload(cloneObject(value));\n    const updatedFieldArrayValues = appendAt(control._getFieldArray(name), appendValue);\n    control._names.focus = getFocusFieldName(name, updatedFieldArrayValues.length - 1, options);\n    ids.current = appendAt(ids.current, appendValue.map(generateId));\n    updateValues(updatedFieldArrayValues);\n    setFields(updatedFieldArrayValues);\n    control._updateFieldArray(name, updatedFieldArrayValues, appendAt, {\n      argA: fillEmptyArray(value)\n    });\n  };\n  const prepend = (value, options) => {\n    const prependValue = convertToArrayPayload(cloneObject(value));\n    const updatedFieldArrayValues = prependAt(control._getFieldArray(name), prependValue);\n    control._names.focus = getFocusFieldName(name, 0, options);\n    ids.current = prependAt(ids.current, prependValue.map(generateId));\n    updateValues(updatedFieldArrayValues);\n    setFields(updatedFieldArrayValues);\n    control._updateFieldArray(name, updatedFieldArrayValues, prependAt, {\n      argA: fillEmptyArray(value)\n    });\n  };\n  const remove = index => {\n    const updatedFieldArrayValues = removeArrayAt(control._getFieldArray(name), index);\n    ids.current = removeArrayAt(ids.current, index);\n    updateValues(updatedFieldArrayValues);\n    setFields(updatedFieldArrayValues);\n    control._updateFieldArray(name, updatedFieldArrayValues, removeArrayAt, {\n      argA: index\n    });\n  };\n  const insert$1 = (index, value, options) => {\n    const insertValue = convertToArrayPayload(cloneObject(value));\n    const updatedFieldArrayValues = insert(control._getFieldArray(name), index, insertValue);\n    control._names.focus = getFocusFieldName(name, index, options);\n    ids.current = insert(ids.current, index, insertValue.map(generateId));\n    updateValues(updatedFieldArrayValues);\n    setFields(updatedFieldArrayValues);\n    control._updateFieldArray(name, updatedFieldArrayValues, insert, {\n      argA: index,\n      argB: fillEmptyArray(value)\n    });\n  };\n  const swap = (indexA, indexB) => {\n    const updatedFieldArrayValues = control._getFieldArray(name);\n    swapArrayAt(updatedFieldArrayValues, indexA, indexB);\n    swapArrayAt(ids.current, indexA, indexB);\n    updateValues(updatedFieldArrayValues);\n    setFields(updatedFieldArrayValues);\n    control._updateFieldArray(name, updatedFieldArrayValues, swapArrayAt, {\n      argA: indexA,\n      argB: indexB\n    }, false);\n  };\n  const move = (from, to) => {\n    const updatedFieldArrayValues = control._getFieldArray(name);\n    moveArrayAt(updatedFieldArrayValues, from, to);\n    moveArrayAt(ids.current, from, to);\n    updateValues(updatedFieldArrayValues);\n    setFields(updatedFieldArrayValues);\n    control._updateFieldArray(name, updatedFieldArrayValues, moveArrayAt, {\n      argA: from,\n      argB: to\n    }, false);\n  };\n  const update = (index, value) => {\n    const updateValue = cloneObject(value);\n    const updatedFieldArrayValues = updateAt(control._getFieldArray(name), index, updateValue);\n    ids.current = [...updatedFieldArrayValues].map((item, i) => !item || i === index ? generateId() : ids.current[i]);\n    updateValues(updatedFieldArrayValues);\n    setFields([...updatedFieldArrayValues]);\n    control._updateFieldArray(name, updatedFieldArrayValues, updateAt, {\n      argA: index,\n      argB: updateValue\n    }, true, false);\n  };\n  const replace = value => {\n    const updatedFieldArrayValues = convertToArrayPayload(cloneObject(value));\n    ids.current = updatedFieldArrayValues.map(generateId);\n    updateValues([...updatedFieldArrayValues]);\n    setFields([...updatedFieldArrayValues]);\n    control._updateFieldArray(name, [...updatedFieldArrayValues], data => data, {}, true, false);\n  };\n  React.useEffect(() => {\n    control._state.action = false;\n    isWatched(name, control._names) && control._subjects.state.next({\n      ...control._formState\n    });\n    if (_actioned.current && (!getValidationModes(control._options.mode).isOnSubmit || control._formState.isSubmitted)) {\n      if (control._options.resolver) {\n        control._executeSchema([name]).then(result => {\n          const error = get(result.errors, name);\n          const existingError = get(control._formState.errors, name);\n          if (existingError ? !error && existingError.type || error && (existingError.type !== error.type || existingError.message !== error.message) : error && error.type) {\n            error ? set(control._formState.errors, name, error) : unset(control._formState.errors, name);\n            control._subjects.state.next({\n              errors: control._formState.errors\n            });\n          }\n        });\n      } else {\n        const field = get(control._fields, name);\n        if (field && field._f) {\n          validateField(field, control._formValues, control._options.criteriaMode === VALIDATION_MODE.all, control._options.shouldUseNativeValidation, true).then(error => !isEmptyObject(error) && control._subjects.state.next({\n            errors: updateFieldArrayRootError(control._formState.errors, error, name)\n          }));\n        }\n      }\n    }\n    control._subjects.values.next({\n      name,\n      values: {\n        ...control._formValues\n      }\n    });\n    control._names.focus && iterateFieldsByAction(control._fields, (ref, key) => {\n      if (control._names.focus && key.startsWith(control._names.focus) && ref.focus) {\n        ref.focus();\n        return 1;\n      }\n      return;\n    });\n    control._names.focus = '';\n    control._updateValid();\n    _actioned.current = false;\n  }, [fields, name, control]);\n  React.useEffect(() => {\n    !get(control._formValues, name) && control._updateFieldArray(name);\n    return () => {\n      (control._options.shouldUnregister || shouldUnregister) && control.unregister(name);\n    };\n  }, [name, control, keyName, shouldUnregister]);\n  return {\n    swap: React.useCallback(swap, [updateValues, name, control]),\n    move: React.useCallback(move, [updateValues, name, control]),\n    prepend: React.useCallback(prepend, [updateValues, name, control]),\n    append: React.useCallback(append, [updateValues, name, control]),\n    remove: React.useCallback(remove, [updateValues, name, control]),\n    insert: React.useCallback(insert$1, [updateValues, name, control]),\n    update: React.useCallback(update, [updateValues, name, control]),\n    replace: React.useCallback(replace, [updateValues, name, control]),\n    fields: React.useMemo(() => fields.map((field, index) => ({\n      ...field,\n      [keyName]: ids.current[index] || generateId()\n    })), [fields, keyName])\n  };\n}\nvar createSubject = () => {\n  let _observers = [];\n  const next = value => {\n    for (const observer of _observers) {\n      observer.next && observer.next(value);\n    }\n  };\n  const subscribe = observer => {\n    _observers.push(observer);\n    return {\n      unsubscribe: () => {\n        _observers = _observers.filter(o => o !== observer);\n      }\n    };\n  };\n  const unsubscribe = () => {\n    _observers = [];\n  };\n  return {\n    get observers() {\n      return _observers;\n    },\n    next,\n    subscribe,\n    unsubscribe\n  };\n};\nvar isPrimitive = value => isNullOrUndefined(value) || !isObjectType(value);\nfunction deepEqual(object1, object2) {\n  if (isPrimitive(object1) || isPrimitive(object2)) {\n    return object1 === object2;\n  }\n  if (isDateObject(object1) && isDateObject(object2)) {\n    return object1.getTime() === object2.getTime();\n  }\n  const keys1 = Object.keys(object1);\n  const keys2 = Object.keys(object2);\n  if (keys1.length !== keys2.length) {\n    return false;\n  }\n  for (const key of keys1) {\n    const val1 = object1[key];\n    if (!keys2.includes(key)) {\n      return false;\n    }\n    if (key !== 'ref') {\n      const val2 = object2[key];\n      if (isDateObject(val1) && isDateObject(val2) || isObject(val1) && isObject(val2) || Array.isArray(val1) && Array.isArray(val2) ? !deepEqual(val1, val2) : val1 !== val2) {\n        return false;\n      }\n    }\n  }\n  return true;\n}\nvar isMultipleSelect = element => element.type === `select-multiple`;\nvar isRadioOrCheckbox = ref => isRadioInput(ref) || isCheckBoxInput(ref);\nvar live = ref => isHTMLElement(ref) && ref.isConnected;\nvar objectHasFunction = data => {\n  for (const key in data) {\n    if (isFunction(data[key])) {\n      return true;\n    }\n  }\n  return false;\n};\nfunction markFieldsDirty(data, fields = {}) {\n  const isParentNodeArray = Array.isArray(data);\n  if (isObject(data) || isParentNodeArray) {\n    for (const key in data) {\n      if (Array.isArray(data[key]) || isObject(data[key]) && !objectHasFunction(data[key])) {\n        fields[key] = Array.isArray(data[key]) ? [] : {};\n        markFieldsDirty(data[key], fields[key]);\n      } else if (!isNullOrUndefined(data[key])) {\n        fields[key] = true;\n      }\n    }\n  }\n  return fields;\n}\nfunction getDirtyFieldsFromDefaultValues(data, formValues, dirtyFieldsFromValues) {\n  const isParentNodeArray = Array.isArray(data);\n  if (isObject(data) || isParentNodeArray) {\n    for (const key in data) {\n      if (Array.isArray(data[key]) || isObject(data[key]) && !objectHasFunction(data[key])) {\n        if (isUndefined(formValues) || isPrimitive(dirtyFieldsFromValues[key])) {\n          dirtyFieldsFromValues[key] = Array.isArray(data[key]) ? markFieldsDirty(data[key], []) : {\n            ...markFieldsDirty(data[key])\n          };\n        } else {\n          getDirtyFieldsFromDefaultValues(data[key], isNullOrUndefined(formValues) ? {} : formValues[key], dirtyFieldsFromValues[key]);\n        }\n      } else {\n        dirtyFieldsFromValues[key] = !deepEqual(data[key], formValues[key]);\n      }\n    }\n  }\n  return dirtyFieldsFromValues;\n}\nvar getDirtyFields = (defaultValues, formValues) => getDirtyFieldsFromDefaultValues(defaultValues, formValues, markFieldsDirty(formValues));\nvar getFieldValueAs = (value, {\n  valueAsNumber,\n  valueAsDate,\n  setValueAs\n}) => isUndefined(value) ? value : valueAsNumber ? value === '' ? NaN : value ? +value : value : valueAsDate && isString(value) ? new Date(value) : setValueAs ? setValueAs(value) : value;\nfunction getFieldValue(_f) {\n  const ref = _f.ref;\n  if (_f.refs ? _f.refs.every(ref => ref.disabled) : ref.disabled) {\n    return;\n  }\n  if (isFileInput(ref)) {\n    return ref.files;\n  }\n  if (isRadioInput(ref)) {\n    return getRadioValue(_f.refs).value;\n  }\n  if (isMultipleSelect(ref)) {\n    return [...ref.selectedOptions].map(({\n      value\n    }) => value);\n  }\n  if (isCheckBoxInput(ref)) {\n    return getCheckboxValue(_f.refs).value;\n  }\n  return getFieldValueAs(isUndefined(ref.value) ? _f.ref.value : ref.value, _f);\n}\nvar getResolverOptions = (fieldsNames, _fields, criteriaMode, shouldUseNativeValidation) => {\n  const fields = {};\n  for (const name of fieldsNames) {\n    const field = get(_fields, name);\n    field && set(fields, name, field._f);\n  }\n  return {\n    criteriaMode,\n    names: [...fieldsNames],\n    fields,\n    shouldUseNativeValidation\n  };\n};\nvar getRuleValue = rule => isUndefined(rule) ? rule : isRegex(rule) ? rule.source : isObject(rule) ? isRegex(rule.value) ? rule.value.source : rule.value : rule;\nvar hasValidation = options => options.mount && (options.required || options.min || options.max || options.maxLength || options.minLength || options.pattern || options.validate);\nfunction schemaErrorLookup(errors, _fields, name) {\n  const error = get(errors, name);\n  if (error || isKey(name)) {\n    return {\n      error,\n      name\n    };\n  }\n  const names = name.split('.');\n  while (names.length) {\n    const fieldName = names.join('.');\n    const field = get(_fields, fieldName);\n    const foundError = get(errors, fieldName);\n    if (field && !Array.isArray(field) && name !== fieldName) {\n      return {\n        name\n      };\n    }\n    if (foundError && foundError.type) {\n      return {\n        name: fieldName,\n        error: foundError\n      };\n    }\n    names.pop();\n  }\n  return {\n    name\n  };\n}\nvar skipValidation = (isBlurEvent, isTouched, isSubmitted, reValidateMode, mode) => {\n  if (mode.isOnAll) {\n    return false;\n  } else if (!isSubmitted && mode.isOnTouch) {\n    return !(isTouched || isBlurEvent);\n  } else if (isSubmitted ? reValidateMode.isOnBlur : mode.isOnBlur) {\n    return !isBlurEvent;\n  } else if (isSubmitted ? reValidateMode.isOnChange : mode.isOnChange) {\n    return isBlurEvent;\n  }\n  return true;\n};\nvar unsetEmptyArray = (ref, name) => !compact(get(ref, name)).length && unset(ref, name);\nconst defaultOptions = {\n  mode: VALIDATION_MODE.onSubmit,\n  reValidateMode: VALIDATION_MODE.onChange,\n  shouldFocusError: true\n};\nfunction createFormControl(props = {}, flushRootRender) {\n  let _options = {\n    ...defaultOptions,\n    ...props\n  };\n  let _formState = {\n    submitCount: 0,\n    isDirty: false,\n    isLoading: isFunction(_options.defaultValues),\n    isValidating: false,\n    isSubmitted: false,\n    isSubmitting: false,\n    isSubmitSuccessful: false,\n    isValid: false,\n    touchedFields: {},\n    dirtyFields: {},\n    errors: _options.errors || {},\n    disabled: _options.disabled || false\n  };\n  let _fields = {};\n  let _defaultValues = isObject(_options.defaultValues) || isObject(_options.values) ? cloneObject(_options.defaultValues || _options.values) || {} : {};\n  let _formValues = _options.shouldUnregister ? {} : cloneObject(_defaultValues);\n  let _state = {\n    action: false,\n    mount: false,\n    watch: false\n  };\n  let _names = {\n    mount: new Set(),\n    unMount: new Set(),\n    array: new Set(),\n    watch: new Set()\n  };\n  let delayErrorCallback;\n  let timer = 0;\n  const _proxyFormState = {\n    isDirty: false,\n    dirtyFields: false,\n    touchedFields: false,\n    isValidating: false,\n    isValid: false,\n    errors: false\n  };\n  const _subjects = {\n    values: createSubject(),\n    array: createSubject(),\n    state: createSubject()\n  };\n  const validationModeBeforeSubmit = getValidationModes(_options.mode);\n  const validationModeAfterSubmit = getValidationModes(_options.reValidateMode);\n  const shouldDisplayAllAssociatedErrors = _options.criteriaMode === VALIDATION_MODE.all;\n  const debounce = callback => wait => {\n    clearTimeout(timer);\n    timer = setTimeout(callback, wait);\n  };\n  const _updateValid = async shouldUpdateValid => {\n    if (_proxyFormState.isValid || shouldUpdateValid) {\n      const isValid = _options.resolver ? isEmptyObject((await _executeSchema()).errors) : await executeBuiltInValidation(_fields, true);\n      if (isValid !== _formState.isValid) {\n        _subjects.state.next({\n          isValid\n        });\n      }\n    }\n  };\n  const _updateIsValidating = value => _proxyFormState.isValidating && _subjects.state.next({\n    isValidating: value\n  });\n  const _updateFieldArray = (name, values = [], method, args, shouldSetValues = true, shouldUpdateFieldsAndState = true) => {\n    if (args && method) {\n      _state.action = true;\n      if (shouldUpdateFieldsAndState && Array.isArray(get(_fields, name))) {\n        const fieldValues = method(get(_fields, name), args.argA, args.argB);\n        shouldSetValues && set(_fields, name, fieldValues);\n      }\n      if (shouldUpdateFieldsAndState && Array.isArray(get(_formState.errors, name))) {\n        const errors = method(get(_formState.errors, name), args.argA, args.argB);\n        shouldSetValues && set(_formState.errors, name, errors);\n        unsetEmptyArray(_formState.errors, name);\n      }\n      if (_proxyFormState.touchedFields && shouldUpdateFieldsAndState && Array.isArray(get(_formState.touchedFields, name))) {\n        const touchedFields = method(get(_formState.touchedFields, name), args.argA, args.argB);\n        shouldSetValues && set(_formState.touchedFields, name, touchedFields);\n      }\n      if (_proxyFormState.dirtyFields) {\n        _formState.dirtyFields = getDirtyFields(_defaultValues, _formValues);\n      }\n      _subjects.state.next({\n        name,\n        isDirty: _getDirty(name, values),\n        dirtyFields: _formState.dirtyFields,\n        errors: _formState.errors,\n        isValid: _formState.isValid\n      });\n    } else {\n      set(_formValues, name, values);\n    }\n  };\n  const updateErrors = (name, error) => {\n    set(_formState.errors, name, error);\n    _subjects.state.next({\n      errors: _formState.errors\n    });\n  };\n  const _setErrors = errors => {\n    _formState.errors = errors;\n    _subjects.state.next({\n      errors: _formState.errors,\n      isValid: false\n    });\n  };\n  const updateValidAndValue = (name, shouldSkipSetValueAs, value, ref) => {\n    const field = get(_fields, name);\n    if (field) {\n      const defaultValue = get(_formValues, name, isUndefined(value) ? get(_defaultValues, name) : value);\n      isUndefined(defaultValue) || ref && ref.defaultChecked || shouldSkipSetValueAs ? set(_formValues, name, shouldSkipSetValueAs ? defaultValue : getFieldValue(field._f)) : setFieldValue(name, defaultValue);\n      _state.mount && _updateValid();\n    }\n  };\n  const updateTouchAndDirty = (name, fieldValue, isBlurEvent, shouldDirty, shouldRender) => {\n    let shouldUpdateField = false;\n    let isPreviousDirty = false;\n    const output = {\n      name\n    };\n    const disabledField = !!(get(_fields, name) && get(_fields, name)._f.disabled);\n    if (!isBlurEvent || shouldDirty) {\n      if (_proxyFormState.isDirty) {\n        isPreviousDirty = _formState.isDirty;\n        _formState.isDirty = output.isDirty = _getDirty();\n        shouldUpdateField = isPreviousDirty !== output.isDirty;\n      }\n      const isCurrentFieldPristine = disabledField || deepEqual(get(_defaultValues, name), fieldValue);\n      isPreviousDirty = !!(!disabledField && get(_formState.dirtyFields, name));\n      isCurrentFieldPristine || disabledField ? unset(_formState.dirtyFields, name) : set(_formState.dirtyFields, name, true);\n      output.dirtyFields = _formState.dirtyFields;\n      shouldUpdateField = shouldUpdateField || _proxyFormState.dirtyFields && isPreviousDirty !== !isCurrentFieldPristine;\n    }\n    if (isBlurEvent) {\n      const isPreviousFieldTouched = get(_formState.touchedFields, name);\n      if (!isPreviousFieldTouched) {\n        set(_formState.touchedFields, name, isBlurEvent);\n        output.touchedFields = _formState.touchedFields;\n        shouldUpdateField = shouldUpdateField || _proxyFormState.touchedFields && isPreviousFieldTouched !== isBlurEvent;\n      }\n    }\n    shouldUpdateField && shouldRender && _subjects.state.next(output);\n    return shouldUpdateField ? output : {};\n  };\n  const shouldRenderByError = (name, isValid, error, fieldState) => {\n    const previousFieldError = get(_formState.errors, name);\n    const shouldUpdateValid = _proxyFormState.isValid && isBoolean(isValid) && _formState.isValid !== isValid;\n    if (props.delayError && error) {\n      delayErrorCallback = debounce(() => updateErrors(name, error));\n      delayErrorCallback(props.delayError);\n    } else {\n      clearTimeout(timer);\n      delayErrorCallback = null;\n      error ? set(_formState.errors, name, error) : unset(_formState.errors, name);\n    }\n    if ((error ? !deepEqual(previousFieldError, error) : previousFieldError) || !isEmptyObject(fieldState) || shouldUpdateValid) {\n      const updatedFormState = {\n        ...fieldState,\n        ...(shouldUpdateValid && isBoolean(isValid) ? {\n          isValid\n        } : {}),\n        errors: _formState.errors,\n        name\n      };\n      _formState = {\n        ..._formState,\n        ...updatedFormState\n      };\n      _subjects.state.next(updatedFormState);\n    }\n    _updateIsValidating(false);\n  };\n  const _executeSchema = async name => _options.resolver(_formValues, _options.context, getResolverOptions(name || _names.mount, _fields, _options.criteriaMode, _options.shouldUseNativeValidation));\n  const executeSchemaAndUpdateState = async names => {\n    const {\n      errors\n    } = await _executeSchema(names);\n    if (names) {\n      for (const name of names) {\n        const error = get(errors, name);\n        error ? set(_formState.errors, name, error) : unset(_formState.errors, name);\n      }\n    } else {\n      _formState.errors = errors;\n    }\n    return errors;\n  };\n  const executeBuiltInValidation = async (fields, shouldOnlyCheckValid, context = {\n    valid: true\n  }) => {\n    for (const name in fields) {\n      const field = fields[name];\n      if (field) {\n        const {\n          _f,\n          ...fieldValue\n        } = field;\n        if (_f) {\n          const isFieldArrayRoot = _names.array.has(_f.name);\n          const fieldError = await validateField(field, _formValues, shouldDisplayAllAssociatedErrors, _options.shouldUseNativeValidation && !shouldOnlyCheckValid, isFieldArrayRoot);\n          if (fieldError[_f.name]) {\n            context.valid = false;\n            if (shouldOnlyCheckValid) {\n              break;\n            }\n          }\n          !shouldOnlyCheckValid && (get(fieldError, _f.name) ? isFieldArrayRoot ? updateFieldArrayRootError(_formState.errors, fieldError, _f.name) : set(_formState.errors, _f.name, fieldError[_f.name]) : unset(_formState.errors, _f.name));\n        }\n        fieldValue && (await executeBuiltInValidation(fieldValue, shouldOnlyCheckValid, context));\n      }\n    }\n    return context.valid;\n  };\n  const _removeUnmounted = () => {\n    for (const name of _names.unMount) {\n      const field = get(_fields, name);\n      field && (field._f.refs ? field._f.refs.every(ref => !live(ref)) : !live(field._f.ref)) && unregister(name);\n    }\n    _names.unMount = new Set();\n  };\n  const _getDirty = (name, data) => (name && data && set(_formValues, name, data), !deepEqual(getValues(), _defaultValues));\n  const _getWatch = (names, defaultValue, isGlobal) => generateWatchOutput(names, _names, {\n    ...(_state.mount ? _formValues : isUndefined(defaultValue) ? _defaultValues : isString(names) ? {\n      [names]: defaultValue\n    } : defaultValue)\n  }, isGlobal, defaultValue);\n  const _getFieldArray = name => compact(get(_state.mount ? _formValues : _defaultValues, name, props.shouldUnregister ? get(_defaultValues, name, []) : []));\n  const setFieldValue = (name, value, options = {}) => {\n    const field = get(_fields, name);\n    let fieldValue = value;\n    if (field) {\n      const fieldReference = field._f;\n      if (fieldReference) {\n        !fieldReference.disabled && set(_formValues, name, getFieldValueAs(value, fieldReference));\n        fieldValue = isHTMLElement(fieldReference.ref) && isNullOrUndefined(value) ? '' : value;\n        if (isMultipleSelect(fieldReference.ref)) {\n          [...fieldReference.ref.options].forEach(optionRef => optionRef.selected = fieldValue.includes(optionRef.value));\n        } else if (fieldReference.refs) {\n          if (isCheckBoxInput(fieldReference.ref)) {\n            fieldReference.refs.length > 1 ? fieldReference.refs.forEach(checkboxRef => (!checkboxRef.defaultChecked || !checkboxRef.disabled) && (checkboxRef.checked = Array.isArray(fieldValue) ? !!fieldValue.find(data => data === checkboxRef.value) : fieldValue === checkboxRef.value)) : fieldReference.refs[0] && (fieldReference.refs[0].checked = !!fieldValue);\n          } else {\n            fieldReference.refs.forEach(radioRef => radioRef.checked = radioRef.value === fieldValue);\n          }\n        } else if (isFileInput(fieldReference.ref)) {\n          fieldReference.ref.value = '';\n        } else {\n          fieldReference.ref.value = fieldValue;\n          if (!fieldReference.ref.type) {\n            _subjects.values.next({\n              name,\n              values: {\n                ..._formValues\n              }\n            });\n          }\n        }\n      }\n    }\n    (options.shouldDirty || options.shouldTouch) && updateTouchAndDirty(name, fieldValue, options.shouldTouch, options.shouldDirty, true);\n    options.shouldValidate && trigger(name);\n  };\n  const setValues = (name, value, options) => {\n    for (const fieldKey in value) {\n      const fieldValue = value[fieldKey];\n      const fieldName = `${name}.${fieldKey}`;\n      const field = get(_fields, fieldName);\n      (_names.array.has(name) || !isPrimitive(fieldValue) || field && !field._f) && !isDateObject(fieldValue) ? setValues(fieldName, fieldValue, options) : setFieldValue(fieldName, fieldValue, options);\n    }\n  };\n  const setValue = (name, value, options = {}) => {\n    const field = get(_fields, name);\n    const isFieldArray = _names.array.has(name);\n    const cloneValue = cloneObject(value);\n    set(_formValues, name, cloneValue);\n    if (isFieldArray) {\n      _subjects.array.next({\n        name,\n        values: {\n          ..._formValues\n        }\n      });\n      if ((_proxyFormState.isDirty || _proxyFormState.dirtyFields) && options.shouldDirty) {\n        _subjects.state.next({\n          name,\n          dirtyFields: getDirtyFields(_defaultValues, _formValues),\n          isDirty: _getDirty(name, cloneValue)\n        });\n      }\n    } else {\n      field && !field._f && !isNullOrUndefined(cloneValue) ? setValues(name, cloneValue, options) : setFieldValue(name, cloneValue, options);\n    }\n    isWatched(name, _names) && _subjects.state.next({\n      ..._formState\n    });\n    _subjects.values.next({\n      name,\n      values: {\n        ..._formValues\n      }\n    });\n    !_state.mount && flushRootRender();\n  };\n  const onChange = async event => {\n    const target = event.target;\n    let name = target.name;\n    let isFieldValueUpdated = true;\n    const field = get(_fields, name);\n    const getCurrentFieldValue = () => target.type ? getFieldValue(field._f) : getEventValue(event);\n    const _updateIsFieldValueUpdated = fieldValue => {\n      isFieldValueUpdated = Number.isNaN(fieldValue) || fieldValue === get(_formValues, name, fieldValue);\n    };\n    if (field) {\n      let error;\n      let isValid;\n      const fieldValue = getCurrentFieldValue();\n      const isBlurEvent = event.type === EVENTS.BLUR || event.type === EVENTS.FOCUS_OUT;\n      const shouldSkipValidation = !hasValidation(field._f) && !_options.resolver && !get(_formState.errors, name) && !field._f.deps || skipValidation(isBlurEvent, get(_formState.touchedFields, name), _formState.isSubmitted, validationModeAfterSubmit, validationModeBeforeSubmit);\n      const watched = isWatched(name, _names, isBlurEvent);\n      set(_formValues, name, fieldValue);\n      if (isBlurEvent) {\n        field._f.onBlur && field._f.onBlur(event);\n        delayErrorCallback && delayErrorCallback(0);\n      } else if (field._f.onChange) {\n        field._f.onChange(event);\n      }\n      const fieldState = updateTouchAndDirty(name, fieldValue, isBlurEvent, false);\n      const shouldRender = !isEmptyObject(fieldState) || watched;\n      !isBlurEvent && _subjects.values.next({\n        name,\n        type: event.type,\n        values: {\n          ..._formValues\n        }\n      });\n      if (shouldSkipValidation) {\n        _proxyFormState.isValid && _updateValid();\n        return shouldRender && _subjects.state.next({\n          name,\n          ...(watched ? {} : fieldState)\n        });\n      }\n      !isBlurEvent && watched && _subjects.state.next({\n        ..._formState\n      });\n      _updateIsValidating(true);\n      if (_options.resolver) {\n        const {\n          errors\n        } = await _executeSchema([name]);\n        _updateIsFieldValueUpdated(fieldValue);\n        if (isFieldValueUpdated) {\n          const previousErrorLookupResult = schemaErrorLookup(_formState.errors, _fields, name);\n          const errorLookupResult = schemaErrorLookup(errors, _fields, previousErrorLookupResult.name || name);\n          error = errorLookupResult.error;\n          name = errorLookupResult.name;\n          isValid = isEmptyObject(errors);\n        }\n      } else {\n        error = (await validateField(field, _formValues, shouldDisplayAllAssociatedErrors, _options.shouldUseNativeValidation))[name];\n        _updateIsFieldValueUpdated(fieldValue);\n        if (isFieldValueUpdated) {\n          if (error) {\n            isValid = false;\n          } else if (_proxyFormState.isValid) {\n            isValid = await executeBuiltInValidation(_fields, true);\n          }\n        }\n      }\n      if (isFieldValueUpdated) {\n        field._f.deps && trigger(field._f.deps);\n        shouldRenderByError(name, isValid, error, fieldState);\n      }\n    }\n  };\n  const _focusInput = (ref, key) => {\n    if (get(_formState.errors, key) && ref.focus) {\n      ref.focus();\n      return 1;\n    }\n    return;\n  };\n  const trigger = async (name, options = {}) => {\n    let isValid;\n    let validationResult;\n    const fieldNames = convertToArrayPayload(name);\n    _updateIsValidating(true);\n    if (_options.resolver) {\n      const errors = await executeSchemaAndUpdateState(isUndefined(name) ? name : fieldNames);\n      isValid = isEmptyObject(errors);\n      validationResult = name ? !fieldNames.some(name => get(errors, name)) : isValid;\n    } else if (name) {\n      validationResult = (await Promise.all(fieldNames.map(async fieldName => {\n        const field = get(_fields, fieldName);\n        return await executeBuiltInValidation(field && field._f ? {\n          [fieldName]: field\n        } : field);\n      }))).every(Boolean);\n      !(!validationResult && !_formState.isValid) && _updateValid();\n    } else {\n      validationResult = isValid = await executeBuiltInValidation(_fields);\n    }\n    _subjects.state.next({\n      ...(!isString(name) || _proxyFormState.isValid && isValid !== _formState.isValid ? {} : {\n        name\n      }),\n      ...(_options.resolver || !name ? {\n        isValid\n      } : {}),\n      errors: _formState.errors,\n      isValidating: false\n    });\n    options.shouldFocus && !validationResult && iterateFieldsByAction(_fields, _focusInput, name ? fieldNames : _names.mount);\n    return validationResult;\n  };\n  const getValues = fieldNames => {\n    const values = {\n      ..._defaultValues,\n      ...(_state.mount ? _formValues : {})\n    };\n    return isUndefined(fieldNames) ? values : isString(fieldNames) ? get(values, fieldNames) : fieldNames.map(name => get(values, name));\n  };\n  const getFieldState = (name, formState) => ({\n    invalid: !!get((formState || _formState).errors, name),\n    isDirty: !!get((formState || _formState).dirtyFields, name),\n    isTouched: !!get((formState || _formState).touchedFields, name),\n    error: get((formState || _formState).errors, name)\n  });\n  const clearErrors = name => {\n    name && convertToArrayPayload(name).forEach(inputName => unset(_formState.errors, inputName));\n    _subjects.state.next({\n      errors: name ? _formState.errors : {}\n    });\n  };\n  const setError = (name, error, options) => {\n    const ref = (get(_fields, name, {\n      _f: {}\n    })._f || {}).ref;\n    set(_formState.errors, name, {\n      ...error,\n      ref\n    });\n    _subjects.state.next({\n      name,\n      errors: _formState.errors,\n      isValid: false\n    });\n    options && options.shouldFocus && ref && ref.focus && ref.focus();\n  };\n  const watch = (name, defaultValue) => isFunction(name) ? _subjects.values.subscribe({\n    next: payload => name(_getWatch(undefined, defaultValue), payload)\n  }) : _getWatch(name, defaultValue, true);\n  const unregister = (name, options = {}) => {\n    for (const fieldName of name ? convertToArrayPayload(name) : _names.mount) {\n      _names.mount.delete(fieldName);\n      _names.array.delete(fieldName);\n      if (!options.keepValue) {\n        unset(_fields, fieldName);\n        unset(_formValues, fieldName);\n      }\n      !options.keepError && unset(_formState.errors, fieldName);\n      !options.keepDirty && unset(_formState.dirtyFields, fieldName);\n      !options.keepTouched && unset(_formState.touchedFields, fieldName);\n      !_options.shouldUnregister && !options.keepDefaultValue && unset(_defaultValues, fieldName);\n    }\n    _subjects.values.next({\n      values: {\n        ..._formValues\n      }\n    });\n    _subjects.state.next({\n      ..._formState,\n      ...(!options.keepDirty ? {} : {\n        isDirty: _getDirty()\n      })\n    });\n    !options.keepIsValid && _updateValid();\n  };\n  const _updateDisabledField = ({\n    disabled,\n    name,\n    field,\n    fields,\n    value\n  }) => {\n    if (isBoolean(disabled)) {\n      const inputValue = disabled ? undefined : isUndefined(value) ? getFieldValue(field ? field._f : get(fields, name)._f) : value;\n      set(_formValues, name, inputValue);\n      updateTouchAndDirty(name, inputValue, false, false, true);\n    }\n  };\n  const register = (name, options = {}) => {\n    let field = get(_fields, name);\n    const disabledIsDefined = isBoolean(options.disabled);\n    set(_fields, name, {\n      ...(field || {}),\n      _f: {\n        ...(field && field._f ? field._f : {\n          ref: {\n            name\n          }\n        }),\n        name,\n        mount: true,\n        ...options\n      }\n    });\n    _names.mount.add(name);\n    if (field) {\n      _updateDisabledField({\n        field,\n        disabled: options.disabled,\n        name,\n        value: options.value\n      });\n    } else {\n      updateValidAndValue(name, true, options.value);\n    }\n    return {\n      ...(disabledIsDefined ? {\n        disabled: options.disabled\n      } : {}),\n      ...(_options.progressive ? {\n        required: !!options.required,\n        min: getRuleValue(options.min),\n        max: getRuleValue(options.max),\n        minLength: getRuleValue(options.minLength),\n        maxLength: getRuleValue(options.maxLength),\n        pattern: getRuleValue(options.pattern)\n      } : {}),\n      name,\n      onChange,\n      onBlur: onChange,\n      ref: ref => {\n        if (ref) {\n          register(name, options);\n          field = get(_fields, name);\n          const fieldRef = isUndefined(ref.value) ? ref.querySelectorAll ? ref.querySelectorAll('input,select,textarea')[0] || ref : ref : ref;\n          const radioOrCheckbox = isRadioOrCheckbox(fieldRef);\n          const refs = field._f.refs || [];\n          if (radioOrCheckbox ? refs.find(option => option === fieldRef) : fieldRef === field._f.ref) {\n            return;\n          }\n          set(_fields, name, {\n            _f: {\n              ...field._f,\n              ...(radioOrCheckbox ? {\n                refs: [...refs.filter(live), fieldRef, ...(Array.isArray(get(_defaultValues, name)) ? [{}] : [])],\n                ref: {\n                  type: fieldRef.type,\n                  name\n                }\n              } : {\n                ref: fieldRef\n              })\n            }\n          });\n          updateValidAndValue(name, false, undefined, fieldRef);\n        } else {\n          field = get(_fields, name, {});\n          if (field._f) {\n            field._f.mount = false;\n          }\n          (_options.shouldUnregister || options.shouldUnregister) && !(isNameInFieldArray(_names.array, name) && _state.action) && _names.unMount.add(name);\n        }\n      }\n    };\n  };\n  const _focusError = () => _options.shouldFocusError && iterateFieldsByAction(_fields, _focusInput, _names.mount);\n  const _disableForm = disabled => {\n    if (isBoolean(disabled)) {\n      _subjects.state.next({\n        disabled\n      });\n      iterateFieldsByAction(_fields, (ref, name) => {\n        let requiredDisabledState = disabled;\n        const currentField = get(_fields, name);\n        if (currentField && isBoolean(currentField._f.disabled)) {\n          requiredDisabledState || (requiredDisabledState = currentField._f.disabled);\n        }\n        ref.disabled = requiredDisabledState;\n      }, 0, false);\n    }\n  };\n  const handleSubmit = (onValid, onInvalid) => async e => {\n    if (e) {\n      e.preventDefault && e.preventDefault();\n      e.persist && e.persist();\n    }\n    let fieldValues = cloneObject(_formValues);\n    _subjects.state.next({\n      isSubmitting: true\n    });\n    if (_options.resolver) {\n      const {\n        errors,\n        values\n      } = await _executeSchema();\n      _formState.errors = errors;\n      fieldValues = values;\n    } else {\n      await executeBuiltInValidation(_fields);\n    }\n    unset(_formState.errors, 'root');\n    if (isEmptyObject(_formState.errors)) {\n      _subjects.state.next({\n        errors: {}\n      });\n      await onValid(fieldValues, e);\n    } else {\n      if (onInvalid) {\n        await onInvalid({\n          ..._formState.errors\n        }, e);\n      }\n      _focusError();\n      setTimeout(_focusError);\n    }\n    _subjects.state.next({\n      isSubmitted: true,\n      isSubmitting: false,\n      isSubmitSuccessful: isEmptyObject(_formState.errors),\n      submitCount: _formState.submitCount + 1,\n      errors: _formState.errors\n    });\n  };\n  const resetField = (name, options = {}) => {\n    if (get(_fields, name)) {\n      if (isUndefined(options.defaultValue)) {\n        setValue(name, cloneObject(get(_defaultValues, name)));\n      } else {\n        setValue(name, options.defaultValue);\n        set(_defaultValues, name, cloneObject(options.defaultValue));\n      }\n      if (!options.keepTouched) {\n        unset(_formState.touchedFields, name);\n      }\n      if (!options.keepDirty) {\n        unset(_formState.dirtyFields, name);\n        _formState.isDirty = options.defaultValue ? _getDirty(name, cloneObject(get(_defaultValues, name))) : _getDirty();\n      }\n      if (!options.keepError) {\n        unset(_formState.errors, name);\n        _proxyFormState.isValid && _updateValid();\n      }\n      _subjects.state.next({\n        ..._formState\n      });\n    }\n  };\n  const _reset = (formValues, keepStateOptions = {}) => {\n    const updatedValues = formValues ? cloneObject(formValues) : _defaultValues;\n    const cloneUpdatedValues = cloneObject(updatedValues);\n    const values = formValues && !isEmptyObject(formValues) ? cloneUpdatedValues : _defaultValues;\n    if (!keepStateOptions.keepDefaultValues) {\n      _defaultValues = updatedValues;\n    }\n    if (!keepStateOptions.keepValues) {\n      if (keepStateOptions.keepDirtyValues) {\n        for (const fieldName of _names.mount) {\n          get(_formState.dirtyFields, fieldName) ? set(values, fieldName, get(_formValues, fieldName)) : setValue(fieldName, get(values, fieldName));\n        }\n      } else {\n        if (isWeb && isUndefined(formValues)) {\n          for (const name of _names.mount) {\n            const field = get(_fields, name);\n            if (field && field._f) {\n              const fieldReference = Array.isArray(field._f.refs) ? field._f.refs[0] : field._f.ref;\n              if (isHTMLElement(fieldReference)) {\n                const form = fieldReference.closest('form');\n                if (form) {\n                  form.reset();\n                  break;\n                }\n              }\n            }\n          }\n        }\n        _fields = {};\n      }\n      _formValues = props.shouldUnregister ? keepStateOptions.keepDefaultValues ? cloneObject(_defaultValues) : {} : cloneObject(values);\n      _subjects.array.next({\n        values: {\n          ...values\n        }\n      });\n      _subjects.values.next({\n        values: {\n          ...values\n        }\n      });\n    }\n    _names = {\n      mount: new Set(),\n      unMount: new Set(),\n      array: new Set(),\n      watch: new Set(),\n      watchAll: false,\n      focus: ''\n    };\n    !_state.mount && flushRootRender();\n    _state.mount = !_proxyFormState.isValid || !!keepStateOptions.keepIsValid;\n    _state.watch = !!props.shouldUnregister;\n    _subjects.state.next({\n      submitCount: keepStateOptions.keepSubmitCount ? _formState.submitCount : 0,\n      isDirty: keepStateOptions.keepDirty ? _formState.isDirty : !!(keepStateOptions.keepDefaultValues && !deepEqual(formValues, _defaultValues)),\n      isSubmitted: keepStateOptions.keepIsSubmitted ? _formState.isSubmitted : false,\n      dirtyFields: keepStateOptions.keepDirtyValues ? _formState.dirtyFields : keepStateOptions.keepDefaultValues && formValues ? getDirtyFields(_defaultValues, formValues) : {},\n      touchedFields: keepStateOptions.keepTouched ? _formState.touchedFields : {},\n      errors: keepStateOptions.keepErrors ? _formState.errors : {},\n      isSubmitSuccessful: keepStateOptions.keepIsSubmitSuccessful ? _formState.isSubmitSuccessful : false,\n      isSubmitting: false\n    });\n  };\n  const reset = (formValues, keepStateOptions) => _reset(isFunction(formValues) ? formValues(_formValues) : formValues, keepStateOptions);\n  const setFocus = (name, options = {}) => {\n    const field = get(_fields, name);\n    const fieldReference = field && field._f;\n    if (fieldReference) {\n      const fieldRef = fieldReference.refs ? fieldReference.refs[0] : fieldReference.ref;\n      if (fieldRef.focus) {\n        fieldRef.focus();\n        options.shouldSelect && fieldRef.select();\n      }\n    }\n  };\n  const _updateFormState = updatedFormState => {\n    _formState = {\n      ..._formState,\n      ...updatedFormState\n    };\n  };\n  const _resetDefaultValues = () => isFunction(_options.defaultValues) && _options.defaultValues().then(values => {\n    reset(values, _options.resetOptions);\n    _subjects.state.next({\n      isLoading: false\n    });\n  });\n  return {\n    control: {\n      register,\n      unregister,\n      getFieldState,\n      handleSubmit,\n      setError,\n      _executeSchema,\n      _getWatch,\n      _getDirty,\n      _updateValid,\n      _removeUnmounted,\n      _updateFieldArray,\n      _updateDisabledField,\n      _getFieldArray,\n      _reset,\n      _resetDefaultValues,\n      _updateFormState,\n      _disableForm,\n      _subjects,\n      _proxyFormState,\n      _setErrors,\n      get _fields() {\n        return _fields;\n      },\n      get _formValues() {\n        return _formValues;\n      },\n      get _state() {\n        return _state;\n      },\n      set _state(value) {\n        _state = value;\n      },\n      get _defaultValues() {\n        return _defaultValues;\n      },\n      get _names() {\n        return _names;\n      },\n      set _names(value) {\n        _names = value;\n      },\n      get _formState() {\n        return _formState;\n      },\n      set _formState(value) {\n        _formState = value;\n      },\n      get _options() {\n        return _options;\n      },\n      set _options(value) {\n        _options = {\n          ..._options,\n          ...value\n        };\n      }\n    },\n    trigger,\n    register,\n    handleSubmit,\n    watch,\n    setValue,\n    getValues,\n    reset,\n    resetField,\n    clearErrors,\n    unregister,\n    setError,\n    setFocus,\n    getFieldState\n  };\n}\n\n/**\n * Custom hook to manage the entire form.\n *\n * @remarks\n * [API](https://react-hook-form.com/docs/useform) • [Demo](https://codesandbox.io/s/react-hook-form-get-started-ts-5ksmm) • [Video](https://www.youtube.com/watch?v=RkXv4AXXC_4)\n *\n * @param props - form configuration and validation parameters.\n *\n * @returns methods - individual functions to manage the form state. {@link UseFormReturn}\n *\n * @example\n * ```tsx\n * function App() {\n *   const { register, handleSubmit, watch, formState: { errors } } = useForm();\n *   const onSubmit = data => console.log(data);\n *\n *   console.log(watch(\"example\"));\n *\n *   return (\n *     <form onSubmit={handleSubmit(onSubmit)}>\n *       <input defaultValue=\"test\" {...register(\"example\")} />\n *       <input {...register(\"exampleRequired\", { required: true })} />\n *       {errors.exampleRequired && <span>This field is required</span>}\n *       <button>Submit</button>\n *     </form>\n *   );\n * }\n * ```\n */\nfunction useForm(props = {}) {\n  const _formControl = React.useRef();\n  const _values = React.useRef();\n  const [formState, updateFormState] = React.useState({\n    isDirty: false,\n    isValidating: false,\n    isLoading: isFunction(props.defaultValues),\n    isSubmitted: false,\n    isSubmitting: false,\n    isSubmitSuccessful: false,\n    isValid: false,\n    submitCount: 0,\n    dirtyFields: {},\n    touchedFields: {},\n    errors: props.errors || {},\n    disabled: props.disabled || false,\n    defaultValues: isFunction(props.defaultValues) ? undefined : props.defaultValues\n  });\n  if (!_formControl.current) {\n    _formControl.current = {\n      ...createFormControl(props, () => updateFormState(formState => ({\n        ...formState\n      }))),\n      formState\n    };\n  }\n  const control = _formControl.current.control;\n  control._options = props;\n  useSubscribe({\n    subject: control._subjects.state,\n    next: value => {\n      if (shouldRenderFormState(value, control._proxyFormState, control._updateFormState, true)) {\n        updateFormState({\n          ...control._formState\n        });\n      }\n    }\n  });\n  React.useEffect(() => control._disableForm(props.disabled), [control, props.disabled]);\n  React.useEffect(() => {\n    if (control._proxyFormState.isDirty) {\n      const isDirty = control._getDirty();\n      if (isDirty !== formState.isDirty) {\n        control._subjects.state.next({\n          isDirty\n        });\n      }\n    }\n  }, [control, formState.isDirty]);\n  React.useEffect(() => {\n    if (props.values && !deepEqual(props.values, _values.current)) {\n      control._reset(props.values, control._options.resetOptions);\n      _values.current = props.values;\n      updateFormState(state => ({\n        ...state\n      }));\n    } else {\n      control._resetDefaultValues();\n    }\n  }, [props.values, control]);\n  React.useEffect(() => {\n    if (props.errors) {\n      control._setErrors(props.errors);\n    }\n  }, [props.errors, control]);\n  React.useEffect(() => {\n    if (!control._state.mount) {\n      control._updateValid();\n      control._state.mount = true;\n    }\n    if (control._state.watch) {\n      control._state.watch = false;\n      control._subjects.state.next({\n        ...control._formState\n      });\n    }\n    control._removeUnmounted();\n  });\n  _formControl.current.formState = getProxyFormState(formState, control);\n  return _formControl.current;\n}\nexport { Controller, Form, FormProvider, appendErrors, get, set, useController, useFieldArray, useForm, useFormContext, useFormState, useWatch };\n//# sourceMappingURL=index.esm.mjs.map"],"names":["isCheckBoxInput","element","type","isDateObject","value","Date","isNullOrUndefined","isObjectType","isObject","Array","isArray","getEventValue","event","target","checked","isNameInFieldArray","names","name","has","substring","search","getNodeParentName","isPlainObject","tempObject","prototypeCopy","constructor","prototype","hasOwnProperty","isWeb","window","HTMLElement","document","cloneObject","data","copy","Set","Blob","FileList","key","compact","filter","Boolean","isUndefined","val","undefined","get","object","path","defaultValue","result","split","reduce","isBoolean","EVENTS","BLUR","FOCUS_OUT","CHANGE","VALIDATION_MODE","onBlur","onChange","onSubmit","onTouched","all","INPUT_VALIDATION_RULES","HookFormContext","useFormContext","FormProvider","props","children","Provider","getProxyFormState","formState","control","localProxyFormState","isRoot","defaultValues","_defaultValues","Object","defineProperty","_key","_proxyFormState","isEmptyObject","keys","length","shouldRenderFormState","formStateData","updateFormState","find","convertToArrayPayload","shouldSubscribeByName","signalName","exact","some","currentName","startsWith","useSubscribe","_props","current","subscription","disabled","subject","subscribe","next","unsubscribe","useFormState","methods","_formState","_mounted","_localProxyFormState","isDirty","isLoading","dirtyFields","touchedFields","isValidating","isValid","errors","_name","_updateFormState","_subjects","state","_updateValid","isString","generateWatchOutput","_names","formValues","isGlobal","watch","add","map","fieldName","watchAll","useWatch","values","updateValue","_formValues","_getWatch","_removeUnmounted","isKey","test","stringToPath","input","replace","set","index","tempPath","lastIndex","newValue","objValue","isNaN","Controller","render","shouldUnregister","isArrayField","array","_registerProps","register","rules","_shouldUnregisterField","_options","updateMounted","field","_fields","_f","mount","_state","action","unregister","_updateDisabledField","fields","ref","elm","focus","select","setCustomValidity","message","reportValidity","fieldState","defineProperties","invalid","enumerable","isTouched","error","useController","appendErrors","validateAllFieldCriteria","types","getValidationModes","mode","isOnSubmit","isOnBlur","isOnChange","isOnAll","isOnTouch","isWatched","isBlurEvent","watchName","slice","iterateFieldsByAction","fieldsNames","abortEarly","currentField","refs","updateFieldArrayRootError","fieldArrayErrors","isFileInput","isFunction","isHTMLElement","owner","ownerDocument","defaultView","isMessage","isRadioInput","isRegex","RegExp","defaultResult","validResult","getCheckboxValue","options","option","attributes","defaultReturn","getRadioValue","previous","getValidateError","every","getValueAndMessage","validationData","validateField","async","shouldUseNativeValidation","isFieldArray","required","maxLength","minLength","min","max","pattern","validate","valueAsNumber","inputValue","inputRef","isRadio","isCheckBox","isRadioOrCheckbox","isEmpty","appendErrorsCurry","bind","getMinMaxMessage","exceedMax","maxLengthMessage","minLengthMessage","maxType","minType","exceedMin","maxOutput","minOutput","valueDate","valueAsDate","convertTimeToDate","time","toDateString","isTime","isWeek","valueNumber","maxLengthOutput","minLengthOutput","patternValue","match","validateError","validationResult","unset","paths","childObject","updatePath","baseGet","obj","isEmptyArray","createSubject","_observers","observers","observer","push","o","isPrimitive","deepEqual","object1","object2","getTime","keys1","keys2","val1","includes","val2","isMultipleSelect","live","isConnected","objectHasFunction","markFieldsDirty","isParentNodeArray","getDirtyFieldsFromDefaultValues","dirtyFieldsFromValues","getDirtyFields","getFieldValueAs","setValueAs","NaN","getFieldValue","files","selectedOptions","getResolverOptions","criteriaMode","getRuleValue","rule","source","hasValidation","schemaErrorLookup","join","foundError","pop","skipValidation","isSubmitted","reValidateMode","unsetEmptyArray","defaultOptions","shouldFocusError","createFormControl","flushRootRender","delayErrorCallback","submitCount","isSubmitting","isSubmitSuccessful","unMount","timer","validationModeBeforeSubmit","validationModeAfterSubmit","shouldDisplayAllAssociatedErrors","shouldUpdateValid","resolver","_executeSchema","executeBuiltInValidation","_updateIsValidating","updateValidAndValue","shouldSkipSetValueAs","defaultChecked","setFieldValue","updateTouchAndDirty","fieldValue","shouldDirty","shouldRender","shouldUpdateField","isPreviousDirty","output","disabledField","_getDirty","isCurrentFieldPristine","isPreviousFieldTouched","shouldRenderByError","previousFieldError","callback","delayError","updateErrors","wait","clearTimeout","setTimeout","updatedFormState","context","shouldOnlyCheckValid","valid","isFieldArrayRoot","fieldError","getValues","fieldReference","forEach","optionRef","selected","checkboxRef","radioRef","shouldTouch","shouldValidate","trigger","setValues","fieldKey","setValue","cloneValue","isFieldValueUpdated","_updateIsFieldValueUpdated","Number","shouldSkipValidation","deps","watched","previousErrorLookupResult","errorLookupResult","_focusInput","fieldNames","executeSchemaAndUpdateState","Promise","shouldFocus","getFieldState","setError","delete","keepValue","keepError","keepDirty","keepTouched","keepDefaultValue","keepIsValid","disabledIsDefined","progressive","fieldRef","querySelectorAll","radioOrCheckbox","_focusError","handleSubmit","onValid","onInvalid","e","preventDefault","persist","fieldValues","_reset","keepStateOptions","updatedValues","cloneUpdatedValues","keepDefaultValues","keepValues","keepDirtyValues","form","closest","reset","keepSubmitCount","keepIsSubmitted","keepErrors","keepIsSubmitSuccessful","_updateFieldArray","method","args","shouldSetValues","shouldUpdateFieldsAndState","argA","argB","_getFieldArray","_resetDefaultValues","then","resetOptions","_disableForm","requiredDisabledState","_setErrors","payload","resetField","clearErrors","inputName","setFocus","shouldSelect","useForm","_formControl","_values"],"sourceRoot":""}