/** @license React v16.8.4

 * react.development.js

 *

 * Copyright (c) Facebook, Inc. and its affiliates.

 *

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

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

 */

'use strict';

(function (global, factory) {

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

	typeof define === 'function' && define.amd ? define(factory) :

	(global.React = factory());

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

// TODO: this is special because it gets imported during build.

var ReactVersion = '16.8.4';

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

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_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3;

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

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;

  }

  return null;

}

/*

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;

};

/**

 * Use invariant() to assert state which your program assumes to be true.

 *

 * Provide sprintf-style format (only %s is supported) and arguments

 * to provide information about what broke and what you were

 * expecting.

 *

 * The invariant message will be stripped in production, but the invariant

 * will remain to ensure logic does not differ in production.

 */

var validateFormat = function () {};

{

  validateFormat = function (format) {

    if (format === undefined) {

      throw new Error('invariant requires an error message argument');

    }

  };

}

function invariant(condition, format, a, b, c, d, e, f) {

  validateFormat(format);

  if (!condition) {

    var error = void 0;

    if (format === undefined) {

      error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');

    } else {

      var args = [a, b, c, d, e, f];

      var argIndex = 0;

      error = new Error(format.replace(/%s/g, function () {

        return args[argIndex++];

      }));

      error.name = 'Invariant Violation';

    }

    error.framesToPop = 1; // we don't care about invariant's own frame

    throw error;

  }

}

// Relying on the `invariant()` implementation lets us

// preserve the format and params in the www builds.

/**

 * 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;

/**

 * 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 warningWithoutStack = function () {};

{

  warningWithoutStack = function (condition, format) {

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

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

    }

    if (format === undefined) {

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

    }

    if (args.length > 8) {

      // Check before the condition to catch violations early.

      throw new Error('warningWithoutStack() currently supports at most 8 arguments.');

    }

    if (condition) {

      return;

    }

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

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

        return '' + item;

      });

      argsWithFormat.unshift('Warning: ' + format);

      // We intentionally don't use spread (or .apply) directly because it

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

      Function.prototype.apply.call(console.error, 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 warningWithoutStack$1 = warningWithoutStack;

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;

    }

    warningWithoutStack$1(false, "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

   */

  enqueueSetState: function (publicInstance, partialState, callback, callerName) {

    warnNoop(publicInstance, 'setState');

  }