node_modules ignore

server/node_modules/formik/README.md

@@ -0,0 +1,61 @@
+<p align="center">
+  <img src="https://user-images.githubusercontent.com/4060187/61057426-4e5a4600-a3c3-11e9-9114-630743e05814.png" width="211" height="182" alt="Formik.js" />
+</p>
+
+<h3 align="center">
+  Build forms in React, without the tears.
+</h3>
+
+<br>
+
+[![Stable Release](https://img.shields.io/npm/v/formik.svg)](https://npm.im/formik)
+[![Blazing Fast](https://badgen.now.sh/badge/speed/blazing%20%F0%9F%94%A5/green)](https://npm.im/formik)
+[![gzip size](http://img.badgesize.io/https://unpkg.com/formik@latest/dist/formik.esm.js?compression=gzip)](https://unpkg.com/formik@latest/dist/formik.esm.js)
+[![license](https://badgen.now.sh/badge/license/Apache-2.0)](./LICENSE)
+[![Discord](https://img.shields.io/discord/769256827007139912.svg?style=flat-square)](https://discord.gg/pJSg287)
+
+**Visit [https://formik.org](https://formik.org) to get started with Formik.**
+
+## Organizations and projects using Formik
+
+[List of organizations and projects using Formik](https://github.com/jaredpalmer/formik/issues/87)
+
+## Authors
+
+- Jared Palmer [@jaredpalmer](https://twitter.com/jaredpalmer)
+- Ian White [@eonwhite](https://twitter.com/eonwhite)
+
+## Contributing
+
+This monorepo uses `yarn`, so to start you'll need the package manager installed.
+
+To run E2E tests you'll also need Playwright set up, which can be done locally via `npx playwright install`. Afterward, run `yarn start:app` and in a separate tab run `yarn e2e:ui` to boot up the test runner.
+
+When you're done with your changes, we use [changesets](https://github.com/changesets/changesets) to manage release notes. Run `yarn changeset` to autogenerate notes to be appended to your pull request.
+
+Thank you!
+
+## Contributors
+
+Formik is made with <3 thanks to these wonderful people
+([emoji key](https://github.com/kentcdodds/all-contributors#emoji-key)):
+
+<!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
+<!-- prettier-ignore -->
+| [<img src="https://avatars2.githubusercontent.com/u/4060187?v=4" width="100px;"/><br /><sub><b>Jared Palmer</b></sub>](http://jaredpalmer.com)<br />[💬](#question-jaredpalmer "Answering Questions") [💻](https://github.com/jaredpalmer/formik/commits?author=jaredpalmer "Code") [🎨](#design-jaredpalmer "Design") [📖](https://github.com/jaredpalmer/formik/commits?author=jaredpalmer "Documentation") [💡](#example-jaredpalmer "Examples") [🤔](#ideas-jaredpalmer "Ideas, Planning, & Feedback") [👀](#review-jaredpalmer "Reviewed Pull Requests") [⚠️](https://github.com/jaredpalmer/formik/commits?author=jaredpalmer "Tests") | [<img src="https://avatars0.githubusercontent.com/u/109324?v=4" width="100px;"/><br /><sub><b>Ian White</b></sub>](https://www.stardog.io)<br />[💬](#question-eonwhite "Answering Questions") [🐛](https://github.com/jaredpalmer/formik/issues?q=author%3Aeonwhite "Bug reports") [💻](https://github.com/jaredpalmer/formik/commits?author=eonwhite "Code") [📖](https://github.com/jaredpalmer/formik/commits?author=eonwhite "Documentation") [🤔](#ideas-eonwhite "Ideas, Planning, & Feedback") [👀](#review-eonwhite "Reviewed Pull Requests") | [<img src="https://avatars0.githubusercontent.com/u/829963?v=4" width="100px;"/><br /><sub><b>Andrej Badin</b></sub>](http://andrejbadin.com)<br />[💬](#question-Andreyco "Answering Questions") [🐛](https://github.com/jaredpalmer/formik/issues?q=author%3AAndreyco "Bug reports") [📖](https://github.com/jaredpalmer/formik/commits?author=Andreyco "Documentation") | [<img src="https://avatars2.githubusercontent.com/u/91115?v=4" width="100px;"/><br /><sub><b>Adam Howard</b></sub>](http://adz.co.de)<br />[💬](#question-skattyadz "Answering Questions") [🐛](https://github.com/jaredpalmer/formik/issues?q=author%3Askattyadz "Bug reports") [🤔](#ideas-skattyadz "Ideas, Planning, & Feedback") [👀](#review-skattyadz "Reviewed Pull Requests") | [<img src="https://avatars1.githubusercontent.com/u/6711845?v=4" width="100px;"/><br /><sub><b>Vlad Shcherbin</b></sub>](https://github.com/VladShcherbin)<br />[💬](#question-VladShcherbin "Answering Questions") [🐛](https://github.com/jaredpalmer/formik/issues?q=author%3AVladShcherbin "Bug reports") [🤔](#ideas-VladShcherbin "Ideas, Planning, & Feedback") | [<img src="https://avatars3.githubusercontent.com/u/383212?v=4" width="100px;"/><br /><sub><b>Brikou CARRE</b></sub>](https://github.com/brikou)<br />[🐛](https://github.com/jaredpalmer/formik/issues?q=author%3Abrikou "Bug reports") [📖](https://github.com/jaredpalmer/formik/commits?author=brikou "Documentation") | [<img src="https://avatars0.githubusercontent.com/u/5314713?v=4" width="100px;"/><br /><sub><b>Sam Kvale</b></sub>](http://skvale.github.io)<br />[🐛](https://github.com/jaredpalmer/formik/issues?q=author%3Askvale "Bug reports") [💻](https://github.com/jaredpalmer/formik/commits?author=skvale "Code") [⚠️](https://github.com/jaredpalmer/formik/commits?author=skvale "Tests") |
+| :---: | :---: | :---: | :---: | :---: | :---: | :---: |
+| [<img src="https://avatars0.githubusercontent.com/u/13765558?v=4" width="100px;"/><br /><sub><b>Jon Tansey</b></sub>](http://jon.tansey.info)<br />[🐛](https://github.com/jaredpalmer/formik/issues?q=author%3Ajontansey "Bug reports") [💻](https://github.com/jaredpalmer/formik/commits?author=jontansey "Code") | [<img src="https://avatars0.githubusercontent.com/u/6819171?v=4" width="100px;"/><br /><sub><b>Tyler Martinez</b></sub>](http://slightlytyler.com)<br />[🐛](https://github.com/jaredpalmer/formik/issues?q=author%3Aslightlytyler "Bug reports") [📖](https://github.com/jaredpalmer/formik/commits?author=slightlytyler "Documentation") | [<img src="https://avatars0.githubusercontent.com/u/1285032?v=4" width="100px;"/><br /><sub><b>Tobias Lohse</b></sub>](http://MrLoh.se)<br />[🐛](https://github.com/jaredpalmer/formik/issues?q=author%3AMrLoh "Bug reports") [💻](https://github.com/jaredpalmer/formik/commits?author=MrLoh "Code") |
+
+<!-- ALL-CONTRIBUTORS-LIST:END -->
+
+This project follows the
+[all-contributors](https://github.com/kentcdodds/all-contributors)
+specification. Contributions of any kind welcome!
+
+## Related
+
+- [TSDX](https://github.com/jaredpalmer/tsdx) - Zero-config CLI for TypeScript used by this repo. (Formik's Rollup configuration as a CLI)
+
+---
+
+[Apache 2.0 License.](https://github.com/jaredpalmer/formik/blob/master/LICENSE)

server/node_modules/formik/dist/ErrorMessage.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="hoist-non-react-statics" />
+import * as React from 'react';
+import { FormikContextType } from './types';
+export interface ErrorMessageProps {
+    id?: string;
+    name: string;
+    className?: string;
+    component?: string | React.ComponentType;
+    children?: (errorMessage: string) => React.ReactNode;
+    render?: (errorMessage: string) => React.ReactNode;
+}
+export declare const ErrorMessage: React.FC<ErrorMessageProps> & import("hoist-non-react-statics").NonReactStatics<React.ComponentClass<ErrorMessageProps & {
+    formik: FormikContextType<ErrorMessageProps & {
+        formik: FormikContextType<any>;
+    }>;
+}, any>, {}>;

server/node_modules/formik/dist/FastField.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="hoist-non-react-statics" />
+import * as React from 'react';
+import { FormikProps, GenericFieldHTMLAttributes, FieldMetaProps, FieldInputProps } from './types';
+import { FieldConfig } from './Field';
+export interface FastFieldProps<V = any> {
+    field: FieldInputProps<V>;
+    meta: FieldMetaProps<V>;
+    form: FormikProps<V>;
+}
+export type FastFieldConfig<T> = FieldConfig & {
+    /** Override FastField's default shouldComponentUpdate */
+    shouldUpdate?: (nextProps: T & GenericFieldHTMLAttributes, props: {}) => boolean;
+};
+export type FastFieldAttributes<T> = GenericFieldHTMLAttributes & FastFieldConfig<T> & T;
+export declare const FastField: React.FC<any> & import("hoist-non-react-statics").NonReactStatics<React.ComponentClass<any, any>, {}>;

server/node_modules/formik/dist/Field.d.ts

@@ -0,0 +1,53 @@
+import * as React from 'react';
+import { FormikProps, GenericFieldHTMLAttributes, FieldMetaProps, FieldHelperProps, FieldInputProps, FieldValidator } from './types';
+export interface FieldProps<V = any, FormValues = any> {
+    field: FieldInputProps<V>;
+    form: FormikProps<FormValues>;
+    meta: FieldMetaProps<V>;
+}
+export interface FieldConfig<V = any> {
+    /**
+     * Field component to render. Can either be a string like 'select' or a component.
+     */
+    component?: string | React.ComponentType<FieldProps<V>> | React.ComponentType | React.ForwardRefExoticComponent<any>;
+    /**
+     * Component to render. Can either be a string e.g. 'select', 'input', or 'textarea', or a component.
+     */
+    as?: React.ComponentType<FieldProps<V>['field']> | string | React.ComponentType | React.ForwardRefExoticComponent<any>;
+    /**
+     * Render prop (works like React router's <Route render={props =>} />)
+     * @deprecated
+     */
+    render?: (props: FieldProps<V>) => React.ReactNode;
+    /**
+     * Children render function <Field name>{props => ...}</Field>)
+     */
+    children?: ((props: FieldProps<V>) => React.ReactNode) | React.ReactNode;
+    /**
+     * Validate a single field value independently
+     */
+    validate?: FieldValidator;
+    /**
+     * Used for 'select' and related input types.
+     */
+    multiple?: boolean;
+    /**
+     * Field name
+     */
+    name: string;
+    /** HTML input type */
+    type?: string;
+    /** Field value */
+    value?: any;
+    /** Inner ref */
+    innerRef?: (instance: any) => void;
+}
+export type FieldAttributes<T> = {
+    className?: string;
+} & GenericFieldHTMLAttributes & FieldConfig<T> & T & {
+    name: string;
+};
+export type FieldHookConfig<T> = GenericFieldHTMLAttributes & FieldConfig<T>;
+export declare function useField<Val = any>(propsOrFieldName: string | FieldHookConfig<Val>): [FieldInputProps<Val>, FieldMetaProps<Val>, FieldHelperProps<Val>];
+export declare function Field({ validate, name, render, children, as: is, // `as` is reserved in typescript lol
+component, className, ...props }: FieldAttributes<any>): any;

server/node_modules/formik/dist/FieldArray.d.ts

@@ -0,0 +1,62 @@
+/// <reference types="hoist-non-react-statics" />
+import * as React from 'react';
+import { FormikContextType, FormikProps, SharedRenderProps } from './types';
+export type FieldArrayRenderProps = ArrayHelpers & {
+    form: FormikProps<any>;
+    name: string;
+};
+export type FieldArrayConfig = {
+    /** Really the path to the array field to be updated */
+    name: string;
+    /** Should field array validate the form AFTER array updates/changes? */
+    validateOnChange?: boolean;
+} & SharedRenderProps<FieldArrayRenderProps>;
+export interface ArrayHelpers<T extends any[] = any[]> {
+    /** Imperatively add a value to the end of an array */
+    push<X = T[number]>(obj: X): void;
+    /** Curried fn to add a value to the end of an array */
+    handlePush<X = T[number]>(obj: X): () => void;
+    /** Imperatively swap two values in an array */
+    swap: (indexA: number, indexB: number) => void;
+    /** Curried fn to swap two values in an array */
+    handleSwap: (indexA: number, indexB: number) => () => void;
+    /** Imperatively move an element in an array to another index */
+    move: (from: number, to: number) => void;
+    /** Imperatively move an element in an array to another index */
+    handleMove: (from: number, to: number) => () => void;
+    /** Imperatively insert an element at a given index into the array */
+    insert<X = T[number]>(index: number, value: X): void;
+    /** Curried fn to insert an element at a given index into the array */
+    handleInsert<X = T[number]>(index: number, value: X): () => void;
+    /** Imperatively replace a value at an index of an array  */
+    replace<X = T[number]>(index: number, value: X): void;
+    /** Curried fn to replace an element at a given index into the array */
+    handleReplace<X = T[number]>(index: number, value: X): () => void;
+    /** Imperatively add an element to the beginning of an array and return its length */
+    unshift<X = T[number]>(value: X): number;
+    /** Curried fn to add an element to the beginning of an array */
+    handleUnshift<X = T[number]>(value: X): () => void;
+    /** Curried fn to remove an element at an index of an array */
+    handleRemove: (index: number) => () => void;
+    /** Curried fn to remove a value from the end of the array */
+    handlePop: () => () => void;
+    /** Imperatively remove and element at an index of an array */
+    remove<X = T[number]>(index: number): X | undefined;
+    /** Imperatively remove and return value from the end of the array */
+    pop<X = T[number]>(): X | undefined;
+}
+/**
+ * Some array helpers!
+ */
+export declare const move: <T>(array: T[], from: number, to: number) => unknown[];
+export declare const swap: <T>(arrayLike: ArrayLike<T>, indexA: number, indexB: number) => unknown[];
+export declare const insert: <T>(arrayLike: ArrayLike<T>, index: number, value: T) => unknown[];
+export declare const replace: <T>(arrayLike: ArrayLike<T>, index: number, value: T) => unknown[];
+export declare const FieldArray: React.FC<FieldArrayConfig> & import("hoist-non-react-statics").NonReactStatics<React.ComponentClass<{
+    /** Really the path to the array field to be updated */
+    name: string;
+    /** Should field array validate the form AFTER array updates/changes? */
+    validateOnChange?: boolean | undefined;
+} & SharedRenderProps<FieldArrayRenderProps> & {
+    formik: FormikContextType<any>;
+}, any>, {}>;

server/node_modules/formik/dist/Form.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+export type FormikFormProps = Pick<React.FormHTMLAttributes<HTMLFormElement>, Exclude<keyof React.FormHTMLAttributes<HTMLFormElement>, 'onReset' | 'onSubmit'>>;
+export declare const Form: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.FormHTMLAttributes<HTMLFormElement>, HTMLFormElement>, "ref"> & React.RefAttributes<HTMLFormElement>>;

server/node_modules/formik/dist/Formik.d.ts

@@ -0,0 +1,62 @@
+import * as React from 'react';
+import { FieldConfig } from './Field';
+import { FieldHelperProps, FieldInputProps, FieldMetaProps, FormikConfig, FormikErrors, FormikState, FormikTouched, FormikValues } from './types';
+export declare function useFormik<Values extends FormikValues = FormikValues>({ validateOnChange, validateOnBlur, validateOnMount, isInitialValid, enableReinitialize, onSubmit, ...rest }: FormikConfig<Values>): {
+    initialValues: Values;
+    initialErrors: FormikErrors<unknown>;
+    initialTouched: FormikTouched<unknown>;
+    initialStatus: any;
+    handleBlur: {
+        (e: React.FocusEvent<any, Element>): void;
+        <T = any>(fieldOrEvent: T): T extends string ? (e: any) => void : void;
+    };
+    handleChange: {
+        (e: React.ChangeEvent<any>): void;
+        <T_1 = string | React.ChangeEvent<any>>(field: T_1): T_1 extends React.ChangeEvent<any> ? void : (e: string | React.ChangeEvent<any>) => void;
+    };
+    handleReset: (e: any) => void;
+    handleSubmit: (e?: React.FormEvent<HTMLFormElement>) => void;
+    resetForm: (nextState?: Partial<FormikState<Values>>) => void;
+    setErrors: (errors: FormikErrors<Values>) => void;
+    setFormikState: (stateOrCb: FormikState<Values> | ((state: FormikState<Values>) => FormikState<Values>)) => void;
+    setFieldTouched: (field: string, touched?: boolean, shouldValidate?: boolean) => Promise<FormikErrors<Values>> | Promise<void>;
+    setFieldValue: (field: string, value: any, shouldValidate?: boolean) => Promise<FormikErrors<Values>> | Promise<void>;
+    setFieldError: (field: string, value: string | undefined) => void;
+    setStatus: (status: any) => void;
+    setSubmitting: (isSubmitting: boolean) => void;
+    setTouched: (touched: FormikTouched<Values>, shouldValidate?: boolean) => Promise<FormikErrors<Values>> | Promise<void>;
+    setValues: (values: React.SetStateAction<Values>, shouldValidate?: boolean) => Promise<FormikErrors<Values>> | Promise<void>;
+    submitForm: () => Promise<any>;
+    validateForm: (values?: Values) => Promise<FormikErrors<Values>>;
+    validateField: (name: string) => Promise<void> | Promise<string | undefined>;
+    isValid: boolean;
+    dirty: boolean;
+    unregisterField: (name: string) => void;
+    registerField: (name: string, { validate }: any) => void;
+    getFieldProps: (nameOrOptions: string | FieldConfig<any>) => FieldInputProps<any>;
+    getFieldMeta: (name: string) => FieldMetaProps<any>;
+    getFieldHelpers: (name: string) => FieldHelperProps<any>;
+    validateOnBlur: boolean;
+    validateOnChange: boolean;
+    validateOnMount: boolean;
+    values: Values;
+    errors: FormikErrors<Values>;
+    touched: FormikTouched<Values>;
+    isSubmitting: boolean;
+    isValidating: boolean;
+    status?: any;
+    submitCount: number;
+};
+export declare function Formik<Values extends FormikValues = FormikValues, ExtraProps = {}>(props: FormikConfig<Values> & ExtraProps): React.JSX.Element;
+/**
+ * Transform Yup ValidationError to a more usable object
+ */
+export declare function yupToFormErrors<Values>(yupError: any): FormikErrors<Values>;
+/**
+ * Validate a yup schema.
+ */
+export declare function validateYupSchema<T extends FormikValues>(values: T, schema: any, sync?: boolean, context?: any): Promise<Partial<T>>;
+/**
+ * Recursively prepare values.
+ */
+export declare function prepareDataForValidation<T extends FormikValues>(values: T): FormikValues;

server/node_modules/formik/dist/FormikContext.d.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+import { FormikContextType } from './types';
+export declare const FormikContext: React.Context<FormikContextType<any>>;
+export declare const FormikProvider: React.Provider<FormikContextType<any>>;
+export declare const FormikConsumer: React.Consumer<FormikContextType<any>>;
+export declare function useFormikContext<Values>(): FormikContextType<Values>;

server/node_modules/formik/dist/connect.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import hoistNonReactStatics from 'hoist-non-react-statics';
+import { FormikContextType } from './types';
+/**
+ * Connect any component to Formik context, and inject as a prop called `formik`;
+ * @param Comp React Component
+ */
+export declare function connect<OuterProps, Values = {}>(Comp: React.ComponentType<OuterProps & {
+    formik: FormikContextType<Values>;
+}>): React.FC<OuterProps> & hoistNonReactStatics.NonReactStatics<React.ComponentClass<OuterProps & {
+    formik: FormikContextType<Values>;
+}, any>, {}>;

server/node_modules/formik/dist/index.d.ts

@@ -0,0 +1,11 @@
+export * from './Formik';
+export * from './Field';
+export * from './Form';
+export * from './withFormik';
+export * from './FieldArray';
+export * from './utils';
+export * from './types';
+export * from './connect';
+export * from './ErrorMessage';
+export * from './FormikContext';
+export * from './FastField';

server/node_modules/formik/dist/index.js

@@ -0,0 +1,8 @@
+
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./formik.cjs.production.min.js')
+} else {
+  module.exports = require('./formik.cjs.development.js')
+}

server/node_modules/formik/dist/types.d.ts

@@ -0,0 +1,249 @@
+import * as React from 'react';
+import { FieldConfig } from './Field';
+/**
+ * Values of fields in the form
+ */
+export interface FormikValues {
+    [field: string]: any;
+}
+/**
+ * An object containing error messages whose keys correspond to FormikValues.
+ * Should always be an object of strings, but any is allowed to support i18n libraries.
+ */
+export type FormikErrors<Values> = {
+    [K in keyof Values]?: Values[K] extends any[] ? Values[K][number] extends object ? FormikErrors<Values[K][number]>[] | string | string[] : string | string[] : Values[K] extends object ? FormikErrors<Values[K]> : string;
+};
+/**
+ * An object containing touched state of the form whose keys correspond to FormikValues.
+ */
+export type FormikTouched<Values> = {
+    [K in keyof Values]?: Values[K] extends any[] ? Values[K][number] extends object ? FormikTouched<Values[K][number]>[] : boolean : Values[K] extends object ? FormikTouched<Values[K]> : boolean;
+};
+/**
+ * Formik state tree
+ */
+export interface FormikState<Values> {
+    /** Form values */
+    values: Values;
+    /** map of field names to specific error for that field */
+    errors: FormikErrors<Values>;
+    /** map of field names to whether the field has been touched */
+    touched: FormikTouched<Values>;
+    /** whether the form is currently submitting */
+    isSubmitting: boolean;
+    /** whether the form is currently validating (prior to submission) */
+    isValidating: boolean;
+    /** Top level status state, in case you need it */
+    status?: any;
+    /** Number of times user tried to submit the form */
+    submitCount: number;
+}
+/**
+ * Formik computed properties. These are read-only.
+ */
+export interface FormikComputedProps<Values> {
+    /** True if any input has been touched. False otherwise. */
+    readonly dirty: boolean;
+    /** True if state.errors is empty */
+    readonly isValid: boolean;
+    /** The initial values of the form */
+    readonly initialValues: Values;
+    /** The initial errors of the form */
+    readonly initialErrors: FormikErrors<Values>;
+    /** The initial visited fields of the form */
+    readonly initialTouched: FormikTouched<Values>;
+    /** The initial status of the form */
+    readonly initialStatus?: any;
+}
+/**
+ * Formik state helpers
+ */
+export interface FormikHelpers<Values> {
+    /** Manually set top level status. */
+    setStatus: (status?: any) => void;
+    /** Manually set errors object */
+    setErrors: (errors: FormikErrors<Values>) => void;
+    /** Manually set isSubmitting */
+    setSubmitting: (isSubmitting: boolean) => void;
+    /** Manually set touched object */
+    setTouched: (touched: FormikTouched<Values>, shouldValidate?: boolean) => Promise<void | FormikErrors<Values>>;
+    /** Manually set values object  */
+    setValues: (values: React.SetStateAction<Values>, shouldValidate?: boolean) => Promise<void | FormikErrors<Values>>;
+    /** Set value of form field directly */
+    setFieldValue: (field: string, value: any, shouldValidate?: boolean) => Promise<void | FormikErrors<Values>>;
+    /** Set error message of a form field directly */
+    setFieldError: (field: string, message: string | undefined) => void;
+    /** Set whether field has been touched directly */
+    setFieldTouched: (field: string, isTouched?: boolean, shouldValidate?: boolean) => Promise<void | FormikErrors<Values>>;
+    /** Validate form values */
+    validateForm: (values?: any) => Promise<FormikErrors<Values>>;
+    /** Validate field value */
+    validateField: (field: string) => Promise<void> | Promise<string | undefined>;
+    /** Reset form */
+    resetForm: (nextState?: Partial<FormikState<Values>>) => void;
+    /** Submit the form imperatively */
+    submitForm: () => Promise<void>;
+    /** Set Formik state, careful! */
+    setFormikState: (f: FormikState<Values> | ((prevState: FormikState<Values>) => FormikState<Values>), cb?: () => void) => void;
+}
+/**
+ * Formik form event handlers
+ */
+export interface FormikHandlers {
+    /** Form submit handler */
+    handleSubmit: (e?: React.FormEvent<HTMLFormElement>) => void;
+    /** Reset form event handler  */
+    handleReset: (e?: React.SyntheticEvent<any>) => void;
+    handleBlur: {
+        /** Classic React blur handler, keyed by input name */
+        (e: React.FocusEvent<any>): void;
+        /** Preact-like linkState. Will return a handleBlur function. */
+        <T = string | any>(fieldOrEvent: T): T extends string ? (e: any) => void : void;
+    };
+    handleChange: {
+        /** Classic React change handler, keyed by input name */
+        (e: React.ChangeEvent<any>): void;
+        /** Preact-like linkState. Will return a handleChange function.  */
+        <T = string | React.ChangeEvent<any>>(field: T): T extends React.ChangeEvent<any> ? void : (e: string | React.ChangeEvent<any>) => void;
+    };
+    getFieldProps: <Value = any>(props: string | FieldConfig<Value>) => FieldInputProps<Value>;
+    getFieldMeta: <Value>(name: string) => FieldMetaProps<Value>;
+    getFieldHelpers: <Value = any>(name: string) => FieldHelperProps<Value>;
+}
+/**
+ * Base formik configuration/props shared between the HoC and Component.
+ */
+export interface FormikSharedConfig<Props = {}> {
+    /** Tells Formik to validate the form on each input's onChange event */
+    validateOnChange?: boolean;
+    /** Tells Formik to validate the form on each input's onBlur event */
+    validateOnBlur?: boolean;
+    /** Tells Formik to validate upon mount */
+    validateOnMount?: boolean;
+    /** Tell Formik if initial form values are valid or not on first render */
+    isInitialValid?: boolean | ((props: Props) => boolean);
+    /** Should Formik reset the form when new initialValues change */
+    enableReinitialize?: boolean;
+}
+/**
+ * <Formik /> props
+ */
+export interface FormikConfig<Values> extends FormikSharedConfig {
+    /**
+     * Form component to render
+     */
+    component?: React.ComponentType<FormikProps<Values>>;
+    /**
+     * Render prop (works like React router's <Route render={props =>} />)
+     * @deprecated
+     */
+    render?: (props: FormikProps<Values>) => React.ReactNode;
+    /**
+     * React children or child render callback
+     */
+    children?: ((props: FormikProps<Values>) => React.ReactNode) | React.ReactNode;
+    /**
+     * Initial values of the form
+     */
+    initialValues: Values;
+    /**
+     * Initial status
+     */
+    initialStatus?: any;
+    /** Initial object map of field names to specific error for that field */
+    initialErrors?: FormikErrors<Values>;
+    /** Initial object map of field names to whether the field has been touched */
+    initialTouched?: FormikTouched<Values>;
+    /**
+     * Reset handler
+     */
+    onReset?: (values: Values, formikHelpers: FormikHelpers<Values>) => void;
+    /**
+     * Submission handler
+     */
+    onSubmit: (values: Values, formikHelpers: FormikHelpers<Values>) => void | Promise<any>;
+    /**
+     * A Yup Schema or a function that returns a Yup schema
+     */
+    validationSchema?: any | (() => any);
+    /**
+     * Validation function. Must return an error object or promise that
+     * throws an error object where that object keys map to corresponding value.
+     */
+    validate?: (values: Values) => void | object | Promise<FormikErrors<Values>>;
+    /** Inner ref */
+    innerRef?: React.Ref<FormikProps<Values>>;
+}
+/**
+ * State, handlers, and helpers made available to form component or render prop
+ * of <Formik/>.
+ */
+export type FormikProps<Values> = FormikSharedConfig & FormikState<Values> & FormikHelpers<Values> & FormikHandlers & FormikComputedProps<Values> & FormikRegistration & {
+    submitForm: () => Promise<any>;
+};
+/** Internal Formik registration methods that get passed down as props */
+export interface FormikRegistration {
+    registerField: (name: string, fns: {
+        validate?: FieldValidator;
+    }) => void;
+    unregisterField: (name: string) => void;
+}
+/**
+ * State, handlers, and helpers made available to Formik's primitive components through context.
+ */
+export type FormikContextType<Values> = FormikProps<Values> & Pick<FormikConfig<Values>, 'validate' | 'validationSchema'>;
+export interface SharedRenderProps<T> {
+    /**
+     * Field component to render. Can either be a string like 'select' or a component.
+     */
+    component?: keyof JSX.IntrinsicElements | React.ComponentType<T | void>;
+    /**
+     * Render prop (works like React router's <Route render={props =>} />)
+     */
+    render?: (props: T) => React.ReactNode;
+    /**
+     * Children render function <Field name>{props => ...}</Field>)
+     */
+    children?: (props: T) => React.ReactNode;
+}
+export type GenericFieldHTMLAttributes = JSX.IntrinsicElements['input'] | JSX.IntrinsicElements['select'] | JSX.IntrinsicElements['textarea'];
+/** Field metadata */
+export interface FieldMetaProps<Value> {
+    /** Value of the field */
+    value: Value;
+    /** Error message of the field */
+    error?: string;
+    /** Has the field been visited? */
+    touched: boolean;
+    /** Initial value of the field */
+    initialValue?: Value;
+    /** Initial touched state of the field */
+    initialTouched: boolean;
+    /** Initial error message of the field */
+    initialError?: string;
+}
+/** Imperative handles to change a field's value, error and touched */
+export interface FieldHelperProps<Value> {
+    /** Set the field's value */
+    setValue: (value: Value, shouldValidate?: boolean) => Promise<void | FormikErrors<Value>>;
+    /** Set the field's touched value */
+    setTouched: (value: boolean, shouldValidate?: boolean) => Promise<void | FormikErrors<Value>>;
+    /** Set the field's error value */
+    setError: (value: string | undefined) => void;
+}
+/** Field input value, name, and event handlers */
+export interface FieldInputProps<Value> {
+    /** Value of the field */
+    value: Value;
+    /** Name of the field */
+    name: string;
+    /** Multiple select? */
+    multiple?: boolean;
+    /** Is the field checked? */
+    checked?: boolean;
+    /** Change event handler */
+    onChange: FormikHandlers['handleChange'];
+    /** Blur event handler */
+    onBlur: FormikHandlers['handleBlur'];
+}
+export type FieldValidator = (value: any) => string | void | Promise<string | void>;

server/node_modules/formik/dist/utils.d.ts

@@ -0,0 +1,68 @@
+import * as React from 'react';
+/** @private is the value an empty array? */
+export declare const isEmptyArray: (value?: any) => boolean;
+/** @private is the given object a Function? */
+export declare const isFunction: (obj: any) => obj is Function;
+/** @private is the given object an Object? */
+export declare const isObject: (obj: any) => obj is Object;
+/** @private is the given object an integer? */
+export declare const isInteger: (obj: any) => boolean;
+/** @private is the given object a string? */
+export declare const isString: (obj: any) => obj is string;
+/** @private is the given object a NaN? */
+export declare const isNaN: (obj: any) => boolean;
+/** @private Does a React component have exactly 0 children? */
+export declare const isEmptyChildren: (children: any) => boolean;
+/** @private is the given object/value a promise? */
+export declare const isPromise: (value: any) => value is PromiseLike<any>;
+/** @private is the given object/value a type of synthetic event? */
+export declare const isInputEvent: (value: any) => value is React.SyntheticEvent<any, Event>;
+/**
+ * Same as document.activeElement but wraps in a try-catch block. In IE it is
+ * not safe to call document.activeElement if there is nothing focused.
+ *
+ * The activeElement will be null only if the document or document body is not
+ * yet defined.
+ *
+ * @param {?Document} doc Defaults to current document.
+ * @return {Element | null}
+ * @see https://github.com/facebook/fbjs/blob/master/packages/fbjs/src/core/dom/getActiveElement.js
+ */
+export declare function getActiveElement(doc?: Document): Element | null;
+/**
+ * Deeply get a value from an object via its path.
+ */
+export declare function getIn(obj: any, key: string | string[], def?: any, p?: number): any;
+/**
+ * Deeply set a value from in object via it's path. If the value at `path`
+ * has changed, return a shallow copy of obj with `value` set at `path`.
+ * If `value` has not changed, return the original `obj`.
+ *
+ * Existing objects / arrays along `path` are also shallow copied. Sibling
+ * objects along path retain the same internal js reference. Since new
+ * objects / arrays are only created along `path`, we can test if anything
+ * changed in a nested structure by comparing the object's reference in
+ * the old and new object, similar to how russian doll cache invalidation
+ * works.
+ *
+ * In earlier versions of this function, which used cloneDeep, there were
+ * issues whereby settings a nested value would mutate the parent
+ * instead of creating a new object. `clone` avoids that bug making a
+ * shallow copy of the objects along the update path
+ * so no object is mutated in place.
+ *
+ * Before changing this function, please read through the following
+ * discussions.
+ *
+ * @see https://github.com/developit/linkstate
+ * @see https://github.com/jaredpalmer/formik/pull/123
+ */
+export declare function setIn(obj: any, path: string, value: any): any;
+/**
+ * Recursively a set the same value for all keys and arrays nested object, cloning
+ * @param object
+ * @param value
+ * @param visited
+ * @param response
+ */
+export declare function setNestedObjectValues<T>(object: any, value: any, visited?: any, response?: any): T;

server/node_modules/formik/dist/withFormik.d.ts

@@ -0,0 +1,68 @@
+import * as React from 'react';
+import { FormikHelpers, FormikProps, FormikSharedConfig, FormikValues, FormikTouched, FormikErrors } from './types';
+/**
+ * State, handlers, and helpers injected as props into the wrapped form component.
+ * Used with withFormik()
+ *
+ * @deprecated  Use `OuterProps & FormikProps<Values>` instead.
+ */
+export type InjectedFormikProps<Props, Values> = Props & FormikProps<Values>;
+/**
+ * Formik helpers + { props }
+ */
+export type FormikBag<P, V> = {
+    props: P;
+} & FormikHelpers<V>;
+/**
+ * withFormik() configuration options. Backwards compatible.
+ */
+export interface WithFormikConfig<Props, Values extends FormikValues = FormikValues, DeprecatedPayload = Values> extends FormikSharedConfig<Props> {
+    /**
+     * Set the display name of the component. Useful for React DevTools.
+     */
+    displayName?: string;
+    /**
+     * Submission handler
+     */
+    handleSubmit: (values: Values, formikBag: FormikBag<Props, Values>) => void;
+    /**
+     * Map props to the form values
+     */
+    mapPropsToValues?: (props: Props) => Values;
+    /**
+     * Map props to the form status
+     */
+    mapPropsToStatus?: (props: Props) => any;
+    /**
+     * Map props to the form touched state
+     */
+    mapPropsToTouched?: (props: Props) => FormikTouched<Values>;
+    /**
+     * Map props to the form errors state
+     */
+    mapPropsToErrors?: (props: Props) => FormikErrors<Values>;
+    /**
+     * @deprecated in 0.9.0 (but needed to break TS types)
+     */
+    mapValuesToPayload?: (values: Values) => DeprecatedPayload;
+    /**
+     * A Yup Schema or a function that returns a Yup schema
+     */
+    validationSchema?: any | ((props: Props) => any);
+    /**
+     * Validation function. Must return an error object or promise that
+     * throws an error object where that object keys map to corresponding value.
+     */
+    validate?: (values: Values, props: Props) => void | object | Promise<any>;
+}
+export type CompositeComponent<P> = React.ComponentClass<P> | React.FunctionComponent<P>;
+export interface ComponentDecorator<TOwnProps, TMergedProps> {
+    (component: CompositeComponent<TMergedProps>): React.ComponentType<TOwnProps>;
+}
+export interface InferableComponentDecorator<TOwnProps> {
+    <T extends CompositeComponent<TOwnProps>>(component: T): T;
+}
+/**
+ * A public higher-order component to access the imperative API
+ */
+export declare function withFormik<OuterProps extends object, Values extends FormikValues, Payload = Values>({ mapPropsToValues, ...config }: WithFormikConfig<OuterProps, Values, Payload>): ComponentDecorator<OuterProps, OuterProps & FormikProps<Values>>;

server/node_modules/formik/node_modules/deepmerge/changelog.md

@@ -0,0 +1,109 @@
+# [2.2.1](https://github.com/KyleAMathews/deepmerge/releases/tag/v2.2.1)
+
+- bug: typescript export type was wrong [#121](https://github.com/KyleAMathews/deepmerge/pull/121)
+
+# [2.2.0](https://github.com/KyleAMathews/deepmerge/releases/tag/v2.2.0)
+
+- feature: added TypeScript typings [#119](https://github.com/KyleAMathews/deepmerge/pull/119)
+
+# [2.1.1](https://github.com/KyleAMathews/deepmerge/releases/tag/v2.1.1)
+
+- documentation: Rename "methods" to "api", note ESM syntax [#103](https://github.com/KyleAMathews/deepmerge/pull/103)
+- documentation: Fix grammar [#107](https://github.com/KyleAMathews/deepmerge/pull/107)
+- documentation: Restructure headers for clarity + some wording tweaks [108](https://github.com/KyleAMathews/deepmerge/pull/108) + [109](https://github.com/KyleAMathews/deepmerge/pull/109)
+
+
+# [2.1.0](https://github.com/KyleAMathews/deepmerge/releases/tag/v2.1.0)
+
+- feature: Support a custom `isMergeableObject` function [#96](https://github.com/KyleAMathews/deepmerge/pull/96)
+- documentation: note a Webpack bug that some users might need to work around [#100](https://github.com/KyleAMathews/deepmerge/pull/100)
+
+# [2.0.1](https://github.com/KyleAMathews/deepmerge/releases/tag/v2.0.1)
+
+- documentation: fix the old array merge algorithm in the readme.  [#84](https://github.com/KyleAMathews/deepmerge/pull/84)
+
+# [2.0.0](https://github.com/KyleAMathews/deepmerge/releases/tag/v2.0.0)
+
+- breaking: the array merge algorithm has changed from a complicated thing to `target.concat(source).map(element => cloneUnlessOtherwiseSpecified(element, optionsArgument))`
+- breaking: The `clone` option now defaults to `true`
+- feature: `merge.all` now accepts an array of any size, even 0 or 1 elements
+
+See [pull request 77](https://github.com/KyleAMathews/deepmerge/pull/77).
+
+# [1.5.2](https://github.com/KyleAMathews/deepmerge/releases/tag/v1.5.2)
+
+- fix: no longer attempts to merge React elements [#76](https://github.com/KyleAMathews/deepmerge/issues/76)
+
+# [1.5.1](https://github.com/KyleAMathews/deepmerge/releases/tag/v1.5.1)
+
+- bower support: officially dropping bower support.  If you use bower, please depend on the [unpkg distribution](https://unpkg.com/deepmerge/dist/umd.js).  See [#63](https://github.com/KyleAMathews/deepmerge/issues/63)
+
+# [1.5.0](https://github.com/KyleAMathews/deepmerge/releases/tag/v1.5.0)
+
+- bug fix: merging objects into arrays was allowed, and doesn't make any sense. [#65](https://github.com/KyleAMathews/deepmerge/issues/65) published as a feature release instead of a patch because it is a decent behavior change.
+
+# [1.4.4](https://github.com/KyleAMathews/deepmerge/releases/tag/v1.4.4)
+
+- bower support: updated `main` in bower.json
+
+# [1.4.3](https://github.com/KyleAMathews/deepmerge/releases/tag/v1.4.3)
+
+- bower support: inline is-mergeable-object in a new CommonJS build, so that people using both bower and CommonJS can bundle the library [0b34e6](https://github.com/KyleAMathews/deepmerge/commit/0b34e6e95f989f2fc8091d25f0d291c08f3d2d24)
+
+# [1.4.2](https://github.com/KyleAMathews/deepmerge/releases/tag/v1.4.2)
+
+- performance: bump is-mergeable-object dependency version for a slight performance improvement [5906c7](https://github.com/KyleAMathews/deepmerge/commit/5906c765d691d48e83d76efbb0d4b9ca150dc12c)
+
+# [1.4.1](https://github.com/KyleAMathews/deepmerge/releases/tag/v1.4.1)
+
+- documentation: fix unpkg link [acc45b](https://github.com/KyleAMathews/deepmerge/commit/acc45be85519c1df906a72ecb24764b622d18d47)
+
+# [1.4.0](https://github.com/KyleAMathews/deepmerge/releases/tag/v1.4.0)
+
+- api: instead of only exporting a UMD module, expose a UMD module with `pkg.main`, a CJS module with `pkg.browser`, and an ES module with `pkg.module` [#62](https://github.com/KyleAMathews/deepmerge/pull/62)
+
+# [1.3.2](https://github.com/KyleAMathews/deepmerge/releases/tag/v1.3.2)
+
+- documentation: note the minified/gzipped file sizes [56](https://github.com/KyleAMathews/deepmerge/pull/56)
+- documentation: make data structures more readable in merge example: pull request [57](https://github.com/KyleAMathews/deepmerge/pull/57)
+
+# [1.3.1](https://github.com/KyleAMathews/deepmerge/releases/tag/v1.3.1)
+
+- documentation: clarify and test some array merging documentation: pull request [51](https://github.com/KyleAMathews/deepmerge/pull/51)
+
+# [1.3.0](https://github.com/KyleAMathews/deepmerge/releases/tag/v1.3.0)
+
+- feature: `merge.all`, a merge function that merges any number of objects: pull request [50](https://github.com/KyleAMathews/deepmerge/pull/50)
+
+# [1.2.0](https://github.com/KyleAMathews/deepmerge/releases/tag/v1.2.0)
+
+- fix: an error that would be thrown when an array would be merged onto a truthy non-array value: pull request [46](https://github.com/KyleAMathews/deepmerge/pull/46)
+- feature: the ability to clone: Issue [28](https://github.com/KyleAMathews/deepmerge/issues/28), pull requests [44](https://github.com/KyleAMathews/deepmerge/pull/44) and [48](https://github.com/KyleAMathews/deepmerge/pull/48)
+- maintenance: added tests + travis to `.npmignore`: pull request [47](https://github.com/KyleAMathews/deepmerge/pull/47)
+
+# [1.1.1](https://github.com/KyleAMathews/deepmerge/releases/tag/v1.1.1)
+
+- fix an issue where an error was thrown when merging an array onto a non-array: [Pull request 46](https://github.com/KyleAMathews/deepmerge/pull/46)
+
+# [1.1.0](https://github.com/KyleAMathews/deepmerge/releases/tag/v1.1.0)
+
+- allow consumers to specify their own array merging algorithm: [Pull request 37](https://github.com/KyleAMathews/deepmerge/pull/37)
+
+# [1.0.3](https://github.com/KyleAMathews/deepmerge/releases/tag/v1.0.3)
+
+- adding bower.json back: [Issue 38](https://github.com/KyleAMathews/deepmerge/pull/38)
+- updating keywords and Github links in package.json [bc3898e](https://github.com/KyleAMathews/deepmerge/commit/bc3898e587a56f74591328f40f656b0152c1d5eb)
+
+# [1.0.2](https://github.com/KyleAMathews/deepmerge/releases/tag/v1.0.2)
+
+- Updating the readme: dropping bower, testing that the example works: [7102fc](https://github.com/KyleAMathews/deepmerge/commit/7102fcc4ddec11e2d33205866f9f18df14e5aeb5)
+
+# [1.0.1](https://github.com/KyleAMathews/deepmerge/releases/tag/v1.0.1)
+
+- `null`, dates, and regular expressions are now properly merged in arrays: [Issue 18](https://github.com/KyleAMathews/deepmerge/pull/18), plus commit: [ef1c6b](https://github.com/KyleAMathews/deepmerge/commit/ef1c6bac8350ba12a24966f0bc7da02560827586)
+
+# 1.0.0
+
+- Should only be a patch change, because this module is READY. [Issue 15](https://github.com/KyleAMathews/deepmerge/issues/15)
+- Regular expressions are now treated like primitive values when merging: [Issue 30](https://github.com/KyleAMathews/deepmerge/pull/30)
+- Dates are now treated like primitives when merging: [Issue 31](https://github.com/KyleAMathews/deepmerge/issues/31)

server/node_modules/formik/node_modules/deepmerge/dist/cjs.js

@@ -0,0 +1,101 @@
+'use strict';
+
+var isMergeableObject = function isMergeableObject(value) {
+	return isNonNullObject(value)
+		&& !isSpecial(value)
+};
+
+function isNonNullObject(value) {
+	return !!value && typeof value === 'object'
+}
+
+function isSpecial(value) {
+	var stringValue = Object.prototype.toString.call(value);
+
+	return stringValue === '[object RegExp]'
+		|| stringValue === '[object Date]'
+		|| isReactElement(value)
+}
+
+// see https://github.com/facebook/react/blob/b5ac963fb791d1298e7f396236383bc955f916c1/src/isomorphic/classic/element/ReactElement.js#L21-L25
+var canUseSymbol = typeof Symbol === 'function' && Symbol.for;
+var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for('react.element') : 0xeac7;
+
+function isReactElement(value) {
+	return value.$$typeof === REACT_ELEMENT_TYPE
+}
+
+function emptyTarget(val) {
+	return Array.isArray(val) ? [] : {}
+}
+
+function cloneUnlessOtherwiseSpecified(value, optionsArgument) {
+	var cloneOptionWasSpecified = optionsArgument && typeof optionsArgument.clone === 'boolean';
+	var clone = !cloneOptionWasSpecified || optionsArgument.clone === true;
+
+	return (clone && isMergeableObject(value))
+		? deepmerge(emptyTarget(value), value, optionsArgument)
+		: value
+}
+
+function defaultArrayMerge(target, source, optionsArgument) {
+	var destination = target.slice();
+	source.forEach(function(e, i) {
+		if (typeof destination[i] === 'undefined') {
+			destination[i] = cloneUnlessOtherwiseSpecified(e, optionsArgument);
+		} else if (isMergeableObject(e)) {
+			destination[i] = deepmerge(target[i], e, optionsArgument);
+		} else if (target.indexOf(e) === -1) {
+			destination.push(cloneUnlessOtherwiseSpecified(e, optionsArgument));
+		}
+	});
+	return destination
+}
+
+function mergeObject(target, source, optionsArgument) {
+	var destination = {};
+	if (isMergeableObject(target)) {
+		Object.keys(target).forEach(function(key) {
+			destination[key] = cloneUnlessOtherwiseSpecified(target[key], optionsArgument);
+		});
+	}
+	Object.keys(source).forEach(function(key) {
+		if (!isMergeableObject(source[key]) || !target[key]) {
+			destination[key] = cloneUnlessOtherwiseSpecified(source[key], optionsArgument);
+		} else {
+			destination[key] = deepmerge(target[key], source[key], optionsArgument);
+		}
+	});
+	return destination
+}
+
+function deepmerge(target, source, optionsArgument) {
+	var sourceIsArray = Array.isArray(source);
+	var targetIsArray = Array.isArray(target);
+	var options = optionsArgument || { arrayMerge: defaultArrayMerge };
+	var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
+
+	if (!sourceAndTargetTypesMatch) {
+		return cloneUnlessOtherwiseSpecified(source, optionsArgument)
+	} else if (sourceIsArray) {
+		var arrayMerge = options.arrayMerge || defaultArrayMerge;
+		return arrayMerge(target, source, optionsArgument)
+	} else {
+		return mergeObject(target, source, optionsArgument)
+	}
+}
+
+deepmerge.all = function deepmergeAll(array, optionsArgument) {
+	if (!Array.isArray(array) || array.length < 2) {
+		throw new Error('first argument should be an array with at least two elements')
+	}
+
+	// we are sure there are at least 2 values, so it is safe to have no initial value
+	return array.reduce(function(prev, next) {
+		return deepmerge(prev, next, optionsArgument)
+	})
+};
+
+var deepmerge_1 = deepmerge;
+
+module.exports = deepmerge_1;

server/node_modules/formik/node_modules/deepmerge/dist/es.js

@@ -0,0 +1,89 @@
+var isMergeableObject = function isMergeableObject(value) {
+	return isNonNullObject(value)
+		&& !isSpecial(value)
+};
+
+function isNonNullObject(value) {
+	return !!value && typeof value === 'object'
+}
+
+function isSpecial(value) {
+	var stringValue = Object.prototype.toString.call(value);
+
+	return stringValue === '[object RegExp]'
+		|| stringValue === '[object Date]'
+		|| isReactElement(value)
+}
+
+// see https://github.com/facebook/react/blob/b5ac963fb791d1298e7f396236383bc955f916c1/src/isomorphic/classic/element/ReactElement.js#L21-L25
+var canUseSymbol = typeof Symbol === 'function' && Symbol.for;
+var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for('react.element') : 0xeac7;
+
+function isReactElement(value) {
+	return value.$$typeof === REACT_ELEMENT_TYPE
+}
+
+function emptyTarget(val) {
+	return Array.isArray(val) ? [] : {}
+}
+
+function cloneUnlessOtherwiseSpecified(value, options) {
+	return (options.clone !== false && options.isMergeableObject(value))
+		? deepmerge(emptyTarget(value), value, options)
+		: value
+}
+
+function defaultArrayMerge(target, source, options) {
+	return target.concat(source).map(function(element) {
+		return cloneUnlessOtherwiseSpecified(element, options)
+	})
+}
+
+function mergeObject(target, source, options) {
+	var destination = {};
+	if (options.isMergeableObject(target)) {
+		Object.keys(target).forEach(function(key) {
+			destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
+		});
+	}
+	Object.keys(source).forEach(function(key) {
+		if (!options.isMergeableObject(source[key]) || !target[key]) {
+			destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
+		} else {
+			destination[key] = deepmerge(target[key], source[key], options);
+		}
+	});
+	return destination
+}
+
+function deepmerge(target, source, options) {
+	options = options || {};
+	options.arrayMerge = options.arrayMerge || defaultArrayMerge;
+	options.isMergeableObject = options.isMergeableObject || isMergeableObject;
+
+	var sourceIsArray = Array.isArray(source);
+	var targetIsArray = Array.isArray(target);
+	var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
+
+	if (!sourceAndTargetTypesMatch) {
+		return cloneUnlessOtherwiseSpecified(source, options)
+	} else if (sourceIsArray) {
+		return options.arrayMerge(target, source, options)
+	} else {
+		return mergeObject(target, source, options)
+	}
+}
+
+deepmerge.all = function deepmergeAll(array, options) {
+	if (!Array.isArray(array)) {
+		throw new Error('first argument should be an array')
+	}
+
+	return array.reduce(function(prev, next) {
+		return deepmerge(prev, next, options)
+	}, {})
+};
+
+var deepmerge_1 = deepmerge;
+
+export default deepmerge_1;

server/node_modules/formik/node_modules/deepmerge/dist/umd.js

@@ -0,0 +1,97 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+	typeof define === 'function' && define.amd ? define(factory) :
+	(global.deepmerge = factory());
+}(this, (function () { 'use strict';
+
+var isMergeableObject = function isMergeableObject(value) {
+	return isNonNullObject(value)
+		&& !isSpecial(value)
+};
+
+function isNonNullObject(value) {
+	return !!value && typeof value === 'object'
+}
+
+function isSpecial(value) {
+	var stringValue = Object.prototype.toString.call(value);
+
+	return stringValue === '[object RegExp]'
+		|| stringValue === '[object Date]'
+		|| isReactElement(value)
+}
+
+// see https://github.com/facebook/react/blob/b5ac963fb791d1298e7f396236383bc955f916c1/src/isomorphic/classic/element/ReactElement.js#L21-L25
+var canUseSymbol = typeof Symbol === 'function' && Symbol.for;
+var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for('react.element') : 0xeac7;
+
+function isReactElement(value) {
+	return value.$$typeof === REACT_ELEMENT_TYPE
+}
+
+function emptyTarget(val) {
+	return Array.isArray(val) ? [] : {}
+}
+
+function cloneUnlessOtherwiseSpecified(value, options) {
+	return (options.clone !== false && options.isMergeableObject(value))
+		? deepmerge(emptyTarget(value), value, options)
+		: value
+}
+
+function defaultArrayMerge(target, source, options) {
+	return target.concat(source).map(function(element) {
+		return cloneUnlessOtherwiseSpecified(element, options)
+	})
+}
+
+function mergeObject(target, source, options) {
+	var destination = {};
+	if (options.isMergeableObject(target)) {
+		Object.keys(target).forEach(function(key) {
+			destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
+		});
+	}
+	Object.keys(source).forEach(function(key) {
+		if (!options.isMergeableObject(source[key]) || !target[key]) {
+			destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
+		} else {
+			destination[key] = deepmerge(target[key], source[key], options);
+		}
+	});
+	return destination
+}
+
+function deepmerge(target, source, options) {
+	options = options || {};
+	options.arrayMerge = options.arrayMerge || defaultArrayMerge;
+	options.isMergeableObject = options.isMergeableObject || isMergeableObject;
+
+	var sourceIsArray = Array.isArray(source);
+	var targetIsArray = Array.isArray(target);
+	var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
+
+	if (!sourceAndTargetTypesMatch) {
+		return cloneUnlessOtherwiseSpecified(source, options)
+	} else if (sourceIsArray) {
+		return options.arrayMerge(target, source, options)
+	} else {
+		return mergeObject(target, source, options)
+	}
+}
+
+deepmerge.all = function deepmergeAll(array, options) {
+	if (!Array.isArray(array)) {
+		throw new Error('first argument should be an array')
+	}
+
+	return array.reduce(function(prev, next) {
+		return deepmerge(prev, next, options)
+	}, {})
+};
+
+var deepmerge_1 = deepmerge;
+
+return deepmerge_1;
+
+})));

server/node_modules/formik/node_modules/deepmerge/index.d.ts

@@ -0,0 +1,14 @@
+declare function deepmerge<T>(x: Partial<T>, y: Partial<T>, options?: deepmerge.Options): T;
+declare function deepmerge<T1, T2>(x: Partial<T1>, y: Partial<T2>, options?: deepmerge.Options): T1 & T2;
+
+declare namespace deepmerge {
+	export interface Options {
+		arrayMerge?(target: any[], source: any[], options?: Options): any[];
+		clone?: boolean;
+		isMergeableObject?(value: object): boolean;
+	}
+
+	export function all (objects: object[], options?: Options): object;
+}
+
+export = deepmerge;

server/node_modules/formik/node_modules/deepmerge/index.js

@@ -0,0 +1,64 @@
+var defaultIsMergeableObject = require('is-mergeable-object')
+
+function emptyTarget(val) {
+	return Array.isArray(val) ? [] : {}
+}
+
+function cloneUnlessOtherwiseSpecified(value, options) {
+	return (options.clone !== false && options.isMergeableObject(value))
+		? deepmerge(emptyTarget(value), value, options)
+		: value
+}
+
+function defaultArrayMerge(target, source, options) {
+	return target.concat(source).map(function(element) {
+		return cloneUnlessOtherwiseSpecified(element, options)
+	})
+}
+
+function mergeObject(target, source, options) {
+	var destination = {}
+	if (options.isMergeableObject(target)) {
+		Object.keys(target).forEach(function(key) {
+			destination[key] = cloneUnlessOtherwiseSpecified(target[key], options)
+		})
+	}
+	Object.keys(source).forEach(function(key) {
+		if (!options.isMergeableObject(source[key]) || !target[key]) {
+			destination[key] = cloneUnlessOtherwiseSpecified(source[key], options)
+		} else {
+			destination[key] = deepmerge(target[key], source[key], options)
+		}
+	})
+	return destination
+}
+
+function deepmerge(target, source, options) {
+	options = options || {}
+	options.arrayMerge = options.arrayMerge || defaultArrayMerge
+	options.isMergeableObject = options.isMergeableObject || defaultIsMergeableObject
+
+	var sourceIsArray = Array.isArray(source)
+	var targetIsArray = Array.isArray(target)
+	var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray
+
+	if (!sourceAndTargetTypesMatch) {
+		return cloneUnlessOtherwiseSpecified(source, options)
+	} else if (sourceIsArray) {
+		return options.arrayMerge(target, source, options)
+	} else {
+		return mergeObject(target, source, options)
+	}
+}
+
+deepmerge.all = function deepmergeAll(array, options) {
+	if (!Array.isArray(array)) {
+		throw new Error('first argument should be an array')
+	}
+
+	return array.reduce(function(prev, next) {
+		return deepmerge(prev, next, options)
+	}, {})
+}
+
+module.exports = deepmerge

server/node_modules/formik/node_modules/deepmerge/license.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2012 Nicholas Fisher
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

server/node_modules/formik/node_modules/deepmerge/package.json

@@ -0,0 +1,44 @@
+{
+  "author": "Nick Fisher",
+  "name": "deepmerge",
+  "description": "A library for deep (recursive) merging of Javascript objects",
+  "keywords": [
+    "merge",
+    "deep",
+    "extend",
+    "copy",
+    "clone",
+    "recursive"
+  ],
+  "version": "2.2.1",
+  "homepage": "https://github.com/KyleAMathews/deepmerge",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/KyleAMathews/deepmerge.git"
+  },
+  "main": "dist/umd.js",
+  "module": "dist/es.js",
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "scripts": {
+    "build": "rollup -c",
+    "test": "npm run build && tap test/*.js && jsmd readme.md && npm run test:typescript",
+    "test:typescript": "tsc --noEmit test/typescript.ts && ts-node test/typescript.ts",
+    "size": "npm run build && uglifyjs --compress --mangle -- ./dist/umd.js | gzip -c | wc -c"
+  },
+  "devDependencies": {
+    "is-mergeable-object": "1.1.0",
+    "is-plain-object": "^2.0.4",
+    "jsmd": "0.3.1",
+    "rollup": "0.49.3",
+    "rollup-plugin-commonjs": "8.2.1",
+    "rollup-plugin-node-resolve": "3.0.0",
+    "tap": "12.0.1",
+    "ts-node": "7.0.1",
+    "typescript": "=2.2.2",
+    "uglify-js": "^3.3.12"
+  },
+  "license": "MIT",
+  "dependencies": {}
+}

server/node_modules/formik/node_modules/deepmerge/readme.md

@@ -0,0 +1,249 @@
+# deepmerge
+
+Merges the enumerable attributes of two or more objects deeply.
+
+> UMD bundle is 567B minified+gzipped
+
+
+### Migration from 1.x to 2.0.0
+
+[***Check out the changes from version 1.x to 2.0.0***](https://github.com/KyleAMathews/deepmerge/blob/master/changelog.md#200)
+
+For the legacy array element-merging algorithm, see [the `arrayMerge` option below](#arraymerge).
+
+
+### Webpack bug
+
+If you have `require('deepmerge')` (as opposed to `import merge from 'deepmerge'`) anywhere in your codebase, Webpack 3 and 4 have a bug that [breaks bundling](https://github.com/webpack/webpack/issues/6584).
+
+If you see `Error: merge is not a function`, add this alias to your Webpack config:
+
+```
+alias: {
+	deepmerge$: path.resolve(__dirname, 'node_modules/deepmerge/dist/umd.js'),
+}
+```
+
+
+## Getting Started
+
+### Example Usage
+<!--js
+var merge = require('./')
+-->
+
+```js
+var x = {
+	foo: { bar: 3 },
+	array: [{
+		does: 'work',
+		too: [ 1, 2, 3 ]
+	}]
+}
+
+var y = {
+	foo: { baz: 4 },
+	quux: 5,
+	array: [{
+		does: 'work',
+		too: [ 4, 5, 6 ]
+	}, {
+		really: 'yes'
+	}]
+}
+
+var expected = {
+	foo: {
+		bar: 3,
+		baz: 4
+	},
+	array: [{
+		does: 'work',
+		too: [ 1, 2, 3 ]
+	}, {
+		does: 'work',
+		too: [ 4, 5, 6 ]
+	}, {
+		really: 'yes'
+	}],
+	quux: 5
+}
+
+merge(x, y) // => expected
+```
+
+
+### Installation
+
+With [npm](http://npmjs.org) do:
+
+```sh
+npm install deepmerge
+```
+
+deepmerge can be used directly in the browser without the use of package managers/bundlers as well:  [UMD version from unpkg.com](https://unpkg.com/deepmerge/dist/umd.js).
+
+
+### Includes
+
+CommonJS:
+```
+var merge = require('deepmerge')
+```
+
+ES Modules:
+```
+import merge from 'deepmerge'
+```
+
+
+# API
+
+
+## `merge(x, y, [options])`
+
+Merge two objects `x` and `y` deeply, returning a new merged object with the
+elements from both `x` and `y`.
+
+If an element at the same key is present for both `x` and `y`, the value from
+`y` will appear in the result.
+
+Merging creates a new object, so that neither `x` or `y` is modified.
+
+**Note:** By default, arrays are merged by concatenating them.
+
+## `merge.all(arrayOfObjects, [options])`
+
+Merges any number of objects into a single result object.
+
+```js
+var x = { foo: { bar: 3 } }
+var y = { foo: { baz: 4 } }
+var z = { bar: 'yay!' }
+
+var expected = { foo: { bar: 3, baz: 4 }, bar: 'yay!' }
+
+merge.all([x, y, z]) // => expected
+```
+
+
+## Options
+
+### `arrayMerge`
+
+There are multiple ways to merge two arrays, below are a few examples but you can also create your own custom function.
+
+#### Overwrite Array
+
+Overwrites the existing array values completely rather than concatenating them
+
+```js
+const overwriteMerge = (destinationArray, sourceArray, options) => sourceArray
+
+merge(
+	[1, 2, 3],
+	[3, 2, 1],
+	{ arrayMerge: overwriteMerge }
+) // => [3, 2, 1]
+```
+
+#### Combine Array
+
+Combine arrays, such as overwriting existing defaults while also adding/keeping values that are different names
+
+To use the legacy (pre-version-2.0.0) array merging algorithm, use the following:
+
+```js
+const emptyTarget = value => Array.isArray(value) ? [] : {}
+const clone = (value, options) => merge(emptyTarget(value), value, options)
+
+function combineMerge(target, source, options) {
+	const destination = target.slice()
+
+	source.forEach(function(e, i) {
+		if (typeof destination[i] === 'undefined') {
+			const cloneRequested = options.clone !== false
+			const shouldClone = cloneRequested && options.isMergeableObject(e)
+			destination[i] = shouldClone ? clone(e, options) : e
+		} else if (options.isMergeableObject(e)) {
+			destination[i] = merge(target[i], e, options)
+		} else if (target.indexOf(e) === -1) {
+			destination.push(e)
+		}
+	})
+	return destination
+}
+
+merge(
+	[{ a: true }],
+	[{ b: true }, 'ah yup'],
+	{ arrayMerge: combineMerge }
+) // => [{ a: true, b: true }, 'ah yup']
+```
+
+### `isMergeableObject`
+
+By default, deepmerge clones every property from almost every kind of object.
+
+You may not want this, if your objects are of special types, and you want to copy the whole object instead of just copying its properties.
+
+You can accomplish this by passing in a function for the `isMergeableObject` option.
+
+If you only want to clone properties of plain objects, and ignore all "special" kinds of instantiated objects, you probably want to drop in [`is-plain-object`](https://github.com/jonschlinkert/is-plain-object).
+
+```js
+const isPlainObject = require('is-plain-object')
+
+function SuperSpecial() {
+	this.special = 'oh yeah man totally'
+}
+
+const instantiatedSpecialObject = new SuperSpecial()
+
+const target = {
+	someProperty: {
+		cool: 'oh for sure'
+	}
+}
+
+const source = {
+	someProperty: instantiatedSpecialObject
+}
+
+const defaultOutput = merge(target, source)
+
+defaultOutput.someProperty.cool // => 'oh for sure'
+defaultOutput.someProperty.special // => 'oh yeah man totally'
+defaultOutput.someProperty instanceof SuperSpecial // => false
+
+const customMergeOutput = merge(target, source, {
+	isMergeableObject: isPlainObject
+})
+
+customMergeOutput.someProperty.cool // => undefined
+customMergeOutput.someProperty.special // => 'oh yeah man totally'
+customMergeOutput.someProperty instanceof SuperSpecial // => true
+```
+
+
+### `clone`
+
+*Deprecated.*
+
+Defaults to `true`.
+
+If `clone` is `false` then child objects will be copied directly instead of being cloned.  This was the default behavior before version 2.x.
+
+
+# Testing
+
+With [npm](http://npmjs.org) do:
+
+```sh
+npm test
+```
+
+
+# License
+
+MIT

server/node_modules/formik/node_modules/deepmerge/rollup.config.js

@@ -0,0 +1,17 @@
+import resolve from 'rollup-plugin-node-resolve'
+import commonjs from 'rollup-plugin-commonjs'
+
+var pkg = require('./package.json')
+
+export default {
+	input: 'index.js',
+	name: 'deepmerge',
+	plugins: [
+		commonjs(),
+		resolve(),
+	],
+	output: [
+		{ file: pkg.main, format: 'umd' },
+		{ file: pkg.module, format: 'es' },
+	],
+}

server/node_modules/formik/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "formik",
+  "description": "Build forms in React, without the tears",
+  "version": "2.4.5",
+  "license": "Apache-2.0",
+  "author": "Jared Palmer <jared@palmer.net> (https://jaredpalmer.com)",
+  "contributors": [
+    "Evan Jacobs <probablyup@gmail.com> (https://probablyup.com)"
+  ],
+  "repository": "jaredpalmer/formik",
+  "homepage": "https://formik.org",
+  "keywords": [
+    "formik",
+    "form",
+    "forms",
+    "react",
+    "react-dom",
+    "hooks",
+    "react hooks",
+    "validation",
+    "render props",
+    "validation",
+    "higher order component",
+    "hoc"
+  ],
+  "funding": [
+    {
+      "type": "individual",
+      "url": "https://opencollective.com/formik"
+    }
+  ],
+  "main": "dist/index.js",
+  "umd:main": "dist/formik.umd.production.js",
+  "module": "dist/formik.esm.js",
+  "typings": "dist/index.d.ts",
+  "files": ["dist"],
+  "peerDependencies": {
+    "react": ">=16.8.0"
+  },
+  "sideEffects": false,
+  "scripts": {
+    "test": "tsdx test --env=jsdom",
+    "test:watch": "npm run test -- --watchAll",
+    "start": "tsdx watch --tsconfig tsconfig.build.json --verbose --noClean",
+    "build": "tsdx build --tsconfig tsconfig.build.json",
+    "lint": "tsdx lint"
+  },
+  "dependencies": {
+    "@types/hoist-non-react-statics": "^3.3.1",
+    "deepmerge": "^2.1.1",
+    "hoist-non-react-statics": "^3.3.0",
+    "lodash": "^4.17.21",
+    "lodash-es": "^4.17.21",
+    "react-fast-compare": "^2.0.1",
+    "tiny-warning": "^1.0.2",
+    "tslib": "^2.0.0"
+  },
+  "devDependencies": {
+    "@testing-library/react": "^14.0.0",
+    "@types/lodash": "^4.14.119",
+    "@types/react": "^18.2.7",
+    "@types/react-dom": "^18.2.4",
+    "@types/warning": "^3.0.0",
+    "just-debounce-it": "^1.1.0",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "tsdx": "^0.14.1",
+    "typescript": "^4.0.3",
+    "yup": "^0.32.0"
+  },
+  "jest": {
+    "globals": {
+      "__DEV__": "boolean"
+    },
+    "collectCoverageFrom": [
+      "src/**/*.{ts,tsx}"
+    ],
+    "setupFilesAfterEnv": [
+      "<rootDir>/test/setupTests.ts"
+    ]
+  }
+}