JohanLe / me-app

(function (global, factory) {

  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react')) :

  typeof define === 'function' && define.amd ? define(['exports', 'react'], factory) :

  (global = global || self, factory(global.ReactRouterDOM = {}, global.React));

}(this, function (exports, React) { 'use strict';

  var React__default = 'default' in React ? React['default'] : React;

  function _inheritsLoose(subClass, superClass) {

    subClass.prototype = Object.create(superClass.prototype);

    subClass.prototype.constructor = subClass;

    subClass.__proto__ = superClass;

  }

  var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};

  function unwrapExports (x) {

  	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;

  }

  function createCommonjsModule(fn, module) {

  	return module = { exports: {} }, fn(module, module.exports), module.exports;

  }

  var reactIs_production_min = createCommonjsModule(function (module, exports) {

  Object.defineProperty(exports,"__esModule",{value:!0});

  var b="function"===typeof Symbol&&Symbol.for,c=b?Symbol.for("react.element"):60103,d=b?Symbol.for("react.portal"):60106,e=b?Symbol.for("react.fragment"):60107,f=b?Symbol.for("react.strict_mode"):60108,g=b?Symbol.for("react.profiler"):60114,h=b?Symbol.for("react.provider"):60109,k=b?Symbol.for("react.context"):60110,l=b?Symbol.for("react.async_mode"):60111,m=b?Symbol.for("react.concurrent_mode"):60111,n=b?Symbol.for("react.forward_ref"):60112,p=b?Symbol.for("react.suspense"):60113,q=b?Symbol.for("react.suspense_list"):

  60120,r=b?Symbol.for("react.memo"):60115,t=b?Symbol.for("react.lazy"):60116,v=b?Symbol.for("react.fundamental"):60117,w=b?Symbol.for("react.responder"):60118;function x(a){if("object"===typeof a&&null!==a){var u=a.$$typeof;switch(u){case c:switch(a=a.type,a){case l:case m:case e:case g:case f:case p:return a;default:switch(a=a&&a.$$typeof,a){case k:case n:case h:return a;default:return u}}case t:case r:case d:return u}}}function y(a){return x(a)===m}exports.typeOf=x;exports.AsyncMode=l;

  exports.ConcurrentMode=m;exports.ContextConsumer=k;exports.ContextProvider=h;exports.Element=c;exports.ForwardRef=n;exports.Fragment=e;exports.Lazy=t;exports.Memo=r;exports.Portal=d;exports.Profiler=g;exports.StrictMode=f;exports.Suspense=p;

  exports.isValidElementType=function(a){return "string"===typeof a||"function"===typeof a||a===e||a===m||a===g||a===f||a===p||a===q||"object"===typeof a&&null!==a&&(a.$$typeof===t||a.$$typeof===r||a.$$typeof===h||a.$$typeof===k||a.$$typeof===n||a.$$typeof===v||a.$$typeof===w)};exports.isAsyncMode=function(a){return y(a)||x(a)===l};exports.isConcurrentMode=y;exports.isContextConsumer=function(a){return x(a)===k};exports.isContextProvider=function(a){return x(a)===h};

  exports.isElement=function(a){return "object"===typeof a&&null!==a&&a.$$typeof===c};exports.isForwardRef=function(a){return x(a)===n};exports.isFragment=function(a){return x(a)===e};exports.isLazy=function(a){return x(a)===t};exports.isMemo=function(a){return x(a)===r};exports.isPortal=function(a){return x(a)===d};exports.isProfiler=function(a){return x(a)===g};exports.isStrictMode=function(a){return x(a)===f};exports.isSuspense=function(a){return x(a)===p};

  });

  unwrapExports(reactIs_production_min);

  var reactIs_production_min_1 = reactIs_production_min.typeOf;

  var reactIs_production_min_2 = reactIs_production_min.AsyncMode;

  var reactIs_production_min_3 = reactIs_production_min.ConcurrentMode;

  var reactIs_production_min_4 = reactIs_production_min.ContextConsumer;

  var reactIs_production_min_5 = reactIs_production_min.ContextProvider;

  var reactIs_production_min_6 = reactIs_production_min.Element;

  var reactIs_production_min_7 = reactIs_production_min.ForwardRef;

  var reactIs_production_min_8 = reactIs_production_min.Fragment;

  var reactIs_production_min_9 = reactIs_production_min.Lazy;

  var reactIs_production_min_10 = reactIs_production_min.Memo;

  var reactIs_production_min_11 = reactIs_production_min.Portal;

  var reactIs_production_min_12 = reactIs_production_min.Profiler;

  var reactIs_production_min_13 = reactIs_production_min.StrictMode;

  var reactIs_production_min_14 = reactIs_production_min.Suspense;

  var reactIs_production_min_15 = reactIs_production_min.isValidElementType;

  var reactIs_production_min_16 = reactIs_production_min.isAsyncMode;

  var reactIs_production_min_17 = reactIs_production_min.isConcurrentMode;

  var reactIs_production_min_18 = reactIs_production_min.isContextConsumer;

  var reactIs_production_min_19 = reactIs_production_min.isContextProvider;

  var reactIs_production_min_20 = reactIs_production_min.isElement;

  var reactIs_production_min_21 = reactIs_production_min.isForwardRef;

  var reactIs_production_min_22 = reactIs_production_min.isFragment;

  var reactIs_production_min_23 = reactIs_production_min.isLazy;

  var reactIs_production_min_24 = reactIs_production_min.isMemo;

  var reactIs_production_min_25 = reactIs_production_min.isPortal;

  var reactIs_production_min_26 = reactIs_production_min.isProfiler;

  var reactIs_production_min_27 = reactIs_production_min.isStrictMode;

  var reactIs_production_min_28 = reactIs_production_min.isSuspense;

  var reactIs_development = createCommonjsModule(function (module, exports) {

  {

    (function() {

  Object.defineProperty(exports, '__esModule', { value: true });

  // The Symbol used to tag the ReactElement-like types. If there is no native Symbol

  // nor polyfill, then a plain number is used for performance.

  var hasSymbol = typeof Symbol === 'function' && Symbol.for;

  var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7;

  var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for('react.portal') : 0xeaca;

  var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for('react.fragment') : 0xeacb;

  var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for('react.strict_mode') : 0xeacc;

  var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2;

  var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for('react.provider') : 0xeacd;

  var REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for('react.context') : 0xeace;

  // TODO: We don't use AsyncMode or ConcurrentMode anymore. They were temporary

  // (unstable) APIs that have been removed. Can we remove the symbols?

  var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for('react.async_mode') : 0xeacf;

  var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for('react.concurrent_mode') : 0xeacf;

  var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0;

  var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for('react.suspense') : 0xead1;

  var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? Symbol.for('react.suspense_list') : 0xead8;

  var REACT_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3;

  var REACT_LAZY_TYPE = hasSymbol ? Symbol.for('react.lazy') : 0xead4;

  var REACT_FUNDAMENTAL_TYPE = hasSymbol ? Symbol.for('react.fundamental') : 0xead5;

  var REACT_RESPONDER_TYPE = hasSymbol ? Symbol.for('react.responder') : 0xead6;

  function isValidElementType(type) {

    return typeof type === 'string' || typeof type === 'function' ||

    // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.

    type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE);

  }

  /**

   * Forked from fbjs/warning:

   * https://github.com/facebook/fbjs/blob/e66ba20ad5be433eb54423f2b097d829324d9de6/packages/fbjs/src/__forks__/warning.js

   *

   * Only change is we use console.warn instead of console.error,

   * and do nothing when 'console' is not supported.

   * This really simplifies the code.

   * ---

   * Similar to invariant but only logs a warning if the condition is not met.

   * This can be used to log issues in development environments in critical

   * paths. Removing the logging code for production environments will keep the

   * same logic and follow the same code paths.

   */

  var lowPriorityWarning = function () {};

  {

    var printWarning = function (format) {

      for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {

        args[_key - 1] = arguments[_key];

      }

      var argIndex = 0;

      var message = 'Warning: ' + format.replace(/%s/g, function () {

        return args[argIndex++];

      });

      if (typeof console !== 'undefined') {

        console.warn(message);

      }

      try {

        // --- Welcome to debugging React ---

        // This error was thrown as a convenience so that you can use this stack

        // to find the callsite that caused this warning to fire.

        throw new Error(message);

      } catch (x) {}

    };

    lowPriorityWarning = function (condition, format) {

      if (format === undefined) {

        throw new Error('`lowPriorityWarning(condition, format, ...args)` requires a warning ' + 'message argument');

      }

      if (!condition) {

        for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {

          args[_key2 - 2] = arguments[_key2];

        }

        printWarning.apply(undefined, [format].concat(args));

      }

    };

  }

  var lowPriorityWarning$1 = lowPriorityWarning;

  function typeOf(object) {

    if (typeof object === 'object' && object !== null) {

      var $$typeof = object.$$typeof;

      switch ($$typeof) {

        case REACT_ELEMENT_TYPE:

          var type = object.type;

          switch (type) {

            case REACT_ASYNC_MODE_TYPE:

            case REACT_CONCURRENT_MODE_TYPE:

            case REACT_FRAGMENT_TYPE:

            case REACT_PROFILER_TYPE:

            case REACT_STRICT_MODE_TYPE:

            case REACT_SUSPENSE_TYPE:

              return type;

            default:

              var $$typeofType = type && type.$$typeof;

              switch ($$typeofType) {

                case REACT_CONTEXT_TYPE:

                case REACT_FORWARD_REF_TYPE:

                case REACT_PROVIDER_TYPE:

                  return $$typeofType;

                default:

                  return $$typeof;

              }

          }

        case REACT_LAZY_TYPE:

        case REACT_MEMO_TYPE:

        case REACT_PORTAL_TYPE:

          return $$typeof;

      }

    }

    return undefined;

  }

  // AsyncMode is deprecated along with isAsyncMode

  var AsyncMode = REACT_ASYNC_MODE_TYPE;

  var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;

  var ContextConsumer = REACT_CONTEXT_TYPE;

  var ContextProvider = REACT_PROVIDER_TYPE;

  var Element = REACT_ELEMENT_TYPE;

  var ForwardRef = REACT_FORWARD_REF_TYPE;

  var Fragment = REACT_FRAGMENT_TYPE;

  var Lazy = REACT_LAZY_TYPE;

  var Memo = REACT_MEMO_TYPE;

  var Portal = REACT_PORTAL_TYPE;

  var Profiler = REACT_PROFILER_TYPE;

  var StrictMode = REACT_STRICT_MODE_TYPE;

  var Suspense = REACT_SUSPENSE_TYPE;

  var hasWarnedAboutDeprecatedIsAsyncMode = false;

  // AsyncMode should be deprecated

  function isAsyncMode(object) {

    {

      if (!hasWarnedAboutDeprecatedIsAsyncMode) {

        hasWarnedAboutDeprecatedIsAsyncMode = true;

        lowPriorityWarning$1(false, 'The ReactIs.isAsyncMode() alias has been deprecated, ' + 'and will be removed in React 17+. Update your code to use ' + 'ReactIs.isConcurrentMode() instead. It has the exact same API.');

      }

    }

    return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;

  }

  function isConcurrentMode(object) {

    return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;

  }

  function isContextConsumer(object) {

    return typeOf(object) === REACT_CONTEXT_TYPE;

  }

  function isContextProvider(object) {

    return typeOf(object) === REACT_PROVIDER_TYPE;

  }

  function isElement(object) {

    return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;

  }

  function isForwardRef(object) {

    return typeOf(object) === REACT_FORWARD_REF_TYPE;

  }

  function isFragment(object) {

    return typeOf(object) === REACT_FRAGMENT_TYPE;

  }

  function isLazy(object) {

    return typeOf(object) === REACT_LAZY_TYPE;

  }

  function isMemo(object) {

    return typeOf(object) === REACT_MEMO_TYPE;

  }

  function isPortal(object) {

    return typeOf(object) === REACT_PORTAL_TYPE;

  }

  function isProfiler(object) {

    return typeOf(object) === REACT_PROFILER_TYPE;

  }

  function isStrictMode(object) {

    return typeOf(object) === REACT_STRICT_MODE_TYPE;

  }

  function isSuspense(object) {

    return typeOf(object) === REACT_SUSPENSE_TYPE;

  }

  exports.typeOf = typeOf;

  exports.AsyncMode = AsyncMode;

  exports.ConcurrentMode = ConcurrentMode;

  exports.ContextConsumer = ContextConsumer;

  exports.ContextProvider = ContextProvider;

  exports.Element = Element;

  exports.ForwardRef = ForwardRef;

  exports.Fragment = Fragment;

  exports.Lazy = Lazy;

  exports.Memo = Memo;

  exports.Portal = Portal;

  exports.Profiler = Profiler;

  exports.StrictMode = StrictMode;

  exports.Suspense = Suspense;

  exports.isValidElementType = isValidElementType;

  exports.isAsyncMode = isAsyncMode;

  exports.isConcurrentMode = isConcurrentMode;

  exports.isContextConsumer = isContextConsumer;

  exports.isContextProvider = isContextProvider;

  exports.isElement = isElement;

  exports.isForwardRef = isForwardRef;

  exports.isFragment = isFragment;

  exports.isLazy = isLazy;

  exports.isMemo = isMemo;

  exports.isPortal = isPortal;

  exports.isProfiler = isProfiler;

  exports.isStrictMode = isStrictMode;

  exports.isSuspense = isSuspense;

    })();

  }

  });

  unwrapExports(reactIs_development);

  var reactIs_development_1 = reactIs_development.typeOf;

  var reactIs_development_2 = reactIs_development.AsyncMode;

  var reactIs_development_3 = reactIs_development.ConcurrentMode;

  var reactIs_development_4 = reactIs_development.ContextConsumer;

  var reactIs_development_5 = reactIs_development.ContextProvider;

  var reactIs_development_6 = reactIs_development.Element;

  var reactIs_development_7 = reactIs_development.ForwardRef;

  var reactIs_development_8 = reactIs_development.Fragment;

  var reactIs_development_9 = reactIs_development.Lazy;

  var reactIs_development_10 = reactIs_development.Memo;

  var reactIs_development_11 = reactIs_development.Portal;

  var reactIs_development_12 = reactIs_development.Profiler;

  var reactIs_development_13 = reactIs_development.StrictMode;

  var reactIs_development_14 = reactIs_development.Suspense;

  var reactIs_development_15 = reactIs_development.isValidElementType;

  var reactIs_development_16 = reactIs_development.isAsyncMode;

  var reactIs_development_17 = reactIs_development.isConcurrentMode;

  var reactIs_development_18 = reactIs_development.isContextConsumer;

  var reactIs_development_19 = reactIs_development.isContextProvider;

  var reactIs_development_20 = reactIs_development.isElement;

  var reactIs_development_21 = reactIs_development.isForwardRef;

  var reactIs_development_22 = reactIs_development.isFragment;

  var reactIs_development_23 = reactIs_development.isLazy;

  var reactIs_development_24 = reactIs_development.isMemo;

  var reactIs_development_25 = reactIs_development.isPortal;

  var reactIs_development_26 = reactIs_development.isProfiler;

  var reactIs_development_27 = reactIs_development.isStrictMode;

  var reactIs_development_28 = reactIs_development.isSuspense;

  var reactIs = createCommonjsModule(function (module) {

  {

    module.exports = reactIs_development;

  }

  });

  var reactIs_1 = reactIs.isValidElementType;

  /*

  object-assign

  (c) Sindre Sorhus

  @license MIT

  */

  /* eslint-disable no-unused-vars */

  var getOwnPropertySymbols = Object.getOwnPropertySymbols;

  var hasOwnProperty = Object.prototype.hasOwnProperty;

  var propIsEnumerable = Object.prototype.propertyIsEnumerable;

  function toObject(val) {

  	if (val === null || val === undefined) {

  		throw new TypeError('Object.assign cannot be called with null or undefined');

  	}

  	return Object(val);

  }

  function shouldUseNative() {

  	try {

  		if (!Object.assign) {

  			return false;

  		}

  		// Detect buggy property enumeration order in older V8 versions.

  		// https://bugs.chromium.org/p/v8/issues/detail?id=4118

  		var test1 = new String('abc');  // eslint-disable-line no-new-wrappers

  		test1[5] = 'de';

  		if (Object.getOwnPropertyNames(test1)[0] === '5') {

  			return false;

  		}

  		// https://bugs.chromium.org/p/v8/issues/detail?id=3056

  		var test2 = {};

  		for (var i = 0; i < 10; i++) {

  			test2['_' + String.fromCharCode(i)] = i;

  		}

  		var order2 = Object.getOwnPropertyNames(test2).map(function (n) {

  			return test2[n];

  		});

  		if (order2.join('') !== '0123456789') {

  			return false;

  		}

  		// https://bugs.chromium.org/p/v8/issues/detail?id=3056

  		var test3 = {};

  		'abcdefghijklmnopqrst'.split('').forEach(function (letter) {

  			test3[letter] = letter;

  		});

  		if (Object.keys(Object.assign({}, test3)).join('') !==

  				'abcdefghijklmnopqrst') {

  			return false;

  		}

  		return true;

  	} catch (err) {

  		// We don't expect any of the above to throw, but better to be safe.

  		return false;

  	}

  }

  var objectAssign = shouldUseNative() ? Object.assign : function (target, source) {

  	var from;

  	var to = toObject(target);

  	var symbols;

  	for (var s = 1; s < arguments.length; s++) {

  		from = Object(arguments[s]);

  		for (var key in from) {

  			if (hasOwnProperty.call(from, key)) {

  				to[key] = from[key];

  			}

  		}

  		if (getOwnPropertySymbols) {

  			symbols = getOwnPropertySymbols(from);

  			for (var i = 0; i < symbols.length; i++) {

  				if (propIsEnumerable.call(from, symbols[i])) {

  					to[symbols[i]] = from[symbols[i]];

  				}

  			}

  		}

  	}

  	return to;

  };

  /**

   * Copyright (c) 2013-present, Facebook, Inc.

   *

   * This source code is licensed under the MIT license found in the

   * LICENSE file in the root directory of this source tree.

   */

  var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';

  var ReactPropTypesSecret_1 = ReactPropTypesSecret;

  var printWarning = function() {};

  {

    var ReactPropTypesSecret$1 = ReactPropTypesSecret_1;

    var loggedTypeFailures = {};

    var has = Function.call.bind(Object.prototype.hasOwnProperty);

    printWarning = function(text) {

      var message = 'Warning: ' + text;

      if (typeof console !== 'undefined') {

        console.error(message);

      }

      try {

        // --- Welcome to debugging React ---

        // This error was thrown as a convenience so that you can use this stack

        // to find the callsite that caused this warning to fire.

        throw new Error(message);

      } catch (x) {}

    };

  }

  /**

   * Assert that the values match with the type specs.

   * Error messages are memorized and will only be shown once.

   *

   * @param {object} typeSpecs Map of name to a ReactPropType

   * @param {object} values Runtime values that need to be type-checked

   * @param {string} location e.g. "prop", "context", "child context"

   * @param {string} componentName Name of the component for error messages.

   * @param {?Function} getStack Returns the component stack.

   * @private

   */

  function checkPropTypes(typeSpecs, values, location, componentName, getStack) {

    {

      for (var typeSpecName in typeSpecs) {

        if (has(typeSpecs, typeSpecName)) {

          var error;

          // Prop type validation may throw. In case they do, we don't want to

          // fail the render phase where it didn't fail before. So we log it.

          // After these have been cleaned up, we'll let them throw.

          try {

            // This is intentionally an invariant that gets caught. It's the same

            // behavior as without this statement except with a better message.

            if (typeof typeSpecs[typeSpecName] !== 'function') {

              var err = Error(

                (componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' +

                'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.'

              );

              err.name = 'Invariant Violation';

              throw err;

            }

            error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret$1);

          } catch (ex) {

            error = ex;

          }

          if (error && !(error instanceof Error)) {

            printWarning(

              (componentName || 'React class') + ': type specification of ' +

              location + ' `' + typeSpecName + '` is invalid; the type checker ' +

              'function must return `null` or an `Error` but returned a ' + typeof error + '. ' +

              'You may have forgotten to pass an argument to the type checker ' +

              'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' +

              'shape all require an argument).'

            );

          }

          if (error instanceof Error && !(error.message in loggedTypeFailures)) {

            // Only monitor this failure once because there tends to be a lot of the

            // same error.

            loggedTypeFailures[error.message] = true;

            var stack = getStack ? getStack() : '';

            printWarning(

              'Failed ' + location + ' type: ' + error.message + (stack != null ? stack : '')

            );

          }

        }

      }

    }

  }

  /**

   * Resets warning cache when testing.

   *

   * @private

   */

  checkPropTypes.resetWarningCache = function() {

    {

      loggedTypeFailures = {};

    }

  };

  var checkPropTypes_1 = checkPropTypes;

  var has$1 = Function.call.bind(Object.prototype.hasOwnProperty);

  var printWarning$1 = function() {};

  {

    printWarning$1 = function(text) {

      var message = 'Warning: ' + text;

      if (typeof console !== 'undefined') {

        console.error(message);

      }

      try {

        // --- Welcome to debugging React ---

        // This error was thrown as a convenience so that you can use this stack

        // to find the callsite that caused this warning to fire.

        throw new Error(message);

      } catch (x) {}

    };

  }

  function emptyFunctionThatReturnsNull() {

    return null;

  }

  var factoryWithTypeCheckers = function(isValidElement, throwOnDirectAccess) {

    /* global Symbol */

    var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;

    var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.

    /**

     * Returns the iterator method function contained on the iterable object.

     *

     * Be sure to invoke the function with the iterable as context:

     *

     *     var iteratorFn = getIteratorFn(myIterable);

     *     if (iteratorFn) {

     *       var iterator = iteratorFn.call(myIterable);

     *       ...

     *     }

     *

     * @param {?object} maybeIterable

     * @return {?function}

     */

    function getIteratorFn(maybeIterable) {

      var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);

      if (typeof iteratorFn === 'function') {

        return iteratorFn;

      }

    }

    /**

     * Collection of methods that allow declaration and validation of props that are

     * supplied to React components. Example usage:

     *

     *   var Props = require('ReactPropTypes');

     *   var MyArticle = React.createClass({

     *     propTypes: {

     *       // An optional string prop named "description".

     *       description: Props.string,

     *

     *       // A required enum prop named "category".

     *       category: Props.oneOf(['News','Photos']).isRequired,

     *

     *       // A prop named "dialog" that requires an instance of Dialog.

     *       dialog: Props.instanceOf(Dialog).isRequired

     *     },

     *     render: function() { ... }

     *   });

     *

     * A more formal specification of how these methods are used:

     *

     *   type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...)

     *   decl := ReactPropTypes.{type}(.isRequired)?

     *

     * Each and every declaration produces a function with the same signature. This

     * allows the creation of custom validation functions. For example:

     *

     *  var MyLink = React.createClass({

     *    propTypes: {

     *      // An optional string or URI prop named "href".

     *      href: function(props, propName, componentName) {

     *        var propValue = props[propName];

     *        if (propValue != null && typeof propValue !== 'string' &&

     *            !(propValue instanceof URI)) {

     *          return new Error(

     *            'Expected a string or an URI for ' + propName + ' in ' +

     *            componentName

     *          );

     *        }

     *      }

     *    },

     *    render: function() {...}

     *  });

     *

     * @internal

     */

    var ANONYMOUS = '<<anonymous>>';

    // Important!

    // Keep this list in sync with production version in `./factoryWithThrowingShims.js`.

    var ReactPropTypes = {

      array: createPrimitiveTypeChecker('array'),

      bool: createPrimitiveTypeChecker('boolean'),

      func: createPrimitiveTypeChecker('function'),

      number: createPrimitiveTypeChecker('number'),

      object: createPrimitiveTypeChecker('object'),

      string: createPrimitiveTypeChecker('string'),

      symbol: createPrimitiveTypeChecker('symbol'),

      any: createAnyTypeChecker(),

      arrayOf: createArrayOfTypeChecker,

      element: createElementTypeChecker(),

      elementType: createElementTypeTypeChecker(),

      instanceOf: createInstanceTypeChecker,

      node: createNodeChecker(),

      objectOf: createObjectOfTypeChecker,

      oneOf: createEnumTypeChecker,

      oneOfType: createUnionTypeChecker,

      shape: createShapeTypeChecker,

      exact: createStrictShapeTypeChecker,

    };

    /**

     * inlined Object.is polyfill to avoid requiring consumers ship their own

     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is

     */

    /*eslint-disable no-self-compare*/

    function is(x, y) {

      // SameValue algorithm

      if (x === y) {

        // Steps 1-5, 7-10

        // Steps 6.b-6.e: +0 != -0

        return x !== 0 || 1 / x === 1 / y;

      } else {

        // Step 6.a: NaN == NaN

        return x !== x && y !== y;

      }

    }

    /*eslint-enable no-self-compare*/

    /**

     * We use an Error-like object for backward compatibility as people may call

     * PropTypes directly and inspect their output. However, we don't use real

     * Errors anymore. We don't inspect their stack anyway, and creating them

     * is prohibitively expensive if they are created too often, such as what

     * happens in oneOfType() for any type before the one that matched.

     */

    function PropTypeError(message) {

      this.message = message;

      this.stack = '';

    }

    // Make `instanceof Error` still work for returned errors.

    PropTypeError.prototype = Error.prototype;

    function createChainableTypeChecker(validate) {

      {

        var manualPropTypeCallCache = {};

        var manualPropTypeWarningCount = 0;

      }

      function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {

        componentName = componentName || ANONYMOUS;

        propFullName = propFullName || propName;

        if (secret !== ReactPropTypesSecret_1) {

          if (throwOnDirectAccess) {

            // New behavior only for users of `prop-types` package

            var err = new Error(

              'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +

              'Use `PropTypes.checkPropTypes()` to call them. ' +

              'Read more at http://fb.me/use-check-prop-types'

            );

            err.name = 'Invariant Violation';

            throw err;

          } else if ( typeof console !== 'undefined') {

            // Old behavior for people using React.PropTypes

            var cacheKey = componentName + ':' + propName;

            if (

              !manualPropTypeCallCache[cacheKey] &&

              // Avoid spamming the console because they are often not actionable except for lib authors

              manualPropTypeWarningCount < 3

            ) {

              printWarning$1(

                'You are manually calling a React.PropTypes validation ' +

                'function for the `' + propFullName + '` prop on `' + componentName  + '`. This is deprecated ' +

                'and will throw in the standalone `prop-types` package. ' +

                'You may be seeing this warning due to a third-party PropTypes ' +

                'library. See https://fb.me/react-warning-dont-call-proptypes ' + 'for details.'

              );

              manualPropTypeCallCache[cacheKey] = true;

              manualPropTypeWarningCount++;

            }

          }

        }

        if (props[propName] == null) {

          if (isRequired) {

            if (props[propName] === null) {

              return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));

            }

            return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.'));

          }

          return null;

        } else {

          return validate(props, propName, componentName, location, propFullName);

        }

      }

      var chainedCheckType = checkType.bind(null, false);

      chainedCheckType.isRequired = checkType.bind(null, true);

      return chainedCheckType;

    }

    function createPrimitiveTypeChecker(expectedType) {

      function validate(props, propName, componentName, location, propFullName, secret) {

        var propValue = props[propName];

        var propType = getPropType(propValue);

        if (propType !== expectedType) {

          // `propValue` being instance of, say, date/regexp, pass the 'object'

          // check, but we can offer a more precise error message here rather than

          // 'of type `object`'.

          var preciseType = getPreciseType(propValue);

          return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'));

        }

        return null;

      }

      return createChainableTypeChecker(validate);

    }

    function createAnyTypeChecker() {

      return createChainableTypeChecker(emptyFunctionThatReturnsNull);

    }

    function createArrayOfTypeChecker(typeChecker) {

      function validate(props, propName, componentName, location, propFullName) {

        if (typeof typeChecker !== 'function') {

          return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside arrayOf.');

        }

        var propValue = props[propName];

        if (!Array.isArray(propValue)) {

          var propType = getPropType(propValue);

          return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an array.'));

        }

        for (var i = 0; i < propValue.length; i++) {

          var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']', ReactPropTypesSecret_1);

          if (error instanceof Error) {

            return error;

          }

        }

        return null;

      }

      return createChainableTypeChecker(validate);

    }

    function createElementTypeChecker() {

      function validate(props, propName, componentName, location, propFullName) {

        var propValue = props[propName];

        if (!isValidElement(propValue)) {

          var propType = getPropType(propValue);

          return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement.'));

        }

        return null;

      }

      return createChainableTypeChecker(validate);

    }

    function createElementTypeTypeChecker() {

      function validate(props, propName, componentName, location, propFullName) {

        var propValue = props[propName];

        if (!reactIs.isValidElementType(propValue)) {

          var propType = getPropType(propValue);

          return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement type.'));

        }

        return null;

      }

      return createChainableTypeChecker(validate);

    }

    function createInstanceTypeChecker(expectedClass) {

      function validate(props, propName, componentName, location, propFullName) {

        if (!(props[propName] instanceof expectedClass)) {

          var expectedClassName = expectedClass.name || ANONYMOUS;

          var actualClassName = getClassName(props[propName]);

          return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.'));

        }

        return null;

      }

      return createChainableTypeChecker(validate);

    }

    function createEnumTypeChecker(expectedValues) {

      if (!Array.isArray(expectedValues)) {

        {

          if (arguments.length > 1) {

            printWarning$1(

              'Invalid arguments supplied to oneOf, expected an array, got ' + arguments.length + ' arguments. ' +

              'A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z]).'

            );

          } else {

            printWarning$1('Invalid argument supplied to oneOf, expected an array.');

          }

        }

        return emptyFunctionThatReturnsNull;

      }

      function validate(props, propName, componentName, location, propFullName) {

        var propValue = props[propName];

        for (var i = 0; i < expectedValues.length; i++) {

          if (is(propValue, expectedValues[i])) {

            return null;

          }

        }

        var valuesString = JSON.stringify(expectedValues, function replacer(key, value) {

          var type = getPreciseType(value);

          if (type === 'symbol') {

            return String(value);

          }

          return value;

        });

        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + String(propValue) + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));

      }

      return createChainableTypeChecker(validate);

    }

    function createObjectOfTypeChecker(typeChecker) {

      function validate(props, propName, componentName, location, propFullName) {

        if (typeof typeChecker !== 'function') {

          return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.');

        }

        var propValue = props[propName];

        var propType = getPropType(propValue);

        if (propType !== 'object') {

          return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.'));

        }

        for (var key in propValue) {

          if (has$1(propValue, key)) {

            var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret_1);

            if (error instanceof Error) {

              return error;

            }

          }

        }

        return null;

      }

      return createChainableTypeChecker(validate);

    }

    function createUnionTypeChecker(arrayOfTypeCheckers) {

      if (!Array.isArray(arrayOfTypeCheckers)) {

         printWarning$1('Invalid argument supplied to oneOfType, expected an instance of array.') ;

        return emptyFunctionThatReturnsNull;

      }

      for (var i = 0; i < arrayOfTypeCheckers.length; i++) {

        var checker = arrayOfTypeCheckers[i];

        if (typeof checker !== 'function') {

          printWarning$1(

            'Invalid argument supplied to oneOfType. Expected an array of check functions, but ' +

            'received ' + getPostfixForTypeWarning(checker) + ' at index ' + i + '.'

          );

          return emptyFunctionThatReturnsNull;

        }

      }

      function validate(props, propName, componentName, location, propFullName) {

        for (var i = 0; i < arrayOfTypeCheckers.length; i++) {

          var checker = arrayOfTypeCheckers[i];

          if (checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret_1) == null) {

            return null;

          }

        }

        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`.'));

      }

      return createChainableTypeChecker(validate);

    }

    function createNodeChecker() {

      function validate(props, propName, componentName, location, propFullName) {

        if (!isNode(props[propName])) {

          return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.'));

        }

        return null;

      }

      return createChainableTypeChecker(validate);

    }

    function createShapeTypeChecker(shapeTypes) {

      function validate(props, propName, componentName, location, propFullName) {

        var propValue = props[propName];

        var propType = getPropType(propValue);

        if (propType !== 'object') {

          return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));

        }

        for (var key in shapeTypes) {

          var checker = shapeTypes[key];

          if (!checker) {

            continue;

          }

          var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret_1);

          if (error) {

            return error;

          }

        }

        return null;

      }

      return createChainableTypeChecker(validate);

    }

    function createStrictShapeTypeChecker(shapeTypes) {

      function validate(props, propName, componentName, location, propFullName) {

        var propValue = props[propName];

        var propType = getPropType(propValue);

        if (propType !== 'object') {

          return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));

        }

        // We need to check all keys in case some are required but missing from

        // props.

        var allKeys = objectAssign({}, props[propName], shapeTypes);

        for (var key in allKeys) {

          var checker = shapeTypes[key];

          if (!checker) {

            return new PropTypeError(

              'Invalid ' + location + ' `' + propFullName + '` key `' + key + '` supplied to `' + componentName + '`.' +

              '\nBad object: ' + JSON.stringify(props[propName], null, '  ') +

              '\nValid keys: ' +  JSON.stringify(Object.keys(shapeTypes), null, '  ')

            );

          }

          var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret_1);

          if (error) {

            return error;

          }

        }

        return null;

      }

      return createChainableTypeChecker(validate);

    }

    function isNode(propValue) {

      switch (typeof propValue) {

        case 'number':

        case 'string':

        case 'undefined':

          return true;

        case 'boolean':

          return !propValue;

        case 'object':

          if (Array.isArray(propValue)) {

            return propValue.every(isNode);

          }

          if (propValue === null || isValidElement(propValue)) {

            return true;

          }

          var iteratorFn = getIteratorFn(propValue);

          if (iteratorFn) {

            var iterator = iteratorFn.call(propValue);

            var step;

            if (iteratorFn !== propValue.entries) {

              while (!(step = iterator.next()).done) {

                if (!isNode(step.value)) {

                  return false;

                }

              }

            } else {

              // Iterator will provide entry [k,v] tuples rather than values.

              while (!(step = iterator.next()).done) {

                var entry = step.value;

                if (entry) {

                  if (!isNode(entry[1])) {

                    return false;

                  }

                }

              }

            }

          } else {

            return false;

          }

          return true;

        default:

          return false;

      }

    }

    function isSymbol(propType, propValue) {

      // Native Symbol.

      if (propType === 'symbol') {

        return true;

      }

      // falsy value can't be a Symbol

      if (!propValue) {

        return false;

      }

      // 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'

      if (propValue['@@toStringTag'] === 'Symbol') {

        return true;

      }

      // Fallback for non-spec compliant Symbols which are polyfilled.

      if (typeof Symbol === 'function' && propValue instanceof Symbol) {

        return true;

      }

      return false;

    }

    // Equivalent of `typeof` but with special handling for array and regexp.

    function getPropType(propValue) {

      var propType = typeof propValue;

      if (Array.isArray(propValue)) {

        return 'array';

      }

      if (propValue instanceof RegExp) {

        // Old webkits (at least until Android 4.0) return 'function' rather than

        // 'object' for typeof a RegExp. We'll normalize this here so that /bla/

        // passes PropTypes.object.

        return 'object';

      }

      if (isSymbol(propType, propValue)) {

        return 'symbol';

      }

      return propType;

    }

    // This handles more types than `getPropType`. Only used for error messages.

    // See `createPrimitiveTypeChecker`.

    function getPreciseType(propValue) {

      if (typeof propValue === 'undefined' || propValue === null) {

        return '' + propValue;

      }

      var propType = getPropType(propValue);

      if (propType === 'object') {

        if (propValue instanceof Date) {

          return 'date';

        } else if (propValue instanceof RegExp) {

          return 'regexp';

        }

      }

      return propType;

    }

    // Returns a string that is postfixed to a warning about an invalid type.

    // For example, "undefined" or "of type array"

    function getPostfixForTypeWarning(value) {

      var type = getPreciseType(value);

      switch (type) {

        case 'array':

        case 'object':

          return 'an ' + type;

        case 'boolean':

        case 'date':

        case 'regexp':

          return 'a ' + type;

        default:

          return type;

      }

    }

    // Returns class name of the object, if any.

    function getClassName(propValue) {

      if (!propValue.constructor || !propValue.constructor.name) {

        return ANONYMOUS;

      }

      return propValue.constructor.name;

    }

    ReactPropTypes.checkPropTypes = checkPropTypes_1;

    ReactPropTypes.resetWarningCache = checkPropTypes_1.resetWarningCache;

    ReactPropTypes.PropTypes = ReactPropTypes;

    return ReactPropTypes;

  };

  var propTypes = createCommonjsModule(function (module) {

  /**

   * Copyright (c) 2013-present, Facebook, Inc.

   *

   * This source code is licensed under the MIT license found in the

   * LICENSE file in the root directory of this source tree.

   */

  {

    var ReactIs = reactIs;

    // By explicitly using `prop-types` you are opting into new development behavior.

    // http://fb.me/prop-types-in-prod