/** @license React v16.13.1

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

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

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

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

  var ReactVersion = '16.13.1';

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

  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_BLOCK_TYPE = hasSymbol ? Symbol.for('react.block') : 0xead9;

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

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

  var REACT_SCOPE_TYPE = hasSymbol ? Symbol.for('react.scope') : 0xead7;

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

  var FAUX_ITERATOR_SYMBOL = '@@iterator';

  function getIteratorFn(maybeIterable) {

    if (maybeIterable === null || typeof maybeIterable !== 'object') {

      return null;

    }

    var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];

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

      return maybeIterator;

    }

  /*

  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;

  };

  /**

   * Keeps track of the current dispatcher.

   */

  var ReactCurrentDispatcher = {

    /**

     * @internal

     * @type {ReactComponent}

     */

    current: null

  };

  /**

   * Keeps track of the current batch's configuration such as how long an update

   * should suspend for if it needs to.

   */

  var ReactCurrentBatchConfig = {

    suspense: null

  };

  /**

   * Keeps track of the current owner.

   *

   * The current owner is the component who should own any components that are

   * currently being constructed.

   */

  var ReactCurrentOwner = {

    /**

     * @internal

     * @type {ReactComponent}

     */

    current: null

  };

  var BEFORE_SLASH_RE = /^(.*)[\\\/]/;

  function describeComponentFrame (name, source, ownerName) {

    var sourceInfo = '';

    if (source) {

      var path = source.fileName;

      var fileName = path.replace(BEFORE_SLASH_RE, '');

      {

        // In DEV, include code for a common special case:

        // prefer "folder/index.js" instead of just "index.js".

        if (/^index\./.test(fileName)) {

          var match = path.match(BEFORE_SLASH_RE);

          if (match) {

            var pathBeforeSlash = match[1];

            if (pathBeforeSlash) {

              var folderName = pathBeforeSlash.replace(BEFORE_SLASH_RE, '');

              fileName = folderName + '/' + fileName;

            }

          }

        }

      }

      sourceInfo = ' (at ' + fileName + ':' + source.lineNumber + ')';

    } else if (ownerName) {

      sourceInfo = ' (created by ' + ownerName + ')';

    }

    return '\n    in ' + (name || 'Unknown') + sourceInfo;

  }

  var Resolved = 1;

  function refineResolvedLazyComponent(lazyComponent) {

    return lazyComponent._status === Resolved ? lazyComponent._result : null;

  }

  function getWrappedName(outerType, innerType, wrapperName) {

    var functionName = innerType.displayName || innerType.name || '';

    return outerType.displayName || (functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName);

  function getComponentName(type) {

    if (type == null) {

      // Host root, text node or just invalid type.

      return null;

    }

    {

      if (typeof type.tag === 'number') {

        error('Received an unexpected object in getComponentName(). ' + 'This is likely a bug in React. Please file an issue.');

      }

    }

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

      return type.displayName || type.name || null;

    }

    if (typeof type === 'string') {

      return type;

    }

    switch (type) {

      case REACT_FRAGMENT_TYPE:

        return 'Fragment';

      case REACT_PORTAL_TYPE:

        return 'Portal';

      case REACT_PROFILER_TYPE:

        return "Profiler";

      case REACT_STRICT_MODE_TYPE:

        return 'StrictMode';

      case REACT_SUSPENSE_TYPE:

        return 'Suspense';

      case REACT_SUSPENSE_LIST_TYPE:

        return 'SuspenseList';

    }

    if (typeof type === 'object') {

      switch (type.$$typeof) {

        case REACT_CONTEXT_TYPE:

          return 'Context.Consumer';

        case REACT_PROVIDER_TYPE:

          return 'Context.Provider';

        case REACT_FORWARD_REF_TYPE:

          return getWrappedName(type, type.render, 'ForwardRef');

        case REACT_MEMO_TYPE:

          return getComponentName(type.type);

        case REACT_BLOCK_TYPE:

          return getComponentName(type.render);

        case REACT_LAZY_TYPE:

          {

            var thenable = type;

            var resolvedThenable = refineResolvedLazyComponent(thenable);

            if (resolvedThenable) {

              return getComponentName(resolvedThenable);

            }

            break;

          }

      }

    }

    return null;

  }

  var ReactDebugCurrentFrame = {};

  var currentlyValidatingElement = null;

  function setCurrentlyValidatingElement(element) {

    {

      currentlyValidatingElement = element;

  }

  {

    // Stack implementation injected by the current renderer.

    ReactDebugCurrentFrame.getCurrentStack = null;

    ReactDebugCurrentFrame.getStackAddendum = function () {

      var stack = ''; // Add an extra top frame while an element is being validated

      if (currentlyValidatingElement) {

        var name = getComponentName(currentlyValidatingElement.type);

        var owner = currentlyValidatingElement._owner;

        stack += describeComponentFrame(name, currentlyValidatingElement._source, owner && getComponentName(owner.type));

      } // Delegate to the injected renderer-specific implementation

      var impl = ReactDebugCurrentFrame.getCurrentStack;

      if (impl) {

        stack += impl() || '';

      }

      return stack;

    };

  }

  /**

   * Used by act() to track whether you're inside an act() scope.

   */

  var IsSomeRendererActing = {

    current: false

  };

  var ReactSharedInternals = {

    ReactCurrentDispatcher: ReactCurrentDispatcher,

    ReactCurrentBatchConfig: ReactCurrentBatchConfig,

    ReactCurrentOwner: ReactCurrentOwner,

    IsSomeRendererActing: IsSomeRendererActing,

    // Used by renderers to avoid bundling object-assign twice in UMD bundles:

    assign: objectAssign

  };

  {

    objectAssign(ReactSharedInternals, {

      // These should not be included in production.

      ReactDebugCurrentFrame: ReactDebugCurrentFrame,

      // Shim for React DOM 16.0.0 which still destructured (but not used) this.

      // TODO: remove in React 17.0.

      ReactComponentTreeHook: {}

  }

  // by calls to these methods by a Babel plugin.

  //

  // In PROD (or in packages without access to React internals),

  // they are left as they are instead.

  function warn(format) {

    {

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

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

      }

      printWarning('warn', format, args);

    }

  }

  function error(format) {

    {

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

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

      }

      printWarning('error', format, args);

  }

  function printWarning(level, format, args) {

    // When changing this logic, you might want to also

    // update consoleWithStackDev.www.js as well.

    {

      var hasExistingStack = args.length > 0 && typeof args[args.length - 1] === 'string' && args[args.length - 1].indexOf('\n    in') === 0;

      if (!hasExistingStack) {

        var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;

        var stack = ReactDebugCurrentFrame.getStackAddendum();

        if (stack !== '') {

          format += '%s';

          args = args.concat([stack]);

        }

      }

      var argsWithFormat = args.map(function (item) {

        return '' + item;

      }); // Careful: RN currently depends on this prefix

      argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it

      // breaks IE9: https://github.com/facebook/react/issues/13610

      // eslint-disable-next-line react-internal/no-production-logging

      Function.prototype.apply.call(console[level], console, argsWithFormat);

      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.

        var argIndex = 0;

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

          return args[argIndex++];

        });

        throw new Error(message);

      } catch (x) {}

    }

  }

  var didWarnStateUpdateForUnmountedComponent = {};

  function warnNoop(publicInstance, callerName) {

    {

      var _constructor = publicInstance.constructor;

      var componentName = _constructor && (_constructor.displayName || _constructor.name) || 'ReactClass';

      var warningKey = componentName + "." + callerName;

      if (didWarnStateUpdateForUnmountedComponent[warningKey]) {

        return;

      }

      error("Can't call %s on a component that is not yet mounted. " + 'This is a no-op, but it might indicate a bug in your application. ' + 'Instead, assign to `this.state` directly or define a `state = {};` ' + 'class property with the desired state in the %s component.', callerName, componentName);

      didWarnStateUpdateForUnmountedComponent[warningKey] = true;

  }

  /**

   * This is the abstract API for an update queue.

   */

  var ReactNoopUpdateQueue = {

    /**

     * Checks whether or not this composite component is mounted.

     * @param {ReactClass} publicInstance The instance we want to test.

     * @return {boolean} True if mounted, false otherwise.

     * @protected

     * @final

     */

    isMounted: function (publicInstance) {

      return false;

    },

    /**

     * Forces an update. This should only be invoked when it is known with

     * certainty that we are **not** in a DOM transaction.

     *

     * You may want to call this when you know that some deeper aspect of the

     * component's state has changed but `setState` was not called.

     *

     * This will not invoke `shouldComponentUpdate`, but it will invoke

     * `componentWillUpdate` and `componentDidUpdate`.

     *

     * @param {ReactClass} publicInstance The instance that should rerender.

     * @param {?function} callback Called after component is updated.

     * @param {?string} callerName name of the calling function in the public API.

     * @internal

     */

    enqueueForceUpdate: function (publicInstance, callback, callerName) {

      warnNoop(publicInstance, 'forceUpdate');

    },

    /**

     * Replaces all of the state. Always use this or `setState` to mutate state.

     * You should treat `this.state` as immutable.

     *

     * There is no guarantee that `this.state` will be immediately updated, so

     * accessing `this.state` after calling this method may return the old value.

     *

     * @param {ReactClass} publicInstance The instance that should rerender.

     * @param {object} completeState Next state.

     * @param {?function} callback Called after component is updated.

     * @param {?string} callerName name of the calling function in the public API.

     * @internal

     */

    enqueueReplaceState: function (publicInstance, completeState, callback, callerName) {

      warnNoop(publicInstance, 'replaceState');

    },

    /**

     * Sets a subset of the state. This only exists because _pendingState is

     * internal. This provides a merging strategy that is not available to deep

     * properties which is confusing. TODO: Expose pendingState or don't use it

     * during the merge.

     *

     * @param {ReactClass} publicInstance The instance that should rerender.

     * @param {object} partialState Next partial state to be merged with state.

     * @param {?function} callback Called after component is updated.

     * @param {?string} Name of the calling function in the public API.

     * @internal