@pinuts/bsr-uikit-relaunch 0.0.3 → 0.0.4

package/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;

package/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>>;

package/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)

package/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;

package/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;

package/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;
+
+})));

package/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;

package/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

package/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.