{"version":3,"sources":["../../src/utils/isHTMLElement.ts","../../src/constants.ts","../../src/logic/attachEventListeners.ts","../../src/utils/isNullOrUndefined.ts","../../src/utils/isObject.ts","../../src/utils/isKey.ts","../../src/utils/compact.ts","../../src/utils/stringToPath.ts","../../src/utils/set.ts","../../src/logic/transformToNestObject.ts","../../src/utils/isUndefined.ts","../../src/utils/get.ts","../../src/logic/focusOnErrorField.ts","../../src/logic/removeAllEventListeners.ts","../../src/logic/getRadioValue.ts","../../src/utils/isRadioInput.ts","../../src/utils/isFileInput.ts","../../src/utils/isCheckBoxInput.ts","../../src/utils/isMultipleSelect.ts","../../src/logic/getCheckboxValue.ts","../../src/logic/getFieldValue.ts","../../src/logic/getMultipleSelectValue.ts","../../src/utils/isDetached.ts","../../src/utils/isEmptyObject.ts","../../src/utils/isBoolean.ts","../../src/utils/unset.ts","../../src/logic/findRemovedFieldAndRemoveListener.ts","../../src/utils/isPrimitive.ts","../../src/utils/deepMerge.ts","../../src/utils/deepEqual.ts","../../src/logic/setFieldArrayDirtyFields.ts","../../src/utils/isString.ts","../../src/logic/getFieldsValues.ts","../../src/logic/isErrorStateChanged.ts","../../src/utils/isRegex.ts","../../src/logic/getValueAndMessage.ts","../../src/utils/isFunction.ts","../../src/utils/isMessage.ts","../../src/logic/getValidateError.ts","../../src/logic/appendErrors.ts","../../src/logic/validateField.ts","../../src/utils/getPath.ts","../../src/logic/assignWatchFields.ts","../../src/logic/skipValidation.ts","../../src/logic/getNodeParentName.ts","../../src/logic/isNameInFieldArray.ts","../../src/utils/isSelectInput.ts","../../src/utils/onDomRemove.ts","../../src/utils/isWeb.ts","../../src/utils/cloneObject.ts","../../src/utils/validationModeChecker.ts","../../src/utils/isRadioOrCheckbox.ts","../../src/useForm.ts","../../src/useFormContext.tsx","../../src/useController.ts","../../src/logic/getInputValue.ts","../../src/controller.tsx"],"names":["value","HTMLElement","EVENTS","VALIDATION_MODE","SELECT","UNDEFINED","INPUT_VALIDATION_RULES","attachEventListeners","shouldAttachChangeEvent","handleChange","ref","isHTMLElement","addEventListener","isObjectType","isNullOrUndefined","Array","isArray","Date","test","filter","Boolean","input","compact","replace","split","set","object","path","index","tempPath","isKey","stringToPath","length","lastIndex","key","newValue","objValue","isObject","isNaN","data","val","undefined","obj","defaultValue","result","reduce","isUndefined","fields","fieldErrors","field","focus","options","validateWithStateUpdate","removeEventListener","defaultReturn","isValid","previous","option","checked","element","type","defaultResult","validResult","values","map","attributes","getFieldValue","fieldsRef","name","shallowFieldsStateRef","excludeDisabled","shouldKeepRawValue","current","disabled","valueAsNumber","valueAsDate","setValueAs","isFileInput","files","isRadioInput","getRadioValue","isMultipleSelect","selected","isCheckBox","getCheckboxValue","NaN","isDetached","nodeType","Node","DOCUMENT_NODE","parentNode","Object","keys","unset","previousObjRef","updatePath","childObject","slice","baseGet","k","objectRef","currentPaths","currentPathsLength","item","isEmptyObject","isBoolean","isSameRef","fieldValue","findRemovedFieldAndRemoveListener","shouldUnregister","forceDelete","fieldRef","isCheckBoxInput","forEach","removeAllEventListeners","deepMerge","target","source","isPrimitive","targetValue","sourceValue","deepEqual","object1","object2","isErrorObject","React.isValidElement","keys1","keys2","val1","val2","setDirtyFields","defaultValues","dirtyFields","parentName","shallowFieldsState","search","output","isString","startsWith","find","transformToNestObject","errors","error","validFields","fieldsWithValidation","previousError","RegExp","validationData","isRegex","message","getValidateError","isMessage","validateAllFieldCriteria","types","a","required","maxLength","minLength","min","max","pattern","validate","isRadio","isRadioOrCheckbox","isEmpty","appendErrorsCurry","appendErrors","bind","getMinMaxMessage","exceedMax","maxLengthMessage","minLengthMessage","maxType","minType","getValueAndMessage","maxOutput","minOutput","valueDate","exceedMin","valueNumber","parseFloat","maxLengthOutput","minLengthOutput","patternValue","getFieldsValue","validateRef","isFunction","validateError","validationResult","entries","validateFunction","validateResult","getPath","rootPath","paths","property","rootName","push","fieldValues","fieldName","watchFields","inputValue","isSingleField","add","isOnBlur","isOnChange","isOnTouch","isTouched","isReValidateOnBlur","isReValidateOnChange","isBlurEvent","isSubmitted","isOnAll","substring","indexOf","isMatchFieldArrayName","searchName","names","some","onDomRemove","removeFieldEventListenerAndRef","observer","MutationObserver","observe","window","document","childList","subtree","cloneObject","copy","isWeb","File","includes","constructor","getTime","Set","Map","get","mode","isOnSubmit","isWindowUndefined","isProxyEnabled","Proxy","useForm","reValidateMode","resolver","context","shouldFocusError","criteriaMode","React.useRef","fieldArrayDefaultValuesRef","fieldArrayValuesRef","watchFieldsRef","useWatchFieldsRef","useWatchRenderFunctionsRef","fieldsWithValidationRef","validFieldsRef","defaultValuesRef","isUnMount","isWatchAllRef","handleChangeRef","resetFieldArrayFunctionRef","contextRef","resolverRef","fieldArrayNamesRef","modeRef","modeChecker","isValidateAllFieldCriteria","React.useState","isDirty","isValidating","submitCount","touched","isSubmitting","isSubmitSuccessful","formState","setFormState","readFormStateRef","formStateRef","observerRef","updateFormState","React.useCallback","state","updateIsValidating","shouldRenderBaseOnError","shouldRender","shouldReRender","isErrorStateChanged","setFieldValue","rawValue","radioRef","selectRef","checkboxRef","isFormDirty","formValues","getValues","updateAndGetDirtyState","isFieldDirty","isDirtyFieldExist","previousIsDirty","isChanged","executeValidation","skipReRender","validateField","executeSchemaOrResolverValidation","previousFormIsValid","isInputsValid","every","trigger","Promise","all","setInternalValues","shouldDirty","shouldValidate","setInternalValue","config","has","getNodeParentName","setFieldArrayDirtyFields","isFieldWatched","match","renderWatchedInputs","found","size","setValue","setFieldArrayDefaultValues","payload","getFieldsValues","shouldSkipValidation","skipValidation","parentNodeName","currentError","validateResolver","newDefaultValues","removeFieldEventListener","updateWatchedValue","clearErrors","inputName","setError","shouldFocus","watchInternal","fieldNames","watchId","assignWatchFields","combinedDefaultValues","watch","unregister","registerFieldRef","fieldRefAndValidationOptions","isRadioOrCheckboxFunction","isFieldArray","isNameInFieldArray","compareRef","currentRef","isEmptyDefaultValue","isEmptyUnmountFields","then","isSelectInput","register","refOrRegisterOptions","handleSubmit","onValid","onInvalid","e","preventDefault","persist","fieldError","focusOnErrorField","resetRefs","reset","omitResetState","inputRef","closest","resetFieldArray","React.useEffect","disconnect","commonProps","prop","control","React.useMemo","FormContext","React.createContext","displayName","useFormContext","React.useContext","useController","rules","onFocus","methods","isNotFieldArray","getInitialValue","setInputStateValue","valueRef","onFocusRef","commonTask","event","getInputValue","registerField","shouldUpdateValue","defineProperties","onBlur","onChange","meta","invalid","Controller","props","as","render","rest","componentProps","React.cloneElement","React.createElement"],"mappings":"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","file":"static/js/0.eccd9d34.chunk.js","sourcesContent":["export default (value: any): value is HTMLElement =>\n  value instanceof HTMLElement;\n","import { ValidationMode } from './types';\n\nexport const EVENTS = {\n  BLUR: 'blur',\n  CHANGE: 'change',\n  INPUT: 'input',\n};\n\nexport const VALIDATION_MODE: ValidationMode = {\n  onBlur: 'onBlur',\n  onChange: 'onChange',\n  onSubmit: 'onSubmit',\n  onTouched: 'onTouched',\n  all: 'all',\n};\n\nexport const SELECT = 'select';\n\nexport const UNDEFINED = 'undefined';\n\nexport const 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};\n","import isHTMLElement from '../utils/isHTMLElement';\nimport { EVENTS } from '../constants';\nimport { Field } from '../types';\n\nexport default function attachEventListeners(\n  { ref }: Field,\n  shouldAttachChangeEvent?: boolean,\n  handleChange?: EventListenerOrEventListenerObject,\n): void {\n  if (isHTMLElement(ref) && handleChange) {\n    ref.addEventListener(\n      shouldAttachChangeEvent ? EVENTS.CHANGE : EVENTS.INPUT,\n      handleChange,\n    );\n    ref.addEventListener(EVENTS.BLUR, handleChange);\n  }\n}\n","export default (value: unknown): value is null | undefined => value == null;\n","import isNullOrUndefined from './isNullOrUndefined';\n\nexport const isObjectType = (value: unknown) => typeof value === 'object';\n\nexport default <T extends object>(value: unknown): value is T =>\n  !isNullOrUndefined(value) &&\n  !Array.isArray(value) &&\n  isObjectType(value) &&\n  !(value instanceof Date);\n","export default (value: string) => /^\\w*$/.test(value);\n","export default (value: any[]) => value.filter(Boolean);\n","import compact from './compact';\n\nexport default (input: string): string[] =>\n  compact(\n    input\n      .replace(/[\"|']/g, '')\n      .replace(/\\[/g, '.')\n      .replace(/\\]/g, '')\n      .split('.'),\n  );\n","import isObject from './isObject';\nimport isKey from './isKey';\nimport stringToPath from './stringToPath';\nimport { FieldValues } from '../types';\n\nexport default function set(\n  object: FieldValues,\n  path: string,\n  value?: unknown,\n) {\n  let index = -1;\n  const tempPath = isKey(path) ? [path] : stringToPath(path);\n  const length = tempPath.length;\n  const lastIndex = length - 1;\n\n  while (++index < length) {\n    const key = tempPath[index];\n    let newValue = value;\n\n    if (index !== lastIndex) {\n      const objValue = object[key];\n      newValue =\n        isObject(objValue) || Array.isArray(objValue)\n          ? objValue\n          : !isNaN(+tempPath[index + 1])\n          ? []\n          : {};\n    }\n    object[key] = newValue;\n    object = object[key];\n  }\n  return object;\n}\n","import set from '../utils/set';\nimport isKey from '../utils/isKey';\nimport { FieldValues } from '../types';\n\nexport default (data: FieldValues, value: Record<string, any> = {}): any => {\n  for (const key in data) {\n    !isKey(key) ? set(value, key, data[key]) : (value[key] = data[key]);\n  }\n  return value;\n};\n","export default (val: unknown): val is undefined => val === undefined;\n","import isUndefined from './isUndefined';\nimport isNullOrUndefined from './isNullOrUndefined';\nimport compact from './compact';\n\nexport default (obj: any = {}, path: string, defaultValue?: unknown) => {\n  const result = compact(path.split(/[,[\\].]+?/)).reduce(\n    (result, key) => (isNullOrUndefined(result) ? result : result[key]),\n    obj,\n  );\n\n  return isUndefined(result) || result === obj\n    ? isUndefined(obj[path])\n      ? defaultValue\n      : obj[path]\n    : result;\n};\n","import get from '../utils/get';\nimport isUndefined from '../utils/isUndefined';\nimport { FieldErrors, FieldRefs } from '../types';\n\nexport default <TFieldValues>(\n  fields: FieldRefs<TFieldValues>,\n  fieldErrors: FieldErrors<TFieldValues>,\n) => {\n  for (const key in fields) {\n    if (get(fieldErrors, key)) {\n      const field = fields[key];\n\n      if (field) {\n        if (field.ref.focus && isUndefined(field.ref.focus())) {\n          break;\n        } else if (field.options) {\n          field.options[0].ref.focus();\n\n          break;\n        }\n      }\n    }\n  }\n};\n","import isHTMLElement from '../utils/isHTMLElement';\nimport { EVENTS } from '../constants';\nimport { Ref } from '../types';\n\nexport default (\n  ref: Ref,\n  validateWithStateUpdate: EventListenerOrEventListenerObject,\n): void => {\n  if (isHTMLElement(ref) && ref.removeEventListener) {\n    ref.removeEventListener(EVENTS.INPUT, validateWithStateUpdate);\n    ref.removeEventListener(EVENTS.CHANGE, validateWithStateUpdate);\n    ref.removeEventListener(EVENTS.BLUR, validateWithStateUpdate);\n  }\n};\n","import { RadioOrCheckboxOption } from '../types';\n\ntype RadioFieldResult = {\n  isValid: boolean;\n  value: number | string | null;\n};\n\nconst defaultReturn: RadioFieldResult = {\n  isValid: false,\n  value: null,\n};\n\nexport default (options?: RadioOrCheckboxOption[]): RadioFieldResult =>\n  Array.isArray(options)\n    ? options.reduce(\n        (previous, option): RadioFieldResult =>\n          option && option.ref.checked\n            ? {\n                isValid: true,\n                value: option.ref.value,\n              }\n            : previous,\n        defaultReturn,\n      )\n    : defaultReturn;\n","import { FieldElement } from '../types';\n\nexport default (element: FieldElement): element is HTMLInputElement =>\n  element.type === 'radio';\n","import { FieldElement } from '../types';\n\nexport default (element: FieldElement): element is HTMLInputElement =>\n  element.type === 'file';\n","import { FieldElement } from '../types';\n\nexport default (element: FieldElement): element is HTMLInputElement =>\n  element.type === 'checkbox';\n","import { FieldElement } from '../types';\nimport { SELECT } from '../constants';\n\nexport default (element: FieldElement): element is HTMLSelectElement =>\n  element.type === `${SELECT}-multiple`;\n","import isUndefined from '../utils/isUndefined';\nimport { RadioOrCheckboxOption } from '../types';\n\ntype CheckboxFieldResult = {\n  isValid: boolean;\n  value: string | string[] | boolean;\n};\n\nconst defaultResult: CheckboxFieldResult = {\n  value: false,\n  isValid: false,\n};\n\nconst validResult = { value: true, isValid: true };\n\nexport default (options?: RadioOrCheckboxOption[]): CheckboxFieldResult => {\n  if (Array.isArray(options)) {\n    if (options.length > 1) {\n      const values = options\n        .filter((option) => option && option.ref.checked)\n        .map(({ ref: { value } }) => value);\n      return { value: values, isValid: !!values.length };\n    }\n\n    const { checked, value, attributes } = options[0].ref;\n\n    return checked\n      ? attributes && !isUndefined((attributes as any).value)\n        ? isUndefined(value) || value === ''\n          ? validResult\n          : { value: value, isValid: true }\n        : validResult\n      : defaultResult;\n  }\n\n  return defaultResult;\n};\n","import * as React from 'react';\nimport getRadioValue from './getRadioValue';\nimport getMultipleSelectValue from './getMultipleSelectValue';\nimport isRadioInput from '../utils/isRadioInput';\nimport get from '../utils/get';\nimport isFileInput from '../utils/isFileInput';\nimport isCheckBox from '../utils/isCheckBoxInput';\nimport isMultipleSelect from '../utils/isMultipleSelect';\nimport getCheckboxValue from './getCheckboxValue';\nimport { FieldRefs, FieldValues, InternalFieldName } from '../types';\n\nexport default function getFieldValue<TFieldValues extends FieldValues>(\n  fieldsRef: React.MutableRefObject<FieldRefs<TFieldValues>>,\n  name: InternalFieldName<TFieldValues>,\n  shallowFieldsStateRef?: React.MutableRefObject<Partial<FieldValues>>,\n  excludeDisabled?: boolean,\n  shouldKeepRawValue?: boolean,\n) {\n  const field = fieldsRef.current[name]!;\n\n  if (field) {\n    const {\n      ref: { value, disabled },\n      ref,\n      valueAsNumber,\n      valueAsDate,\n      setValueAs,\n    } = field;\n\n    if (disabled && excludeDisabled) {\n      return;\n    }\n\n    if (isFileInput(ref)) {\n      return ref.files;\n    }\n\n    if (isRadioInput(ref)) {\n      return getRadioValue(field.options).value;\n    }\n\n    if (isMultipleSelect(ref)) {\n      return getMultipleSelectValue(ref.options);\n    }\n\n    if (isCheckBox(ref)) {\n      return getCheckboxValue(field.options).value;\n    }\n\n    return shouldKeepRawValue\n      ? value\n      : valueAsNumber\n      ? value === ''\n        ? NaN\n        : +value\n      : valueAsDate\n      ? (ref as HTMLInputElement).valueAsDate\n      : setValueAs\n      ? setValueAs(value)\n      : value;\n  }\n\n  if (shallowFieldsStateRef) {\n    return get(shallowFieldsStateRef.current, name);\n  }\n}\n","export default (\n  options: HTMLOptionElement[] | HTMLOptionsCollection,\n): string[] =>\n  [...options]\n    .filter(({ selected }): boolean => selected)\n    .map(({ value }): string => value);\n","import { Ref } from '../types';\n\nexport default function isDetached(element: Ref): boolean {\n  if (!element) {\n    return true;\n  }\n\n  if (\n    !(element instanceof HTMLElement) ||\n    element.nodeType === Node.DOCUMENT_NODE\n  ) {\n    return false;\n  }\n\n  return isDetached(element.parentNode as Ref);\n}\n","import isObject from './isObject';\nimport { EmptyObject } from '../types';\n\nexport default (value: unknown): value is EmptyObject =>\n  isObject(value) && !Object.keys(value).length;\n","export default (value: unknown): value is boolean => typeof value === 'boolean';\n","import isKey from './isKey';\nimport stringToPath from './stringToPath';\nimport isEmptyObject from './isEmptyObject';\nimport isObject from './isObject';\nimport isUndefined from './isUndefined';\nimport isBoolean from './isBoolean';\n\nfunction baseGet(object: any, updatePath: (string | number)[]) {\n  const length = updatePath.slice(0, -1).length;\n  let index = 0;\n\n  while (index < length) {\n    object = isUndefined(object) ? index++ : object[updatePath[index++]];\n  }\n\n  return object;\n}\n\nexport default function unset(object: any, path: string) {\n  const updatePath = isKey(path) ? [path] : stringToPath(path);\n  const childObject =\n    updatePath.length == 1 ? object : baseGet(object, updatePath);\n  const key = updatePath[updatePath.length - 1];\n  let previousObjRef;\n\n  if (childObject) {\n    delete childObject[key];\n  }\n\n  for (let k = 0; k < updatePath.slice(0, -1).length; k++) {\n    let index = -1;\n    let objectRef;\n    const currentPaths = updatePath.slice(0, -(k + 1));\n    const currentPathsLength = currentPaths.length - 1;\n\n    if (k > 0) {\n      previousObjRef = object;\n    }\n\n    while (++index < currentPaths.length) {\n      const item = currentPaths[index];\n      objectRef = objectRef ? objectRef[item] : object[item];\n\n      if (\n        currentPathsLength === index &&\n        ((isObject(objectRef) && isEmptyObject(objectRef)) ||\n          (Array.isArray(objectRef) &&\n            !objectRef.filter(\n              (data) =>\n                (isObject(data) && !isEmptyObject(data)) || isBoolean(data),\n            ).length))\n      ) {\n        previousObjRef ? delete previousObjRef[item] : delete object[item];\n      }\n\n      previousObjRef = objectRef;\n    }\n  }\n\n  return object;\n}\n","import * as React from 'react';\nimport removeAllEventListeners from './removeAllEventListeners';\nimport getFieldValue from './getFieldValue';\nimport isRadioInput from '../utils/isRadioInput';\nimport set from '../utils/set';\nimport isCheckBoxInput from '../utils/isCheckBoxInput';\nimport isDetached from '../utils/isDetached';\nimport unset from '../utils/unset';\nimport compact from '../utils/compact';\nimport isUndefined from '../utils/isUndefined';\nimport { Field, FieldRefs, FieldValues, Ref } from '../types';\n\nconst isSameRef = (fieldValue: Field, ref: Ref) =>\n  fieldValue && fieldValue.ref === ref;\n\nexport default function findRemovedFieldAndRemoveListener<\n  TFieldValues extends FieldValues\n>(\n  fieldsRef: React.MutableRefObject<FieldRefs<TFieldValues>>,\n  handleChange: ({ type, target }: Event) => Promise<void | boolean>,\n  field: Field,\n  shallowFieldsStateRef: React.MutableRefObject<FieldValues>,\n  shouldUnregister?: boolean,\n  forceDelete?: boolean,\n): void {\n  const {\n    ref,\n    ref: { name },\n  } = field;\n  const fieldRef = fieldsRef.current[name] as Field;\n\n  if (!shouldUnregister) {\n    const value = getFieldValue(fieldsRef, name, shallowFieldsStateRef);\n\n    !isUndefined(value) && set(shallowFieldsStateRef.current, name, value);\n  }\n\n  if (!ref.type || !fieldRef) {\n    delete fieldsRef.current[name];\n    return;\n  }\n\n  if (isRadioInput(ref) || isCheckBoxInput(ref)) {\n    if (Array.isArray(fieldRef.options) && fieldRef.options.length) {\n      compact(fieldRef.options).forEach((option = {}, index): void => {\n        if (\n          (isDetached(option.ref) && isSameRef(option, option.ref)) ||\n          forceDelete\n        ) {\n          removeAllEventListeners(option.ref, handleChange);\n          unset(fieldRef.options, `[${index}]`);\n        }\n      });\n\n      if (fieldRef.options && !compact(fieldRef.options).length) {\n        delete fieldsRef.current[name];\n      }\n    } else {\n      delete fieldsRef.current[name];\n    }\n  } else if ((isDetached(ref) && isSameRef(fieldRef, ref)) || forceDelete) {\n    removeAllEventListeners(ref, handleChange);\n\n    delete fieldsRef.current[name];\n  }\n}\n","import isNullOrUndefined from './isNullOrUndefined';\nimport { isObjectType } from './isObject';\nimport { Primitive } from '../types';\n\nexport default (value: unknown): value is Primitive =>\n  isNullOrUndefined(value) || !isObjectType(value);\n","import isObject from './isObject';\nimport isPrimitive from './isPrimitive';\n\nexport function deepMerge<\n  T extends Record<keyof T, any>,\n  U extends Record<keyof U, any>\n>(target: T, source: U): T & U {\n  if (isPrimitive(target) || isPrimitive(source)) {\n    return source;\n  }\n\n  for (const key in source) {\n    const targetValue = target[key];\n    const sourceValue = source[key];\n\n    try {\n      target[key] =\n        (isObject(targetValue) && isObject(sourceValue)) ||\n        (Array.isArray(targetValue) && Array.isArray(sourceValue))\n          ? deepMerge(targetValue, sourceValue)\n          : sourceValue;\n    } catch {}\n  }\n\n  return target;\n}\n","import * as React from 'react';\nimport isObject from '../utils/isObject';\nimport isPrimitive from './isPrimitive';\n\nexport default function deepEqual(\n  object1: any,\n  object2: any,\n  isErrorObject?: boolean,\n) {\n  if (\n    isPrimitive(object1) ||\n    isPrimitive(object2) ||\n    object1 instanceof Date ||\n    object2 instanceof Date\n  ) {\n    return object1 === object2;\n  }\n\n  if (!React.isValidElement(object1)) {\n    const keys1 = Object.keys(object1);\n    const keys2 = Object.keys(object2);\n\n    if (keys1.length !== keys2.length) {\n      return false;\n    }\n\n    for (const key of keys1) {\n      const val1 = object1[key];\n\n      if (!(isErrorObject && key === 'ref')) {\n        const val2 = object2[key];\n\n        if (\n          (isObject(val1) || Array.isArray(val1)) &&\n          (isObject(val2) || Array.isArray(val2))\n            ? !deepEqual(val1, val2, isErrorObject)\n            : val1 !== val2\n        ) {\n          return false;\n        }\n      }\n    }\n  }\n\n  return true;\n}\n","import { get } from '../utils';\nimport set from '../utils/set';\nimport { deepMerge } from '../utils/deepMerge';\nimport deepEqual from '../utils/deepEqual';\n\nfunction setDirtyFields<\n  T extends Record<string, unknown>[],\n  U extends Record<string, unknown>[],\n  K extends Record<string, boolean | []>\n>(\n  values: T,\n  defaultValues: U,\n  dirtyFields: Record<string, boolean | []>[],\n  parentNode?: K,\n  parentName?: keyof K,\n) {\n  let index = -1;\n\n  while (++index < values.length) {\n    for (const key in values[index]) {\n      if (Array.isArray(values[index][key])) {\n        !dirtyFields[index] && (dirtyFields[index] = {});\n        dirtyFields[index][key] = [];\n        setDirtyFields(\n          values[index][key] as T,\n          get(defaultValues[index] || {}, key, []),\n          dirtyFields[index][key] as [],\n          dirtyFields[index],\n          key,\n        );\n      } else {\n        deepEqual(get(defaultValues[index] || {}, key), values[index][key])\n          ? set(dirtyFields[index] || {}, key)\n          : (dirtyFields[index] = {\n              ...dirtyFields[index],\n              [key]: true,\n            });\n      }\n    }\n\n    parentNode &&\n      !dirtyFields.length &&\n      delete parentNode[parentName as keyof K];\n  }\n\n  return dirtyFields;\n}\n\nexport default <T extends U, U extends Record<string, unknown>[]>(\n  values: T,\n  defaultValues: U,\n  dirtyFields: Record<string, boolean | []>[],\n) =>\n  deepMerge(\n    setDirtyFields(values, defaultValues, dirtyFields.slice(0, values.length)),\n    setDirtyFields(defaultValues, values, dirtyFields.slice(0, values.length)),\n  );\n","export default (value: unknown): value is string => typeof value === 'string';\n","import * as React from 'react';\nimport getFieldValue from './getFieldValue';\nimport isString from '../utils/isString';\nimport { deepMerge } from '../utils/deepMerge';\nimport isUndefined from '../utils/isUndefined';\nimport { InternalFieldName, FieldValues, FieldRefs } from '../types';\nimport transformToNestObject from './transformToNestObject';\n\nexport default <TFieldValues extends FieldValues>(\n  fieldsRef: React.MutableRefObject<FieldRefs<TFieldValues>>,\n  shallowFieldsState: Record<string, any>,\n  shouldUnregister: boolean,\n  excludeDisabled?: boolean,\n  search?:\n    | InternalFieldName<TFieldValues>\n    | InternalFieldName<TFieldValues>[]\n    | { nest: boolean },\n) => {\n  const output = {} as TFieldValues;\n\n  for (const name in fieldsRef.current) {\n    if (\n      isUndefined(search) ||\n      (isString(search)\n        ? name.startsWith(search)\n        : Array.isArray(search) && search.find((data) => name.startsWith(data)))\n    ) {\n      output[name as InternalFieldName<TFieldValues>] = getFieldValue(\n        fieldsRef,\n        name,\n        undefined,\n        excludeDisabled,\n      );\n    }\n  }\n\n  return shouldUnregister\n    ? transformToNestObject(output)\n    : deepMerge(shallowFieldsState, transformToNestObject(output));\n};\n","import get from '../utils/get';\nimport isUndefined from '../utils/isUndefined';\nimport deepEqual from '../utils/deepEqual';\nimport {\n  FieldValues,\n  InternalFieldName,\n  FieldErrors,\n  FieldNamesMarkedBoolean,\n  FieldError,\n} from '../types';\n\nexport default <TFieldValues extends FieldValues>({\n  errors,\n  name,\n  error,\n  validFields,\n  fieldsWithValidation,\n}: {\n  errors: FieldErrors<TFieldValues>;\n  error: FieldError | undefined;\n  name: InternalFieldName<TFieldValues>;\n  validFields: FieldNamesMarkedBoolean<TFieldValues>;\n  fieldsWithValidation: FieldNamesMarkedBoolean<TFieldValues>;\n}): boolean => {\n  const isValid = isUndefined(error);\n  const previousError = get(errors, name);\n\n  return (\n    (isValid && !!previousError) ||\n    (!isValid && !deepEqual(previousError, error, true)) ||\n    (isValid && get(fieldsWithValidation, name) && !get(validFields, name))\n  );\n};\n","export default (value: unknown): value is RegExp => value instanceof RegExp;\n","import isObject from '../utils/isObject';\nimport isRegex from '../utils/isRegex';\nimport { ValidationRule } from '../types';\n\nexport default (validationData?: ValidationRule) =>\n  isObject(validationData) && !isRegex(validationData)\n    ? validationData\n    : {\n        value: validationData,\n        message: '',\n      };\n","export default (value: unknown): value is Function =>\n  typeof value === 'function';\n","import * as React from 'react';\nimport isString from '../utils/isString';\nimport { Message } from '../types';\n\nexport default (value: unknown): value is Message =>\n  isString(value) || React.isValidElement(value as JSX.Element);\n","import isBoolean from '../utils/isBoolean';\nimport isMessage from '../utils/isMessage';\nimport { FieldError, ValidateResult, Ref } from '../types';\n\nexport default function getValidateError(\n  result: ValidateResult,\n  ref: Ref,\n  type = 'validate',\n): FieldError | void {\n  if (isMessage(result) || (isBoolean(result) && !result)) {\n    return {\n      type,\n      message: isMessage(result) ? result : '',\n      ref,\n    };\n  }\n}\n","import {\n  InternalFieldName,\n  ValidateResult,\n  InternalFieldErrors,\n} from '../types';\n\nexport default <TFieldValues>(\n  name: InternalFieldName<TFieldValues>,\n  validateAllFieldCriteria: boolean,\n  errors: InternalFieldErrors<TFieldValues>,\n  type: string,\n  message: ValidateResult,\n) =>\n  validateAllFieldCriteria\n    ? {\n        ...errors[name],\n        types: {\n          ...(errors[name] && errors[name]!.types ? errors[name]!.types : {}),\n          [type]: message || true,\n        },\n      }\n    : {};\n","import * as React from 'react';\nimport getRadioValue from './getRadioValue';\nimport getCheckboxValue from './getCheckboxValue';\nimport isNullOrUndefined from '../utils/isNullOrUndefined';\nimport isRadioInput from '../utils/isRadioInput';\nimport getValueAndMessage from './getValueAndMessage';\nimport isCheckBoxInput from '../utils/isCheckBoxInput';\nimport isString from '../utils/isString';\nimport isEmptyObject from '../utils/isEmptyObject';\nimport isObject from '../utils/isObject';\nimport isFunction from '../utils/isFunction';\nimport getFieldsValue from './getFieldValue';\nimport isRegex from '../utils/isRegex';\nimport isBoolean from '../utils/isBoolean';\nimport isMessage from '../utils/isMessage';\nimport getValidateError from './getValidateError';\nimport appendErrors from './appendErrors';\nimport { INPUT_VALIDATION_RULES } from '../constants';\nimport {\n  Field,\n  FieldValues,\n  FieldRefs,\n  Message,\n  FieldError,\n  InternalFieldName,\n  InternalFieldErrors,\n} from '../types';\n\nexport default async <TFieldValues extends FieldValues>(\n  fieldsRef: React.MutableRefObject<FieldRefs<TFieldValues>>,\n  validateAllFieldCriteria: boolean,\n  {\n    ref,\n    ref: { value },\n    options,\n    required,\n    maxLength,\n    minLength,\n    min,\n    max,\n    pattern,\n    validate,\n  }: Field,\n  shallowFieldsStateRef: React.MutableRefObject<Record<string, any>>,\n): Promise<InternalFieldErrors<TFieldValues>> => {\n  const name: InternalFieldName<TFieldValues> = ref.name;\n  const error: InternalFieldErrors<TFieldValues> = {};\n  const isRadio = isRadioInput(ref);\n  const isCheckBox = isCheckBoxInput(ref);\n  const isRadioOrCheckbox = isRadio || isCheckBox;\n  const isEmpty = value === '';\n  const appendErrorsCurry = appendErrors.bind(\n    null,\n    name,\n    validateAllFieldCriteria,\n    error,\n  );\n  const getMinMaxMessage = (\n    exceedMax: boolean,\n    maxLengthMessage: Message,\n    minLengthMessage: Message,\n    maxType = INPUT_VALIDATION_RULES.maxLength,\n    minType = INPUT_VALIDATION_RULES.minLength,\n  ) => {\n    const message = exceedMax ? maxLengthMessage : minLengthMessage;\n    error[name] = {\n      type: exceedMax ? maxType : minType,\n      message,\n      ref,\n      ...(exceedMax\n        ? appendErrorsCurry(maxType, message)\n        : appendErrorsCurry(minType, message)),\n    };\n  };\n\n  if (\n    required &&\n    ((!isRadio && !isCheckBox && (isEmpty || isNullOrUndefined(value))) ||\n      (isBoolean(value) && !value) ||\n      (isCheckBox && !getCheckboxValue(options).isValid) ||\n      (isRadio && !getRadioValue(options).isValid))\n  ) {\n    const { value, message } = isMessage(required)\n      ? { value: !!required, message: required }\n      : getValueAndMessage(required);\n\n    if (value) {\n      error[name] = {\n        type: INPUT_VALIDATION_RULES.required,\n        message,\n        ref: isRadioOrCheckbox\n          ? (((fieldsRef.current[name] as Field).options || [])[0] || {}).ref\n          : ref,\n        ...appendErrorsCurry(INPUT_VALIDATION_RULES.required, message),\n      };\n      if (!validateAllFieldCriteria) {\n        return error;\n      }\n    }\n  }\n\n  if ((!isNullOrUndefined(min) || !isNullOrUndefined(max)) && value !== '') {\n    let exceedMax;\n    let exceedMin;\n    const maxOutput = getValueAndMessage(max);\n    const minOutput = getValueAndMessage(min);\n\n    if (!isNaN(value)) {\n      const valueNumber =\n        (ref as HTMLInputElement).valueAsNumber || parseFloat(value);\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 =\n        (ref as HTMLInputElement).valueAsDate || new Date(value);\n      if (isString(maxOutput.value)) {\n        exceedMax = valueDate > new Date(maxOutput.value);\n      }\n      if (isString(minOutput.value)) {\n        exceedMin = valueDate < new Date(minOutput.value);\n      }\n    }\n\n    if (exceedMax || exceedMin) {\n      getMinMaxMessage(\n        !!exceedMax,\n        maxOutput.message,\n        minOutput.message,\n        INPUT_VALIDATION_RULES.max,\n        INPUT_VALIDATION_RULES.min,\n      );\n      if (!validateAllFieldCriteria) {\n        return error;\n      }\n    }\n  }\n\n  if (isString(value) && !isEmpty && (maxLength || minLength)) {\n    const maxLengthOutput = getValueAndMessage(maxLength);\n    const minLengthOutput = getValueAndMessage(minLength);\n    const exceedMax =\n      !isNullOrUndefined(maxLengthOutput.value) &&\n      value.length > maxLengthOutput.value;\n    const exceedMin =\n      !isNullOrUndefined(minLengthOutput.value) &&\n      value.length < minLengthOutput.value;\n\n    if (exceedMax || exceedMin) {\n      getMinMaxMessage(\n        exceedMax,\n        maxLengthOutput.message,\n        minLengthOutput.message,\n      );\n      if (!validateAllFieldCriteria) {\n        return error;\n      }\n    }\n  }\n\n  if (isString(value) && pattern && !isEmpty) {\n    const { value: patternValue, message } = getValueAndMessage(pattern);\n\n    if (isRegex(patternValue) && !patternValue.test(value)) {\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        return error;\n      }\n    }\n  }\n\n  if (validate) {\n    const fieldValue = getFieldsValue(\n      fieldsRef,\n      name,\n      shallowFieldsStateRef,\n      false,\n      true,\n    );\n    const validateRef = isRadioOrCheckbox && options ? options[0].ref : ref;\n\n    if (isFunction(validate)) {\n      const result = await validate(fieldValue);\n      const validateError = getValidateError(result, validateRef);\n\n      if (validateError) {\n        error[name] = {\n          ...validateError,\n          ...appendErrorsCurry(\n            INPUT_VALIDATION_RULES.validate,\n            validateError.message,\n          ),\n        };\n        if (!validateAllFieldCriteria) {\n          return error;\n        }\n      }\n    } else if (isObject(validate)) {\n      let validationResult = {} as FieldError;\n      for (const [key, validateFunction] of Object.entries(validate)) {\n        if (!isEmptyObject(validationResult) && !validateAllFieldCriteria) {\n          break;\n        }\n\n        const validateResult = await validateFunction(fieldValue);\n        const validateError = getValidateError(\n          validateResult,\n          validateRef,\n          key,\n        );\n\n        if (validateError) {\n          validationResult = {\n            ...validateError,\n            ...appendErrorsCurry(key, validateError.message),\n          };\n\n          if (validateAllFieldCriteria) {\n            error[name] = validationResult;\n          }\n        }\n      }\n\n      if (!isEmptyObject(validationResult)) {\n        error[name] = {\n          ref: validateRef,\n          ...validationResult,\n        };\n        if (!validateAllFieldCriteria) {\n          return error;\n        }\n      }\n    }\n  }\n\n  return error;\n};\n","import isPrimitive from './isPrimitive';\nimport isObject from './isObject';\nimport { FieldName } from '../types';\n\nexport const getPath = <TFieldValues>(\n  rootPath: FieldName<TFieldValues>,\n  values: any,\n  paths: FieldName<TFieldValues>[] = [],\n): FieldName<TFieldValues>[] => {\n  for (const property in values) {\n    const rootName = (rootPath +\n      (isObject(values)\n        ? `.${property}`\n        : `[${property}]`)) as FieldName<TFieldValues>;\n\n    isPrimitive(values[property])\n      ? paths.push(rootName)\n      : getPath(rootName, values[property], paths);\n  }\n\n  return paths;\n};\n","import get from '../utils/get';\nimport { getPath } from '../utils/getPath';\nimport isEmptyObject from '../utils/isEmptyObject';\nimport isUndefined from '../utils/isUndefined';\nimport isObject from '../utils/isObject';\nimport {\n  DeepPartial,\n  FieldValue,\n  FieldValues,\n  InternalFieldName,\n  UnpackNestedValue,\n} from '../types';\n\nexport default <TFieldValues extends FieldValues>(\n  fieldValues: TFieldValues,\n  fieldName: InternalFieldName<TFieldValues>,\n  watchFields: Set<InternalFieldName<TFieldValues>>,\n  inputValue: UnpackNestedValue<DeepPartial<TFieldValues>>,\n  isSingleField?: boolean,\n):\n  | FieldValue<TFieldValues>\n  | UnpackNestedValue<DeepPartial<TFieldValues>>\n  | undefined => {\n  let value = undefined;\n\n  watchFields.add(fieldName);\n\n  if (!isEmptyObject(fieldValues)) {\n    value = get(fieldValues, fieldName);\n\n    if (isObject(value) || Array.isArray(value)) {\n      getPath(fieldName, value).forEach((name) => watchFields.add(name));\n    }\n  }\n\n  return isUndefined(value)\n    ? isSingleField\n      ? inputValue\n      : get(inputValue, fieldName)\n    : value;\n};\n","export default ({\n  isOnBlur,\n  isOnChange,\n  isOnTouch,\n  isTouched,\n  isReValidateOnBlur,\n  isReValidateOnChange,\n  isBlurEvent,\n  isSubmitted,\n  isOnAll,\n}: {\n  isOnAll?: boolean;\n  isOnBlur?: boolean;\n  isOnChange?: boolean;\n  isReValidateOnBlur?: boolean;\n  isReValidateOnChange?: boolean;\n  isBlurEvent?: boolean;\n  isSubmitted?: boolean;\n  isOnTouch?: boolean;\n  isTouched?: boolean;\n}) => {\n  if (isOnAll) {\n    return false;\n  } else if (!isSubmitted && isOnTouch) {\n    return !(isTouched || isBlurEvent);\n  } else if (isSubmitted ? isReValidateOnBlur : isOnBlur) {\n    return !isBlurEvent;\n  } else if (isSubmitted ? isReValidateOnChange : isOnChange) {\n    return isBlurEvent;\n  }\n  return true;\n};\n","export default (name: string) => name.substring(0, name.indexOf('['));\n","import { FieldValues, InternalFieldName } from '../types';\n\nexport const isMatchFieldArrayName = (name: string, searchName: string) =>\n  RegExp(\n    `^${searchName}([|.)\\\\d+`.replace(/\\[/g, '\\\\[').replace(/\\]/g, '\\\\]'),\n  ).test(name);\n\nexport default (\n  names: Set<InternalFieldName<FieldValues>>,\n  name: InternalFieldName<FieldValues>,\n) => [...names].some((current) => isMatchFieldArrayName(name, current));\n","import { FieldElement } from '../types';\nimport { SELECT } from '../constants';\n\nexport default (element: FieldElement): element is HTMLSelectElement =>\n  element.type === `${SELECT}-one`;\n","import * as React from 'react';\nimport { Field, FieldRefs } from '../types';\nimport isDetached from './isDetached';\n\nexport default function onDomRemove<TFieldValues>(\n  fieldsRef: React.MutableRefObject<FieldRefs<TFieldValues>>,\n  removeFieldEventListenerAndRef: (\n    field: Field | undefined,\n    forceDelete?: boolean,\n  ) => void,\n): MutationObserver {\n  const observer = new MutationObserver((): void => {\n    for (const field of Object.values(fieldsRef.current)) {\n      if (field && field.options) {\n        for (const option of field.options) {\n          if (option && option.ref && isDetached(option.ref)) {\n            removeFieldEventListenerAndRef(field);\n          }\n        }\n      } else if (field && isDetached(field.ref)) {\n        removeFieldEventListenerAndRef(field);\n      }\n    }\n  });\n\n  observer.observe(window.document, {\n    childList: true,\n    subtree: true,\n  });\n\n  return observer;\n}\n","import { UNDEFINED } from '../constants';\n\nexport default typeof window !== UNDEFINED && typeof document !== UNDEFINED;\n","import isPrimitive from './isPrimitive';\nimport isHTMLElement from './isHTMLElement';\nimport isWeb from './isWeb';\n\nexport default function cloneObject<T extends unknown>(data: T): T {\n  let copy: any;\n\n  if (\n    isPrimitive(data) ||\n    (isWeb && (data instanceof File || isHTMLElement(data)))\n  ) {\n    return data;\n  }\n\n  if (\n    !['Set', 'Map', 'Object', 'Date', 'Array'].includes(\n      (data as Object).constructor?.name,\n    )\n  ) {\n    return data;\n  }\n\n  if (data instanceof Date) {\n    copy = new Date(data.getTime());\n    return copy;\n  }\n\n  if (data instanceof Set) {\n    copy = new Set();\n    for (const item of data) {\n      copy.add(item);\n    }\n    return copy;\n  }\n\n  if (data instanceof Map) {\n    copy = new Map();\n    for (const key of data.keys()) {\n      copy.set(key, cloneObject(data.get(key)));\n    }\n    return copy;\n  }\n\n  copy = Array.isArray(data) ? [] : {};\n\n  for (const key in data) {\n    copy[key] = cloneObject(data[key]);\n  }\n\n  return copy;\n}\n","import { VALIDATION_MODE } from '../constants';\nimport { Mode } from '../types';\n\nexport default (\n  mode?: Mode,\n): {\n  isOnSubmit: boolean;\n  isOnBlur: boolean;\n  isOnChange: boolean;\n  isOnAll: boolean;\n  isOnTouch: boolean;\n} => ({\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});\n","import isRadioInput from './isRadioInput';\nimport isCheckBoxInput from './isCheckBoxInput';\nimport { FieldElement } from '../types';\n\nexport default (ref: FieldElement): ref is HTMLInputElement =>\n  isRadioInput(ref) || isCheckBoxInput(ref);\n","import * as React from 'react';\nimport attachEventListeners from './logic/attachEventListeners';\nimport transformToNestObject from './logic/transformToNestObject';\nimport focusOnErrorField from './logic/focusOnErrorField';\nimport findRemovedFieldAndRemoveListener from './logic/findRemovedFieldAndRemoveListener';\nimport setFieldArrayDirtyFields from './logic/setFieldArrayDirtyFields';\nimport getFieldsValues from './logic/getFieldsValues';\nimport getFieldValue from './logic/getFieldValue';\nimport isErrorStateChanged from './logic/isErrorStateChanged';\nimport validateField from './logic/validateField';\nimport assignWatchFields from './logic/assignWatchFields';\nimport skipValidation from './logic/skipValidation';\nimport getNodeParentName from './logic/getNodeParentName';\nimport deepEqual from './utils/deepEqual';\nimport isNameInFieldArray from './logic/isNameInFieldArray';\nimport isCheckBoxInput from './utils/isCheckBoxInput';\nimport isEmptyObject from './utils/isEmptyObject';\nimport isRadioInput from './utils/isRadioInput';\nimport isSelectInput from './utils/isSelectInput';\nimport isFileInput from './utils/isFileInput';\nimport onDomRemove from './utils/onDomRemove';\nimport isObject from './utils/isObject';\nimport { getPath } from './utils/getPath';\nimport isPrimitive from './utils/isPrimitive';\nimport isFunction from './utils/isFunction';\nimport isString from './utils/isString';\nimport isUndefined from './utils/isUndefined';\nimport get from './utils/get';\nimport set from './utils/set';\nimport unset from './utils/unset';\nimport isKey from './utils/isKey';\nimport cloneObject from './utils/cloneObject';\nimport modeChecker from './utils/validationModeChecker';\nimport isMultipleSelect from './utils/isMultipleSelect';\nimport compact from './utils/compact';\nimport isNullOrUndefined from './utils/isNullOrUndefined';\nimport isRadioOrCheckboxFunction from './utils/isRadioOrCheckbox';\nimport isWeb from './utils/isWeb';\nimport isHTMLElement from './utils/isHTMLElement';\nimport { EVENTS, UNDEFINED, VALIDATION_MODE } from './constants';\nimport {\n  UseFormMethods,\n  FieldValues,\n  UnpackNestedValue,\n  FieldName,\n  InternalFieldName,\n  FieldErrors,\n  Field,\n  FieldRefs,\n  UseFormOptions,\n  RegisterOptions,\n  SubmitHandler,\n  FieldElement,\n  FormStateProxy,\n  ReadFormState,\n  Ref,\n  HandleChange,\n  RadioOrCheckboxOption,\n  OmitResetState,\n  SetValueConfig,\n  ErrorOption,\n  FormState,\n  SubmitErrorHandler,\n  FieldNamesMarkedBoolean,\n  LiteralToPrimitive,\n  DeepPartial,\n  InternalNameSet,\n  DefaultValues,\n  FieldError,\n  SetFieldValue,\n  FieldArrayDefaultValues,\n  ResetFieldArrayFunctionRef,\n  UseWatchRenderFunctions,\n  RecordInternalNameSet,\n} from './types';\n\nconst isWindowUndefined = typeof window === UNDEFINED;\nconst isProxyEnabled = isWeb ? 'Proxy' in window : typeof Proxy !== UNDEFINED;\n\nexport function useForm<\n  TFieldValues extends FieldValues = FieldValues,\n  TContext extends object = object\n>({\n  mode = VALIDATION_MODE.onSubmit,\n  reValidateMode = VALIDATION_MODE.onChange,\n  resolver,\n  context,\n  defaultValues = {} as DefaultValues<TFieldValues>,\n  shouldFocusError = true,\n  shouldUnregister = true,\n  criteriaMode,\n}: UseFormOptions<TFieldValues, TContext> = {}): UseFormMethods<TFieldValues> {\n  const fieldsRef = React.useRef<FieldRefs<TFieldValues>>({});\n  const fieldArrayDefaultValuesRef = React.useRef<FieldArrayDefaultValues>({});\n  const fieldArrayValuesRef = React.useRef<FieldArrayDefaultValues>({});\n  const watchFieldsRef = React.useRef<InternalNameSet<TFieldValues>>(new Set());\n  const useWatchFieldsRef = React.useRef<RecordInternalNameSet<TFieldValues>>(\n    {},\n  );\n  const useWatchRenderFunctionsRef = React.useRef<UseWatchRenderFunctions>({});\n  const fieldsWithValidationRef = React.useRef<\n    FieldNamesMarkedBoolean<TFieldValues>\n  >({});\n  const validFieldsRef = React.useRef<FieldNamesMarkedBoolean<TFieldValues>>(\n    {},\n  );\n  const defaultValuesRef = React.useRef<DefaultValues<TFieldValues>>(\n    defaultValues,\n  );\n  const isUnMount = React.useRef(false);\n  const isWatchAllRef = React.useRef(false);\n  const handleChangeRef = React.useRef<HandleChange>();\n  const shallowFieldsStateRef = React.useRef({});\n  const resetFieldArrayFunctionRef = React.useRef<\n    ResetFieldArrayFunctionRef<TFieldValues>\n  >({});\n  const contextRef = React.useRef(context);\n  const resolverRef = React.useRef(resolver);\n  const fieldArrayNamesRef = React.useRef<InternalNameSet<TFieldValues>>(\n    new Set(),\n  );\n  const modeRef = React.useRef(modeChecker(mode));\n  const { isOnSubmit, isOnTouch } = modeRef.current;\n  const isValidateAllFieldCriteria = criteriaMode === VALIDATION_MODE.all;\n  const [formState, setFormState] = React.useState<FormState<TFieldValues>>({\n    isDirty: false,\n    isValidating: false,\n    dirtyFields: {},\n    isSubmitted: false,\n    submitCount: 0,\n    touched: {},\n    isSubmitting: false,\n    isSubmitSuccessful: false,\n    isValid: !isOnSubmit,\n    errors: {},\n  });\n  const readFormStateRef = React.useRef<ReadFormState>({\n    isDirty: !isProxyEnabled,\n    dirtyFields: !isProxyEnabled,\n    touched: !isProxyEnabled || isOnTouch,\n    isValidating: !isProxyEnabled,\n    isSubmitting: !isProxyEnabled,\n    isValid: !isProxyEnabled,\n  });\n  const formStateRef = React.useRef(formState);\n  const observerRef = React.useRef<MutationObserver | undefined>();\n  const {\n    isOnBlur: isReValidateOnBlur,\n    isOnChange: isReValidateOnChange,\n  } = React.useRef(modeChecker(reValidateMode)).current;\n\n  contextRef.current = context;\n  resolverRef.current = resolver;\n  formStateRef.current = formState;\n  shallowFieldsStateRef.current = shouldUnregister\n    ? {}\n    : isEmptyObject(shallowFieldsStateRef.current)\n    ? cloneObject(defaultValues)\n    : shallowFieldsStateRef.current;\n\n  const updateFormState = React.useCallback(\n    (state: Partial<FormState<TFieldValues>> = {}) => {\n      if (!isUnMount.current) {\n        formStateRef.current = {\n          ...formStateRef.current,\n          ...state,\n        };\n        setFormState(formStateRef.current);\n      }\n    },\n    [],\n  );\n\n  const updateIsValidating = () =>\n    readFormStateRef.current.isValidating &&\n    updateFormState({\n      isValidating: true,\n    });\n\n  const shouldRenderBaseOnError = React.useCallback(\n    (\n      name: InternalFieldName<TFieldValues>,\n      error: FieldError | undefined,\n      shouldRender: boolean | null = false,\n      state: {\n        dirtyFields?: FieldNamesMarkedBoolean<TFieldValues>;\n        isDirty?: boolean;\n        touched?: FieldNamesMarkedBoolean<TFieldValues>;\n      } = {},\n      isValid?: boolean,\n    ): boolean | void => {\n      let shouldReRender =\n        shouldRender ||\n        isErrorStateChanged<TFieldValues>({\n          errors: formStateRef.current.errors,\n          error,\n          name,\n          validFields: validFieldsRef.current,\n          fieldsWithValidation: fieldsWithValidationRef.current,\n        });\n      const previousError = get(formStateRef.current.errors, name);\n\n      if (error) {\n        unset(validFieldsRef.current, name);\n        shouldReRender =\n          shouldReRender ||\n          !previousError ||\n          !deepEqual(previousError, error, true);\n        set(formStateRef.current.errors, name, error);\n      } else {\n        if (get(fieldsWithValidationRef.current, name) || resolverRef.current) {\n          set(validFieldsRef.current, name, true);\n          shouldReRender = shouldReRender || previousError;\n        }\n\n        unset(formStateRef.current.errors, name);\n      }\n\n      if (\n        (shouldReRender && !isNullOrUndefined(shouldRender)) ||\n        !isEmptyObject(state) ||\n        readFormStateRef.current.isValidating\n      ) {\n        updateFormState({\n          ...state,\n          ...(resolverRef.current ? { isValid: !!isValid } : {}),\n          isValidating: false,\n        });\n      }\n    },\n    [],\n  );\n\n  const setFieldValue = React.useCallback(\n    (name: FieldName<TFieldValues>, rawValue: SetFieldValue<TFieldValues>) => {\n      const { ref, options } = fieldsRef.current[name] as Field;\n      const value =\n        isWeb && isHTMLElement(ref) && isNullOrUndefined(rawValue)\n          ? ''\n          : rawValue;\n\n      if (isRadioInput(ref)) {\n        (options || []).forEach(\n          ({ ref: radioRef }: { ref: HTMLInputElement }) =>\n            (radioRef.checked = radioRef.value === value),\n        );\n      } else if (isFileInput(ref) && !isString(value)) {\n        ref.files = value as FileList;\n      } else if (isMultipleSelect(ref)) {\n        [...ref.options].forEach(\n          (selectRef) =>\n            (selectRef.selected = (value as string[]).includes(\n              selectRef.value,\n            )),\n        );\n      } else if (isCheckBoxInput(ref) && options) {\n        options.length > 1\n          ? options.forEach(\n              ({ ref: checkboxRef }) =>\n                (checkboxRef.checked = Array.isArray(value)\n                  ? !!(value as []).find(\n                      (data: string) => data === checkboxRef.value,\n                    )\n                  : value === checkboxRef.value),\n            )\n          : (options[0].ref.checked = !!value);\n      } else {\n        ref.value = value;\n      }\n    },\n    [],\n  );\n\n  const isFormDirty = React.useCallback(\n    (name?: string, data?: unknown[]): boolean => {\n      if (readFormStateRef.current.isDirty) {\n        const formValues = getValues();\n\n        name && data && set(formValues, name, data);\n\n        return !deepEqual(formValues, defaultValuesRef.current);\n      }\n\n      return false;\n    },\n    [],\n  );\n\n  const updateAndGetDirtyState = React.useCallback(\n    (\n      name: InternalFieldName<TFieldValues>,\n      shouldRender = true,\n    ): Partial<\n      Pick<FormState<TFieldValues>, 'dirtyFields' | 'isDirty' | 'touched'>\n    > => {\n      if (\n        readFormStateRef.current.isDirty ||\n        readFormStateRef.current.dirtyFields\n      ) {\n        const isFieldDirty = !deepEqual(\n          get(defaultValuesRef.current, name),\n          getFieldValue(fieldsRef, name, shallowFieldsStateRef),\n        );\n        const isDirtyFieldExist = get(formStateRef.current.dirtyFields, name);\n        const previousIsDirty = formStateRef.current.isDirty;\n\n        isFieldDirty\n          ? set(formStateRef.current.dirtyFields, name, true)\n          : unset(formStateRef.current.dirtyFields, name);\n\n        const state = {\n          isDirty: isFormDirty(),\n          dirtyFields: formStateRef.current.dirtyFields,\n        };\n\n        const isChanged =\n          (readFormStateRef.current.isDirty &&\n            previousIsDirty !== state.isDirty) ||\n          (readFormStateRef.current.dirtyFields &&\n            isDirtyFieldExist !== get(formStateRef.current.dirtyFields, name));\n\n        isChanged && shouldRender && updateFormState(state);\n\n        return isChanged ? state : {};\n      }\n\n      return {};\n    },\n    [],\n  );\n\n  const executeValidation = React.useCallback(\n    async (\n      name: InternalFieldName<TFieldValues>,\n      skipReRender?: boolean | null,\n    ): Promise<boolean> => {\n      if (process.env.NODE_ENV !== 'production') {\n        if (!fieldsRef.current[name]) {\n          console.warn('📋 Field is missing with `name` attribute: ', name);\n          return false;\n        }\n      }\n\n      const error = (\n        await validateField<TFieldValues>(\n          fieldsRef,\n          isValidateAllFieldCriteria,\n          fieldsRef.current[name] as Field,\n          shallowFieldsStateRef,\n        )\n      )[name];\n\n      shouldRenderBaseOnError(name, error, skipReRender);\n\n      return isUndefined(error);\n    },\n    [shouldRenderBaseOnError, isValidateAllFieldCriteria],\n  );\n\n  const executeSchemaOrResolverValidation = React.useCallback(\n    async (\n      names:\n        | InternalFieldName<TFieldValues>\n        | InternalFieldName<TFieldValues>[],\n    ) => {\n      const { errors } = await resolverRef.current!(\n        getValues(),\n        contextRef.current,\n        isValidateAllFieldCriteria,\n      );\n      const previousFormIsValid = formStateRef.current.isValid;\n\n      if (Array.isArray(names)) {\n        const isInputsValid = names\n          .map((name) => {\n            const error = get(errors, name);\n\n            error\n              ? set(formStateRef.current.errors, name, error)\n              : unset(formStateRef.current.errors, name);\n\n            return !error;\n          })\n          .every(Boolean);\n\n        updateFormState({\n          isValid: isEmptyObject(errors),\n          isValidating: false,\n        });\n\n        return isInputsValid;\n      } else {\n        const error = get(errors, names);\n\n        shouldRenderBaseOnError(\n          names,\n          error,\n          previousFormIsValid !== isEmptyObject(errors),\n          {},\n          isEmptyObject(errors),\n        );\n\n        return !error;\n      }\n    },\n    [shouldRenderBaseOnError, isValidateAllFieldCriteria],\n  );\n\n  const trigger = React.useCallback(\n    async (\n      name?: FieldName<TFieldValues> | FieldName<TFieldValues>[],\n    ): Promise<boolean> => {\n      const fields = name || Object.keys(fieldsRef.current);\n\n      updateIsValidating();\n\n      if (resolverRef.current) {\n        return executeSchemaOrResolverValidation(fields);\n      }\n\n      if (Array.isArray(fields)) {\n        !name && (formStateRef.current.errors = {});\n        const result = await Promise.all(\n          fields.map(async (data) => await executeValidation(data, null)),\n        );\n        updateFormState({\n          isValidating: false,\n        });\n        return result.every(Boolean);\n      }\n\n      return await executeValidation(fields);\n    },\n    [executeSchemaOrResolverValidation, executeValidation],\n  );\n\n  const setInternalValues = React.useCallback(\n    (\n      name: FieldName<TFieldValues>,\n      value: SetFieldValue<TFieldValues>,\n      { shouldDirty, shouldValidate }: SetValueConfig,\n    ) => {\n      const data = {};\n      set(data, name, value);\n\n      for (const fieldName of getPath(name, value)) {\n        if (fieldsRef.current[fieldName]) {\n          setFieldValue(fieldName, get(data, fieldName));\n          shouldDirty && updateAndGetDirtyState(fieldName);\n          shouldValidate && trigger(fieldName as FieldName<TFieldValues>);\n        }\n      }\n    },\n    [trigger, setFieldValue, updateAndGetDirtyState],\n  );\n\n  const setInternalValue = React.useCallback(\n    (\n      name: FieldName<TFieldValues>,\n      value: SetFieldValue<TFieldValues>,\n      config: SetValueConfig,\n    ) => {\n      !shouldUnregister &&\n        !isPrimitive(value) &&\n        set(\n          shallowFieldsStateRef.current,\n          name,\n          Array.isArray(value) ? [...value] : { ...value },\n        );\n\n      if (fieldsRef.current[name]) {\n        setFieldValue(name, value);\n        config.shouldDirty && updateAndGetDirtyState(name);\n        config.shouldValidate && trigger(name as any);\n      } else if (!isPrimitive(value)) {\n        setInternalValues(name, value, config);\n\n        if (fieldArrayNamesRef.current.has(name)) {\n          const parentName = getNodeParentName(name) || name;\n          set(fieldArrayDefaultValuesRef.current, name, value);\n\n          resetFieldArrayFunctionRef.current[parentName]({\n            [parentName]: get(fieldArrayDefaultValuesRef.current, parentName),\n          } as UnpackNestedValue<DeepPartial<TFieldValues>>);\n\n          if (\n            (readFormStateRef.current.isDirty ||\n              readFormStateRef.current.dirtyFields) &&\n            config.shouldDirty\n          ) {\n            set(\n              formStateRef.current.dirtyFields,\n              name,\n              setFieldArrayDirtyFields(\n                value,\n                get(defaultValuesRef.current, name, []),\n                get(formStateRef.current.dirtyFields, name, []),\n              ),\n            );\n\n            updateFormState({\n              isDirty: !deepEqual(\n                { ...getValues(), [name]: value },\n                defaultValuesRef.current,\n              ),\n            });\n          }\n        }\n      }\n\n      !shouldUnregister && set(shallowFieldsStateRef.current, name, value);\n    },\n    [updateAndGetDirtyState, setFieldValue, setInternalValues],\n  );\n\n  const isFieldWatched = <T extends FieldName<TFieldValues>>(name: T) =>\n    isWatchAllRef.current ||\n    watchFieldsRef.current.has(name) ||\n    watchFieldsRef.current.has((name.match(/\\w+/) || [])[0]);\n\n  const renderWatchedInputs = <T extends FieldName<FieldValues>>(\n    name: T,\n  ): boolean => {\n    let found = true;\n\n    if (!isEmptyObject(useWatchFieldsRef.current)) {\n      for (const key in useWatchFieldsRef.current) {\n        if (\n          !name ||\n          !useWatchFieldsRef.current[key].size ||\n          useWatchFieldsRef.current[key].has(name) ||\n          useWatchFieldsRef.current[key].has(getNodeParentName(name))\n        ) {\n          useWatchRenderFunctionsRef.current[key]();\n          found = false;\n        }\n      }\n    }\n\n    return found;\n  };\n\n  function setValue(\n    name: FieldName<TFieldValues>,\n    value: SetFieldValue<TFieldValues>,\n    config?: SetValueConfig,\n  ): void {\n    setInternalValue(name, value, config || {});\n    isFieldWatched(name) && updateFormState();\n    renderWatchedInputs(name);\n  }\n\n  handleChangeRef.current = handleChangeRef.current\n    ? handleChangeRef.current\n    : async ({ type, target }: Event): Promise<void | boolean> => {\n        let name = (target as Ref)!.name;\n        const field = fieldsRef.current[name];\n        let error;\n        let isValid;\n\n        if (field) {\n          const isBlurEvent = type === EVENTS.BLUR;\n          const shouldSkipValidation = skipValidation({\n            isBlurEvent,\n            isReValidateOnChange,\n            isReValidateOnBlur,\n            isTouched: !!get(formStateRef.current.touched, name),\n            isSubmitted: formStateRef.current.isSubmitted,\n            ...modeRef.current,\n          });\n          let state = updateAndGetDirtyState(name, false);\n          let shouldRender =\n            !isEmptyObject(state) ||\n            (!isBlurEvent && isFieldWatched(name as FieldName<TFieldValues>));\n\n          if (\n            isBlurEvent &&\n            !get(formStateRef.current.touched, name) &&\n            readFormStateRef.current.touched\n          ) {\n            set(formStateRef.current.touched, name, true);\n            state = {\n              ...state,\n              touched: formStateRef.current.touched,\n            };\n          }\n\n          if (!shouldUnregister && isCheckBoxInput(target as Ref)) {\n            set(\n              shallowFieldsStateRef.current,\n              name,\n              getFieldValue(fieldsRef, name),\n            );\n          }\n\n          if (shouldSkipValidation) {\n            !isBlurEvent && renderWatchedInputs(name);\n            return (\n              (!isEmptyObject(state) ||\n                (shouldRender && isEmptyObject(state))) &&\n              updateFormState(state)\n            );\n          }\n\n          updateIsValidating();\n\n          if (resolverRef.current) {\n            const { errors } = await resolverRef.current(\n              getValues(),\n              contextRef.current,\n              isValidateAllFieldCriteria,\n            );\n            const previousFormIsValid = formStateRef.current.isValid;\n            error = get(errors, name);\n\n            if (\n              isCheckBoxInput(target as Ref) &&\n              !error &&\n              resolverRef.current\n            ) {\n              const parentNodeName = getNodeParentName(name);\n              const currentError = get(errors, parentNodeName, {});\n              currentError.type &&\n                currentError.message &&\n                (error = currentError);\n\n              if (\n                parentNodeName &&\n                (currentError ||\n                  get(formStateRef.current.errors, parentNodeName))\n              ) {\n                name = parentNodeName;\n              }\n            }\n\n            isValid = isEmptyObject(errors);\n\n            previousFormIsValid !== isValid && (shouldRender = true);\n          } else {\n            error = (\n              await validateField<TFieldValues>(\n                fieldsRef,\n                isValidateAllFieldCriteria,\n                field,\n                shallowFieldsStateRef,\n              )\n            )[name];\n          }\n\n          !isBlurEvent && renderWatchedInputs(name);\n          shouldRenderBaseOnError(name, error, shouldRender, state, isValid);\n        }\n      };\n\n  function setFieldArrayDefaultValues<T extends FieldValues>(data: T): T {\n    if (!shouldUnregister) {\n      let copy = cloneObject(data);\n\n      for (const value of fieldArrayNamesRef.current) {\n        if (isKey(value) && !copy[value]) {\n          copy = {\n            ...copy,\n            [value]: [],\n          };\n        }\n      }\n\n      return copy;\n    }\n    return data;\n  }\n\n  function getValues(): UnpackNestedValue<TFieldValues>;\n  function getValues<TFieldName extends string, TFieldValue extends unknown>(\n    name: TFieldName,\n  ): TFieldName extends keyof TFieldValues\n    ? UnpackNestedValue<TFieldValues>[TFieldName]\n    : TFieldValue;\n  function getValues<TFieldName extends keyof TFieldValues>(\n    names: TFieldName[],\n  ): UnpackNestedValue<Pick<TFieldValues, TFieldName>>;\n  function getValues(payload?: string | string[]): unknown {\n    if (isString(payload)) {\n      return getFieldValue(fieldsRef, payload, shallowFieldsStateRef);\n    }\n\n    if (Array.isArray(payload)) {\n      const data = {};\n\n      for (const name of payload) {\n        set(data, name, getFieldValue(fieldsRef, name, shallowFieldsStateRef));\n      }\n\n      return data;\n    }\n\n    return setFieldArrayDefaultValues(\n      getFieldsValues(\n        fieldsRef,\n        cloneObject(shallowFieldsStateRef.current),\n        shouldUnregister,\n      ),\n    );\n  }\n\n  const validateResolver = React.useCallback(\n    async (values = {}) => {\n      const newDefaultValues = isEmptyObject(fieldsRef.current)\n        ? defaultValuesRef.current\n        : {};\n\n      const { errors } =\n        (await resolverRef.current!(\n          {\n            ...newDefaultValues,\n            ...getValues(),\n            ...values,\n          },\n          contextRef.current,\n          isValidateAllFieldCriteria,\n        )) || {};\n      const isValid = isEmptyObject(errors);\n\n      formStateRef.current.isValid !== isValid &&\n        updateFormState({\n          isValid,\n        });\n    },\n    [isValidateAllFieldCriteria],\n  );\n\n  const removeFieldEventListener = React.useCallback(\n    (field: Field, forceDelete?: boolean) => {\n      findRemovedFieldAndRemoveListener(\n        fieldsRef,\n        handleChangeRef.current!,\n        field,\n        shallowFieldsStateRef,\n        shouldUnregister,\n        forceDelete,\n      );\n\n      if (shouldUnregister) {\n        unset(validFieldsRef.current, field.ref.name);\n        unset(fieldsWithValidationRef.current, field.ref.name);\n      }\n    },\n    [shouldUnregister],\n  );\n\n  const updateWatchedValue = React.useCallback((name: string) => {\n    if (isWatchAllRef.current) {\n      updateFormState();\n    } else {\n      for (const watchField of watchFieldsRef.current) {\n        if (watchField.startsWith(name)) {\n          updateFormState();\n          break;\n        }\n      }\n\n      renderWatchedInputs(name);\n    }\n  }, []);\n\n  const removeFieldEventListenerAndRef = React.useCallback(\n    (field?: Field, forceDelete?: boolean) => {\n      if (field) {\n        removeFieldEventListener(field, forceDelete);\n\n        if (shouldUnregister && !compact(field.options || []).length) {\n          unset(formStateRef.current.errors, field.ref.name);\n          set(formStateRef.current.dirtyFields, field.ref.name, true);\n\n          updateFormState({\n            isDirty: isFormDirty(),\n          });\n\n          readFormStateRef.current.isValid &&\n            resolverRef.current &&\n            validateResolver();\n          updateWatchedValue(field.ref.name);\n        }\n      }\n    },\n    [validateResolver, removeFieldEventListener],\n  );\n\n  function clearErrors(\n    name?: FieldName<TFieldValues> | FieldName<TFieldValues>[],\n  ): void {\n    name &&\n      (Array.isArray(name) ? name : [name]).forEach((inputName) =>\n        fieldsRef.current[inputName] && isKey(inputName)\n          ? delete formStateRef.current.errors[inputName]\n          : unset(formStateRef.current.errors, inputName),\n      );\n\n    updateFormState({\n      errors: name ? formStateRef.current.errors : {},\n    });\n  }\n\n  function setError(name: FieldName<TFieldValues>, error: ErrorOption) {\n    const ref = (fieldsRef.current[name] || {})!.ref;\n\n    set(formStateRef.current.errors, name, {\n      ...error,\n      ref,\n    });\n\n    updateFormState({\n      isValid: false,\n    });\n\n    error.shouldFocus && ref && ref.focus && ref.focus();\n  }\n\n  const watchInternal = React.useCallback(\n    <T>(fieldNames?: string | string[], defaultValue?: T, watchId?: string) => {\n      const watchFields = watchId\n        ? useWatchFieldsRef.current[watchId]\n        : watchFieldsRef.current;\n      let fieldValues = getFieldsValues<TFieldValues>(\n        fieldsRef,\n        cloneObject(shallowFieldsStateRef.current),\n        shouldUnregister,\n        false,\n        fieldNames,\n      );\n\n      if (isString(fieldNames)) {\n        const parentNodeName = getNodeParentName(fieldNames) || fieldNames;\n\n        if (fieldArrayNamesRef.current.has(parentNodeName)) {\n          fieldValues = {\n            ...fieldArrayValuesRef.current,\n            ...fieldValues,\n          };\n        }\n\n        return assignWatchFields<TFieldValues>(\n          fieldValues,\n          fieldNames,\n          watchFields,\n          isUndefined(get(defaultValuesRef.current, fieldNames))\n            ? defaultValue\n            : get(defaultValuesRef.current, fieldNames),\n          true,\n        );\n      }\n\n      const combinedDefaultValues = isUndefined(defaultValue)\n        ? defaultValuesRef.current\n        : defaultValue;\n\n      if (Array.isArray(fieldNames)) {\n        return fieldNames.reduce(\n          (previous, name) => ({\n            ...previous,\n            [name]: assignWatchFields<TFieldValues>(\n              fieldValues,\n              name,\n              watchFields,\n              combinedDefaultValues as UnpackNestedValue<\n                DeepPartial<TFieldValues>\n              >,\n            ),\n          }),\n          {},\n        );\n      }\n\n      isWatchAllRef.current = isUndefined(watchId);\n\n      return transformToNestObject(\n        (!isEmptyObject(fieldValues) && fieldValues) ||\n          (combinedDefaultValues as FieldValues),\n      );\n    },\n    [],\n  );\n\n  function watch(): UnpackNestedValue<TFieldValues>;\n  function watch<\n    TFieldName extends string,\n    TFieldValue extends TFieldValues[TFieldName]\n  >(\n    name?: TFieldName,\n    defaultValue?: UnpackNestedValue<LiteralToPrimitive<TFieldValue>>,\n  ): UnpackNestedValue<LiteralToPrimitive<TFieldValue>>;\n  function watch<TFieldName extends keyof TFieldValues>(\n    names: TFieldName[],\n    defaultValues?: UnpackNestedValue<\n      DeepPartial<Pick<TFieldValues, TFieldName>>\n    >,\n  ): UnpackNestedValue<Pick<TFieldValues, TFieldName>>;\n  function watch(\n    names: string[],\n    defaultValues?: UnpackNestedValue<DeepPartial<TFieldValues>>,\n  ): UnpackNestedValue<DeepPartial<TFieldValues>>;\n  function watch(\n    fieldNames?: string | string[] | undefined,\n    defaultValue?: unknown,\n  ): unknown {\n    return watchInternal(fieldNames, defaultValue);\n  }\n\n  function unregister(\n    name: FieldName<TFieldValues> | FieldName<TFieldValues>[],\n  ): void {\n    for (const fieldName of Array.isArray(name) ? name : [name]) {\n      removeFieldEventListenerAndRef(fieldsRef.current[fieldName], true);\n    }\n  }\n\n  function registerFieldRef<TFieldElement extends FieldElement<TFieldValues>>(\n    ref: TFieldElement & Ref,\n    options: RegisterOptions | null = {},\n  ): ((name: InternalFieldName<TFieldValues>) => void) | void {\n    if (process.env.NODE_ENV !== 'production') {\n      if (!ref.name) {\n        return console.warn(\n          '📋 Field is missing `name` attribute',\n          ref,\n          `https://react-hook-form.com/api#useForm`,\n        );\n      }\n\n      if (\n        fieldArrayNamesRef.current.has(ref.name.split(/\\[\\d+\\]$/)[0]) &&\n        !RegExp(\n          `^${ref.name.split(/\\[\\d+\\]$/)[0]}[\\\\d+].\\\\w+`\n            .replace(/\\[/g, '\\\\[')\n            .replace(/\\]/g, '\\\\]'),\n        ).test(ref.name)\n      ) {\n        return console.warn(\n          '📋 `name` prop should be in object shape: name=\"test[index].name\"',\n          ref,\n          'https://react-hook-form.com/api#useFieldArray',\n        );\n      }\n    }\n\n    const { name, type, value } = ref;\n    const fieldRefAndValidationOptions = {\n      ref,\n      ...options,\n    };\n    const fields = fieldsRef.current;\n    const isRadioOrCheckbox = isRadioOrCheckboxFunction(ref);\n    const isFieldArray = isNameInFieldArray(fieldArrayNamesRef.current, name);\n    const compareRef = (currentRef: Ref) =>\n      isWeb && (!isHTMLElement(ref) || currentRef === ref);\n    let field = fields[name] as Field;\n    let isEmptyDefaultValue = true;\n    let defaultValue;\n\n    if (\n      field &&\n      (isRadioOrCheckbox\n        ? Array.isArray(field.options) &&\n          compact(field.options).find((option) => {\n            return value === option.ref.value && compareRef(option.ref);\n          })\n        : compareRef(field.ref))\n    ) {\n      fields[name] = {\n        ...field,\n        ...options,\n      };\n      return;\n    }\n\n    if (type) {\n      field = isRadioOrCheckbox\n        ? {\n            options: [\n              ...compact((field && field.options) || []),\n              {\n                ref,\n              } as RadioOrCheckboxOption,\n            ],\n            ref: { type, name },\n            ...options,\n          }\n        : {\n            ...fieldRefAndValidationOptions,\n          };\n    } else {\n      field = fieldRefAndValidationOptions;\n    }\n\n    fields[name] = field;\n\n    const isEmptyUnmountFields = isUndefined(\n      get(shallowFieldsStateRef.current, name),\n    );\n\n    if (!isEmptyObject(defaultValuesRef.current) || !isEmptyUnmountFields) {\n      defaultValue = get(\n        isEmptyUnmountFields\n          ? defaultValuesRef.current\n          : shallowFieldsStateRef.current,\n        name,\n      );\n      isEmptyDefaultValue = isUndefined(defaultValue);\n\n      if (!isEmptyDefaultValue && !isFieldArray) {\n        setFieldValue(name as FieldName<TFieldValues>, defaultValue);\n      }\n    }\n\n    if (!isEmptyObject(options)) {\n      set(fieldsWithValidationRef.current, name, true);\n\n      if (!isOnSubmit && readFormStateRef.current.isValid) {\n        validateField(\n          fieldsRef,\n          isValidateAllFieldCriteria,\n          field,\n          shallowFieldsStateRef,\n        ).then((error: FieldErrors) => {\n          const previousFormIsValid = formStateRef.current.isValid;\n\n          isEmptyObject(error)\n            ? set(validFieldsRef.current, name, true)\n            : unset(validFieldsRef.current, name);\n\n          previousFormIsValid !== isEmptyObject(error) && updateFormState();\n        });\n      }\n    }\n\n    if (shouldUnregister && !(isFieldArray && isEmptyDefaultValue)) {\n      !isFieldArray && unset(formStateRef.current.dirtyFields, name);\n    }\n\n    if (type) {\n      attachEventListeners(\n        isRadioOrCheckbox && field.options\n          ? field.options[field.options.length - 1]\n          : field,\n        isRadioOrCheckbox || isSelectInput(ref),\n        handleChangeRef.current,\n      );\n    }\n  }\n\n  function register<TFieldElement extends FieldElement<TFieldValues>>(\n    options?: RegisterOptions,\n  ): (ref: (TFieldElement & Ref) | null) => void;\n  function register(\n    name: FieldName<TFieldValues>,\n    options?: RegisterOptions,\n  ): void;\n  function register<TFieldElement extends FieldElement<TFieldValues>>(\n    ref: (TFieldElement & Ref) | null,\n    options?: RegisterOptions,\n  ): void;\n  function register<TFieldElement extends FieldElement<TFieldValues>>(\n    refOrRegisterOptions?:\n      | FieldName<TFieldValues>\n      | RegisterOptions\n      | (TFieldElement & Ref)\n      | null,\n    options?: RegisterOptions,\n  ): ((ref: (TFieldElement & Ref) | null) => void) | void {\n    if (!isWindowUndefined) {\n      if (isString(refOrRegisterOptions)) {\n        registerFieldRef({ name: refOrRegisterOptions }, options);\n      } else if (\n        isObject(refOrRegisterOptions) &&\n        'name' in refOrRegisterOptions\n      ) {\n        registerFieldRef(refOrRegisterOptions, options);\n      } else {\n        return (ref: (TFieldElement & Ref) | null) =>\n          ref && registerFieldRef(ref, refOrRegisterOptions);\n      }\n    }\n  }\n\n  const handleSubmit = React.useCallback(\n    <TSubmitFieldValues extends FieldValues = TFieldValues>(\n      onValid: SubmitHandler<TSubmitFieldValues>,\n      onInvalid?: SubmitErrorHandler<TFieldValues>,\n    ) => async (e?: React.BaseSyntheticEvent): Promise<void> => {\n      if (e && e.preventDefault) {\n        e.preventDefault();\n        e.persist();\n      }\n      let fieldErrors: FieldErrors<TFieldValues> = {};\n      let fieldValues = setFieldArrayDefaultValues(\n        getFieldsValues(\n          fieldsRef,\n          cloneObject(shallowFieldsStateRef.current),\n          shouldUnregister,\n          true,\n        ),\n      );\n\n      readFormStateRef.current.isSubmitting &&\n        updateFormState({\n          isSubmitting: true,\n        });\n\n      try {\n        if (resolverRef.current) {\n          const { errors, values } = await resolverRef.current(\n            fieldValues,\n            contextRef.current,\n            isValidateAllFieldCriteria,\n          );\n          formStateRef.current.errors = fieldErrors = errors;\n          fieldValues = values;\n        } else {\n          for (const field of Object.values(fieldsRef.current)) {\n            if (field) {\n              const { name } = field.ref;\n\n              const fieldError = await validateField(\n                fieldsRef,\n                isValidateAllFieldCriteria,\n                field,\n                shallowFieldsStateRef,\n              );\n\n              if (fieldError[name]) {\n                set(fieldErrors, name, fieldError[name]);\n                unset(validFieldsRef.current, name);\n              } else if (get(fieldsWithValidationRef.current, name)) {\n                unset(formStateRef.current.errors, name);\n                set(validFieldsRef.current, name, true);\n              }\n            }\n          }\n        }\n\n        if (\n          isEmptyObject(fieldErrors) &&\n          Object.keys(formStateRef.current.errors).every(\n            (name) => name in fieldsRef.current,\n          )\n        ) {\n          updateFormState({\n            errors: {},\n            isSubmitting: true,\n          });\n          await onValid(fieldValues, e);\n        } else {\n          formStateRef.current.errors = {\n            ...formStateRef.current.errors,\n            ...fieldErrors,\n          };\n          onInvalid && (await onInvalid(formStateRef.current.errors, e));\n          shouldFocusError &&\n            focusOnErrorField(fieldsRef.current, formStateRef.current.errors);\n        }\n      } finally {\n        formStateRef.current.isSubmitting = false;\n        updateFormState({\n          isSubmitted: true,\n          isSubmitting: false,\n          isSubmitSuccessful: isEmptyObject(formStateRef.current.errors),\n          submitCount: formStateRef.current.submitCount + 1,\n        });\n      }\n    },\n    [shouldFocusError, isValidateAllFieldCriteria],\n  );\n\n  const resetRefs = ({\n    errors,\n    isDirty,\n    isSubmitted,\n    touched,\n    isValid,\n    submitCount,\n    dirtyFields,\n  }: OmitResetState) => {\n    if (!isValid) {\n      validFieldsRef.current = {};\n      fieldsWithValidationRef.current = {};\n    }\n\n    fieldArrayDefaultValuesRef.current = {};\n    watchFieldsRef.current = new Set();\n    isWatchAllRef.current = false;\n\n    updateFormState({\n      submitCount: submitCount ? formStateRef.current.submitCount : 0,\n      isDirty: isDirty ? formStateRef.current.isDirty : false,\n      isSubmitted: isSubmitted ? formStateRef.current.isSubmitted : false,\n      isValid: isValid ? formStateRef.current.isValid : false,\n      dirtyFields: dirtyFields ? formStateRef.current.dirtyFields : {},\n      touched: touched ? formStateRef.current.touched : {},\n      errors: errors ? formStateRef.current.errors : {},\n      isSubmitting: false,\n      isSubmitSuccessful: false,\n    });\n  };\n\n  const reset = (\n    values?: DefaultValues<TFieldValues>,\n    omitResetState: OmitResetState = {},\n  ): void => {\n    if (isWeb) {\n      for (const field of Object.values(fieldsRef.current)) {\n        if (field) {\n          const { ref, options } = field;\n          const inputRef =\n            isRadioOrCheckboxFunction(ref) && Array.isArray(options)\n              ? options[0].ref\n              : ref;\n\n          if (isHTMLElement(inputRef)) {\n            try {\n              inputRef.closest('form')!.reset();\n              break;\n            } catch {}\n          }\n        }\n      }\n    }\n\n    fieldsRef.current = {};\n    defaultValuesRef.current = { ...(values || defaultValuesRef.current) };\n    values && renderWatchedInputs('');\n\n    Object.values(resetFieldArrayFunctionRef.current).forEach(\n      (resetFieldArray) => isFunction(resetFieldArray) && resetFieldArray(),\n    );\n\n    shallowFieldsStateRef.current = shouldUnregister\n      ? {}\n      : cloneObject(values || defaultValuesRef.current);\n\n    resetRefs(omitResetState);\n  };\n\n  React.useEffect(() => {\n    resolver && readFormStateRef.current.isValid && validateResolver();\n    observerRef.current =\n      observerRef.current || !isWeb\n        ? observerRef.current\n        : onDomRemove(fieldsRef, removeFieldEventListenerAndRef);\n  }, [removeFieldEventListenerAndRef, defaultValuesRef.current]);\n\n  React.useEffect(\n    () => () => {\n      observerRef.current && observerRef.current.disconnect();\n      isUnMount.current = true;\n\n      if (process.env.NODE_ENV !== 'production') {\n        return;\n      }\n\n      Object.values(fieldsRef.current).forEach((field) =>\n        removeFieldEventListenerAndRef(field, true),\n      );\n    },\n    [],\n  );\n\n  if (!resolver && readFormStateRef.current.isValid) {\n    formState.isValid =\n      deepEqual(validFieldsRef.current, fieldsWithValidationRef.current) &&\n      isEmptyObject(formStateRef.current.errors);\n  }\n\n  const commonProps = {\n    trigger,\n    setValue: React.useCallback(setValue, [setInternalValue, trigger]),\n    getValues: React.useCallback(getValues, []),\n    register: React.useCallback(register, [defaultValuesRef.current]),\n    unregister: React.useCallback(unregister, []),\n    formState: isProxyEnabled\n      ? new Proxy(formState, {\n          get: (obj, prop: keyof FormStateProxy) => {\n            if (process.env.NODE_ENV !== 'production') {\n              if (prop === 'isValid' && isOnSubmit) {\n                console.warn(\n                  '📋 `formState.isValid` is applicable with `onTouched`, `onChange` or `onBlur` mode. https://react-hook-form.com/api#formState',\n                );\n              }\n            }\n\n            if (prop in obj) {\n              readFormStateRef.current[prop] = true;\n              return obj[prop];\n            }\n\n            return undefined;\n          },\n        })\n      : formState,\n  };\n\n  const control = React.useMemo(\n    () => ({\n      isFormDirty,\n      updateWatchedValue,\n      shouldUnregister,\n      updateFormState,\n      removeFieldEventListener,\n      watchInternal,\n      mode: modeRef.current,\n      reValidateMode: {\n        isReValidateOnBlur,\n        isReValidateOnChange,\n      },\n      validateResolver: resolver ? validateResolver : undefined,\n      fieldsRef,\n      resetFieldArrayFunctionRef,\n      useWatchFieldsRef,\n      useWatchRenderFunctionsRef,\n      fieldArrayDefaultValuesRef,\n      validFieldsRef,\n      fieldsWithValidationRef,\n      fieldArrayNamesRef,\n      readFormStateRef,\n      formStateRef,\n      defaultValuesRef,\n      shallowFieldsStateRef,\n      fieldArrayValuesRef,\n      ...commonProps,\n    }),\n    [\n      defaultValuesRef.current,\n      updateWatchedValue,\n      shouldUnregister,\n      removeFieldEventListener,\n      watchInternal,\n    ],\n  );\n\n  return {\n    watch,\n    control,\n    handleSubmit,\n    reset: React.useCallback(reset, []),\n    clearErrors: React.useCallback(clearErrors, []),\n    setError: React.useCallback(setError, []),\n    errors: formState.errors,\n    ...commonProps,\n  };\n}\n","import * as React from 'react';\nimport { UseFormMethods, FieldValues, FormProviderProps } from './types';\n\nconst FormContext = React.createContext<UseFormMethods | null>(null);\n\nFormContext.displayName = 'RHFContext';\n\nexport const useFormContext = <\n  TFieldValues extends FieldValues\n>(): UseFormMethods<TFieldValues> =>\n  React.useContext(FormContext) as UseFormMethods<TFieldValues>;\n\nexport const FormProvider = <TFieldValues extends FieldValues>({\n  children,\n  ...props\n}: FormProviderProps<TFieldValues>) => (\n  <FormContext.Provider value={{ ...props } as UseFormMethods}>\n    {children}\n  </FormContext.Provider>\n);\n","import { useFormContext } from './useFormContext';\nimport isNameInFieldArray from './logic/isNameInFieldArray';\nimport isUndefined from './utils/isUndefined';\nimport get from './utils/get';\nimport * as React from 'react';\nimport isFunction from './utils/isFunction';\nimport skipValidation from './logic/skipValidation';\nimport getInputValue from './logic/getInputValue';\nimport set from './utils/set';\nimport {\n  FieldValues,\n  UseControllerOptions,\n  UseControllerMethods,\n} from './types';\n\nexport function useController<TFieldValues extends FieldValues = FieldValues>({\n  name,\n  rules,\n  defaultValue,\n  control,\n  onFocus,\n}: UseControllerOptions<TFieldValues>): UseControllerMethods<TFieldValues> {\n  const methods = useFormContext<TFieldValues>();\n\n  if (process.env.NODE_ENV !== 'production') {\n    if (!control && !methods) {\n      throw new Error(\n        '📋 Controller is missing `control` prop. https://react-hook-form.com/api#Controller',\n      );\n    }\n  }\n\n  const {\n    defaultValuesRef,\n    setValue,\n    register,\n    unregister,\n    trigger,\n    mode,\n    reValidateMode: { isReValidateOnBlur, isReValidateOnChange },\n    formState,\n    formStateRef: {\n      current: { isSubmitted, touched, errors },\n    },\n    updateFormState,\n    readFormStateRef,\n    fieldsRef,\n    fieldArrayNamesRef,\n    shallowFieldsStateRef,\n  } = control || methods.control;\n\n  const isNotFieldArray = !isNameInFieldArray(fieldArrayNamesRef.current, name);\n  const getInitialValue = () =>\n    !isUndefined(get(shallowFieldsStateRef.current, name)) && isNotFieldArray\n      ? get(shallowFieldsStateRef.current, name)\n      : isUndefined(defaultValue)\n      ? get(defaultValuesRef.current, name)\n      : defaultValue;\n  const [value, setInputStateValue] = React.useState(getInitialValue());\n  const valueRef = React.useRef(value);\n  const ref = React.useRef({\n    focus: () => null,\n  });\n  const onFocusRef = React.useRef(\n    onFocus ||\n      (() => {\n        if (isFunction(ref.current.focus)) {\n          ref.current.focus();\n        }\n\n        if (process.env.NODE_ENV !== 'production') {\n          if (!isFunction(ref.current.focus)) {\n            console.warn(\n              `📋 'ref' from Controller render prop must be attached to a React component or a DOM Element whose ref provides a 'focus()' method`,\n            );\n          }\n        }\n      }),\n  );\n\n  const shouldValidate = React.useCallback(\n    (isBlurEvent?: boolean) =>\n      !skipValidation({\n        isBlurEvent,\n        isReValidateOnBlur,\n        isReValidateOnChange,\n        isSubmitted,\n        isTouched: !!get(touched, name),\n        ...mode,\n      }),\n    [\n      isReValidateOnBlur,\n      isReValidateOnChange,\n      isSubmitted,\n      touched,\n      name,\n      mode,\n    ],\n  );\n\n  const commonTask = React.useCallback(([event]: any[]) => {\n    const data = getInputValue(event);\n    setInputStateValue(data);\n    valueRef.current = data;\n    return data;\n  }, []);\n\n  const registerField = React.useCallback(\n    (shouldUpdateValue?: boolean) => {\n      if (process.env.NODE_ENV !== 'production') {\n        if (!name) {\n          return console.warn(\n            '📋 Field is missing `name` prop. https://react-hook-form.com/api#Controller',\n          );\n        }\n      }\n\n      if (fieldsRef.current[name]) {\n        fieldsRef.current[name] = {\n          ref: fieldsRef.current[name]!.ref,\n          ...rules,\n        };\n      } else {\n        register(\n          Object.defineProperties(\n            {\n              name,\n              focus: onFocusRef.current,\n            },\n            {\n              value: {\n                set(data) {\n                  setInputStateValue(data);\n                  valueRef.current = data;\n                },\n                get() {\n                  return valueRef.current;\n                },\n              },\n            },\n          ),\n          rules,\n        );\n\n        shouldUpdateValue = isUndefined(get(defaultValuesRef.current, name));\n      }\n\n      shouldUpdateValue &&\n        isNotFieldArray &&\n        setInputStateValue(getInitialValue());\n    },\n    [rules, name, register],\n  );\n\n  React.useEffect(() => () => unregister(name), [name]);\n\n  React.useEffect(() => {\n    if (process.env.NODE_ENV !== 'production') {\n      if (isUndefined(value)) {\n        console.warn(\n          `📋 ${name} is missing in the 'defaultValue' prop of either its Controller (https://react-hook-form.com/api#Controller) or useForm (https://react-hook-form.com/api#useForm)`,\n        );\n      }\n\n      if (!isNotFieldArray && isUndefined(defaultValue)) {\n        console.warn(\n          '📋 Controller is missing `defaultValue` prop when using `useFieldArray`. https://react-hook-form.com/api#Controller',\n        );\n      }\n    }\n\n    registerField();\n  }, [registerField]);\n\n  React.useEffect(() => {\n    !fieldsRef.current[name] && registerField(true);\n  });\n\n  const onBlur = React.useCallback(() => {\n    if (readFormStateRef.current.touched && !get(touched, name)) {\n      set(touched, name, true);\n      updateFormState({\n        touched,\n      });\n    }\n\n    shouldValidate(true) && trigger(name);\n  }, [name, updateFormState, shouldValidate, trigger, readFormStateRef]);\n\n  const onChange = React.useCallback(\n    (...event: any[]) =>\n      setValue(name, commonTask(event), {\n        shouldValidate: shouldValidate(),\n        shouldDirty: true,\n      }),\n    [setValue, name, shouldValidate],\n  );\n\n  return {\n    field: {\n      onChange,\n      onBlur,\n      name,\n      value,\n      ref,\n    },\n    meta: Object.defineProperties(\n      {\n        invalid: !!get(errors, name),\n      },\n      {\n        isDirty: {\n          get() {\n            return !!get(formState.dirtyFields, name);\n          },\n        },\n        isTouched: {\n          get() {\n            return !!get(formState.touched, name);\n          },\n        },\n      },\n    ),\n  };\n}\n","import isUndefined from '../utils/isUndefined';\nimport isObject from '../utils/isObject';\nimport isPrimitive from '../utils/isPrimitive';\n\nexport default (event: any) =>\n  isPrimitive(event) ||\n  !isObject(event.target) ||\n  (isObject(event.target) && !event.type)\n    ? event\n    : isUndefined(event.target.value)\n    ? event.target.checked\n    : event.target.value;\n","import * as React from 'react';\nimport { useController } from './useController';\nimport { ControllerProps, FieldValues } from './types';\n\ntype NativeInputs = 'input' | 'select' | 'textarea';\n\nconst Controller = <\n  TAs extends React.ReactElement | React.ComponentType<any> | NativeInputs,\n  TFieldValues extends FieldValues = FieldValues\n>(\n  props: ControllerProps<TAs, TFieldValues>,\n) => {\n  const { rules, as, render, defaultValue, control, onFocus, ...rest } = props;\n  const { field, meta } = useController(props);\n\n  const componentProps = {\n    ...rest,\n    ...field,\n  };\n\n  return as\n    ? React.isValidElement(as)\n      ? React.cloneElement(as, componentProps)\n      : React.createElement(as as NativeInputs, componentProps as any)\n    : render\n    ? render(field, meta)\n    : null;\n};\n\nexport { Controller };\n"],"sourceRoot":""}