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

 */

(function (global, factory) {

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

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

  }

  var hasOwnProperty = Object.prototype.hasOwnProperty;

  };

  /**

   * 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 = {

  };

  /**

   * 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

  };

    {

    }

  }

  {

    ReactDebugCurrentFrame.getCurrentStack = null;

    ReactDebugCurrentFrame.getStackAddendum = function () {

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

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

  };

  {

  }

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

    }

  }

  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

     */

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

      warnNoop(publicInstance, 'setState');

    }

  };

  var emptyObject = {};

  {

    Object.freeze(emptyObject);

  }

  /**

   * Base class helpers for the updating state of a component.

   */

  function Component(props, context, updater) {

    this.props = props;

    this.context = context; // If a component has string refs, we will assign a different object later.

    this.refs = emptyObject; // We initialize the default updater but the real one gets injected by the

    // renderer.

    this.updater = updater || ReactNoopUpdateQueue;

  }

  Component.prototype.isReactComponent = {};

  /**

   * Sets a subset of the state. Always use this 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.

   *

   * There is no guarantee that calls to `setState` will run synchronously,

   * as they may eventually be batched together.  You can provide an optional

   * callback that will be executed when the call to setState is actually

   * completed.

   *

   * When a function is provided to setState, it will be called at some point in

   * the future (not synchronously). It will be called with the up to date

   * component arguments (state, props, context). These values can be different

   * from this.* because your function may be called after receiveProps but before

   * shouldComponentUpdate, and this new state, props, and context will not yet be

   * assigned to this.

   *

   * @param {object|function} partialState Next partial state or function to

   *        produce next partial state to be merged with current state.

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

   * @final

   * @protected

   */

  Component.prototype.setState = function (partialState, callback) {

    if (!(typeof partialState === 'object' || typeof partialState === 'function' || partialState == null)) {

      {

        throw Error( "setState(...): takes an object of state variables to update or a function which returns an object of state variables." );

      }

    }

    this.updater.enqueueSetState(this, partialState, callback, 'setState');

  };

  /**

   * 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 {?function} callback Called after update is complete.

   * @final

   * @protected

   */

  Component.prototype.forceUpdate = function (callback) {

    this.updater.enqueueForceUpdate(this, callback, 'forceUpdate');

  };

  /**

   * Deprecated APIs. These APIs used to exist on classic React classes but since

   * we would like to deprecate them, we're not going to move them over to this

   * modern base class. Instead, we define a getter that warns if it's accessed.

   */

  {

    var deprecatedAPIs = {

      isMounted: ['isMounted', 'Instead, make sure to clean up subscriptions and pending requests in ' + 'componentWillUnmount to prevent memory leaks.'],

      replaceState: ['replaceState', 'Refactor your code to use setState instead (see ' + 'https://github.com/facebook/react/issues/3236).']

    };

    var defineDeprecationWarning = function (methodName, info) {

      Object.defineProperty(Component.prototype, methodName, {

        get: function () {

          warn('%s(...) is deprecated in plain JavaScript React classes. %s', info[0], info[1]);

          return undefined;

        }

      });

    };

    for (var fnName in deprecatedAPIs) {

      if (deprecatedAPIs.hasOwnProperty(fnName)) {

        defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);

      }

    }

  }

  function ComponentDummy() {}

  ComponentDummy.prototype = Component.prototype;

  /**

   * Convenience component with default shallow equality check for sCU.

   */

  function PureComponent(props, context, updater) {

    this.props = props;

    this.context = context; // If a component has string refs, we will assign a different object later.

    this.refs = emptyObject;

    this.updater = updater || ReactNoopUpdateQueue;

  }

  var pureComponentPrototype = PureComponent.prototype = new ComponentDummy();

  pureComponentPrototype.constructor = PureComponent; // Avoid an extra prototype jump for these methods.

  pureComponentPrototype.isPureReactComponent = true;

  // an immutable object with a single mutable value

  function createRef() {

    var refObject = {

      current: null

    };

    {

      Object.seal(refObject);

    }

    return refObject;

  }