@sunggang/ui-lib 0.3.65 → 0.4.0

package/index.esm.esm.js

@@ -0,0 +1,3375 @@
+import * as React from 'react';
+import React__default from 'react';
+
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value1 = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value1);
+    } else {
+        Promise.resolve(value1).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value1) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value1);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _define_property(obj, key, value1) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value1,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value1;
+    }
+    return obj;
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _object_without_properties(source, excluded) {
+    if (source == null) return {};
+    var target = _object_without_properties_loose(source, excluded);
+    var key, i;
+    if (Object.getOwnPropertySymbols) {
+        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
+        for(i = 0; i < sourceSymbolKeys.length; i++){
+            key = sourceSymbolKeys[i];
+            if (excluded.indexOf(key) >= 0) continue;
+            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
+            target[key] = source[key];
+        }
+    }
+    return target;
+}
+function _object_without_properties_loose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var isCheckBoxInput = function(element) {
+    return element.type === "checkbox";
+};
+var isDateObject = function(value1) {
+    return _instanceof(value1, Date);
+};
+var isNullOrUndefined = function(value1) {
+    return value1 == null;
+};
+var isObjectType = function(value1) {
+    return typeof value1 === "object";
+};
+var isObject = function(value1) {
+    return !isNullOrUndefined(value1) && !Array.isArray(value1) && isObjectType(value1) && !isDateObject(value1);
+};
+var getEventValue = function(event) {
+    return isObject(event) && event.target ? isCheckBoxInput(event.target) ? event.target.checked : event.target.value : event;
+};
+var getNodeParentName = function(name) {
+    return name.substring(0, name.search(/\.\d+(\.|$)/)) || name;
+};
+var isNameInFieldArray = function(names, name) {
+    return names.has(getNodeParentName(name));
+};
+var isPlainObject = function(tempObject) {
+    var prototypeCopy = tempObject.constructor && tempObject.constructor.prototype;
+    return isObject(prototypeCopy) && prototypeCopy.hasOwnProperty("isPrototypeOf");
+};
+var isWeb = typeof window !== "undefined" && typeof window.HTMLElement !== "undefined" && typeof document !== "undefined";
+function cloneObject(data) {
+    var copy;
+    var isArray = Array.isArray(data);
+    var isFileListInstance = typeof FileList !== "undefined" ? _instanceof(data, FileList) : false;
+    if (_instanceof(data, Date)) {
+        copy = new Date(data);
+    } else if (_instanceof(data, Set)) {
+        copy = new Set(data);
+    } else if (!(isWeb && (_instanceof(data, Blob) || isFileListInstance)) && (isArray || isObject(data))) {
+        copy = isArray ? [] : {};
+        if (!isArray && !isPlainObject(data)) {
+            copy = data;
+        } else {
+            for(var key in data){
+                if (data.hasOwnProperty(key)) {
+                    copy[key] = cloneObject(data[key]);
+                }
+            }
+        }
+    } else {
+        return data;
+    }
+    return copy;
+}
+var compact = function(value1) {
+    return Array.isArray(value1) ? value1.filter(Boolean) : [];
+};
+var isUndefined = function(val) {
+    return val === undefined;
+};
+var get = function(object, path, defaultValue) {
+    if (!path || !isObject(object)) {
+        return defaultValue;
+    }
+    var result = compact(path.split(/[,[\].]+?/)).reduce(function(result, key) {
+        return isNullOrUndefined(result) ? result : result[key];
+    }, object);
+    return isUndefined(result) || result === object ? isUndefined(object[path]) ? defaultValue : object[path] : result;
+};
+var isBoolean = function(value1) {
+    return typeof value1 === "boolean";
+};
+var isKey = function(value1) {
+    return /^\w*$/.test(value1);
+};
+var stringToPath = function(input) {
+    return compact(input.replace(/["|']|\]/g, "").split(/\.|\[/));
+};
+var set = function(object, path, value1) {
+    var index = -1;
+    var tempPath = isKey(path) ? [
+        path
+    ] : stringToPath(path);
+    var length = tempPath.length;
+    var lastIndex = length - 1;
+    while(++index < length){
+        var key = tempPath[index];
+        var newValue = value1;
+        if (index !== lastIndex) {
+            var objValue = object[key];
+            newValue = isObject(objValue) || Array.isArray(objValue) ? objValue : !isNaN(+tempPath[index + 1]) ? [] : {};
+        }
+        if (key === "__proto__" || key === "constructor" || key === "prototype") {
+            return;
+        }
+        object[key] = newValue;
+        object = object[key];
+    }
+};
+var EVENTS = {
+    BLUR: "blur",
+    FOCUS_OUT: "focusout",
+    CHANGE: "change"
+};
+var VALIDATION_MODE = {
+    onBlur: "onBlur",
+    onChange: "onChange",
+    onSubmit: "onSubmit",
+    onTouched: "onTouched",
+    all: "all"
+};
+var INPUT_VALIDATION_RULES = {
+    max: "max",
+    min: "min",
+    maxLength: "maxLength",
+    minLength: "minLength",
+    pattern: "pattern",
+    required: "required",
+    validate: "validate"
+};
+var HookFormContext = React__default.createContext(null);
+/**
+ * This custom hook allows you to access the form context. useFormContext is intended to be used in deeply nested structures, where it would become inconvenient to pass the context as a prop. To be used with {@link FormProvider}.
+ *
+ * @remarks
+ * [API](https://react-hook-form.com/docs/useformcontext) • [Demo](https://codesandbox.io/s/react-hook-form-v7-form-context-ytudi)
+ *
+ * @returns return all useForm methods
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   const methods = useForm();
+ *   const onSubmit = data => console.log(data);
+ *
+ *   return (
+ *     <FormProvider {...methods} >
+ *       <form onSubmit={methods.handleSubmit(onSubmit)}>
+ *         <NestedInput />
+ *         <input type="submit" />
+ *       </form>
+ *     </FormProvider>
+ *   );
+ * }
+ *
+ *  function NestedInput() {
+ *   const { register } = useFormContext(); // retrieve all hook methods
+ *   return <input {...register("test")} />;
+ * }
+ * ```
+ */ var useFormContext = function() {
+    return React__default.useContext(HookFormContext);
+};
+/**
+ * A provider component that propagates the `useForm` methods to all children components via [React Context](https://reactjs.org/docs/context.html) API. To be used with {@link useFormContext}.
+ *
+ * @remarks
+ * [API](https://react-hook-form.com/docs/useformcontext) • [Demo](https://codesandbox.io/s/react-hook-form-v7-form-context-ytudi)
+ *
+ * @param props - all useForm methods
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   const methods = useForm();
+ *   const onSubmit = data => console.log(data);
+ *
+ *   return (
+ *     <FormProvider {...methods} >
+ *       <form onSubmit={methods.handleSubmit(onSubmit)}>
+ *         <NestedInput />
+ *         <input type="submit" />
+ *       </form>
+ *     </FormProvider>
+ *   );
+ * }
+ *
+ *  function NestedInput() {
+ *   const { register } = useFormContext(); // retrieve all hook methods
+ *   return <input {...register("test")} />;
+ * }
+ * ```
+ */ var FormProvider = function(props) {
+    var children = props.children, data = _object_without_properties(props, [
+        "children"
+    ]);
+    return React__default.createElement(HookFormContext.Provider, {
+        value: data
+    }, children);
+};
+var getProxyFormState = function(formState, control, localProxyFormState) {
+    var _loop = function(key) {
+        Object.defineProperty(result, key, {
+            get: function() {
+                var _key = key;
+                if (control._proxyFormState[_key] !== VALIDATION_MODE.all) {
+                    control._proxyFormState[_key] = !isRoot || VALIDATION_MODE.all;
+                }
+                localProxyFormState && (localProxyFormState[_key] = true);
+                return formState[_key];
+            }
+        });
+    };
+    var isRoot = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : true;
+    var result = {
+        defaultValues: control._defaultValues
+    };
+    for(var key in formState)_loop(key);
+    return result;
+};
+var useIsomorphicLayoutEffect = typeof window !== "undefined" ? React.useLayoutEffect : React.useEffect;
+/**
+ * This custom hook allows you to subscribe to each form state, and isolate the re-render at the custom hook level. It has its scope in terms of form state subscription, so it would not affect other useFormState and useForm. Using this hook can reduce the re-render impact on large and complex form application.
+ *
+ * @remarks
+ * [API](https://react-hook-form.com/docs/useformstate) • [Demo](https://codesandbox.io/s/useformstate-75xly)
+ *
+ * @param props - include options on specify fields to subscribe. {@link UseFormStateReturn}
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   const { register, handleSubmit, control } = useForm({
+ *     defaultValues: {
+ *     firstName: "firstName"
+ *   }});
+ *   const { dirtyFields } = useFormState({
+ *     control
+ *   });
+ *   const onSubmit = (data) => console.log(data);
+ *
+ *   return (
+ *     <form onSubmit={handleSubmit(onSubmit)}>
+ *       <input {...register("firstName")} placeholder="First Name" />
+ *       {dirtyFields.firstName && <p>Field is dirty.</p>}
+ *       <input type="submit" />
+ *     </form>
+ *   );
+ * }
+ * ```
+ */ function useFormState(props) {
+    var methods = useFormContext();
+    var _ref = props || {}, _ref_control = _ref.control, control = _ref_control === void 0 ? methods.control : _ref_control, disabled = _ref.disabled, name = _ref.name, exact = _ref.exact;
+    var _React__default_useState = _sliced_to_array(React__default.useState(control._formState), 2), formState = _React__default_useState[0], updateFormState = _React__default_useState[1];
+    var _localProxyFormState = React__default.useRef({
+        isDirty: false,
+        isLoading: false,
+        dirtyFields: false,
+        touchedFields: false,
+        validatingFields: false,
+        isValidating: false,
+        isValid: false,
+        errors: false
+    });
+    useIsomorphicLayoutEffect(function() {
+        return control._subscribe({
+            name: name,
+            formState: _localProxyFormState.current,
+            exact: exact,
+            callback: function(formState) {
+                !disabled && updateFormState(_object_spread({}, control._formState, formState));
+            }
+        });
+    }, [
+        name,
+        disabled,
+        exact
+    ]);
+    React__default.useEffect(function() {
+        _localProxyFormState.current.isValid && control._setValid(true);
+    }, [
+        control
+    ]);
+    return React__default.useMemo(function() {
+        return getProxyFormState(formState, control, _localProxyFormState.current, false);
+    }, [
+        formState,
+        control
+    ]);
+}
+var isString = function(value1) {
+    return typeof value1 === "string";
+};
+var generateWatchOutput = function(names, _names, formValues, isGlobal, defaultValue) {
+    if (isString(names)) {
+        isGlobal && _names.watch.add(names);
+        return get(formValues, names, defaultValue);
+    }
+    if (Array.isArray(names)) {
+        return names.map(function(fieldName) {
+            return isGlobal && _names.watch.add(fieldName), get(formValues, fieldName);
+        });
+    }
+    isGlobal && (_names.watchAll = true);
+    return formValues;
+};
+/**
+ * Custom hook to subscribe to field change and isolate re-rendering at the component level.
+ *
+ * @remarks
+ *
+ * [API](https://react-hook-form.com/docs/usewatch) • [Demo](https://codesandbox.io/s/react-hook-form-v7-ts-usewatch-h9i5e)
+ *
+ * @example
+ * ```tsx
+ * const { control } = useForm();
+ * const values = useWatch({
+ *   name: "fieldName"
+ *   control,
+ * })
+ * ```
+ */ function useWatch(props) {
+    var methods = useFormContext();
+    var _ref = props || {}, _ref_control = _ref.control, control = _ref_control === void 0 ? methods.control : _ref_control, name = _ref.name, defaultValue = _ref.defaultValue, disabled = _ref.disabled, exact = _ref.exact;
+    var _defaultValue = React__default.useRef(defaultValue);
+    var _React__default_useState = _sliced_to_array(React__default.useState(control._getWatch(name, _defaultValue.current)), 2), value1 = _React__default_useState[0], updateValue = _React__default_useState[1];
+    useIsomorphicLayoutEffect(function() {
+        return control._subscribe({
+            name: name,
+            formState: {
+                values: true
+            },
+            exact: exact,
+            callback: function(formState) {
+                return !disabled && updateValue(generateWatchOutput(name, control._names, formState.values || control._formValues, false, _defaultValue.current));
+            }
+        });
+    }, [
+        name,
+        control,
+        disabled,
+        exact
+    ]);
+    React__default.useEffect(function() {
+        return control._removeUnmounted();
+    });
+    return value1;
+}
+/**
+ * Custom hook to work with controlled component, this function provide you with both form and field level state. Re-render is isolated at the hook level.
+ *
+ * @remarks
+ * [API](https://react-hook-form.com/docs/usecontroller) • [Demo](https://codesandbox.io/s/usecontroller-0o8px)
+ *
+ * @param props - the path name to the form field value, and validation rules.
+ *
+ * @returns field properties, field and form state. {@link UseControllerReturn}
+ *
+ * @example
+ * ```tsx
+ * function Input(props) {
+ *   const { field, fieldState, formState } = useController(props);
+ *   return (
+ *     <div>
+ *       <input {...field} placeholder={props.name} />
+ *       <p>{fieldState.isTouched && "Touched"}</p>
+ *       <p>{formState.isSubmitted ? "submitted" : ""}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */ function useController(props) {
+    var methods = useFormContext();
+    var name = props.name, disabled = props.disabled, _props_control = props.control, control = _props_control === void 0 ? methods.control : _props_control, shouldUnregister = props.shouldUnregister;
+    var isArrayField = isNameInFieldArray(control._names.array, name);
+    var value1 = useWatch({
+        control: control,
+        name: name,
+        defaultValue: get(control._formValues, name, get(control._defaultValues, name, props.defaultValue)),
+        exact: true
+    });
+    var formState = useFormState({
+        control: control,
+        name: name,
+        exact: true
+    });
+    var _props = React__default.useRef(props);
+    var _registerProps = React__default.useRef(control.register(name, _object_spread(_object_spread_props(_object_spread({}, props.rules), {
+        value: value1
+    }), isBoolean(props.disabled) ? {
+        disabled: props.disabled
+    } : {})));
+    var fieldState = React__default.useMemo(function() {
+        return Object.defineProperties({}, {
+            invalid: {
+                enumerable: true,
+                get: function() {
+                    return !!get(formState.errors, name);
+                }
+            },
+            isDirty: {
+                enumerable: true,
+                get: function() {
+                    return !!get(formState.dirtyFields, name);
+                }
+            },
+            isTouched: {
+                enumerable: true,
+                get: function() {
+                    return !!get(formState.touchedFields, name);
+                }
+            },
+            isValidating: {
+                enumerable: true,
+                get: function() {
+                    return !!get(formState.validatingFields, name);
+                }
+            },
+            error: {
+                enumerable: true,
+                get: function() {
+                    return get(formState.errors, name);
+                }
+            }
+        });
+    }, [
+        formState,
+        name
+    ]);
+    var onChange = React__default.useCallback(function(event) {
+        return _registerProps.current.onChange({
+            target: {
+                value: getEventValue(event),
+                name: name
+            },
+            type: EVENTS.CHANGE
+        });
+    }, [
+        name
+    ]);
+    var onBlur = React__default.useCallback(function() {
+        return _registerProps.current.onBlur({
+            target: {
+                value: get(control._formValues, name),
+                name: name
+            },
+            type: EVENTS.BLUR
+        });
+    }, [
+        name,
+        control._formValues
+    ]);
+    var ref = React__default.useCallback(function(elm) {
+        var field = get(control._fields, name);
+        if (field && elm) {
+            field._f.ref = {
+                focus: function() {
+                    return elm.focus();
+                },
+                select: function() {
+                    return elm.select();
+                },
+                setCustomValidity: function(message) {
+                    return elm.setCustomValidity(message);
+                },
+                reportValidity: function() {
+                    return elm.reportValidity();
+                }
+            };
+        }
+    }, [
+        control._fields,
+        name
+    ]);
+    var field = React__default.useMemo(function() {
+        return _object_spread_props(_object_spread({
+            name: name,
+            value: value1
+        }, isBoolean(disabled) || formState.disabled ? {
+            disabled: formState.disabled || disabled
+        } : {}), {
+            onChange: onChange,
+            onBlur: onBlur,
+            ref: ref
+        });
+    }, [
+        name,
+        disabled,
+        formState.disabled,
+        onChange,
+        onBlur,
+        ref,
+        value1
+    ]);
+    React__default.useEffect(function() {
+        var _shouldUnregisterField = control._options.shouldUnregister || shouldUnregister;
+        control.register(name, _object_spread({}, _props.current.rules, isBoolean(_props.current.disabled) ? {
+            disabled: _props.current.disabled
+        } : {}));
+        var updateMounted = function(name, value1) {
+            var field = get(control._fields, name);
+            if (field && field._f) {
+                field._f.mount = value1;
+            }
+        };
+        updateMounted(name, true);
+        if (_shouldUnregisterField) {
+            var value1 = cloneObject(get(control._options.defaultValues, name));
+            set(control._defaultValues, name, value1);
+            if (isUndefined(get(control._formValues, name))) {
+                set(control._formValues, name, value1);
+            }
+        }
+        !isArrayField && control.register(name);
+        return function() {
+            (isArrayField ? _shouldUnregisterField && !control._state.action : _shouldUnregisterField) ? control.unregister(name) : updateMounted(name, false);
+        };
+    }, [
+        name,
+        control,
+        isArrayField,
+        shouldUnregister
+    ]);
+    React__default.useEffect(function() {
+        control._setDisabledField({
+            disabled: disabled,
+            name: name
+        });
+    }, [
+        disabled,
+        name,
+        control
+    ]);
+    return React__default.useMemo(function() {
+        return {
+            field: field,
+            formState: formState,
+            fieldState: fieldState
+        };
+    }, [
+        field,
+        formState,
+        fieldState
+    ]);
+}
+/**
+ * Component based on `useController` hook to work with controlled component.
+ *
+ * @remarks
+ * [API](https://react-hook-form.com/docs/usecontroller/controller) • [Demo](https://codesandbox.io/s/react-hook-form-v6-controller-ts-jwyzw) • [Video](https://www.youtube.com/watch?v=N2UNk_UCVyA)
+ *
+ * @param props - the path name to the form field value, and validation rules.
+ *
+ * @returns provide field handler functions, field and form state.
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   const { control } = useForm<FormValues>({
+ *     defaultValues: {
+ *       test: ""
+ *     }
+ *   });
+ *
+ *   return (
+ *     <form>
+ *       <Controller
+ *         control={control}
+ *         name="test"
+ *         render={({ field: { onChange, onBlur, value, ref }, formState, fieldState }) => (
+ *           <>
+ *             <input
+ *               onChange={onChange} // send value to hook form
+ *               onBlur={onBlur} // notify when input is touched
+ *               value={value} // return updated value
+ *               ref={ref} // set ref for focus management
+ *             />
+ *             <p>{formState.isSubmitted ? "submitted" : ""}</p>
+ *             <p>{fieldState.isTouched ? "touched" : ""}</p>
+ *           </>
+ *         )}
+ *       />
+ *     </form>
+ *   );
+ * }
+ * ```
+ */ var Controller = function(props) {
+    return props.render(useController(props));
+};
+var appendErrors = function(name, validateAllFieldCriteria, errors, type, message) {
+    return validateAllFieldCriteria ? _object_spread_props(_object_spread({}, errors[name]), {
+        types: _object_spread_props(_object_spread({}, errors[name] && errors[name].types ? errors[name].types : {}), _define_property({}, type, message || true))
+    }) : {};
+};
+var convertToArrayPayload = function(value1) {
+    return Array.isArray(value1) ? value1 : [
+        value1
+    ];
+};
+var createSubject = function() {
+    var _observers = [];
+    var next = function(value1) {
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = _observers[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var observer = _step.value;
+                observer.next && observer.next(value1);
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    };
+    var subscribe = function(observer) {
+        _observers.push(observer);
+        return {
+            unsubscribe: function() {
+                _observers = _observers.filter(function(o) {
+                    return o !== observer;
+                });
+            }
+        };
+    };
+    var unsubscribe = function() {
+        _observers = [];
+    };
+    return {
+        get observers () {
+            return _observers;
+        },
+        next: next,
+        subscribe: subscribe,
+        unsubscribe: unsubscribe
+    };
+};
+var isPrimitive = function(value1) {
+    return isNullOrUndefined(value1) || !isObjectType(value1);
+};
+function deepEqual(object1, object2) {
+    if (isPrimitive(object1) || isPrimitive(object2)) {
+        return object1 === object2;
+    }
+    if (isDateObject(object1) && isDateObject(object2)) {
+        return object1.getTime() === object2.getTime();
+    }
+    var keys1 = Object.keys(object1);
+    var keys2 = Object.keys(object2);
+    if (keys1.length !== keys2.length) {
+        return false;
+    }
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = keys1[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var key = _step.value;
+            var val1 = object1[key];
+            if (!keys2.includes(key)) {
+                return false;
+            }
+            if (key !== "ref") {
+                var val2 = object2[key];
+                if (isDateObject(val1) && isDateObject(val2) || isObject(val1) && isObject(val2) || Array.isArray(val1) && Array.isArray(val2) ? !deepEqual(val1, val2) : val1 !== val2) {
+                    return false;
+                }
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return true;
+}
+var isEmptyObject = function(value1) {
+    return isObject(value1) && !Object.keys(value1).length;
+};
+var isFileInput = function(element) {
+    return element.type === "file";
+};
+var isFunction = function(value1) {
+    return typeof value1 === "function";
+};
+var isHTMLElement = function(value1) {
+    if (!isWeb) {
+        return false;
+    }
+    var owner = value1 ? value1.ownerDocument : 0;
+    return _instanceof(value1, owner && owner.defaultView ? owner.defaultView.HTMLElement : HTMLElement);
+};
+var isMultipleSelect = function(element) {
+    return element.type === "select-multiple";
+};
+var isRadioInput = function(element) {
+    return element.type === "radio";
+};
+var isRadioOrCheckbox = function(ref) {
+    return isRadioInput(ref) || isCheckBoxInput(ref);
+};
+var live = function(ref) {
+    return isHTMLElement(ref) && ref.isConnected;
+};
+function baseGet(object, updatePath) {
+    var length = updatePath.slice(0, -1).length;
+    var index = 0;
+    while(index < length){
+        object = isUndefined(object) ? index++ : object[updatePath[index++]];
+    }
+    return object;
+}
+function isEmptyArray(obj) {
+    for(var key in obj){
+        if (obj.hasOwnProperty(key) && !isUndefined(obj[key])) {
+            return false;
+        }
+    }
+    return true;
+}
+function unset(object, path) {
+    var paths = Array.isArray(path) ? path : isKey(path) ? [
+        path
+    ] : stringToPath(path);
+    var childObject = paths.length === 1 ? object : baseGet(object, paths);
+    var index = paths.length - 1;
+    var key = paths[index];
+    if (childObject) {
+        delete childObject[key];
+    }
+    if (index !== 0 && (isObject(childObject) && isEmptyObject(childObject) || Array.isArray(childObject) && isEmptyArray(childObject))) {
+        unset(object, paths.slice(0, -1));
+    }
+    return object;
+}
+var objectHasFunction = function(data) {
+    for(var key in data){
+        if (isFunction(data[key])) {
+            return true;
+        }
+    }
+    return false;
+};
+function markFieldsDirty(data) {
+    var fields = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    var isParentNodeArray = Array.isArray(data);
+    if (isObject(data) || isParentNodeArray) {
+        for(var key in data){
+            if (Array.isArray(data[key]) || isObject(data[key]) && !objectHasFunction(data[key])) {
+                fields[key] = Array.isArray(data[key]) ? [] : {};
+                markFieldsDirty(data[key], fields[key]);
+            } else if (!isNullOrUndefined(data[key])) {
+                fields[key] = true;
+            }
+        }
+    }
+    return fields;
+}
+function getDirtyFieldsFromDefaultValues(data, formValues, dirtyFieldsFromValues) {
+    var isParentNodeArray = Array.isArray(data);
+    if (isObject(data) || isParentNodeArray) {
+        for(var key in data){
+            if (Array.isArray(data[key]) || isObject(data[key]) && !objectHasFunction(data[key])) {
+                if (isUndefined(formValues) || isPrimitive(dirtyFieldsFromValues[key])) {
+                    dirtyFieldsFromValues[key] = Array.isArray(data[key]) ? markFieldsDirty(data[key], []) : _object_spread({}, markFieldsDirty(data[key]));
+                } else {
+                    getDirtyFieldsFromDefaultValues(data[key], isNullOrUndefined(formValues) ? {} : formValues[key], dirtyFieldsFromValues[key]);
+                }
+            } else {
+                dirtyFieldsFromValues[key] = !deepEqual(data[key], formValues[key]);
+            }
+        }
+    }
+    return dirtyFieldsFromValues;
+}
+var getDirtyFields = function(defaultValues, formValues) {
+    return getDirtyFieldsFromDefaultValues(defaultValues, formValues, markFieldsDirty(formValues));
+};
+var defaultResult = {
+    value: false,
+    isValid: false
+};
+var validResult = {
+    value: true,
+    isValid: true
+};
+var getCheckboxValue = function(options) {
+    if (Array.isArray(options)) {
+        if (options.length > 1) {
+            var values = options.filter(function(option) {
+                return option && option.checked && !option.disabled;
+            }).map(function(option) {
+                return option.value;
+            });
+            return {
+                value: values,
+                isValid: !!values.length
+            };
+        }
+        return options[0].checked && !options[0].disabled ? options[0].attributes && !isUndefined(options[0].attributes.value) ? isUndefined(options[0].value) || options[0].value === "" ? validResult : {
+            value: options[0].value,
+            isValid: true
+        } : validResult : defaultResult;
+    }
+    return defaultResult;
+};
+var getFieldValueAs = function(value1, param) {
+    var valueAsNumber = param.valueAsNumber, valueAsDate = param.valueAsDate, setValueAs = param.setValueAs;
+    return isUndefined(value1) ? value1 : valueAsNumber ? value1 === "" ? NaN : value1 ? +value1 : value1 : valueAsDate && isString(value1) ? new Date(value1) : setValueAs ? setValueAs(value1) : value1;
+};
+var defaultReturn = {
+    isValid: false,
+    value: null
+};
+var getRadioValue = function(options) {
+    return Array.isArray(options) ? options.reduce(function(previous, option) {
+        return option && option.checked && !option.disabled ? {
+            isValid: true,
+            value: option.value
+        } : previous;
+    }, defaultReturn) : defaultReturn;
+};
+function getFieldValue(_f) {
+    var ref = _f.ref;
+    if (isFileInput(ref)) {
+        return ref.files;
+    }
+    if (isRadioInput(ref)) {
+        return getRadioValue(_f.refs).value;
+    }
+    if (isMultipleSelect(ref)) {
+        return _to_consumable_array(ref.selectedOptions).map(function(param) {
+            var value1 = param.value;
+            return value1;
+        });
+    }
+    if (isCheckBoxInput(ref)) {
+        return getCheckboxValue(_f.refs).value;
+    }
+    return getFieldValueAs(isUndefined(ref.value) ? _f.ref.value : ref.value, _f);
+}
+var getResolverOptions = function(fieldsNames, _fields, criteriaMode, shouldUseNativeValidation) {
+    var fields = {};
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = fieldsNames[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var name = _step.value;
+            var field = get(_fields, name);
+            field && set(fields, name, field._f);
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return {
+        criteriaMode: criteriaMode,
+        names: _to_consumable_array(fieldsNames),
+        fields: fields,
+        shouldUseNativeValidation: shouldUseNativeValidation
+    };
+};
+var isRegex = function(value1) {
+    return _instanceof(value1, RegExp);
+};
+var getRuleValue = function(rule) {
+    return isUndefined(rule) ? rule : isRegex(rule) ? rule.source : isObject(rule) ? isRegex(rule.value) ? rule.value.source : rule.value : rule;
+};
+var getValidationModes = function(mode) {
+    return {
+        isOnSubmit: !mode || mode === VALIDATION_MODE.onSubmit,
+        isOnBlur: mode === VALIDATION_MODE.onBlur,
+        isOnChange: mode === VALIDATION_MODE.onChange,
+        isOnAll: mode === VALIDATION_MODE.all,
+        isOnTouch: mode === VALIDATION_MODE.onTouched
+    };
+};
+var ASYNC_FUNCTION = "AsyncFunction";
+var hasPromiseValidation = function(fieldReference) {
+    return !!fieldReference && !!fieldReference.validate && !!(isFunction(fieldReference.validate) && fieldReference.validate.constructor.name === ASYNC_FUNCTION || isObject(fieldReference.validate) && Object.values(fieldReference.validate).find(function(validateFunction) {
+        return validateFunction.constructor.name === ASYNC_FUNCTION;
+    }));
+};
+var hasValidation = function(options) {
+    return options.mount && (options.required || options.min || options.max || options.maxLength || options.minLength || options.pattern || options.validate);
+};
+var isWatched = function(name, _names, isBlurEvent) {
+    return !isBlurEvent && (_names.watchAll || _names.watch.has(name) || _to_consumable_array(_names.watch).some(function(watchName) {
+        return name.startsWith(watchName) && /^\.\w+/.test(name.slice(watchName.length));
+    }));
+};
+var iterateFieldsByAction = function(fields, action, fieldsNames, abortEarly) {
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = (fieldsNames || Object.keys(fields))[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _ref = _step.value;
+            var key = _ref;
+            var field = get(fields, key);
+            if (field) {
+                var _f = field._f, currentField = _object_without_properties(field, [
+                    "_f"
+                ]);
+                if (_f) {
+                    if (_f.refs && _f.refs[0] && action(_f.refs[0], key) && !abortEarly) {
+                        return true;
+                    } else if (_f.ref && action(_f.ref, _f.name) && !abortEarly) {
+                        return true;
+                    } else {
+                        if (iterateFieldsByAction(currentField, action)) {
+                            break;
+                        }
+                    }
+                } else if (isObject(currentField)) {
+                    if (iterateFieldsByAction(currentField, action)) {
+                        break;
+                    }
+                }
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return;
+};
+function schemaErrorLookup(errors, _fields, name) {
+    var error = get(errors, name);
+    if (error || isKey(name)) {
+        return {
+            error: error,
+            name: name
+        };
+    }
+    var names = name.split(".");
+    while(names.length){
+        var fieldName = names.join(".");
+        var field = get(_fields, fieldName);
+        var foundError = get(errors, fieldName);
+        if (field && !Array.isArray(field) && name !== fieldName) {
+            return {
+                name: name
+            };
+        }
+        if (foundError && foundError.type) {
+            return {
+                name: fieldName,
+                error: foundError
+            };
+        }
+        names.pop();
+    }
+    return {
+        name: name
+    };
+}
+var shouldRenderFormState = function(formStateData, _proxyFormState, updateFormState, isRoot) {
+    updateFormState(formStateData);
+    formStateData.name; var formState = _object_without_properties(formStateData, [
+        "name"
+    ]);
+    return isEmptyObject(formState) || Object.keys(formState).length >= Object.keys(_proxyFormState).length || Object.keys(formState).find(function(key) {
+        return _proxyFormState[key] === (!isRoot || VALIDATION_MODE.all);
+    });
+};
+var shouldSubscribeByName = function(name, signalName, exact) {
+    return !name || !signalName || name === signalName || convertToArrayPayload(name).some(function(currentName) {
+        return currentName && (exact ? currentName === signalName : currentName.startsWith(signalName) || signalName.startsWith(currentName));
+    });
+};
+var skipValidation = function(isBlurEvent, isTouched, isSubmitted, reValidateMode, mode) {
+    if (mode.isOnAll) {
+        return false;
+    } else if (!isSubmitted && mode.isOnTouch) {
+        return !(isTouched || isBlurEvent);
+    } else if (isSubmitted ? reValidateMode.isOnBlur : mode.isOnBlur) {
+        return !isBlurEvent;
+    } else if (isSubmitted ? reValidateMode.isOnChange : mode.isOnChange) {
+        return isBlurEvent;
+    }
+    return true;
+};
+var unsetEmptyArray = function(ref, name) {
+    return !compact(get(ref, name)).length && unset(ref, name);
+};
+var updateFieldArrayRootError = function(errors, error, name) {
+    var fieldArrayErrors = convertToArrayPayload(get(errors, name));
+    set(fieldArrayErrors, "root", error[name]);
+    set(errors, name, fieldArrayErrors);
+    return errors;
+};
+var isMessage = function(value1) {
+    return isString(value1);
+};
+function getValidateError(result, ref) {
+    var type = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "validate";
+    if (isMessage(result) || Array.isArray(result) && result.every(isMessage) || isBoolean(result) && !result) {
+        return {
+            type: type,
+            message: isMessage(result) ? result : "",
+            ref: ref
+        };
+    }
+}
+var getValueAndMessage = function(validationData) {
+    return isObject(validationData) && !isRegex(validationData) ? validationData : {
+        value: validationData,
+        message: ""
+    };
+};
+var validateField = function() {
+    var _ref = _async_to_generator(function(field, disabledFieldNames, formValues, validateAllFieldCriteria, shouldUseNativeValidation, isFieldArray) {
+        var _field__f, ref, refs, required, maxLength, minLength, min, max, pattern, validate, name, valueAsNumber, mount, inputValue, inputRef, setCustomValidity, error, isRadio, isCheckBox, isRadioOrCheckbox, isEmpty, appendErrorsCurry, getMinMaxMessage, _ref, value1, message, exceedMax, exceedMin, maxOutput, minOutput, valueNumber, valueDate, convertTimeToDate, isTime, isWeek, maxLengthOutput, minLengthOutput, exceedMax1, exceedMin1, _getValueAndMessage, patternValue, message1, result, validateError, validationResult, _tmp, _tmp1, _i, key, validateError1;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _field__f = field._f, ref = _field__f.ref, refs = _field__f.refs, required = _field__f.required, maxLength = _field__f.maxLength, minLength = _field__f.minLength, min = _field__f.min, max = _field__f.max, pattern = _field__f.pattern, validate = _field__f.validate, name = _field__f.name, valueAsNumber = _field__f.valueAsNumber, mount = _field__f.mount;
+                    inputValue = get(formValues, name);
+                    if (!mount || disabledFieldNames.has(name)) {
+                        return [
+                            2,
+                            {}
+                        ];
+                    }
+                    inputRef = refs ? refs[0] : ref;
+                    setCustomValidity = function(message) {
+                        if (shouldUseNativeValidation && inputRef.reportValidity) {
+                            inputRef.setCustomValidity(isBoolean(message) ? "" : message || "");
+                            inputRef.reportValidity();
+                        }
+                    };
+                    error = {};
+                    isRadio = isRadioInput(ref);
+                    isCheckBox = isCheckBoxInput(ref);
+                    isRadioOrCheckbox = isRadio || isCheckBox;
+                    isEmpty = (valueAsNumber || isFileInput(ref)) && isUndefined(ref.value) && isUndefined(inputValue) || isHTMLElement(ref) && ref.value === "" || inputValue === "" || Array.isArray(inputValue) && !inputValue.length;
+                    appendErrorsCurry = appendErrors.bind(null, name, validateAllFieldCriteria, error);
+                    getMinMaxMessage = function(exceedMax, maxLengthMessage, minLengthMessage) {
+                        var maxType = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : INPUT_VALIDATION_RULES.maxLength, minType = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : INPUT_VALIDATION_RULES.minLength;
+                        var message = exceedMax ? maxLengthMessage : minLengthMessage;
+                        error[name] = _object_spread({
+                            type: exceedMax ? maxType : minType,
+                            message: message,
+                            ref: ref
+                        }, appendErrorsCurry(exceedMax ? maxType : minType, message));
+                    };
+                    if (isFieldArray ? !Array.isArray(inputValue) || !inputValue.length : required && (!isRadioOrCheckbox && (isEmpty || isNullOrUndefined(inputValue)) || isBoolean(inputValue) && !inputValue || isCheckBox && !getCheckboxValue(refs).isValid || isRadio && !getRadioValue(refs).isValid)) {
+                        _ref = isMessage(required) ? {
+                            value: !!required,
+                            message: required
+                        } : getValueAndMessage(required), value1 = _ref.value, message = _ref.message;
+                        if (value1) {
+                            error[name] = _object_spread({
+                                type: INPUT_VALIDATION_RULES.required,
+                                message: message,
+                                ref: inputRef
+                            }, appendErrorsCurry(INPUT_VALIDATION_RULES.required, message));
+                            if (!validateAllFieldCriteria) {
+                                setCustomValidity(message);
+                                return [
+                                    2,
+                                    error
+                                ];
+                            }
+                        }
+                    }
+                    if (!isEmpty && (!isNullOrUndefined(min) || !isNullOrUndefined(max))) {
+                        maxOutput = getValueAndMessage(max);
+                        minOutput = getValueAndMessage(min);
+                        if (!isNullOrUndefined(inputValue) && !isNaN(inputValue)) {
+                            valueNumber = ref.valueAsNumber || (inputValue ? +inputValue : inputValue);
+                            if (!isNullOrUndefined(maxOutput.value)) {
+                                exceedMax = valueNumber > maxOutput.value;
+                            }
+                            if (!isNullOrUndefined(minOutput.value)) {
+                                exceedMin = valueNumber < minOutput.value;
+                            }
+                        } else {
+                            valueDate = ref.valueAsDate || new Date(inputValue);
+                            convertTimeToDate = function(time) {
+                                return new Date(new Date().toDateString() + " " + time);
+                            };
+                            isTime = ref.type == "time";
+                            isWeek = ref.type == "week";
+                            if (isString(maxOutput.value) && inputValue) {
+                                exceedMax = isTime ? convertTimeToDate(inputValue) > convertTimeToDate(maxOutput.value) : isWeek ? inputValue > maxOutput.value : valueDate > new Date(maxOutput.value);
+                            }
+                            if (isString(minOutput.value) && inputValue) {
+                                exceedMin = isTime ? convertTimeToDate(inputValue) < convertTimeToDate(minOutput.value) : isWeek ? inputValue < minOutput.value : valueDate < new Date(minOutput.value);
+                            }
+                        }
+                        if (exceedMax || exceedMin) {
+                            getMinMaxMessage(!!exceedMax, maxOutput.message, minOutput.message, INPUT_VALIDATION_RULES.max, INPUT_VALIDATION_RULES.min);
+                            if (!validateAllFieldCriteria) {
+                                setCustomValidity(error[name].message);
+                                return [
+                                    2,
+                                    error
+                                ];
+                            }
+                        }
+                    }
+                    if ((maxLength || minLength) && !isEmpty && (isString(inputValue) || isFieldArray && Array.isArray(inputValue))) {
+                        maxLengthOutput = getValueAndMessage(maxLength);
+                        minLengthOutput = getValueAndMessage(minLength);
+                        exceedMax1 = !isNullOrUndefined(maxLengthOutput.value) && inputValue.length > +maxLengthOutput.value;
+                        exceedMin1 = !isNullOrUndefined(minLengthOutput.value) && inputValue.length < +minLengthOutput.value;
+                        if (exceedMax1 || exceedMin1) {
+                            getMinMaxMessage(exceedMax1, maxLengthOutput.message, minLengthOutput.message);
+                            if (!validateAllFieldCriteria) {
+                                setCustomValidity(error[name].message);
+                                return [
+                                    2,
+                                    error
+                                ];
+                            }
+                        }
+                    }
+                    if (pattern && !isEmpty && isString(inputValue)) {
+                        _getValueAndMessage = getValueAndMessage(pattern), patternValue = _getValueAndMessage.value, message1 = _getValueAndMessage.message;
+                        if (isRegex(patternValue) && !inputValue.match(patternValue)) {
+                            error[name] = _object_spread({
+                                type: INPUT_VALIDATION_RULES.pattern,
+                                message: message1,
+                                ref: ref
+                            }, appendErrorsCurry(INPUT_VALIDATION_RULES.pattern, message1));
+                            if (!validateAllFieldCriteria) {
+                                setCustomValidity(message1);
+                                return [
+                                    2,
+                                    error
+                                ];
+                            }
+                        }
+                    }
+                    if (!validate) return [
+                        3,
+                        7
+                    ];
+                    if (!isFunction(validate)) return [
+                        3,
+                        2
+                    ];
+                    return [
+                        4,
+                        validate(inputValue, formValues)
+                    ];
+                case 1:
+                    result = _state.sent();
+                    validateError = getValidateError(result, inputRef);
+                    if (validateError) {
+                        error[name] = _object_spread({}, validateError, appendErrorsCurry(INPUT_VALIDATION_RULES.validate, validateError.message));
+                        if (!validateAllFieldCriteria) {
+                            setCustomValidity(validateError.message);
+                            return [
+                                2,
+                                error
+                            ];
+                        }
+                    }
+                    return [
+                        3,
+                        7
+                    ];
+                case 2:
+                    if (!isObject(validate)) return [
+                        3,
+                        7
+                    ];
+                    validationResult = {};
+                    _tmp = [];
+                    for(_tmp1 in validate)_tmp.push(_tmp1);
+                    _i = 0;
+                    _state.label = 3;
+                case 3:
+                    if (!(_i < _tmp.length)) return [
+                        3,
+                        6
+                    ];
+                    key = _tmp[_i];
+                    if (!isEmptyObject(validationResult) && !validateAllFieldCriteria) {
+                        return [
+                            3,
+                            6
+                        ];
+                    }
+                    return [
+                        4,
+                        validate[key](inputValue, formValues)
+                    ];
+                case 4:
+                    validateError1 = getValidateError.apply(void 0, [
+                        _state.sent(),
+                        inputRef,
+                        key
+                    ]);
+                    if (validateError1) {
+                        validationResult = _object_spread({}, validateError1, appendErrorsCurry(key, validateError1.message));
+                        setCustomValidity(validateError1.message);
+                        if (validateAllFieldCriteria) {
+                            error[name] = validationResult;
+                        }
+                    }
+                    _state.label = 5;
+                case 5:
+                    _i++;
+                    return [
+                        3,
+                        3
+                    ];
+                case 6:
+                    if (!isEmptyObject(validationResult)) {
+                        error[name] = _object_spread({
+                            ref: inputRef
+                        }, validationResult);
+                        if (!validateAllFieldCriteria) {
+                            return [
+                                2,
+                                error
+                            ];
+                        }
+                    }
+                    _state.label = 7;
+                case 7:
+                    setCustomValidity(true);
+                    return [
+                        2,
+                        error
+                    ];
+            }
+        });
+    });
+    return function validateField(field, disabledFieldNames, formValues, validateAllFieldCriteria, shouldUseNativeValidation, isFieldArray) {
+        return _ref.apply(this, arguments);
+    };
+}();
+var defaultOptions = {
+    mode: VALIDATION_MODE.onSubmit,
+    reValidateMode: VALIDATION_MODE.onChange,
+    shouldFocusError: true
+};
+function createFormControl() {
+    var props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+    var _options = _object_spread({}, defaultOptions, props);
+    var _formState = {
+        submitCount: 0,
+        isDirty: false,
+        isReady: false,
+        isLoading: isFunction(_options.defaultValues),
+        isValidating: false,
+        isSubmitted: false,
+        isSubmitting: false,
+        isSubmitSuccessful: false,
+        isValid: false,
+        touchedFields: {},
+        dirtyFields: {},
+        validatingFields: {},
+        errors: _options.errors || {},
+        disabled: _options.disabled || false
+    };
+    var _fields = {};
+    var _defaultValues = isObject(_options.defaultValues) || isObject(_options.values) ? cloneObject(_options.defaultValues || _options.values) || {} : {};
+    var _formValues = _options.shouldUnregister ? {} : cloneObject(_defaultValues);
+    var _state = {
+        action: false,
+        mount: false,
+        watch: false
+    };
+    var _names = {
+        mount: new Set(),
+        disabled: new Set(),
+        unMount: new Set(),
+        array: new Set(),
+        watch: new Set()
+    };
+    var delayErrorCallback;
+    var timer = 0;
+    var _proxyFormState = {
+        isDirty: false,
+        dirtyFields: false,
+        validatingFields: false,
+        touchedFields: false,
+        isValidating: false,
+        isValid: false,
+        errors: false
+    };
+    var _proxySubscribeFormState = _object_spread({}, _proxyFormState);
+    var _subjects = {
+        array: createSubject(),
+        state: createSubject()
+    };
+    var shouldDisplayAllAssociatedErrors = _options.criteriaMode === VALIDATION_MODE.all;
+    var debounce = function(callback) {
+        return function(wait) {
+            clearTimeout(timer);
+            timer = setTimeout(callback, wait);
+        };
+    };
+    var _setValid = function() {
+        var _ref = _async_to_generator(function(shouldUpdateValid) {
+            var isValid, _tmp;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        if (!(!_options.disabled && (_proxyFormState.isValid || _proxySubscribeFormState.isValid || shouldUpdateValid))) return [
+                            3,
+                            5
+                        ];
+                        if (!_options.resolver) return [
+                            3,
+                            2
+                        ];
+                        return [
+                            4,
+                            _runSchema()
+                        ];
+                    case 1:
+                        _tmp = isEmptyObject.apply(void 0, [
+                            _state.sent().errors
+                        ]);
+                        return [
+                            3,
+                            4
+                        ];
+                    case 2:
+                        return [
+                            4,
+                            executeBuiltInValidation(_fields, true)
+                        ];
+                    case 3:
+                        _tmp = _state.sent();
+                        _state.label = 4;
+                    case 4:
+                        isValid = _tmp;
+                        if (isValid !== _formState.isValid) {
+                            _subjects.state.next({
+                                isValid: isValid
+                            });
+                        }
+                        _state.label = 5;
+                    case 5:
+                        return [
+                            2
+                        ];
+                }
+            });
+        });
+        return function _setValid(shouldUpdateValid) {
+            return _ref.apply(this, arguments);
+        };
+    }();
+    var _updateIsValidating = function(names, isValidating) {
+        if (!_options.disabled && (_proxyFormState.isValidating || _proxyFormState.validatingFields || _proxySubscribeFormState.isValidating || _proxySubscribeFormState.validatingFields)) {
+            (names || Array.from(_names.mount)).forEach(function(name) {
+                if (name) {
+                    isValidating ? set(_formState.validatingFields, name, isValidating) : unset(_formState.validatingFields, name);
+                }
+            });
+            _subjects.state.next({
+                validatingFields: _formState.validatingFields,
+                isValidating: !isEmptyObject(_formState.validatingFields)
+            });
+        }
+    };
+    var _setFieldArray = function(name) {
+        var values = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [], method = arguments.length > 2 ? arguments[2] : void 0, args = arguments.length > 3 ? arguments[3] : void 0, shouldSetValues = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : true, shouldUpdateFieldsAndState = arguments.length > 5 && arguments[5] !== void 0 ? arguments[5] : true;
+        if (args && method && !_options.disabled) {
+            _state.action = true;
+            if (shouldUpdateFieldsAndState && Array.isArray(get(_fields, name))) {
+                var fieldValues = method(get(_fields, name), args.argA, args.argB);
+                shouldSetValues && set(_fields, name, fieldValues);
+            }
+            if (shouldUpdateFieldsAndState && Array.isArray(get(_formState.errors, name))) {
+                var errors = method(get(_formState.errors, name), args.argA, args.argB);
+                shouldSetValues && set(_formState.errors, name, errors);
+                unsetEmptyArray(_formState.errors, name);
+            }
+            if ((_proxyFormState.touchedFields || _proxySubscribeFormState.touchedFields) && shouldUpdateFieldsAndState && Array.isArray(get(_formState.touchedFields, name))) {
+                var touchedFields = method(get(_formState.touchedFields, name), args.argA, args.argB);
+                shouldSetValues && set(_formState.touchedFields, name, touchedFields);
+            }
+            if (_proxyFormState.dirtyFields || _proxySubscribeFormState.dirtyFields) {
+                _formState.dirtyFields = getDirtyFields(_defaultValues, _formValues);
+            }
+            _subjects.state.next({
+                name: name,
+                isDirty: _getDirty(name, values),
+                dirtyFields: _formState.dirtyFields,
+                errors: _formState.errors,
+                isValid: _formState.isValid
+            });
+        } else {
+            set(_formValues, name, values);
+        }
+    };
+    var updateErrors = function(name, error) {
+        set(_formState.errors, name, error);
+        _subjects.state.next({
+            errors: _formState.errors
+        });
+    };
+    var _setErrors = function(errors) {
+        _formState.errors = errors;
+        _subjects.state.next({
+            errors: _formState.errors,
+            isValid: false
+        });
+    };
+    var updateValidAndValue = function(name, shouldSkipSetValueAs, value1, ref) {
+        var field = get(_fields, name);
+        if (field) {
+            var defaultValue = get(_formValues, name, isUndefined(value1) ? get(_defaultValues, name) : value1);
+            isUndefined(defaultValue) || ref && ref.defaultChecked || shouldSkipSetValueAs ? set(_formValues, name, shouldSkipSetValueAs ? defaultValue : getFieldValue(field._f)) : setFieldValue(name, defaultValue);
+            _state.mount && _setValid();
+        }
+    };
+    var updateTouchAndDirty = function(name, fieldValue, isBlurEvent, shouldDirty, shouldRender) {
+        var shouldUpdateField = false;
+        var isPreviousDirty = false;
+        var output = {
+            name: name
+        };
+        if (!_options.disabled) {
+            if (!isBlurEvent || shouldDirty) {
+                if (_proxyFormState.isDirty || _proxySubscribeFormState.isDirty) {
+                    isPreviousDirty = _formState.isDirty;
+                    _formState.isDirty = output.isDirty = _getDirty();
+                    shouldUpdateField = isPreviousDirty !== output.isDirty;
+                }
+                var isCurrentFieldPristine = deepEqual(get(_defaultValues, name), fieldValue);
+                isPreviousDirty = !!get(_formState.dirtyFields, name);
+                isCurrentFieldPristine ? unset(_formState.dirtyFields, name) : set(_formState.dirtyFields, name, true);
+                output.dirtyFields = _formState.dirtyFields;
+                shouldUpdateField = shouldUpdateField || (_proxyFormState.dirtyFields || _proxySubscribeFormState.dirtyFields) && isPreviousDirty !== !isCurrentFieldPristine;
+            }
+            if (isBlurEvent) {
+                var isPreviousFieldTouched = get(_formState.touchedFields, name);
+                if (!isPreviousFieldTouched) {
+                    set(_formState.touchedFields, name, isBlurEvent);
+                    output.touchedFields = _formState.touchedFields;
+                    shouldUpdateField = shouldUpdateField || (_proxyFormState.touchedFields || _proxySubscribeFormState.touchedFields) && isPreviousFieldTouched !== isBlurEvent;
+                }
+            }
+            shouldUpdateField && shouldRender && _subjects.state.next(output);
+        }
+        return shouldUpdateField ? output : {};
+    };
+    var shouldRenderByError = function(name, isValid, error, fieldState) {
+        var previousFieldError = get(_formState.errors, name);
+        var shouldUpdateValid = (_proxyFormState.isValid || _proxySubscribeFormState.isValid) && isBoolean(isValid) && _formState.isValid !== isValid;
+        if (_options.delayError && error) {
+            delayErrorCallback = debounce(function() {
+                return updateErrors(name, error);
+            });
+            delayErrorCallback(_options.delayError);
+        } else {
+            clearTimeout(timer);
+            delayErrorCallback = null;
+            error ? set(_formState.errors, name, error) : unset(_formState.errors, name);
+        }
+        if ((error ? !deepEqual(previousFieldError, error) : previousFieldError) || !isEmptyObject(fieldState) || shouldUpdateValid) {
+            var updatedFormState = _object_spread_props(_object_spread({}, fieldState, shouldUpdateValid && isBoolean(isValid) ? {
+                isValid: isValid
+            } : {}), {
+                errors: _formState.errors,
+                name: name
+            });
+            _formState = _object_spread({}, _formState, updatedFormState);
+            _subjects.state.next(updatedFormState);
+        }
+    };
+    var _runSchema = function() {
+        var _ref = _async_to_generator(function(name) {
+            var result;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        _updateIsValidating(name, true);
+                        return [
+                            4,
+                            _options.resolver(_formValues, _options.context, getResolverOptions(name || _names.mount, _fields, _options.criteriaMode, _options.shouldUseNativeValidation))
+                        ];
+                    case 1:
+                        result = _state.sent();
+                        _updateIsValidating(name);
+                        return [
+                            2,
+                            result
+                        ];
+                }
+            });
+        });
+        return function _runSchema(name) {
+            return _ref.apply(this, arguments);
+        };
+    }();
+    var executeSchemaAndUpdateState = function() {
+        var _ref = _async_to_generator(function(names) {
+            var errors, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, name, error;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        return [
+                            4,
+                            _runSchema(names)
+                        ];
+                    case 1:
+                        errors = _state.sent().errors;
+                        if (names) {
+                            _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                            try {
+                                for(_iterator = names[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                    name = _step.value;
+                                    error = get(errors, name);
+                                    error ? set(_formState.errors, name, error) : unset(_formState.errors, name);
+                                }
+                            } catch (err) {
+                                _didIteratorError = true;
+                                _iteratorError = err;
+                            } finally{
+                                try {
+                                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                        _iterator.return();
+                                    }
+                                } finally{
+                                    if (_didIteratorError) {
+                                        throw _iteratorError;
+                                    }
+                                }
+                            }
+                        } else {
+                            _formState.errors = errors;
+                        }
+                        return [
+                            2,
+                            errors
+                        ];
+                }
+            });
+        });
+        return function executeSchemaAndUpdateState(names) {
+            return _ref.apply(this, arguments);
+        };
+    }();
+    var executeBuiltInValidation = function() {
+        var _ref = _async_to_generator(function(fields, shouldOnlyCheckValid) {
+            var context, _tmp, _tmp1, _i, _ref, name, field, _f, fieldValue, isFieldArrayRoot, isPromiseFunction, fieldError, _tmp2;
+            var _arguments = arguments;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        context = _arguments.length > 2 && _arguments[2] !== void 0 ? _arguments[2] : {
+                            valid: true
+                        };
+                        _tmp = [];
+                        for(_tmp1 in fields)_tmp.push(_tmp1);
+                        _i = 0;
+                        _state.label = 1;
+                    case 1:
+                        if (!(_i < _tmp.length)) return [
+                            3,
+                            7
+                        ];
+                        _ref = _tmp[_i];
+                        name = _ref;
+                        field = fields[name];
+                        if (!field) return [
+                            3,
+                            6
+                        ];
+                        _f = field._f, fieldValue = _object_without_properties(field, [
+                            "_f"
+                        ]);
+                        if (!_f) return [
+                            3,
+                            3
+                        ];
+                        isFieldArrayRoot = _names.array.has(_f.name);
+                        isPromiseFunction = field._f && hasPromiseValidation(field._f);
+                        if (isPromiseFunction && _proxyFormState.validatingFields) {
+                            _updateIsValidating([
+                                name
+                            ], true);
+                        }
+                        return [
+                            4,
+                            validateField(field, _names.disabled, _formValues, shouldDisplayAllAssociatedErrors, _options.shouldUseNativeValidation && !shouldOnlyCheckValid, isFieldArrayRoot)
+                        ];
+                    case 2:
+                        fieldError = _state.sent();
+                        if (isPromiseFunction && _proxyFormState.validatingFields) {
+                            _updateIsValidating([
+                                name
+                            ]);
+                        }
+                        if (fieldError[_f.name]) {
+                            context.valid = false;
+                            if (shouldOnlyCheckValid) {
+                                return [
+                                    3,
+                                    7
+                                ];
+                            }
+                        }
+                        !shouldOnlyCheckValid && (get(fieldError, _f.name) ? isFieldArrayRoot ? updateFieldArrayRootError(_formState.errors, fieldError, _f.name) : set(_formState.errors, _f.name, fieldError[_f.name]) : unset(_formState.errors, _f.name));
+                        _state.label = 3;
+                    case 3:
+                        _tmp2 = !isEmptyObject(fieldValue);
+                        if (!_tmp2) return [
+                            3,
+                            5
+                        ];
+                        return [
+                            4,
+                            executeBuiltInValidation(fieldValue, shouldOnlyCheckValid, context)
+                        ];
+                    case 4:
+                        _tmp2 = _state.sent();
+                        _state.label = 5;
+                    case 5:
+                        _state.label = 6;
+                    case 6:
+                        _i++;
+                        return [
+                            3,
+                            1
+                        ];
+                    case 7:
+                        return [
+                            2,
+                            context.valid
+                        ];
+                }
+            });
+        });
+        return function executeBuiltInValidation(fields, shouldOnlyCheckValid) {
+            return _ref.apply(this, arguments);
+        };
+    }();
+    var _removeUnmounted = function() {
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = _names.unMount[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var name = _step.value;
+                var field = get(_fields, name);
+                field && (field._f.refs ? field._f.refs.every(function(ref) {
+                    return !live(ref);
+                }) : !live(field._f.ref)) && unregister(name);
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+        _names.unMount = new Set();
+    };
+    var _getDirty = function(name, data) {
+        return !_options.disabled && (name && data && set(_formValues, name, data), !deepEqual(getValues(), _defaultValues));
+    };
+    var _getWatch = function(names, defaultValue, isGlobal) {
+        return generateWatchOutput(names, _names, _object_spread({}, _state.mount ? _formValues : isUndefined(defaultValue) ? _defaultValues : isString(names) ? _define_property({}, names, defaultValue) : defaultValue), isGlobal, defaultValue);
+    };
+    var _getFieldArray = function(name) {
+        return compact(get(_state.mount ? _formValues : _defaultValues, name, _options.shouldUnregister ? get(_defaultValues, name, []) : []));
+    };
+    var setFieldValue = function(name, value1) {
+        var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+        var field = get(_fields, name);
+        var fieldValue = value1;
+        if (field) {
+            var fieldReference = field._f;
+            if (fieldReference) {
+                !fieldReference.disabled && set(_formValues, name, getFieldValueAs(value1, fieldReference));
+                fieldValue = isHTMLElement(fieldReference.ref) && isNullOrUndefined(value1) ? "" : value1;
+                if (isMultipleSelect(fieldReference.ref)) {
+                    _to_consumable_array(fieldReference.ref.options).forEach(function(optionRef) {
+                        return optionRef.selected = fieldValue.includes(optionRef.value);
+                    });
+                } else if (fieldReference.refs) {
+                    if (isCheckBoxInput(fieldReference.ref)) {
+                        fieldReference.refs.forEach(function(checkboxRef) {
+                            if (!checkboxRef.defaultChecked || !checkboxRef.disabled) {
+                                if (Array.isArray(fieldValue)) {
+                                    checkboxRef.checked = !!fieldValue.find(function(data) {
+                                        return data === checkboxRef.value;
+                                    });
+                                } else {
+                                    checkboxRef.checked = fieldValue === checkboxRef.value || !!fieldValue;
+                                }
+                            }
+                        });
+                    } else {
+                        fieldReference.refs.forEach(function(radioRef) {
+                            return radioRef.checked = radioRef.value === fieldValue;
+                        });
+                    }
+                } else if (isFileInput(fieldReference.ref)) {
+                    fieldReference.ref.value = "";
+                } else {
+                    fieldReference.ref.value = fieldValue;
+                    if (!fieldReference.ref.type) {
+                        _subjects.state.next({
+                            name: name,
+                            values: cloneObject(_formValues)
+                        });
+                    }
+                }
+            }
+        }
+        (options.shouldDirty || options.shouldTouch) && updateTouchAndDirty(name, fieldValue, options.shouldTouch, options.shouldDirty, true);
+        options.shouldValidate && trigger(name);
+    };
+    var setValues = function(name, value1, options) {
+        for(var fieldKey in value1){
+            if (!value1.hasOwnProperty(fieldKey)) {
+                return;
+            }
+            var fieldValue = value1[fieldKey];
+            var fieldName = "".concat(name, ".").concat(fieldKey);
+            var field = get(_fields, fieldName);
+            (_names.array.has(name) || isObject(fieldValue) || field && !field._f) && !isDateObject(fieldValue) ? setValues(fieldName, fieldValue, options) : setFieldValue(fieldName, fieldValue, options);
+        }
+    };
+    var setValue = function(name, value1) {
+        var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+        var field = get(_fields, name);
+        var isFieldArray = _names.array.has(name);
+        var cloneValue = cloneObject(value1);
+        set(_formValues, name, cloneValue);
+        if (isFieldArray) {
+            _subjects.array.next({
+                name: name,
+                values: cloneObject(_formValues)
+            });
+            if ((_proxyFormState.isDirty || _proxyFormState.dirtyFields || _proxySubscribeFormState.isDirty || _proxySubscribeFormState.dirtyFields) && options.shouldDirty) {
+                _subjects.state.next({
+                    name: name,
+                    dirtyFields: getDirtyFields(_defaultValues, _formValues),
+                    isDirty: _getDirty(name, cloneValue)
+                });
+            }
+        } else {
+            field && !field._f && !isNullOrUndefined(cloneValue) ? setValues(name, cloneValue, options) : setFieldValue(name, cloneValue, options);
+        }
+        isWatched(name, _names) && _subjects.state.next(_object_spread({}, _formState));
+        _subjects.state.next({
+            name: _state.mount ? name : undefined,
+            values: cloneObject(_formValues)
+        });
+    };
+    var onChange = function() {
+        var _ref = _async_to_generator(function(event) {
+            var target, name, isFieldValueUpdated, field, _updateIsFieldValueUpdated, validationModeBeforeSubmit, validationModeAfterSubmit, error, isValid, fieldValue, isBlurEvent, shouldSkipValidation, watched, fieldState, shouldRender, errors, previousErrorLookupResult, errorLookupResult;
+            return _ts_generator(this, function(_state1) {
+                switch(_state1.label){
+                    case 0:
+                        _state.mount = true;
+                        target = event.target;
+                        name = target.name;
+                        isFieldValueUpdated = true;
+                        field = get(_fields, name);
+                        _updateIsFieldValueUpdated = function(fieldValue) {
+                            isFieldValueUpdated = Number.isNaN(fieldValue) || isDateObject(fieldValue) && isNaN(fieldValue.getTime()) || deepEqual(fieldValue, get(_formValues, name, fieldValue));
+                        };
+                        validationModeBeforeSubmit = getValidationModes(_options.mode);
+                        validationModeAfterSubmit = getValidationModes(_options.reValidateMode);
+                        if (!field) return [
+                            3,
+                            7
+                        ];
+                        fieldValue = target.type ? getFieldValue(field._f) : getEventValue(event);
+                        isBlurEvent = event.type === EVENTS.BLUR || event.type === EVENTS.FOCUS_OUT;
+                        shouldSkipValidation = !hasValidation(field._f) && !_options.resolver && !get(_formState.errors, name) && !field._f.deps || skipValidation(isBlurEvent, get(_formState.touchedFields, name), _formState.isSubmitted, validationModeAfterSubmit, validationModeBeforeSubmit);
+                        watched = isWatched(name, _names, isBlurEvent);
+                        set(_formValues, name, fieldValue);
+                        if (isBlurEvent) {
+                            field._f.onBlur && field._f.onBlur(event);
+                            delayErrorCallback && delayErrorCallback(0);
+                        } else if (field._f.onChange) {
+                            field._f.onChange(event);
+                        }
+                        fieldState = updateTouchAndDirty(name, fieldValue, isBlurEvent);
+                        shouldRender = !isEmptyObject(fieldState) || watched;
+                        !isBlurEvent && _subjects.state.next({
+                            name: name,
+                            type: event.type,
+                            values: cloneObject(_formValues)
+                        });
+                        if (shouldSkipValidation) {
+                            if (_proxyFormState.isValid || _proxySubscribeFormState.isValid) {
+                                if (_options.mode === "onBlur") {
+                                    if (isBlurEvent) {
+                                        _setValid();
+                                    }
+                                } else if (!isBlurEvent) {
+                                    _setValid();
+                                }
+                            }
+                            return [
+                                2,
+                                shouldRender && _subjects.state.next(_object_spread({
+                                    name: name
+                                }, watched ? {} : fieldState))
+                            ];
+                        }
+                        !isBlurEvent && watched && _subjects.state.next(_object_spread({}, _formState));
+                        if (!_options.resolver) return [
+                            3,
+                            2
+                        ];
+                        return [
+                            4,
+                            _runSchema([
+                                name
+                            ])
+                        ];
+                    case 1:
+                        errors = _state1.sent().errors;
+                        _updateIsFieldValueUpdated(fieldValue);
+                        if (isFieldValueUpdated) {
+                            previousErrorLookupResult = schemaErrorLookup(_formState.errors, _fields, name);
+                            errorLookupResult = schemaErrorLookup(errors, _fields, previousErrorLookupResult.name || name);
+                            error = errorLookupResult.error;
+                            name = errorLookupResult.name;
+                            isValid = isEmptyObject(errors);
+                        }
+                        return [
+                            3,
+                            6
+                        ];
+                    case 2:
+                        _updateIsValidating([
+                            name
+                        ], true);
+                        return [
+                            4,
+                            validateField(field, _names.disabled, _formValues, shouldDisplayAllAssociatedErrors, _options.shouldUseNativeValidation)
+                        ];
+                    case 3:
+                        error = _state1.sent()[name];
+                        _updateIsValidating([
+                            name
+                        ]);
+                        _updateIsFieldValueUpdated(fieldValue);
+                        if (!isFieldValueUpdated) return [
+                            3,
+                            6
+                        ];
+                        if (!error) return [
+                            3,
+                            4
+                        ];
+                        isValid = false;
+                        return [
+                            3,
+                            6
+                        ];
+                    case 4:
+                        if (!(_proxyFormState.isValid || _proxySubscribeFormState.isValid)) return [
+                            3,
+                            6
+                        ];
+                        return [
+                            4,
+                            executeBuiltInValidation(_fields, true)
+                        ];
+                    case 5:
+                        isValid = _state1.sent();
+                        _state1.label = 6;
+                    case 6:
+                        if (isFieldValueUpdated) {
+                            field._f.deps && trigger(field._f.deps);
+                            shouldRenderByError(name, isValid, error, fieldState);
+                        }
+                        _state1.label = 7;
+                    case 7:
+                        return [
+                            2
+                        ];
+                }
+            });
+        });
+        return function onChange(event) {
+            return _ref.apply(this, arguments);
+        };
+    }();
+    var _focusInput = function(ref, key) {
+        if (get(_formState.errors, key) && ref.focus) {
+            ref.focus();
+            return 1;
+        }
+        return;
+    };
+    var trigger = function() {
+        var _ref = _async_to_generator(function(name) {
+            var options, isValid, validationResult, fieldNames, errors;
+            var _arguments = arguments;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        options = _arguments.length > 1 && _arguments[1] !== void 0 ? _arguments[1] : {};
+                        fieldNames = convertToArrayPayload(name);
+                        if (!_options.resolver) return [
+                            3,
+                            2
+                        ];
+                        return [
+                            4,
+                            executeSchemaAndUpdateState(isUndefined(name) ? name : fieldNames)
+                        ];
+                    case 1:
+                        errors = _state.sent();
+                        isValid = isEmptyObject(errors);
+                        validationResult = name ? !fieldNames.some(function(name) {
+                            return get(errors, name);
+                        }) : isValid;
+                        return [
+                            3,
+                            6
+                        ];
+                    case 2:
+                        if (!name) return [
+                            3,
+                            4
+                        ];
+                        return [
+                            4,
+                            Promise.all(fieldNames.map(function() {
+                                var _ref = _async_to_generator(function(fieldName) {
+                                    var field;
+                                    return _ts_generator(this, function(_state) {
+                                        switch(_state.label){
+                                            case 0:
+                                                field = get(_fields, fieldName);
+                                                return [
+                                                    4,
+                                                    executeBuiltInValidation(field && field._f ? _define_property({}, fieldName, field) : field)
+                                                ];
+                                            case 1:
+                                                return [
+                                                    2,
+                                                    _state.sent()
+                                                ];
+                                        }
+                                    });
+                                });
+                                return function(fieldName) {
+                                    return _ref.apply(this, arguments);
+                                };
+                            }()))
+                        ];
+                    case 3:
+                        validationResult = _state.sent().every(Boolean);
+                        !(!validationResult && !_formState.isValid) && _setValid();
+                        return [
+                            3,
+                            6
+                        ];
+                    case 4:
+                        return [
+                            4,
+                            executeBuiltInValidation(_fields)
+                        ];
+                    case 5:
+                        validationResult = isValid = _state.sent();
+                        _state.label = 6;
+                    case 6:
+                        _subjects.state.next(_object_spread_props(_object_spread({}, !isString(name) || (_proxyFormState.isValid || _proxySubscribeFormState.isValid) && isValid !== _formState.isValid ? {} : {
+                            name: name
+                        }, _options.resolver || !name ? {
+                            isValid: isValid
+                        } : {}), {
+                            errors: _formState.errors
+                        }));
+                        options.shouldFocus && !validationResult && iterateFieldsByAction(_fields, _focusInput, name ? fieldNames : _names.mount);
+                        return [
+                            2,
+                            validationResult
+                        ];
+                }
+            });
+        });
+        return function trigger(name) {
+            return _ref.apply(this, arguments);
+        };
+    }();
+    var getValues = function(fieldNames) {
+        var values = _object_spread({}, _state.mount ? _formValues : _defaultValues);
+        return isUndefined(fieldNames) ? values : isString(fieldNames) ? get(values, fieldNames) : fieldNames.map(function(name) {
+            return get(values, name);
+        });
+    };
+    var getFieldState = function(name, formState) {
+        return {
+            invalid: !!get((formState || _formState).errors, name),
+            isDirty: !!get((formState || _formState).dirtyFields, name),
+            error: get((formState || _formState).errors, name),
+            isValidating: !!get(_formState.validatingFields, name),
+            isTouched: !!get((formState || _formState).touchedFields, name)
+        };
+    };
+    var clearErrors = function(name) {
+        name && convertToArrayPayload(name).forEach(function(inputName) {
+            return unset(_formState.errors, inputName);
+        });
+        _subjects.state.next({
+            errors: name ? _formState.errors : {}
+        });
+    };
+    var setError = function(name, error, options) {
+        var ref = (get(_fields, name, {
+            _f: {}
+        })._f || {}).ref;
+        var currentError = get(_formState.errors, name) || {};
+        // Don't override existing error messages elsewhere in the object tree.
+        currentError.ref; currentError.message; currentError.type; var restOfErrorTree = _object_without_properties(currentError, [
+            "ref",
+            "message",
+            "type"
+        ]);
+        set(_formState.errors, name, _object_spread_props(_object_spread({}, restOfErrorTree, error), {
+            ref: ref
+        }));
+        _subjects.state.next({
+            name: name,
+            errors: _formState.errors,
+            isValid: false
+        });
+        options && options.shouldFocus && ref && ref.focus && ref.focus();
+    };
+    var watch = function(name, defaultValue) {
+        return isFunction(name) ? _subjects.state.subscribe({
+            next: function(payload) {
+                return name(_getWatch(undefined, defaultValue), payload);
+            }
+        }) : _getWatch(name, defaultValue, true);
+    };
+    var _subscribe = function(props) {
+        return _subjects.state.subscribe({
+            next: function(formState) {
+                if (shouldSubscribeByName(props.name, formState.name, props.exact) && shouldRenderFormState(formState, props.formState || _proxyFormState, _setFormState, props.reRenderRoot)) {
+                    props.callback(_object_spread({
+                        values: _object_spread({}, _formValues)
+                    }, _formState, formState));
+                }
+            }
+        }).unsubscribe;
+    };
+    var subscribe = function(props) {
+        _state.mount = true;
+        _proxySubscribeFormState = _object_spread({}, _proxySubscribeFormState, props.formState);
+        return _subscribe(_object_spread_props(_object_spread({}, props), {
+            formState: _proxySubscribeFormState
+        }));
+    };
+    var unregister = function(name) {
+        var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = (name ? convertToArrayPayload(name) : _names.mount)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var fieldName = _step.value;
+                _names.mount.delete(fieldName);
+                _names.array.delete(fieldName);
+                if (!options.keepValue) {
+                    unset(_fields, fieldName);
+                    unset(_formValues, fieldName);
+                }
+                !options.keepError && unset(_formState.errors, fieldName);
+                !options.keepDirty && unset(_formState.dirtyFields, fieldName);
+                !options.keepTouched && unset(_formState.touchedFields, fieldName);
+                !options.keepIsValidating && unset(_formState.validatingFields, fieldName);
+                !_options.shouldUnregister && !options.keepDefaultValue && unset(_defaultValues, fieldName);
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+        _subjects.state.next({
+            values: cloneObject(_formValues)
+        });
+        _subjects.state.next(_object_spread({}, _formState, !options.keepDirty ? {} : {
+            isDirty: _getDirty()
+        }));
+        !options.keepIsValid && _setValid();
+    };
+    var _setDisabledField = function(param) {
+        var disabled = param.disabled, name = param.name;
+        if (isBoolean(disabled) && _state.mount || !!disabled || _names.disabled.has(name)) {
+            disabled ? _names.disabled.add(name) : _names.disabled.delete(name);
+        }
+    };
+    var register = function(name) {
+        var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+        var field = get(_fields, name);
+        var disabledIsDefined = isBoolean(options.disabled) || isBoolean(_options.disabled);
+        set(_fields, name, _object_spread_props(_object_spread({}, field || {}), {
+            _f: _object_spread(_object_spread_props(_object_spread({}, field && field._f ? field._f : {
+                ref: {
+                    name: name
+                }
+            }), {
+                name: name,
+                mount: true
+            }), options)
+        }));
+        _names.mount.add(name);
+        if (field) {
+            _setDisabledField({
+                disabled: isBoolean(options.disabled) ? options.disabled : _options.disabled,
+                name: name
+            });
+        } else {
+            updateValidAndValue(name, true, options.value);
+        }
+        return _object_spread_props(_object_spread({}, disabledIsDefined ? {
+            disabled: options.disabled || _options.disabled
+        } : {}, _options.progressive ? {
+            required: !!options.required,
+            min: getRuleValue(options.min),
+            max: getRuleValue(options.max),
+            minLength: getRuleValue(options.minLength),
+            maxLength: getRuleValue(options.maxLength),
+            pattern: getRuleValue(options.pattern)
+        } : {}), {
+            name: name,
+            onChange: onChange,
+            onBlur: onChange,
+            ref: function(ref) {
+                if (ref) {
+                    register(name, options);
+                    field = get(_fields, name);
+                    var fieldRef = isUndefined(ref.value) ? ref.querySelectorAll ? ref.querySelectorAll("input,select,textarea")[0] || ref : ref : ref;
+                    var radioOrCheckbox = isRadioOrCheckbox(fieldRef);
+                    var refs = field._f.refs || [];
+                    if (radioOrCheckbox ? refs.find(function(option) {
+                        return option === fieldRef;
+                    }) : fieldRef === field._f.ref) {
+                        return;
+                    }
+                    set(_fields, name, {
+                        _f: _object_spread({}, field._f, radioOrCheckbox ? {
+                            refs: _to_consumable_array(refs.filter(live)).concat([
+                                fieldRef
+                            ], _to_consumable_array(Array.isArray(get(_defaultValues, name)) ? [
+                                {}
+                            ] : [])),
+                            ref: {
+                                type: fieldRef.type,
+                                name: name
+                            }
+                        } : {
+                            ref: fieldRef
+                        })
+                    });
+                    updateValidAndValue(name, false, undefined, fieldRef);
+                } else {
+                    field = get(_fields, name, {});
+                    if (field._f) {
+                        field._f.mount = false;
+                    }
+                    (_options.shouldUnregister || options.shouldUnregister) && !(isNameInFieldArray(_names.array, name) && _state.action) && _names.unMount.add(name);
+                }
+            }
+        });
+    };
+    var _focusError = function() {
+        return _options.shouldFocusError && iterateFieldsByAction(_fields, _focusInput, _names.mount);
+    };
+    var _disableForm = function(disabled) {
+        if (isBoolean(disabled)) {
+            _subjects.state.next({
+                disabled: disabled
+            });
+            iterateFieldsByAction(_fields, function(ref, name) {
+                var currentField = get(_fields, name);
+                if (currentField) {
+                    ref.disabled = currentField._f.disabled || disabled;
+                    if (Array.isArray(currentField._f.refs)) {
+                        currentField._f.refs.forEach(function(inputRef) {
+                            inputRef.disabled = currentField._f.disabled || disabled;
+                        });
+                    }
+                }
+            }, 0, false);
+        }
+    };
+    var handleSubmit = function(onValid, onInvalid) {
+        return function() {
+            var _ref = _async_to_generator(function(e) {
+                var onValidError, fieldValues, _ref, errors, values, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, name, error;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            onValidError = undefined;
+                            if (e) {
+                                e.preventDefault && e.preventDefault();
+                                e.persist && e.persist();
+                            }
+                            fieldValues = cloneObject(_formValues);
+                            _subjects.state.next({
+                                isSubmitting: true
+                            });
+                            if (!_options.resolver) return [
+                                3,
+                                2
+                            ];
+                            return [
+                                4,
+                                _runSchema()
+                            ];
+                        case 1:
+                            _ref = _state.sent(), errors = _ref.errors, values = _ref.values;
+                            _formState.errors = errors;
+                            fieldValues = values;
+                            return [
+                                3,
+                                4
+                            ];
+                        case 2:
+                            return [
+                                4,
+                                executeBuiltInValidation(_fields)
+                            ];
+                        case 3:
+                            _state.sent();
+                            _state.label = 4;
+                        case 4:
+                            if (_names.disabled.size) {
+                                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                try {
+                                    for(_iterator = _names.disabled[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                        name = _step.value;
+                                        set(fieldValues, name, undefined);
+                                    }
+                                } catch (err) {
+                                    _didIteratorError = true;
+                                    _iteratorError = err;
+                                } finally{
+                                    try {
+                                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                            _iterator.return();
+                                        }
+                                    } finally{
+                                        if (_didIteratorError) {
+                                            throw _iteratorError;
+                                        }
+                                    }
+                                }
+                            }
+                            unset(_formState.errors, "root");
+                            if (!isEmptyObject(_formState.errors)) return [
+                                3,
+                                9
+                            ];
+                            _subjects.state.next({
+                                errors: {}
+                            });
+                            _state.label = 5;
+                        case 5:
+                            _state.trys.push([
+                                5,
+                                7,
+                                ,
+                                8
+                            ]);
+                            return [
+                                4,
+                                onValid(fieldValues, e)
+                            ];
+                        case 6:
+                            _state.sent();
+                            return [
+                                3,
+                                8
+                            ];
+                        case 7:
+                            error = _state.sent();
+                            onValidError = error;
+                            return [
+                                3,
+                                8
+                            ];
+                        case 8:
+                            return [
+                                3,
+                                12
+                            ];
+                        case 9:
+                            if (!onInvalid) return [
+                                3,
+                                11
+                            ];
+                            return [
+                                4,
+                                onInvalid(_object_spread({}, _formState.errors), e)
+                            ];
+                        case 10:
+                            _state.sent();
+                            _state.label = 11;
+                        case 11:
+                            _focusError();
+                            setTimeout(_focusError);
+                            _state.label = 12;
+                        case 12:
+                            _subjects.state.next({
+                                isSubmitted: true,
+                                isSubmitting: false,
+                                isSubmitSuccessful: isEmptyObject(_formState.errors) && !onValidError,
+                                submitCount: _formState.submitCount + 1,
+                                errors: _formState.errors
+                            });
+                            if (onValidError) {
+                                throw onValidError;
+                            }
+                            return [
+                                2
+                            ];
+                    }
+                });
+            });
+            return function(e) {
+                return _ref.apply(this, arguments);
+            };
+        }();
+    };
+    var resetField = function(name) {
+        var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+        if (get(_fields, name)) {
+            if (isUndefined(options.defaultValue)) {
+                setValue(name, cloneObject(get(_defaultValues, name)));
+            } else {
+                setValue(name, options.defaultValue);
+                set(_defaultValues, name, cloneObject(options.defaultValue));
+            }
+            if (!options.keepTouched) {
+                unset(_formState.touchedFields, name);
+            }
+            if (!options.keepDirty) {
+                unset(_formState.dirtyFields, name);
+                _formState.isDirty = options.defaultValue ? _getDirty(name, cloneObject(get(_defaultValues, name))) : _getDirty();
+            }
+            if (!options.keepError) {
+                unset(_formState.errors, name);
+                _proxyFormState.isValid && _setValid();
+            }
+            _subjects.state.next(_object_spread({}, _formState));
+        }
+    };
+    var _reset = function(formValues) {
+        var keepStateOptions = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+        var updatedValues = formValues ? cloneObject(formValues) : _defaultValues;
+        var cloneUpdatedValues = cloneObject(updatedValues);
+        var isEmptyResetValues = isEmptyObject(formValues);
+        var values = isEmptyResetValues ? _defaultValues : cloneUpdatedValues;
+        if (!keepStateOptions.keepDefaultValues) {
+            _defaultValues = updatedValues;
+        }
+        if (!keepStateOptions.keepValues) {
+            if (keepStateOptions.keepDirtyValues) {
+                var fieldsToCheck = new Set(_to_consumable_array(_names.mount).concat(_to_consumable_array(Object.keys(getDirtyFields(_defaultValues, _formValues)))));
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = Array.from(fieldsToCheck)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var fieldName = _step.value;
+                        get(_formState.dirtyFields, fieldName) ? set(values, fieldName, get(_formValues, fieldName)) : setValue(fieldName, get(values, fieldName));
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+            } else {
+                if (isWeb && isUndefined(formValues)) {
+                    var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                    try {
+                        for(var _iterator1 = _names.mount[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                            var name = _step1.value;
+                            var field = get(_fields, name);
+                            if (field && field._f) {
+                                var fieldReference = Array.isArray(field._f.refs) ? field._f.refs[0] : field._f.ref;
+                                if (isHTMLElement(fieldReference)) {
+                                    var form = fieldReference.closest("form");
+                                    if (form) {
+                                        form.reset();
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                    } catch (err) {
+                        _didIteratorError1 = true;
+                        _iteratorError1 = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                                _iterator1.return();
+                            }
+                        } finally{
+                            if (_didIteratorError1) {
+                                throw _iteratorError1;
+                            }
+                        }
+                    }
+                }
+                var _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
+                try {
+                    for(var _iterator2 = _names.mount[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true){
+                        var fieldName1 = _step2.value;
+                        setValue(fieldName1, get(values, fieldName1));
+                    }
+                } catch (err) {
+                    _didIteratorError2 = true;
+                    _iteratorError2 = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+                            _iterator2.return();
+                        }
+                    } finally{
+                        if (_didIteratorError2) {
+                            throw _iteratorError2;
+                        }
+                    }
+                }
+            }
+            _formValues = cloneObject(values);
+            _subjects.array.next({
+                values: _object_spread({}, values)
+            });
+            _subjects.state.next({
+                values: _object_spread({}, values)
+            });
+        }
+        _names = {
+            mount: keepStateOptions.keepDirtyValues ? _names.mount : new Set(),
+            unMount: new Set(),
+            array: new Set(),
+            disabled: new Set(),
+            watch: new Set(),
+            watchAll: false,
+            focus: ""
+        };
+        _state.mount = !_proxyFormState.isValid || !!keepStateOptions.keepIsValid || !!keepStateOptions.keepDirtyValues;
+        _state.watch = !!_options.shouldUnregister;
+        _subjects.state.next({
+            submitCount: keepStateOptions.keepSubmitCount ? _formState.submitCount : 0,
+            isDirty: isEmptyResetValues ? false : keepStateOptions.keepDirty ? _formState.isDirty : !!(keepStateOptions.keepDefaultValues && !deepEqual(formValues, _defaultValues)),
+            isSubmitted: keepStateOptions.keepIsSubmitted ? _formState.isSubmitted : false,
+            dirtyFields: isEmptyResetValues ? {} : keepStateOptions.keepDirtyValues ? keepStateOptions.keepDefaultValues && _formValues ? getDirtyFields(_defaultValues, _formValues) : _formState.dirtyFields : keepStateOptions.keepDefaultValues && formValues ? getDirtyFields(_defaultValues, formValues) : keepStateOptions.keepDirty ? _formState.dirtyFields : {},
+            touchedFields: keepStateOptions.keepTouched ? _formState.touchedFields : {},
+            errors: keepStateOptions.keepErrors ? _formState.errors : {},
+            isSubmitSuccessful: keepStateOptions.keepIsSubmitSuccessful ? _formState.isSubmitSuccessful : false,
+            isSubmitting: false
+        });
+    };
+    var reset = function(formValues, keepStateOptions) {
+        return _reset(isFunction(formValues) ? formValues(_formValues) : formValues, keepStateOptions);
+    };
+    var setFocus = function(name) {
+        var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+        var field = get(_fields, name);
+        var fieldReference = field && field._f;
+        if (fieldReference) {
+            var fieldRef = fieldReference.refs ? fieldReference.refs[0] : fieldReference.ref;
+            if (fieldRef.focus) {
+                fieldRef.focus();
+                options.shouldSelect && isFunction(fieldRef.select) && fieldRef.select();
+            }
+        }
+    };
+    var _setFormState = function(updatedFormState) {
+        _formState = _object_spread({}, _formState, updatedFormState);
+    };
+    var _resetDefaultValues = function() {
+        return isFunction(_options.defaultValues) && _options.defaultValues().then(function(values) {
+            reset(values, _options.resetOptions);
+            _subjects.state.next({
+                isLoading: false
+            });
+        });
+    };
+    var methods = {
+        control: {
+            register: register,
+            unregister: unregister,
+            getFieldState: getFieldState,
+            handleSubmit: handleSubmit,
+            setError: setError,
+            _subscribe: _subscribe,
+            _runSchema: _runSchema,
+            _getWatch: _getWatch,
+            _getDirty: _getDirty,
+            _setValid: _setValid,
+            _setFieldArray: _setFieldArray,
+            _setDisabledField: _setDisabledField,
+            _setErrors: _setErrors,
+            _getFieldArray: _getFieldArray,
+            _reset: _reset,
+            _resetDefaultValues: _resetDefaultValues,
+            _removeUnmounted: _removeUnmounted,
+            _disableForm: _disableForm,
+            _subjects: _subjects,
+            _proxyFormState: _proxyFormState,
+            get _fields () {
+                return _fields;
+            },
+            get _formValues () {
+                return _formValues;
+            },
+            get _state () {
+                return _state;
+            },
+            set _state (value){
+                _state = value;
+            },
+            get _defaultValues () {
+                return _defaultValues;
+            },
+            get _names () {
+                return _names;
+            },
+            set _names (value){
+                _names = value;
+            },
+            get _formState () {
+                return _formState;
+            },
+            get _options () {
+                return _options;
+            },
+            set _options (value){
+                _options = _object_spread({}, _options, value);
+            }
+        },
+        subscribe: subscribe,
+        trigger: trigger,
+        register: register,
+        handleSubmit: handleSubmit,
+        watch: watch,
+        setValue: setValue,
+        getValues: getValues,
+        reset: reset,
+        resetField: resetField,
+        clearErrors: clearErrors,
+        unregister: unregister,
+        setError: setError,
+        setFocus: setFocus,
+        getFieldState: getFieldState
+    };
+    return _object_spread_props(_object_spread({}, methods), {
+        formControl: methods
+    });
+}
+var generateId = function() {
+    var d = typeof performance === "undefined" ? Date.now() : performance.now() * 1000;
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+        var r = (Math.random() * 16 + d) % 16 | 0;
+        return (c == "x" ? r : r & 0x3 | 0x8).toString(16);
+    });
+};
+var getFocusFieldName = function(name, index) {
+    var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+    return options.shouldFocus || isUndefined(options.shouldFocus) ? options.focusName || "".concat(name, ".").concat(isUndefined(options.focusIndex) ? index : options.focusIndex, ".") : "";
+};
+var appendAt = function(data, value1) {
+    return _to_consumable_array(data).concat(_to_consumable_array(convertToArrayPayload(value1)));
+};
+var fillEmptyArray = function(value1) {
+    return Array.isArray(value1) ? value1.map(function() {
+        return undefined;
+    }) : undefined;
+};
+function insert(data, index, value1) {
+    return _to_consumable_array(data.slice(0, index)).concat(_to_consumable_array(convertToArrayPayload(value1)), _to_consumable_array(data.slice(index)));
+}
+var moveArrayAt = function(data, from, to) {
+    if (!Array.isArray(data)) {
+        return [];
+    }
+    if (isUndefined(data[to])) {
+        data[to] = undefined;
+    }
+    data.splice(to, 0, data.splice(from, 1)[0]);
+    return data;
+};
+var prependAt = function(data, value1) {
+    return _to_consumable_array(convertToArrayPayload(value1)).concat(_to_consumable_array(convertToArrayPayload(data)));
+};
+function removeAtIndexes(data, indexes) {
+    var i = 0;
+    var temp = _to_consumable_array(data);
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = indexes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var index = _step.value;
+            temp.splice(index - i, 1);
+            i++;
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return compact(temp).length ? temp : [];
+}
+var removeArrayAt = function(data, index) {
+    return isUndefined(index) ? [] : removeAtIndexes(data, convertToArrayPayload(index).sort(function(a, b) {
+        return a - b;
+    }));
+};
+var swapArrayAt = function(data, indexA, indexB) {
+    var ref;
+    ref = [
+        data[indexB],
+        data[indexA]
+    ], data[indexA] = ref[0], data[indexB] = ref[1];
+};
+var updateAt = function(fieldValues, index, value1) {
+    fieldValues[index] = value1;
+    return fieldValues;
+};
+/**
+ * A custom hook that exposes convenient methods to perform operations with a list of dynamic inputs that need to be appended, updated, removed etc. • [Demo](https://codesandbox.io/s/react-hook-form-usefieldarray-ssugn) • [Video](https://youtu.be/4MrbfGSFY2A)
+ *
+ * @remarks
+ * [API](https://react-hook-form.com/docs/usefieldarray) • [Demo](https://codesandbox.io/s/react-hook-form-usefieldarray-ssugn)
+ *
+ * @param props - useFieldArray props
+ *
+ * @returns methods - functions to manipulate with the Field Arrays (dynamic inputs) {@link UseFieldArrayReturn}
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   const { register, control, handleSubmit, reset, trigger, setError } = useForm({
+ *     defaultValues: {
+ *       test: []
+ *     }
+ *   });
+ *   const { fields, append } = useFieldArray({
+ *     control,
+ *     name: "test"
+ *   });
+ *
+ *   return (
+ *     <form onSubmit={handleSubmit(data => console.log(data))}>
+ *       {fields.map((item, index) => (
+ *          <input key={item.id} {...register(`test.${index}.firstName`)}  />
+ *       ))}
+ *       <button type="button" onClick={() => append({ firstName: "bill" })}>
+ *         append
+ *       </button>
+ *       <input type="submit" />
+ *     </form>
+ *   );
+ * }
+ * ```
+ */ function useFieldArray(props) {
+    var methods = useFormContext();
+    var _props_control = props.control, control = _props_control === void 0 ? methods.control : _props_control, name = props.name, _props_keyName = props.keyName, keyName = _props_keyName === void 0 ? "id" : _props_keyName, shouldUnregister = props.shouldUnregister, rules = props.rules;
+    var _React__default_useState = _sliced_to_array(React__default.useState(control._getFieldArray(name)), 2), fields = _React__default_useState[0], setFields = _React__default_useState[1];
+    var ids = React__default.useRef(control._getFieldArray(name).map(generateId));
+    var _fieldIds = React__default.useRef(fields);
+    var _name = React__default.useRef(name);
+    var _actioned = React__default.useRef(false);
+    _name.current = name;
+    _fieldIds.current = fields;
+    control._names.array.add(name);
+    rules && control.register(name, rules);
+    React__default.useEffect(function() {
+        return control._subjects.array.subscribe({
+            next: function(param) {
+                var values = param.values, fieldArrayName = param.name;
+                if (fieldArrayName === _name.current || !fieldArrayName) {
+                    var fieldValues = get(values, _name.current);
+                    if (Array.isArray(fieldValues)) {
+                        setFields(fieldValues);
+                        ids.current = fieldValues.map(generateId);
+                    }
+                }
+            }
+        }).unsubscribe;
+    }, [
+        control
+    ]);
+    var updateValues = React__default.useCallback(function(updatedFieldArrayValues) {
+        _actioned.current = true;
+        control._setFieldArray(name, updatedFieldArrayValues);
+    }, [
+        control,
+        name
+    ]);
+    var append = function(value1, options) {
+        var appendValue = convertToArrayPayload(cloneObject(value1));
+        var updatedFieldArrayValues = appendAt(control._getFieldArray(name), appendValue);
+        control._names.focus = getFocusFieldName(name, updatedFieldArrayValues.length - 1, options);
+        ids.current = appendAt(ids.current, appendValue.map(generateId));
+        updateValues(updatedFieldArrayValues);
+        setFields(updatedFieldArrayValues);
+        control._setFieldArray(name, updatedFieldArrayValues, appendAt, {
+            argA: fillEmptyArray(value1)
+        });
+    };
+    var prepend = function(value1, options) {
+        var prependValue = convertToArrayPayload(cloneObject(value1));
+        var updatedFieldArrayValues = prependAt(control._getFieldArray(name), prependValue);
+        control._names.focus = getFocusFieldName(name, 0, options);
+        ids.current = prependAt(ids.current, prependValue.map(generateId));
+        updateValues(updatedFieldArrayValues);
+        setFields(updatedFieldArrayValues);
+        control._setFieldArray(name, updatedFieldArrayValues, prependAt, {
+            argA: fillEmptyArray(value1)
+        });
+    };
+    var remove = function(index) {
+        var updatedFieldArrayValues = removeArrayAt(control._getFieldArray(name), index);
+        ids.current = removeArrayAt(ids.current, index);
+        updateValues(updatedFieldArrayValues);
+        setFields(updatedFieldArrayValues);
+        !Array.isArray(get(control._fields, name)) && set(control._fields, name, undefined);
+        control._setFieldArray(name, updatedFieldArrayValues, removeArrayAt, {
+            argA: index
+        });
+    };
+    var insert$1 = function(index, value1, options) {
+        var insertValue = convertToArrayPayload(cloneObject(value1));
+        var updatedFieldArrayValues = insert(control._getFieldArray(name), index, insertValue);
+        control._names.focus = getFocusFieldName(name, index, options);
+        ids.current = insert(ids.current, index, insertValue.map(generateId));
+        updateValues(updatedFieldArrayValues);
+        setFields(updatedFieldArrayValues);
+        control._setFieldArray(name, updatedFieldArrayValues, insert, {
+            argA: index,
+            argB: fillEmptyArray(value1)
+        });
+    };
+    var swap = function(indexA, indexB) {
+        var updatedFieldArrayValues = control._getFieldArray(name);
+        swapArrayAt(updatedFieldArrayValues, indexA, indexB);
+        swapArrayAt(ids.current, indexA, indexB);
+        updateValues(updatedFieldArrayValues);
+        setFields(updatedFieldArrayValues);
+        control._setFieldArray(name, updatedFieldArrayValues, swapArrayAt, {
+            argA: indexA,
+            argB: indexB
+        }, false);
+    };
+    var move = function(from, to) {
+        var updatedFieldArrayValues = control._getFieldArray(name);
+        moveArrayAt(updatedFieldArrayValues, from, to);
+        moveArrayAt(ids.current, from, to);
+        updateValues(updatedFieldArrayValues);
+        setFields(updatedFieldArrayValues);
+        control._setFieldArray(name, updatedFieldArrayValues, moveArrayAt, {
+            argA: from,
+            argB: to
+        }, false);
+    };
+    var update = function(index, value1) {
+        var updateValue = cloneObject(value1);
+        var updatedFieldArrayValues = updateAt(control._getFieldArray(name), index, updateValue);
+        ids.current = _to_consumable_array(updatedFieldArrayValues).map(function(item, i) {
+            return !item || i === index ? generateId() : ids.current[i];
+        });
+        updateValues(updatedFieldArrayValues);
+        setFields(_to_consumable_array(updatedFieldArrayValues));
+        control._setFieldArray(name, updatedFieldArrayValues, updateAt, {
+            argA: index,
+            argB: updateValue
+        }, true, false);
+    };
+    var replace = function(value1) {
+        var updatedFieldArrayValues = convertToArrayPayload(cloneObject(value1));
+        ids.current = updatedFieldArrayValues.map(generateId);
+        updateValues(_to_consumable_array(updatedFieldArrayValues));
+        setFields(_to_consumable_array(updatedFieldArrayValues));
+        control._setFieldArray(name, _to_consumable_array(updatedFieldArrayValues), function(data) {
+            return data;
+        }, {}, true, false);
+    };
+    React__default.useEffect(function() {
+        control._state.action = false;
+        isWatched(name, control._names) && control._subjects.state.next(_object_spread({}, control._formState));
+        if (_actioned.current && (!getValidationModes(control._options.mode).isOnSubmit || control._formState.isSubmitted) && !getValidationModes(control._options.reValidateMode).isOnSubmit) {
+            if (control._options.resolver) {
+                control._runSchema([
+                    name
+                ]).then(function(result) {
+                    var error = get(result.errors, name);
+                    var existingError = get(control._formState.errors, name);
+                    if (existingError ? !error && existingError.type || error && (existingError.type !== error.type || existingError.message !== error.message) : error && error.type) {
+                        error ? set(control._formState.errors, name, error) : unset(control._formState.errors, name);
+                        control._subjects.state.next({
+                            errors: control._formState.errors
+                        });
+                    }
+                });
+            } else {
+                var field = get(control._fields, name);
+                if (field && field._f && !(getValidationModes(control._options.reValidateMode).isOnSubmit && getValidationModes(control._options.mode).isOnSubmit)) {
+                    validateField(field, control._names.disabled, control._formValues, control._options.criteriaMode === VALIDATION_MODE.all, control._options.shouldUseNativeValidation, true).then(function(error) {
+                        return !isEmptyObject(error) && control._subjects.state.next({
+                            errors: updateFieldArrayRootError(control._formState.errors, error, name)
+                        });
+                    });
+                }
+            }
+        }
+        control._subjects.state.next({
+            name: name,
+            values: cloneObject(control._formValues)
+        });
+        control._names.focus && iterateFieldsByAction(control._fields, function(ref, key) {
+            if (control._names.focus && key.startsWith(control._names.focus) && ref.focus) {
+                ref.focus();
+                return 1;
+            }
+            return;
+        });
+        control._names.focus = "";
+        control._setValid();
+        _actioned.current = false;
+    }, [
+        fields,
+        name,
+        control
+    ]);
+    React__default.useEffect(function() {
+        !get(control._formValues, name) && control._setFieldArray(name);
+        return function() {
+            var updateMounted = function(name, value1) {
+                var field = get(control._fields, name);
+                if (field && field._f) {
+                    field._f.mount = value1;
+                }
+            };
+            control._options.shouldUnregister || shouldUnregister ? control.unregister(name) : updateMounted(name, false);
+        };
+    }, [
+        name,
+        control,
+        keyName,
+        shouldUnregister
+    ]);
+    return {
+        swap: React__default.useCallback(swap, [
+            updateValues,
+            name,
+            control
+        ]),
+        move: React__default.useCallback(move, [
+            updateValues,
+            name,
+            control
+        ]),
+        prepend: React__default.useCallback(prepend, [
+            updateValues,
+            name,
+            control
+        ]),
+        append: React__default.useCallback(append, [
+            updateValues,
+            name,
+            control
+        ]),
+        remove: React__default.useCallback(remove, [
+            updateValues,
+            name,
+            control
+        ]),
+        insert: React__default.useCallback(insert$1, [
+            updateValues,
+            name,
+            control
+        ]),
+        update: React__default.useCallback(update, [
+            updateValues,
+            name,
+            control
+        ]),
+        replace: React__default.useCallback(replace, [
+            updateValues,
+            name,
+            control
+        ]),
+        fields: React__default.useMemo(function() {
+            return fields.map(function(field, index) {
+                return _object_spread_props(_object_spread({}, field), _define_property({}, keyName, ids.current[index] || generateId()));
+            });
+        }, [
+            fields,
+            keyName
+        ])
+    };
+}
+/**
+ * Custom hook to manage the entire form.
+ *
+ * @remarks
+ * [API](https://react-hook-form.com/docs/useform) • [Demo](https://codesandbox.io/s/react-hook-form-get-started-ts-5ksmm) • [Video](https://www.youtube.com/watch?v=RkXv4AXXC_4)
+ *
+ * @param props - form configuration and validation parameters.
+ *
+ * @returns methods - individual functions to manage the form state. {@link UseFormReturn}
+ *
+ * @example
+ * ```tsx
+ * function App() {
+ *   const { register, handleSubmit, watch, formState: { errors } } = useForm();
+ *   const onSubmit = data => console.log(data);
+ *
+ *   console.log(watch("example"));
+ *
+ *   return (
+ *     <form onSubmit={handleSubmit(onSubmit)}>
+ *       <input defaultValue="test" {...register("example")} />
+ *       <input {...register("exampleRequired", { required: true })} />
+ *       {errors.exampleRequired && <span>This field is required</span>}
+ *       <button>Submit</button>
+ *     </form>
+ *   );
+ * }
+ * ```
+ */ function useForm() {
+    var props = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+    var _formControl = React__default.useRef(undefined);
+    var _values = React__default.useRef(undefined);
+    var _React__default_useState = _sliced_to_array(React__default.useState({
+        isDirty: false,
+        isValidating: false,
+        isLoading: isFunction(props.defaultValues),
+        isSubmitted: false,
+        isSubmitting: false,
+        isSubmitSuccessful: false,
+        isValid: false,
+        submitCount: 0,
+        dirtyFields: {},
+        touchedFields: {},
+        validatingFields: {},
+        errors: props.errors || {},
+        disabled: props.disabled || false,
+        isReady: false,
+        defaultValues: isFunction(props.defaultValues) ? undefined : props.defaultValues
+    }), 2), formState = _React__default_useState[0], updateFormState = _React__default_useState[1];
+    if (!_formControl.current) {
+        _formControl.current = _object_spread_props(_object_spread({}, props.formControl ? props.formControl : createFormControl(props)), {
+            formState: formState
+        });
+        if (props.formControl && props.defaultValues && !isFunction(props.defaultValues)) {
+            props.formControl.reset(props.defaultValues, props.resetOptions);
+        }
+    }
+    var control = _formControl.current.control;
+    control._options = props;
+    useIsomorphicLayoutEffect(function() {
+        var sub = control._subscribe({
+            formState: control._proxyFormState,
+            callback: function() {
+                return updateFormState(_object_spread({}, control._formState));
+            },
+            reRenderRoot: true
+        });
+        updateFormState(function(data) {
+            return _object_spread_props(_object_spread({}, data), {
+                isReady: true
+            });
+        });
+        control._formState.isReady = true;
+        return sub;
+    }, [
+        control
+    ]);
+    React__default.useEffect(function() {
+        return control._disableForm(props.disabled);
+    }, [
+        control,
+        props.disabled
+    ]);
+    React__default.useEffect(function() {
+        if (props.mode) {
+            control._options.mode = props.mode;
+        }
+        if (props.reValidateMode) {
+            control._options.reValidateMode = props.reValidateMode;
+        }
+        if (props.errors && !isEmptyObject(props.errors)) {
+            control._setErrors(props.errors);
+        }
+    }, [
+        control,
+        props.errors,
+        props.mode,
+        props.reValidateMode
+    ]);
+    React__default.useEffect(function() {
+        props.shouldUnregister && control._subjects.state.next({
+            values: control._getWatch()
+        });
+    }, [
+        control,
+        props.shouldUnregister
+    ]);
+    React__default.useEffect(function() {
+        if (control._proxyFormState.isDirty) {
+            var isDirty = control._getDirty();
+            if (isDirty !== formState.isDirty) {
+                control._subjects.state.next({
+                    isDirty: isDirty
+                });
+            }
+        }
+    }, [
+        control,
+        formState.isDirty
+    ]);
+    React__default.useEffect(function() {
+        if (props.values && !deepEqual(props.values, _values.current)) {
+            control._reset(props.values, control._options.resetOptions);
+            _values.current = props.values;
+            updateFormState(function(state) {
+                return _object_spread({}, state);
+            });
+        } else {
+            control._resetDefaultValues();
+        }
+    }, [
+        control,
+        props.values
+    ]);
+    React__default.useEffect(function() {
+        if (!control._state.mount) {
+            control._setValid();
+            control._state.mount = true;
+        }
+        if (control._state.watch) {
+            control._state.watch = false;
+            control._subjects.state.next(_object_spread({}, control._formState));
+        }
+        control._removeUnmounted();
+    });
+    _formControl.current.formState = getProxyFormState(formState, control);
+    return _formControl.current;
+}
+
+export { Controller as C, FormProvider as F, useFormContext as a, useController as b, useFieldArray as c, useFormState as d, useWatch as e, useForm as u };