hyper-console 0.1.0

data/lib/hyperloop/console/sources/react.js

@@ -0,0 +1,3987 @@
+/**
+ * React v15.5.4
+ */
+(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.React = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){
+/**
+* Copyright 2013-present, Facebook, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the BSD-style license found in the
+* LICENSE file in the root directory of this source tree. An additional grant
+* of patent rights can be found in the PATENTS file in the same directory.
+*
+*
+*/
+
+'use strict';
+
+/**
+* Escape and wrap key so it is safe to use as a reactid
+*
+* @param {string} key to be escaped.
+* @return {string} the escaped key.
+*/
+
+function escape(key) {
+ var escapeRegex = /[=:]/g;
+ var escaperLookup = {
+   '=': '=0',
+   ':': '=2'
+ };
+ var escapedString = ('' + key).replace(escapeRegex, function (match) {
+   return escaperLookup[match];
+ });
+
+ return '$' + escapedString;
+}
+
+/**
+* Unescape and unwrap key for human-readable display
+*
+* @param {string} key to unescape.
+* @return {string} the unescaped key.
+*/
+function unescape(key) {
+ var unescapeRegex = /(=0|=2)/g;
+ var unescaperLookup = {
+   '=0': '=',
+   '=2': ':'
+ };
+ var keySubstring = key[0] === '.' && key[1] === '$' ? key.substring(2) : key.substring(1);
+
+ return ('' + keySubstring).replace(unescapeRegex, function (match) {
+   return unescaperLookup[match];
+ });
+}
+
+var KeyEscapeUtils = {
+ escape: escape,
+ unescape: unescape
+};
+
+module.exports = KeyEscapeUtils;
+},{}],2:[function(_dereq_,module,exports){
+/**
+* Copyright 2013-present, Facebook, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the BSD-style license found in the
+* LICENSE file in the root directory of this source tree. An additional grant
+* of patent rights can be found in the PATENTS file in the same directory.
+*
+*
+*/
+
+'use strict';
+
+var _prodInvariant = _dereq_(25);
+
+var invariant = _dereq_(29);
+
+/**
+* Static poolers. Several custom versions for each potential number of
+* arguments. A completely generic pooler is easy to implement, but would
+* require accessing the `arguments` object. In each of these, `this` refers to
+* the Class itself, not an instance. If any others are needed, simply add them
+* here, or in their own files.
+*/
+var oneArgumentPooler = function (copyFieldsFrom) {
+ var Klass = this;
+ if (Klass.instancePool.length) {
+   var instance = Klass.instancePool.pop();
+   Klass.call(instance, copyFieldsFrom);
+   return instance;
+ } else {
+   return new Klass(copyFieldsFrom);
+ }
+};
+
+var twoArgumentPooler = function (a1, a2) {
+ var Klass = this;
+ if (Klass.instancePool.length) {
+   var instance = Klass.instancePool.pop();
+   Klass.call(instance, a1, a2);
+   return instance;
+ } else {
+   return new Klass(a1, a2);
+ }
+};
+
+var threeArgumentPooler = function (a1, a2, a3) {
+ var Klass = this;
+ if (Klass.instancePool.length) {
+   var instance = Klass.instancePool.pop();
+   Klass.call(instance, a1, a2, a3);
+   return instance;
+ } else {
+   return new Klass(a1, a2, a3);
+ }
+};
+
+var fourArgumentPooler = function (a1, a2, a3, a4) {
+ var Klass = this;
+ if (Klass.instancePool.length) {
+   var instance = Klass.instancePool.pop();
+   Klass.call(instance, a1, a2, a3, a4);
+   return instance;
+ } else {
+   return new Klass(a1, a2, a3, a4);
+ }
+};
+
+var standardReleaser = function (instance) {
+ var Klass = this;
+ !(instance instanceof Klass) ? "development" !== 'production' ? invariant(false, 'Trying to release an instance into a pool of a different type.') : _prodInvariant('25') : void 0;
+ instance.destructor();
+ if (Klass.instancePool.length < Klass.poolSize) {
+   Klass.instancePool.push(instance);
+ }
+};
+
+var DEFAULT_POOL_SIZE = 10;
+var DEFAULT_POOLER = oneArgumentPooler;
+
+/**
+* Augments `CopyConstructor` to be a poolable class, augmenting only the class
+* itself (statically) not adding any prototypical fields. Any CopyConstructor
+* you give this may have a `poolSize` property, and will look for a
+* prototypical `destructor` on instances.
+*
+* @param {Function} CopyConstructor Constructor that can be used to reset.
+* @param {Function} pooler Customizable pooler.
+*/
+var addPoolingTo = function (CopyConstructor, pooler) {
+ // Casting as any so that flow ignores the actual implementation and trusts
+ // it to match the type we declared
+ var NewKlass = CopyConstructor;
+ NewKlass.instancePool = [];
+ NewKlass.getPooled = pooler || DEFAULT_POOLER;
+ if (!NewKlass.poolSize) {
+   NewKlass.poolSize = DEFAULT_POOL_SIZE;
+ }
+ NewKlass.release = standardReleaser;
+ return NewKlass;
+};
+
+var PooledClass = {
+ addPoolingTo: addPoolingTo,
+ oneArgumentPooler: oneArgumentPooler,
+ twoArgumentPooler: twoArgumentPooler,
+ threeArgumentPooler: threeArgumentPooler,
+ fourArgumentPooler: fourArgumentPooler
+};
+
+module.exports = PooledClass;
+},{"25":25,"29":29}],3:[function(_dereq_,module,exports){
+/**
+* Copyright 2013-present, Facebook, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the BSD-style license found in the
+* LICENSE file in the root directory of this source tree. An additional grant
+* of patent rights can be found in the PATENTS file in the same directory.
+*
+*/
+
+'use strict';
+
+var _assign = _dereq_(31);
+
+var ReactChildren = _dereq_(4);
+var ReactComponent = _dereq_(6);
+var ReactPureComponent = _dereq_(17);
+var ReactClass = _dereq_(5);
+var ReactDOMFactories = _dereq_(9);
+var ReactElement = _dereq_(10);
+var ReactPropTypes = _dereq_(15);
+var ReactVersion = _dereq_(19);
+
+var onlyChild = _dereq_(24);
+var warning = _dereq_(30);
+
+var createElement = ReactElement.createElement;
+var createFactory = ReactElement.createFactory;
+var cloneElement = ReactElement.cloneElement;
+
+if ("development" !== 'production') {
+ var canDefineProperty = _dereq_(20);
+ var ReactElementValidator = _dereq_(12);
+ var didWarnPropTypesDeprecated = false;
+ createElement = ReactElementValidator.createElement;
+ createFactory = ReactElementValidator.createFactory;
+ cloneElement = ReactElementValidator.cloneElement;
+}
+
+var __spread = _assign;
+
+if ("development" !== 'production') {
+ var warned = false;
+ __spread = function () {
+   "development" !== 'production' ? warning(warned, 'React.__spread is deprecated and should not be used. Use ' + 'Object.assign directly or another helper function with similar ' + 'semantics. You may be seeing this warning due to your compiler. ' + 'See https://fb.me/react-spread-deprecation for more details.') : void 0;
+   warned = true;
+   return _assign.apply(null, arguments);
+ };
+}
+
+var React = {
+
+ // Modern
+
+ Children: {
+   map: ReactChildren.map,
+   forEach: ReactChildren.forEach,
+   count: ReactChildren.count,
+   toArray: ReactChildren.toArray,
+   only: onlyChild
+ },
+
+ Component: ReactComponent,
+ PureComponent: ReactPureComponent,
+
+ createElement: createElement,
+ cloneElement: cloneElement,
+ isValidElement: ReactElement.isValidElement,
+
+ // Classic
+
+ PropTypes: ReactPropTypes,
+ createClass: ReactClass.createClass,
+ createFactory: createFactory,
+ createMixin: function (mixin) {
+   // Currently a noop. Will be used to validate and trace mixins.
+   return mixin;
+ },
+
+ // This looks DOM specific but these are actually isomorphic helpers
+ // since they are just generating DOM strings.
+ DOM: ReactDOMFactories,
+
+ version: ReactVersion,
+
+ // Deprecated hook for JSX spread, don't use this for anything.
+ __spread: __spread
+};
+
+// TODO: Fix tests so that this deprecation warning doesn't cause failures.
+if ("development" !== 'production') {
+ if (canDefineProperty) {
+   Object.defineProperty(React, 'PropTypes', {
+     get: function () {
+       "development" !== 'production' ? warning(didWarnPropTypesDeprecated, 'Accessing PropTypes via the main React package is deprecated. Use ' + 'the prop-types package from npm instead.') : void 0;
+       didWarnPropTypesDeprecated = true;
+       return ReactPropTypes;
+     }
+   });
+ }
+}
+
+module.exports = React;
+},{"10":10,"12":12,"15":15,"17":17,"19":19,"20":20,"24":24,"30":30,"31":31,"4":4,"5":5,"6":6,"9":9}],4:[function(_dereq_,module,exports){
+/**
+* Copyright 2013-present, Facebook, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the BSD-style license found in the
+* LICENSE file in the root directory of this source tree. An additional grant
+* of patent rights can be found in the PATENTS file in the same directory.
+*
+*/
+
+'use strict';
+
+var PooledClass = _dereq_(2);
+var ReactElement = _dereq_(10);
+
+var emptyFunction = _dereq_(27);
+var traverseAllChildren = _dereq_(26);
+
+var twoArgumentPooler = PooledClass.twoArgumentPooler;
+var fourArgumentPooler = PooledClass.fourArgumentPooler;
+
+var userProvidedKeyEscapeRegex = /\/+/g;
+function escapeUserProvidedKey(text) {
+ return ('' + text).replace(userProvidedKeyEscapeRegex, '$&/');
+}
+
+/**
+* PooledClass representing the bookkeeping associated with performing a child
+* traversal. Allows avoiding binding callbacks.
+*
+* @constructor ForEachBookKeeping
+* @param {!function} forEachFunction Function to perform traversal with.
+* @param {?*} forEachContext Context to perform context with.
+*/
+function ForEachBookKeeping(forEachFunction, forEachContext) {
+ this.func = forEachFunction;
+ this.context = forEachContext;
+ this.count = 0;
+}
+ForEachBookKeeping.prototype.destructor = function () {
+ this.func = null;
+ this.context = null;
+ this.count = 0;
+};
+PooledClass.addPoolingTo(ForEachBookKeeping, twoArgumentPooler);
+
+function forEachSingleChild(bookKeeping, child, name) {
+ var func = bookKeeping.func,
+     context = bookKeeping.context;
+
+ func.call(context, child, bookKeeping.count++);
+}
+
+/**
+* Iterates through children that are typically specified as `props.children`.
+*
+* See https://facebook.github.io/react/docs/top-level-api.html#react.children.foreach
+*
+* The provided forEachFunc(child, index) will be called for each
+* leaf child.
+*
+* @param {?*} children Children tree container.
+* @param {function(*, int)} forEachFunc
+* @param {*} forEachContext Context for forEachContext.
+*/
+function forEachChildren(children, forEachFunc, forEachContext) {
+ if (children == null) {
+   return children;
+ }
+ var traverseContext = ForEachBookKeeping.getPooled(forEachFunc, forEachContext);
+ traverseAllChildren(children, forEachSingleChild, traverseContext);
+ ForEachBookKeeping.release(traverseContext);
+}
+
+/**
+* PooledClass representing the bookkeeping associated with performing a child
+* mapping. Allows avoiding binding callbacks.
+*
+* @constructor MapBookKeeping
+* @param {!*} mapResult Object containing the ordered map of results.
+* @param {!function} mapFunction Function to perform mapping with.
+* @param {?*} mapContext Context to perform mapping with.
+*/
+function MapBookKeeping(mapResult, keyPrefix, mapFunction, mapContext) {
+ this.result = mapResult;
+ this.keyPrefix = keyPrefix;
+ this.func = mapFunction;
+ this.context = mapContext;
+ this.count = 0;
+}
+MapBookKeeping.prototype.destructor = function () {
+ this.result = null;
+ this.keyPrefix = null;
+ this.func = null;
+ this.context = null;
+ this.count = 0;
+};
+PooledClass.addPoolingTo(MapBookKeeping, fourArgumentPooler);
+
+function mapSingleChildIntoContext(bookKeeping, child, childKey) {
+ var result = bookKeeping.result,
+     keyPrefix = bookKeeping.keyPrefix,
+     func = bookKeeping.func,
+     context = bookKeeping.context;
+
+
+ var mappedChild = func.call(context, child, bookKeeping.count++);
+ if (Array.isArray(mappedChild)) {
+   mapIntoWithKeyPrefixInternal(mappedChild, result, childKey, emptyFunction.thatReturnsArgument);
+ } else if (mappedChild != null) {
+   if (ReactElement.isValidElement(mappedChild)) {
+     mappedChild = ReactElement.cloneAndReplaceKey(mappedChild,
+     // Keep both the (mapped) and old keys if they differ, just as
+     // traverseAllChildren used to do for objects as children
+     keyPrefix + (mappedChild.key && (!child || child.key !== mappedChild.key) ? escapeUserProvidedKey(mappedChild.key) + '/' : '') + childKey);
+   }
+   result.push(mappedChild);
+ }
+}
+
+function mapIntoWithKeyPrefixInternal(children, array, prefix, func, context) {
+ var escapedPrefix = '';
+ if (prefix != null) {
+   escapedPrefix = escapeUserProvidedKey(prefix) + '/';
+ }
+ var traverseContext = MapBookKeeping.getPooled(array, escapedPrefix, func, context);
+ traverseAllChildren(children, mapSingleChildIntoContext, traverseContext);
+ MapBookKeeping.release(traverseContext);
+}
+
+/**
+* Maps children that are typically specified as `props.children`.
+*
+* See https://facebook.github.io/react/docs/top-level-api.html#react.children.map
+*
+* The provided mapFunction(child, key, index) will be called for each
+* leaf child.
+*
+* @param {?*} children Children tree container.
+* @param {function(*, int)} func The map function.
+* @param {*} context Context for mapFunction.
+* @return {object} Object containing the ordered map of results.
+*/
+function mapChildren(children, func, context) {
+ if (children == null) {
+   return children;
+ }
+ var result = [];
+ mapIntoWithKeyPrefixInternal(children, result, null, func, context);
+ return result;
+}
+
+function forEachSingleChildDummy(traverseContext, child, name) {
+ return null;
+}
+
+/**
+* Count the number of children that are typically specified as
+* `props.children`.
+*
+* See https://facebook.github.io/react/docs/top-level-api.html#react.children.count
+*
+* @param {?*} children Children tree container.
+* @return {number} The number of children.
+*/
+function countChildren(children, context) {
+ return traverseAllChildren(children, forEachSingleChildDummy, null);
+}
+
+/**
+* Flatten a children object (typically specified as `props.children`) and
+* return an array with appropriately re-keyed children.
+*
+* See https://facebook.github.io/react/docs/top-level-api.html#react.children.toarray
+*/
+function toArray(children) {
+ var result = [];
+ mapIntoWithKeyPrefixInternal(children, result, null, emptyFunction.thatReturnsArgument);
+ return result;
+}
+
+var ReactChildren = {
+ forEach: forEachChildren,
+ map: mapChildren,
+ mapIntoWithKeyPrefixInternal: mapIntoWithKeyPrefixInternal,
+ count: countChildren,
+ toArray: toArray
+};
+
+module.exports = ReactChildren;
+},{"10":10,"2":2,"26":26,"27":27}],5:[function(_dereq_,module,exports){
+/**
+* Copyright 2013-present, Facebook, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the BSD-style license found in the
+* LICENSE file in the root directory of this source tree. An additional grant
+* of patent rights can be found in the PATENTS file in the same directory.
+*
+*/
+
+'use strict';
+
+var _prodInvariant = _dereq_(25),
+   _assign = _dereq_(31);
+
+var ReactComponent = _dereq_(6);
+var ReactElement = _dereq_(10);
+var ReactPropTypeLocationNames = _dereq_(14);
+var ReactNoopUpdateQueue = _dereq_(13);
+
+var emptyObject = _dereq_(28);
+var invariant = _dereq_(29);
+var warning = _dereq_(30);
+
+var MIXINS_KEY = 'mixins';
+
+// Helper function to allow the creation of anonymous functions which do not
+// have .name set to the name of the variable being assigned to.
+function identity(fn) {
+ return fn;
+}
+
+/**
+* Policies that describe methods in `ReactClassInterface`.
+*/
+
+
+var injectedMixins = [];
+
+/**
+* Composite components are higher-level components that compose other composite
+* or host components.
+*
+* To create a new type of `ReactClass`, pass a specification of
+* your new class to `React.createClass`. The only requirement of your class
+* specification is that you implement a `render` method.
+*
+*   var MyComponent = React.createClass({
+*     render: function() {
+*       return <div>Hello World</div>;
+*     }
+*   });
+*
+* The class specification supports a specific protocol of methods that have
+* special meaning (e.g. `render`). See `ReactClassInterface` for
+* more the comprehensive protocol. Any other properties and methods in the
+* class specification will be available on the prototype.
+*
+* @interface ReactClassInterface
+* @internal
+*/
+var ReactClassInterface = {
+
+ /**
+  * An array of Mixin objects to include when defining your component.
+  *
+  * @type {array}
+  * @optional
+  */
+ mixins: 'DEFINE_MANY',
+
+ /**
+  * An object containing properties and methods that should be defined on
+  * the component's constructor instead of its prototype (static methods).
+  *
+  * @type {object}
+  * @optional
+  */
+ statics: 'DEFINE_MANY',
+
+ /**
+  * Definition of prop types for this component.
+  *
+  * @type {object}
+  * @optional
+  */
+ propTypes: 'DEFINE_MANY',
+
+ /**
+  * Definition of context types for this component.
+  *
+  * @type {object}
+  * @optional
+  */
+ contextTypes: 'DEFINE_MANY',
+
+ /**
+  * Definition of context types this component sets for its children.
+  *
+  * @type {object}
+  * @optional
+  */
+ childContextTypes: 'DEFINE_MANY',
+
+ // ==== Definition methods ====
+
+ /**
+  * Invoked when the component is mounted. Values in the mapping will be set on
+  * `this.props` if that prop is not specified (i.e. using an `in` check).
+  *
+  * This method is invoked before `getInitialState` and therefore cannot rely
+  * on `this.state` or use `this.setState`.
+  *
+  * @return {object}
+  * @optional
+  */
+ getDefaultProps: 'DEFINE_MANY_MERGED',
+
+ /**
+  * Invoked once before the component is mounted. The return value will be used
+  * as the initial value of `this.state`.
+  *
+  *   getInitialState: function() {
+  *     return {
+  *       isOn: false,
+  *       fooBaz: new BazFoo()
+  *     }
+  *   }
+  *
+  * @return {object}
+  * @optional
+  */
+ getInitialState: 'DEFINE_MANY_MERGED',
+
+ /**
+  * @return {object}
+  * @optional
+  */
+ getChildContext: 'DEFINE_MANY_MERGED',
+
+ /**
+  * Uses props from `this.props` and state from `this.state` to render the
+  * structure of the component.
+  *
+  * No guarantees are made about when or how often this method is invoked, so
+  * it must not have side effects.
+  *
+  *   render: function() {
+  *     var name = this.props.name;
+  *     return <div>Hello, {name}!</div>;
+  *   }
+  *
+  * @return {ReactComponent}
+  * @required
+  */
+ render: 'DEFINE_ONCE',
+
+ // ==== Delegate methods ====
+
+ /**
+  * Invoked when the component is initially created and about to be mounted.
+  * This may have side effects, but any external subscriptions or data created
+  * by this method must be cleaned up in `componentWillUnmount`.
+  *
+  * @optional
+  */
+ componentWillMount: 'DEFINE_MANY',
+
+ /**
+  * Invoked when the component has been mounted and has a DOM representation.
+  * However, there is no guarantee that the DOM node is in the document.
+  *
+  * Use this as an opportunity to operate on the DOM when the component has
+  * been mounted (initialized and rendered) for the first time.
+  *
+  * @param {DOMElement} rootNode DOM element representing the component.
+  * @optional
+  */
+ componentDidMount: 'DEFINE_MANY',
+
+ /**
+  * Invoked before the component receives new props.
+  *
+  * Use this as an opportunity to react to a prop transition by updating the
+  * state using `this.setState`. Current props are accessed via `this.props`.
+  *
+  *   componentWillReceiveProps: function(nextProps, nextContext) {
+  *     this.setState({
+  *       likesIncreasing: nextProps.likeCount > this.props.likeCount
+  *     });
+  *   }
+  *
+  * NOTE: There is no equivalent `componentWillReceiveState`. An incoming prop
+  * transition may cause a state change, but the opposite is not true. If you
+  * need it, you are probably looking for `componentWillUpdate`.
+  *
+  * @param {object} nextProps
+  * @optional
+  */
+ componentWillReceiveProps: 'DEFINE_MANY',
+
+ /**
+  * Invoked while deciding if the component should be updated as a result of
+  * receiving new props, state and/or context.
+  *
+  * Use this as an opportunity to `return false` when you're certain that the
+  * transition to the new props/state/context will not require a component
+  * update.
+  *
+  *   shouldComponentUpdate: function(nextProps, nextState, nextContext) {
+  *     return !equal(nextProps, this.props) ||
+  *       !equal(nextState, this.state) ||
+  *       !equal(nextContext, this.context);
+  *   }
+  *
+  * @param {object} nextProps
+  * @param {?object} nextState
+  * @param {?object} nextContext
+  * @return {boolean} True if the component should update.
+  * @optional
+  */
+ shouldComponentUpdate: 'DEFINE_ONCE',
+
+ /**
+  * Invoked when the component is about to update due to a transition from
+  * `this.props`, `this.state` and `this.context` to `nextProps`, `nextState`
+  * and `nextContext`.
+  *
+  * Use this as an opportunity to perform preparation before an update occurs.
+  *
+  * NOTE: You **cannot** use `this.setState()` in this method.
+  *
+  * @param {object} nextProps
+  * @param {?object} nextState
+  * @param {?object} nextContext
+  * @param {ReactReconcileTransaction} transaction
+  * @optional
+  */
+ componentWillUpdate: 'DEFINE_MANY',
+
+ /**
+  * Invoked when the component's DOM representation has been updated.
+  *
+  * Use this as an opportunity to operate on the DOM when the component has
+  * been updated.
+  *
+  * @param {object} prevProps
+  * @param {?object} prevState
+  * @param {?object} prevContext
+  * @param {DOMElement} rootNode DOM element representing the component.
+  * @optional
+  */
+ componentDidUpdate: 'DEFINE_MANY',
+
+ /**
+  * Invoked when the component is about to be removed from its parent and have
+  * its DOM representation destroyed.
+  *
+  * Use this as an opportunity to deallocate any external resources.
+  *
+  * NOTE: There is no `componentDidUnmount` since your component will have been
+  * destroyed by that point.
+  *
+  * @optional
+  */
+ componentWillUnmount: 'DEFINE_MANY',
+
+ // ==== Advanced methods ====
+
+ /**
+  * Updates the component's currently mounted DOM representation.
+  *
+  * By default, this implements React's rendering and reconciliation algorithm.
+  * Sophisticated clients may wish to override this.
+  *
+  * @param {ReactReconcileTransaction} transaction
+  * @internal
+  * @overridable
+  */
+ updateComponent: 'OVERRIDE_BASE'
+
+};
+
+/**
+* Mapping from class specification keys to special processing functions.
+*
+* Although these are declared like instance properties in the specification
+* when defining classes using `React.createClass`, they are actually static
+* and are accessible on the constructor instead of the prototype. Despite
+* being static, they must be defined outside of the "statics" key under
+* which all other static methods are defined.
+*/
+var RESERVED_SPEC_KEYS = {
+ displayName: function (Constructor, displayName) {
+   Constructor.displayName = displayName;
+ },
+ mixins: function (Constructor, mixins) {
+   if (mixins) {
+     for (var i = 0; i < mixins.length; i++) {
+       mixSpecIntoComponent(Constructor, mixins[i]);
+     }
+   }
+ },
+ childContextTypes: function (Constructor, childContextTypes) {
+   if ("development" !== 'production') {
+     validateTypeDef(Constructor, childContextTypes, 'childContext');
+   }
+   Constructor.childContextTypes = _assign({}, Constructor.childContextTypes, childContextTypes);
+ },
+ contextTypes: function (Constructor, contextTypes) {
+   if ("development" !== 'production') {
+     validateTypeDef(Constructor, contextTypes, 'context');
+   }
+   Constructor.contextTypes = _assign({}, Constructor.contextTypes, contextTypes);
+ },
+ /**
+  * Special case getDefaultProps which should move into statics but requires
+  * automatic merging.
+  */
+ getDefaultProps: function (Constructor, getDefaultProps) {
+   if (Constructor.getDefaultProps) {
+     Constructor.getDefaultProps = createMergedResultFunction(Constructor.getDefaultProps, getDefaultProps);
+   } else {
+     Constructor.getDefaultProps = getDefaultProps;
+   }
+ },
+ propTypes: function (Constructor, propTypes) {
+   if ("development" !== 'production') {
+     validateTypeDef(Constructor, propTypes, 'prop');
+   }
+   Constructor.propTypes = _assign({}, Constructor.propTypes, propTypes);
+ },
+ statics: function (Constructor, statics) {
+   mixStaticSpecIntoComponent(Constructor, statics);
+ },
+ autobind: function () {} };
+
+function validateTypeDef(Constructor, typeDef, location) {
+ for (var propName in typeDef) {
+   if (typeDef.hasOwnProperty(propName)) {
+     // use a warning instead of an invariant so components
+     // don't show up in prod but only in __DEV__
+     "development" !== 'production' ? warning(typeof typeDef[propName] === 'function', '%s: %s type `%s` is invalid; it must be a function, usually from ' + 'React.PropTypes.', Constructor.displayName || 'ReactClass', ReactPropTypeLocationNames[location], propName) : void 0;
+   }
+ }
+}
+
+function validateMethodOverride(isAlreadyDefined, name) {
+ var specPolicy = ReactClassInterface.hasOwnProperty(name) ? ReactClassInterface[name] : null;
+
+ // Disallow overriding of base class methods unless explicitly allowed.
+ if (ReactClassMixin.hasOwnProperty(name)) {
+   !(specPolicy === 'OVERRIDE_BASE') ? "development" !== 'production' ? invariant(false, 'ReactClassInterface: You are attempting to override `%s` from your class specification. Ensure that your method names do not overlap with React methods.', name) : _prodInvariant('73', name) : void 0;
+ }
+
+ // Disallow defining methods more than once unless explicitly allowed.
+ if (isAlreadyDefined) {
+   !(specPolicy === 'DEFINE_MANY' || specPolicy === 'DEFINE_MANY_MERGED') ? "development" !== 'production' ? invariant(false, 'ReactClassInterface: You are attempting to define `%s` on your component more than once. This conflict may be due to a mixin.', name) : _prodInvariant('74', name) : void 0;
+ }
+}
+
+/**
+* Mixin helper which handles policy validation and reserved
+* specification keys when building React classes.
+*/
+function mixSpecIntoComponent(Constructor, spec) {
+ if (!spec) {
+   if ("development" !== 'production') {
+     var typeofSpec = typeof spec;
+     var isMixinValid = typeofSpec === 'object' && spec !== null;
+
+     "development" !== 'production' ? warning(isMixinValid, '%s: You\'re attempting to include a mixin that is either null ' + 'or not an object. Check the mixins included by the component, ' + 'as well as any mixins they include themselves. ' + 'Expected object but got %s.', Constructor.displayName || 'ReactClass', spec === null ? null : typeofSpec) : void 0;
+   }
+
+   return;
+ }
+
+ !(typeof spec !== 'function') ? "development" !== 'production' ? invariant(false, 'ReactClass: You\'re attempting to use a component class or function as a mixin. Instead, just use a regular object.') : _prodInvariant('75') : void 0;
+ !!ReactElement.isValidElement(spec) ? "development" !== 'production' ? invariant(false, 'ReactClass: You\'re attempting to use a component as a mixin. Instead, just use a regular object.') : _prodInvariant('76') : void 0;
+
+ var proto = Constructor.prototype;
+ var autoBindPairs = proto.__reactAutoBindPairs;
+
+ // By handling mixins before any other properties, we ensure the same
+ // chaining order is applied to methods with DEFINE_MANY policy, whether
+ // mixins are listed before or after these methods in the spec.
+ if (spec.hasOwnProperty(MIXINS_KEY)) {
+   RESERVED_SPEC_KEYS.mixins(Constructor, spec.mixins);
+ }
+
+ for (var name in spec) {
+   if (!spec.hasOwnProperty(name)) {
+     continue;
+   }
+
+   if (name === MIXINS_KEY) {
+     // We have already handled mixins in a special case above.
+     continue;
+   }
+
+   var property = spec[name];
+   var isAlreadyDefined = proto.hasOwnProperty(name);
+   validateMethodOverride(isAlreadyDefined, name);
+
+   if (RESERVED_SPEC_KEYS.hasOwnProperty(name)) {
+     RESERVED_SPEC_KEYS[name](Constructor, property);
+   } else {
+     // Setup methods on prototype:
+     // The following member methods should not be automatically bound:
+     // 1. Expected ReactClass methods (in the "interface").
+     // 2. Overridden methods (that were mixed in).
+     var isReactClassMethod = ReactClassInterface.hasOwnProperty(name);
+     var isFunction = typeof property === 'function';
+     var shouldAutoBind = isFunction && !isReactClassMethod && !isAlreadyDefined && spec.autobind !== false;
+
+     if (shouldAutoBind) {
+       autoBindPairs.push(name, property);
+       proto[name] = property;
+     } else {
+       if (isAlreadyDefined) {
+         var specPolicy = ReactClassInterface[name];
+
+         // These cases should already be caught by validateMethodOverride.
+         !(isReactClassMethod && (specPolicy === 'DEFINE_MANY_MERGED' || specPolicy === 'DEFINE_MANY')) ? "development" !== 'production' ? invariant(false, 'ReactClass: Unexpected spec policy %s for key %s when mixing in component specs.', specPolicy, name) : _prodInvariant('77', specPolicy, name) : void 0;
+
+         // For methods which are defined more than once, call the existing
+         // methods before calling the new property, merging if appropriate.
+         if (specPolicy === 'DEFINE_MANY_MERGED') {
+           proto[name] = createMergedResultFunction(proto[name], property);
+         } else if (specPolicy === 'DEFINE_MANY') {
+           proto[name] = createChainedFunction(proto[name], property);
+         }
+       } else {
+         proto[name] = property;
+         if ("development" !== 'production') {
+           // Add verbose displayName to the function, which helps when looking
+           // at profiling tools.
+           if (typeof property === 'function' && spec.displayName) {
+             proto[name].displayName = spec.displayName + '_' + name;
+           }
+         }
+       }
+     }
+   }
+ }
+}
+
+function mixStaticSpecIntoComponent(Constructor, statics) {
+ if (!statics) {
+   return;
+ }
+ for (var name in statics) {
+   var property = statics[name];
+   if (!statics.hasOwnProperty(name)) {
+     continue;
+   }
+
+   var isReserved = name in RESERVED_SPEC_KEYS;
+   !!isReserved ? "development" !== 'production' ? invariant(false, 'ReactClass: You are attempting to define a reserved property, `%s`, that shouldn\'t be on the "statics" key. Define it as an instance property instead; it will still be accessible on the constructor.', name) : _prodInvariant('78', name) : void 0;
+
+   var isInherited = name in Constructor;
+   !!isInherited ? "development" !== 'production' ? invariant(false, 'ReactClass: You are attempting to define `%s` on your component more than once. This conflict may be due to a mixin.', name) : _prodInvariant('79', name) : void 0;
+   Constructor[name] = property;
+ }
+}
+
+/**
+* Merge two objects, but throw if both contain the same key.
+*
+* @param {object} one The first object, which is mutated.
+* @param {object} two The second object
+* @return {object} one after it has been mutated to contain everything in two.
+*/
+function mergeIntoWithNoDuplicateKeys(one, two) {
+ !(one && two && typeof one === 'object' && typeof two === 'object') ? "development" !== 'production' ? invariant(false, 'mergeIntoWithNoDuplicateKeys(): Cannot merge non-objects.') : _prodInvariant('80') : void 0;
+
+ for (var key in two) {
+   if (two.hasOwnProperty(key)) {
+     !(one[key] === undefined) ? "development" !== 'production' ? invariant(false, 'mergeIntoWithNoDuplicateKeys(): Tried to merge two objects with the same key: `%s`. This conflict may be due to a mixin; in particular, this may be caused by two getInitialState() or getDefaultProps() methods returning objects with clashing keys.', key) : _prodInvariant('81', key) : void 0;
+     one[key] = two[key];
+   }
+ }
+ return one;
+}
+
+/**
+* Creates a function that invokes two functions and merges their return values.
+*
+* @param {function} one Function to invoke first.
+* @param {function} two Function to invoke second.
+* @return {function} Function that invokes the two argument functions.
+* @private
+*/
+function createMergedResultFunction(one, two) {
+ return function mergedResult() {
+   var a = one.apply(this, arguments);
+   var b = two.apply(this, arguments);
+   if (a == null) {
+     return b;
+   } else if (b == null) {
+     return a;
+   }
+   var c = {};
+   mergeIntoWithNoDuplicateKeys(c, a);
+   mergeIntoWithNoDuplicateKeys(c, b);
+   return c;
+ };
+}
+
+/**
+* Creates a function that invokes two functions and ignores their return vales.
+*
+* @param {function} one Function to invoke first.
+* @param {function} two Function to invoke second.
+* @return {function} Function that invokes the two argument functions.
+* @private
+*/
+function createChainedFunction(one, two) {
+ return function chainedFunction() {
+   one.apply(this, arguments);
+   two.apply(this, arguments);
+ };
+}
+
+/**
+* Binds a method to the component.
+*
+* @param {object} component Component whose method is going to be bound.
+* @param {function} method Method to be bound.
+* @return {function} The bound method.
+*/
+function bindAutoBindMethod(component, method) {
+ var boundMethod = method.bind(component);
+ if ("development" !== 'production') {
+   boundMethod.__reactBoundContext = component;
+   boundMethod.__reactBoundMethod = method;
+   boundMethod.__reactBoundArguments = null;
+   var componentName = component.constructor.displayName;
+   var _bind = boundMethod.bind;
+   boundMethod.bind = function (newThis) {
+     for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+       args[_key - 1] = arguments[_key];
+     }
+
+     // User is trying to bind() an autobound method; we effectively will
+     // ignore the value of "this" that the user is trying to use, so
+     // let's warn.
+     if (newThis !== component && newThis !== null) {
+       "development" !== 'production' ? warning(false, 'bind(): React component methods may only be bound to the ' + 'component instance. See %s', componentName) : void 0;
+     } else if (!args.length) {
+       "development" !== 'production' ? warning(false, 'bind(): You are binding a component method to the component. ' + 'React does this for you automatically in a high-performance ' + 'way, so you can safely remove this call. See %s', componentName) : void 0;
+       return boundMethod;
+     }
+     var reboundMethod = _bind.apply(boundMethod, arguments);
+     reboundMethod.__reactBoundContext = component;
+     reboundMethod.__reactBoundMethod = method;
+     reboundMethod.__reactBoundArguments = args;
+     return reboundMethod;
+   };
+ }
+ return boundMethod;
+}
+
+/**
+* Binds all auto-bound methods in a component.
+*
+* @param {object} component Component whose method is going to be bound.
+*/
+function bindAutoBindMethods(component) {
+ var pairs = component.__reactAutoBindPairs;
+ for (var i = 0; i < pairs.length; i += 2) {
+   var autoBindKey = pairs[i];
+   var method = pairs[i + 1];
+   component[autoBindKey] = bindAutoBindMethod(component, method);
+ }
+}
+
+/**
+* Add more to the ReactClass base class. These are all legacy features and
+* therefore not already part of the modern ReactComponent.
+*/
+var ReactClassMixin = {
+
+ /**
+  * TODO: This will be deprecated because state should always keep a consistent
+  * type signature and the only use case for this, is to avoid that.
+  */
+ replaceState: function (newState, callback) {
+   this.updater.enqueueReplaceState(this, newState);
+   if (callback) {
+     this.updater.enqueueCallback(this, callback, 'replaceState');
+   }
+ },
+
+ /**
+  * Checks whether or not this composite component is mounted.
+  * @return {boolean} True if mounted, false otherwise.
+  * @protected
+  * @final
+  */
+ isMounted: function () {
+   return this.updater.isMounted(this);
+ }
+};
+
+var ReactClassComponent = function () {};
+_assign(ReactClassComponent.prototype, ReactComponent.prototype, ReactClassMixin);
+
+var didWarnDeprecated = false;
+
+/**
+* Module for creating composite components.
+*
+* @class ReactClass
+*/
+var ReactClass = {
+
+ /**
+  * Creates a composite component class given a class specification.
+  * See https://facebook.github.io/react/docs/top-level-api.html#react.createclass
+  *
+  * @param {object} spec Class specification (which must define `render`).
+  * @return {function} Component constructor function.
+  * @public
+  */
+ createClass: function (spec) {
+   if ("development" !== 'production') {
+     "development" !== 'production' ? warning(didWarnDeprecated, '%s: React.createClass is deprecated and will be removed in version 16. ' + 'Use plain JavaScript classes instead. If you\'re not yet ready to ' + 'migrate, create-react-class is available on npm as a ' + 'drop-in replacement.', spec && spec.displayName || 'A Component') : void 0;
+     didWarnDeprecated = true;
+   }
+
+   // To keep our warnings more understandable, we'll use a little hack here to
+   // ensure that Constructor.name !== 'Constructor'. This makes sure we don't
+   // unnecessarily identify a class without displayName as 'Constructor'.
+   var Constructor = identity(function (props, context, updater) {
+     // This constructor gets overridden by mocks. The argument is used
+     // by mocks to assert on what gets mounted.
+
+     if ("development" !== 'production') {
+       "development" !== 'production' ? warning(this instanceof Constructor, 'Something is calling a React component directly. Use a factory or ' + 'JSX instead. See: https://fb.me/react-legacyfactory') : void 0;
+     }
+
+     // Wire up auto-binding
+     if (this.__reactAutoBindPairs.length) {
+       bindAutoBindMethods(this);
+     }
+
+     this.props = props;
+     this.context = context;
+     this.refs = emptyObject;
+     this.updater = updater || ReactNoopUpdateQueue;
+
+     this.state = null;
+
+     // ReactClasses doesn't have constructors. Instead, they use the
+     // getInitialState and componentWillMount methods for initialization.
+
+     var initialState = this.getInitialState ? this.getInitialState() : null;
+     if ("development" !== 'production') {
+       // We allow auto-mocks to proceed as if they're returning null.
+       if (initialState === undefined && this.getInitialState._isMockFunction) {
+         // This is probably bad practice. Consider warning here and
+         // deprecating this convenience.
+         initialState = null;
+       }
+     }
+     !(typeof initialState === 'object' && !Array.isArray(initialState)) ? "development" !== 'production' ? invariant(false, '%s.getInitialState(): must return an object or null', Constructor.displayName || 'ReactCompositeComponent') : _prodInvariant('82', Constructor.displayName || 'ReactCompositeComponent') : void 0;
+
+     this.state = initialState;
+   });
+   Constructor.prototype = new ReactClassComponent();
+   Constructor.prototype.constructor = Constructor;
+   Constructor.prototype.__reactAutoBindPairs = [];
+
+   injectedMixins.forEach(mixSpecIntoComponent.bind(null, Constructor));
+
+   mixSpecIntoComponent(Constructor, spec);
+
+   // Initialize the defaultProps property after all mixins have been merged.
+   if (Constructor.getDefaultProps) {
+     Constructor.defaultProps = Constructor.getDefaultProps();
+   }
+
+   if ("development" !== 'production') {
+     // This is a tag to indicate that the use of these method names is ok,
+     // since it's used with createClass. If it's not, then it's likely a
+     // mistake so we'll warn you to use the static property, property
+     // initializer or constructor respectively.
+     if (Constructor.getDefaultProps) {
+       Constructor.getDefaultProps.isReactClassApproved = {};
+     }
+     if (Constructor.prototype.getInitialState) {
+       Constructor.prototype.getInitialState.isReactClassApproved = {};
+     }
+   }
+
+   !Constructor.prototype.render ? "development" !== 'production' ? invariant(false, 'createClass(...): Class specification must implement a `render` method.') : _prodInvariant('83') : void 0;
+
+   if ("development" !== 'production') {
+     "development" !== 'production' ? warning(!Constructor.prototype.componentShouldUpdate, '%s has a method called ' + 'componentShouldUpdate(). Did you mean shouldComponentUpdate()? ' + 'The name is phrased as a question because the function is ' + 'expected to return a value.', spec.displayName || 'A component') : void 0;
+     "development" !== 'production' ? warning(!Constructor.prototype.componentWillRecieveProps, '%s has a method called ' + 'componentWillRecieveProps(). Did you mean componentWillReceiveProps()?', spec.displayName || 'A component') : void 0;
+   }
+
+   // Reduce time spent doing lookups by setting these on the prototype.
+   for (var methodName in ReactClassInterface) {
+     if (!Constructor.prototype[methodName]) {
+       Constructor.prototype[methodName] = null;
+     }
+   }
+
+   return Constructor;
+ },
+
+ injection: {
+   injectMixin: function (mixin) {
+     injectedMixins.push(mixin);
+   }
+ }
+
+};
+
+module.exports = ReactClass;
+},{"10":10,"13":13,"14":14,"25":25,"28":28,"29":29,"30":30,"31":31,"6":6}],6:[function(_dereq_,module,exports){
+/**
+* Copyright 2013-present, Facebook, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the BSD-style license found in the
+* LICENSE file in the root directory of this source tree. An additional grant
+* of patent rights can be found in the PATENTS file in the same directory.
+*
+*/
+
+'use strict';
+
+var _prodInvariant = _dereq_(25);
+
+var ReactNoopUpdateQueue = _dereq_(13);
+
+var canDefineProperty = _dereq_(20);
+var emptyObject = _dereq_(28);
+var invariant = _dereq_(29);
+var warning = _dereq_(30);
+
+/**
+* Base class helpers for the updating state of a component.
+*/
+function ReactComponent(props, context, updater) {
+ this.props = props;
+ this.context = context;
+ this.refs = emptyObject;
+ // We initialize the default updater but the real one gets injected by the
+ // renderer.
+ this.updater = updater || ReactNoopUpdateQueue;
+}
+
+ReactComponent.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
+*/
+ReactComponent.prototype.setState = function (partialState, callback) {
+ !(typeof partialState === 'object' || typeof partialState === 'function' || partialState == null) ? "development" !== 'production' ? invariant(false, 'setState(...): takes an object of state variables to update or a function which returns an object of state variables.') : _prodInvariant('85') : void 0;
+ this.updater.enqueueSetState(this, partialState);
+ if (callback) {
+   this.updater.enqueueCallback(this, 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
+*/
+ReactComponent.prototype.forceUpdate = function (callback) {
+ this.updater.enqueueForceUpdate(this);
+ if (callback) {
+   this.updater.enqueueCallback(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.
+*/
+if ("development" !== 'production') {
+ 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) {
+   if (canDefineProperty) {
+     Object.defineProperty(ReactComponent.prototype, methodName, {
+       get: function () {
+         "development" !== 'production' ? warning(false, '%s(...) is deprecated in plain JavaScript React classes. %s', info[0], info[1]) : void 0;
+         return undefined;
+       }
+     });
+   }
+ };
+ for (var fnName in deprecatedAPIs) {
+   if (deprecatedAPIs.hasOwnProperty(fnName)) {
+     defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);
+   }
+ }
+}
+
+module.exports = ReactComponent;
+},{"13":13,"20":20,"25":25,"28":28,"29":29,"30":30}],7:[function(_dereq_,module,exports){
+/**
+* Copyright 2016-present, Facebook, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the BSD-style license found in the
+* LICENSE file in the root directory of this source tree. An additional grant
+* of patent rights can be found in the PATENTS file in the same directory.
+*
+*
+*/
+
+'use strict';
+
+var _prodInvariant = _dereq_(25);
+
+var ReactCurrentOwner = _dereq_(8);
+
+var invariant = _dereq_(29);
+var warning = _dereq_(30);
+
+function isNative(fn) {
+ // Based on isNative() from Lodash
+ var funcToString = Function.prototype.toString;
+ var hasOwnProperty = Object.prototype.hasOwnProperty;
+ var reIsNative = RegExp('^' + funcToString
+ // Take an example native function source for comparison
+ .call(hasOwnProperty)
+ // Strip regex characters so we can use it for regex
+ .replace(/[\\^$.*+?()[\]{}|]/g, '\\$&')
+ // Remove hasOwnProperty from the template to make it generic
+ .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$');
+ try {
+   var source = funcToString.call(fn);
+   return reIsNative.test(source);
+ } catch (err) {
+   return false;
+ }
+}
+
+var canUseCollections =
+// Array.from
+typeof Array.from === 'function' &&
+// Map
+typeof Map === 'function' && isNative(Map) &&
+// Map.prototype.keys
+Map.prototype != null && typeof Map.prototype.keys === 'function' && isNative(Map.prototype.keys) &&
+// Set
+typeof Set === 'function' && isNative(Set) &&
+// Set.prototype.keys
+Set.prototype != null && typeof Set.prototype.keys === 'function' && isNative(Set.prototype.keys);
+
+var setItem;
+var getItem;
+var removeItem;
+var getItemIDs;
+var addRoot;
+var removeRoot;
+var getRootIDs;
+
+if (canUseCollections) {
+ var itemMap = new Map();
+ var rootIDSet = new Set();
+
+ setItem = function (id, item) {
+   itemMap.set(id, item);
+ };
+ getItem = function (id) {
+   return itemMap.get(id);
+ };
+ removeItem = function (id) {
+   itemMap['delete'](id);
+ };
+ getItemIDs = function () {
+   return Array.from(itemMap.keys());
+ };
+
+ addRoot = function (id) {
+   rootIDSet.add(id);
+ };
+ removeRoot = function (id) {
+   rootIDSet['delete'](id);
+ };
+ getRootIDs = function () {
+   return Array.from(rootIDSet.keys());
+ };
+} else {
+ var itemByKey = {};
+ var rootByKey = {};
+
+ // Use non-numeric keys to prevent V8 performance issues:
+ // https://github.com/facebook/react/pull/7232
+ var getKeyFromID = function (id) {
+   return '.' + id;
+ };
+ var getIDFromKey = function (key) {
+   return parseInt(key.substr(1), 10);
+ };
+
+ setItem = function (id, item) {
+   var key = getKeyFromID(id);
+   itemByKey[key] = item;
+ };
+ getItem = function (id) {
+   var key = getKeyFromID(id);
+   return itemByKey[key];
+ };
+ removeItem = function (id) {
+   var key = getKeyFromID(id);
+   delete itemByKey[key];
+ };
+ getItemIDs = function () {
+   return Object.keys(itemByKey).map(getIDFromKey);
+ };
+
+ addRoot = function (id) {
+   var key = getKeyFromID(id);
+   rootByKey[key] = true;
+ };
+ removeRoot = function (id) {
+   var key = getKeyFromID(id);
+   delete rootByKey[key];
+ };
+ getRootIDs = function () {
+   return Object.keys(rootByKey).map(getIDFromKey);
+ };
+}
+
+var unmountedIDs = [];
+
+function purgeDeep(id) {
+ var item = getItem(id);
+ if (item) {
+   var childIDs = item.childIDs;
+
+   removeItem(id);
+   childIDs.forEach(purgeDeep);
+ }
+}
+
+function describeComponentFrame(name, source, ownerName) {
+ return '\n    in ' + (name || 'Unknown') + (source ? ' (at ' + source.fileName.replace(/^.*[\\\/]/, '') + ':' + source.lineNumber + ')' : ownerName ? ' (created by ' + ownerName + ')' : '');
+}
+
+function getDisplayName(element) {
+ if (element == null) {
+   return '#empty';
+ } else if (typeof element === 'string' || typeof element === 'number') {
+   return '#text';
+ } else if (typeof element.type === 'string') {
+   return element.type;
+ } else {
+   return element.type.displayName || element.type.name || 'Unknown';
+ }
+}
+
+function describeID(id) {
+ var name = ReactComponentTreeHook.getDisplayName(id);
+ var element = ReactComponentTreeHook.getElement(id);
+ var ownerID = ReactComponentTreeHook.getOwnerID(id);
+ var ownerName;
+ if (ownerID) {
+   ownerName = ReactComponentTreeHook.getDisplayName(ownerID);
+ }
+ "development" !== 'production' ? warning(element, 'ReactComponentTreeHook: Missing React element for debugID %s when ' + 'building stack', id) : void 0;
+ return describeComponentFrame(name, element && element._source, ownerName);
+}
+
+var ReactComponentTreeHook = {
+ onSetChildren: function (id, nextChildIDs) {
+   var item = getItem(id);
+   !item ? "development" !== 'production' ? invariant(false, 'Item must have been set') : _prodInvariant('144') : void 0;
+   item.childIDs = nextChildIDs;
+
+   for (var i = 0; i < nextChildIDs.length; i++) {
+     var nextChildID = nextChildIDs[i];
+     var nextChild = getItem(nextChildID);
+     !nextChild ? "development" !== 'production' ? invariant(false, 'Expected hook events to fire for the child before its parent includes it in onSetChildren().') : _prodInvariant('140') : void 0;
+     !(nextChild.childIDs != null || typeof nextChild.element !== 'object' || nextChild.element == null) ? "development" !== 'production' ? invariant(false, 'Expected onSetChildren() to fire for a container child before its parent includes it in onSetChildren().') : _prodInvariant('141') : void 0;
+     !nextChild.isMounted ? "development" !== 'production' ? invariant(false, 'Expected onMountComponent() to fire for the child before its parent includes it in onSetChildren().') : _prodInvariant('71') : void 0;
+     if (nextChild.parentID == null) {
+       nextChild.parentID = id;
+       // TODO: This shouldn't be necessary but mounting a new root during in
+       // componentWillMount currently causes not-yet-mounted components to
+       // be purged from our tree data so their parent id is missing.
+     }
+     !(nextChild.parentID === id) ? "development" !== 'production' ? invariant(false, 'Expected onBeforeMountComponent() parent and onSetChildren() to be consistent (%s has parents %s and %s).', nextChildID, nextChild.parentID, id) : _prodInvariant('142', nextChildID, nextChild.parentID, id) : void 0;
+   }
+ },
+ onBeforeMountComponent: function (id, element, parentID) {
+   var item = {
+     element: element,
+     parentID: parentID,
+     text: null,
+     childIDs: [],
+     isMounted: false,
+     updateCount: 0
+   };
+   setItem(id, item);
+ },
+ onBeforeUpdateComponent: function (id, element) {
+   var item = getItem(id);
+   if (!item || !item.isMounted) {
+     // We may end up here as a result of setState() in componentWillUnmount().
+     // In this case, ignore the element.
+     return;
+   }
+   item.element = element;
+ },
+ onMountComponent: function (id) {
+   var item = getItem(id);
+   !item ? "development" !== 'production' ? invariant(false, 'Item must have been set') : _prodInvariant('144') : void 0;
+   item.isMounted = true;
+   var isRoot = item.parentID === 0;
+   if (isRoot) {
+     addRoot(id);
+   }
+ },
+ onUpdateComponent: function (id) {
+   var item = getItem(id);
+   if (!item || !item.isMounted) {
+     // We may end up here as a result of setState() in componentWillUnmount().
+     // In this case, ignore the element.
+     return;
+   }
+   item.updateCount++;
+ },
+ onUnmountComponent: function (id) {
+   var item = getItem(id);
+   if (item) {
+     // We need to check if it exists.
+     // `item` might not exist if it is inside an error boundary, and a sibling
+     // error boundary child threw while mounting. Then this instance never
+     // got a chance to mount, but it still gets an unmounting event during
+     // the error boundary cleanup.
+     item.isMounted = false;
+     var isRoot = item.parentID === 0;
+     if (isRoot) {
+       removeRoot(id);
+     }
+   }
+   unmountedIDs.push(id);
+ },
+ purgeUnmountedComponents: function () {
+   if (ReactComponentTreeHook._preventPurging) {
+     // Should only be used for testing.
+     return;
+   }
+
+   for (var i = 0; i < unmountedIDs.length; i++) {
+     var id = unmountedIDs[i];
+     purgeDeep(id);
+   }
+   unmountedIDs.length = 0;
+ },
+ isMounted: function (id) {
+   var item = getItem(id);
+   return item ? item.isMounted : false;
+ },
+ getCurrentStackAddendum: function (topElement) {
+   var info = '';
+   if (topElement) {
+     var name = getDisplayName(topElement);
+     var owner = topElement._owner;
+     info += describeComponentFrame(name, topElement._source, owner && owner.getName());
+   }
+
+   var currentOwner = ReactCurrentOwner.current;
+   var id = currentOwner && currentOwner._debugID;
+
+   info += ReactComponentTreeHook.getStackAddendumByID(id);
+   return info;
+ },
+ getStackAddendumByID: function (id) {
+   var info = '';
+   while (id) {
+     info += describeID(id);
+     id = ReactComponentTreeHook.getParentID(id);
+   }
+   return info;
+ },
+ getChildIDs: function (id) {
+   var item = getItem(id);
+   return item ? item.childIDs : [];
+ },
+ getDisplayName: function (id) {
+   var element = ReactComponentTreeHook.getElement(id);
+   if (!element) {
+     return null;
+   }
+   return getDisplayName(element);
+ },
+ getElement: function (id) {
+   var item = getItem(id);
+   return item ? item.element : null;
+ },
+ getOwnerID: function (id) {
+   var element = ReactComponentTreeHook.getElement(id);
+   if (!element || !element._owner) {
+     return null;
+   }
+   return element._owner._debugID;
+ },
+ getParentID: function (id) {
+   var item = getItem(id);
+   return item ? item.parentID : null;
+ },
+ getSource: function (id) {
+   var item = getItem(id);
+   var element = item ? item.element : null;
+   var source = element != null ? element._source : null;
+   return source;
+ },
+ getText: function (id) {
+   var element = ReactComponentTreeHook.getElement(id);
+   if (typeof element === 'string') {
+     return element;
+   } else if (typeof element === 'number') {
+     return '' + element;
+   } else {
+     return null;
+   }
+ },
+ getUpdateCount: function (id) {
+   var item = getItem(id);
+   return item ? item.updateCount : 0;
+ },
+
+
+ getRootIDs: getRootIDs,
+ getRegisteredIDs: getItemIDs
+};
+
+module.exports = ReactComponentTreeHook;
+},{"25":25,"29":29,"30":30,"8":8}],8:[function(_dereq_,module,exports){
+/**
+* Copyright 2013-present, Facebook, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the BSD-style license found in the
+* LICENSE file in the root directory of this source tree. An additional grant
+* of patent rights can be found in the PATENTS file in the same directory.
+*
+*
+*/
+
+'use strict';
+
+/**
+* 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
+
+};
+
+module.exports = ReactCurrentOwner;
+},{}],9:[function(_dereq_,module,exports){
+/**
+* Copyright 2013-present, Facebook, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the BSD-style license found in the
+* LICENSE file in the root directory of this source tree. An additional grant
+* of patent rights can be found in the PATENTS file in the same directory.
+*
+*/
+
+'use strict';
+
+var ReactElement = _dereq_(10);
+
+/**
+* Create a factory that creates HTML tag elements.
+*
+* @private
+*/
+var createDOMFactory = ReactElement.createFactory;
+if ("development" !== 'production') {
+ var ReactElementValidator = _dereq_(12);
+ createDOMFactory = ReactElementValidator.createFactory;
+}
+
+/**
+* Creates a mapping from supported HTML tags to `ReactDOMComponent` classes.
+* This is also accessible via `React.DOM`.
+*
+* @public
+*/
+var ReactDOMFactories = {
+ a: createDOMFactory('a'),
+ abbr: createDOMFactory('abbr'),
+ address: createDOMFactory('address'),
+ area: createDOMFactory('area'),
+ article: createDOMFactory('article'),
+ aside: createDOMFactory('aside'),
+ audio: createDOMFactory('audio'),
+ b: createDOMFactory('b'),
+ base: createDOMFactory('base'),
+ bdi: createDOMFactory('bdi'),
+ bdo: createDOMFactory('bdo'),
+ big: createDOMFactory('big'),
+ blockquote: createDOMFactory('blockquote'),
+ body: createDOMFactory('body'),
+ br: createDOMFactory('br'),
+ button: createDOMFactory('button'),
+ canvas: createDOMFactory('canvas'),
+ caption: createDOMFactory('caption'),
+ cite: createDOMFactory('cite'),
+ code: createDOMFactory('code'),
+ col: createDOMFactory('col'),
+ colgroup: createDOMFactory('colgroup'),
+ data: createDOMFactory('data'),
+ datalist: createDOMFactory('datalist'),
+ dd: createDOMFactory('dd'),
+ del: createDOMFactory('del'),
+ details: createDOMFactory('details'),
+ dfn: createDOMFactory('dfn'),
+ dialog: createDOMFactory('dialog'),
+ div: createDOMFactory('div'),
+ dl: createDOMFactory('dl'),
+ dt: createDOMFactory('dt'),
+ em: createDOMFactory('em'),
+ embed: createDOMFactory('embed'),
+ fieldset: createDOMFactory('fieldset'),
+ figcaption: createDOMFactory('figcaption'),
+ figure: createDOMFactory('figure'),
+ footer: createDOMFactory('footer'),
+ form: createDOMFactory('form'),
+ h1: createDOMFactory('h1'),
+ h2: createDOMFactory('h2'),
+ h3: createDOMFactory('h3'),
+ h4: createDOMFactory('h4'),
+ h5: createDOMFactory('h5'),
+ h6: createDOMFactory('h6'),
+ head: createDOMFactory('head'),
+ header: createDOMFactory('header'),
+ hgroup: createDOMFactory('hgroup'),
+ hr: createDOMFactory('hr'),
+ html: createDOMFactory('html'),
+ i: createDOMFactory('i'),
+ iframe: createDOMFactory('iframe'),
+ img: createDOMFactory('img'),
+ input: createDOMFactory('input'),
+ ins: createDOMFactory('ins'),
+ kbd: createDOMFactory('kbd'),
+ keygen: createDOMFactory('keygen'),
+ label: createDOMFactory('label'),
+ legend: createDOMFactory('legend'),
+ li: createDOMFactory('li'),
+ link: createDOMFactory('link'),
+ main: createDOMFactory('main'),
+ map: createDOMFactory('map'),
+ mark: createDOMFactory('mark'),
+ menu: createDOMFactory('menu'),
+ menuitem: createDOMFactory('menuitem'),
+ meta: createDOMFactory('meta'),
+ meter: createDOMFactory('meter'),
+ nav: createDOMFactory('nav'),
+ noscript: createDOMFactory('noscript'),
+ object: createDOMFactory('object'),
+ ol: createDOMFactory('ol'),
+ optgroup: createDOMFactory('optgroup'),
+ option: createDOMFactory('option'),
+ output: createDOMFactory('output'),
+ p: createDOMFactory('p'),
+ param: createDOMFactory('param'),
+ picture: createDOMFactory('picture'),
+ pre: createDOMFactory('pre'),
+ progress: createDOMFactory('progress'),
+ q: createDOMFactory('q'),
+ rp: createDOMFactory('rp'),
+ rt: createDOMFactory('rt'),
+ ruby: createDOMFactory('ruby'),
+ s: createDOMFactory('s'),
+ samp: createDOMFactory('samp'),
+ script: createDOMFactory('script'),
+ section: createDOMFactory('section'),
+ select: createDOMFactory('select'),
+ small: createDOMFactory('small'),
+ source: createDOMFactory('source'),
+ span: createDOMFactory('span'),
+ strong: createDOMFactory('strong'),
+ style: createDOMFactory('style'),
+ sub: createDOMFactory('sub'),
+ summary: createDOMFactory('summary'),
+ sup: createDOMFactory('sup'),
+ table: createDOMFactory('table'),
+ tbody: createDOMFactory('tbody'),
+ td: createDOMFactory('td'),
+ textarea: createDOMFactory('textarea'),
+ tfoot: createDOMFactory('tfoot'),
+ th: createDOMFactory('th'),
+ thead: createDOMFactory('thead'),
+ time: createDOMFactory('time'),
+ title: createDOMFactory('title'),
+ tr: createDOMFactory('tr'),
+ track: createDOMFactory('track'),
+ u: createDOMFactory('u'),
+ ul: createDOMFactory('ul'),
+ 'var': createDOMFactory('var'),
+ video: createDOMFactory('video'),
+ wbr: createDOMFactory('wbr'),
+
+ // SVG
+ circle: createDOMFactory('circle'),
+ clipPath: createDOMFactory('clipPath'),
+ defs: createDOMFactory('defs'),
+ ellipse: createDOMFactory('ellipse'),
+ g: createDOMFactory('g'),
+ image: createDOMFactory('image'),
+ line: createDOMFactory('line'),
+ linearGradient: createDOMFactory('linearGradient'),
+ mask: createDOMFactory('mask'),
+ path: createDOMFactory('path'),
+ pattern: createDOMFactory('pattern'),
+ polygon: createDOMFactory('polygon'),
+ polyline: createDOMFactory('polyline'),
+ radialGradient: createDOMFactory('radialGradient'),
+ rect: createDOMFactory('rect'),
+ stop: createDOMFactory('stop'),
+ svg: createDOMFactory('svg'),
+ text: createDOMFactory('text'),
+ tspan: createDOMFactory('tspan')
+};
+
+module.exports = ReactDOMFactories;
+},{"10":10,"12":12}],10:[function(_dereq_,module,exports){
+/**
+* Copyright 2014-present, Facebook, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the BSD-style license found in the
+* LICENSE file in the root directory of this source tree. An additional grant
+* of patent rights can be found in the PATENTS file in the same directory.
+*
+*/
+
+'use strict';
+
+var _assign = _dereq_(31);
+
+var ReactCurrentOwner = _dereq_(8);
+
+var warning = _dereq_(30);
+var canDefineProperty = _dereq_(20);
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+var REACT_ELEMENT_TYPE = _dereq_(11);
+
+var RESERVED_PROPS = {
+ key: true,
+ ref: true,
+ __self: true,
+ __source: true
+};
+
+var specialPropKeyWarningShown, specialPropRefWarningShown;
+
+function hasValidRef(config) {
+ if ("development" !== 'production') {
+   if (hasOwnProperty.call(config, 'ref')) {
+     var getter = Object.getOwnPropertyDescriptor(config, 'ref').get;
+     if (getter && getter.isReactWarning) {
+       return false;
+     }
+   }
+ }
+ return config.ref !== undefined;
+}
+
+function hasValidKey(config) {
+ if ("development" !== 'production') {
+   if (hasOwnProperty.call(config, 'key')) {
+     var getter = Object.getOwnPropertyDescriptor(config, 'key').get;
+     if (getter && getter.isReactWarning) {
+       return false;
+     }
+   }
+ }
+ return config.key !== undefined;
+}
+
+function defineKeyPropWarningGetter(props, displayName) {
+ var warnAboutAccessingKey = function () {
+   if (!specialPropKeyWarningShown) {
+     specialPropKeyWarningShown = true;
+     "development" !== 'production' ? 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) : void 0;
+   }
+ };
+ warnAboutAccessingKey.isReactWarning = true;
+ Object.defineProperty(props, 'key', {
+   get: warnAboutAccessingKey,
+   configurable: true
+ });
+}
+
+function defineRefPropWarningGetter(props, displayName) {
+ var warnAboutAccessingRef = function () {
+   if (!specialPropRefWarningShown) {
+     specialPropRefWarningShown = true;
+     "development" !== 'production' ? 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) : void 0;
+   }
+ };
+ warnAboutAccessingRef.isReactWarning = true;
+ Object.defineProperty(props, 'ref', {
+   get: warnAboutAccessingRef,
+   configurable: true
+ });
+}
+
+/**
+* Factory method to create a new React element. This no longer adheres to
+* the class pattern, so do not use new to call it. Also, no instanceof check
+* will work. Instead test $$typeof field against Symbol.for('react.element') to check
+* if something is a React Element.
+*
+* @param {*} type
+* @param {*} key
+* @param {string|object} ref
+* @param {*} self A *temporary* helper to detect places where `this` is
+* different from the `owner` when React.createElement is called, so that we
+* can warn. We want to get rid of owner and replace string `ref`s with arrow
+* functions, and as long as `this` and owner are the same, there will be no
+* change in behavior.
+* @param {*} source An annotation object (added by a transpiler or otherwise)
+* indicating filename, line number, and/or other information.
+* @param {*} owner
+* @param {*} props
+* @internal
+*/
+var ReactElement = function (type, key, ref, self, source, owner, props) {
+ var element = {
+   // This tag allow us to uniquely identify this as a React Element
+   $$typeof: REACT_ELEMENT_TYPE,
+
+   // Built-in properties that belong on the element
+   type: type,
+   key: key,
+   ref: ref,
+   props: props,
+
+   // Record the component responsible for creating this element.
+   _owner: owner
+ };
+
+ if ("development" !== 'production') {
+   // The validation flag is currently mutative. We put it on
+   // an external backing store so that we can freeze the whole object.
+   // This can be replaced with a WeakMap once they are implemented in
+   // commonly used development environments.
+   element._store = {};
+
+   // To make comparing ReactElements easier for testing purposes, we make
+   // the validation flag non-enumerable (where possible, which should
+   // include every environment we run tests in), so the test framework
+   // ignores it.
+   if (canDefineProperty) {
+     Object.defineProperty(element._store, 'validated', {
+       configurable: false,
+       enumerable: false,
+       writable: true,
+       value: false
+     });
+     // self and source are DEV only properties.
+     Object.defineProperty(element, '_self', {
+       configurable: false,
+       enumerable: false,
+       writable: false,
+       value: self
+     });
+     // Two elements created in two different places should be considered
+     // equal for testing purposes and therefore we hide it from enumeration.
+     Object.defineProperty(element, '_source', {
+       configurable: false,
+       enumerable: false,
+       writable: false,
+       value: source
+     });
+   } else {
+     element._store.validated = false;
+     element._self = self;
+     element._source = source;
+   }
+   if (Object.freeze) {
+     Object.freeze(element.props);
+     Object.freeze(element);
+   }
+ }
+
+ return element;
+};
+
+/**
+* Create and return a new ReactElement of the given type.
+* See https://facebook.github.io/react/docs/top-level-api.html#react.createelement
+*/
+ReactElement.createElement = function (type, config, children) {
+ var propName;
+
+ // Reserved names are extracted
+ var props = {};
+
+ var key = null;
+ var ref = null;
+ var self = null;
+ var source = null;
+
+ if (config != null) {
+   if (hasValidRef(config)) {
+     ref = config.ref;
+   }
+   if (hasValidKey(config)) {
+     key = '' + config.key;
+   }
+
+   self = config.__self === undefined ? null : config.__self;
+   source = config.__source === undefined ? null : config.__source;
+   // Remaining properties are added to a new props object
+   for (propName in config) {
+     if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
+       props[propName] = config[propName];
+     }
+   }
+ }
+
+ // Children can be more than one argument, and those are transferred onto
+ // the newly allocated props object.
+ var childrenLength = arguments.length - 2;
+ if (childrenLength === 1) {
+   props.children = children;
+ } else if (childrenLength > 1) {
+   var childArray = Array(childrenLength);
+   for (var i = 0; i < childrenLength; i++) {
+     childArray[i] = arguments[i + 2];
+   }
+   if ("development" !== 'production') {
+     if (Object.freeze) {
+       Object.freeze(childArray);
+     }
+   }
+   props.children = childArray;
+ }
+
+ // Resolve default props
+ if (type && type.defaultProps) {
+   var defaultProps = type.defaultProps;
+   for (propName in defaultProps) {
+     if (props[propName] === undefined) {
+       props[propName] = defaultProps[propName];
+     }
+   }
+ }
+ if ("development" !== 'production') {
+   if (key || ref) {
+     if (typeof props.$$typeof === 'undefined' || props.$$typeof !== REACT_ELEMENT_TYPE) {
+       var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type;
+       if (key) {
+         defineKeyPropWarningGetter(props, displayName);
+       }
+       if (ref) {
+         defineRefPropWarningGetter(props, displayName);
+       }
+     }
+   }
+ }
+ return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
+};
+
+/**
+* Return a function that produces ReactElements of a given type.
+* See https://facebook.github.io/react/docs/top-level-api.html#react.createfactory
+*/
+ReactElement.createFactory = function (type) {
+ var factory = ReactElement.createElement.bind(null, type);
+ // Expose the type on the factory and the prototype so that it can be
+ // easily accessed on elements. E.g. `<Foo />.type === Foo`.
+ // This should not be named `constructor` since this may not be the function
+ // that created the element, and it may not even be a constructor.
+ // Legacy hook TODO: Warn if this is accessed
+ factory.type = type;
+ return factory;
+};
+
+ReactElement.cloneAndReplaceKey = function (oldElement, newKey) {
+ var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props);
+
+ return newElement;
+};
+
+/**
+* Clone and return a new ReactElement using element as the starting point.
+* See https://facebook.github.io/react/docs/top-level-api.html#react.cloneelement
+*/
+ReactElement.cloneElement = function (element, config, children) {
+ var propName;
+
+ // Original props are copied
+ var props = _assign({}, element.props);
+
+ // Reserved names are extracted
+ var key = element.key;
+ var ref = element.ref;
+ // Self is preserved since the owner is preserved.
+ var self = element._self;
+ // Source is preserved since cloneElement is unlikely to be targeted by a
+ // transpiler, and the original source is probably a better indicator of the
+ // true owner.
+ var source = element._source;
+
+ // Owner will be preserved, unless ref is overridden
+ var owner = element._owner;
+
+ if (config != null) {
+   if (hasValidRef(config)) {
+     // Silently steal the ref from the parent.
+     ref = config.ref;
+     owner = ReactCurrentOwner.current;
+   }
+   if (hasValidKey(config)) {
+     key = '' + config.key;
+   }
+
+   // Remaining properties override existing props
+   var defaultProps;
+   if (element.type && element.type.defaultProps) {
+     defaultProps = element.type.defaultProps;
+   }
+   for (propName in config) {
+     if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
+       if (config[propName] === undefined && defaultProps !== undefined) {
+         // Resolve default props
+         props[propName] = defaultProps[propName];
+       } else {
+         props[propName] = config[propName];
+       }
+     }
+   }
+ }
+
+ // Children can be more than one argument, and those are transferred onto
+ // the newly allocated props object.
+ var childrenLength = arguments.length - 2;
+ if (childrenLength === 1) {
+   props.children = children;
+ } else if (childrenLength > 1) {
+   var childArray = Array(childrenLength);
+   for (var i = 0; i < childrenLength; i++) {
+     childArray[i] = arguments[i + 2];
+   }
+   props.children = childArray;
+ }
+
+ return ReactElement(element.type, key, ref, self, source, owner, props);
+};
+
+/**
+* Verifies the object is a ReactElement.
+* See https://facebook.github.io/react/docs/top-level-api.html#react.isvalidelement
+* @param {?object} object
+* @return {boolean} True if `object` is a valid component.
+* @final
+*/
+ReactElement.isValidElement = function (object) {
+ return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+};
+
+module.exports = ReactElement;
+},{"11":11,"20":20,"30":30,"31":31,"8":8}],11:[function(_dereq_,module,exports){
+/**
+* Copyright 2014-present, Facebook, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the BSD-style license found in the
+* LICENSE file in the root directory of this source tree. An additional grant
+* of patent rights can be found in the PATENTS file in the same directory.
+*
+*
+*/
+
+'use strict';
+
+// The Symbol used to tag the ReactElement type. If there is no native Symbol
+// nor polyfill, then a plain number is used for performance.
+
+var REACT_ELEMENT_TYPE = typeof Symbol === 'function' && Symbol['for'] && Symbol['for']('react.element') || 0xeac7;
+
+module.exports = REACT_ELEMENT_TYPE;
+},{}],12:[function(_dereq_,module,exports){
+/**
+* Copyright 2014-present, Facebook, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the BSD-style license found in the
+* LICENSE file in the root directory of this source tree. An additional grant
+* of patent rights can be found in the PATENTS file in the same directory.
+*
+*/
+
+/**
+* ReactElementValidator provides a wrapper around a element factory
+* which validates the props passed to the element. This is intended to be
+* used only in DEV and could be replaced by a static type checker for languages
+* that support it.
+*/
+
+'use strict';
+
+var ReactCurrentOwner = _dereq_(8);
+var ReactComponentTreeHook = _dereq_(7);
+var ReactElement = _dereq_(10);
+
+var checkReactTypeSpec = _dereq_(21);
+
+var canDefineProperty = _dereq_(20);
+var getIteratorFn = _dereq_(22);
+var warning = _dereq_(30);
+
+function getDeclarationErrorAddendum() {
+ if (ReactCurrentOwner.current) {
+   var name = ReactCurrentOwner.current.getName();
+   if (name) {
+     return ' Check the render method of `' + name + '`.';
+   }
+ }
+ return '';
+}
+
+function getSourceInfoErrorAddendum(elementProps) {
+ if (elementProps !== null && elementProps !== undefined && elementProps.__source !== undefined) {
+   var source = elementProps.__source;
+   var fileName = source.fileName.replace(/^.*[\\\/]/, '');
+   var lineNumber = source.lineNumber;
+   return ' Check your code at ' + fileName + ':' + lineNumber + '.';
+ }
+ return '';
+}
+
+/**
+* Warn if there's no key explicitly set on dynamic arrays of children or
+* object keys are not valid. This allows us to keep track of children between
+* updates.
+*/
+var ownerHasKeyUseWarning = {};
+
+function getCurrentComponentErrorInfo(parentType) {
+ var info = getDeclarationErrorAddendum();
+
+ if (!info) {
+   var parentName = typeof parentType === 'string' ? parentType : parentType.displayName || parentType.name;
+   if (parentName) {
+     info = ' Check the top-level render call using <' + parentName + '>.';
+   }
+ }
+ return info;
+}
+
+/**
+* Warn if the element doesn't have an explicit key assigned to it.
+* This element is in an array. The array could grow and shrink or be
+* reordered. All children that haven't already been validated are required to
+* have a "key" property assigned to it. Error statuses are cached so a warning
+* will only be shown once.
+*
+* @internal
+* @param {ReactElement} element Element that requires a key.
+* @param {*} parentType element's parent's type.
+*/
+function validateExplicitKey(element, parentType) {
+ if (!element._store || element._store.validated || element.key != null) {
+   return;
+ }
+ element._store.validated = true;
+
+ var memoizer = ownerHasKeyUseWarning.uniqueKey || (ownerHasKeyUseWarning.uniqueKey = {});
+
+ var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);
+ if (memoizer[currentComponentErrorInfo]) {
+   return;
+ }
+ memoizer[currentComponentErrorInfo] = true;
+
+ // Usually the current owner is the offender, but if it accepts children as a
+ // property, it may be the creator of the child that's responsible for
+ // assigning it a key.
+ var childOwner = '';
+ if (element && element._owner && element._owner !== ReactCurrentOwner.current) {
+   // Give the component that originally created this child.
+   childOwner = ' It was passed a child from ' + element._owner.getName() + '.';
+ }
+
+ "development" !== 'production' ? 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, ReactComponentTreeHook.getCurrentStackAddendum(element)) : void 0;
+}
+
+/**
+* Ensure that every element either is passed in a static location, in an
+* array with an explicit keys property defined, or in an object literal
+* with valid key property.
+*
+* @internal
+* @param {ReactNode} node Statically passed child of any type.
+* @param {*} parentType node's parent's type.
+*/
+function validateChildKeys(node, parentType) {
+ if (typeof node !== 'object') {
+   return;
+ }
+ if (Array.isArray(node)) {
+   for (var i = 0; i < node.length; i++) {
+     var child = node[i];
+     if (ReactElement.isValidElement(child)) {
+       validateExplicitKey(child, parentType);
+     }
+   }
+ } else if (ReactElement.isValidElement(node)) {
+   // This element was passed in a valid location.
+   if (node._store) {
+     node._store.validated = true;
+   }
+ } else if (node) {
+   var iteratorFn = getIteratorFn(node);
+   // Entry iterators provide implicit keys.
+   if (iteratorFn) {
+     if (iteratorFn !== node.entries) {
+       var iterator = iteratorFn.call(node);
+       var step;
+       while (!(step = iterator.next()).done) {
+         if (ReactElement.isValidElement(step.value)) {
+           validateExplicitKey(step.value, parentType);
+         }
+       }
+     }
+   }
+ }
+}
+
+/**
+* Given an element, validate that its props follow the propTypes definition,
+* provided by the type.
+*
+* @param {ReactElement} element
+*/
+function validatePropTypes(element) {
+ var componentClass = element.type;
+ if (typeof componentClass !== 'function') {
+   return;
+ }
+ var name = componentClass.displayName || componentClass.name;
+ if (componentClass.propTypes) {
+   checkReactTypeSpec(componentClass.propTypes, element.props, 'prop', name, element, null);
+ }
+ if (typeof componentClass.getDefaultProps === 'function') {
+   "development" !== 'production' ? warning(componentClass.getDefaultProps.isReactClassApproved, 'getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.') : void 0;
+ }
+}
+
+var ReactElementValidator = {
+
+ createElement: function (type, props, children) {
+   var validType = typeof type === 'string' || typeof type === 'function';
+   // We warn in this case but don't throw. We expect the element creation to
+   // succeed and there will likely be errors in render.
+   if (!validType) {
+     if (typeof type !== 'function' && typeof type !== 'string') {
+       var info = '';
+       if (type === undefined || typeof type === 'object' && type !== null && Object.keys(type).length === 0) {
+         info += ' You likely forgot to export your component from the file ' + 'it\'s defined in.';
+       }
+
+       var sourceInfo = getSourceInfoErrorAddendum(props);
+       if (sourceInfo) {
+         info += sourceInfo;
+       } else {
+         info += getDeclarationErrorAddendum();
+       }
+
+       info += ReactComponentTreeHook.getCurrentStackAddendum();
+
+       "development" !== 'production' ? 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) : void 0;
+     }
+   }
+
+   var element = ReactElement.createElement.apply(this, arguments);
+
+   // The result can be nullish if a mock or a custom function is used.
+   // TODO: Drop this when these are no longer allowed as the type argument.
+   if (element == null) {
+     return element;
+   }
+
+   // Skip key warning if the type isn't valid since our key validation logic
+   // doesn't expect a non-string/function type and can throw confusing errors.
+   // We don't want exception behavior to differ between dev and prod.
+   // (Rendering will throw with a helpful message and as soon as the type is
+   // fixed, the key warnings will appear.)
+   if (validType) {
+     for (var i = 2; i < arguments.length; i++) {
+       validateChildKeys(arguments[i], type);
+     }
+   }
+
+   validatePropTypes(element);
+
+   return element;
+ },
+
+ createFactory: function (type) {
+   var validatedFactory = ReactElementValidator.createElement.bind(null, type);
+   // Legacy hook TODO: Warn if this is accessed
+   validatedFactory.type = type;
+
+   if ("development" !== 'production') {
+     if (canDefineProperty) {
+       Object.defineProperty(validatedFactory, 'type', {
+         enumerable: false,
+         get: function () {
+           "development" !== 'production' ? warning(false, 'Factory.type is deprecated. Access the class directly ' + 'before passing it to createFactory.') : void 0;
+           Object.defineProperty(this, 'type', {
+             value: type
+           });
+           return type;
+         }
+       });
+     }
+   }
+
+   return validatedFactory;
+ },
+
+ cloneElement: function (element, props, children) {
+   var newElement = ReactElement.cloneElement.apply(this, arguments);
+   for (var i = 2; i < arguments.length; i++) {
+     validateChildKeys(arguments[i], newElement.type);
+   }
+   validatePropTypes(newElement);
+   return newElement;
+ }
+
+};
+
+module.exports = ReactElementValidator;
+},{"10":10,"20":20,"21":21,"22":22,"30":30,"7":7,"8":8}],13:[function(_dereq_,module,exports){
+/**
+* Copyright 2015-present, Facebook, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the BSD-style license found in the
+* LICENSE file in the root directory of this source tree. An additional grant
+* of patent rights can be found in the PATENTS file in the same directory.
+*
+*/
+
+'use strict';
+
+var warning = _dereq_(30);
+
+function warnNoop(publicInstance, callerName) {
+ if ("development" !== 'production') {
+   var constructor = publicInstance.constructor;
+   "development" !== 'production' ? 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. Please check the code for the %s component.', callerName, callerName, constructor && (constructor.displayName || constructor.name) || 'ReactClass') : void 0;
+ }
+}
+
+/**
+* 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;
+ },
+
+ /**
+  * Enqueue a callback that will be executed after all the pending updates
+  * have processed.
+  *
+  * @param {ReactClass} publicInstance The instance to use as `this` context.
+  * @param {?function} callback Called after state is updated.
+  * @internal
+  */
+ enqueueCallback: function (publicInstance, callback) {},
+
+ /**
+  * 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.
+  * @internal
+  */
+ enqueueForceUpdate: function (publicInstance) {
+   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.
+  * @internal
+  */
+ enqueueReplaceState: function (publicInstance, completeState) {
+   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.
+  * @internal
+  */
+ enqueueSetState: function (publicInstance, partialState) {
+   warnNoop(publicInstance, 'setState');
+ }
+};
+
+module.exports = ReactNoopUpdateQueue;
+},{"30":30}],14:[function(_dereq_,module,exports){
+/**
+* Copyright 2013-present, Facebook, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the BSD-style license found in the
+* LICENSE file in the root directory of this source tree. An additional grant
+* of patent rights can be found in the PATENTS file in the same directory.
+*
+*
+*/
+
+'use strict';
+
+var ReactPropTypeLocationNames = {};
+
+if ("development" !== 'production') {
+ ReactPropTypeLocationNames = {
+   prop: 'prop',
+   context: 'context',
+   childContext: 'child context'
+ };
+}
+
+module.exports = ReactPropTypeLocationNames;
+},{}],15:[function(_dereq_,module,exports){
+/**
+* Copyright 2013-present, Facebook, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the BSD-style license found in the
+* LICENSE file in the root directory of this source tree. An additional grant
+* of patent rights can be found in the PATENTS file in the same directory.
+*
+*/
+
+'use strict';
+
+var _require = _dereq_(10),
+   isValidElement = _require.isValidElement;
+
+var factory = _dereq_(33);
+
+module.exports = factory(isValidElement);
+},{"10":10,"33":33}],16:[function(_dereq_,module,exports){
+/**
+* Copyright 2013-present, Facebook, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the BSD-style license found in the
+* LICENSE file in the root directory of this source tree. An additional grant
+* of patent rights can be found in the PATENTS file in the same directory.
+*
+*
+*/
+
+'use strict';
+
+var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
+
+module.exports = ReactPropTypesSecret;
+},{}],17:[function(_dereq_,module,exports){
+/**
+* Copyright 2013-present, Facebook, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the BSD-style license found in the
+* LICENSE file in the root directory of this source tree. An additional grant
+* of patent rights can be found in the PATENTS file in the same directory.
+*
+*/
+
+'use strict';
+
+var _assign = _dereq_(31);
+
+var ReactComponent = _dereq_(6);
+var ReactNoopUpdateQueue = _dereq_(13);
+
+var emptyObject = _dereq_(28);
+
+/**
+* Base class helpers for the updating state of a component.
+*/
+function ReactPureComponent(props, context, updater) {
+ // Duplicated from ReactComponent.
+ this.props = props;
+ this.context = context;
+ this.refs = emptyObject;
+ // We initialize the default updater but the real one gets injected by the
+ // renderer.
+ this.updater = updater || ReactNoopUpdateQueue;
+}
+
+function ComponentDummy() {}
+ComponentDummy.prototype = ReactComponent.prototype;
+ReactPureComponent.prototype = new ComponentDummy();
+ReactPureComponent.prototype.constructor = ReactPureComponent;
+// Avoid an extra prototype jump for these methods.
+_assign(ReactPureComponent.prototype, ReactComponent.prototype);
+ReactPureComponent.prototype.isPureReactComponent = true;
+
+module.exports = ReactPureComponent;
+},{"13":13,"28":28,"31":31,"6":6}],18:[function(_dereq_,module,exports){
+/**
+* Copyright 2013-present, Facebook, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the BSD-style license found in the
+* LICENSE file in the root directory of this source tree. An additional grant
+* of patent rights can be found in the PATENTS file in the same directory.
+*
+*/
+
+'use strict';
+
+var _assign = _dereq_(31);
+
+var React = _dereq_(3);
+
+// `version` will be added here by the React module.
+var ReactUMDEntry = _assign(React, {
+ __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: {
+   ReactCurrentOwner: _dereq_(8)
+ }
+});
+
+if ("development" !== 'production') {
+ _assign(ReactUMDEntry.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED, {
+   // ReactComponentTreeHook should not be included in production.
+   ReactComponentTreeHook: _dereq_(7),
+   getNextDebugID: _dereq_(23)
+ });
+}
+
+module.exports = ReactUMDEntry;
+},{"23":23,"3":3,"31":31,"7":7,"8":8}],19:[function(_dereq_,module,exports){
+/**
+* Copyright 2013-present, Facebook, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the BSD-style license found in the
+* LICENSE file in the root directory of this source tree. An additional grant
+* of patent rights can be found in the PATENTS file in the same directory.
+*
+*/
+
+'use strict';
+
+module.exports = '15.5.4';
+},{}],20:[function(_dereq_,module,exports){
+/**
+* Copyright 2013-present, Facebook, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the BSD-style license found in the
+* LICENSE file in the root directory of this source tree. An additional grant
+* of patent rights can be found in the PATENTS file in the same directory.
+*
+*
+*/
+
+'use strict';
+
+var canDefineProperty = false;
+if ("development" !== 'production') {
+ try {
+   // $FlowFixMe https://github.com/facebook/flow/issues/285
+   Object.defineProperty({}, 'x', { get: function () {} });
+   canDefineProperty = true;
+ } catch (x) {
+   // IE will fail on defineProperty
+ }
+}
+
+module.exports = canDefineProperty;
+},{}],21:[function(_dereq_,module,exports){
+(function (process){
+/**
+* Copyright 2013-present, Facebook, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the BSD-style license found in the
+* LICENSE file in the root directory of this source tree. An additional grant
+* of patent rights can be found in the PATENTS file in the same directory.
+*
+*/
+
+'use strict';
+
+var _prodInvariant = _dereq_(25);
+
+var ReactPropTypeLocationNames = _dereq_(14);
+var ReactPropTypesSecret = _dereq_(16);
+
+var invariant = _dereq_(29);
+var warning = _dereq_(30);
+
+var ReactComponentTreeHook;
+
+if (typeof process !== 'undefined' && process.env && "development" === 'test') {
+ // Temporary hack.
+ // Inline requires don't work well with Jest:
+ // https://github.com/facebook/react/issues/7240
+ // Remove the inline requires when we don't need them anymore:
+ // https://github.com/facebook/react/pull/7178
+ ReactComponentTreeHook = _dereq_(7);
+}
+
+var loggedTypeFailures = {};
+
+/**
+* Assert that the values match with the type specs.
+* Error messages are memorized and will only be shown once.
+*
+* @param {object} typeSpecs Map of name to a ReactPropType
+* @param {object} values Runtime values that need to be type-checked
+* @param {string} location e.g. "prop", "context", "child context"
+* @param {string} componentName Name of the component for error messages.
+* @param {?object} element The React element that is being type-checked
+* @param {?number} debugID The React component instance that is being type-checked
+* @private
+*/
+function checkReactTypeSpec(typeSpecs, values, location, componentName, element, debugID) {
+ for (var typeSpecName in typeSpecs) {
+   if (typeSpecs.hasOwnProperty(typeSpecName)) {
+     var error;
+     // Prop type validation may throw. In case they do, we don't want to
+     // fail the render phase where it didn't fail before. So we log it.
+     // After these have been cleaned up, we'll let them throw.
+     try {
+       // This is intentionally an invariant that gets caught. It's the same
+       // behavior as without this statement except with a better message.
+       !(typeof typeSpecs[typeSpecName] === 'function') ? "development" !== 'production' ? invariant(false, '%s: %s type `%s` is invalid; it must be a function, usually from React.PropTypes.', componentName || 'React class', ReactPropTypeLocationNames[location], typeSpecName) : _prodInvariant('84', componentName || 'React class', ReactPropTypeLocationNames[location], typeSpecName) : void 0;
+       error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
+     } catch (ex) {
+       error = ex;
+     }
+     "development" !== 'production' ? warning(!error || error instanceof Error, '%s: type specification of %s `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', ReactPropTypeLocationNames[location], typeSpecName, typeof error) : void 0;
+     if (error instanceof Error && !(error.message in loggedTypeFailures)) {
+       // Only monitor this failure once because there tends to be a lot of the
+       // same error.
+       loggedTypeFailures[error.message] = true;
+
+       var componentStackInfo = '';
+
+       if ("development" !== 'production') {
+         if (!ReactComponentTreeHook) {
+           ReactComponentTreeHook = _dereq_(7);
+         }
+         if (debugID !== null) {
+           componentStackInfo = ReactComponentTreeHook.getStackAddendumByID(debugID);
+         } else if (element !== null) {
+           componentStackInfo = ReactComponentTreeHook.getCurrentStackAddendum(element);
+         }
+       }
+
+       "development" !== 'production' ? warning(false, 'Failed %s type: %s%s', location, error.message, componentStackInfo) : void 0;
+     }
+   }
+ }
+}
+
+module.exports = checkReactTypeSpec;
+}).call(this,undefined)
+},{"14":14,"16":16,"25":25,"29":29,"30":30,"7":7}],22:[function(_dereq_,module,exports){
+/**
+* Copyright 2013-present, Facebook, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the BSD-style license found in the
+* LICENSE file in the root directory of this source tree. An additional grant
+* of patent rights can be found in the PATENTS file in the same directory.
+*
+*
+*/
+
+'use strict';
+
+/* global Symbol */
+
+var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
+var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.
+
+/**
+* Returns the iterator method function contained on the iterable object.
+*
+* Be sure to invoke the function with the iterable as context:
+*
+*     var iteratorFn = getIteratorFn(myIterable);
+*     if (iteratorFn) {
+*       var iterator = iteratorFn.call(myIterable);
+*       ...
+*     }
+*
+* @param {?object} maybeIterable
+* @return {?function}
+*/
+function getIteratorFn(maybeIterable) {
+ var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);
+ if (typeof iteratorFn === 'function') {
+   return iteratorFn;
+ }
+}
+
+module.exports = getIteratorFn;
+},{}],23:[function(_dereq_,module,exports){
+/**
+* Copyright 2013-present, Facebook, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the BSD-style license found in the
+* LICENSE file in the root directory of this source tree. An additional grant
+* of patent rights can be found in the PATENTS file in the same directory.
+*
+*
+*/
+
+'use strict';
+
+var nextDebugID = 1;
+
+function getNextDebugID() {
+ return nextDebugID++;
+}
+
+module.exports = getNextDebugID;
+},{}],24:[function(_dereq_,module,exports){
+/**
+* Copyright 2013-present, Facebook, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the BSD-style license found in the
+* LICENSE file in the root directory of this source tree. An additional grant
+* of patent rights can be found in the PATENTS file in the same directory.
+*
+*/
+'use strict';
+
+var _prodInvariant = _dereq_(25);
+
+var ReactElement = _dereq_(10);
+
+var invariant = _dereq_(29);
+
+/**
+* Returns the first child in a collection of children and verifies that there
+* is only one child in the collection.
+*
+* See https://facebook.github.io/react/docs/top-level-api.html#react.children.only
+*
+* The current implementation of this function assumes that a single child gets
+* passed without a wrapper, but the purpose of this helper function is to
+* abstract away the particular structure of children.
+*
+* @param {?object} children Child collection structure.
+* @return {ReactElement} The first and only `ReactElement` contained in the
+* structure.
+*/
+function onlyChild(children) {
+ !ReactElement.isValidElement(children) ? "development" !== 'production' ? invariant(false, 'React.Children.only expected to receive a single React element child.') : _prodInvariant('143') : void 0;
+ return children;
+}
+
+module.exports = onlyChild;
+},{"10":10,"25":25,"29":29}],25:[function(_dereq_,module,exports){
+/**
+* Copyright (c) 2013-present, Facebook, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the BSD-style license found in the
+* LICENSE file in the root directory of this source tree. An additional grant
+* of patent rights can be found in the PATENTS file in the same directory.
+*
+*
+*/
+'use strict';
+
+/**
+* WARNING: DO NOT manually require this module.
+* This is a replacement for `invariant(...)` used by the error code system
+* and will _only_ be required by the corresponding babel pass.
+* It always throws.
+*/
+
+function reactProdInvariant(code) {
+ var argCount = arguments.length - 1;
+
+ var message = 'Minified React error #' + code + '; visit ' + 'http://facebook.github.io/react/docs/error-decoder.html?invariant=' + code;
+
+ for (var argIdx = 0; argIdx < argCount; argIdx++) {
+   message += '&args[]=' + encodeURIComponent(arguments[argIdx + 1]);
+ }
+
+ message += ' for the full message or use the non-minified dev environment' + ' for full errors and additional helpful warnings.';
+
+ var error = new Error(message);
+ error.name = 'Invariant Violation';
+ error.framesToPop = 1; // we don't care about reactProdInvariant's own frame
+
+ throw error;
+}
+
+module.exports = reactProdInvariant;
+},{}],26:[function(_dereq_,module,exports){
+/**
+* Copyright 2013-present, Facebook, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the BSD-style license found in the
+* LICENSE file in the root directory of this source tree. An additional grant
+* of patent rights can be found in the PATENTS file in the same directory.
+*
+*/
+
+'use strict';
+
+var _prodInvariant = _dereq_(25);
+
+var ReactCurrentOwner = _dereq_(8);
+var REACT_ELEMENT_TYPE = _dereq_(11);
+
+var getIteratorFn = _dereq_(22);
+var invariant = _dereq_(29);
+var KeyEscapeUtils = _dereq_(1);
+var warning = _dereq_(30);
+
+var SEPARATOR = '.';
+var SUBSEPARATOR = ':';
+
+/**
+* This is inlined from ReactElement since this file is shared between
+* isomorphic and renderers. We could extract this to a
+*
+*/
+
+/**
+* TODO: Test that a single child and an array with one item have the same key
+* pattern.
+*/
+
+var didWarnAboutMaps = false;
+
+/**
+* Generate a key string that identifies a component within a set.
+*
+* @param {*} component A component that could contain a manual key.
+* @param {number} index Index that is used if a manual key is not provided.
+* @return {string}
+*/
+function getComponentKey(component, index) {
+ // Do some typechecking here since we call this blindly. We want to ensure
+ // that we don't block potential future ES APIs.
+ if (component && typeof component === 'object' && component.key != null) {
+   // Explicit key
+   return KeyEscapeUtils.escape(component.key);
+ }
+ // Implicit key determined by the index in the set
+ return index.toString(36);
+}
+
+/**
+* @param {?*} children Children tree container.
+* @param {!string} nameSoFar Name of the key path so far.
+* @param {!function} callback Callback to invoke with each child found.
+* @param {?*} traverseContext Used to pass information throughout the traversal
+* process.
+* @return {!number} The number of children in this subtree.
+*/
+function traverseAllChildrenImpl(children, nameSoFar, callback, traverseContext) {
+ var type = typeof children;
+
+ if (type === 'undefined' || type === 'boolean') {
+   // All of the above are perceived as null.
+   children = null;
+ }
+
+ if (children === null || type === 'string' || type === 'number' ||
+ // The following is inlined from ReactElement. This means we can optimize
+ // some checks. React Fiber also inlines this logic for similar purposes.
+ type === 'object' && children.$$typeof === REACT_ELEMENT_TYPE) {
+   callback(traverseContext, children,
+   // If it's the only child, treat the name as if it was wrapped in an array
+   // so that it's consistent if the number of children grows.
+   nameSoFar === '' ? SEPARATOR + getComponentKey(children, 0) : nameSoFar);
+   return 1;
+ }
+
+ var child;
+ var nextName;
+ var subtreeCount = 0; // Count of children found in the current subtree.
+ var nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR;
+
+ if (Array.isArray(children)) {
+   for (var i = 0; i < children.length; i++) {
+     child = children[i];
+     nextName = nextNamePrefix + getComponentKey(child, i);
+     subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);
+   }
+ } else {
+   var iteratorFn = getIteratorFn(children);
+   if (iteratorFn) {
+     var iterator = iteratorFn.call(children);
+     var step;
+     if (iteratorFn !== children.entries) {
+       var ii = 0;
+       while (!(step = iterator.next()).done) {
+         child = step.value;
+         nextName = nextNamePrefix + getComponentKey(child, ii++);
+         subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);
+       }
+     } else {
+       if ("development" !== 'production') {
+         var mapsAsChildrenAddendum = '';
+         if (ReactCurrentOwner.current) {
+           var mapsAsChildrenOwnerName = ReactCurrentOwner.current.getName();
+           if (mapsAsChildrenOwnerName) {
+             mapsAsChildrenAddendum = ' Check the render method of `' + mapsAsChildrenOwnerName + '`.';
+           }
+         }
+         "development" !== 'production' ? warning(didWarnAboutMaps, 'Using Maps as children is not yet fully supported. It is an ' + 'experimental feature that might be removed. Convert it to a ' + 'sequence / iterable of keyed ReactElements instead.%s', mapsAsChildrenAddendum) : void 0;
+         didWarnAboutMaps = true;
+       }
+       // Iterator will provide entry [k,v] tuples rather than values.
+       while (!(step = iterator.next()).done) {
+         var entry = step.value;
+         if (entry) {
+           child = entry[1];
+           nextName = nextNamePrefix + KeyEscapeUtils.escape(entry[0]) + SUBSEPARATOR + getComponentKey(child, 0);
+           subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);
+         }
+       }
+     }
+   } else if (type === 'object') {
+     var addendum = '';
+     if ("development" !== 'production') {
+       addendum = ' If you meant to render a collection of children, use an array ' + 'instead or wrap the object using createFragment(object) from the ' + 'React add-ons.';
+       if (children._isReactElement) {
+         addendum = ' It looks like you\'re using an element created by a different ' + 'version of React. Make sure to use only one copy of React.';
+       }
+       if (ReactCurrentOwner.current) {
+         var name = ReactCurrentOwner.current.getName();
+         if (name) {
+           addendum += ' Check the render method of `' + name + '`.';
+         }
+       }
+     }
+     var childrenString = String(children);
+     !false ? "development" !== 'production' ? 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) : _prodInvariant('31', childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString, addendum) : void 0;
+   }
+ }
+
+ return subtreeCount;
+}
+
+/**
+* Traverses children that are typically specified as `props.children`, but
+* might also be specified through attributes:
+*
+* - `traverseAllChildren(this.props.children, ...)`
+* - `traverseAllChildren(this.props.leftPanelChildren, ...)`
+*
+* The `traverseContext` is an optional argument that is passed through the
+* entire traversal. It can be used to store accumulations or anything else that
+* the callback might find relevant.
+*
+* @param {?*} children Children tree object.
+* @param {!function} callback To invoke upon traversing each child.
+* @param {?*} traverseContext Context for traversal.
+* @return {!number} The number of children in this subtree.
+*/
+function traverseAllChildren(children, callback, traverseContext) {
+ if (children == null) {
+   return 0;
+ }
+
+ return traverseAllChildrenImpl(children, '', callback, traverseContext);
+}
+
+module.exports = traverseAllChildren;
+},{"1":1,"11":11,"22":22,"25":25,"29":29,"30":30,"8":8}],27:[function(_dereq_,module,exports){
+"use strict";
+
+/**
+* Copyright (c) 2013-present, Facebook, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the BSD-style license found in the
+* LICENSE file in the root directory of this source tree. An additional grant
+* of patent rights can be found in the PATENTS file in the same directory.
+*
+*
+*/
+
+function makeEmptyFunction(arg) {
+ return function () {
+   return arg;
+ };
+}
+
+/**
+* This function accepts and discards inputs; it has no side effects. This is
+* primarily useful idiomatically for overridable function endpoints which
+* always need to be callable, since JS lacks a null-call idiom ala Cocoa.
+*/
+var emptyFunction = function emptyFunction() {};
+
+emptyFunction.thatReturns = makeEmptyFunction;
+emptyFunction.thatReturnsFalse = makeEmptyFunction(false);
+emptyFunction.thatReturnsTrue = makeEmptyFunction(true);
+emptyFunction.thatReturnsNull = makeEmptyFunction(null);
+emptyFunction.thatReturnsThis = function () {
+ return this;
+};
+emptyFunction.thatReturnsArgument = function (arg) {
+ return arg;
+};
+
+module.exports = emptyFunction;
+},{}],28:[function(_dereq_,module,exports){
+/**
+* Copyright (c) 2013-present, Facebook, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the BSD-style license found in the
+* LICENSE file in the root directory of this source tree. An additional grant
+* of patent rights can be found in the PATENTS file in the same directory.
+*
+*/
+
+'use strict';
+
+var emptyObject = {};
+
+if ("development" !== 'production') {
+ Object.freeze(emptyObject);
+}
+
+module.exports = emptyObject;
+},{}],29:[function(_dereq_,module,exports){
+/**
+* Copyright (c) 2013-present, Facebook, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the BSD-style license found in the
+* LICENSE file in the root directory of this source tree. An additional grant
+* of patent rights can be found in the PATENTS file in the same directory.
+*
+*/
+
+'use strict';
+
+/**
+* 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(format) {};
+
+if ("development" !== 'production') {
+ validateFormat = function validateFormat(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;
+   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;
+ }
+}
+
+module.exports = invariant;
+},{}],30:[function(_dereq_,module,exports){
+/**
+* Copyright 2014-2015, Facebook, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the BSD-style license found in the
+* LICENSE file in the root directory of this source tree. An additional grant
+* of patent rights can be found in the PATENTS file in the same directory.
+*
+*/
+
+'use strict';
+
+var emptyFunction = _dereq_(27);
+
+/**
+* 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 warning = emptyFunction;
+
+if ("development" !== 'production') {
+ (function () {
+   var printWarning = function printWarning(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.error(message);
+     }
+     try {
+       // --- Welcome to debugging React ---
+       // This error was thrown as a convenience so that you can use this stack
+       // to find the callsite that caused this warning to fire.
+       throw new Error(message);
+     } catch (x) {}
+   };
+
+   warning = function warning(condition, format) {
+     if (format === undefined) {
+       throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument');
+     }
+
+     if (format.indexOf('Failed Composite propType: ') === 0) {
+       return; // Ignore CompositeComponent proptype check.
+     }
+
+     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));
+     }
+   };
+ })();
+}
+
+module.exports = warning;
+},{"27":27}],31:[function(_dereq_,module,exports){
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+
+'use strict';
+/* 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;
+ }
+}
+
+module.exports = 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;
+};
+
+},{}],32:[function(_dereq_,module,exports){
+/**
+* Copyright 2013-present, Facebook, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the BSD-style license found in the
+* LICENSE file in the root directory of this source tree. An additional grant
+* of patent rights can be found in the PATENTS file in the same directory.
+*/
+
+'use strict';
+
+if ("development" !== 'production') {
+ var invariant = _dereq_(29);
+ var warning = _dereq_(30);
+ var ReactPropTypesSecret = _dereq_(35);
+ var loggedTypeFailures = {};
+}
+
+/**
+* Assert that the values match with the type specs.
+* Error messages are memorized and will only be shown once.
+*
+* @param {object} typeSpecs Map of name to a ReactPropType
+* @param {object} values Runtime values that need to be type-checked
+* @param {string} location e.g. "prop", "context", "child context"
+* @param {string} componentName Name of the component for error messages.
+* @param {?Function} getStack Returns the component stack.
+* @private
+*/
+function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
+ if ("development" !== 'production') {
+   for (var typeSpecName in typeSpecs) {
+     if (typeSpecs.hasOwnProperty(typeSpecName)) {
+       var error;
+       // Prop type validation may throw. In case they do, we don't want to
+       // fail the render phase where it didn't fail before. So we log it.
+       // After these have been cleaned up, we'll let them throw.
+       try {
+         // This is intentionally an invariant that gets caught. It's the same
+         // behavior as without this statement except with a better message.
+         invariant(typeof typeSpecs[typeSpecName] === 'function', '%s: %s type `%s` is invalid; it must be a function, usually from ' + 'React.PropTypes.', componentName || 'React class', location, typeSpecName);
+         error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
+       } catch (ex) {
+         error = ex;
+       }
+       warning(!error || error instanceof Error, '%s: type specification of %s `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', location, typeSpecName, typeof error);
+       if (error instanceof Error && !(error.message in loggedTypeFailures)) {
+         // Only monitor this failure once because there tends to be a lot of the
+         // same error.
+         loggedTypeFailures[error.message] = true;
+
+         var stack = getStack ? getStack() : '';
+
+         warning(false, 'Failed %s type: %s%s', location, error.message, stack != null ? stack : '');
+       }
+     }
+   }
+ }
+}
+
+module.exports = checkPropTypes;
+
+},{"29":29,"30":30,"35":35}],33:[function(_dereq_,module,exports){
+/**
+* Copyright 2013-present, Facebook, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the BSD-style license found in the
+* LICENSE file in the root directory of this source tree. An additional grant
+* of patent rights can be found in the PATENTS file in the same directory.
+*/
+
+'use strict';
+
+// React 15.5 references this module, and assumes PropTypes are still callable in production.
+// Therefore we re-export development-only version with all the PropTypes checks here.
+// However if one is migrating to the `prop-types` npm library, they will go through the
+// `index.js` entry point, and it will branch depending on the environment.
+var factory = _dereq_(34);
+module.exports = function(isValidElement) {
+ // It is still allowed in 15.5.
+ var throwOnDirectAccess = false;
+ return factory(isValidElement, throwOnDirectAccess);
+};
+
+},{"34":34}],34:[function(_dereq_,module,exports){
+/**
+* Copyright 2013-present, Facebook, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the BSD-style license found in the
+* LICENSE file in the root directory of this source tree. An additional grant
+* of patent rights can be found in the PATENTS file in the same directory.
+*/
+
+'use strict';
+
+var emptyFunction = _dereq_(27);
+var invariant = _dereq_(29);
+var warning = _dereq_(30);
+
+var ReactPropTypesSecret = _dereq_(35);
+var checkPropTypes = _dereq_(32);
+
+module.exports = function(isValidElement, throwOnDirectAccess) {
+ /* global Symbol */
+ var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
+ var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.
+
+ /**
+  * Returns the iterator method function contained on the iterable object.
+  *
+  * Be sure to invoke the function with the iterable as context:
+  *
+  *     var iteratorFn = getIteratorFn(myIterable);
+  *     if (iteratorFn) {
+  *       var iterator = iteratorFn.call(myIterable);
+  *       ...
+  *     }
+  *
+  * @param {?object} maybeIterable
+  * @return {?function}
+  */
+ function getIteratorFn(maybeIterable) {
+   var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);
+   if (typeof iteratorFn === 'function') {
+     return iteratorFn;
+   }
+ }
+
+ /**
+  * Collection of methods that allow declaration and validation of props that are
+  * supplied to React components. Example usage:
+  *
+  *   var Props = require('ReactPropTypes');
+  *   var MyArticle = React.createClass({
+  *     propTypes: {
+  *       // An optional string prop named "description".
+  *       description: Props.string,
+  *
+  *       // A required enum prop named "category".
+  *       category: Props.oneOf(['News','Photos']).isRequired,
+  *
+  *       // A prop named "dialog" that requires an instance of Dialog.
+  *       dialog: Props.instanceOf(Dialog).isRequired
+  *     },
+  *     render: function() { ... }
+  *   });
+  *
+  * A more formal specification of how these methods are used:
+  *
+  *   type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...)
+  *   decl := ReactPropTypes.{type}(.isRequired)?
+  *
+  * Each and every declaration produces a function with the same signature. This
+  * allows the creation of custom validation functions. For example:
+  *
+  *  var MyLink = React.createClass({
+  *    propTypes: {
+  *      // An optional string or URI prop named "href".
+  *      href: function(props, propName, componentName) {
+  *        var propValue = props[propName];
+  *        if (propValue != null && typeof propValue !== 'string' &&
+  *            !(propValue instanceof URI)) {
+  *          return new Error(
+  *            'Expected a string or an URI for ' + propName + ' in ' +
+  *            componentName
+  *          );
+  *        }
+  *      }
+  *    },
+  *    render: function() {...}
+  *  });
+  *
+  * @internal
+  */
+
+ var ANONYMOUS = '<<anonymous>>';
+
+ // Important!
+ // Keep this list in sync with production version in `./factoryWithThrowingShims.js`.
+ var ReactPropTypes = {
+   array: createPrimitiveTypeChecker('array'),
+   bool: createPrimitiveTypeChecker('boolean'),
+   func: createPrimitiveTypeChecker('function'),
+   number: createPrimitiveTypeChecker('number'),
+   object: createPrimitiveTypeChecker('object'),
+   string: createPrimitiveTypeChecker('string'),
+   symbol: createPrimitiveTypeChecker('symbol'),
+
+   any: createAnyTypeChecker(),
+   arrayOf: createArrayOfTypeChecker,
+   element: createElementTypeChecker(),
+   instanceOf: createInstanceTypeChecker,
+   node: createNodeChecker(),
+   objectOf: createObjectOfTypeChecker,
+   oneOf: createEnumTypeChecker,
+   oneOfType: createUnionTypeChecker,
+   shape: createShapeTypeChecker
+ };
+
+ /**
+  * inlined Object.is polyfill to avoid requiring consumers ship their own
+  * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+  */
+ /*eslint-disable no-self-compare*/
+ function is(x, y) {
+   // SameValue algorithm
+   if (x === y) {
+     // Steps 1-5, 7-10
+     // Steps 6.b-6.e: +0 != -0
+     return x !== 0 || 1 / x === 1 / y;
+   } else {
+     // Step 6.a: NaN == NaN
+     return x !== x && y !== y;
+   }
+ }
+ /*eslint-enable no-self-compare*/
+
+ /**
+  * We use an Error-like object for backward compatibility as people may call
+  * PropTypes directly and inspect their output. However, we don't use real
+  * Errors anymore. We don't inspect their stack anyway, and creating them
+  * is prohibitively expensive if they are created too often, such as what
+  * happens in oneOfType() for any type before the one that matched.
+  */
+ function PropTypeError(message) {
+   this.message = message;
+   this.stack = '';
+ }
+ // Make `instanceof Error` still work for returned errors.
+ PropTypeError.prototype = Error.prototype;
+
+ function createChainableTypeChecker(validate) {
+   if ("development" !== 'production') {
+     var manualPropTypeCallCache = {};
+   }
+   function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {
+     componentName = componentName || ANONYMOUS;
+     propFullName = propFullName || propName;
+
+     if (secret !== ReactPropTypesSecret) {
+       if (throwOnDirectAccess) {
+         // New behavior only for users of `prop-types` package
+         invariant(
+           false,
+           'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +
+           'Use `PropTypes.checkPropTypes()` to call them. ' +
+           'Read more at http://fb.me/use-check-prop-types'
+         );
+       } else if ("development" !== 'production' && typeof console !== 'undefined') {
+         // Old behavior for people using React.PropTypes
+         var cacheKey = componentName + ':' + propName;
+         if (!manualPropTypeCallCache[cacheKey]) {
+           warning(
+             false,
+             'You are manually calling a React.PropTypes validation ' +
+             'function for the `%s` prop on `%s`. This is deprecated ' +
+             'and will throw in the standalone `prop-types` package. ' +
+             'You may be seeing this warning due to a third-party PropTypes ' +
+             'library. See https://fb.me/react-warning-dont-call-proptypes ' + 'for details.',
+             propFullName,
+             componentName
+           );
+           manualPropTypeCallCache[cacheKey] = true;
+         }
+       }
+     }
+     if (props[propName] == null) {
+       if (isRequired) {
+         if (props[propName] === null) {
+           return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));
+         }
+         return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.'));
+       }
+       return null;
+     } else {
+       return validate(props, propName, componentName, location, propFullName);
+     }
+   }
+
+   var chainedCheckType = checkType.bind(null, false);
+   chainedCheckType.isRequired = checkType.bind(null, true);
+
+   return chainedCheckType;
+ }
+
+ function createPrimitiveTypeChecker(expectedType) {
+   function validate(props, propName, componentName, location, propFullName, secret) {
+     var propValue = props[propName];
+     var propType = getPropType(propValue);
+     if (propType !== expectedType) {
+       // `propValue` being instance of, say, date/regexp, pass the 'object'
+       // check, but we can offer a more precise error message here rather than
+       // 'of type `object`'.
+       var preciseType = getPreciseType(propValue);
+
+       return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'));
+     }
+     return null;
+   }
+   return createChainableTypeChecker(validate);
+ }
+
+ function createAnyTypeChecker() {
+   return createChainableTypeChecker(emptyFunction.thatReturnsNull);
+ }
+
+ function createArrayOfTypeChecker(typeChecker) {
+   function validate(props, propName, componentName, location, propFullName) {
+     if (typeof typeChecker !== 'function') {
+       return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside arrayOf.');
+     }
+     var propValue = props[propName];
+     if (!Array.isArray(propValue)) {
+       var propType = getPropType(propValue);
+       return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an array.'));
+     }
+     for (var i = 0; i < propValue.length; i++) {
+       var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']', ReactPropTypesSecret);
+       if (error instanceof Error) {
+         return error;
+       }
+     }
+     return null;
+   }
+   return createChainableTypeChecker(validate);
+ }
+
+ function createElementTypeChecker() {
+   function validate(props, propName, componentName, location, propFullName) {
+     var propValue = props[propName];
+     if (!isValidElement(propValue)) {
+       var propType = getPropType(propValue);
+       return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement.'));
+     }
+     return null;
+   }
+   return createChainableTypeChecker(validate);
+ }
+
+ function createInstanceTypeChecker(expectedClass) {
+   function validate(props, propName, componentName, location, propFullName) {
+     if (!(props[propName] instanceof expectedClass)) {
+       var expectedClassName = expectedClass.name || ANONYMOUS;
+       var actualClassName = getClassName(props[propName]);
+       return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.'));
+     }
+     return null;
+   }
+   return createChainableTypeChecker(validate);
+ }
+
+ function createEnumTypeChecker(expectedValues) {
+   if (!Array.isArray(expectedValues)) {
+     "development" !== 'production' ? warning(false, 'Invalid argument supplied to oneOf, expected an instance of array.') : void 0;
+     return emptyFunction.thatReturnsNull;
+   }
+
+   function validate(props, propName, componentName, location, propFullName) {
+     var propValue = props[propName];
+     for (var i = 0; i < expectedValues.length; i++) {
+       if (is(propValue, expectedValues[i])) {
+         return null;
+       }
+     }
+
+     var valuesString = JSON.stringify(expectedValues);
+     return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + propValue + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));
+   }
+   return createChainableTypeChecker(validate);
+ }
+
+ function createObjectOfTypeChecker(typeChecker) {
+   function validate(props, propName, componentName, location, propFullName) {
+     if (typeof typeChecker !== 'function') {
+       return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.');
+     }
+     var propValue = props[propName];
+     var propType = getPropType(propValue);
+     if (propType !== 'object') {
+       return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.'));
+     }
+     for (var key in propValue) {
+       if (propValue.hasOwnProperty(key)) {
+         var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
+         if (error instanceof Error) {
+           return error;
+         }
+       }
+     }
+     return null;
+   }
+   return createChainableTypeChecker(validate);
+ }
+
+ function createUnionTypeChecker(arrayOfTypeCheckers) {
+   if (!Array.isArray(arrayOfTypeCheckers)) {
+     "development" !== 'production' ? warning(false, 'Invalid argument supplied to oneOfType, expected an instance of array.') : void 0;
+     return emptyFunction.thatReturnsNull;
+   }
+
+   function validate(props, propName, componentName, location, propFullName) {
+     for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
+       var checker = arrayOfTypeCheckers[i];
+       if (checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret) == null) {
+         return null;
+       }
+     }
+
+     return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`.'));
+   }
+   return createChainableTypeChecker(validate);
+ }
+
+ function createNodeChecker() {
+   function validate(props, propName, componentName, location, propFullName) {
+     if (!isNode(props[propName])) {
+       return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.'));
+     }
+     return null;
+   }
+   return createChainableTypeChecker(validate);
+ }
+
+ function createShapeTypeChecker(shapeTypes) {
+   function validate(props, propName, componentName, location, propFullName) {
+     var propValue = props[propName];
+     var propType = getPropType(propValue);
+     if (propType !== 'object') {
+       return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
+     }
+     for (var key in shapeTypes) {
+       var checker = shapeTypes[key];
+       if (!checker) {
+         continue;
+       }
+       var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
+       if (error) {
+         return error;
+       }
+     }
+     return null;
+   }
+   return createChainableTypeChecker(validate);
+ }
+
+ function isNode(propValue) {
+   switch (typeof propValue) {
+     case 'number':
+     case 'string':
+     case 'undefined':
+       return true;
+     case 'boolean':
+       return !propValue;
+     case 'object':
+       if (Array.isArray(propValue)) {
+         return propValue.every(isNode);
+       }
+       if (propValue === null || isValidElement(propValue)) {
+         return true;
+       }
+
+       var iteratorFn = getIteratorFn(propValue);
+       if (iteratorFn) {
+         var iterator = iteratorFn.call(propValue);
+         var step;
+         if (iteratorFn !== propValue.entries) {
+           while (!(step = iterator.next()).done) {
+             if (!isNode(step.value)) {
+               return false;
+             }
+           }
+         } else {
+           // Iterator will provide entry [k,v] tuples rather than values.
+           while (!(step = iterator.next()).done) {
+             var entry = step.value;
+             if (entry) {
+               if (!isNode(entry[1])) {
+                 return false;
+               }
+             }
+           }
+         }
+       } else {
+         return false;
+       }
+
+       return true;
+     default:
+       return false;
+   }
+ }
+
+ function isSymbol(propType, propValue) {
+   // Native Symbol.
+   if (propType === 'symbol') {
+     return true;
+   }
+
+   // 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'
+   if (propValue['@@toStringTag'] === 'Symbol') {
+     return true;
+   }
+
+   // Fallback for non-spec compliant Symbols which are polyfilled.
+   if (typeof Symbol === 'function' && propValue instanceof Symbol) {
+     return true;
+   }
+
+   return false;
+ }
+
+ // Equivalent of `typeof` but with special handling for array and regexp.
+ function getPropType(propValue) {
+   var propType = typeof propValue;
+   if (Array.isArray(propValue)) {
+     return 'array';
+   }
+   if (propValue instanceof RegExp) {
+     // Old webkits (at least until Android 4.0) return 'function' rather than
+     // 'object' for typeof a RegExp. We'll normalize this here so that /bla/
+     // passes PropTypes.object.
+     return 'object';
+   }
+   if (isSymbol(propType, propValue)) {
+     return 'symbol';
+   }
+   return propType;
+ }
+
+ // This handles more types than `getPropType`. Only used for error messages.
+ // See `createPrimitiveTypeChecker`.
+ function getPreciseType(propValue) {
+   var propType = getPropType(propValue);
+   if (propType === 'object') {
+     if (propValue instanceof Date) {
+       return 'date';
+     } else if (propValue instanceof RegExp) {
+       return 'regexp';
+     }
+   }
+   return propType;
+ }
+
+ // Returns class name of the object, if any.
+ function getClassName(propValue) {
+   if (!propValue.constructor || !propValue.constructor.name) {
+     return ANONYMOUS;
+   }
+   return propValue.constructor.name;
+ }
+
+ ReactPropTypes.checkPropTypes = checkPropTypes;
+ ReactPropTypes.PropTypes = ReactPropTypes;
+
+ return ReactPropTypes;
+};
+
+},{"27":27,"29":29,"30":30,"32":32,"35":35}],35:[function(_dereq_,module,exports){
+/**
+* Copyright 2013-present, Facebook, Inc.
+* All rights reserved.
+*
+* This source code is licensed under the BSD-style license found in the
+* LICENSE file in the root directory of this source tree. An additional grant
+* of patent rights can be found in the PATENTS file in the same directory.
+*/
+
+'use strict';
+
+var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
+
+module.exports = ReactPropTypesSecret;
+
+},{}]},{},[18])(18)
+});