{"dependencies":[{"name":"object-assign","loc":{"line":18,"column":22}},{"name":"fbjs/lib/emptyObject","loc":{"line":19,"column":26}},{"name":"fbjs/lib/invariant","loc":{"line":20,"column":24}},{"name":"fbjs/lib/warning","loc":{"line":21,"column":22}},{"name":"fbjs/lib/emptyFunction","loc":{"line":22,"column":28}},{"name":"prop-types/checkPropTypes","loc":{"line":23,"column":29}}],"generated":{"js":"/** @license React v16.2.0\n * react.development.js\n *\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nif (\"development\" !== \"production\") {\n  (function () {\n    'use strict';\n\n    var _assign = require('object-assign');\n    var emptyObject = require('fbjs/lib/emptyObject');\n    var invariant = require('fbjs/lib/invariant');\n    var warning = require('fbjs/lib/warning');\n    var emptyFunction = require('fbjs/lib/emptyFunction');\n    var checkPropTypes = require('prop-types/checkPropTypes');\n\n    // TODO: this is special because it gets imported during build.\n\n    var ReactVersion = '16.2.0';\n\n    // The Symbol used to tag the ReactElement-like types. If there is no native Symbol\n    // nor polyfill, then a plain number is used for performance.\n    var hasSymbol = typeof Symbol === 'function' && Symbol['for'];\n\n    var REACT_ELEMENT_TYPE = hasSymbol ? Symbol['for']('react.element') : 0xeac7;\n    var REACT_CALL_TYPE = hasSymbol ? Symbol['for']('react.call') : 0xeac8;\n    var REACT_RETURN_TYPE = hasSymbol ? Symbol['for']('react.return') : 0xeac9;\n    var REACT_PORTAL_TYPE = hasSymbol ? Symbol['for']('react.portal') : 0xeaca;\n    var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol['for']('react.fragment') : 0xeacb;\n\n    var MAYBE_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;\n    var FAUX_ITERATOR_SYMBOL = '@@iterator';\n\n    function getIteratorFn(maybeIterable) {\n      if (maybeIterable === null || typeof maybeIterable === 'undefined') {\n        return null;\n      }\n      var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];\n      if (typeof maybeIterator === 'function') {\n        return maybeIterator;\n      }\n      return null;\n    }\n\n    /**\n     * WARNING: DO NOT manually require this module.\n     * This is a replacement for `invariant(...)` used by the error code system\n     * and will _only_ be required by the corresponding babel pass.\n     * It always throws.\n     */\n\n    /**\n     * Forked from fbjs/warning:\n     * https://github.com/facebook/fbjs/blob/e66ba20ad5be433eb54423f2b097d829324d9de6/packages/fbjs/src/__forks__/warning.js\n     *\n     * Only change is we use console.warn instead of console.error,\n     * and do nothing when 'console' is not supported.\n     * This really simplifies the code.\n     * ---\n     * Similar to invariant but only logs a warning if the condition is not met.\n     * This can be used to log issues in development environments in critical\n     * paths. Removing the logging code for production environments will keep the\n     * same logic and follow the same code paths.\n     */\n\n    var lowPriorityWarning = function () {};\n\n    {\n      var printWarning = function (format) {\n        for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n          args[_key - 1] = arguments[_key];\n        }\n\n        var argIndex = 0;\n        var message = 'Warning: ' + format.replace(/%s/g, function () {\n          return args[argIndex++];\n        });\n        if (typeof console !== 'undefined') {\n          console.warn(message);\n        }\n        try {\n          // --- Welcome to debugging React ---\n          // This error was thrown as a convenience so that you can use this stack\n          // to find the callsite that caused this warning to fire.\n          throw new Error(message);\n        } catch (x) {}\n      };\n\n      lowPriorityWarning = function (condition, format) {\n        if (format === undefined) {\n          throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument');\n        }\n        if (!condition) {\n          for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {\n            args[_key2 - 2] = arguments[_key2];\n          }\n\n          printWarning.apply(undefined, [format].concat(args));\n        }\n      };\n    }\n\n    var lowPriorityWarning$1 = lowPriorityWarning;\n\n    var didWarnStateUpdateForUnmountedComponent = {};\n\n    function warnNoop(publicInstance, callerName) {\n      {\n        var constructor = publicInstance.constructor;\n        var componentName = constructor && (constructor.displayName || constructor.name) || 'ReactClass';\n        var warningKey = componentName + '.' + callerName;\n        if (didWarnStateUpdateForUnmountedComponent[warningKey]) {\n          return;\n        }\n        warning(false, '%s(...): Can only update a mounted or mounting component. ' + 'This usually means you called %s() on an unmounted component. ' + 'This is a no-op.\\n\\nPlease check the code for the %s component.', callerName, callerName, componentName);\n        didWarnStateUpdateForUnmountedComponent[warningKey] = true;\n      }\n    }\n\n    /**\n     * This is the abstract API for an update queue.\n     */\n    var ReactNoopUpdateQueue = {\n      /**\n       * Checks whether or not this composite component is mounted.\n       * @param {ReactClass} publicInstance The instance we want to test.\n       * @return {boolean} True if mounted, false otherwise.\n       * @protected\n       * @final\n       */\n      isMounted: function (publicInstance) {\n        return false;\n      },\n\n      /**\n       * Forces an update. This should only be invoked when it is known with\n       * certainty that we are **not** in a DOM transaction.\n       *\n       * You may want to call this when you know that some deeper aspect of the\n       * component's state has changed but `setState` was not called.\n       *\n       * This will not invoke `shouldComponentUpdate`, but it will invoke\n       * `componentWillUpdate` and `componentDidUpdate`.\n       *\n       * @param {ReactClass} publicInstance The instance that should rerender.\n       * @param {?function} callback Called after component is updated.\n       * @param {?string} callerName name of the calling function in the public API.\n       * @internal\n       */\n      enqueueForceUpdate: function (publicInstance, callback, callerName) {\n        warnNoop(publicInstance, 'forceUpdate');\n      },\n\n      /**\n       * Replaces all of the state. Always use this or `setState` to mutate state.\n       * You should treat `this.state` as immutable.\n       *\n       * There is no guarantee that `this.state` will be immediately updated, so\n       * accessing `this.state` after calling this method may return the old value.\n       *\n       * @param {ReactClass} publicInstance The instance that should rerender.\n       * @param {object} completeState Next state.\n       * @param {?function} callback Called after component is updated.\n       * @param {?string} callerName name of the calling function in the public API.\n       * @internal\n       */\n      enqueueReplaceState: function (publicInstance, completeState, callback, callerName) {\n        warnNoop(publicInstance, 'replaceState');\n      },\n\n      /**\n       * Sets a subset of the state. This only exists because _pendingState is\n       * internal. This provides a merging strategy that is not available to deep\n       * properties which is confusing. TODO: Expose pendingState or don't use it\n       * during the merge.\n       *\n       * @param {ReactClass} publicInstance The instance that should rerender.\n       * @param {object} partialState Next partial state to be merged with state.\n       * @param {?function} callback Called after component is updated.\n       * @param {?string} Name of the calling function in the public API.\n       * @internal\n       */\n      enqueueSetState: function (publicInstance, partialState, callback, callerName) {\n        warnNoop(publicInstance, 'setState');\n      }\n    };\n\n    /**\n     * Base class helpers for the updating state of a component.\n     */\n    function Component(props, context, updater) {\n      this.props = props;\n      this.context = context;\n      this.refs = emptyObject;\n      // We initialize the default updater but the real one gets injected by the\n      // renderer.\n      this.updater = updater || ReactNoopUpdateQueue;\n    }\n\n    Component.prototype.isReactComponent = {};\n\n    /**\n     * Sets a subset of the state. Always use this to mutate\n     * state. You should treat `this.state` as immutable.\n     *\n     * There is no guarantee that `this.state` will be immediately updated, so\n     * accessing `this.state` after calling this method may return the old value.\n     *\n     * There is no guarantee that calls to `setState` will run synchronously,\n     * as they may eventually be batched together.  You can provide an optional\n     * callback that will be executed when the call to setState is actually\n     * completed.\n     *\n     * When a function is provided to setState, it will be called at some point in\n     * the future (not synchronously). It will be called with the up to date\n     * component arguments (state, props, context). These values can be different\n     * from this.* because your function may be called after receiveProps but before\n     * shouldComponentUpdate, and this new state, props, and context will not yet be\n     * assigned to this.\n     *\n     * @param {object|function} partialState Next partial state or function to\n     *        produce next partial state to be merged with current state.\n     * @param {?function} callback Called after state is updated.\n     * @final\n     * @protected\n     */\n    Component.prototype.setState = function (partialState, callback) {\n      !(typeof partialState === 'object' || typeof partialState === 'function' || partialState == null) ? invariant(false, 'setState(...): takes an object of state variables to update or a function which returns an object of state variables.') : void 0;\n      this.updater.enqueueSetState(this, partialState, callback, 'setState');\n    };\n\n    /**\n     * Forces an update. This should only be invoked when it is known with\n     * certainty that we are **not** in a DOM transaction.\n     *\n     * You may want to call this when you know that some deeper aspect of the\n     * component's state has changed but `setState` was not called.\n     *\n     * This will not invoke `shouldComponentUpdate`, but it will invoke\n     * `componentWillUpdate` and `componentDidUpdate`.\n     *\n     * @param {?function} callback Called after update is complete.\n     * @final\n     * @protected\n     */\n    Component.prototype.forceUpdate = function (callback) {\n      this.updater.enqueueForceUpdate(this, callback, 'forceUpdate');\n    };\n\n    /**\n     * Deprecated APIs. These APIs used to exist on classic React classes but since\n     * we would like to deprecate them, we're not going to move them over to this\n     * modern base class. Instead, we define a getter that warns if it's accessed.\n     */\n    {\n      var deprecatedAPIs = {\n        isMounted: ['isMounted', 'Instead, make sure to clean up subscriptions and pending requests in ' + 'componentWillUnmount to prevent memory leaks.'],\n        replaceState: ['replaceState', 'Refactor your code to use setState instead (see ' + 'https://github.com/facebook/react/issues/3236).']\n      };\n      var defineDeprecationWarning = function (methodName, info) {\n        Object.defineProperty(Component.prototype, methodName, {\n          get: function () {\n            lowPriorityWarning$1(false, '%s(...) is deprecated in plain JavaScript React classes. %s', info[0], info[1]);\n            return undefined;\n          }\n        });\n      };\n      for (var fnName in deprecatedAPIs) {\n        if (deprecatedAPIs.hasOwnProperty(fnName)) {\n          defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);\n        }\n      }\n    }\n\n    /**\n     * Base class helpers for the updating state of a component.\n     */\n    function PureComponent(props, context, updater) {\n      // Duplicated from Component.\n      this.props = props;\n      this.context = context;\n      this.refs = emptyObject;\n      // We initialize the default updater but the real one gets injected by the\n      // renderer.\n      this.updater = updater || ReactNoopUpdateQueue;\n    }\n\n    function ComponentDummy() {}\n    ComponentDummy.prototype = Component.prototype;\n    var pureComponentPrototype = PureComponent.prototype = new ComponentDummy();\n    pureComponentPrototype.constructor = PureComponent;\n    // Avoid an extra prototype jump for these methods.\n    _assign(pureComponentPrototype, Component.prototype);\n    pureComponentPrototype.isPureReactComponent = true;\n\n    function AsyncComponent(props, context, updater) {\n      // Duplicated from Component.\n      this.props = props;\n      this.context = context;\n      this.refs = emptyObject;\n      // We initialize the default updater but the real one gets injected by the\n      // renderer.\n      this.updater = updater || ReactNoopUpdateQueue;\n    }\n\n    var asyncComponentPrototype = AsyncComponent.prototype = new ComponentDummy();\n    asyncComponentPrototype.constructor = AsyncComponent;\n    // Avoid an extra prototype jump for these methods.\n    _assign(asyncComponentPrototype, Component.prototype);\n    asyncComponentPrototype.unstable_isAsyncReactComponent = true;\n    asyncComponentPrototype.render = function () {\n      return this.props.children;\n    };\n\n    /**\n     * Keeps track of the current owner.\n     *\n     * The current owner is the component who should own any components that are\n     * currently being constructed.\n     */\n    var ReactCurrentOwner = {\n      /**\n       * @internal\n       * @type {ReactComponent}\n       */\n      current: null\n    };\n\n    var hasOwnProperty = Object.prototype.hasOwnProperty;\n\n    var RESERVED_PROPS = {\n      key: true,\n      ref: true,\n      __self: true,\n      __source: true\n    };\n\n    var specialPropKeyWarningShown;\n    var specialPropRefWarningShown;\n\n    function hasValidRef(config) {\n      {\n        if (hasOwnProperty.call(config, 'ref')) {\n          var getter = Object.getOwnPropertyDescriptor(config, 'ref').get;\n          if (getter && getter.isReactWarning) {\n            return false;\n          }\n        }\n      }\n      return config.ref !== undefined;\n    }\n\n    function hasValidKey(config) {\n      {\n        if (hasOwnProperty.call(config, 'key')) {\n          var getter = Object.getOwnPropertyDescriptor(config, 'key').get;\n          if (getter && getter.isReactWarning) {\n            return false;\n          }\n        }\n      }\n      return config.key !== undefined;\n    }\n\n    function defineKeyPropWarningGetter(props, displayName) {\n      var warnAboutAccessingKey = function () {\n        if (!specialPropKeyWarningShown) {\n          specialPropKeyWarningShown = true;\n          warning(false, '%s: `key` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://fb.me/react-special-props)', displayName);\n        }\n      };\n      warnAboutAccessingKey.isReactWarning = true;\n      Object.defineProperty(props, 'key', {\n        get: warnAboutAccessingKey,\n        configurable: true\n      });\n    }\n\n    function defineRefPropWarningGetter(props, displayName) {\n      var warnAboutAccessingRef = function () {\n        if (!specialPropRefWarningShown) {\n          specialPropRefWarningShown = true;\n          warning(false, '%s: `ref` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://fb.me/react-special-props)', displayName);\n        }\n      };\n      warnAboutAccessingRef.isReactWarning = true;\n      Object.defineProperty(props, 'ref', {\n        get: warnAboutAccessingRef,\n        configurable: true\n      });\n    }\n\n    /**\n     * Factory method to create a new React element. This no longer adheres to\n     * the class pattern, so do not use new to call it. Also, no instanceof check\n     * will work. Instead test $$typeof field against Symbol.for('react.element') to check\n     * if something is a React Element.\n     *\n     * @param {*} type\n     * @param {*} key\n     * @param {string|object} ref\n     * @param {*} self A *temporary* helper to detect places where `this` is\n     * different from the `owner` when React.createElement is called, so that we\n     * can warn. We want to get rid of owner and replace string `ref`s with arrow\n     * functions, and as long as `this` and owner are the same, there will be no\n     * change in behavior.\n     * @param {*} source An annotation object (added by a transpiler or otherwise)\n     * indicating filename, line number, and/or other information.\n     * @param {*} owner\n     * @param {*} props\n     * @internal\n     */\n    var ReactElement = function (type, key, ref, self, source, owner, props) {\n      var element = {\n        // This tag allow us to uniquely identify this as a React Element\n        $$typeof: REACT_ELEMENT_TYPE,\n\n        // Built-in properties that belong on the element\n        type: type,\n        key: key,\n        ref: ref,\n        props: props,\n\n        // Record the component responsible for creating this element.\n        _owner: owner\n      };\n\n      {\n        // The validation flag is currently mutative. We put it on\n        // an external backing store so that we can freeze the whole object.\n        // This can be replaced with a WeakMap once they are implemented in\n        // commonly used development environments.\n        element._store = {};\n\n        // To make comparing ReactElements easier for testing purposes, we make\n        // the validation flag non-enumerable (where possible, which should\n        // include every environment we run tests in), so the test framework\n        // ignores it.\n        Object.defineProperty(element._store, 'validated', {\n          configurable: false,\n          enumerable: false,\n          writable: true,\n          value: false\n        });\n        // self and source are DEV only properties.\n        Object.defineProperty(element, '_self', {\n          configurable: false,\n          enumerable: false,\n          writable: false,\n          value: self\n        });\n        // Two elements created in two different places should be considered\n        // equal for testing purposes and therefore we hide it from enumeration.\n        Object.defineProperty(element, '_source', {\n          configurable: false,\n          enumerable: false,\n          writable: false,\n          value: source\n        });\n        if (Object.freeze) {\n          Object.freeze(element.props);\n          Object.freeze(element);\n        }\n      }\n\n      return element;\n    };\n\n    /**\n     * Create and return a new ReactElement of the given type.\n     * See https://reactjs.org/docs/react-api.html#createelement\n     */\n    function createElement(type, config, children) {\n      var propName;\n\n      // Reserved names are extracted\n      var props = {};\n\n      var key = null;\n      var ref = null;\n      var self = null;\n      var source = null;\n\n      if (config != null) {\n        if (hasValidRef(config)) {\n          ref = config.ref;\n        }\n        if (hasValidKey(config)) {\n          key = '' + config.key;\n        }\n\n        self = config.__self === undefined ? null : config.__self;\n        source = config.__source === undefined ? null : config.__source;\n        // Remaining properties are added to a new props object\n        for (propName in config) {\n          if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {\n            props[propName] = config[propName];\n          }\n        }\n      }\n\n      // Children can be more than one argument, and those are transferred onto\n      // the newly allocated props object.\n      var childrenLength = arguments.length - 2;\n      if (childrenLength === 1) {\n        props.children = children;\n      } else if (childrenLength > 1) {\n        var childArray = Array(childrenLength);\n        for (var i = 0; i < childrenLength; i++) {\n          childArray[i] = arguments[i + 2];\n        }\n        {\n          if (Object.freeze) {\n            Object.freeze(childArray);\n          }\n        }\n        props.children = childArray;\n      }\n\n      // Resolve default props\n      if (type && type.defaultProps) {\n        var defaultProps = type.defaultProps;\n        for (propName in defaultProps) {\n          if (props[propName] === undefined) {\n            props[propName] = defaultProps[propName];\n          }\n        }\n      }\n      {\n        if (key || ref) {\n          if (typeof props.$$typeof === 'undefined' || props.$$typeof !== REACT_ELEMENT_TYPE) {\n            var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type;\n            if (key) {\n              defineKeyPropWarningGetter(props, displayName);\n            }\n            if (ref) {\n              defineRefPropWarningGetter(props, displayName);\n            }\n          }\n        }\n      }\n      return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);\n    }\n\n    /**\n     * Return a function that produces ReactElements of a given type.\n     * See https://reactjs.org/docs/react-api.html#createfactory\n     */\n\n    function cloneAndReplaceKey(oldElement, newKey) {\n      var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props);\n\n      return newElement;\n    }\n\n    /**\n     * Clone and return a new ReactElement using element as the starting point.\n     * See https://reactjs.org/docs/react-api.html#cloneelement\n     */\n    function cloneElement(element, config, children) {\n      var propName;\n\n      // Original props are copied\n      var props = _assign({}, element.props);\n\n      // Reserved names are extracted\n      var key = element.key;\n      var ref = element.ref;\n      // Self is preserved since the owner is preserved.\n      var self = element._self;\n      // Source is preserved since cloneElement is unlikely to be targeted by a\n      // transpiler, and the original source is probably a better indicator of the\n      // true owner.\n      var source = element._source;\n\n      // Owner will be preserved, unless ref is overridden\n      var owner = element._owner;\n\n      if (config != null) {\n        if (hasValidRef(config)) {\n          // Silently steal the ref from the parent.\n          ref = config.ref;\n          owner = ReactCurrentOwner.current;\n        }\n        if (hasValidKey(config)) {\n          key = '' + config.key;\n        }\n\n        // Remaining properties override existing props\n        var defaultProps;\n        if (element.type && element.type.defaultProps) {\n          defaultProps = element.type.defaultProps;\n        }\n        for (propName in config) {\n          if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {\n            if (config[propName] === undefined && defaultProps !== undefined) {\n              // Resolve default props\n              props[propName] = defaultProps[propName];\n            } else {\n              props[propName] = config[propName];\n            }\n          }\n        }\n      }\n\n      // Children can be more than one argument, and those are transferred onto\n      // the newly allocated props object.\n      var childrenLength = arguments.length - 2;\n      if (childrenLength === 1) {\n        props.children = children;\n      } else if (childrenLength > 1) {\n        var childArray = Array(childrenLength);\n        for (var i = 0; i < childrenLength; i++) {\n          childArray[i] = arguments[i + 2];\n        }\n        props.children = childArray;\n      }\n\n      return ReactElement(element.type, key, ref, self, source, owner, props);\n    }\n\n    /**\n     * Verifies the object is a ReactElement.\n     * See https://reactjs.org/docs/react-api.html#isvalidelement\n     * @param {?object} object\n     * @return {boolean} True if `object` is a valid component.\n     * @final\n     */\n    function isValidElement(object) {\n      return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;\n    }\n\n    var ReactDebugCurrentFrame = {};\n\n    {\n      // Component that is being worked on\n      ReactDebugCurrentFrame.getCurrentStack = null;\n\n      ReactDebugCurrentFrame.getStackAddendum = function () {\n        var impl = ReactDebugCurrentFrame.getCurrentStack;\n        if (impl) {\n          return impl();\n        }\n        return null;\n      };\n    }\n\n    var SEPARATOR = '.';\n    var SUBSEPARATOR = ':';\n\n    /**\n     * Escape and wrap key so it is safe to use as a reactid\n     *\n     * @param {string} key to be escaped.\n     * @return {string} the escaped key.\n     */\n    function escape(key) {\n      var escapeRegex = /[=:]/g;\n      var escaperLookup = {\n        '=': '=0',\n        ':': '=2'\n      };\n      var escapedString = ('' + key).replace(escapeRegex, function (match) {\n        return escaperLookup[match];\n      });\n\n      return '$' + escapedString;\n    }\n\n    /**\n     * TODO: Test that a single child and an array with one item have the same key\n     * pattern.\n     */\n\n    var didWarnAboutMaps = false;\n\n    var userProvidedKeyEscapeRegex = /\\/+/g;\n    function escapeUserProvidedKey(text) {\n      return ('' + text).replace(userProvidedKeyEscapeRegex, '$&/');\n    }\n\n    var POOL_SIZE = 10;\n    var traverseContextPool = [];\n    function getPooledTraverseContext(mapResult, keyPrefix, mapFunction, mapContext) {\n      if (traverseContextPool.length) {\n        var traverseContext = traverseContextPool.pop();\n        traverseContext.result = mapResult;\n        traverseContext.keyPrefix = keyPrefix;\n        traverseContext.func = mapFunction;\n        traverseContext.context = mapContext;\n        traverseContext.count = 0;\n        return traverseContext;\n      } else {\n        return {\n          result: mapResult,\n          keyPrefix: keyPrefix,\n          func: mapFunction,\n          context: mapContext,\n          count: 0\n        };\n      }\n    }\n\n    function releaseTraverseContext(traverseContext) {\n      traverseContext.result = null;\n      traverseContext.keyPrefix = null;\n      traverseContext.func = null;\n      traverseContext.context = null;\n      traverseContext.count = 0;\n      if (traverseContextPool.length < POOL_SIZE) {\n        traverseContextPool.push(traverseContext);\n      }\n    }\n\n    /**\n     * @param {?*} children Children tree container.\n     * @param {!string} nameSoFar Name of the key path so far.\n     * @param {!function} callback Callback to invoke with each child found.\n     * @param {?*} traverseContext Used to pass information throughout the traversal\n     * process.\n     * @return {!number} The number of children in this subtree.\n     */\n    function traverseAllChildrenImpl(children, nameSoFar, callback, traverseContext) {\n      var type = typeof children;\n\n      if (type === 'undefined' || type === 'boolean') {\n        // All of the above are perceived as null.\n        children = null;\n      }\n\n      var invokeCallback = false;\n\n      if (children === null) {\n        invokeCallback = true;\n      } else {\n        switch (type) {\n          case 'string':\n          case 'number':\n            invokeCallback = true;\n            break;\n          case 'object':\n            switch (children.$$typeof) {\n              case REACT_ELEMENT_TYPE:\n              case REACT_CALL_TYPE:\n              case REACT_RETURN_TYPE:\n              case REACT_PORTAL_TYPE:\n                invokeCallback = true;\n            }\n        }\n      }\n\n      if (invokeCallback) {\n        callback(traverseContext, children,\n        // If it's the only child, treat the name as if it was wrapped in an array\n        // so that it's consistent if the number of children grows.\n        nameSoFar === '' ? SEPARATOR + getComponentKey(children, 0) : nameSoFar);\n        return 1;\n      }\n\n      var child;\n      var nextName;\n      var subtreeCount = 0; // Count of children found in the current subtree.\n      var nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR;\n\n      if (Array.isArray(children)) {\n        for (var i = 0; i < children.length; i++) {\n          child = children[i];\n          nextName = nextNamePrefix + getComponentKey(child, i);\n          subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);\n        }\n      } else {\n        var iteratorFn = getIteratorFn(children);\n        if (typeof iteratorFn === 'function') {\n          {\n            // Warn about using Maps as children\n            if (iteratorFn === children.entries) {\n              warning(didWarnAboutMaps, 'Using Maps as children is unsupported and will likely yield ' + 'unexpected results. Convert it to a sequence/iterable of keyed ' + 'ReactElements instead.%s', ReactDebugCurrentFrame.getStackAddendum());\n              didWarnAboutMaps = true;\n            }\n          }\n\n          var iterator = iteratorFn.call(children);\n          var step;\n          var ii = 0;\n          while (!(step = iterator.next()).done) {\n            child = step.value;\n            nextName = nextNamePrefix + getComponentKey(child, ii++);\n            subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);\n          }\n        } else if (type === 'object') {\n          var addendum = '';\n          {\n            addendum = ' If you meant to render a collection of children, use an array ' + 'instead.' + ReactDebugCurrentFrame.getStackAddendum();\n          }\n          var childrenString = '' + children;\n          invariant(false, 'Objects are not valid as a React child (found: %s).%s', childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString, addendum);\n        }\n      }\n\n      return subtreeCount;\n    }\n\n    /**\n     * Traverses children that are typically specified as `props.children`, but\n     * might also be specified through attributes:\n     *\n     * - `traverseAllChildren(this.props.children, ...)`\n     * - `traverseAllChildren(this.props.leftPanelChildren, ...)`\n     *\n     * The `traverseContext` is an optional argument that is passed through the\n     * entire traversal. It can be used to store accumulations or anything else that\n     * the callback might find relevant.\n     *\n     * @param {?*} children Children tree object.\n     * @param {!function} callback To invoke upon traversing each child.\n     * @param {?*} traverseContext Context for traversal.\n     * @return {!number} The number of children in this subtree.\n     */\n    function traverseAllChildren(children, callback, traverseContext) {\n      if (children == null) {\n        return 0;\n      }\n\n      return traverseAllChildrenImpl(children, '', callback, traverseContext);\n    }\n\n    /**\n     * Generate a key string that identifies a component within a set.\n     *\n     * @param {*} component A component that could contain a manual key.\n     * @param {number} index Index that is used if a manual key is not provided.\n     * @return {string}\n     */\n    function getComponentKey(component, index) {\n      // Do some typechecking here since we call this blindly. We want to ensure\n      // that we don't block potential future ES APIs.\n      if (typeof component === 'object' && component !== null && component.key != null) {\n        // Explicit key\n        return escape(component.key);\n      }\n      // Implicit key determined by the index in the set\n      return index.toString(36);\n    }\n\n    function forEachSingleChild(bookKeeping, child, name) {\n      var func = bookKeeping.func,\n          context = bookKeeping.context;\n\n      func.call(context, child, bookKeeping.count++);\n    }\n\n    /**\n     * Iterates through children that are typically specified as `props.children`.\n     *\n     * See https://reactjs.org/docs/react-api.html#react.children.foreach\n     *\n     * The provided forEachFunc(child, index) will be called for each\n     * leaf child.\n     *\n     * @param {?*} children Children tree container.\n     * @param {function(*, int)} forEachFunc\n     * @param {*} forEachContext Context for forEachContext.\n     */\n    function forEachChildren(children, forEachFunc, forEachContext) {\n      if (children == null) {\n        return children;\n      }\n      var traverseContext = getPooledTraverseContext(null, null, forEachFunc, forEachContext);\n      traverseAllChildren(children, forEachSingleChild, traverseContext);\n      releaseTraverseContext(traverseContext);\n    }\n\n    function mapSingleChildIntoContext(bookKeeping, child, childKey) {\n      var result = bookKeeping.result,\n          keyPrefix = bookKeeping.keyPrefix,\n          func = bookKeeping.func,\n          context = bookKeeping.context;\n\n      var mappedChild = func.call(context, child, bookKeeping.count++);\n      if (Array.isArray(mappedChild)) {\n        mapIntoWithKeyPrefixInternal(mappedChild, result, childKey, emptyFunction.thatReturnsArgument);\n      } else if (mappedChild != null) {\n        if (isValidElement(mappedChild)) {\n          mappedChild = cloneAndReplaceKey(mappedChild,\n          // Keep both the (mapped) and old keys if they differ, just as\n          // traverseAllChildren used to do for objects as children\n          keyPrefix + (mappedChild.key && (!child || child.key !== mappedChild.key) ? escapeUserProvidedKey(mappedChild.key) + '/' : '') + childKey);\n        }\n        result.push(mappedChild);\n      }\n    }\n\n    function mapIntoWithKeyPrefixInternal(children, array, prefix, func, context) {\n      var escapedPrefix = '';\n      if (prefix != null) {\n        escapedPrefix = escapeUserProvidedKey(prefix) + '/';\n      }\n      var traverseContext = getPooledTraverseContext(array, escapedPrefix, func, context);\n      traverseAllChildren(children, mapSingleChildIntoContext, traverseContext);\n      releaseTraverseContext(traverseContext);\n    }\n\n    /**\n     * Maps children that are typically specified as `props.children`.\n     *\n     * See https://reactjs.org/docs/react-api.html#react.children.map\n     *\n     * The provided mapFunction(child, key, index) will be called for each\n     * leaf child.\n     *\n     * @param {?*} children Children tree container.\n     * @param {function(*, int)} func The map function.\n     * @param {*} context Context for mapFunction.\n     * @return {object} Object containing the ordered map of results.\n     */\n    function mapChildren(children, func, context) {\n      if (children == null) {\n        return children;\n      }\n      var result = [];\n      mapIntoWithKeyPrefixInternal(children, result, null, func, context);\n      return result;\n    }\n\n    /**\n     * Count the number of children that are typically specified as\n     * `props.children`.\n     *\n     * See https://reactjs.org/docs/react-api.html#react.children.count\n     *\n     * @param {?*} children Children tree container.\n     * @return {number} The number of children.\n     */\n    function countChildren(children, context) {\n      return traverseAllChildren(children, emptyFunction.thatReturnsNull, null);\n    }\n\n    /**\n     * Flatten a children object (typically specified as `props.children`) and\n     * return an array with appropriately re-keyed children.\n     *\n     * See https://reactjs.org/docs/react-api.html#react.children.toarray\n     */\n    function toArray(children) {\n      var result = [];\n      mapIntoWithKeyPrefixInternal(children, result, null, emptyFunction.thatReturnsArgument);\n      return result;\n    }\n\n    /**\n     * Returns the first child in a collection of children and verifies that there\n     * is only one child in the collection.\n     *\n     * See https://reactjs.org/docs/react-api.html#react.children.only\n     *\n     * The current implementation of this function assumes that a single child gets\n     * passed without a wrapper, but the purpose of this helper function is to\n     * abstract away the particular structure of children.\n     *\n     * @param {?object} children Child collection structure.\n     * @return {ReactElement} The first and only `ReactElement` contained in the\n     * structure.\n     */\n    function onlyChild(children) {\n      !isValidElement(children) ? invariant(false, 'React.Children.only expected to receive a single React element child.') : void 0;\n      return children;\n    }\n\n    var describeComponentFrame = function (name, source, ownerName) {\n      return '\\n    in ' + (name || 'Unknown') + (source ? ' (at ' + source.fileName.replace(/^.*[\\\\\\/]/, '') + ':' + source.lineNumber + ')' : ownerName ? ' (created by ' + ownerName + ')' : '');\n    };\n\n    function getComponentName(fiber) {\n      var type = fiber.type;\n\n      if (typeof type === 'string') {\n        return type;\n      }\n      if (typeof type === 'function') {\n        return type.displayName || type.name;\n      }\n      return null;\n    }\n\n    /**\n     * ReactElementValidator provides a wrapper around a element factory\n     * which validates the props passed to the element. This is intended to be\n     * used only in DEV and could be replaced by a static type checker for languages\n     * that support it.\n     */\n\n    {\n      var currentlyValidatingElement = null;\n\n      var propTypesMisspellWarningShown = false;\n\n      var getDisplayName = function (element) {\n        if (element == null) {\n          return '#empty';\n        } else if (typeof element === 'string' || typeof element === 'number') {\n          return '#text';\n        } else if (typeof element.type === 'string') {\n          return element.type;\n        } else if (element.type === REACT_FRAGMENT_TYPE) {\n          return 'React.Fragment';\n        } else {\n          return element.type.displayName || element.type.name || 'Unknown';\n        }\n      };\n\n      var getStackAddendum = function () {\n        var stack = '';\n        if (currentlyValidatingElement) {\n          var name = getDisplayName(currentlyValidatingElement);\n          var owner = currentlyValidatingElement._owner;\n          stack += describeComponentFrame(name, currentlyValidatingElement._source, owner && getComponentName(owner));\n        }\n        stack += ReactDebugCurrentFrame.getStackAddendum() || '';\n        return stack;\n      };\n\n      var VALID_FRAGMENT_PROPS = new Map([['children', true], ['key', true]]);\n    }\n\n    function getDeclarationErrorAddendum() {\n      if (ReactCurrentOwner.current) {\n        var name = getComponentName(ReactCurrentOwner.current);\n        if (name) {\n          return '\\n\\nCheck the render method of `' + name + '`.';\n        }\n      }\n      return '';\n    }\n\n    function getSourceInfoErrorAddendum(elementProps) {\n      if (elementProps !== null && elementProps !== undefined && elementProps.__source !== undefined) {\n        var source = elementProps.__source;\n        var fileName = source.fileName.replace(/^.*[\\\\\\/]/, '');\n        var lineNumber = source.lineNumber;\n        return '\\n\\nCheck your code at ' + fileName + ':' + lineNumber + '.';\n      }\n      return '';\n    }\n\n    /**\n     * Warn if there's no key explicitly set on dynamic arrays of children or\n     * object keys are not valid. This allows us to keep track of children between\n     * updates.\n     */\n    var ownerHasKeyUseWarning = {};\n\n    function getCurrentComponentErrorInfo(parentType) {\n      var info = getDeclarationErrorAddendum();\n\n      if (!info) {\n        var parentName = typeof parentType === 'string' ? parentType : parentType.displayName || parentType.name;\n        if (parentName) {\n          info = '\\n\\nCheck the top-level render call using <' + parentName + '>.';\n        }\n      }\n      return info;\n    }\n\n    /**\n     * Warn if the element doesn't have an explicit key assigned to it.\n     * This element is in an array. The array could grow and shrink or be\n     * reordered. All children that haven't already been validated are required to\n     * have a \"key\" property assigned to it. Error statuses are cached so a warning\n     * will only be shown once.\n     *\n     * @internal\n     * @param {ReactElement} element Element that requires a key.\n     * @param {*} parentType element's parent's type.\n     */\n    function validateExplicitKey(element, parentType) {\n      if (!element._store || element._store.validated || element.key != null) {\n        return;\n      }\n      element._store.validated = true;\n\n      var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);\n      if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {\n        return;\n      }\n      ownerHasKeyUseWarning[currentComponentErrorInfo] = true;\n\n      // Usually the current owner is the offender, but if it accepts children as a\n      // property, it may be the creator of the child that's responsible for\n      // assigning it a key.\n      var childOwner = '';\n      if (element && element._owner && element._owner !== ReactCurrentOwner.current) {\n        // Give the component that originally created this child.\n        childOwner = ' It was passed a child from ' + getComponentName(element._owner) + '.';\n      }\n\n      currentlyValidatingElement = element;\n      {\n        warning(false, 'Each child in an array or iterator should have a unique \"key\" prop.' + '%s%s See https://fb.me/react-warning-keys for more information.%s', currentComponentErrorInfo, childOwner, getStackAddendum());\n      }\n      currentlyValidatingElement = null;\n    }\n\n    /**\n     * Ensure that every element either is passed in a static location, in an\n     * array with an explicit keys property defined, or in an object literal\n     * with valid key property.\n     *\n     * @internal\n     * @param {ReactNode} node Statically passed child of any type.\n     * @param {*} parentType node's parent's type.\n     */\n    function validateChildKeys(node, parentType) {\n      if (typeof node !== 'object') {\n        return;\n      }\n      if (Array.isArray(node)) {\n        for (var i = 0; i < node.length; i++) {\n          var child = node[i];\n          if (isValidElement(child)) {\n            validateExplicitKey(child, parentType);\n          }\n        }\n      } else if (isValidElement(node)) {\n        // This element was passed in a valid location.\n        if (node._store) {\n          node._store.validated = true;\n        }\n      } else if (node) {\n        var iteratorFn = getIteratorFn(node);\n        if (typeof iteratorFn === 'function') {\n          // Entry iterators used to provide implicit keys,\n          // but now we print a separate warning for them later.\n          if (iteratorFn !== node.entries) {\n            var iterator = iteratorFn.call(node);\n            var step;\n            while (!(step = iterator.next()).done) {\n              if (isValidElement(step.value)) {\n                validateExplicitKey(step.value, parentType);\n              }\n            }\n          }\n        }\n      }\n    }\n\n    /**\n     * Given an element, validate that its props follow the propTypes definition,\n     * provided by the type.\n     *\n     * @param {ReactElement} element\n     */\n    function validatePropTypes(element) {\n      var componentClass = element.type;\n      if (typeof componentClass !== 'function') {\n        return;\n      }\n      var name = componentClass.displayName || componentClass.name;\n      var propTypes = componentClass.propTypes;\n      if (propTypes) {\n        currentlyValidatingElement = element;\n        checkPropTypes(propTypes, element.props, 'prop', name, getStackAddendum);\n        currentlyValidatingElement = null;\n      } else if (componentClass.PropTypes !== undefined && !propTypesMisspellWarningShown) {\n        propTypesMisspellWarningShown = true;\n        warning(false, 'Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?', name || 'Unknown');\n      }\n      if (typeof componentClass.getDefaultProps === 'function') {\n        warning(componentClass.getDefaultProps.isReactClassApproved, 'getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.');\n      }\n    }\n\n    /**\n     * Given a fragment, validate that it can only be provided with fragment props\n     * @param {ReactElement} fragment\n     */\n    function validateFragmentProps(fragment) {\n      currentlyValidatingElement = fragment;\n\n      var _iteratorNormalCompletion = true;\n      var _didIteratorError = false;\n      var _iteratorError = undefined;\n\n      try {\n        for (var _iterator = Object.keys(fragment.props)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {\n          var key = _step.value;\n\n          if (!VALID_FRAGMENT_PROPS.has(key)) {\n            warning(false, 'Invalid prop `%s` supplied to `React.Fragment`. ' + 'React.Fragment can only have `key` and `children` props.%s', key, getStackAddendum());\n            break;\n          }\n        }\n      } catch (err) {\n        _didIteratorError = true;\n        _iteratorError = err;\n      } finally {\n        try {\n          if (!_iteratorNormalCompletion && _iterator['return']) {\n            _iterator['return']();\n          }\n        } finally {\n          if (_didIteratorError) {\n            throw _iteratorError;\n          }\n        }\n      }\n\n      if (fragment.ref !== null) {\n        warning(false, 'Invalid attribute `ref` supplied to `React.Fragment`.%s', getStackAddendum());\n      }\n\n      currentlyValidatingElement = null;\n    }\n\n    function createElementWithValidation(type, props, children) {\n      var validType = typeof type === 'string' || typeof type === 'function' || typeof type === 'symbol' || typeof type === 'number';\n      // We warn in this case but don't throw. We expect the element creation to\n      // succeed and there will likely be errors in render.\n      if (!validType) {\n        var info = '';\n        if (type === undefined || typeof type === 'object' && type !== null && Object.keys(type).length === 0) {\n          info += ' You likely forgot to export your component from the file ' + \"it's defined in, or you might have mixed up default and named imports.\";\n        }\n\n        var sourceInfo = getSourceInfoErrorAddendum(props);\n        if (sourceInfo) {\n          info += sourceInfo;\n        } else {\n          info += getDeclarationErrorAddendum();\n        }\n\n        info += getStackAddendum() || '';\n\n        warning(false, 'React.createElement: type is invalid -- expected a string (for ' + 'built-in components) or a class/function (for composite ' + 'components) but got: %s.%s', type == null ? type : typeof type, info);\n      }\n\n      var element = createElement.apply(this, arguments);\n\n      // The result can be nullish if a mock or a custom function is used.\n      // TODO: Drop this when these are no longer allowed as the type argument.\n      if (element == null) {\n        return element;\n      }\n\n      // Skip key warning if the type isn't valid since our key validation logic\n      // doesn't expect a non-string/function type and can throw confusing errors.\n      // We don't want exception behavior to differ between dev and prod.\n      // (Rendering will throw with a helpful message and as soon as the type is\n      // fixed, the key warnings will appear.)\n      if (validType) {\n        for (var i = 2; i < arguments.length; i++) {\n          validateChildKeys(arguments[i], type);\n        }\n      }\n\n      if (typeof type === 'symbol' && type === REACT_FRAGMENT_TYPE) {\n        validateFragmentProps(element);\n      } else {\n        validatePropTypes(element);\n      }\n\n      return element;\n    }\n\n    function createFactoryWithValidation(type) {\n      var validatedFactory = createElementWithValidation.bind(null, type);\n      // Legacy hook TODO: Warn if this is accessed\n      validatedFactory.type = type;\n\n      {\n        Object.defineProperty(validatedFactory, 'type', {\n          enumerable: false,\n          get: function () {\n            lowPriorityWarning$1(false, 'Factory.type is deprecated. Access the class directly ' + 'before passing it to createFactory.');\n            Object.defineProperty(this, 'type', {\n              value: type\n            });\n            return type;\n          }\n        });\n      }\n\n      return validatedFactory;\n    }\n\n    function cloneElementWithValidation(element, props, children) {\n      var newElement = cloneElement.apply(this, arguments);\n      for (var i = 2; i < arguments.length; i++) {\n        validateChildKeys(arguments[i], newElement.type);\n      }\n      validatePropTypes(newElement);\n      return newElement;\n    }\n\n    var React = {\n      Children: {\n        map: mapChildren,\n        forEach: forEachChildren,\n        count: countChildren,\n        toArray: toArray,\n        only: onlyChild\n      },\n\n      Component: Component,\n      PureComponent: PureComponent,\n      unstable_AsyncComponent: AsyncComponent,\n\n      Fragment: REACT_FRAGMENT_TYPE,\n\n      createElement: createElementWithValidation,\n      cloneElement: cloneElementWithValidation,\n      createFactory: createFactoryWithValidation,\n      isValidElement: isValidElement,\n\n      version: ReactVersion,\n\n      __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: {\n        ReactCurrentOwner: ReactCurrentOwner,\n        // Used by renderers to avoid bundling object-assign twice in UMD bundles:\n        assign: _assign\n      }\n    };\n\n    {\n      _assign(React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED, {\n        // These should not be included in production.\n        ReactDebugCurrentFrame: ReactDebugCurrentFrame,\n        // Shim for React DOM 16.0.0 which still destructured (but not used) this.\n        // TODO: remove in React 17.0.\n        ReactComponentTreeHook: {}\n      });\n    }\n\n    var React$2 = Object.freeze({\n      default: React\n    });\n\n    var React$3 = React$2 && React || React$2;\n\n    // TODO: decide on the top-level export form.\n    // This is hacky but makes it work with both Rollup and Jest.\n    var react = React$3['default'] ? React$3['default'] : React$3;\n\n    module.exports = react;\n  })();\n}"},"hash":"f60cef3d78f83db33d698b01770d6e78"}