{"version":3,"sources":["../node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/createForOfIteratorHelper.js","../node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/toConsumableArray.js","../node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js","../node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/iterableToArray.js","../node_modules/babel-preset-react-app/node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js","../../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"],"names":["_createForOfIteratorHelper","o","allowArrayLike","it","Symbol","iterator","Array","isArray","unsupportedIterableToArray","length","i","F","s","n","done","value","e","_e","f","TypeError","err","normalCompletion","didErr","step","next","_e2","_toConsumableArray","arr","arrayLikeToArray","iter","Object","from","HTMLElement","EVENTS","VALIDATION_MODE","SELECT","UNDEFINED","INPUT_VALIDATION_RULES","attachEventListeners","shouldAttachChangeEvent","handleChange","ref","isHTMLElement","addEventListener","isObjectType","isNullOrUndefined","Date","test","filter","Boolean","input","compact","replace","split","set","object","path","index","tempPath","isKey","stringToPath","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","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","validateAllFieldCriteria","types","a","required","maxLength","minLength","min","max","pattern","validate","isRadio","isRadioOrCheckbox","isEmpty","appendErrorsCurry","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","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","includes","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","removeFieldEventListener","updateWatchedValue","clearErrors","inputName","setError","shouldFocus","watchInternal","fieldNames","watchId","assignWatchFields","combinedDefaultValues","watch","unregister","registerFieldRef","fieldRefAndValidationOptions","isRadioOrCheckboxFunction","isFieldArray","compareRef","currentRef","isEmptyDefaultValue","isEmptyUnmountFields","then","isSelectInput","register","refOrRegisterOptions","handleSubmit","onValid","onInvalid","preventDefault","persist","fieldError","focusOnErrorField","resetRefs","reset","omitResetState","inputRef","closest","resetFieldArray","React.useEffect","disconnect","commonProps","prop","control","React.useMemo","FormContext","React.createContext","displayName"],"mappings":"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","file":"static/js/0.087cb9b8.chunk.js","sourcesContent":["import unsupportedIterableToArray from \"@babel/runtime/helpers/esm/unsupportedIterableToArray\";\nexport default function _createForOfIteratorHelper(o, allowArrayLike) {\n  var it;\n\n  if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) {\n    if (Array.isArray(o) || (it = unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") {\n      if (it) o = it;\n      var i = 0;\n\n      var F = function F() {};\n\n      return {\n        s: F,\n        n: function n() {\n          if (i >= o.length) return {\n            done: true\n          };\n          return {\n            done: false,\n            value: o[i++]\n          };\n        },\n        e: function e(_e) {\n          throw _e;\n        },\n        f: F\n      };\n    }\n\n    throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n  }\n\n  var normalCompletion = true,\n      didErr = false,\n      err;\n  return {\n    s: function s() {\n      it = o[Symbol.iterator]();\n    },\n    n: function n() {\n      var step = it.next();\n      normalCompletion = step.done;\n      return step;\n    },\n    e: function e(_e2) {\n      didErr = true;\n      err = _e2;\n    },\n    f: function f() {\n      try {\n        if (!normalCompletion && it[\"return\"] != null) it[\"return\"]();\n      } finally {\n        if (didErr) throw err;\n      }\n    }\n  };\n}","import arrayWithoutHoles from \"@babel/runtime/helpers/esm/arrayWithoutHoles\";\nimport iterableToArray from \"@babel/runtime/helpers/esm/iterableToArray\";\nimport unsupportedIterableToArray from \"@babel/runtime/helpers/esm/unsupportedIterableToArray\";\nimport nonIterableSpread from \"@babel/runtime/helpers/esm/nonIterableSpread\";\nexport default function _toConsumableArray(arr) {\n  return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();\n}","import arrayLikeToArray from \"@babel/runtime/helpers/esm/arrayLikeToArray\";\nexport default function _arrayWithoutHoles(arr) {\n  if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}","export default function _iterableToArray(iter) {\n  if (typeof Symbol !== \"undefined\" && Symbol.iterator in Object(iter)) return Array.from(iter);\n}","export default function _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}","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 (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(shallowFieldsStateRef.current, name, { ...value });\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 { errors } = await resolverRef.current!(\n        {\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    [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(validFieldsRef.current, field.ref.name);\n          unset(fieldsWithValidationRef.current, field.ref.name);\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[],\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"],"sourceRoot":""}