@stokr/components-library 3.0.65 → 3.0.67

package/dist/node_modules/formik/dist/formik.esm.js

@@ -0,0 +1,969 @@
+import deepmerge_1 from "../../deepmerge/dist/es.js";
+import isPlainObject from "../../lodash-es/isPlainObject.js";
+import cloneDeep from "../../lodash-es/cloneDeep.js";
+import { useImperativeHandle, useEffect, createElement, Children, forwardRef, useRef, useState, useCallback, useMemo, createContext, useContext, useLayoutEffect } from "react";
+import isEqual from "../../../_virtual/index12.js";
+import warning from "../../tiny-warning/dist/tiny-warning.esm.js";
+import clone from "../../lodash-es/clone.js";
+import toPath from "../../lodash-es/toPath.js";
+import "../../../_virtual/hoist-non-react-statics.cjs.js";
+function _extends() {
+  _extends = Object.assign || function(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+function _objectWithoutPropertiesLoose(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;
+}
+var FormikContext = /* @__PURE__ */ createContext(void 0);
+FormikContext.displayName = "FormikContext";
+var FormikProvider = FormikContext.Provider;
+FormikContext.Consumer;
+function useFormikContext() {
+  var formik = useContext(FormikContext);
+  !!!formik ? process.env.NODE_ENV !== "production" ? warning(false, "Formik context is undefined, please verify you are calling useFormikContext() as child of a <Formik> component.") : warning() : void 0;
+  return formik;
+}
+var isFunction = function isFunction2(obj) {
+  return typeof obj === "function";
+};
+var isObject = function isObject2(obj) {
+  return obj !== null && typeof obj === "object";
+};
+var isInteger = function isInteger2(obj) {
+  return String(Math.floor(Number(obj))) === obj;
+};
+var isString = function isString2(obj) {
+  return Object.prototype.toString.call(obj) === "[object String]";
+};
+var isEmptyChildren = function isEmptyChildren2(children) {
+  return Children.count(children) === 0;
+};
+var isPromise = function isPromise2(value) {
+  return isObject(value) && isFunction(value.then);
+};
+function getActiveElement(doc) {
+  doc = doc || (typeof document !== "undefined" ? document : void 0);
+  if (typeof doc === "undefined") {
+    return null;
+  }
+  try {
+    return doc.activeElement || doc.body;
+  } catch (e) {
+    return doc.body;
+  }
+}
+function getIn(obj, key, def, p) {
+  if (p === void 0) {
+    p = 0;
+  }
+  var path = toPath(key);
+  while (obj && p < path.length) {
+    obj = obj[path[p++]];
+  }
+  if (p !== path.length && !obj) {
+    return def;
+  }
+  return obj === void 0 ? def : obj;
+}
+function setIn(obj, path, value) {
+  var res = clone(obj);
+  var resVal = res;
+  var i = 0;
+  var pathArray = toPath(path);
+  for (; i < pathArray.length - 1; i++) {
+    var currentPath = pathArray[i];
+    var currentObj = getIn(obj, pathArray.slice(0, i + 1));
+    if (currentObj && (isObject(currentObj) || Array.isArray(currentObj))) {
+      resVal = resVal[currentPath] = clone(currentObj);
+    } else {
+      var nextPath = pathArray[i + 1];
+      resVal = resVal[currentPath] = isInteger(nextPath) && Number(nextPath) >= 0 ? [] : {};
+    }
+  }
+  if ((i === 0 ? obj : resVal)[pathArray[i]] === value) {
+    return obj;
+  }
+  if (value === void 0) {
+    delete resVal[pathArray[i]];
+  } else {
+    resVal[pathArray[i]] = value;
+  }
+  if (i === 0 && value === void 0) {
+    delete res[pathArray[i]];
+  }
+  return res;
+}
+function setNestedObjectValues(object, value, visited, response) {
+  if (visited === void 0) {
+    visited = /* @__PURE__ */ new WeakMap();
+  }
+  if (response === void 0) {
+    response = {};
+  }
+  for (var _i = 0, _Object$keys = Object.keys(object); _i < _Object$keys.length; _i++) {
+    var k = _Object$keys[_i];
+    var val = object[k];
+    if (isObject(val)) {
+      if (!visited.get(val)) {
+        visited.set(val, true);
+        response[k] = Array.isArray(val) ? [] : {};
+        setNestedObjectValues(val, value, visited, response[k]);
+      }
+    } else {
+      response[k] = value;
+    }
+  }
+  return response;
+}
+function formikReducer(state, msg) {
+  switch (msg.type) {
+    case "SET_VALUES":
+      return _extends({}, state, {
+        values: msg.payload
+      });
+    case "SET_TOUCHED":
+      return _extends({}, state, {
+        touched: msg.payload
+      });
+    case "SET_ERRORS":
+      if (isEqual(state.errors, msg.payload)) {
+        return state;
+      }
+      return _extends({}, state, {
+        errors: msg.payload
+      });
+    case "SET_STATUS":
+      return _extends({}, state, {
+        status: msg.payload
+      });
+    case "SET_ISSUBMITTING":
+      return _extends({}, state, {
+        isSubmitting: msg.payload
+      });
+    case "SET_ISVALIDATING":
+      return _extends({}, state, {
+        isValidating: msg.payload
+      });
+    case "SET_FIELD_VALUE":
+      return _extends({}, state, {
+        values: setIn(state.values, msg.payload.field, msg.payload.value)
+      });
+    case "SET_FIELD_TOUCHED":
+      return _extends({}, state, {
+        touched: setIn(state.touched, msg.payload.field, msg.payload.value)
+      });
+    case "SET_FIELD_ERROR":
+      return _extends({}, state, {
+        errors: setIn(state.errors, msg.payload.field, msg.payload.value)
+      });
+    case "RESET_FORM":
+      return _extends({}, state, msg.payload);
+    case "SET_FORMIK_STATE":
+      return msg.payload(state);
+    case "SUBMIT_ATTEMPT":
+      return _extends({}, state, {
+        touched: setNestedObjectValues(state.values, true),
+        isSubmitting: true,
+        submitCount: state.submitCount + 1
+      });
+    case "SUBMIT_FAILURE":
+      return _extends({}, state, {
+        isSubmitting: false
+      });
+    case "SUBMIT_SUCCESS":
+      return _extends({}, state, {
+        isSubmitting: false
+      });
+    default:
+      return state;
+  }
+}
+var emptyErrors = {};
+var emptyTouched = {};
+function useFormik(_ref) {
+  var _ref$validateOnChange = _ref.validateOnChange, validateOnChange = _ref$validateOnChange === void 0 ? true : _ref$validateOnChange, _ref$validateOnBlur = _ref.validateOnBlur, validateOnBlur = _ref$validateOnBlur === void 0 ? true : _ref$validateOnBlur, _ref$validateOnMount = _ref.validateOnMount, validateOnMount = _ref$validateOnMount === void 0 ? false : _ref$validateOnMount, isInitialValid = _ref.isInitialValid, _ref$enableReinitiali = _ref.enableReinitialize, enableReinitialize = _ref$enableReinitiali === void 0 ? false : _ref$enableReinitiali, onSubmit = _ref.onSubmit, rest = _objectWithoutPropertiesLoose(_ref, ["validateOnChange", "validateOnBlur", "validateOnMount", "isInitialValid", "enableReinitialize", "onSubmit"]);
+  var props = _extends({
+    validateOnChange,
+    validateOnBlur,
+    validateOnMount,
+    onSubmit
+  }, rest);
+  var initialValues = useRef(props.initialValues);
+  var initialErrors = useRef(props.initialErrors || emptyErrors);
+  var initialTouched = useRef(props.initialTouched || emptyTouched);
+  var initialStatus = useRef(props.initialStatus);
+  var isMounted = useRef(false);
+  var fieldRegistry = useRef({});
+  if (process.env.NODE_ENV !== "production") {
+    useEffect(function() {
+      !(typeof isInitialValid === "undefined") ? process.env.NODE_ENV !== "production" ? warning(false, "isInitialValid has been deprecated and will be removed in future versions of Formik. Please use initialErrors or validateOnMount instead.") : warning() : void 0;
+    }, []);
+  }
+  useEffect(function() {
+    isMounted.current = true;
+    return function() {
+      isMounted.current = false;
+    };
+  }, []);
+  var _React$useState = useState(0), setIteration = _React$useState[1];
+  var stateRef = useRef({
+    values: cloneDeep(props.initialValues),
+    errors: cloneDeep(props.initialErrors) || emptyErrors,
+    touched: cloneDeep(props.initialTouched) || emptyTouched,
+    status: cloneDeep(props.initialStatus),
+    isSubmitting: false,
+    isValidating: false,
+    submitCount: 0
+  });
+  var state = stateRef.current;
+  var dispatch = useCallback(function(action) {
+    var prev = stateRef.current;
+    stateRef.current = formikReducer(prev, action);
+    if (prev !== stateRef.current) setIteration(function(x) {
+      return x + 1;
+    });
+  }, []);
+  var runValidateHandler = useCallback(function(values, field) {
+    return new Promise(function(resolve, reject) {
+      var maybePromisedErrors = props.validate(values, field);
+      if (maybePromisedErrors == null) {
+        resolve(emptyErrors);
+      } else if (isPromise(maybePromisedErrors)) {
+        maybePromisedErrors.then(function(errors) {
+          resolve(errors || emptyErrors);
+        }, function(actualException) {
+          if (process.env.NODE_ENV !== "production") {
+            console.warn("Warning: An unhandled error was caught during validation in <Formik validate />", actualException);
+          }
+          reject(actualException);
+        });
+      } else {
+        resolve(maybePromisedErrors);
+      }
+    });
+  }, [props.validate]);
+  var runValidationSchema = useCallback(function(values, field) {
+    var validationSchema = props.validationSchema;
+    var schema = isFunction(validationSchema) ? validationSchema(field) : validationSchema;
+    var promise = field && schema.validateAt ? schema.validateAt(field, values) : validateYupSchema(values, schema);
+    return new Promise(function(resolve, reject) {
+      promise.then(function() {
+        resolve(emptyErrors);
+      }, function(err) {
+        if (err.name === "ValidationError") {
+          resolve(yupToFormErrors(err));
+        } else {
+          if (process.env.NODE_ENV !== "production") {
+            console.warn("Warning: An unhandled error was caught during validation in <Formik validationSchema />", err);
+          }
+          reject(err);
+        }
+      });
+    });
+  }, [props.validationSchema]);
+  var runSingleFieldLevelValidation = useCallback(function(field, value) {
+    return new Promise(function(resolve) {
+      return resolve(fieldRegistry.current[field].validate(value));
+    });
+  }, []);
+  var runFieldLevelValidations = useCallback(function(values) {
+    var fieldKeysWithValidation = Object.keys(fieldRegistry.current).filter(function(f) {
+      return isFunction(fieldRegistry.current[f].validate);
+    });
+    var fieldValidations = fieldKeysWithValidation.length > 0 ? fieldKeysWithValidation.map(function(f) {
+      return runSingleFieldLevelValidation(f, getIn(values, f));
+    }) : [Promise.resolve("DO_NOT_DELETE_YOU_WILL_BE_FIRED")];
+    return Promise.all(fieldValidations).then(function(fieldErrorsList) {
+      return fieldErrorsList.reduce(function(prev, curr, index) {
+        if (curr === "DO_NOT_DELETE_YOU_WILL_BE_FIRED") {
+          return prev;
+        }
+        if (curr) {
+          prev = setIn(prev, fieldKeysWithValidation[index], curr);
+        }
+        return prev;
+      }, {});
+    });
+  }, [runSingleFieldLevelValidation]);
+  var runAllValidations = useCallback(function(values) {
+    return Promise.all([runFieldLevelValidations(values), props.validationSchema ? runValidationSchema(values) : {}, props.validate ? runValidateHandler(values) : {}]).then(function(_ref2) {
+      var fieldErrors = _ref2[0], schemaErrors = _ref2[1], validateErrors = _ref2[2];
+      var combinedErrors = deepmerge_1.all([fieldErrors, schemaErrors, validateErrors], {
+        arrayMerge
+      });
+      return combinedErrors;
+    });
+  }, [props.validate, props.validationSchema, runFieldLevelValidations, runValidateHandler, runValidationSchema]);
+  var validateFormWithHighPriority = useEventCallback(function(values) {
+    if (values === void 0) {
+      values = state.values;
+    }
+    dispatch({
+      type: "SET_ISVALIDATING",
+      payload: true
+    });
+    return runAllValidations(values).then(function(combinedErrors) {
+      if (!!isMounted.current) {
+        dispatch({
+          type: "SET_ISVALIDATING",
+          payload: false
+        });
+        dispatch({
+          type: "SET_ERRORS",
+          payload: combinedErrors
+        });
+      }
+      return combinedErrors;
+    });
+  });
+  useEffect(function() {
+    if (validateOnMount && isMounted.current === true && isEqual(initialValues.current, props.initialValues)) {
+      validateFormWithHighPriority(initialValues.current);
+    }
+  }, [validateOnMount, validateFormWithHighPriority]);
+  var resetForm = useCallback(function(nextState) {
+    var values = nextState && nextState.values ? nextState.values : initialValues.current;
+    var errors = nextState && nextState.errors ? nextState.errors : initialErrors.current ? initialErrors.current : props.initialErrors || {};
+    var touched = nextState && nextState.touched ? nextState.touched : initialTouched.current ? initialTouched.current : props.initialTouched || {};
+    var status = nextState && nextState.status ? nextState.status : initialStatus.current ? initialStatus.current : props.initialStatus;
+    initialValues.current = values;
+    initialErrors.current = errors;
+    initialTouched.current = touched;
+    initialStatus.current = status;
+    var dispatchFn = function dispatchFn2() {
+      dispatch({
+        type: "RESET_FORM",
+        payload: {
+          isSubmitting: !!nextState && !!nextState.isSubmitting,
+          errors,
+          touched,
+          status,
+          values,
+          isValidating: !!nextState && !!nextState.isValidating,
+          submitCount: !!nextState && !!nextState.submitCount && typeof nextState.submitCount === "number" ? nextState.submitCount : 0
+        }
+      });
+    };
+    if (props.onReset) {
+      var maybePromisedOnReset = props.onReset(state.values, imperativeMethods);
+      if (isPromise(maybePromisedOnReset)) {
+        maybePromisedOnReset.then(dispatchFn);
+      } else {
+        dispatchFn();
+      }
+    } else {
+      dispatchFn();
+    }
+  }, [props.initialErrors, props.initialStatus, props.initialTouched, props.onReset]);
+  useEffect(function() {
+    if (isMounted.current === true && !isEqual(initialValues.current, props.initialValues)) {
+      if (enableReinitialize) {
+        initialValues.current = props.initialValues;
+        resetForm();
+        if (validateOnMount) {
+          validateFormWithHighPriority(initialValues.current);
+        }
+      }
+    }
+  }, [enableReinitialize, props.initialValues, resetForm, validateOnMount, validateFormWithHighPriority]);
+  useEffect(function() {
+    if (enableReinitialize && isMounted.current === true && !isEqual(initialErrors.current, props.initialErrors)) {
+      initialErrors.current = props.initialErrors || emptyErrors;
+      dispatch({
+        type: "SET_ERRORS",
+        payload: props.initialErrors || emptyErrors
+      });
+    }
+  }, [enableReinitialize, props.initialErrors]);
+  useEffect(function() {
+    if (enableReinitialize && isMounted.current === true && !isEqual(initialTouched.current, props.initialTouched)) {
+      initialTouched.current = props.initialTouched || emptyTouched;
+      dispatch({
+        type: "SET_TOUCHED",
+        payload: props.initialTouched || emptyTouched
+      });
+    }
+  }, [enableReinitialize, props.initialTouched]);
+  useEffect(function() {
+    if (enableReinitialize && isMounted.current === true && !isEqual(initialStatus.current, props.initialStatus)) {
+      initialStatus.current = props.initialStatus;
+      dispatch({
+        type: "SET_STATUS",
+        payload: props.initialStatus
+      });
+    }
+  }, [enableReinitialize, props.initialStatus, props.initialTouched]);
+  var validateField = useEventCallback(function(name) {
+    if (fieldRegistry.current[name] && isFunction(fieldRegistry.current[name].validate)) {
+      var value = getIn(state.values, name);
+      var maybePromise = fieldRegistry.current[name].validate(value);
+      if (isPromise(maybePromise)) {
+        dispatch({
+          type: "SET_ISVALIDATING",
+          payload: true
+        });
+        return maybePromise.then(function(x) {
+          return x;
+        }).then(function(error) {
+          dispatch({
+            type: "SET_FIELD_ERROR",
+            payload: {
+              field: name,
+              value: error
+            }
+          });
+          dispatch({
+            type: "SET_ISVALIDATING",
+            payload: false
+          });
+        });
+      } else {
+        dispatch({
+          type: "SET_FIELD_ERROR",
+          payload: {
+            field: name,
+            value: maybePromise
+          }
+        });
+        return Promise.resolve(maybePromise);
+      }
+    } else if (props.validationSchema) {
+      dispatch({
+        type: "SET_ISVALIDATING",
+        payload: true
+      });
+      return runValidationSchema(state.values, name).then(function(x) {
+        return x;
+      }).then(function(error) {
+        dispatch({
+          type: "SET_FIELD_ERROR",
+          payload: {
+            field: name,
+            value: getIn(error, name)
+          }
+        });
+        dispatch({
+          type: "SET_ISVALIDATING",
+          payload: false
+        });
+      });
+    }
+    return Promise.resolve();
+  });
+  var registerField = useCallback(function(name, _ref3) {
+    var validate = _ref3.validate;
+    fieldRegistry.current[name] = {
+      validate
+    };
+  }, []);
+  var unregisterField = useCallback(function(name) {
+    delete fieldRegistry.current[name];
+  }, []);
+  var setTouched = useEventCallback(function(touched, shouldValidate) {
+    dispatch({
+      type: "SET_TOUCHED",
+      payload: touched
+    });
+    var willValidate = shouldValidate === void 0 ? validateOnBlur : shouldValidate;
+    return willValidate ? validateFormWithHighPriority(state.values) : Promise.resolve();
+  });
+  var setErrors = useCallback(function(errors) {
+    dispatch({
+      type: "SET_ERRORS",
+      payload: errors
+    });
+  }, []);
+  var setValues = useEventCallback(function(values, shouldValidate) {
+    var resolvedValues = isFunction(values) ? values(state.values) : values;
+    dispatch({
+      type: "SET_VALUES",
+      payload: resolvedValues
+    });
+    var willValidate = shouldValidate === void 0 ? validateOnChange : shouldValidate;
+    return willValidate ? validateFormWithHighPriority(resolvedValues) : Promise.resolve();
+  });
+  var setFieldError = useCallback(function(field, value) {
+    dispatch({
+      type: "SET_FIELD_ERROR",
+      payload: {
+        field,
+        value
+      }
+    });
+  }, []);
+  var setFieldValue = useEventCallback(function(field, value, shouldValidate) {
+    var resolvedValue = isFunction(value) ? value(getIn(state.values, field)) : value;
+    dispatch({
+      type: "SET_FIELD_VALUE",
+      payload: {
+        field,
+        value: resolvedValue
+      }
+    });
+    var willValidate = shouldValidate === void 0 ? validateOnChange : shouldValidate;
+    return willValidate ? validateFormWithHighPriority(setIn(state.values, field, resolvedValue)) : Promise.resolve();
+  });
+  var executeChange = useCallback(function(eventOrTextValue, maybePath) {
+    var field = maybePath;
+    var val = eventOrTextValue;
+    var parsed;
+    if (!isString(eventOrTextValue)) {
+      if (eventOrTextValue.persist) {
+        eventOrTextValue.persist();
+      }
+      var target = eventOrTextValue.target ? eventOrTextValue.target : eventOrTextValue.currentTarget;
+      var type = target.type, name = target.name, id = target.id, value = target.value, checked = target.checked, outerHTML = target.outerHTML, options = target.options, multiple = target.multiple;
+      field = maybePath ? maybePath : name ? name : id;
+      if (!field && process.env.NODE_ENV !== "production") {
+        warnAboutMissingIdentifier({
+          htmlContent: outerHTML,
+          documentationAnchorLink: "handlechange-e-reactchangeeventany--void",
+          handlerName: "handleChange"
+        });
+      }
+      val = /number|range/.test(type) ? (parsed = parseFloat(value), isNaN(parsed) ? "" : parsed) : /checkbox/.test(type) ? getValueForCheckbox(getIn(state.values, field), checked, value) : options && multiple ? getSelectedValues(options) : value;
+    }
+    if (field) {
+      setFieldValue(field, val);
+    }
+  }, [setFieldValue, state.values]);
+  var handleChange = useEventCallback(function(eventOrPath) {
+    if (isString(eventOrPath)) {
+      return function(event) {
+        return executeChange(event, eventOrPath);
+      };
+    } else {
+      executeChange(eventOrPath);
+    }
+  });
+  var setFieldTouched = useEventCallback(function(field, touched, shouldValidate) {
+    if (touched === void 0) {
+      touched = true;
+    }
+    dispatch({
+      type: "SET_FIELD_TOUCHED",
+      payload: {
+        field,
+        value: touched
+      }
+    });
+    var willValidate = shouldValidate === void 0 ? validateOnBlur : shouldValidate;
+    return willValidate ? validateFormWithHighPriority(state.values) : Promise.resolve();
+  });
+  var executeBlur = useCallback(function(e, path) {
+    if (e.persist) {
+      e.persist();
+    }
+    var _e$target = e.target, name = _e$target.name, id = _e$target.id, outerHTML = _e$target.outerHTML;
+    var field = path ? path : name ? name : id;
+    if (!field && process.env.NODE_ENV !== "production") {
+      warnAboutMissingIdentifier({
+        htmlContent: outerHTML,
+        documentationAnchorLink: "handleblur-e-any--void",
+        handlerName: "handleBlur"
+      });
+    }
+    setFieldTouched(field, true);
+  }, [setFieldTouched]);
+  var handleBlur = useEventCallback(function(eventOrString) {
+    if (isString(eventOrString)) {
+      return function(event) {
+        return executeBlur(event, eventOrString);
+      };
+    } else {
+      executeBlur(eventOrString);
+    }
+  });
+  var setFormikState = useCallback(function(stateOrCb) {
+    if (isFunction(stateOrCb)) {
+      dispatch({
+        type: "SET_FORMIK_STATE",
+        payload: stateOrCb
+      });
+    } else {
+      dispatch({
+        type: "SET_FORMIK_STATE",
+        payload: function payload() {
+          return stateOrCb;
+        }
+      });
+    }
+  }, []);
+  var setStatus = useCallback(function(status) {
+    dispatch({
+      type: "SET_STATUS",
+      payload: status
+    });
+  }, []);
+  var setSubmitting = useCallback(function(isSubmitting) {
+    dispatch({
+      type: "SET_ISSUBMITTING",
+      payload: isSubmitting
+    });
+  }, []);
+  var submitForm = useEventCallback(function() {
+    dispatch({
+      type: "SUBMIT_ATTEMPT"
+    });
+    return validateFormWithHighPriority().then(function(combinedErrors) {
+      var isInstanceOfError = combinedErrors instanceof Error;
+      var isActuallyValid = !isInstanceOfError && Object.keys(combinedErrors).length === 0;
+      if (isActuallyValid) {
+        var promiseOrUndefined;
+        try {
+          promiseOrUndefined = executeSubmit();
+          if (promiseOrUndefined === void 0) {
+            return;
+          }
+        } catch (error) {
+          throw error;
+        }
+        return Promise.resolve(promiseOrUndefined).then(function(result) {
+          if (!!isMounted.current) {
+            dispatch({
+              type: "SUBMIT_SUCCESS"
+            });
+          }
+          return result;
+        })["catch"](function(_errors) {
+          if (!!isMounted.current) {
+            dispatch({
+              type: "SUBMIT_FAILURE"
+            });
+            throw _errors;
+          }
+        });
+      } else if (!!isMounted.current) {
+        dispatch({
+          type: "SUBMIT_FAILURE"
+        });
+        if (isInstanceOfError) {
+          throw combinedErrors;
+        }
+      }
+      return;
+    });
+  });
+  var handleSubmit = useEventCallback(function(e) {
+    if (e && e.preventDefault && isFunction(e.preventDefault)) {
+      e.preventDefault();
+    }
+    if (e && e.stopPropagation && isFunction(e.stopPropagation)) {
+      e.stopPropagation();
+    }
+    if (process.env.NODE_ENV !== "production" && typeof document !== "undefined") {
+      var activeElement = getActiveElement();
+      if (activeElement !== null && activeElement instanceof HTMLButtonElement) {
+        !(activeElement.attributes && activeElement.attributes.getNamedItem("type")) ? process.env.NODE_ENV !== "production" ? warning(false, 'You submitted a Formik form using a button with an unspecified `type` attribute.  Most browsers default button elements to `type="submit"`. If this is not a submit button, please add `type="button"`.') : warning() : void 0;
+      }
+    }
+    submitForm()["catch"](function(reason) {
+      console.warn("Warning: An unhandled error was caught from submitForm()", reason);
+    });
+  });
+  var imperativeMethods = {
+    resetForm,
+    validateForm: validateFormWithHighPriority,
+    validateField,
+    setErrors,
+    setFieldError,
+    setFieldTouched,
+    setFieldValue,
+    setStatus,
+    setSubmitting,
+    setTouched,
+    setValues,
+    setFormikState,
+    submitForm
+  };
+  var executeSubmit = useEventCallback(function() {
+    return onSubmit(state.values, imperativeMethods);
+  });
+  var handleReset = useEventCallback(function(e) {
+    if (e && e.preventDefault && isFunction(e.preventDefault)) {
+      e.preventDefault();
+    }
+    if (e && e.stopPropagation && isFunction(e.stopPropagation)) {
+      e.stopPropagation();
+    }
+    resetForm();
+  });
+  var getFieldMeta = useCallback(function(name) {
+    return {
+      value: getIn(state.values, name),
+      error: getIn(state.errors, name),
+      touched: !!getIn(state.touched, name),
+      initialValue: getIn(initialValues.current, name),
+      initialTouched: !!getIn(initialTouched.current, name),
+      initialError: getIn(initialErrors.current, name)
+    };
+  }, [state.errors, state.touched, state.values]);
+  var getFieldHelpers = useCallback(function(name) {
+    return {
+      setValue: function setValue(value, shouldValidate) {
+        return setFieldValue(name, value, shouldValidate);
+      },
+      setTouched: function setTouched2(value, shouldValidate) {
+        return setFieldTouched(name, value, shouldValidate);
+      },
+      setError: function setError(value) {
+        return setFieldError(name, value);
+      }
+    };
+  }, [setFieldValue, setFieldTouched, setFieldError]);
+  var getFieldProps = useCallback(function(nameOrOptions) {
+    var isAnObject = isObject(nameOrOptions);
+    var name = isAnObject ? nameOrOptions.name : nameOrOptions;
+    var valueState = getIn(state.values, name);
+    var field = {
+      name,
+      value: valueState,
+      onChange: handleChange,
+      onBlur: handleBlur
+    };
+    if (isAnObject) {
+      var type = nameOrOptions.type, valueProp = nameOrOptions.value, is = nameOrOptions.as, multiple = nameOrOptions.multiple;
+      if (type === "checkbox") {
+        if (valueProp === void 0) {
+          field.checked = !!valueState;
+        } else {
+          field.checked = !!(Array.isArray(valueState) && ~valueState.indexOf(valueProp));
+          field.value = valueProp;
+        }
+      } else if (type === "radio") {
+        field.checked = valueState === valueProp;
+        field.value = valueProp;
+      } else if (is === "select" && multiple) {
+        field.value = field.value || [];
+        field.multiple = true;
+      }
+    }
+    return field;
+  }, [handleBlur, handleChange, state.values]);
+  var dirty = useMemo(function() {
+    return !isEqual(initialValues.current, state.values);
+  }, [initialValues.current, state.values]);
+  var isValid = useMemo(function() {
+    return typeof isInitialValid !== "undefined" ? dirty ? state.errors && Object.keys(state.errors).length === 0 : isInitialValid !== false && isFunction(isInitialValid) ? isInitialValid(props) : isInitialValid : state.errors && Object.keys(state.errors).length === 0;
+  }, [isInitialValid, dirty, state.errors, props]);
+  var ctx = _extends({}, state, {
+    initialValues: initialValues.current,
+    initialErrors: initialErrors.current,
+    initialTouched: initialTouched.current,
+    initialStatus: initialStatus.current,
+    handleBlur,
+    handleChange,
+    handleReset,
+    handleSubmit,
+    resetForm,
+    setErrors,
+    setFormikState,
+    setFieldTouched,
+    setFieldValue,
+    setFieldError,
+    setStatus,
+    setSubmitting,
+    setTouched,
+    setValues,
+    submitForm,
+    validateForm: validateFormWithHighPriority,
+    validateField,
+    isValid,
+    dirty,
+    unregisterField,
+    registerField,
+    getFieldProps,
+    getFieldMeta,
+    getFieldHelpers,
+    validateOnBlur,
+    validateOnChange,
+    validateOnMount
+  });
+  return ctx;
+}
+function Formik(props) {
+  var formikbag = useFormik(props);
+  var component = props.component, children = props.children, render = props.render, innerRef = props.innerRef;
+  useImperativeHandle(innerRef, function() {
+    return formikbag;
+  });
+  if (process.env.NODE_ENV !== "production") {
+    useEffect(function() {
+      !!props.render ? process.env.NODE_ENV !== "production" ? warning(false, "<Formik render> has been deprecated and will be removed in future versions of Formik. Please use a child callback function instead. To get rid of this warning, replace <Formik render={(props) => ...} /> with <Formik>{(props) => ...}</Formik>") : warning() : void 0;
+    }, []);
+  }
+  return createElement(FormikProvider, {
+    value: formikbag
+  }, component ? createElement(component, formikbag) : render ? render(formikbag) : children ? isFunction(children) ? children(formikbag) : !isEmptyChildren(children) ? Children.only(children) : null : null);
+}
+function warnAboutMissingIdentifier(_ref4) {
+  var htmlContent = _ref4.htmlContent, documentationAnchorLink = _ref4.documentationAnchorLink, handlerName = _ref4.handlerName;
+  console.warn("Warning: Formik called `" + handlerName + "`, but you forgot to pass an `id` or `name` attribute to your input:\n    " + htmlContent + "\n    Formik cannot determine which value to update. For more info see https://formik.org/docs/api/formik#" + documentationAnchorLink + "\n  ");
+}
+function yupToFormErrors(yupError) {
+  var errors = {};
+  if (yupError.inner) {
+    if (yupError.inner.length === 0) {
+      return setIn(errors, yupError.path, yupError.message);
+    }
+    for (var _iterator = yupError.inner, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator](); ; ) {
+      var _ref5;
+      if (_isArray) {
+        if (_i >= _iterator.length) break;
+        _ref5 = _iterator[_i++];
+      } else {
+        _i = _iterator.next();
+        if (_i.done) break;
+        _ref5 = _i.value;
+      }
+      var err = _ref5;
+      if (!getIn(errors, err.path)) {
+        errors = setIn(errors, err.path, err.message);
+      }
+    }
+  }
+  return errors;
+}
+function validateYupSchema(values, schema, sync, context) {
+  if (sync === void 0) {
+    sync = false;
+  }
+  var normalizedValues = prepareDataForValidation(values);
+  return schema[sync ? "validateSync" : "validate"](normalizedValues, {
+    abortEarly: false,
+    context: normalizedValues
+  });
+}
+function prepareDataForValidation(values) {
+  var data = Array.isArray(values) ? [] : {};
+  for (var k in values) {
+    if (Object.prototype.hasOwnProperty.call(values, k)) {
+      var key = String(k);
+      if (Array.isArray(values[key]) === true) {
+        data[key] = values[key].map(function(value) {
+          if (Array.isArray(value) === true || isPlainObject(value)) {
+            return prepareDataForValidation(value);
+          } else {
+            return value !== "" ? value : void 0;
+          }
+        });
+      } else if (isPlainObject(values[key])) {
+        data[key] = prepareDataForValidation(values[key]);
+      } else {
+        data[key] = values[key] !== "" ? values[key] : void 0;
+      }
+    }
+  }
+  return data;
+}
+function arrayMerge(target, source, options) {
+  var destination = target.slice();
+  source.forEach(function merge(e, i) {
+    if (typeof destination[i] === "undefined") {
+      var cloneRequested = options.clone !== false;
+      var shouldClone = cloneRequested && options.isMergeableObject(e);
+      destination[i] = shouldClone ? deepmerge_1(Array.isArray(e) ? [] : {}, e, options) : e;
+    } else if (options.isMergeableObject(e)) {
+      destination[i] = deepmerge_1(target[i], e, options);
+    } else if (target.indexOf(e) === -1) {
+      destination.push(e);
+    }
+  });
+  return destination;
+}
+function getSelectedValues(options) {
+  return Array.from(options).filter(function(el) {
+    return el.selected;
+  }).map(function(el) {
+    return el.value;
+  });
+}
+function getValueForCheckbox(currentValue, checked, valueProp) {
+  if (typeof currentValue === "boolean") {
+    return Boolean(checked);
+  }
+  var currentArrayOfValues = [];
+  var isValueInArray = false;
+  var index = -1;
+  if (!Array.isArray(currentValue)) {
+    if (!valueProp || valueProp == "true" || valueProp == "false") {
+      return Boolean(checked);
+    }
+  } else {
+    currentArrayOfValues = currentValue;
+    index = currentValue.indexOf(valueProp);
+    isValueInArray = index >= 0;
+  }
+  if (checked && valueProp && !isValueInArray) {
+    return currentArrayOfValues.concat(valueProp);
+  }
+  if (!isValueInArray) {
+    return currentArrayOfValues;
+  }
+  return currentArrayOfValues.slice(0, index).concat(currentArrayOfValues.slice(index + 1));
+}
+var useIsomorphicLayoutEffect = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined" ? useLayoutEffect : useEffect;
+function useEventCallback(fn) {
+  var ref = useRef(fn);
+  useIsomorphicLayoutEffect(function() {
+    ref.current = fn;
+  });
+  return useCallback(function() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return ref.current.apply(void 0, args);
+  }, []);
+}
+var Form = /* @__PURE__ */ forwardRef(function(props, ref) {
+  var action = props.action, rest = _objectWithoutPropertiesLoose(props, ["action"]);
+  var _action = action != null ? action : "#";
+  var _useFormikContext = useFormikContext(), handleReset = _useFormikContext.handleReset, handleSubmit = _useFormikContext.handleSubmit;
+  return createElement("form", _extends({
+    onSubmit: handleSubmit,
+    ref,
+    onReset: handleReset,
+    action: _action
+  }, rest));
+});
+Form.displayName = "Form";
+export {
+  Form,
+  Formik,
+  FormikContext,
+  FormikProvider,
+  getActiveElement,
+  getIn,
+  isEmptyChildren,
+  isFunction,
+  isInteger,
+  isObject,
+  isPromise,
+  isString,
+  prepareDataForValidation,
+  setIn,
+  setNestedObjectValues,
+  useFormik,
+  useFormikContext,
+  validateYupSchema,
+  yupToFormErrors
+};