{"version":3,"file":"1203-cea7444e.pkg.js","mappings":"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","sources":["webpack://frontend-build-tools/./node_modules/react-escape-outside/dist/index.js","webpack://frontend-build-tools/./node_modules/react-hook-form/dist/index.esm.js","webpack://frontend-build-tools/./node_modules/redux-persist/es/integration/react.js"],"sourcesContent":["\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports[\"default\"] = void 0;\n\nvar _react = _interopRequireWildcard(require(\"react\"));\n\nvar _propTypes = _interopRequireDefault(require(\"prop-types\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { \"default\": obj }; }\n\nfunction _getRequireWildcardCache() { if (typeof WeakMap !== \"function\") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }\n\nfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== \"object\" && typeof obj !== \"function\") { return { \"default\": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj[\"default\"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }\n\nfunction _typeof(obj) { \"@babel/helpers - typeof\"; if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nfunction _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\nfunction _createSuper(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } return _assertThisInitialized(self); }\n\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\n\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nvar EscapeOutside = /*#__PURE__*/function (_Component) {\n  _inherits(EscapeOutside, _Component);\n\n  var _super = _createSuper(EscapeOutside);\n\n  function EscapeOutside() {\n    var _this;\n\n    _classCallCheck(this, EscapeOutside);\n\n    _this = _super.call(this);\n    _this.onEscape = _this.onEscape.bind(_assertThisInitialized(_this));\n    _this.onClick = _this.onClick.bind(_assertThisInitialized(_this));\n    _this.getRef = _this.getRef.bind(_assertThisInitialized(_this));\n    return _this;\n  }\n\n  _createClass(EscapeOutside, [{\n    key: \"componentDidMount\",\n    value: function componentDidMount() {\n      document.addEventListener(\"keydown\", this.onEscape);\n      document.addEventListener(this.props.mouseEvent, this.onClick, true);\n      document.addEventListener(this.props.touchEvent, this.onClick, true);\n    }\n  }, {\n    key: \"componentWillUnmount\",\n    value: function componentWillUnmount() {\n      document.removeEventListener(\"keydown\", this.onEscape);\n      document.removeEventListener(this.props.mouseEvent, this.onClick, true);\n      document.removeEventListener(this.props.touchEvent, this.onClick, true);\n    }\n  }, {\n    key: \"onEscape\",\n    value: function onEscape(e) {\n      if (e.keyCode === 27) this.props.onEscapeOutside();\n    }\n  }, {\n    key: \"onClick\",\n    value: function onClick(e) {\n      if (this.ref && !this.ref.contains(e.target)) this.props.onEscapeOutside(e);\n    }\n  }, {\n    key: \"getRef\",\n    value: function getRef(ref) {\n      this.ref = ref;\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      var props = Object.assign({}, this.props);\n      var children = props.children;\n      delete props.onEscapeOutside;\n      delete props.children;\n      delete props.mouseEvent;\n      delete props.touchEvent;\n      return /*#__PURE__*/_react[\"default\"].createElement(\"div\", _extends({\n        ref: this.getRef\n      }, props), children);\n    }\n  }]);\n\n  return EscapeOutside;\n}(_react.Component);\n\nexports[\"default\"] = EscapeOutside;\n\n_defineProperty(EscapeOutside, \"propTypes\", {\n  children: _propTypes[\"default\"].element.isRequired,\n  onEscapeOutside: _propTypes[\"default\"].func.isRequired,\n  mouseEvent: _propTypes[\"default\"].string,\n  touchEvent: _propTypes[\"default\"].string\n});\n\n_defineProperty(EscapeOutside, \"defaultProps\", {\n  mouseEvent: \"click\",\n  touchEvent: \"touchend\"\n});","import { isValidElement, useRef, useState, useCallback, useEffect, useMemo, createContext, useContext, createElement, cloneElement } from 'react';\n\nvar isHTMLElement = (value) => value instanceof HTMLElement;\n\nconst EVENTS = {\r\n    BLUR: 'blur',\r\n    CHANGE: 'change',\r\n    INPUT: 'input',\r\n};\r\nconst VALIDATION_MODE = {\r\n    onBlur: 'onBlur',\r\n    onChange: 'onChange',\r\n    onSubmit: 'onSubmit',\r\n    onTouched: 'onTouched',\r\n    all: 'all',\r\n};\r\nconst SELECT = 'select';\r\nconst UNDEFINED = 'undefined';\r\nconst INPUT_VALIDATION_RULES = {\r\n    max: 'max',\r\n    min: 'min',\r\n    maxLength: 'maxLength',\r\n    minLength: 'minLength',\r\n    pattern: 'pattern',\r\n    required: 'required',\r\n    validate: 'validate',\r\n};\n\nfunction attachEventListeners({ ref }, shouldAttachChangeEvent, handleChange) {\r\n    if (isHTMLElement(ref) && handleChange) {\r\n        ref.addEventListener(shouldAttachChangeEvent ? EVENTS.CHANGE : EVENTS.INPUT, handleChange);\r\n        ref.addEventListener(EVENTS.BLUR, handleChange);\r\n    }\r\n}\n\nvar isNullOrUndefined = (value) => value == null;\n\nconst isObjectType = (value) => typeof value === 'object';\r\nvar isObject = (value) => !isNullOrUndefined(value) &&\r\n    !Array.isArray(value) &&\r\n    isObjectType(value) &&\r\n    !(value instanceof Date);\n\nvar isKey = (value) => /^\\w*$/.test(value);\n\nvar compact = (value) => value.filter(Boolean);\n\nvar stringToPath = (input) => compact(input\r\n    .replace(/[\"|']/g, '')\r\n    .replace(/\\[/g, '.')\r\n    .replace(/\\]/g, '')\r\n    .split('.'));\n\nfunction set(object, path, value) {\r\n    let index = -1;\r\n    const tempPath = isKey(path) ? [path] : stringToPath(path);\r\n    const length = tempPath.length;\r\n    const lastIndex = length - 1;\r\n    while (++index < length) {\r\n        const key = tempPath[index];\r\n        let newValue = value;\r\n        if (index !== lastIndex) {\r\n            const objValue = object[key];\r\n            newValue =\r\n                isObject(objValue) || Array.isArray(objValue)\r\n                    ? objValue\r\n                    : !isNaN(+tempPath[index + 1])\r\n                        ? []\r\n                        : {};\r\n        }\r\n        object[key] = newValue;\r\n        object = object[key];\r\n    }\r\n    return object;\r\n}\n\nvar transformToNestObject = (data, value = {}) => {\r\n    for (const key in data) {\r\n        !isKey(key) ? set(value, key, data[key]) : (value[key] = data[key]);\r\n    }\r\n    return value;\r\n};\n\nvar isUndefined = (val) => val === undefined;\n\nvar get = (obj = {}, path, defaultValue) => {\r\n    const result = compact(path.split(/[,[\\].]+?/)).reduce((result, key) => (isNullOrUndefined(result) ? result : result[key]), obj);\r\n    return isUndefined(result) || result === obj\r\n        ? isUndefined(obj[path])\r\n            ? defaultValue\r\n            : obj[path]\r\n        : result;\r\n};\n\nvar focusOnErrorField = (fields, fieldErrors) => {\r\n    for (const key in fields) {\r\n        if (get(fieldErrors, key)) {\r\n            const field = fields[key];\r\n            if (field) {\r\n                if (field.ref.focus && isUndefined(field.ref.focus())) {\r\n                    break;\r\n                }\r\n                else if (field.options) {\r\n                    field.options[0].ref.focus();\r\n                    break;\r\n                }\r\n            }\r\n        }\r\n    }\r\n};\n\nvar removeAllEventListeners = (ref, validateWithStateUpdate) => {\r\n    if (isHTMLElement(ref) && ref.removeEventListener) {\r\n        ref.removeEventListener(EVENTS.INPUT, validateWithStateUpdate);\r\n        ref.removeEventListener(EVENTS.CHANGE, validateWithStateUpdate);\r\n        ref.removeEventListener(EVENTS.BLUR, validateWithStateUpdate);\r\n    }\r\n};\n\nconst defaultReturn = {\r\n    isValid: false,\r\n    value: null,\r\n};\r\nvar getRadioValue = (options) => Array.isArray(options)\r\n    ? options.reduce((previous, option) => option && option.ref.checked\r\n        ? {\r\n            isValid: true,\r\n            value: option.ref.value,\r\n        }\r\n        : previous, defaultReturn)\r\n    : defaultReturn;\n\nvar getMultipleSelectValue = (options) => [...options]\r\n    .filter(({ selected }) => selected)\r\n    .map(({ value }) => value);\n\nvar isRadioInput = (element) => element.type === 'radio';\n\nvar isFileInput = (element) => element.type === 'file';\n\nvar isCheckBoxInput = (element) => element.type === 'checkbox';\n\nvar isMultipleSelect = (element) => element.type === `${SELECT}-multiple`;\n\nconst defaultResult = {\r\n    value: false,\r\n    isValid: false,\r\n};\r\nconst validResult = { value: true, isValid: true };\r\nvar getCheckboxValue = (options) => {\r\n    if (Array.isArray(options)) {\r\n        if (options.length > 1) {\r\n            const values = options\r\n                .filter((option) => option && option.ref.checked)\r\n                .map(({ ref: { value } }) => value);\r\n            return { value: values, isValid: !!values.length };\r\n        }\r\n        const { checked, value, attributes } = options[0].ref;\r\n        return checked\r\n            ? attributes && !isUndefined(attributes.value)\r\n                ? isUndefined(value) || value === ''\r\n                    ? validResult\r\n                    : { value: value, isValid: true }\r\n                : validResult\r\n            : defaultResult;\r\n    }\r\n    return defaultResult;\r\n};\n\nfunction getFieldValue(fieldsRef, name, shallowFieldsStateRef, excludeDisabled, shouldKeepRawValue) {\r\n    const field = fieldsRef.current[name];\r\n    if (field) {\r\n        const { ref: { value, disabled }, ref, valueAsNumber, valueAsDate, setValueAs, } = field;\r\n        if (disabled && excludeDisabled) {\r\n            return;\r\n        }\r\n        if (isFileInput(ref)) {\r\n            return ref.files;\r\n        }\r\n        if (isRadioInput(ref)) {\r\n            return getRadioValue(field.options).value;\r\n        }\r\n        if (isMultipleSelect(ref)) {\r\n            return getMultipleSelectValue(ref.options);\r\n        }\r\n        if (isCheckBoxInput(ref)) {\r\n            return getCheckboxValue(field.options).value;\r\n        }\r\n        return shouldKeepRawValue\r\n            ? value\r\n            : valueAsNumber\r\n                ? value === ''\r\n                    ? NaN\r\n                    : +value\r\n                : valueAsDate\r\n                    ? ref.valueAsDate\r\n                    : setValueAs\r\n                        ? setValueAs(value)\r\n                        : value;\r\n    }\r\n    if (shallowFieldsStateRef) {\r\n        return get(shallowFieldsStateRef.current, name);\r\n    }\r\n}\n\nfunction isDetached(element) {\r\n    if (!element) {\r\n        return true;\r\n    }\r\n    if (!(element instanceof HTMLElement) ||\r\n        element.nodeType === Node.DOCUMENT_NODE) {\r\n        return false;\r\n    }\r\n    return isDetached(element.parentNode);\r\n}\n\nvar isEmptyObject = (value) => isObject(value) && !Object.keys(value).length;\n\nvar isBoolean = (value) => typeof value === 'boolean';\n\nfunction baseGet(object, updatePath) {\r\n    const length = updatePath.slice(0, -1).length;\r\n    let index = 0;\r\n    while (index < length) {\r\n        object = isUndefined(object) ? index++ : object[updatePath[index++]];\r\n    }\r\n    return object;\r\n}\r\nfunction unset(object, path) {\r\n    const updatePath = isKey(path) ? [path] : stringToPath(path);\r\n    const childObject = updatePath.length == 1 ? object : baseGet(object, updatePath);\r\n    const key = updatePath[updatePath.length - 1];\r\n    let previousObjRef;\r\n    if (childObject) {\r\n        delete childObject[key];\r\n    }\r\n    for (let k = 0; k < updatePath.slice(0, -1).length; k++) {\r\n        let index = -1;\r\n        let objectRef;\r\n        const currentPaths = updatePath.slice(0, -(k + 1));\r\n        const currentPathsLength = currentPaths.length - 1;\r\n        if (k > 0) {\r\n            previousObjRef = object;\r\n        }\r\n        while (++index < currentPaths.length) {\r\n            const item = currentPaths[index];\r\n            objectRef = objectRef ? objectRef[item] : object[item];\r\n            if (currentPathsLength === index &&\r\n                ((isObject(objectRef) && isEmptyObject(objectRef)) ||\r\n                    (Array.isArray(objectRef) &&\r\n                        !objectRef.filter((data) => (isObject(data) && !isEmptyObject(data)) || isBoolean(data)).length))) {\r\n                previousObjRef ? delete previousObjRef[item] : delete object[item];\r\n            }\r\n            previousObjRef = objectRef;\r\n        }\r\n    }\r\n    return object;\r\n}\n\nconst isSameRef = (fieldValue, ref) => fieldValue && fieldValue.ref === ref;\r\nfunction findRemovedFieldAndRemoveListener(fieldsRef, handleChange, field, shallowFieldsStateRef, shouldUnregister, forceDelete) {\r\n    const { ref, ref: { name }, } = field;\r\n    const fieldRef = fieldsRef.current[name];\r\n    if (!shouldUnregister) {\r\n        const value = getFieldValue(fieldsRef, name, shallowFieldsStateRef);\r\n        !isUndefined(value) && set(shallowFieldsStateRef.current, name, value);\r\n    }\r\n    if (!ref.type || !fieldRef) {\r\n        delete fieldsRef.current[name];\r\n        return;\r\n    }\r\n    if (isRadioInput(ref) || isCheckBoxInput(ref)) {\r\n        if (Array.isArray(fieldRef.options) && fieldRef.options.length) {\r\n            compact(fieldRef.options).forEach((option = {}, index) => {\r\n                if ((isDetached(option.ref) && isSameRef(option, option.ref)) ||\r\n                    forceDelete) {\r\n                    removeAllEventListeners(option.ref, handleChange);\r\n                    unset(fieldRef.options, `[${index}]`);\r\n                }\r\n            });\r\n            if (fieldRef.options && !compact(fieldRef.options).length) {\r\n                delete fieldsRef.current[name];\r\n            }\r\n        }\r\n        else {\r\n            delete fieldsRef.current[name];\r\n        }\r\n    }\r\n    else if ((isDetached(ref) && isSameRef(fieldRef, ref)) || forceDelete) {\r\n        removeAllEventListeners(ref, handleChange);\r\n        delete fieldsRef.current[name];\r\n    }\r\n}\n\nvar isPrimitive = (value) => isNullOrUndefined(value) || !isObjectType(value);\n\nfunction deepMerge(target, source) {\r\n    if (isPrimitive(target) || isPrimitive(source)) {\r\n        return source;\r\n    }\r\n    for (const key in source) {\r\n        const targetValue = target[key];\r\n        const sourceValue = source[key];\r\n        try {\r\n            target[key] =\r\n                (isObject(targetValue) && isObject(sourceValue)) ||\r\n                    (Array.isArray(targetValue) && Array.isArray(sourceValue))\r\n                    ? deepMerge(targetValue, sourceValue)\r\n                    : sourceValue;\r\n        }\r\n        catch (_a) { }\r\n    }\r\n    return target;\r\n}\n\nfunction deepEqual(object1, object2, isErrorObject) {\r\n    if (isPrimitive(object1) ||\r\n        isPrimitive(object2) ||\r\n        object1 instanceof Date ||\r\n        object2 instanceof Date) {\r\n        return object1 === object2;\r\n    }\r\n    if (!isValidElement(object1)) {\r\n        const keys1 = Object.keys(object1);\r\n        const keys2 = Object.keys(object2);\r\n        if (keys1.length !== keys2.length) {\r\n            return false;\r\n        }\r\n        for (const key of keys1) {\r\n            const val1 = object1[key];\r\n            if (!(isErrorObject && key === 'ref')) {\r\n                const val2 = object2[key];\r\n                if ((isObject(val1) || Array.isArray(val1)) &&\r\n                    (isObject(val2) || Array.isArray(val2))\r\n                    ? !deepEqual(val1, val2, isErrorObject)\r\n                    : val1 !== val2) {\r\n                    return false;\r\n                }\r\n            }\r\n        }\r\n    }\r\n    return true;\r\n}\n\nfunction setDirtyFields(values, defaultValues, dirtyFields, parentNode, parentName) {\r\n    let index = -1;\r\n    while (++index < values.length) {\r\n        for (const key in values[index]) {\r\n            if (Array.isArray(values[index][key])) {\r\n                !dirtyFields[index] && (dirtyFields[index] = {});\r\n                dirtyFields[index][key] = [];\r\n                setDirtyFields(values[index][key], get(defaultValues[index] || {}, key, []), dirtyFields[index][key], dirtyFields[index], key);\r\n            }\r\n            else {\r\n                deepEqual(get(defaultValues[index] || {}, key), values[index][key])\r\n                    ? set(dirtyFields[index] || {}, key)\r\n                    : (dirtyFields[index] = Object.assign(Object.assign({}, dirtyFields[index]), { [key]: true }));\r\n            }\r\n        }\r\n        parentNode &&\r\n            !dirtyFields.length &&\r\n            delete parentNode[parentName];\r\n    }\r\n    return dirtyFields;\r\n}\r\nvar setFieldArrayDirtyFields = (values, defaultValues, dirtyFields) => deepMerge(setDirtyFields(values, defaultValues, dirtyFields.slice(0, values.length)), setDirtyFields(defaultValues, values, dirtyFields.slice(0, values.length)));\n\nvar isString = (value) => typeof value === 'string';\n\nvar getFieldsValues = (fieldsRef, shallowFieldsState, shouldUnregister, excludeDisabled, search) => {\r\n    const output = {};\r\n    for (const name in fieldsRef.current) {\r\n        if (isUndefined(search) ||\r\n            (isString(search)\r\n                ? name.startsWith(search)\r\n                : Array.isArray(search) && search.find((data) => name.startsWith(data)))) {\r\n            output[name] = getFieldValue(fieldsRef, name, undefined, excludeDisabled);\r\n        }\r\n    }\r\n    return shouldUnregister\r\n        ? transformToNestObject(output)\r\n        : deepMerge(shallowFieldsState, transformToNestObject(output));\r\n};\n\nvar isErrorStateChanged = ({ errors, name, error, validFields, fieldsWithValidation, }) => {\r\n    const isValid = isUndefined(error);\r\n    const previousError = get(errors, name);\r\n    return ((isValid && !!previousError) ||\r\n        (!isValid && !deepEqual(previousError, error, true)) ||\r\n        (isValid && get(fieldsWithValidation, name) && !get(validFields, name)));\r\n};\n\nvar isRegex = (value) => value instanceof RegExp;\n\nvar getValueAndMessage = (validationData) => isObject(validationData) && !isRegex(validationData)\r\n    ? validationData\r\n    : {\r\n        value: validationData,\r\n        message: '',\r\n    };\n\nvar isFunction = (value) => typeof value === 'function';\n\nvar isMessage = (value) => isString(value) || isValidElement(value);\n\nfunction getValidateError(result, ref, type = 'validate') {\r\n    if (isMessage(result) || (isBoolean(result) && !result)) {\r\n        return {\r\n            type,\r\n            message: isMessage(result) ? result : '',\r\n            ref,\r\n        };\r\n    }\r\n}\n\nvar appendErrors = (name, validateAllFieldCriteria, errors, type, message) => validateAllFieldCriteria\r\n    ? Object.assign(Object.assign({}, errors[name]), { types: Object.assign(Object.assign({}, (errors[name] && errors[name].types ? errors[name].types : {})), { [type]: message || true }) }) : {};\n\nvar validateField = async (fieldsRef, validateAllFieldCriteria, { ref, ref: { value }, options, required, maxLength, minLength, min, max, pattern, validate, }, shallowFieldsStateRef) => {\r\n    const name = ref.name;\r\n    const error = {};\r\n    const isRadio = isRadioInput(ref);\r\n    const isCheckBox = isCheckBoxInput(ref);\r\n    const isRadioOrCheckbox = isRadio || isCheckBox;\r\n    const isEmpty = value === '';\r\n    const appendErrorsCurry = appendErrors.bind(null, name, validateAllFieldCriteria, error);\r\n    const getMinMaxMessage = (exceedMax, maxLengthMessage, minLengthMessage, maxType = INPUT_VALIDATION_RULES.maxLength, minType = INPUT_VALIDATION_RULES.minLength) => {\r\n        const message = exceedMax ? maxLengthMessage : minLengthMessage;\r\n        error[name] = Object.assign({ type: exceedMax ? maxType : minType, message,\r\n            ref }, (exceedMax\r\n            ? appendErrorsCurry(maxType, message)\r\n            : appendErrorsCurry(minType, message)));\r\n    };\r\n    if (required &&\r\n        ((!isRadio && !isCheckBox && (isEmpty || isNullOrUndefined(value))) ||\r\n            (isBoolean(value) && !value) ||\r\n            (isCheckBox && !getCheckboxValue(options).isValid) ||\r\n            (isRadio && !getRadioValue(options).isValid))) {\r\n        const { value, message } = isMessage(required)\r\n            ? { value: !!required, message: required }\r\n            : getValueAndMessage(required);\r\n        if (value) {\r\n            error[name] = Object.assign({ type: INPUT_VALIDATION_RULES.required, message, ref: isRadioOrCheckbox\r\n                    ? ((fieldsRef.current[name].options || [])[0] || {}).ref\r\n                    : ref }, appendErrorsCurry(INPUT_VALIDATION_RULES.required, message));\r\n            if (!validateAllFieldCriteria) {\r\n                return error;\r\n            }\r\n        }\r\n    }\r\n    if ((!isNullOrUndefined(min) || !isNullOrUndefined(max)) && value !== '') {\r\n        let exceedMax;\r\n        let exceedMin;\r\n        const maxOutput = getValueAndMessage(max);\r\n        const minOutput = getValueAndMessage(min);\r\n        if (!isNaN(value)) {\r\n            const valueNumber = ref.valueAsNumber || parseFloat(value);\r\n            if (!isNullOrUndefined(maxOutput.value)) {\r\n                exceedMax = valueNumber > maxOutput.value;\r\n            }\r\n            if (!isNullOrUndefined(minOutput.value)) {\r\n                exceedMin = valueNumber < minOutput.value;\r\n            }\r\n        }\r\n        else {\r\n            const valueDate = ref.valueAsDate || new Date(value);\r\n            if (isString(maxOutput.value)) {\r\n                exceedMax = valueDate > new Date(maxOutput.value);\r\n            }\r\n            if (isString(minOutput.value)) {\r\n                exceedMin = valueDate < new Date(minOutput.value);\r\n            }\r\n        }\r\n        if (exceedMax || exceedMin) {\r\n            getMinMaxMessage(!!exceedMax, maxOutput.message, minOutput.message, INPUT_VALIDATION_RULES.max, INPUT_VALIDATION_RULES.min);\r\n            if (!validateAllFieldCriteria) {\r\n                return error;\r\n            }\r\n        }\r\n    }\r\n    if (isString(value) && !isEmpty && (maxLength || minLength)) {\r\n        const maxLengthOutput = getValueAndMessage(maxLength);\r\n        const minLengthOutput = getValueAndMessage(minLength);\r\n        const exceedMax = !isNullOrUndefined(maxLengthOutput.value) &&\r\n            value.length > maxLengthOutput.value;\r\n        const exceedMin = !isNullOrUndefined(minLengthOutput.value) &&\r\n            value.length < minLengthOutput.value;\r\n        if (exceedMax || exceedMin) {\r\n            getMinMaxMessage(exceedMax, maxLengthOutput.message, minLengthOutput.message);\r\n            if (!validateAllFieldCriteria) {\r\n                return error;\r\n            }\r\n        }\r\n    }\r\n    if (isString(value) && pattern && !isEmpty) {\r\n        const { value: patternValue, message } = getValueAndMessage(pattern);\r\n        if (isRegex(patternValue) && !patternValue.test(value)) {\r\n            error[name] = Object.assign({ type: INPUT_VALIDATION_RULES.pattern, message,\r\n                ref }, appendErrorsCurry(INPUT_VALIDATION_RULES.pattern, message));\r\n            if (!validateAllFieldCriteria) {\r\n                return error;\r\n            }\r\n        }\r\n    }\r\n    if (validate) {\r\n        const fieldValue = getFieldValue(fieldsRef, name, shallowFieldsStateRef, false, true);\r\n        const validateRef = isRadioOrCheckbox && options ? options[0].ref : ref;\r\n        if (isFunction(validate)) {\r\n            const result = await validate(fieldValue);\r\n            const validateError = getValidateError(result, validateRef);\r\n            if (validateError) {\r\n                error[name] = Object.assign(Object.assign({}, validateError), appendErrorsCurry(INPUT_VALIDATION_RULES.validate, validateError.message));\r\n                if (!validateAllFieldCriteria) {\r\n                    return error;\r\n                }\r\n            }\r\n        }\r\n        else if (isObject(validate)) {\r\n            let validationResult = {};\r\n            for (const [key, validateFunction] of Object.entries(validate)) {\r\n                if (!isEmptyObject(validationResult) && !validateAllFieldCriteria) {\r\n                    break;\r\n                }\r\n                const validateResult = await validateFunction(fieldValue);\r\n                const validateError = getValidateError(validateResult, validateRef, key);\r\n                if (validateError) {\r\n                    validationResult = Object.assign(Object.assign({}, validateError), appendErrorsCurry(key, validateError.message));\r\n                    if (validateAllFieldCriteria) {\r\n                        error[name] = validationResult;\r\n                    }\r\n                }\r\n            }\r\n            if (!isEmptyObject(validationResult)) {\r\n                error[name] = Object.assign({ ref: validateRef }, validationResult);\r\n                if (!validateAllFieldCriteria) {\r\n                    return error;\r\n                }\r\n            }\r\n        }\r\n    }\r\n    return error;\r\n};\n\nconst getPath = (rootPath, values, paths = []) => {\r\n    for (const property in values) {\r\n        const rootName = (rootPath +\r\n            (isObject(values)\r\n                ? `.${property}`\r\n                : `[${property}]`));\r\n        isPrimitive(values[property])\r\n            ? paths.push(rootName)\r\n            : getPath(rootName, values[property], paths);\r\n    }\r\n    return paths;\r\n};\n\nvar assignWatchFields = (fieldValues, fieldName, watchFields, inputValue, isSingleField) => {\r\n    let value = undefined;\r\n    watchFields.add(fieldName);\r\n    if (!isEmptyObject(fieldValues)) {\r\n        value = get(fieldValues, fieldName);\r\n        if (isObject(value) || Array.isArray(value)) {\r\n            getPath(fieldName, value).forEach((name) => watchFields.add(name));\r\n        }\r\n    }\r\n    return isUndefined(value)\r\n        ? isSingleField\r\n            ? inputValue\r\n            : get(inputValue, fieldName)\r\n        : value;\r\n};\n\nvar skipValidation = ({ isOnBlur, isOnChange, isOnTouch, isTouched, isReValidateOnBlur, isReValidateOnChange, isBlurEvent, isSubmitted, isOnAll, }) => {\r\n    if (isOnAll) {\r\n        return false;\r\n    }\r\n    else if (!isSubmitted && isOnTouch) {\r\n        return !(isTouched || isBlurEvent);\r\n    }\r\n    else if (isSubmitted ? isReValidateOnBlur : isOnBlur) {\r\n        return !isBlurEvent;\r\n    }\r\n    else if (isSubmitted ? isReValidateOnChange : isOnChange) {\r\n        return isBlurEvent;\r\n    }\r\n    return true;\r\n};\n\nvar getFieldArrayParentName = (name) => name.substring(0, name.indexOf('['));\n\nconst isMatchFieldArrayName = (name, searchName) => RegExp(`^${searchName}([|.)\\\\d+`.replace(/\\[/g, '\\\\[').replace(/\\]/g, '\\\\]')).test(name);\r\nvar isNameInFieldArray = (names, name) => [...names].some((current) => isMatchFieldArrayName(name, current));\n\nvar isSelectInput = (element) => element.type === `${SELECT}-one`;\n\nfunction onDomRemove(fieldsRef, removeFieldEventListenerAndRef) {\r\n    const observer = new MutationObserver(() => {\r\n        for (const field of Object.values(fieldsRef.current)) {\r\n            if (field && field.options) {\r\n                for (const option of field.options) {\r\n                    if (option && option.ref && isDetached(option.ref)) {\r\n                        removeFieldEventListenerAndRef(field);\r\n                    }\r\n                }\r\n            }\r\n            else if (field && isDetached(field.ref)) {\r\n                removeFieldEventListenerAndRef(field);\r\n            }\r\n        }\r\n    });\r\n    observer.observe(window.document, {\r\n        childList: true,\r\n        subtree: true,\r\n    });\r\n    return observer;\r\n}\n\nvar isWeb = typeof window !== UNDEFINED && typeof document !== UNDEFINED;\n\nfunction cloneObject(data) {\r\n    var _a;\r\n    let copy;\r\n    if (isPrimitive(data) ||\r\n        (isWeb && (data instanceof File || isHTMLElement(data)))) {\r\n        return data;\r\n    }\r\n    if (!['Set', 'Map', 'Object', 'Date', 'Array'].includes((_a = data.constructor) === null || _a === void 0 ? void 0 : _a.name)) {\r\n        return data;\r\n    }\r\n    if (data instanceof Date) {\r\n        copy = new Date(data.getTime());\r\n        return copy;\r\n    }\r\n    if (data instanceof Set) {\r\n        copy = new Set();\r\n        for (const item of data) {\r\n            copy.add(item);\r\n        }\r\n        return copy;\r\n    }\r\n    if (data instanceof Map) {\r\n        copy = new Map();\r\n        for (const key of data.keys()) {\r\n            copy.set(key, cloneObject(data.get(key)));\r\n        }\r\n        return copy;\r\n    }\r\n    copy = Array.isArray(data) ? [] : {};\r\n    for (const key in data) {\r\n        copy[key] = cloneObject(data[key]);\r\n    }\r\n    return copy;\r\n}\n\nvar modeChecker = (mode) => ({\r\n    isOnSubmit: !mode || mode === VALIDATION_MODE.onSubmit,\r\n    isOnBlur: mode === VALIDATION_MODE.onBlur,\r\n    isOnChange: mode === VALIDATION_MODE.onChange,\r\n    isOnAll: mode === VALIDATION_MODE.all,\r\n    isOnTouch: mode === VALIDATION_MODE.onTouched,\r\n});\n\nvar isRadioOrCheckboxFunction = (ref) => isRadioInput(ref) || isCheckBoxInput(ref);\n\nconst isWindowUndefined = typeof window === UNDEFINED;\r\nconst isProxyEnabled = isWeb ? 'Proxy' in window : typeof Proxy !== UNDEFINED;\r\nfunction useForm({ mode = VALIDATION_MODE.onSubmit, reValidateMode = VALIDATION_MODE.onChange, resolver, context, defaultValues = {}, shouldFocusError = true, shouldUnregister = true, criteriaMode, } = {}) {\r\n    const fieldsRef = useRef({});\r\n    const fieldArrayDefaultValuesRef = useRef({});\r\n    const fieldArrayValuesRef = useRef({});\r\n    const watchFieldsRef = useRef(new Set());\r\n    const useWatchFieldsRef = useRef({});\r\n    const useWatchRenderFunctionsRef = useRef({});\r\n    const fieldsWithValidationRef = useRef({});\r\n    const validFieldsRef = useRef({});\r\n    const defaultValuesRef = useRef(defaultValues);\r\n    const isUnMount = useRef(false);\r\n    const isWatchAllRef = useRef(false);\r\n    const handleChangeRef = useRef();\r\n    const shallowFieldsStateRef = useRef({});\r\n    const resetFieldArrayFunctionRef = useRef({});\r\n    const contextRef = useRef(context);\r\n    const resolverRef = useRef(resolver);\r\n    const fieldArrayNamesRef = useRef(new Set());\r\n    const modeRef = useRef(modeChecker(mode));\r\n    const { isOnSubmit, isOnTouch } = modeRef.current;\r\n    const isValidateAllFieldCriteria = criteriaMode === VALIDATION_MODE.all;\r\n    const [formState, setFormState] = useState({\r\n        isDirty: false,\r\n        isValidating: false,\r\n        dirtyFields: {},\r\n        isSubmitted: false,\r\n        submitCount: 0,\r\n        touched: {},\r\n        isSubmitting: false,\r\n        isSubmitSuccessful: false,\r\n        isValid: !isOnSubmit,\r\n        errors: {},\r\n    });\r\n    const readFormStateRef = useRef({\r\n        isDirty: !isProxyEnabled,\r\n        dirtyFields: !isProxyEnabled,\r\n        touched: !isProxyEnabled || isOnTouch,\r\n        isValidating: !isProxyEnabled,\r\n        isSubmitting: !isProxyEnabled,\r\n        isValid: !isProxyEnabled,\r\n    });\r\n    const formStateRef = useRef(formState);\r\n    const observerRef = useRef();\r\n    const { isOnBlur: isReValidateOnBlur, isOnChange: isReValidateOnChange, } = useRef(modeChecker(reValidateMode)).current;\r\n    contextRef.current = context;\r\n    resolverRef.current = resolver;\r\n    formStateRef.current = formState;\r\n    shallowFieldsStateRef.current = shouldUnregister\r\n        ? {}\r\n        : isEmptyObject(shallowFieldsStateRef.current)\r\n            ? cloneObject(defaultValues)\r\n            : shallowFieldsStateRef.current;\r\n    const updateFormState = useCallback((state = {}) => {\r\n        if (!isUnMount.current) {\r\n            formStateRef.current = Object.assign(Object.assign({}, formStateRef.current), state);\r\n            setFormState(formStateRef.current);\r\n        }\r\n    }, []);\r\n    const updateIsValidating = () => readFormStateRef.current.isValidating &&\r\n        updateFormState({\r\n            isValidating: true,\r\n        });\r\n    const shouldRenderBaseOnError = useCallback((name, error, shouldRender = false, state = {}, isValid) => {\r\n        let shouldReRender = shouldRender ||\r\n            isErrorStateChanged({\r\n                errors: formStateRef.current.errors,\r\n                error,\r\n                name,\r\n                validFields: validFieldsRef.current,\r\n                fieldsWithValidation: fieldsWithValidationRef.current,\r\n            });\r\n        const previousError = get(formStateRef.current.errors, name);\r\n        if (error) {\r\n            unset(validFieldsRef.current, name);\r\n            shouldReRender =\r\n                shouldReRender ||\r\n                    !previousError ||\r\n                    !deepEqual(previousError, error, true);\r\n            set(formStateRef.current.errors, name, error);\r\n        }\r\n        else {\r\n            if (get(fieldsWithValidationRef.current, name) || resolverRef.current) {\r\n                set(validFieldsRef.current, name, true);\r\n                shouldReRender = shouldReRender || previousError;\r\n            }\r\n            unset(formStateRef.current.errors, name);\r\n        }\r\n        if ((shouldReRender && !isNullOrUndefined(shouldRender)) ||\r\n            !isEmptyObject(state) ||\r\n            readFormStateRef.current.isValidating) {\r\n            updateFormState(Object.assign(Object.assign(Object.assign({}, state), (resolverRef.current ? { isValid: !!isValid } : {})), { isValidating: false }));\r\n        }\r\n    }, []);\r\n    const setFieldValue = useCallback((name, rawValue) => {\r\n        const { ref, options } = fieldsRef.current[name];\r\n        const value = isWeb && isHTMLElement(ref) && isNullOrUndefined(rawValue)\r\n            ? ''\r\n            : rawValue;\r\n        if (isRadioInput(ref)) {\r\n            (options || []).forEach(({ ref: radioRef }) => (radioRef.checked = radioRef.value === value));\r\n        }\r\n        else if (isFileInput(ref) && !isString(value)) {\r\n            ref.files = value;\r\n        }\r\n        else if (isMultipleSelect(ref)) {\r\n            [...ref.options].forEach((selectRef) => (selectRef.selected = value.includes(selectRef.value)));\r\n        }\r\n        else if (isCheckBoxInput(ref) && options) {\r\n            options.length > 1\r\n                ? options.forEach(({ ref: checkboxRef }) => (checkboxRef.checked = Array.isArray(value)\r\n                    ? !!value.find((data) => data === checkboxRef.value)\r\n                    : value === checkboxRef.value))\r\n                : (options[0].ref.checked = !!value);\r\n        }\r\n        else {\r\n            ref.value = value;\r\n        }\r\n    }, []);\r\n    const isFormDirty = useCallback((name, data) => {\r\n        if (readFormStateRef.current.isDirty) {\r\n            const formValues = getValues();\r\n            name && data && set(formValues, name, data);\r\n            return !deepEqual(formValues, defaultValuesRef.current);\r\n        }\r\n        return false;\r\n    }, []);\r\n    const updateAndGetDirtyState = useCallback((name, shouldRender = true) => {\r\n        if (readFormStateRef.current.isDirty ||\r\n            readFormStateRef.current.dirtyFields) {\r\n            const isFieldDirty = !deepEqual(get(defaultValuesRef.current, name), getFieldValue(fieldsRef, name, shallowFieldsStateRef));\r\n            const isDirtyFieldExist = get(formStateRef.current.dirtyFields, name);\r\n            const previousIsDirty = formStateRef.current.isDirty;\r\n            isFieldDirty\r\n                ? set(formStateRef.current.dirtyFields, name, true)\r\n                : unset(formStateRef.current.dirtyFields, name);\r\n            const state = {\r\n                isDirty: isFormDirty(),\r\n                dirtyFields: formStateRef.current.dirtyFields,\r\n            };\r\n            const isChanged = (readFormStateRef.current.isDirty &&\r\n                previousIsDirty !== state.isDirty) ||\r\n                (readFormStateRef.current.dirtyFields &&\r\n                    isDirtyFieldExist !== get(formStateRef.current.dirtyFields, name));\r\n            isChanged && shouldRender && updateFormState(state);\r\n            return isChanged ? state : {};\r\n        }\r\n        return {};\r\n    }, []);\r\n    const executeValidation = useCallback(async (name, skipReRender) => {\r\n        if (process.env.NODE_ENV !== 'production') {\r\n            if (!fieldsRef.current[name]) {\r\n                console.warn('📋 Field is missing with `name` attribute: ', name);\r\n                return false;\r\n            }\r\n        }\r\n        const error = (await validateField(fieldsRef, isValidateAllFieldCriteria, fieldsRef.current[name], shallowFieldsStateRef))[name];\r\n        shouldRenderBaseOnError(name, error, skipReRender);\r\n        return isUndefined(error);\r\n    }, [shouldRenderBaseOnError, isValidateAllFieldCriteria]);\r\n    const executeSchemaOrResolverValidation = useCallback(async (names) => {\r\n        const { errors } = await resolverRef.current(getValues(), contextRef.current, isValidateAllFieldCriteria);\r\n        const previousFormIsValid = formStateRef.current.isValid;\r\n        if (Array.isArray(names)) {\r\n            const isInputsValid = names\r\n                .map((name) => {\r\n                const error = get(errors, name);\r\n                error\r\n                    ? set(formStateRef.current.errors, name, error)\r\n                    : unset(formStateRef.current.errors, name);\r\n                return !error;\r\n            })\r\n                .every(Boolean);\r\n            updateFormState({\r\n                isValid: isEmptyObject(errors),\r\n                isValidating: false,\r\n            });\r\n            return isInputsValid;\r\n        }\r\n        else {\r\n            const error = get(errors, names);\r\n            shouldRenderBaseOnError(names, error, previousFormIsValid !== isEmptyObject(errors), {}, isEmptyObject(errors));\r\n            return !error;\r\n        }\r\n    }, [shouldRenderBaseOnError, isValidateAllFieldCriteria]);\r\n    const trigger = useCallback(async (name) => {\r\n        const fields = name || Object.keys(fieldsRef.current);\r\n        updateIsValidating();\r\n        if (resolverRef.current) {\r\n            return executeSchemaOrResolverValidation(fields);\r\n        }\r\n        if (Array.isArray(fields)) {\r\n            !name && (formStateRef.current.errors = {});\r\n            const result = await Promise.all(fields.map(async (data) => await executeValidation(data, null)));\r\n            updateFormState({\r\n                isValidating: false,\r\n            });\r\n            return result.every(Boolean);\r\n        }\r\n        return await executeValidation(fields);\r\n    }, [executeSchemaOrResolverValidation, executeValidation]);\r\n    const setInternalValues = useCallback((name, value, { shouldDirty, shouldValidate }) => {\r\n        const data = {};\r\n        set(data, name, value);\r\n        for (const fieldName of getPath(name, value)) {\r\n            if (fieldsRef.current[fieldName]) {\r\n                setFieldValue(fieldName, get(data, fieldName));\r\n                shouldDirty && updateAndGetDirtyState(fieldName);\r\n                shouldValidate && trigger(fieldName);\r\n            }\r\n        }\r\n    }, [trigger, setFieldValue, updateAndGetDirtyState]);\r\n    const setInternalValue = useCallback((name, value, config) => {\r\n        !shouldUnregister &&\r\n            !isPrimitive(value) &&\r\n            set(shallowFieldsStateRef.current, name, Array.isArray(value) ? [...value] : Object.assign({}, value));\r\n        if (fieldsRef.current[name]) {\r\n            setFieldValue(name, value);\r\n            config.shouldDirty && updateAndGetDirtyState(name);\r\n            config.shouldValidate && trigger(name);\r\n        }\r\n        else if (!isPrimitive(value)) {\r\n            setInternalValues(name, value, config);\r\n            if (fieldArrayNamesRef.current.has(name)) {\r\n                const parentName = getFieldArrayParentName(name) || name;\r\n                set(fieldArrayDefaultValuesRef.current, name, value);\r\n                resetFieldArrayFunctionRef.current[parentName]({\r\n                    [parentName]: get(fieldArrayDefaultValuesRef.current, parentName),\r\n                });\r\n                if ((readFormStateRef.current.isDirty ||\r\n                    readFormStateRef.current.dirtyFields) &&\r\n                    config.shouldDirty) {\r\n                    set(formStateRef.current.dirtyFields, name, setFieldArrayDirtyFields(value, get(defaultValuesRef.current, name, []), get(formStateRef.current.dirtyFields, name, [])));\r\n                    updateFormState({\r\n                        isDirty: !deepEqual(Object.assign(Object.assign({}, getValues()), { [name]: value }), defaultValuesRef.current),\r\n                    });\r\n                }\r\n            }\r\n        }\r\n        !shouldUnregister && set(shallowFieldsStateRef.current, name, value);\r\n    }, [updateAndGetDirtyState, setFieldValue, setInternalValues]);\r\n    const isFieldWatched = (name) => isWatchAllRef.current ||\r\n        watchFieldsRef.current.has(name) ||\r\n        watchFieldsRef.current.has((name.match(/\\w+/) || [])[0]);\r\n    const renderWatchedInputs = (name) => {\r\n        let found = true;\r\n        if (!isEmptyObject(useWatchFieldsRef.current)) {\r\n            for (const key in useWatchFieldsRef.current) {\r\n                if (!name ||\r\n                    !useWatchFieldsRef.current[key].size ||\r\n                    useWatchFieldsRef.current[key].has(name) ||\r\n                    useWatchFieldsRef.current[key].has(getFieldArrayParentName(name))) {\r\n                    useWatchRenderFunctionsRef.current[key]();\r\n                    found = false;\r\n                }\r\n            }\r\n        }\r\n        return found;\r\n    };\r\n    function setValue(name, value, config) {\r\n        setInternalValue(name, value, config || {});\r\n        isFieldWatched(name) && updateFormState();\r\n        renderWatchedInputs(name);\r\n    }\r\n    handleChangeRef.current = handleChangeRef.current\r\n        ? handleChangeRef.current\r\n        : async ({ type, target }) => {\r\n            let name = target.name;\r\n            const field = fieldsRef.current[name];\r\n            let error;\r\n            let isValid;\r\n            if (field) {\r\n                const isBlurEvent = type === EVENTS.BLUR;\r\n                const shouldSkipValidation = skipValidation(Object.assign({ isBlurEvent,\r\n                    isReValidateOnChange,\r\n                    isReValidateOnBlur, isTouched: !!get(formStateRef.current.touched, name), isSubmitted: formStateRef.current.isSubmitted }, modeRef.current));\r\n                let state = updateAndGetDirtyState(name, false);\r\n                let shouldRender = !isEmptyObject(state) ||\r\n                    (!isBlurEvent && isFieldWatched(name));\r\n                if (isBlurEvent &&\r\n                    !get(formStateRef.current.touched, name) &&\r\n                    readFormStateRef.current.touched) {\r\n                    set(formStateRef.current.touched, name, true);\r\n                    state = Object.assign(Object.assign({}, state), { touched: formStateRef.current.touched });\r\n                }\r\n                if (!shouldUnregister && isCheckBoxInput(target)) {\r\n                    set(shallowFieldsStateRef.current, name, getFieldValue(fieldsRef, name));\r\n                }\r\n                if (shouldSkipValidation) {\r\n                    !isBlurEvent && renderWatchedInputs(name);\r\n                    return ((!isEmptyObject(state) ||\r\n                        (shouldRender && isEmptyObject(state))) &&\r\n                        updateFormState(state));\r\n                }\r\n                updateIsValidating();\r\n                if (resolverRef.current) {\r\n                    const { errors } = await resolverRef.current(getValues(), contextRef.current, isValidateAllFieldCriteria);\r\n                    const previousFormIsValid = formStateRef.current.isValid;\r\n                    error = get(errors, name);\r\n                    if (isCheckBoxInput(target) &&\r\n                        !error &&\r\n                        resolverRef.current) {\r\n                        const parentNodeName = getFieldArrayParentName(name);\r\n                        const currentError = get(errors, parentNodeName, {});\r\n                        currentError.type &&\r\n                            currentError.message &&\r\n                            (error = currentError);\r\n                        if (parentNodeName &&\r\n                            (currentError ||\r\n                                get(formStateRef.current.errors, parentNodeName))) {\r\n                            name = parentNodeName;\r\n                        }\r\n                    }\r\n                    isValid = isEmptyObject(errors);\r\n                    previousFormIsValid !== isValid && (shouldRender = true);\r\n                }\r\n                else {\r\n                    error = (await validateField(fieldsRef, isValidateAllFieldCriteria, field, shallowFieldsStateRef))[name];\r\n                }\r\n                !isBlurEvent && renderWatchedInputs(name);\r\n                shouldRenderBaseOnError(name, error, shouldRender, state, isValid);\r\n            }\r\n        };\r\n    function setFieldArrayDefaultValues(data) {\r\n        if (!shouldUnregister) {\r\n            let copy = cloneObject(data);\r\n            for (const value of fieldArrayNamesRef.current) {\r\n                if (isKey(value) && !copy[value]) {\r\n                    copy = Object.assign(Object.assign({}, copy), { [value]: [] });\r\n                }\r\n            }\r\n            return copy;\r\n        }\r\n        return data;\r\n    }\r\n    function getValues(payload) {\r\n        if (isString(payload)) {\r\n            return getFieldValue(fieldsRef, payload, shallowFieldsStateRef);\r\n        }\r\n        if (Array.isArray(payload)) {\r\n            const data = {};\r\n            for (const name of payload) {\r\n                set(data, name, getFieldValue(fieldsRef, name, shallowFieldsStateRef));\r\n            }\r\n            return data;\r\n        }\r\n        return setFieldArrayDefaultValues(getFieldsValues(fieldsRef, cloneObject(shallowFieldsStateRef.current), shouldUnregister));\r\n    }\r\n    const validateResolver = useCallback(async (values = {}) => {\r\n        const newDefaultValues = isEmptyObject(fieldsRef.current)\r\n            ? defaultValuesRef.current\r\n            : {};\r\n        const { errors } = (await resolverRef.current(Object.assign(Object.assign(Object.assign({}, newDefaultValues), getValues()), values), contextRef.current, isValidateAllFieldCriteria)) || {};\r\n        const isValid = isEmptyObject(errors);\r\n        formStateRef.current.isValid !== isValid &&\r\n            updateFormState({\r\n                isValid,\r\n            });\r\n    }, [isValidateAllFieldCriteria]);\r\n    const removeFieldEventListener = useCallback((field, forceDelete) => {\r\n        findRemovedFieldAndRemoveListener(fieldsRef, handleChangeRef.current, field, shallowFieldsStateRef, shouldUnregister, forceDelete);\r\n        if (shouldUnregister) {\r\n            unset(validFieldsRef.current, field.ref.name);\r\n            unset(fieldsWithValidationRef.current, field.ref.name);\r\n        }\r\n    }, [shouldUnregister]);\r\n    const updateWatchedValue = useCallback((name) => {\r\n        if (isWatchAllRef.current) {\r\n            updateFormState();\r\n        }\r\n        else {\r\n            for (const watchField of watchFieldsRef.current) {\r\n                if (watchField.startsWith(name)) {\r\n                    updateFormState();\r\n                    break;\r\n                }\r\n            }\r\n            renderWatchedInputs(name);\r\n        }\r\n    }, []);\r\n    const removeFieldEventListenerAndRef = useCallback((field, forceDelete) => {\r\n        if (field) {\r\n            removeFieldEventListener(field, forceDelete);\r\n            if (shouldUnregister && !compact(field.options || []).length) {\r\n                unset(formStateRef.current.errors, field.ref.name);\r\n                set(formStateRef.current.dirtyFields, field.ref.name, true);\r\n                updateFormState({\r\n                    isDirty: isFormDirty(),\r\n                });\r\n                readFormStateRef.current.isValid &&\r\n                    resolverRef.current &&\r\n                    validateResolver();\r\n                updateWatchedValue(field.ref.name);\r\n            }\r\n        }\r\n    }, [validateResolver, removeFieldEventListener]);\r\n    function clearErrors(name) {\r\n        name &&\r\n            (Array.isArray(name) ? name : [name]).forEach((inputName) => fieldsRef.current[inputName] && isKey(inputName)\r\n                ? delete formStateRef.current.errors[inputName]\r\n                : unset(formStateRef.current.errors, inputName));\r\n        updateFormState({\r\n            errors: name ? formStateRef.current.errors : {},\r\n        });\r\n    }\r\n    function setError(name, error) {\r\n        const ref = (fieldsRef.current[name] || {}).ref;\r\n        set(formStateRef.current.errors, name, Object.assign(Object.assign({}, error), { ref }));\r\n        updateFormState({\r\n            isValid: false,\r\n        });\r\n        error.shouldFocus && ref && ref.focus && ref.focus();\r\n    }\r\n    const watchInternal = useCallback((fieldNames, defaultValue, watchId) => {\r\n        const watchFields = watchId\r\n            ? useWatchFieldsRef.current[watchId]\r\n            : watchFieldsRef.current;\r\n        let fieldValues = getFieldsValues(fieldsRef, cloneObject(shallowFieldsStateRef.current), shouldUnregister, false, fieldNames);\r\n        if (isString(fieldNames)) {\r\n            const parentNodeName = getFieldArrayParentName(fieldNames) || fieldNames;\r\n            if (fieldArrayNamesRef.current.has(parentNodeName)) {\r\n                fieldValues = Object.assign(Object.assign({}, fieldArrayValuesRef.current), fieldValues);\r\n            }\r\n            return assignWatchFields(fieldValues, fieldNames, watchFields, isUndefined(get(defaultValuesRef.current, fieldNames))\r\n                ? defaultValue\r\n                : get(defaultValuesRef.current, fieldNames), true);\r\n        }\r\n        const combinedDefaultValues = isUndefined(defaultValue)\r\n            ? defaultValuesRef.current\r\n            : defaultValue;\r\n        if (Array.isArray(fieldNames)) {\r\n            return fieldNames.reduce((previous, name) => (Object.assign(Object.assign({}, previous), { [name]: assignWatchFields(fieldValues, name, watchFields, combinedDefaultValues) })), {});\r\n        }\r\n        isWatchAllRef.current = isUndefined(watchId);\r\n        return transformToNestObject((!isEmptyObject(fieldValues) && fieldValues) ||\r\n            combinedDefaultValues);\r\n    }, []);\r\n    function watch(fieldNames, defaultValue) {\r\n        return watchInternal(fieldNames, defaultValue);\r\n    }\r\n    function unregister(name) {\r\n        for (const fieldName of Array.isArray(name) ? name : [name]) {\r\n            removeFieldEventListenerAndRef(fieldsRef.current[fieldName], true);\r\n        }\r\n    }\r\n    function registerFieldRef(ref, options = {}) {\r\n        if (process.env.NODE_ENV !== 'production') {\r\n            if (!ref.name) {\r\n                return console.warn('📋 Field is missing `name` attribute', ref, `https://react-hook-form.com/api#useForm`);\r\n            }\r\n            if (fieldArrayNamesRef.current.has(ref.name.split(/\\[\\d+\\]$/)[0]) &&\r\n                !RegExp(`^${ref.name.split(/\\[\\d+\\]$/)[0]}[\\\\d+].\\\\w+`\r\n                    .replace(/\\[/g, '\\\\[')\r\n                    .replace(/\\]/g, '\\\\]')).test(ref.name)) {\r\n                return console.warn('📋 `name` prop should be in object shape: name=\"test[index].name\"', ref, 'https://react-hook-form.com/api#useFieldArray');\r\n            }\r\n        }\r\n        const { name, type, value } = ref;\r\n        const fieldRefAndValidationOptions = Object.assign({ ref }, options);\r\n        const fields = fieldsRef.current;\r\n        const isRadioOrCheckbox = isRadioOrCheckboxFunction(ref);\r\n        const isFieldArray = isNameInFieldArray(fieldArrayNamesRef.current, name);\r\n        const compareRef = (currentRef) => isWeb && (!isHTMLElement(ref) || currentRef === ref);\r\n        let field = fields[name];\r\n        let isEmptyDefaultValue = true;\r\n        let defaultValue;\r\n        if (field &&\r\n            (isRadioOrCheckbox\r\n                ? Array.isArray(field.options) &&\r\n                    compact(field.options).find((option) => {\r\n                        return value === option.ref.value && compareRef(option.ref);\r\n                    })\r\n                : compareRef(field.ref))) {\r\n            fields[name] = Object.assign(Object.assign({}, field), options);\r\n            return;\r\n        }\r\n        if (type) {\r\n            field = isRadioOrCheckbox\r\n                ? Object.assign({ options: [\r\n                        ...compact((field && field.options) || []),\r\n                        {\r\n                            ref,\r\n                        },\r\n                    ], ref: { type, name } }, options) : Object.assign({}, fieldRefAndValidationOptions);\r\n        }\r\n        else {\r\n            field = fieldRefAndValidationOptions;\r\n        }\r\n        fields[name] = field;\r\n        const isEmptyUnmountFields = isUndefined(get(shallowFieldsStateRef.current, name));\r\n        if (!isEmptyObject(defaultValuesRef.current) || !isEmptyUnmountFields) {\r\n            defaultValue = get(isEmptyUnmountFields\r\n                ? defaultValuesRef.current\r\n                : shallowFieldsStateRef.current, name);\r\n            isEmptyDefaultValue = isUndefined(defaultValue);\r\n            if (!isEmptyDefaultValue && !isFieldArray) {\r\n                setFieldValue(name, defaultValue);\r\n            }\r\n        }\r\n        if (!isEmptyObject(options)) {\r\n            set(fieldsWithValidationRef.current, name, true);\r\n            if (!isOnSubmit && readFormStateRef.current.isValid) {\r\n                validateField(fieldsRef, isValidateAllFieldCriteria, field, shallowFieldsStateRef).then((error) => {\r\n                    const previousFormIsValid = formStateRef.current.isValid;\r\n                    isEmptyObject(error)\r\n                        ? set(validFieldsRef.current, name, true)\r\n                        : unset(validFieldsRef.current, name);\r\n                    previousFormIsValid !== isEmptyObject(error) && updateFormState();\r\n                });\r\n            }\r\n        }\r\n        if (shouldUnregister && !(isFieldArray && isEmptyDefaultValue)) {\r\n            !isFieldArray && unset(formStateRef.current.dirtyFields, name);\r\n        }\r\n        if (type) {\r\n            attachEventListeners(isRadioOrCheckbox && field.options\r\n                ? field.options[field.options.length - 1]\r\n                : field, isRadioOrCheckbox || isSelectInput(ref), handleChangeRef.current);\r\n        }\r\n    }\r\n    function register(refOrRegisterOptions, options) {\r\n        if (!isWindowUndefined) {\r\n            if (isString(refOrRegisterOptions)) {\r\n                registerFieldRef({ name: refOrRegisterOptions }, options);\r\n            }\r\n            else if (isObject(refOrRegisterOptions) &&\r\n                'name' in refOrRegisterOptions) {\r\n                registerFieldRef(refOrRegisterOptions, options);\r\n            }\r\n            else {\r\n                return (ref) => ref && registerFieldRef(ref, refOrRegisterOptions);\r\n            }\r\n        }\r\n    }\r\n    const handleSubmit = useCallback((onValid, onInvalid) => async (e) => {\r\n        if (e && e.preventDefault) {\r\n            e.preventDefault();\r\n            e.persist();\r\n        }\r\n        let fieldErrors = {};\r\n        let fieldValues = setFieldArrayDefaultValues(getFieldsValues(fieldsRef, cloneObject(shallowFieldsStateRef.current), shouldUnregister, true));\r\n        readFormStateRef.current.isSubmitting &&\r\n            updateFormState({\r\n                isSubmitting: true,\r\n            });\r\n        try {\r\n            if (resolverRef.current) {\r\n                const { errors, values } = await resolverRef.current(fieldValues, contextRef.current, isValidateAllFieldCriteria);\r\n                formStateRef.current.errors = fieldErrors = errors;\r\n                fieldValues = values;\r\n            }\r\n            else {\r\n                for (const field of Object.values(fieldsRef.current)) {\r\n                    if (field) {\r\n                        const { name } = field.ref;\r\n                        const fieldError = await validateField(fieldsRef, isValidateAllFieldCriteria, field, shallowFieldsStateRef);\r\n                        if (fieldError[name]) {\r\n                            set(fieldErrors, name, fieldError[name]);\r\n                            unset(validFieldsRef.current, name);\r\n                        }\r\n                        else if (get(fieldsWithValidationRef.current, name)) {\r\n                            unset(formStateRef.current.errors, name);\r\n                            set(validFieldsRef.current, name, true);\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n            if (isEmptyObject(fieldErrors) &&\r\n                Object.keys(formStateRef.current.errors).every((name) => name in fieldsRef.current)) {\r\n                updateFormState({\r\n                    errors: {},\r\n                    isSubmitting: true,\r\n                });\r\n                await onValid(fieldValues, e);\r\n            }\r\n            else {\r\n                formStateRef.current.errors = Object.assign(Object.assign({}, formStateRef.current.errors), fieldErrors);\r\n                onInvalid && (await onInvalid(formStateRef.current.errors, e));\r\n                shouldFocusError &&\r\n                    focusOnErrorField(fieldsRef.current, formStateRef.current.errors);\r\n            }\r\n        }\r\n        finally {\r\n            formStateRef.current.isSubmitting = false;\r\n            updateFormState({\r\n                isSubmitted: true,\r\n                isSubmitting: false,\r\n                isSubmitSuccessful: isEmptyObject(formStateRef.current.errors),\r\n                submitCount: formStateRef.current.submitCount + 1,\r\n            });\r\n        }\r\n    }, [shouldFocusError, isValidateAllFieldCriteria]);\r\n    const resetRefs = ({ errors, isDirty, isSubmitted, touched, isValid, submitCount, dirtyFields, }) => {\r\n        if (!isValid) {\r\n            validFieldsRef.current = {};\r\n            fieldsWithValidationRef.current = {};\r\n        }\r\n        fieldArrayDefaultValuesRef.current = {};\r\n        watchFieldsRef.current = new Set();\r\n        isWatchAllRef.current = false;\r\n        updateFormState({\r\n            submitCount: submitCount ? formStateRef.current.submitCount : 0,\r\n            isDirty: isDirty ? formStateRef.current.isDirty : false,\r\n            isSubmitted: isSubmitted ? formStateRef.current.isSubmitted : false,\r\n            isValid: isValid ? formStateRef.current.isValid : false,\r\n            dirtyFields: dirtyFields ? formStateRef.current.dirtyFields : {},\r\n            touched: touched ? formStateRef.current.touched : {},\r\n            errors: errors ? formStateRef.current.errors : {},\r\n            isSubmitting: false,\r\n            isSubmitSuccessful: false,\r\n        });\r\n    };\r\n    const reset = (values, omitResetState = {}) => {\r\n        if (isWeb) {\r\n            for (const field of Object.values(fieldsRef.current)) {\r\n                if (field) {\r\n                    const { ref, options } = field;\r\n                    const inputRef = isRadioOrCheckboxFunction(ref) && Array.isArray(options)\r\n                        ? options[0].ref\r\n                        : ref;\r\n                    if (isHTMLElement(inputRef)) {\r\n                        try {\r\n                            inputRef.closest('form').reset();\r\n                            break;\r\n                        }\r\n                        catch (_a) { }\r\n                    }\r\n                }\r\n            }\r\n        }\r\n        fieldsRef.current = {};\r\n        defaultValuesRef.current = Object.assign({}, (values || defaultValuesRef.current));\r\n        values && renderWatchedInputs('');\r\n        Object.values(resetFieldArrayFunctionRef.current).forEach((resetFieldArray) => isFunction(resetFieldArray) && resetFieldArray());\r\n        shallowFieldsStateRef.current = shouldUnregister\r\n            ? {}\r\n            : cloneObject(values || defaultValuesRef.current);\r\n        resetRefs(omitResetState);\r\n    };\r\n    useEffect(() => {\r\n        resolver && readFormStateRef.current.isValid && validateResolver();\r\n        observerRef.current =\r\n            observerRef.current || !isWeb\r\n                ? observerRef.current\r\n                : onDomRemove(fieldsRef, removeFieldEventListenerAndRef);\r\n    }, [removeFieldEventListenerAndRef, defaultValuesRef.current]);\r\n    useEffect(() => () => {\r\n        observerRef.current && observerRef.current.disconnect();\r\n        isUnMount.current = true;\r\n        if (process.env.NODE_ENV !== 'production') {\r\n            return;\r\n        }\r\n        Object.values(fieldsRef.current).forEach((field) => removeFieldEventListenerAndRef(field, true));\r\n    }, []);\r\n    if (!resolver && readFormStateRef.current.isValid) {\r\n        formState.isValid =\r\n            deepEqual(validFieldsRef.current, fieldsWithValidationRef.current) &&\r\n                isEmptyObject(formStateRef.current.errors);\r\n    }\r\n    const commonProps = {\r\n        trigger,\r\n        setValue: useCallback(setValue, [setInternalValue, trigger]),\r\n        getValues: useCallback(getValues, []),\r\n        register: useCallback(register, [defaultValuesRef.current]),\r\n        unregister: useCallback(unregister, []),\r\n        formState: isProxyEnabled\r\n            ? new Proxy(formState, {\r\n                get: (obj, prop) => {\r\n                    if (process.env.NODE_ENV !== 'production') {\r\n                        if (prop === 'isValid' && isOnSubmit) {\r\n                            console.warn('📋 `formState.isValid` is applicable with `onTouched`, `onChange` or `onBlur` mode. https://react-hook-form.com/api#formState');\r\n                        }\r\n                    }\r\n                    if (prop in obj) {\r\n                        readFormStateRef.current[prop] = true;\r\n                        return obj[prop];\r\n                    }\r\n                    return undefined;\r\n                },\r\n            })\r\n            : formState,\r\n    };\r\n    const control = useMemo(() => (Object.assign({ isFormDirty,\r\n        updateWatchedValue,\r\n        shouldUnregister,\r\n        updateFormState,\r\n        removeFieldEventListener,\r\n        watchInternal, mode: modeRef.current, reValidateMode: {\r\n            isReValidateOnBlur,\r\n            isReValidateOnChange,\r\n        }, validateResolver: resolver ? validateResolver : undefined, fieldsRef,\r\n        resetFieldArrayFunctionRef,\r\n        useWatchFieldsRef,\r\n        useWatchRenderFunctionsRef,\r\n        fieldArrayDefaultValuesRef,\r\n        validFieldsRef,\r\n        fieldsWithValidationRef,\r\n        fieldArrayNamesRef,\r\n        readFormStateRef,\r\n        formStateRef,\r\n        defaultValuesRef,\r\n        shallowFieldsStateRef,\r\n        fieldArrayValuesRef }, commonProps)), [\r\n        defaultValuesRef.current,\r\n        updateWatchedValue,\r\n        shouldUnregister,\r\n        removeFieldEventListener,\r\n        watchInternal,\r\n    ]);\r\n    return Object.assign({ watch,\r\n        control,\r\n        handleSubmit, reset: useCallback(reset, []), clearErrors: useCallback(clearErrors, []), setError: useCallback(setError, []), errors: formState.errors }, commonProps);\r\n}\n\n/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n\r\nfunction __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\n\nconst FormContext = createContext(null);\r\nFormContext.displayName = 'RHFContext';\r\nconst useFormContext = () => useContext(FormContext);\r\nconst FormProvider = (_a) => {\r\n    var { children } = _a, props = __rest(_a, [\"children\"]);\r\n    return (createElement(FormContext.Provider, { value: Object.assign({}, props) }, children));\r\n};\n\nvar generateId = () => {\r\n    const d = typeof performance === UNDEFINED ? Date.now() : performance.now() * 1000;\r\n    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {\r\n        const r = (Math.random() * 16 + d) % 16 | 0;\r\n        return (c == 'x' ? r : (r & 0x3) | 0x8).toString(16);\r\n    });\r\n};\n\nfunction removeAtIndexes(data, indexes) {\r\n    let i = 0;\r\n    const temp = [...data];\r\n    for (const index of indexes) {\r\n        temp.splice(index - i, 1);\r\n        i++;\r\n    }\r\n    return compact(temp).length ? temp : [];\r\n}\r\nvar removeArrayAt = (data, index) => isUndefined(index)\r\n    ? []\r\n    : removeAtIndexes(data, (Array.isArray(index) ? index : [index]).sort((a, b) => a - b));\n\nvar moveArrayAt = (data, from, to) => {\r\n    if (Array.isArray(data)) {\r\n        if (isUndefined(data[to])) {\r\n            data[to] = undefined;\r\n        }\r\n        data.splice(to, 0, data.splice(from, 1)[0]);\r\n        return data;\r\n    }\r\n    return [];\r\n};\n\nvar swapArrayAt = (data, indexA, indexB) => {\r\n    const temp = [data[indexB], data[indexA]];\r\n    data[indexA] = temp[0];\r\n    data[indexB] = temp[1];\r\n};\n\nfunction prepend(data, value) {\r\n    return [...(Array.isArray(value) ? value : [value || undefined]), ...data];\r\n}\n\nfunction insert(data, index, value) {\r\n    return [\r\n        ...data.slice(0, index),\r\n        ...(Array.isArray(value) ? value : [value || undefined]),\r\n        ...data.slice(index),\r\n    ];\r\n}\n\nvar fillEmptyArray = (value) => Array.isArray(value) ? Array(value.length).fill(undefined) : undefined;\n\nvar fillBooleanArray = (value) => (Array.isArray(value) ? value : [value]).map((data) => {\r\n    if (isObject(data)) {\r\n        const object = {};\r\n        for (const key in data) {\r\n            object[key] = true;\r\n        }\r\n        return object;\r\n    }\r\n    return true;\r\n});\n\nconst mapIds = (values = [], keyName, skipWarn) => {\r\n    if (process.env.NODE_ENV !== 'production') {\r\n        if (!skipWarn) {\r\n            for (const value of values) {\r\n                if (typeof value === 'object') {\r\n                    if (keyName in value) {\r\n                        console.warn(`📋 useFieldArray fieldValues contain the keyName \\`${keyName}\\` which is reserved for use by useFieldArray. https://react-hook-form.com/api#useFieldArray`);\r\n                        break;\r\n                    }\r\n                }\r\n                else {\r\n                    console.warn(`📋 useFieldArray input's name should be in object shape instead of flat array. https://react-hook-form.com/api#useFieldArray`);\r\n                    break;\r\n                }\r\n            }\r\n        }\r\n    }\r\n    return values.map((value) => (Object.assign({ [keyName]: value[keyName] || generateId() }, value)));\r\n};\r\nconst useFieldArray = ({ control, name, keyName = 'id', }) => {\r\n    const methods = useFormContext();\r\n    if (process.env.NODE_ENV !== 'production') {\r\n        if (!control && !methods) {\r\n            throw new Error('📋 useFieldArray is missing `control` prop. https://react-hook-form.com/api#useFieldArray');\r\n        }\r\n    }\r\n    const focusIndexRef = useRef(-1);\r\n    const isUnMount = useRef(false);\r\n    const { isFormDirty, updateWatchedValue, resetFieldArrayFunctionRef, fieldArrayNamesRef, fieldsRef, defaultValuesRef, removeFieldEventListener, formStateRef, shallowFieldsStateRef, updateFormState, readFormStateRef, validFieldsRef, fieldsWithValidationRef, fieldArrayDefaultValuesRef, validateResolver, getValues, shouldUnregister, fieldArrayValuesRef, } = control || methods.control;\r\n    const getDefaultValues = (values) => get(shouldUnregister ? values : shallowFieldsStateRef.current, name, []);\r\n    const fieldArrayParentName = getFieldArrayParentName(name);\r\n    const memoizedDefaultValues = useRef([\r\n        ...(get(fieldArrayDefaultValuesRef.current, fieldArrayParentName)\r\n            ? getDefaultValues(fieldArrayDefaultValuesRef.current)\r\n            : getDefaultValues(defaultValuesRef.current)),\r\n    ]);\r\n    const [fields, setFields] = useState(mapIds(memoizedDefaultValues.current, keyName));\r\n    set(fieldArrayValuesRef.current, name, compact(fields));\r\n    const omitKey = (fields) => fields.map((_a = {}) => {\r\n        var _b = keyName, omitted = _a[_b], rest = __rest(_a, [typeof _b === \"symbol\" ? _b : _b + \"\"]);\r\n        return rest;\r\n    });\r\n    fieldArrayNamesRef.current.add(name);\r\n    const getFieldArrayValue = useCallback(() => get(fieldArrayValuesRef.current, name, []), [name]);\r\n    const getCurrentFieldsValues = () => mapIds(get(getValues(), name, getFieldArrayValue()).map((item, index) => (Object.assign(Object.assign({}, getFieldArrayValue()[index]), item))), keyName, true);\r\n    fieldArrayNamesRef.current.add(name);\r\n    if (fieldArrayParentName &&\r\n        !get(fieldArrayDefaultValuesRef.current, fieldArrayParentName)) {\r\n        set(fieldArrayDefaultValuesRef.current, fieldArrayParentName, cloneObject(get(defaultValuesRef.current, fieldArrayParentName)));\r\n    }\r\n    const setFieldAndValidState = (fieldsValues) => {\r\n        setFields(fieldsValues);\r\n        set(fieldArrayValuesRef.current, name, fieldsValues);\r\n        if (readFormStateRef.current.isValid && validateResolver) {\r\n            const values = getValues();\r\n            set(values, name, fieldsValues);\r\n            validateResolver(values);\r\n        }\r\n    };\r\n    const resetFields = () => {\r\n        for (const key in fieldsRef.current) {\r\n            if (isMatchFieldArrayName(key, name)) {\r\n                removeFieldEventListener(fieldsRef.current[key], true);\r\n                delete fieldsRef.current[key];\r\n            }\r\n        }\r\n    };\r\n    const cleanup = (ref) => !compact(get(ref, name, [])).length && unset(ref, name);\r\n    const updateDirtyFieldsWithDefaultValues = (updatedFieldArrayValues) => {\r\n        if (updatedFieldArrayValues) {\r\n            set(formStateRef.current.dirtyFields, name, setFieldArrayDirtyFields(omitKey(updatedFieldArrayValues), get(defaultValuesRef.current, name, []), get(formStateRef.current.dirtyFields, name, [])));\r\n        }\r\n    };\r\n    const batchStateUpdate = (method, args, updatedFieldValues, updatedFormValues = [], shouldSet = true, shouldUpdateValid = false) => {\r\n        if (get(shallowFieldsStateRef.current, name)) {\r\n            const output = method(get(shallowFieldsStateRef.current, name), args.argA, args.argB);\r\n            shouldSet && set(shallowFieldsStateRef.current, name, output);\r\n        }\r\n        if (get(fieldArrayDefaultValuesRef.current, name)) {\r\n            const output = method(get(fieldArrayDefaultValuesRef.current, name), args.argA, args.argB);\r\n            shouldSet && set(fieldArrayDefaultValuesRef.current, name, output);\r\n        }\r\n        if (Array.isArray(get(formStateRef.current.errors, name))) {\r\n            const output = method(get(formStateRef.current.errors, name), args.argA, args.argB);\r\n            shouldSet && set(formStateRef.current.errors, name, output);\r\n            cleanup(formStateRef.current.errors);\r\n        }\r\n        if (readFormStateRef.current.touched &&\r\n            get(formStateRef.current.touched, name)) {\r\n            const output = method(get(formStateRef.current.touched, name), args.argA, args.argB);\r\n            shouldSet && set(formStateRef.current.touched, name, output);\r\n            cleanup(formStateRef.current.touched);\r\n        }\r\n        if (readFormStateRef.current.dirtyFields ||\r\n            readFormStateRef.current.isDirty) {\r\n            set(formStateRef.current.dirtyFields, name, setFieldArrayDirtyFields(omitKey(updatedFormValues), get(defaultValuesRef.current, name, []), get(formStateRef.current.dirtyFields, name, [])));\r\n            updateDirtyFieldsWithDefaultValues(updatedFieldValues);\r\n            cleanup(formStateRef.current.dirtyFields);\r\n        }\r\n        if (shouldUpdateValid &&\r\n            readFormStateRef.current.isValid &&\r\n            !validateResolver) {\r\n            set(validFieldsRef.current, name, method(get(validFieldsRef.current, name, []), args.argA));\r\n            cleanup(validFieldsRef.current);\r\n            set(fieldsWithValidationRef.current, name, method(get(fieldsWithValidationRef.current, name, []), args.argA));\r\n            cleanup(fieldsWithValidationRef.current);\r\n        }\r\n        if (!isUnMount.current && readFormStateRef.current.isDirty) {\r\n            updateFormState({\r\n                isDirty: isFormDirty(name, omitKey(updatedFormValues)),\r\n            });\r\n        }\r\n    };\r\n    const append = (value, shouldFocus = true) => {\r\n        const appendValue = Array.isArray(value) ? value : [value];\r\n        const updateFormValues = [\r\n            ...getCurrentFieldsValues(),\r\n            ...mapIds(appendValue, keyName),\r\n        ];\r\n        setFieldAndValidState(updateFormValues);\r\n        if (readFormStateRef.current.dirtyFields ||\r\n            readFormStateRef.current.isDirty) {\r\n            updateDirtyFieldsWithDefaultValues(updateFormValues);\r\n            updateFormState({\r\n                isDirty: true,\r\n                dirtyFields: formStateRef.current.dirtyFields,\r\n            });\r\n        }\r\n        !shouldUnregister &&\r\n            set(shallowFieldsStateRef.current, name, [\r\n                ...(get(shallowFieldsStateRef.current, name) || []),\r\n                ...cloneObject(appendValue),\r\n            ]);\r\n        focusIndexRef.current = shouldFocus\r\n            ? get(fieldArrayValuesRef.current, name).length - 1\r\n            : -1;\r\n    };\r\n    const prepend$1 = (value, shouldFocus = true) => {\r\n        const emptyArray = fillEmptyArray(value);\r\n        const updatedFieldArrayValues = prepend(getCurrentFieldsValues(), mapIds(Array.isArray(value) ? value : [value], keyName));\r\n        setFieldAndValidState(updatedFieldArrayValues);\r\n        resetFields();\r\n        batchStateUpdate(prepend, {\r\n            argA: emptyArray,\r\n            argC: fillBooleanArray(value),\r\n        }, updatedFieldArrayValues);\r\n        focusIndexRef.current = shouldFocus ? 0 : -1;\r\n    };\r\n    const remove = (index) => {\r\n        const fieldValues = getCurrentFieldsValues();\r\n        const updatedFieldValues = removeArrayAt(fieldValues, index);\r\n        setFieldAndValidState(updatedFieldValues);\r\n        resetFields();\r\n        batchStateUpdate(removeArrayAt, {\r\n            argA: index,\r\n            argC: index,\r\n        }, updatedFieldValues, removeArrayAt(fieldValues, index), true, true);\r\n    };\r\n    const insert$1 = (index, value, shouldFocus = true) => {\r\n        const emptyArray = fillEmptyArray(value);\r\n        const fieldValues = getCurrentFieldsValues();\r\n        const updatedFieldArrayValues = insert(fieldValues, index, mapIds(Array.isArray(value) ? value : [value], keyName));\r\n        setFieldAndValidState(updatedFieldArrayValues);\r\n        resetFields();\r\n        batchStateUpdate(insert, {\r\n            argA: index,\r\n            argB: emptyArray,\r\n            argC: index,\r\n            argD: fillBooleanArray(value),\r\n        }, updatedFieldArrayValues, insert(fieldValues, index));\r\n        focusIndexRef.current = shouldFocus ? index : -1;\r\n    };\r\n    const swap = (indexA, indexB) => {\r\n        const fieldValues = getCurrentFieldsValues();\r\n        swapArrayAt(fieldValues, indexA, indexB);\r\n        resetFields();\r\n        setFieldAndValidState([...fieldValues]);\r\n        batchStateUpdate(swapArrayAt, {\r\n            argA: indexA,\r\n            argB: indexB,\r\n            argC: indexA,\r\n            argD: indexB,\r\n        }, undefined, fieldValues, false);\r\n    };\r\n    const move = (from, to) => {\r\n        const fieldValues = getCurrentFieldsValues();\r\n        moveArrayAt(fieldValues, from, to);\r\n        resetFields();\r\n        setFieldAndValidState([...fieldValues]);\r\n        batchStateUpdate(moveArrayAt, {\r\n            argA: from,\r\n            argB: to,\r\n            argC: from,\r\n            argD: to,\r\n        }, undefined, fieldValues, false);\r\n    };\r\n    useEffect(() => {\r\n        if (process.env.NODE_ENV !== 'production') {\r\n            if (!name) {\r\n                console.warn('📋 useFieldArray is missing `name` attribute. https://react-hook-form.com/api#useFieldArray');\r\n            }\r\n        }\r\n        const defaultValues = get(fieldArrayDefaultValuesRef.current, name);\r\n        if (defaultValues && fields.length < defaultValues.length) {\r\n            set(fieldArrayDefaultValuesRef.current, name, defaultValues.slice(1));\r\n        }\r\n        updateWatchedValue(name);\r\n        if (focusIndexRef.current > -1) {\r\n            for (const key in fieldsRef.current) {\r\n                const field = fieldsRef.current[key];\r\n                if (key.startsWith(`${name}[${focusIndexRef.current}]`) &&\r\n                    field.ref.focus) {\r\n                    field.ref.focus();\r\n                    break;\r\n                }\r\n            }\r\n        }\r\n        focusIndexRef.current = -1;\r\n    }, [fields, name]);\r\n    useEffect(() => {\r\n        const resetFunctions = resetFieldArrayFunctionRef.current;\r\n        const fieldArrayNames = fieldArrayNamesRef.current;\r\n        if (!getFieldArrayParentName(name)) {\r\n            resetFunctions[name] = (data) => {\r\n                resetFields();\r\n                !data && unset(fieldArrayDefaultValuesRef.current, name);\r\n                unset(shallowFieldsStateRef.current, name);\r\n                memoizedDefaultValues.current = get(data || defaultValuesRef.current, name);\r\n                if (!isUnMount.current) {\r\n                    setFields(mapIds(memoizedDefaultValues.current, keyName));\r\n                }\r\n            };\r\n        }\r\n        return () => {\r\n            isUnMount.current = true;\r\n            shouldUnregister && remove();\r\n            resetFields();\r\n            delete resetFunctions[name];\r\n            unset(fieldArrayValuesRef.current, name);\r\n            fieldArrayNames.delete(name);\r\n        };\r\n    }, []);\r\n    return {\r\n        swap: useCallback(swap, [name]),\r\n        move: useCallback(move, [name]),\r\n        prepend: useCallback(prepend$1, [name]),\r\n        append: useCallback(append, [name]),\r\n        remove: useCallback(remove, [name]),\r\n        insert: useCallback(insert$1, [name]),\r\n        fields: compact(fields),\r\n    };\r\n};\n\nvar getInputValue = (event) => isPrimitive(event) ||\r\n    !isObject(event.target) ||\r\n    (isObject(event.target) && !event.type)\r\n    ? event\r\n    : isUndefined(event.target.value)\r\n        ? event.target.checked\r\n        : event.target.value;\n\nfunction useController({ name, rules, defaultValue, control, onFocus, }) {\r\n    const methods = useFormContext();\r\n    if (process.env.NODE_ENV !== 'production') {\r\n        if (!control && !methods) {\r\n            throw new Error('📋 Controller is missing `control` prop. https://react-hook-form.com/api#Controller');\r\n        }\r\n    }\r\n    const { defaultValuesRef, setValue, register, unregister, trigger, mode, reValidateMode: { isReValidateOnBlur, isReValidateOnChange }, formState, formStateRef: { current: { isSubmitted, touched, errors }, }, updateFormState, readFormStateRef, fieldsRef, fieldArrayNamesRef, shallowFieldsStateRef, } = control || methods.control;\r\n    const isNotFieldArray = !isNameInFieldArray(fieldArrayNamesRef.current, name);\r\n    const getInitialValue = () => !isUndefined(get(shallowFieldsStateRef.current, name)) && isNotFieldArray\r\n        ? get(shallowFieldsStateRef.current, name)\r\n        : isUndefined(defaultValue)\r\n            ? get(defaultValuesRef.current, name)\r\n            : defaultValue;\r\n    const [value, setInputStateValue] = useState(getInitialValue());\r\n    const valueRef = useRef(value);\r\n    const ref = useRef({\r\n        focus: () => null,\r\n    });\r\n    const onFocusRef = useRef(onFocus ||\r\n        (() => {\r\n            if (isFunction(ref.current.focus)) {\r\n                ref.current.focus();\r\n            }\r\n            if (process.env.NODE_ENV !== 'production') {\r\n                if (!isFunction(ref.current.focus)) {\r\n                    console.warn(`📋 'ref' from Controller render prop must be attached to a React component or a DOM Element whose ref provides a 'focus()' method`);\r\n                }\r\n            }\r\n        }));\r\n    const shouldValidate = useCallback((isBlurEvent) => !skipValidation(Object.assign({ isBlurEvent,\r\n        isReValidateOnBlur,\r\n        isReValidateOnChange,\r\n        isSubmitted, isTouched: !!get(touched, name) }, mode)), [\r\n        isReValidateOnBlur,\r\n        isReValidateOnChange,\r\n        isSubmitted,\r\n        touched,\r\n        name,\r\n        mode,\r\n    ]);\r\n    const commonTask = useCallback(([event]) => {\r\n        const data = getInputValue(event);\r\n        setInputStateValue(data);\r\n        valueRef.current = data;\r\n        return data;\r\n    }, []);\r\n    const registerField = useCallback((shouldUpdateValue) => {\r\n        if (process.env.NODE_ENV !== 'production') {\r\n            if (!name) {\r\n                return console.warn('📋 Field is missing `name` prop. https://react-hook-form.com/api#Controller');\r\n            }\r\n        }\r\n        if (fieldsRef.current[name]) {\r\n            fieldsRef.current[name] = Object.assign({ ref: fieldsRef.current[name].ref }, rules);\r\n        }\r\n        else {\r\n            register(Object.defineProperties({\r\n                name,\r\n                focus: onFocusRef.current,\r\n            }, {\r\n                value: {\r\n                    set(data) {\r\n                        setInputStateValue(data);\r\n                        valueRef.current = data;\r\n                    },\r\n                    get() {\r\n                        return valueRef.current;\r\n                    },\r\n                },\r\n            }), rules);\r\n            shouldUpdateValue = isUndefined(get(defaultValuesRef.current, name));\r\n        }\r\n        shouldUpdateValue &&\r\n            isNotFieldArray &&\r\n            setInputStateValue(getInitialValue());\r\n    }, [rules, name, register]);\r\n    useEffect(() => () => unregister(name), [name]);\r\n    useEffect(() => {\r\n        if (process.env.NODE_ENV !== 'production') {\r\n            if (isUndefined(value)) {\r\n                console.warn(`📋 ${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)`);\r\n            }\r\n            if (!isNotFieldArray && isUndefined(defaultValue)) {\r\n                console.warn('📋 Controller is missing `defaultValue` prop when using `useFieldArray`. https://react-hook-form.com/api#Controller');\r\n            }\r\n        }\r\n        registerField();\r\n    }, [registerField]);\r\n    useEffect(() => {\r\n        !fieldsRef.current[name] && registerField(true);\r\n    });\r\n    const onBlur = useCallback(() => {\r\n        if (readFormStateRef.current.touched && !get(touched, name)) {\r\n            set(touched, name, true);\r\n            updateFormState({\r\n                touched,\r\n            });\r\n        }\r\n        shouldValidate(true) && trigger(name);\r\n    }, [name, updateFormState, shouldValidate, trigger, readFormStateRef]);\r\n    const onChange = useCallback((...event) => setValue(name, commonTask(event), {\r\n        shouldValidate: shouldValidate(),\r\n        shouldDirty: true,\r\n    }), [setValue, name, shouldValidate]);\r\n    return {\r\n        field: {\r\n            onChange,\r\n            onBlur,\r\n            name,\r\n            value,\r\n            ref,\r\n        },\r\n        meta: Object.defineProperties({\r\n            invalid: !!get(errors, name),\r\n        }, {\r\n            isDirty: {\r\n                get() {\r\n                    return !!get(formState.dirtyFields, name);\r\n                },\r\n            },\r\n            isTouched: {\r\n                get() {\r\n                    return !!get(formState.touched, name);\r\n                },\r\n            },\r\n        }),\r\n    };\r\n}\n\nfunction useWatch({ control, name, defaultValue, }) {\r\n    const methods = useFormContext();\r\n    if (process.env.NODE_ENV !== 'production') {\r\n        if (!control && !methods) {\r\n            throw new Error('📋 useWatch is missing `control` prop. https://react-hook-form.com/api#useWatch');\r\n        }\r\n    }\r\n    const { useWatchFieldsRef, useWatchRenderFunctionsRef, watchInternal, defaultValuesRef, } = control || methods.control;\r\n    const updateValue = useState()[1];\r\n    const idRef = useRef();\r\n    const defaultValueRef = useRef(defaultValue);\r\n    useEffect(() => {\r\n        if (process.env.NODE_ENV !== 'production') {\r\n            if (name === '') {\r\n                console.warn('📋 useWatch is missing `name` attribute. https://react-hook-form.com/api#useWatch');\r\n            }\r\n        }\r\n        const id = (idRef.current = generateId());\r\n        const watchFieldsHookRender = useWatchRenderFunctionsRef.current;\r\n        const watchFieldsHook = useWatchFieldsRef.current;\r\n        watchFieldsHook[id] = new Set();\r\n        watchFieldsHookRender[id] = () => updateValue({});\r\n        watchInternal(name, defaultValueRef.current, id);\r\n        return () => {\r\n            delete watchFieldsHook[id];\r\n            delete watchFieldsHookRender[id];\r\n        };\r\n    }, [\r\n        name,\r\n        useWatchRenderFunctionsRef,\r\n        useWatchFieldsRef,\r\n        watchInternal,\r\n        defaultValueRef,\r\n    ]);\r\n    return idRef.current\r\n        ? watchInternal(name, defaultValueRef.current, idRef.current)\r\n        : isUndefined(defaultValue)\r\n            ? isString(name)\r\n                ? get(defaultValuesRef.current, name)\r\n                : Array.isArray(name)\r\n                    ? name.reduce((previous, inputName) => (Object.assign(Object.assign({}, previous), { [inputName]: get(defaultValuesRef.current, inputName) })), {})\r\n                    : defaultValuesRef.current\r\n            : defaultValue;\r\n}\n\nconst Controller = (props) => {\r\n    const { rules, as, render, defaultValue, control, onFocus } = props, rest = __rest(props, [\"rules\", \"as\", \"render\", \"defaultValue\", \"control\", \"onFocus\"]);\r\n    const { field, meta } = useController(props);\r\n    const componentProps = Object.assign(Object.assign({}, rest), field);\r\n    return as\r\n        ? isValidElement(as)\r\n            ? cloneElement(as, componentProps)\r\n            : createElement(as, componentProps)\r\n        : render\r\n            ? render(field, meta)\r\n            : null;\r\n};\n\nexport { Controller, FormProvider, appendErrors, get, transformToNestObject, useController, useFieldArray, useForm, useFormContext, useWatch };\n//# sourceMappingURL=index.esm.js.map\n","function _typeof(obj) { if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } return _assertThisInitialized(self); }\n\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nimport React, { PureComponent } from 'react'; // eslint-disable-line import/no-unresolved\n\nexport var PersistGate =\n/*#__PURE__*/\nfunction (_PureComponent) {\n  _inherits(PersistGate, _PureComponent);\n\n  function PersistGate() {\n    var _getPrototypeOf2;\n\n    var _this;\n\n    _classCallCheck(this, PersistGate);\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(PersistGate)).call.apply(_getPrototypeOf2, [this].concat(args)));\n\n    _defineProperty(_assertThisInitialized(_this), \"state\", {\n      bootstrapped: false\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_unsubscribe\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"handlePersistorState\", function () {\n      var persistor = _this.props.persistor;\n\n      var _persistor$getState = persistor.getState(),\n          bootstrapped = _persistor$getState.bootstrapped;\n\n      if (bootstrapped) {\n        if (_this.props.onBeforeLift) {\n          Promise.resolve(_this.props.onBeforeLift()).finally(function () {\n            return _this.setState({\n              bootstrapped: true\n            });\n          });\n        } else {\n          _this.setState({\n            bootstrapped: true\n          });\n        }\n\n        _this._unsubscribe && _this._unsubscribe();\n      }\n    });\n\n    return _this;\n  }\n\n  _createClass(PersistGate, [{\n    key: \"componentDidMount\",\n    value: function componentDidMount() {\n      this._unsubscribe = this.props.persistor.subscribe(this.handlePersistorState);\n      this.handlePersistorState();\n    }\n  }, {\n    key: \"componentWillUnmount\",\n    value: function componentWillUnmount() {\n      this._unsubscribe && this._unsubscribe();\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      if (process.env.NODE_ENV !== 'production') {\n        if (typeof this.props.children === 'function' && this.props.loading) console.error('redux-persist: PersistGate expects either a function child or loading prop, but not both. The loading prop will be ignored.');\n      }\n\n      if (typeof this.props.children === 'function') {\n        return this.props.children(this.state.bootstrapped);\n      }\n\n      return this.state.bootstrapped ? this.props.children : this.props.loading;\n    }\n  }]);\n\n  return PersistGate;\n}(PureComponent);\n\n_defineProperty(PersistGate, \"defaultProps\", {\n  children: null,\n  loading: null\n});"],"names":["exports","obj","_react","__esModule","_typeof","cache","_getRequireWildcardCache","has","get","newObj","hasPropertyDescriptor","Object","defineProperty","getOwnPropertyDescriptor","key","prototype","hasOwnProperty","call","desc","set","_interopRequireWildcard","_propTypes","WeakMap","Symbol","iterator","constructor","_extends","assign","target","i","arguments","length","source","apply","this","_defineProperties","props","descriptor","enumerable","configurable","writable","_setPrototypeOf","o","p","setPrototypeOf","__proto__","_assertThisInitialized","self","ReferenceError","_getPrototypeOf","getPrototypeOf","_defineProperty","value","EscapeOutside","_Component","subClass","superClass","TypeError","create","_inherits","Constructor","protoProps","Derived","_super","result","Super","Reflect","construct","sham","Proxy","Date","toString","e","_isNativeReflectConstruct","NewTarget","_possibleConstructorReturn","_this","instance","_classCallCheck","onEscape","bind","onClick","getRef","document","addEventListener","mouseEvent","touchEvent","removeEventListener","keyCode","onEscapeOutside","ref","contains","children","createElement","Component","element","isRequired","func","string","isHTMLElement","HTMLElement","EVENTS","BLUR","CHANGE","INPUT","VALIDATION_MODE","onBlur","onChange","onSubmit","onTouched","all","SELECT","UNDEFINED","INPUT_VALIDATION_RULES","isNullOrUndefined","isObjectType","isObject","Array","isArray","isKey","test","compact","filter","Boolean","stringToPath","input","replace","split","object","path","index","tempPath","lastIndex","newValue","objValue","isNaN","transformToNestObject","data","isUndefined","val","undefined","defaultValue","reduce","focusOnErrorField","fields","fieldErrors","field","focus","options","removeAllEventListeners","validateWithStateUpdate","defaultReturn","isValid","getRadioValue","previous","option","checked","getMultipleSelectValue","selected","map","isRadioInput","type","isFileInput","isCheckBoxInput","isMultipleSelect","defaultResult","validResult","getCheckboxValue","values","attributes","getFieldValue","fieldsRef","name","shallowFieldsStateRef","excludeDisabled","shouldKeepRawValue","current","disabled","valueAsNumber","valueAsDate","setValueAs","files","NaN","isDetached","nodeType","Node","DOCUMENT_NODE","parentNode","isEmptyObject","keys","isBoolean","unset","updatePath","childObject","slice","baseGet","previousObjRef","k","objectRef","currentPaths","currentPathsLength","item","isSameRef","fieldValue","isPrimitive","deepMerge","targetValue","sourceValue","_a","deepEqual","object1","object2","isErrorObject","isValidElement","keys1","keys2","val1","val2","setDirtyFields","defaultValues","dirtyFields","parentName","setFieldArrayDirtyFields","isString","getFieldsValues","shallowFieldsState","shouldUnregister","search","output","startsWith","find","isErrorStateChanged","errors","error","validFields","fieldsWithValidation","previousError","isRegex","RegExp","getValueAndMessage","validationData","message","isFunction","isMessage","getValidateError","appendErrors","validateAllFieldCriteria","types","validateField","async","required","maxLength","minLength","min","max","pattern","validate","isRadio","isCheckBox","isRadioOrCheckbox","isEmpty","appendErrorsCurry","getMinMaxMessage","exceedMax","maxLengthMessage","minLengthMessage","maxType","minType","exceedMin","maxOutput","minOutput","valueDate","valueNumber","parseFloat","maxLengthOutput","minLengthOutput","patternValue","validateRef","validateError","validationResult","validateFunction","entries","getPath","rootPath","paths","property","rootName","push","assignWatchFields","fieldValues","fieldName","watchFields","inputValue","isSingleField","add","forEach","skipValidation","isOnBlur","isOnChange","isOnTouch","isTouched","isReValidateOnBlur","isReValidateOnChange","isBlurEvent","isSubmitted","isOnAll","getFieldArrayParentName","substring","indexOf","isNameInFieldArray","names","some","searchName","isMatchFieldArrayName","isSelectInput","isWeb","window","cloneObject","copy","File","includes","getTime","Set","Map","modeChecker","mode","isOnSubmit","isRadioOrCheckboxFunction","isWindowUndefined","isProxyEnabled","useForm","reValidateMode","resolver","context","shouldFocusError","criteriaMode","useRef","fieldArrayDefaultValuesRef","fieldArrayValuesRef","watchFieldsRef","useWatchFieldsRef","useWatchRenderFunctionsRef","fieldsWithValidationRef","validFieldsRef","defaultValuesRef","isUnMount","isWatchAllRef","handleChangeRef","resetFieldArrayFunctionRef","contextRef","resolverRef","fieldArrayNamesRef","modeRef","isValidateAllFieldCriteria","formState","setFormState","useState","isDirty","isValidating","submitCount","touched","isSubmitting","isSubmitSuccessful","readFormStateRef","formStateRef","observerRef","updateFormState","useCallback","state","updateIsValidating","shouldRenderBaseOnError","shouldRender","shouldReRender","setFieldValue","rawValue","radioRef","selectRef","checkboxRef","isFormDirty","formValues","getValues","updateAndGetDirtyState","isFieldDirty","isDirtyFieldExist","previousIsDirty","isChanged","executeValidation","skipReRender","executeSchemaOrResolverValidation","previousFormIsValid","isInputsValid","every","trigger","Promise","setInternalValues","shouldDirty","shouldValidate","setInternalValue","config","isFieldWatched","match","renderWatchedInputs","found","size","setFieldArrayDefaultValues","payload","shouldSkipValidation","parentNodeName","currentError","validateResolver","newDefaultValues","removeFieldEventListener","forceDelete","handleChange","fieldRef","findRemovedFieldAndRemoveListener","updateWatchedValue","watchField","removeFieldEventListenerAndRef","watchInternal","fieldNames","watchId","combinedDefaultValues","registerFieldRef","fieldRefAndValidationOptions","isFieldArray","compareRef","currentRef","isEmptyDefaultValue","isEmptyUnmountFields","then","shouldAttachChangeEvent","attachEventListeners","handleSubmit","onValid","onInvalid","preventDefault","persist","fieldError","useEffect","observer","MutationObserver","observe","childList","subtree","onDomRemove","disconnect","commonProps","setValue","register","refOrRegisterOptions","unregister","prop","control","useMemo","watch","reset","omitResetState","inputRef","closest","resetFieldArray","resetRefs","clearErrors","inputName","setError","shouldFocus","createContext","displayName","PersistGate","_PureComponent","_getPrototypeOf2","_len","args","_key","concat","bootstrapped","persistor","getState","onBeforeLift","resolve","finally","setState","_unsubscribe","subscribe","handlePersistorState","loading","PureComponent"],"sourceRoot":""}