{"version":3,"file":"30.bundle.js","mappings":"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","sources":["webpack://picasso/./node_modules/react-hook-form/dist/react-hook-form.es.js"],"sourcesContent":["import { isValidElement, useRef, useState, useCallback, useEffect, createContext, useContext, createElement, cloneElement, Fragment } from 'react';\n\nvar isNullOrUndefined = (value) => value == null;\n\nvar isArray = (value) => Array.isArray(value);\n\nconst isObjectType = (value) => typeof value === 'object';\r\nvar isObject = (value) => !isNullOrUndefined(value) && !isArray(value) && isObjectType(value);\n\nvar isHTMLElement = (value) => isObject(value) && value.nodeType === Node.ELEMENT_NODE;\n\nconst VALIDATION_MODE = {\r\n    onBlur: 'onBlur',\r\n    onChange: 'onChange',\r\n    onSubmit: 'onSubmit',\r\n};\r\nconst VALUE = 'value';\r\nconst UNDEFINED = 'undefined';\r\nconst EVENTS = {\r\n    BLUR: 'blur',\r\n    CHANGE: 'change',\r\n    INPUT: 'input',\r\n};\r\nconst SELECT = 'select';\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};\r\nconst REGEX_IS_DEEP_PROP = /\\.|\\[(?:[^[\\]]*|([\"'])(?:(?!\\1)[^\\\\]|\\\\.)*?\\1)\\]/;\r\nconst REGEX_IS_PLAIN_PROP = /^\\w*$/;\r\nconst REGEX_PROP_NAME = /[^.[\\]]+|\\[(?:(-?\\d+(?:\\.\\d+)?)|([\"'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|$))/g;\r\nconst REGEX_ESCAPE_CHAR = /\\\\(\\\\)?/g;\r\nconst REGEX_ARRAY_FIELD_INDEX = /[\\d+]/g;\n\nfunction attachEventListeners({ field: { ref }, handleChange, isRadioOrCheckbox, }) {\r\n    if (isHTMLElement(ref) && handleChange) {\r\n        ref.addEventListener(isRadioOrCheckbox ? EVENTS.CHANGE : EVENTS.INPUT, handleChange);\r\n        ref.addEventListener(EVENTS.BLUR, handleChange);\r\n    }\r\n}\n\nvar isKey = (value) => !isArray(value) &&\r\n    (REGEX_IS_PLAIN_PROP.test(value) || !REGEX_IS_DEEP_PROP.test(value));\n\nvar stringToPath = (string) => {\r\n    const result = [];\r\n    string.replace(REGEX_PROP_NAME, (match, number, quote, string) => {\r\n        result.push(quote ? string.replace(REGEX_ESCAPE_CHAR, '$1') : number || match);\r\n    });\r\n    return result;\r\n};\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) || 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) => Object.entries(data).reduce((previous, [key, value]) => {\r\n    if (!isKey(key)) {\r\n        set(previous, key, value);\r\n        return previous;\r\n    }\r\n    return Object.assign(Object.assign({}, previous), { [key]: value });\r\n}, {});\n\nvar isUndefined = (val) => val === undefined;\n\nvar get = (obj, path, defaultValue) => {\r\n    const result = path\r\n        .split(/[,[\\].]+?/)\r\n        .filter(Boolean)\r\n        .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) {\r\n                    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\nvar isRadioInput = (element) => element.type === 'radio';\n\nvar isCheckBoxInput = (element) => element.type === 'checkbox';\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\nfunction castPath(value) {\r\n    return isArray(value) ? value : stringToPath(value);\r\n}\r\nfunction baseGet(object, path) {\r\n    const updatePath = isKey(path) ? [path] : castPath(path);\r\n    const length = path.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 index == length ? object : undefined;\r\n}\r\nfunction baseSlice(array, start, end) {\r\n    let index = -1;\r\n    let length = array.length;\r\n    if (start < 0) {\r\n        start = -start > length ? 0 : length + start;\r\n    }\r\n    end = end > length ? length : end;\r\n    if (end < 0) {\r\n        end += length;\r\n    }\r\n    length = start > end ? 0 : end - start;\r\n    const result = Array(length);\r\n    while (++index < length) {\r\n        result[index] = array[index + start];\r\n    }\r\n    return result;\r\n}\r\nfunction parent(object, path) {\r\n    return path.length == 1 ? object : baseGet(object, baseSlice(path, 0, -1));\r\n}\r\nfunction baseUnset(object, path) {\r\n    const updatePath = isKey(path) ? [path] : castPath(path);\r\n    const childObject = parent(object, updatePath);\r\n    const key = updatePath[updatePath.length - 1];\r\n    const result = !(childObject != null) || delete childObject[key];\r\n    let previousObjRef = undefined;\r\n    for (let k = 0; k < updatePath.slice(0, -1).length; k++) {\r\n        let index = -1;\r\n        let objectRef = undefined;\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                if ((isObject(objectRef) && isEmptyObject(objectRef)) ||\r\n                    (isArray(objectRef) &&\r\n                        !objectRef.filter((data) => isObject(data) && !isEmptyObject(data))\r\n                            .length)) {\r\n                    previousObjRef ? delete previousObjRef[item] : delete object[item];\r\n                }\r\n            }\r\n            previousObjRef = objectRef;\r\n        }\r\n    }\r\n    return result;\r\n}\r\nfunction unset(object, paths) {\r\n    paths.forEach((path) => {\r\n        baseUnset(object, path);\r\n    });\r\n    return object;\r\n}\n\nconst isSameRef = (fieldValue, ref) => fieldValue && fieldValue.ref === ref;\r\nfunction findRemovedFieldAndRemoveListener(fields, handleChange, field, forceDelete) {\r\n    const { ref, ref: { name, type }, mutationWatcher, } = field;\r\n    const fieldValue = fields[name];\r\n    if (!type) {\r\n        delete fields[name];\r\n        return;\r\n    }\r\n    if ((isRadioInput(ref) || isCheckBoxInput(ref)) && fieldValue) {\r\n        const { options } = fieldValue;\r\n        if (isArray(options) && options.length) {\r\n            options.filter(Boolean).forEach((option, index) => {\r\n                const { ref, mutationWatcher } = option;\r\n                if ((ref && isDetached(ref) && isSameRef(option, ref)) || forceDelete) {\r\n                    removeAllEventListeners(ref, handleChange);\r\n                    if (mutationWatcher) {\r\n                        mutationWatcher.disconnect();\r\n                    }\r\n                    unset(options, [`[${index}]`]);\r\n                }\r\n            });\r\n            if (options && !options.filter(Boolean).length) {\r\n                delete fields[name];\r\n            }\r\n        }\r\n        else {\r\n            delete fields[name];\r\n        }\r\n    }\r\n    else if ((isDetached(ref) && isSameRef(fieldValue, ref)) || forceDelete) {\r\n        removeAllEventListeners(ref, handleChange);\r\n        if (mutationWatcher) {\r\n            mutationWatcher.disconnect();\r\n        }\r\n        delete fields[name];\r\n    }\r\n}\n\nconst defaultReturn = {\r\n    isValid: false,\r\n    value: '',\r\n};\r\nvar getRadioValue = (options) => 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 isFileInput = (element) => element.type === 'file';\n\nvar isMultipleSelect = (element) => element.type === `${SELECT}-multiple`;\n\nvar isEmptyString = (value) => value === '';\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 (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) || isEmptyString(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(fields, ref) {\r\n    const { name, value } = ref;\r\n    const field = fields[name];\r\n    if (isFileInput(ref)) {\r\n        return ref.files;\r\n    }\r\n    if (isRadioInput(ref)) {\r\n        return field ? 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 field ? getCheckboxValue(field.options).value : false;\r\n    }\r\n    return value;\r\n}\n\nvar isString = (value) => typeof value === 'string';\n\nvar getFieldsValues = (fields, search) => {\r\n    const output = {};\r\n    for (const name in fields) {\r\n        if (isUndefined(search) ||\r\n            (isString(search)\r\n                ? name.startsWith(search)\r\n                : isArray(search)\r\n                    ? search.find((data) => name.startsWith(data))\r\n                    : search && search.nest)) {\r\n            output[name] = getFieldValue(fields, fields[name].ref);\r\n        }\r\n    }\r\n    return output;\r\n};\n\nvar compareObject = (objectA = {}, objectB = {}) => {\r\n    const objectAKeys = Object.keys(objectA);\r\n    const objectBKeys = Object.keys(objectB);\r\n    return (objectAKeys.length === objectBKeys.length &&\r\n        objectAKeys.every((key) => objectB[key] && objectB[key] === objectA[key]));\r\n};\n\nvar isSameError = (error, { type, types, message }) => isObject(error) &&\r\n    error.type === type &&\r\n    error.message === message &&\r\n    compareObject(error.types, types);\n\nfunction shouldRenderBasedOnError({ errors, name, error, validFields, fieldsWithValidation, }) {\r\n    const isFieldValid = isEmptyObject(error);\r\n    const isFormValid = isEmptyObject(errors);\r\n    const currentFieldError = get(error, name);\r\n    const existFieldError = get(errors, name);\r\n    if ((isFieldValid && validFields.has(name)) ||\r\n        (existFieldError && existFieldError.isManual)) {\r\n        return false;\r\n    }\r\n    if (isFormValid !== isFieldValid ||\r\n        (!isFormValid && !existFieldError) ||\r\n        (isFieldValid && fieldsWithValidation.has(name) && !validFields.has(name))) {\r\n        return true;\r\n    }\r\n    return currentFieldError && !isSameError(existFieldError, currentFieldError);\r\n}\n\nvar isRegex = (value) => value instanceof RegExp;\n\nvar getValueAndMessage = (validationData) => {\r\n    const isValueMessage = (value) => isObject(value) && !isRegex(value);\r\n    return isValueMessage(validationData)\r\n        ? validationData\r\n        : {\r\n            value: validationData,\r\n            message: '',\r\n        };\r\n};\n\nvar isFunction = (value) => typeof value === 'function';\n\nvar isBoolean = (value) => typeof value === 'boolean';\n\nvar isMessage = (value) => isString(value) || (isObject(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) => {\r\n    if (validateAllFieldCriteria) {\r\n        const error = errors[name];\r\n        return Object.assign(Object.assign({}, error), { types: Object.assign(Object.assign({}, (error && error.types ? error.types : {})), { [type]: message || true }) });\r\n    }\r\n    return {};\r\n};\n\nvar validateField = async (fieldsRef, validateAllFieldCriteria, { ref, ref: { type, value, name }, options, required, maxLength, minLength, min, max, pattern, validate, }) => {\r\n    var _a;\r\n    const fields = fieldsRef.current;\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 = isEmptyString(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        if (!validateAllFieldCriteria) {\r\n            return error;\r\n        }\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: requiredValue, message: requiredMessage } = isMessage(required)\r\n            ? { value: !!required, message: required }\r\n            : getValueAndMessage(required);\r\n        if (requiredValue) {\r\n            error[name] = Object.assign({ type: INPUT_VALIDATION_RULES.required, message: requiredMessage, ref: isRadioOrCheckbox ? (_a = fields[name].options) === null || _a === void 0 ? void 0 : _a[0].ref : ref }, appendErrorsCurry(INPUT_VALIDATION_RULES.required, requiredMessage));\r\n            if (!validateAllFieldCriteria) {\r\n                return error;\r\n            }\r\n        }\r\n    }\r\n    if (!isNullOrUndefined(min) || !isNullOrUndefined(max)) {\r\n        let exceedMax;\r\n        let exceedMin;\r\n        const { value: maxValue, message: maxMessage } = getValueAndMessage(max);\r\n        const { value: minValue, message: minMessage } = getValueAndMessage(min);\r\n        if (type === 'number' || (!type && !isNaN(value))) {\r\n            const valueNumber = ref.valueAsNumber || parseFloat(value);\r\n            if (!isNullOrUndefined(maxValue)) {\r\n                exceedMax = valueNumber > maxValue;\r\n            }\r\n            if (!isNullOrUndefined(minValue)) {\r\n                exceedMin = valueNumber < minValue;\r\n            }\r\n        }\r\n        else {\r\n            const valueDate = ref.valueAsDate || new Date(value);\r\n            if (isString(maxValue)) {\r\n                exceedMax = valueDate > new Date(maxValue);\r\n            }\r\n            if (isString(minValue)) {\r\n                exceedMin = valueDate < new Date(minValue);\r\n            }\r\n        }\r\n        if (exceedMax || exceedMin) {\r\n            getMinMaxMessage(!!exceedMax, maxMessage, minMessage, 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 { value: maxLengthValue, message: maxLengthMessage, } = getValueAndMessage(maxLength);\r\n        const { value: minLengthValue, message: minLengthMessage, } = getValueAndMessage(minLength);\r\n        const inputLength = value.toString().length;\r\n        const exceedMax = !isNullOrUndefined(maxLengthValue) && inputLength > maxLengthValue;\r\n        const exceedMin = !isNullOrUndefined(minLengthValue) && inputLength < minLengthValue;\r\n        if (exceedMax || exceedMin) {\r\n            getMinMaxMessage(!!exceedMax, maxLengthMessage, minLengthMessage);\r\n            if (!validateAllFieldCriteria) {\r\n                return error;\r\n            }\r\n        }\r\n    }\r\n    if (pattern && !isEmpty) {\r\n        const { value: patternValue, message: patternMessage } = getValueAndMessage(pattern);\r\n        if (isRegex(patternValue) && !patternValue.test(value)) {\r\n            error[name] = Object.assign({ type: INPUT_VALIDATION_RULES.pattern, message: patternMessage, ref }, appendErrorsCurry(INPUT_VALIDATION_RULES.pattern, patternMessage));\r\n            if (!validateAllFieldCriteria) {\r\n                return error;\r\n            }\r\n        }\r\n    }\r\n    if (validate) {\r\n        const fieldValue = getFieldValue(fields, ref);\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 parseErrorSchema = (error, validateAllFieldCriteria) => isArray(error.inner)\r\n    ? error.inner.reduce((previous, { path, message, type }) => (Object.assign(Object.assign({}, previous), (path\r\n        ? previous[path] && validateAllFieldCriteria\r\n            ? {\r\n                [path]: appendErrors(path, validateAllFieldCriteria, previous, type, message),\r\n            }\r\n            : {\r\n                [path]: previous[path] || Object.assign({ message,\r\n                    type }, (validateAllFieldCriteria\r\n                    ? {\r\n                        types: { [type]: message || true },\r\n                    }\r\n                    : {})),\r\n            }\r\n        : {}))), {})\r\n    : {\r\n        [error.path]: { message: error.message, type: error.type },\r\n    };\r\nasync function validateWithSchema(validationSchema, validateAllFieldCriteria, data, validationResolver, context) {\r\n    if (validationResolver) {\r\n        return validationResolver(data, context);\r\n    }\r\n    try {\r\n        return {\r\n            values: await validationSchema.validate(data, {\r\n                abortEarly: false,\r\n                context,\r\n            }),\r\n            errors: {},\r\n        };\r\n    }\r\n    catch (e) {\r\n        return {\r\n            values: {},\r\n            errors: transformToNestObject(parseErrorSchema(e, validateAllFieldCriteria)),\r\n        };\r\n    }\r\n}\n\nvar isPrimitive = (value) => isNullOrUndefined(value) || !isObjectType(value);\n\nconst getPath = (path, values) => {\r\n    const getInnerPath = (value, key, isObject) => {\r\n        const pathWithIndex = isObject ? `${path}.${key}` : `${path}[${key}]`;\r\n        return isPrimitive(value) ? pathWithIndex : getPath(pathWithIndex, value);\r\n    };\r\n    return isArray(values)\r\n        ? values.map((value, key) => getInnerPath(value, key))\r\n        : Object.entries(values).map(([key, value]) => getInnerPath(value, key, true));\r\n};\r\nvar getPath$1 = (parentPath, value) => getPath(parentPath, value).flat(Infinity);\n\nvar assignWatchFields = (fieldValues, fieldName, watchFields, inputValue, isSingleField) => {\r\n    let value;\r\n    watchFields.add(fieldName);\r\n    if (isEmptyObject(fieldValues)) {\r\n        value = undefined;\r\n    }\r\n    else if (!isUndefined(fieldValues[fieldName])) {\r\n        value = fieldValues[fieldName];\r\n        watchFields.add(fieldName);\r\n    }\r\n    else {\r\n        value = get(transformToNestObject(fieldValues), fieldName);\r\n        if (!isUndefined(value)) {\r\n            getPath$1(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 = ({ isOnChange, hasError, isBlurEvent, isOnSubmit, isReValidateOnSubmit, isOnBlur, isReValidateOnBlur, isSubmitted, }) => (isOnChange && isBlurEvent) ||\r\n    (isOnSubmit && isReValidateOnSubmit) ||\r\n    (isOnSubmit && !isSubmitted) ||\r\n    (isOnBlur && !isBlurEvent && !hasError) ||\r\n    (isReValidateOnBlur && !isBlurEvent && hasError) ||\r\n    (isReValidateOnSubmit && isSubmitted);\n\nvar getFieldArrayParentName = (name) => name.substring(0, name.indexOf('['));\n\nvar getFieldValueByName = (fields, name) => {\r\n    const results = transformToNestObject(getFieldsValues(fields));\r\n    return name ? get(results, name, results) : results;\r\n};\n\nfunction getIsFieldsDifferent(referenceArray, differenceArray) {\r\n    let isMatch = false;\r\n    if (!isArray(referenceArray) ||\r\n        !isArray(differenceArray) ||\r\n        referenceArray.length !== differenceArray.length) {\r\n        return true;\r\n    }\r\n    for (let i = 0; i < referenceArray.length; i++) {\r\n        if (isMatch) {\r\n            break;\r\n        }\r\n        const dataA = referenceArray[i];\r\n        const dataB = differenceArray[i];\r\n        if (isUndefined(dataB) ||\r\n            Object.keys(dataA).length !== Object.keys(dataB).length) {\r\n            isMatch = true;\r\n            break;\r\n        }\r\n        for (const key in dataA) {\r\n            if (dataA[key] !== dataB[key]) {\r\n                isMatch = true;\r\n                break;\r\n            }\r\n        }\r\n    }\r\n    return isMatch;\r\n}\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(element, onDetachCallback) {\r\n    const observer = new MutationObserver(() => {\r\n        if (isDetached(element)) {\r\n            observer.disconnect();\r\n            onDetachCallback();\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 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});\n\nvar isRadioOrCheckboxFunction = (ref) => isRadioInput(ref) || isCheckBoxInput(ref);\n\nfunction useForm({ mode = VALIDATION_MODE.onSubmit, reValidateMode = VALIDATION_MODE.onChange, validationSchema, validationResolver, validationContext, defaultValues = {}, submitFocusError = true, validateCriteriaMode, } = {}) {\r\n    const fieldsRef = useRef({});\r\n    const errorsRef = useRef({});\r\n    const touchedFieldsRef = useRef({});\r\n    const fieldArrayDefaultValues = useRef({});\r\n    const watchFieldsRef = useRef(new Set());\r\n    const dirtyFieldsRef = useRef(new Set());\r\n    const fieldsWithValidationRef = useRef(new Set());\r\n    const validFieldsRef = useRef(new Set());\r\n    const isValidRef = useRef(true);\r\n    const defaultValuesRef = useRef(defaultValues);\r\n    const defaultValuesAtRenderRef = useRef({});\r\n    const isUnMount = useRef(false);\r\n    const isWatchAllRef = useRef(false);\r\n    const isSubmittedRef = useRef(false);\r\n    const isDirtyRef = useRef(false);\r\n    const submitCountRef = useRef(0);\r\n    const isSubmittingRef = useRef(false);\r\n    const handleChangeRef = useRef();\r\n    const resetFieldArrayFunctionRef = useRef({});\r\n    const validationContextRef = useRef(validationContext);\r\n    const fieldArrayNamesRef = useRef(new Set());\r\n    const [, render] = useState();\r\n    const { isOnBlur, isOnSubmit, isOnChange } = useRef(modeChecker(mode)).current;\r\n    const validateAllFieldCriteria = validateCriteriaMode === 'all';\r\n    const isWindowUndefined = typeof window === UNDEFINED;\r\n    const shouldValidateSchemaOrResolver = !!(validationSchema || validationResolver);\r\n    const isWeb = typeof document !== UNDEFINED &&\r\n        !isWindowUndefined &&\r\n        !isUndefined(window.HTMLElement);\r\n    const isProxyEnabled = isWeb ? 'Proxy' in window : typeof Proxy !== UNDEFINED;\r\n    const readFormStateRef = useRef({\r\n        dirty: !isProxyEnabled,\r\n        dirtyFields: !isProxyEnabled,\r\n        isSubmitted: isOnSubmit,\r\n        submitCount: !isProxyEnabled,\r\n        touched: !isProxyEnabled,\r\n        isSubmitting: !isProxyEnabled,\r\n        isValid: !isProxyEnabled,\r\n    });\r\n    const { isOnBlur: isReValidateOnBlur, isOnSubmit: isReValidateOnSubmit, } = useRef(modeChecker(reValidateMode)).current;\r\n    validationContextRef.current = validationContext;\r\n    const reRender = useCallback(() => {\r\n        if (!isUnMount.current) {\r\n            render({});\r\n        }\r\n    }, []);\r\n    const shouldRenderBaseOnError = useCallback((name, error, shouldRender = false) => {\r\n        let shouldReRender = shouldRender ||\r\n            shouldRenderBasedOnError({\r\n                errors: errorsRef.current,\r\n                error,\r\n                name,\r\n                validFields: validFieldsRef.current,\r\n                fieldsWithValidation: fieldsWithValidationRef.current,\r\n            });\r\n        if (isEmptyObject(error)) {\r\n            if (fieldsWithValidationRef.current.has(name) ||\r\n                shouldValidateSchemaOrResolver) {\r\n                validFieldsRef.current.add(name);\r\n                shouldReRender = shouldReRender || get(errorsRef.current, name);\r\n            }\r\n            errorsRef.current = unset(errorsRef.current, [name]);\r\n        }\r\n        else {\r\n            const previousError = get(errorsRef.current, name);\r\n            validFieldsRef.current.delete(name);\r\n            shouldReRender =\r\n                shouldReRender ||\r\n                    (previousError\r\n                        ? !isSameError(previousError, error[name])\r\n                        : true);\r\n            set(errorsRef.current, name, error[name]);\r\n        }\r\n        if (shouldReRender && !isNullOrUndefined(shouldRender)) {\r\n            reRender();\r\n            return true;\r\n        }\r\n    }, [reRender, shouldValidateSchemaOrResolver]);\r\n    const setFieldValue = useCallback((field, rawValue) => {\r\n        const { ref, options } = field;\r\n        const value = isWeb && isHTMLElement(ref) && isNullOrUndefined(rawValue)\r\n            ? ''\r\n            : rawValue;\r\n        if (isRadioInput(ref) && options) {\r\n            options.forEach(({ ref: radioRef }) => (radioRef.checked = radioRef.value === value));\r\n        }\r\n        else if (isFileInput(ref)) {\r\n            if (isString(value)) {\r\n                ref.value = value;\r\n            }\r\n            else {\r\n                ref.files = value;\r\n            }\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 = value.includes(checkboxRef.value)))\r\n                : (options[0].ref.checked = !!value);\r\n        }\r\n        else {\r\n            ref.value = value;\r\n        }\r\n    }, [isWeb]);\r\n    const setDirty = useCallback((name) => {\r\n        if (!fieldsRef.current[name] ||\r\n            (!readFormStateRef.current.dirty && !readFormStateRef.current.dirtyFields)) {\r\n            return false;\r\n        }\r\n        let isFieldDirty = defaultValuesAtRenderRef.current[name] !==\r\n            getFieldValue(fieldsRef.current, fieldsRef.current[name].ref);\r\n        const isFieldArray = isNameInFieldArray(fieldArrayNamesRef.current, name);\r\n        const previousDirtyFieldsLength = dirtyFieldsRef.current.size;\r\n        if (isFieldArray) {\r\n            const fieldArrayName = getFieldArrayParentName(name);\r\n            isFieldDirty = getIsFieldsDifferent(getFieldValueByName(fieldsRef.current, fieldArrayName), get(defaultValuesRef.current, fieldArrayName));\r\n        }\r\n        const isDirtyChanged = (isFieldArray ? isDirtyRef.current : dirtyFieldsRef.current.has(name)) !==\r\n            isFieldDirty;\r\n        if (isFieldDirty) {\r\n            dirtyFieldsRef.current.add(name);\r\n        }\r\n        else {\r\n            dirtyFieldsRef.current.delete(name);\r\n        }\r\n        isDirtyRef.current = isFieldArray\r\n            ? isFieldDirty\r\n            : !!dirtyFieldsRef.current.size;\r\n        return readFormStateRef.current.dirty\r\n            ? isDirtyChanged\r\n            : previousDirtyFieldsLength !== dirtyFieldsRef.current.size;\r\n    }, []);\r\n    const setInternalValues = useCallback((name, value, parentFieldName) => {\r\n        const isValueArray = isArray(value);\r\n        for (const key in value) {\r\n            const fieldName = `${parentFieldName || name}${isValueArray ? `[${key}]` : `.${key}`}`;\r\n            const field = fieldsRef.current[fieldName];\r\n            if (isObject(value[key])) {\r\n                setInternalValues(name, value[key], fieldName);\r\n            }\r\n            if (field) {\r\n                setFieldValue(field, value[key]);\r\n                setDirty(fieldName);\r\n            }\r\n        }\r\n    }, [setFieldValue, setDirty]);\r\n    const setInternalValue = useCallback((name, value) => {\r\n        const field = fieldsRef.current[name];\r\n        if (field) {\r\n            setFieldValue(field, value);\r\n            const output = setDirty(name);\r\n            if (isBoolean(output)) {\r\n                return output;\r\n            }\r\n        }\r\n        else if (!isPrimitive(value)) {\r\n            setInternalValues(name, value);\r\n        }\r\n    }, [setDirty, setFieldValue, setInternalValues]);\r\n    const executeValidation = useCallback(async (name, skipReRender) => {\r\n        const field = fieldsRef.current[name];\r\n        if (field) {\r\n            const error = await validateField(fieldsRef, validateAllFieldCriteria, field);\r\n            shouldRenderBaseOnError(name, error, skipReRender ? null : false);\r\n            return isEmptyObject(error);\r\n        }\r\n        return false;\r\n    }, [shouldRenderBaseOnError, validateAllFieldCriteria]);\r\n    const executeSchemaOrResolverValidation = useCallback(async (payload) => {\r\n        const { errors } = await validateWithSchema(validationSchema, validateAllFieldCriteria, getFieldValueByName(fieldsRef.current), validationResolver, validationContextRef.current);\r\n        const previousFormIsValid = isValidRef.current;\r\n        isValidRef.current = isEmptyObject(errors);\r\n        if (isArray(payload)) {\r\n            payload.forEach((name) => {\r\n                const error = get(errors, name);\r\n                if (error) {\r\n                    set(errorsRef.current, name, error);\r\n                }\r\n                else {\r\n                    unset(errorsRef.current, [name]);\r\n                }\r\n            });\r\n            reRender();\r\n        }\r\n        else {\r\n            const error = get(errors, payload);\r\n            shouldRenderBaseOnError(payload, (error ? { [payload]: error } : {}), previousFormIsValid !== isValidRef.current);\r\n        }\r\n        return isEmptyObject(errorsRef.current);\r\n    }, [\r\n        reRender,\r\n        shouldRenderBaseOnError,\r\n        validateAllFieldCriteria,\r\n        validationResolver,\r\n        validationSchema,\r\n    ]);\r\n    const triggerValidation = useCallback(async (payload) => {\r\n        const fields = payload || Object.keys(fieldsRef.current);\r\n        if (shouldValidateSchemaOrResolver) {\r\n            return executeSchemaOrResolverValidation(fields);\r\n        }\r\n        if (isArray(fields)) {\r\n            const result = await Promise.all(fields.map(async (data) => await executeValidation(data, true)));\r\n            reRender();\r\n            return result.every(Boolean);\r\n        }\r\n        return await executeValidation(fields);\r\n    }, [\r\n        executeSchemaOrResolverValidation,\r\n        executeValidation,\r\n        reRender,\r\n        shouldValidateSchemaOrResolver,\r\n    ]);\r\n    const isFieldWatched = (name) => isWatchAllRef.current ||\r\n        watchFieldsRef.current.has(name) ||\r\n        watchFieldsRef.current.has((name.match(/\\w+/) || [])[0]);\r\n    function setValue(names, valueOrShouldValidate, shouldValidate) {\r\n        let shouldRender = false;\r\n        const isArrayValue = isArray(names);\r\n        (isArrayValue\r\n            ? names\r\n            : [names]).forEach((name) => {\r\n            const isStringFieldName = isString(name);\r\n            shouldRender =\r\n                setInternalValue(isStringFieldName ? name : Object.keys(name)[0], isStringFieldName\r\n                    ? valueOrShouldValidate\r\n                    : Object.values(name)[0]) || isArrayValue\r\n                    ? true\r\n                    : isFieldWatched(name);\r\n        });\r\n        if (shouldRender || isArrayValue) {\r\n            reRender();\r\n        }\r\n        if (shouldValidate || (isArrayValue && valueOrShouldValidate)) {\r\n            triggerValidation(isArrayValue ? undefined : names);\r\n        }\r\n    }\r\n    handleChangeRef.current = handleChangeRef.current\r\n        ? handleChangeRef.current\r\n        : async ({ type, target }) => {\r\n            const name = target ? target.name : '';\r\n            const fields = fieldsRef.current;\r\n            const errors = errorsRef.current;\r\n            const field = fields[name];\r\n            const currentError = get(errors, name);\r\n            let error;\r\n            if (!field) {\r\n                return;\r\n            }\r\n            const isBlurEvent = type === EVENTS.BLUR;\r\n            const shouldSkipValidation = skipValidation({\r\n                hasError: !!currentError,\r\n                isOnChange,\r\n                isBlurEvent,\r\n                isOnSubmit,\r\n                isReValidateOnSubmit,\r\n                isOnBlur,\r\n                isReValidateOnBlur,\r\n                isSubmitted: isSubmittedRef.current,\r\n            });\r\n            const shouldUpdateDirty = setDirty(name);\r\n            let shouldRender = isFieldWatched(name) || shouldUpdateDirty;\r\n            if (isBlurEvent &&\r\n                !get(touchedFieldsRef.current, name) &&\r\n                readFormStateRef.current.touched) {\r\n                set(touchedFieldsRef.current, name, true);\r\n                shouldRender = true;\r\n            }\r\n            if (shouldSkipValidation) {\r\n                return shouldRender && reRender();\r\n            }\r\n            if (shouldValidateSchemaOrResolver) {\r\n                const { errors } = await validateWithSchema(validationSchema, validateAllFieldCriteria, getFieldValueByName(fields), validationResolver, validationContextRef.current);\r\n                const previousFormIsValid = isValidRef.current;\r\n                isValidRef.current = isEmptyObject(errors);\r\n                error = (get(errors, name)\r\n                    ? { [name]: get(errors, name) }\r\n                    : {});\r\n                if (previousFormIsValid !== isValidRef.current) {\r\n                    shouldRender = true;\r\n                }\r\n            }\r\n            else {\r\n                error = await validateField(fieldsRef, validateAllFieldCriteria, field);\r\n            }\r\n            if (!shouldRenderBaseOnError(name, error) && shouldRender) {\r\n                reRender();\r\n            }\r\n        };\r\n    const validateSchemaOrResolver = useCallback((values = {}) => {\r\n        const fieldValues = isEmptyObject(defaultValuesRef.current)\r\n            ? getFieldsValues(fieldsRef.current)\r\n            : defaultValuesRef.current;\r\n        validateWithSchema(validationSchema, validateAllFieldCriteria, transformToNestObject(Object.assign(Object.assign({}, fieldValues), values)), validationResolver, validationContextRef.current).then(({ errors }) => {\r\n            const previousFormIsValid = isValidRef.current;\r\n            isValidRef.current = isEmptyObject(errors);\r\n            if (previousFormIsValid !== isValidRef.current) {\r\n                reRender();\r\n            }\r\n        });\r\n    }, \r\n    // eslint-disable-next-line react-hooks/exhaustive-deps\r\n    [reRender, validateAllFieldCriteria, validationResolver]);\r\n    const removeFieldEventListener = useCallback((field, forceDelete) => {\r\n        if (handleChangeRef.current && field) {\r\n            findRemovedFieldAndRemoveListener(fieldsRef.current, handleChangeRef.current, field, forceDelete);\r\n        }\r\n    }, []);\r\n    const removeFieldEventListenerAndRef = useCallback((field, forceDelete) => {\r\n        if (!field ||\r\n            (field &&\r\n                isNameInFieldArray(fieldArrayNamesRef.current, field.ref.name) &&\r\n                !forceDelete)) {\r\n            return;\r\n        }\r\n        removeFieldEventListener(field, forceDelete);\r\n        const { name } = field.ref;\r\n        errorsRef.current = unset(errorsRef.current, [name]);\r\n        touchedFieldsRef.current = unset(touchedFieldsRef.current, [name]);\r\n        defaultValuesAtRenderRef.current = unset(defaultValuesAtRenderRef.current, [name]);\r\n        [\r\n            dirtyFieldsRef,\r\n            fieldsWithValidationRef,\r\n            validFieldsRef,\r\n            watchFieldsRef,\r\n        ].forEach((data) => data.current.delete(name));\r\n        if (readFormStateRef.current.isValid ||\r\n            readFormStateRef.current.touched) {\r\n            reRender();\r\n            if (shouldValidateSchemaOrResolver) {\r\n                validateSchemaOrResolver();\r\n            }\r\n        }\r\n    }, [\r\n        reRender,\r\n        shouldValidateSchemaOrResolver,\r\n        validateSchemaOrResolver,\r\n        removeFieldEventListener,\r\n    ]);\r\n    function clearError(name) {\r\n        if (name) {\r\n            unset(errorsRef.current, isArray(name) ? name : [name]);\r\n        }\r\n        else {\r\n            errorsRef.current = {};\r\n        }\r\n        reRender();\r\n    }\r\n    const setInternalError = ({ name, type, types, message, shouldRender, }) => {\r\n        const field = fieldsRef.current[name];\r\n        if (!isSameError(get(errorsRef.current, name), {\r\n            type,\r\n            message,\r\n            types,\r\n        })) {\r\n            set(errorsRef.current, name, {\r\n                type,\r\n                types,\r\n                message,\r\n                ref: field ? field.ref : {},\r\n                isManual: true,\r\n            });\r\n            if (shouldRender) {\r\n                reRender();\r\n            }\r\n        }\r\n    };\r\n    function setError(name, type = '', message) {\r\n        if (isString(name)) {\r\n            setInternalError(Object.assign(Object.assign({ name }, (isObject(type)\r\n                ? {\r\n                    types: type,\r\n                    type: '',\r\n                }\r\n                : {\r\n                    type,\r\n                    message,\r\n                })), { shouldRender: true }));\r\n        }\r\n        else if (isArray(name)) {\r\n            name.forEach((error) => setInternalError(Object.assign({}, error)));\r\n            reRender();\r\n        }\r\n    }\r\n    function watch(fieldNames, defaultValue) {\r\n        const watchFields = watchFieldsRef.current;\r\n        const isDefaultValueUndefined = isUndefined(defaultValue);\r\n        const combinedDefaultValues = isDefaultValueUndefined\r\n            ? defaultValuesRef.current\r\n            : defaultValue;\r\n        const fieldValues = getFieldsValues(fieldsRef.current, fieldNames);\r\n        if (isString(fieldNames)) {\r\n            return assignWatchFields(fieldValues, fieldNames, watchFields, isDefaultValueUndefined\r\n                ? get(combinedDefaultValues, fieldNames)\r\n                : defaultValue, true);\r\n        }\r\n        if (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 = true;\r\n        const result = (!isEmptyObject(fieldValues) && fieldValues) || combinedDefaultValues;\r\n        return fieldNames && fieldNames.nest\r\n            ? transformToNestObject(result)\r\n            : result;\r\n    }\r\n    function unregister(name) {\r\n        if (fieldsRef.current) {\r\n            (isArray(name) ? name : [name]).forEach((fieldName) => removeFieldEventListenerAndRef(fieldsRef.current[fieldName], true));\r\n        }\r\n    }\r\n    function registerFieldsRef(ref, validateOptions = {}) {\r\n        if (!ref.name) {\r\n            // eslint-disable-next-line no-console\r\n            return console.warn('Missing name @', ref);\r\n        }\r\n        const { name, type, value } = ref;\r\n        const fieldRefAndValidationOptions = Object.assign({ ref }, validateOptions);\r\n        const fields = fieldsRef.current;\r\n        const isRadioOrCheckbox = isRadioOrCheckboxFunction(ref);\r\n        let field = fields[name];\r\n        let isEmptyDefaultValue = true;\r\n        let isFieldArray;\r\n        let defaultValue;\r\n        if (isRadioOrCheckbox\r\n            ? field &&\r\n                isArray(field.options) &&\r\n                field.options.filter(Boolean).find((option) => {\r\n                    return value === option.ref.value && option.ref === ref;\r\n                })\r\n            : field && ref === field.ref) {\r\n            fields[name] = Object.assign(Object.assign({}, field), validateOptions);\r\n            return;\r\n        }\r\n        if (type) {\r\n            const mutationWatcher = onDomRemove(ref, () => removeFieldEventListenerAndRef(field));\r\n            field = isRadioOrCheckbox\r\n                ? Object.assign({ options: [\r\n                        ...((field && field.options) || []),\r\n                        {\r\n                            ref,\r\n                            mutationWatcher,\r\n                        },\r\n                    ], ref: { type, name } }, validateOptions) : Object.assign(Object.assign({}, fieldRefAndValidationOptions), { mutationWatcher });\r\n        }\r\n        else {\r\n            field = fieldRefAndValidationOptions;\r\n        }\r\n        fields[name] = field;\r\n        if (!isEmptyObject(defaultValuesRef.current)) {\r\n            defaultValue = get(defaultValuesRef.current, name);\r\n            isEmptyDefaultValue = isUndefined(defaultValue);\r\n            isFieldArray = isNameInFieldArray(fieldArrayNamesRef.current, name);\r\n            if (!isEmptyDefaultValue && !isFieldArray) {\r\n                setFieldValue(field, defaultValue);\r\n            }\r\n        }\r\n        if (shouldValidateSchemaOrResolver &&\r\n            !isFieldArray &&\r\n            readFormStateRef.current.isValid) {\r\n            validateSchemaOrResolver();\r\n        }\r\n        else if (!isEmptyObject(validateOptions)) {\r\n            fieldsWithValidationRef.current.add(name);\r\n            if (!isOnSubmit && readFormStateRef.current.isValid) {\r\n                validateField(fieldsRef, validateAllFieldCriteria, field).then((error) => {\r\n                    const previousFormIsValid = isValidRef.current;\r\n                    isEmptyObject(error)\r\n                        ? validFieldsRef.current.add(name)\r\n                        : (isValidRef.current = false);\r\n                    if (previousFormIsValid !== isValidRef.current) {\r\n                        reRender();\r\n                    }\r\n                });\r\n            }\r\n        }\r\n        if (!defaultValuesAtRenderRef.current[name] &&\r\n            !(isFieldArray && isEmptyDefaultValue)) {\r\n            defaultValuesAtRenderRef.current[name] = isEmptyDefaultValue ? getFieldValue(fields, field.ref) : defaultValue;\r\n        }\r\n        if (type) {\r\n            attachEventListeners({\r\n                field: isRadioOrCheckbox && field.options\r\n                    ? field.options[field.options.length - 1]\r\n                    : field,\r\n                isRadioOrCheckbox: isRadioOrCheckbox || isSelectInput(ref),\r\n                handleChange: handleChangeRef.current,\r\n            });\r\n        }\r\n    }\r\n    function register(refOrValidationOptions, validationOptions) {\r\n        if (isWindowUndefined) {\r\n            return;\r\n        }\r\n        if (isString(refOrValidationOptions)) {\r\n            registerFieldsRef({ name: refOrValidationOptions }, validationOptions);\r\n            return;\r\n        }\r\n        if (isObject(refOrValidationOptions) && 'name' in refOrValidationOptions) {\r\n            registerFieldsRef(refOrValidationOptions, validationOptions);\r\n            return;\r\n        }\r\n        return (ref) => ref && registerFieldsRef(ref, refOrValidationOptions);\r\n    }\r\n    const handleSubmit = useCallback((callback) => async (e) => {\r\n        if (e) {\r\n            e.preventDefault();\r\n            e.persist();\r\n        }\r\n        let fieldErrors = {};\r\n        const fields = fieldsRef.current;\r\n        let fieldValues = getFieldsValues(fields);\r\n        if (readFormStateRef.current.isSubmitting) {\r\n            isSubmittingRef.current = true;\r\n            reRender();\r\n        }\r\n        try {\r\n            if (shouldValidateSchemaOrResolver) {\r\n                const { errors, values } = await validateWithSchema(validationSchema, validateAllFieldCriteria, transformToNestObject(fieldValues), validationResolver, validationContextRef.current);\r\n                errorsRef.current = errors;\r\n                fieldErrors = errors;\r\n                fieldValues = values;\r\n            }\r\n            else {\r\n                for (const field of Object.values(fields)) {\r\n                    if (field) {\r\n                        const { ref: { name }, } = field;\r\n                        const fieldError = await validateField(fieldsRef, validateAllFieldCriteria, field);\r\n                        if (fieldError[name]) {\r\n                            set(fieldErrors, name, fieldError[name]);\r\n                            validFieldsRef.current.delete(name);\r\n                        }\r\n                        else {\r\n                            if (fieldsWithValidationRef.current.has(name)) {\r\n                                validFieldsRef.current.add(name);\r\n                            }\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n            if (isEmptyObject(fieldErrors)) {\r\n                errorsRef.current = {};\r\n                reRender();\r\n                await callback(transformToNestObject(fieldValues), e);\r\n            }\r\n            else {\r\n                errorsRef.current = fieldErrors;\r\n                if (submitFocusError && isWeb) {\r\n                    focusOnErrorField(fields, fieldErrors);\r\n                }\r\n            }\r\n        }\r\n        finally {\r\n            isSubmittedRef.current = true;\r\n            isSubmittingRef.current = false;\r\n            submitCountRef.current = submitCountRef.current + 1;\r\n            reRender();\r\n        }\r\n    }, [\r\n        isWeb,\r\n        reRender,\r\n        shouldValidateSchemaOrResolver,\r\n        submitFocusError,\r\n        validateAllFieldCriteria,\r\n        validationResolver,\r\n        validationSchema,\r\n    ]);\r\n    const resetRefs = ({ errors, dirty, isSubmitted, touched, isValid, submitCount, dirtyFields, }) => {\r\n        fieldsRef.current = {};\r\n        if (!errors) {\r\n            errorsRef.current = {};\r\n        }\r\n        if (!touched) {\r\n            touchedFieldsRef.current = {};\r\n        }\r\n        if (!isValid) {\r\n            validFieldsRef.current = new Set();\r\n            fieldsWithValidationRef.current = new Set();\r\n            isValidRef.current = true;\r\n        }\r\n        if (!dirty) {\r\n            isDirtyRef.current = false;\r\n        }\r\n        if (!dirtyFields) {\r\n            dirtyFieldsRef.current = new Set();\r\n        }\r\n        if (!isSubmitted) {\r\n            isSubmittedRef.current = false;\r\n        }\r\n        if (!submitCount) {\r\n            submitCountRef.current = 0;\r\n        }\r\n        defaultValuesAtRenderRef.current = {};\r\n        fieldArrayDefaultValues.current = {};\r\n        watchFieldsRef.current = new Set();\r\n        isWatchAllRef.current = false;\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) && 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        if (values) {\r\n            defaultValuesRef.current = values;\r\n        }\r\n        Object.values(resetFieldArrayFunctionRef.current).forEach((resetFieldArray) => isFunction(resetFieldArray) && resetFieldArray());\r\n        resetRefs(omitResetState);\r\n        reRender();\r\n    };\r\n    function getValues(payload) {\r\n        if (isString(payload)) {\r\n            return fieldsRef.current[payload]\r\n                ? getFieldValue(fieldsRef.current, fieldsRef.current[payload].ref)\r\n                : get(defaultValuesRef.current, payload);\r\n        }\r\n        const fieldValues = getFieldsValues(fieldsRef.current);\r\n        const outputValues = isEmptyObject(fieldValues)\r\n            ? defaultValuesRef.current\r\n            : fieldValues;\r\n        return payload && payload.nest\r\n            ? transformToNestObject(outputValues)\r\n            : outputValues;\r\n    }\r\n    useEffect(() => () => {\r\n        isUnMount.current = true;\r\n        fieldsRef.current &&\r\n            process.env.NODE_ENV === 'production' &&\r\n            Object.values(fieldsRef.current).forEach((field) => removeFieldEventListenerAndRef(field, true));\r\n    }, [removeFieldEventListenerAndRef]);\r\n    if (!shouldValidateSchemaOrResolver) {\r\n        isValidRef.current =\r\n            validFieldsRef.current.size >= fieldsWithValidationRef.current.size &&\r\n                isEmptyObject(errorsRef.current);\r\n    }\r\n    const formState = {\r\n        dirty: isDirtyRef.current,\r\n        dirtyFields: dirtyFieldsRef.current,\r\n        isSubmitted: isSubmittedRef.current,\r\n        submitCount: submitCountRef.current,\r\n        touched: touchedFieldsRef.current,\r\n        isSubmitting: isSubmittingRef.current,\r\n        isValid: isOnSubmit\r\n            ? isSubmittedRef.current && isEmptyObject(errorsRef.current)\r\n            : isValidRef.current,\r\n    };\r\n    const commonProps = {\r\n        triggerValidation,\r\n        setValue: useCallback(setValue, [\r\n            reRender,\r\n            setInternalValue,\r\n            triggerValidation,\r\n        ]),\r\n        register: useCallback(register, [\r\n            defaultValuesRef.current,\r\n            defaultValuesAtRenderRef.current,\r\n        ]),\r\n        unregister: useCallback(unregister, []),\r\n        getValues: useCallback(getValues, []),\r\n        formState: isProxyEnabled\r\n            ? new Proxy(formState, {\r\n                get: (obj, prop) => {\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 = Object.assign(Object.assign(Object.assign({ removeFieldEventListener,\r\n        reRender }, (shouldValidateSchemaOrResolver\r\n        ? { validateSchemaIsValid: validateSchemaOrResolver }\r\n        : {})), { mode: {\r\n            isOnBlur,\r\n            isOnSubmit,\r\n            isOnChange,\r\n        }, reValidateMode: {\r\n            isReValidateOnBlur,\r\n            isReValidateOnSubmit,\r\n        }, errorsRef,\r\n        touchedFieldsRef,\r\n        fieldsRef,\r\n        isWatchAllRef,\r\n        watchFieldsRef,\r\n        resetFieldArrayFunctionRef,\r\n        fieldArrayDefaultValues,\r\n        validFieldsRef,\r\n        dirtyFieldsRef,\r\n        fieldsWithValidationRef,\r\n        fieldArrayNamesRef,\r\n        isDirtyRef,\r\n        readFormStateRef,\r\n        defaultValuesRef }), commonProps);\r\n    return Object.assign({ watch,\r\n        control,\r\n        handleSubmit, reset: useCallback(reset, []), clearError: useCallback(clearError, []), setError: useCallback(setError, []), errors: errorsRef.current }, commonProps);\r\n}\n\n/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation. All rights reserved.\r\nLicensed under the Apache License, Version 2.0 (the \"License\"); you may not use\r\nthis file except in compliance with the License. You may obtain a copy of the\r\nLicense at http://www.apache.org/licenses/LICENSE-2.0\r\n\r\nTHIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\r\nKIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED\r\nWARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,\r\nMERCHANTABLITY OR NON-INFRINGEMENT.\r\n\r\nSee the Apache Version 2.0 License for specific language governing permissions\r\nand limitations under the License.\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 FormGlobalContext = createContext(null);\r\nfunction useFormContext() {\r\n    return useContext(FormGlobalContext);\r\n}\r\nfunction FormContext(_a) {\r\n    var { children, formState, errors } = _a, restMethods = __rest(_a, [\"children\", \"formState\", \"errors\"]);\r\n    return (createElement(FormGlobalContext.Provider, { value: Object.assign(Object.assign({}, restMethods), { formState, errors }) }, 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, function (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\nconst appendId = (value, keyName) => (Object.assign({ [keyName]: generateId() }, (isObject(value) ? value : { value })));\r\nconst mapIds = (data, keyName) => (isArray(data) ? data : []).map((value) => appendId(value, keyName));\n\nvar getSortRemovedItems = (indexes, removeIndexes, updatedIndexes = [], count = 0, notFoundIndexes = []) => {\r\n    for (const removeIndex of removeIndexes) {\r\n        if (indexes.indexOf(removeIndex) < 0) {\r\n            notFoundIndexes.push(removeIndex);\r\n        }\r\n    }\r\n    for (const index of indexes.sort()) {\r\n        if (removeIndexes.indexOf(index) > -1) {\r\n            updatedIndexes.push(-1);\r\n            count++;\r\n        }\r\n        else {\r\n            updatedIndexes.push(index -\r\n                count -\r\n                (notFoundIndexes.length\r\n                    ? notFoundIndexes\r\n                        .map((notFoundIndex) => notFoundIndex < index)\r\n                        .filter(Boolean).length\r\n                    : 0));\r\n        }\r\n    }\r\n    return updatedIndexes;\r\n};\n\nconst removeAt = (data, index) => [\r\n    ...data.slice(0, index),\r\n    ...data.slice(index + 1),\r\n];\r\nfunction removeAtIndexes(data, index) {\r\n    let k = -1;\r\n    while (++k < data.length) {\r\n        if (index.indexOf(k) >= 0) {\r\n            delete data[k];\r\n        }\r\n    }\r\n    return data.filter(Boolean);\r\n}\r\nvar removeArrayAt = (data, index) => isUndefined(index)\r\n    ? []\r\n    : isArray(index)\r\n        ? removeAtIndexes(data, index)\r\n        : removeAt(data, index);\n\nvar moveArrayAt = (data, from, to) => isArray(data) ? data.splice(to, 0, data.splice(from, 1)[0]) : [];\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 [...(isArray(value) ? value : [value || null]), ...data];\r\n}\n\nfunction insert(data, index, value) {\r\n    return [\r\n        ...data.slice(0, index),\r\n        ...(isArray(value) ? value : [value || null]),\r\n        ...data.slice(index),\r\n    ];\r\n}\n\nvar fillEmptyArray = (value) => isArray(value) ? Array(value.length).fill(null) : null;\n\nconst useFieldArray = ({ control, name, keyName = 'id', }) => {\r\n    const methods = useFormContext();\r\n    const { isWatchAllRef, resetFieldArrayFunctionRef, fieldArrayNamesRef, reRender, fieldsRef, getValues, defaultValuesRef, removeFieldEventListener, errorsRef, dirtyFieldsRef, isDirtyRef, touchedFieldsRef, readFormStateRef, watchFieldsRef, validFieldsRef, fieldsWithValidationRef, fieldArrayDefaultValues, validateSchemaIsValid, } = control || methods.control;\r\n    const getDefaultValues = () => [\r\n        ...get(fieldArrayDefaultValues.current[getFieldArrayParentName(name)]\r\n            ? fieldArrayDefaultValues.current\r\n            : defaultValuesRef.current, name, []),\r\n    ];\r\n    const memoizedDefaultValues = useRef(getDefaultValues());\r\n    const [fields, setField] = useState(mapIds(memoizedDefaultValues.current, keyName));\r\n    const [isDeleted, setIsDeleted] = useState(false);\r\n    const allFields = useRef(fields);\r\n    const isNameKey = isKey(name);\r\n    allFields.current = fields;\r\n    if (isNameKey) {\r\n        fieldArrayDefaultValues.current[name] = memoizedDefaultValues.current;\r\n    }\r\n    const appendValueWithKey = (values) => values.map((value) => appendId(value, keyName));\r\n    const setFieldAndValidState = (fieldsValues) => {\r\n        setField(fieldsValues);\r\n        if (readFormStateRef.current.isValid && validateSchemaIsValid) {\r\n            validateSchemaIsValid({\r\n                [name]: fieldsValues,\r\n            });\r\n        }\r\n    };\r\n    const modifyDirtyFields = ({ shouldRender, isRemove, isPrePend, index, value = {}, } = {}) => {\r\n        let render = shouldRender;\r\n        const values = isArray(value) ? value : [value];\r\n        if (readFormStateRef.current.dirty) {\r\n            const dirtyFieldIndexesAndValues = {};\r\n            if (isPrePend || isRemove) {\r\n                for (const dirtyField of [...dirtyFieldsRef.current].sort()) {\r\n                    if (isMatchFieldArrayName(dirtyField, name)) {\r\n                        const matchedIndexes = dirtyField.match(REGEX_ARRAY_FIELD_INDEX);\r\n                        if (matchedIndexes) {\r\n                            const matchIndex = +matchedIndexes[matchedIndexes.length - 1];\r\n                            if (dirtyFieldIndexesAndValues[matchIndex]) {\r\n                                dirtyFieldIndexesAndValues[matchIndex].push(dirtyField);\r\n                            }\r\n                            else {\r\n                                dirtyFieldIndexesAndValues[matchIndex] = [dirtyField];\r\n                            }\r\n                        }\r\n                        dirtyFieldsRef.current.delete(dirtyField);\r\n                    }\r\n                }\r\n            }\r\n            if (!isUndefined(index) || isPrePend) {\r\n                const updatedDirtyFieldIndexes = isUndefined(index)\r\n                    ? []\r\n                    : getSortRemovedItems(Object.keys(dirtyFieldIndexesAndValues).map((i) => +i), isArray(index) ? index : [index]);\r\n                Object.values(dirtyFieldIndexesAndValues).forEach((values, index) => {\r\n                    const updateIndex = isPrePend ? 0 : updatedDirtyFieldIndexes[index];\r\n                    if (updateIndex > -1) {\r\n                        for (const value of values) {\r\n                            const matchedIndexes = value.match(REGEX_ARRAY_FIELD_INDEX);\r\n                            if (matchedIndexes) {\r\n                                dirtyFieldsRef.current.add(value.replace(/[\\d+]([^[\\d+]+)$/, `${isPrePend\r\n                                    ? +matchedIndexes[matchedIndexes.length - 1] +\r\n                                        values.length\r\n                                    : updateIndex}$1`));\r\n                            }\r\n                        }\r\n                    }\r\n                });\r\n            }\r\n            if (!isRemove) {\r\n                values.forEach((fieldValue, index) => Object.keys(fieldValue).forEach((key) => dirtyFieldsRef.current.add(`${name}[${isPrePend ? index : allFields.current.length + index}].${key}`)));\r\n                isDirtyRef.current = true;\r\n            }\r\n            render = true;\r\n        }\r\n        if (render && !isWatchAllRef.current) {\r\n            reRender();\r\n        }\r\n    };\r\n    const resetFields = (flagOrFields) => {\r\n        if (readFormStateRef.current.dirty) {\r\n            isDirtyRef.current = isUndefined(flagOrFields)\r\n                ? true\r\n                : getIsFieldsDifferent(flagOrFields, defaultValuesRef.current[name] || []);\r\n        }\r\n        for (const key in fieldsRef.current) {\r\n            if (isMatchFieldArrayName(key, name) && fieldsRef.current[key]) {\r\n                removeFieldEventListener(fieldsRef.current[key], true);\r\n            }\r\n        }\r\n    };\r\n    const mapCurrentFieldsValueWithState = () => {\r\n        const currentFieldsValue = get(getValues({ nest: true }), name);\r\n        if (isArray(currentFieldsValue)) {\r\n            for (let i = 0; i < currentFieldsValue.length; i++) {\r\n                allFields.current[i] = Object.assign(Object.assign({}, allFields.current[i]), currentFieldsValue[i]);\r\n            }\r\n        }\r\n    };\r\n    const append = (value) => {\r\n        setFieldAndValidState([\r\n            ...allFields.current,\r\n            ...(isArray(value)\r\n                ? appendValueWithKey(value)\r\n                : [appendId(value, keyName)]),\r\n        ]);\r\n        modifyDirtyFields({ value });\r\n    };\r\n    const prepend$1 = (value) => {\r\n        let shouldRender = false;\r\n        resetFields();\r\n        setFieldAndValidState(prepend(allFields.current, isArray(value) ? appendValueWithKey(value) : [appendId(value, keyName)]));\r\n        if (errorsRef.current[name]) {\r\n            errorsRef.current[name] = prepend(errorsRef.current[name], fillEmptyArray(value));\r\n        }\r\n        if (readFormStateRef.current.touched && touchedFieldsRef.current[name]) {\r\n            touchedFieldsRef.current[name] = prepend(touchedFieldsRef.current[name], fillEmptyArray(value));\r\n            shouldRender = true;\r\n        }\r\n        modifyDirtyFields({\r\n            shouldRender,\r\n            isPrePend: true,\r\n            value,\r\n        });\r\n    };\r\n    const remove = (index) => {\r\n        let shouldRender = false;\r\n        const isIndexUndefined = isUndefined(index);\r\n        if (!isIndexUndefined) {\r\n            mapCurrentFieldsValueWithState();\r\n        }\r\n        resetFields(removeArrayAt(getFieldValueByName(fieldsRef.current, name), index));\r\n        setFieldAndValidState(removeArrayAt(allFields.current, index));\r\n        setIsDeleted(true);\r\n        if (errorsRef.current[name]) {\r\n            errorsRef.current[name] = removeArrayAt(errorsRef.current[name], index);\r\n            if (!errorsRef.current[name].filter(Boolean).length) {\r\n                delete errorsRef.current[name];\r\n            }\r\n        }\r\n        if (readFormStateRef.current.touched && touchedFieldsRef.current[name]) {\r\n            touchedFieldsRef.current[name] = removeArrayAt(touchedFieldsRef.current[name], index);\r\n            shouldRender = true;\r\n        }\r\n        if (readFormStateRef.current.isValid && !validateSchemaIsValid) {\r\n            let fieldIndex = -1;\r\n            let isFound = false;\r\n            const isIndexUndefined = isUndefined(index);\r\n            while (fieldIndex++ < fields.length) {\r\n                const isLast = fieldIndex === fields.length - 1;\r\n                const isCurrentIndex = (isArray(index) ? index : [index]).indexOf(fieldIndex) >= 0;\r\n                if (isCurrentIndex || isIndexUndefined) {\r\n                    isFound = true;\r\n                }\r\n                if (!isFound) {\r\n                    continue;\r\n                }\r\n                for (const key in fields[fieldIndex]) {\r\n                    const currentFieldName = `${name}[${fieldIndex}].${key}`;\r\n                    if (isCurrentIndex || isLast || isIndexUndefined) {\r\n                        validFieldsRef.current.delete(currentFieldName);\r\n                        fieldsWithValidationRef.current.delete(currentFieldName);\r\n                    }\r\n                    else {\r\n                        const previousFieldName = `${name}[${fieldIndex - 1}].${key}`;\r\n                        if (validFieldsRef.current.has(currentFieldName)) {\r\n                            validFieldsRef.current.add(previousFieldName);\r\n                        }\r\n                        if (fieldsWithValidationRef.current.has(currentFieldName)) {\r\n                            fieldsWithValidationRef.current.add(previousFieldName);\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n        }\r\n        modifyDirtyFields({\r\n            shouldRender,\r\n            isRemove: true,\r\n            index,\r\n        });\r\n    };\r\n    const insert$1 = (index, value) => {\r\n        mapCurrentFieldsValueWithState();\r\n        resetFields(insert(getFieldValueByName(fieldsRef.current, name), index));\r\n        setFieldAndValidState(insert(allFields.current, index, isArray(value) ? appendValueWithKey(value) : [appendId(value, keyName)]));\r\n        if (errorsRef.current[name]) {\r\n            errorsRef.current[name] = insert(errorsRef.current[name], index, fillEmptyArray(value));\r\n        }\r\n        if (readFormStateRef.current.touched && touchedFieldsRef.current[name]) {\r\n            touchedFieldsRef.current[name] = insert(touchedFieldsRef.current[name], index, fillEmptyArray(value));\r\n            reRender();\r\n        }\r\n    };\r\n    const swap = (indexA, indexB) => {\r\n        mapCurrentFieldsValueWithState();\r\n        const fieldValues = getFieldValueByName(fieldsRef.current, name);\r\n        swapArrayAt(fieldValues, indexA, indexB);\r\n        resetFields(fieldValues);\r\n        swapArrayAt(allFields.current, indexA, indexB);\r\n        setFieldAndValidState([...allFields.current]);\r\n        if (errorsRef.current[name]) {\r\n            swapArrayAt(errorsRef.current[name], indexA, indexB);\r\n        }\r\n        if (readFormStateRef.current.touched && touchedFieldsRef.current[name]) {\r\n            swapArrayAt(touchedFieldsRef.current[name], indexA, indexB);\r\n            reRender();\r\n        }\r\n    };\r\n    const move = (from, to) => {\r\n        mapCurrentFieldsValueWithState();\r\n        const fieldValues = getFieldValueByName(fieldsRef.current, name);\r\n        moveArrayAt(fieldValues, from, to);\r\n        resetFields(fieldValues);\r\n        moveArrayAt(allFields.current, from, to);\r\n        setFieldAndValidState([...allFields.current]);\r\n        if (errorsRef.current[name]) {\r\n            moveArrayAt(errorsRef.current[name], from, to);\r\n        }\r\n        if (readFormStateRef.current.touched && touchedFieldsRef.current[name]) {\r\n            moveArrayAt(touchedFieldsRef.current[name], from, to);\r\n            reRender();\r\n        }\r\n    };\r\n    const reset = () => {\r\n        resetFields();\r\n        memoizedDefaultValues.current = getDefaultValues();\r\n        setField(mapIds(memoizedDefaultValues.current, keyName));\r\n    };\r\n    useEffect(() => {\r\n        if (isNameKey &&\r\n            isDeleted &&\r\n            fieldArrayDefaultValues.current[name] &&\r\n            fields.length < fieldArrayDefaultValues.current[name].length) {\r\n            fieldArrayDefaultValues.current[name].pop();\r\n        }\r\n    }, [fields, name, fieldArrayDefaultValues, isDeleted, isNameKey]);\r\n    useEffect(() => {\r\n        if (isWatchAllRef && isWatchAllRef.current) {\r\n            reRender();\r\n        }\r\n        else if (watchFieldsRef) {\r\n            for (const watchField of watchFieldsRef.current) {\r\n                if (watchField.startsWith(name)) {\r\n                    reRender();\r\n                    break;\r\n                }\r\n            }\r\n        }\r\n    }, [fields, name, reRender, watchFieldsRef, isWatchAllRef]);\r\n    useEffect(() => {\r\n        const resetFunctions = resetFieldArrayFunctionRef.current;\r\n        const fieldArrayNames = fieldArrayNamesRef.current;\r\n        fieldArrayNames.add(name);\r\n        resetFunctions[name] = reset;\r\n        return () => {\r\n            resetFields();\r\n            delete resetFunctions[name];\r\n            fieldArrayNames.delete(name);\r\n        };\r\n        // eslint-disable-next-line react-hooks/exhaustive-deps\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, [fields, name]),\r\n        insert: useCallback(insert$1, [name]),\r\n        fields,\r\n    };\r\n};\n\nvar getInputValue = (event, isCheckboxInput) => isPrimitive(event) ||\r\n    !isObject(event.target) ||\r\n    (isObject(event.target) && !event.type)\r\n    ? event\r\n    : isCheckboxInput || isUndefined(event.target.value)\r\n        ? event.target.checked\r\n        : event.target.value;\n\nconst Controller = (_a) => {\r\n    var { name, rules, as: InnerComponent, onBlur, onChange, onChangeName = VALIDATION_MODE.onChange, onBlurName = VALIDATION_MODE.onBlur, valueName, defaultValue, control, onFocus } = _a, rest = __rest(_a, [\"name\", \"rules\", \"as\", \"onBlur\", \"onChange\", \"onChangeName\", \"onBlurName\", \"valueName\", \"defaultValue\", \"control\", \"onFocus\"]);\r\n    const methods = useFormContext();\r\n    const { defaultValuesRef, setValue, register, unregister, errorsRef, removeFieldEventListener, triggerValidation, mode: { isOnSubmit, isOnBlur, isOnChange }, reValidateMode: { isReValidateOnBlur, isReValidateOnSubmit }, formState: { isSubmitted }, touchedFieldsRef, readFormStateRef, reRender, fieldsRef, fieldArrayNamesRef, } = control || methods.control;\r\n    const [value, setInputStateValue] = useState(isUndefined(defaultValue)\r\n        ? get(defaultValuesRef.current, name)\r\n        : defaultValue);\r\n    const valueRef = useRef(value);\r\n    const isCheckboxInput = isBoolean(value);\r\n    const shouldReValidateOnBlur = isOnBlur || isReValidateOnBlur;\r\n    const rulesRef = useRef(rules);\r\n    const onFocusRef = useRef(onFocus);\r\n    const isNotFieldArray = !isNameInFieldArray(fieldArrayNamesRef.current, name);\r\n    rulesRef.current = rules;\r\n    const shouldValidate = () => !skipValidation({\r\n        hasError: !!get(errorsRef.current, name),\r\n        isOnBlur,\r\n        isOnSubmit,\r\n        isOnChange,\r\n        isReValidateOnBlur,\r\n        isReValidateOnSubmit,\r\n        isSubmitted,\r\n    });\r\n    const commonTask = (event) => {\r\n        const data = getInputValue(event, isCheckboxInput);\r\n        setInputStateValue(data);\r\n        valueRef.current = data;\r\n        return data;\r\n    };\r\n    const eventWrapper = (event) => (...arg) => setValue(name, commonTask(event(arg)), shouldValidate());\r\n    const handleChange = (event) => {\r\n        const data = commonTask(event);\r\n        setValue(name, data, shouldValidate());\r\n    };\r\n    const registerField = useCallback(() => {\r\n        if (!isNotFieldArray) {\r\n            removeFieldEventListener(fieldsRef.current[name], true);\r\n        }\r\n        register(Object.defineProperty({ name, focus: onFocusRef.current }, 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        }), rulesRef.current);\r\n    }, [\r\n        isNotFieldArray,\r\n        fieldsRef,\r\n        rulesRef,\r\n        name,\r\n        onFocusRef,\r\n        register,\r\n        removeFieldEventListener,\r\n    ]);\r\n    useEffect(() => () => {\r\n        !isNameInFieldArray(fieldArrayNamesRef.current, name) && unregister(name);\r\n    }, [unregister, name, fieldArrayNamesRef]);\r\n    useEffect(() => {\r\n        registerField();\r\n    }, [registerField]);\r\n    // eslint-disable-next-line react-hooks/exhaustive-deps\r\n    useEffect(() => {\r\n        if (!fieldsRef.current[name]) {\r\n            registerField();\r\n            if (isNotFieldArray) {\r\n                setInputStateValue(isUndefined(defaultValue)\r\n                    ? get(defaultValuesRef.current, name)\r\n                    : defaultValue);\r\n            }\r\n        }\r\n    });\r\n    const props = Object.assign(Object.assign(Object.assign(Object.assign({ name }, rest), (onChange\r\n        ? { [onChangeName]: eventWrapper(onChange) }\r\n        : { [onChangeName]: handleChange })), { [onBlurName]: (...args) => {\r\n            if (onBlur) {\r\n                onBlur(args);\r\n            }\r\n            if (readFormStateRef.current.touched &&\r\n                !get(touchedFieldsRef.current, name)) {\r\n                set(touchedFieldsRef.current, name, true);\r\n                reRender();\r\n            }\r\n            if (shouldReValidateOnBlur) {\r\n                triggerValidation(name);\r\n            }\r\n        } }), { [valueName || (isCheckboxInput ? 'checked' : VALUE)]: value });\r\n    return isValidElement(InnerComponent)\r\n        ? cloneElement(InnerComponent, props)\r\n        : createElement(InnerComponent, props);\r\n};\n\nconst ErrorMessage = (_a) => {\r\n    var { as: InnerComponent, errors, name, message, children } = _a, rest = __rest(_a, [\"as\", \"errors\", \"name\", \"message\", \"children\"]);\r\n    const methods = useFormContext();\r\n    const error = get(errors || methods.errors, name);\r\n    if (!error) {\r\n        return null;\r\n    }\r\n    const { message: messageFromRegister, types } = error;\r\n    const props = Object.assign(Object.assign({}, (InnerComponent ? rest : {})), { children: children\r\n            ? children({ message: messageFromRegister || message, messages: types })\r\n            : messageFromRegister || message });\r\n    return InnerComponent ? (isValidElement(InnerComponent) ? (cloneElement(InnerComponent, props)) : (createElement(InnerComponent, props))) : (createElement(Fragment, Object.assign({}, props)));\r\n};\n\nexport { Controller, ErrorMessage, FormContext, useFieldArray, useForm, useFormContext };\n"],"names":["isNullOrUndefined","value","isArray","Array","isObjectType","isObject","isHTMLElement","nodeType","Node","ELEMENT_NODE","VALIDATION_MODE","onBlur","onChange","onSubmit","VALUE","UNDEFINED","EVENTS","SELECT","INPUT_VALIDATION_RULES","REGEX_IS_DEEP_PROP","REGEX_IS_PLAIN_PROP","REGEX_PROP_NAME","REGEX_ESCAPE_CHAR","isKey","test","stringToPath","string","result","replace","match","number","quote","push","set","object","path","index","tempPath","length","lastIndex","key","newValue","objValue","isNaN","transformToNestObject","data","Object","entries","reduce","previous","assign","isUndefined","val","undefined","get","obj","defaultValue","split","filter","Boolean","removeAllEventListeners","ref","validateWithStateUpdate","removeEventListener","isRadioInput","element","type","isCheckBoxInput","isDetached","HTMLElement","DOCUMENT_NODE","parentNode","isEmptyObject","keys","castPath","parent","updatePath","baseGet","array","start","end","baseSlice","unset","paths","forEach","childObject","previousObjRef","k","slice","objectRef","currentPaths","currentPathsLength","item","baseUnset","isSameRef","fieldValue","defaultReturn","isValid","getRadioValue","options","option","checked","isFileInput","isMultipleSelect","isEmptyString","defaultResult","validResult","getCheckboxValue","values","map","attributes","getFieldValue","fields","name","field","files","selected","isString","getFieldsValues","search","output","startsWith","find","nest","isSameError","error","types","message","objectA","objectB","objectAKeys","objectBKeys","every","compareObject","isRegex","RegExp","getValueAndMessage","validationData","isFunction","isBoolean","isMessage","isValidElement","getValidateError","appendErrors","validateAllFieldCriteria","errors","validateField","async","fieldsRef","required","maxLength","minLength","min","max","pattern","validate","_a","current","isRadio","isCheckBox","isRadioOrCheckbox","isEmpty","appendErrorsCurry","bind","getMinMaxMessage","exceedMax","maxLengthMessage","minLengthMessage","maxType","minType","requiredValue","requiredMessage","exceedMin","maxValue","maxMessage","minValue","minMessage","valueNumber","valueAsNumber","parseFloat","valueDate","valueAsDate","Date","maxLengthValue","minLengthValue","inputLength","toString","patternValue","patternMessage","validateRef","validateError","validationResult","validateFunction","parseErrorSchema","inner","validateWithSchema","validationSchema","validationResolver","context","abortEarly","e","isPrimitive","getPath","getInnerPath","pathWithIndex","assignWatchFields","fieldValues","fieldName","watchFields","inputValue","isSingleField","add","parentPath","flat","Infinity","getPath$1","skipValidation","isOnChange","hasError","isBlurEvent","isOnSubmit","isReValidateOnSubmit","isOnBlur","isReValidateOnBlur","isSubmitted","getFieldArrayParentName","substring","indexOf","getFieldValueByName","results","getIsFieldsDifferent","referenceArray","differenceArray","isMatch","i","dataA","dataB","isMatchFieldArrayName","searchName","isNameInFieldArray","names","some","modeChecker","mode","isRadioOrCheckboxFunction","useForm","reValidateMode","validationContext","defaultValues","submitFocusError","validateCriteriaMode","useRef","errorsRef","touchedFieldsRef","fieldArrayDefaultValues","watchFieldsRef","Set","dirtyFieldsRef","fieldsWithValidationRef","validFieldsRef","isValidRef","defaultValuesRef","defaultValuesAtRenderRef","isUnMount","isWatchAllRef","isSubmittedRef","isDirtyRef","submitCountRef","isSubmittingRef","handleChangeRef","resetFieldArrayFunctionRef","validationContextRef","fieldArrayNamesRef","render","useState","isWindowUndefined","window","shouldValidateSchemaOrResolver","isWeb","document","isProxyEnabled","Proxy","readFormStateRef","dirty","dirtyFields","submitCount","touched","isSubmitting","reRender","useCallback","shouldRenderBaseOnError","shouldRender","shouldReRender","validFields","fieldsWithValidation","isFieldValid","isFormValid","currentFieldError","existFieldError","has","isManual","shouldRenderBasedOnError","previousError","delete","setFieldValue","rawValue","radioRef","selectRef","includes","checkboxRef","setDirty","isFieldDirty","isFieldArray","previousDirtyFieldsLength","size","fieldArrayName","isDirtyChanged","setInternalValues","parentFieldName","isValueArray","setInternalValue","executeValidation","skipReRender","executeSchemaOrResolverValidation","payload","previousFormIsValid","triggerValidation","Promise","all","isFieldWatched","target","currentError","shouldSkipValidation","shouldUpdateDirty","validateSchemaOrResolver","then","removeFieldEventListener","forceDelete","handleChange","mutationWatcher","disconnect","findRemovedFieldAndRemoveListener","removeFieldEventListenerAndRef","setInternalError","registerFieldsRef","validateOptions","console","warn","fieldRefAndValidationOptions","isEmptyDefaultValue","onDetachCallback","observer","MutationObserver","observe","childList","subtree","onDomRemove","addEventListener","attachEventListeners","handleSubmit","callback","preventDefault","persist","fieldErrors","fieldError","focus","focusOnErrorField","useEffect","formState","commonProps","setValue","valueOrShouldValidate","shouldValidate","isArrayValue","isStringFieldName","register","refOrValidationOptions","validationOptions","unregister","getValues","outputValues","prop","control","validateSchemaIsValid","watch","fieldNames","isDefaultValueUndefined","combinedDefaultValues","reset","omitResetState","inputRef","closest","resetFieldArray","resetRefs","clearError","setError","__rest","s","t","p","prototype","hasOwnProperty","call","getOwnPropertySymbols","propertyIsEnumerable","FormGlobalContext","createContext","useFormContext","useContext","Controller","rules","as","InnerComponent","onChangeName","onBlurName","valueName","onFocus","rest","methods","setInputStateValue","valueRef","isCheckboxInput","shouldReValidateOnBlur","rulesRef","onFocusRef","isNotFieldArray","commonTask","event","getInputValue","registerField","defineProperty","props","arg","args","cloneElement","createElement"],"sourceRoot":""}