path: root/devtools/client/inspector/markup/test/lib_react_with_addons_15.4.1.js

/**
 * React (with addons) v15.4.1
 */
(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';

var ExecutionEnvironment = _dereq_(43);

/**
* Generate a mapping of standard vendor prefixes using the defined style property and event name.
*
* @param {string} styleProp
* @param {string} eventName
* @returns {object}
*/
function makePrefixMap(styleProp, eventName) {
 var prefixes = {};

 prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();
 prefixes['Webkit' + styleProp] = 'webkit' + eventName;
 prefixes['Moz' + styleProp] = 'moz' + eventName;
 prefixes['ms' + styleProp] = 'MS' + eventName;
 prefixes['O' + styleProp] = 'o' + eventName.toLowerCase();

 return prefixes;
}

/**
* A list of event names to a configurable list of vendor prefixes.
*/
var vendorPrefixes = {
 animationend: makePrefixMap('Animation', 'AnimationEnd'),
 animationiteration: makePrefixMap('Animation', 'AnimationIteration'),
 animationstart: makePrefixMap('Animation', 'AnimationStart'),
 transitionend: makePrefixMap('Transition', 'TransitionEnd')
};

/**
* Event names that have already been detected and prefixed (if applicable).
*/
var prefixedEventNames = {};

/**
* Element to check for prefixes on.
*/
var style = {};

/**
* Bootstrap if a DOM exists.
*/
if (ExecutionEnvironment.canUseDOM) {
 style = document.createElement('div').style;

 // On some platforms, in particular some releases of Android 4.x,
 // the un-prefixed "animation" and "transition" properties are defined on the
 // style object but the events that fire will still be prefixed, so we need
 // to check if the un-prefixed events are usable, and if not remove them from the map.
 if (!('AnimationEvent' in window)) {
   delete vendorPrefixes.animationend.animation;
   delete vendorPrefixes.animationiteration.animation;
   delete vendorPrefixes.animationstart.animation;
 }

 // Same as above
 if (!('TransitionEvent' in window)) {
   delete vendorPrefixes.transitionend.transition;
 }
}

/**
* Attempts to determine the correct vendor prefixed event name.
*
* @param {string} eventName
* @returns {string}
*/
function getVendorPrefixedEventName(eventName) {
 if (prefixedEventNames[eventName]) {
   return prefixedEventNames[eventName];
 } else if (!vendorPrefixes[eventName]) {
   return eventName;
 }

 var prefixMap = vendorPrefixes[eventName];

 for (var styleProp in prefixMap) {
   if (prefixMap.hasOwnProperty(styleProp) && styleProp in style) {
     return prefixedEventNames[eventName] = prefixMap[styleProp];
   }
 }

 return '';
}

module.exports = getVendorPrefixedEventName;
},{"43":43}],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';

/**
* 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;
},{}],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 ReactLink = _dereq_(20);
var ReactStateSetters = _dereq_(26);

/**
* A simple mixin around ReactLink.forState().
* See https://facebook.github.io/react/docs/two-way-binding-helpers.html
*/
var LinkedStateMixin = {
 /**
  * Create a ReactLink that's linked to part of this component's state. The
  * ReactLink will have the current value of this.state[key] and will call
  * setState() when a change is requested.
  *
  * @param {string} key state key to update.
  * @return {ReactLink} ReactLink instance linking to the state.
  */
 linkState: function (key) {
   return new ReactLink(this.state[key], ReactStateSetters.createStateKeySetter(this, key));
 }
};

module.exports = LinkedStateMixin;
},{"20":20,"26":26}],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 _prodInvariant = _dereq_(38);

var invariant = _dereq_(46);

/**
* 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 fiveArgumentPooler = function (a1, a2, a3, a4, a5) {
 var Klass = this;
 if (Klass.instancePool.length) {
   var instance = Klass.instancePool.pop();
   Klass.call(instance, a1, a2, a3, a4, a5);
   return instance;
 } else {
   return new Klass(a1, a2, a3, a4, a5);
 }
};

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,
 fiveArgumentPooler: fiveArgumentPooler
};

module.exports = PooledClass;
},{"38":38,"46":46}],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 _assign = _dereq_(49);

var ReactChildren = _dereq_(9);
var ReactComponent = _dereq_(11);
var ReactPureComponent = _dereq_(25);
var ReactClass = _dereq_(10);
var ReactDOMFactories = _dereq_(15);
var ReactElement = _dereq_(16);
var ReactPropTypes = _dereq_(23);
var ReactVersion = _dereq_(30);

var onlyChild = _dereq_(37);
var warning = _dereq_(48);

var createElement = ReactElement.createElement;
var createFactory = ReactElement.createFactory;
var cloneElement = ReactElement.cloneElement;

if ("development" !== 'production') {
 var ReactElementValidator = _dereq_(18);
 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
};

module.exports = React;
},{"10":10,"11":11,"15":15,"16":16,"18":18,"23":23,"25":25,"30":30,"37":37,"48":48,"49":49,"9":9}],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.
*
*/

/* globals ReactDOM */

'use strict';

exports.getReactDOM = function () {
 return ReactDOM;
};

exports.getReactInstanceMap = function () {
 return ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactInstanceMap;
};

if ("development" !== 'production') {
 exports.getReactPerf = function () {
   return ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactPerf;
 };

 exports.getReactTestUtils = function () {
   return ReactDOM.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactTestUtils;
 };
}
},{}],7:[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_(49);

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var React = _dereq_(5);

var ReactTransitionGroup = _dereq_(29);
var ReactCSSTransitionGroupChild = _dereq_(8);

function createTransitionTimeoutPropValidator(transitionType) {
 var timeoutPropName = 'transition' + transitionType + 'Timeout';
 var enabledPropName = 'transition' + transitionType;

 return function (props) {
   // If the transition is enabled
   if (props[enabledPropName]) {
     // If no timeout duration is provided
     if (props[timeoutPropName] == null) {
       return new Error(timeoutPropName + ' wasn\'t supplied to ReactCSSTransitionGroup: ' + 'this can cause unreliable animations and won\'t be supported in ' + 'a future version of React. See ' + 'https://fb.me/react-animation-transition-group-timeout for more ' + 'information.');

       // If the duration isn't a number
     } else if (typeof props[timeoutPropName] !== 'number') {
       return new Error(timeoutPropName + ' must be a number (in milliseconds)');
     }
   }
 };
}

/**
* An easy way to perform CSS transitions and animations when a React component
* enters or leaves the DOM.
* See https://facebook.github.io/react/docs/animation.html#high-level-api-reactcsstransitiongroup
*/

var ReactCSSTransitionGroup = function (_React$Component) {
 _inherits(ReactCSSTransitionGroup, _React$Component);

 function ReactCSSTransitionGroup() {
   var _temp, _this, _ret;

   _classCallCheck(this, ReactCSSTransitionGroup);

   for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
     args[_key] = arguments[_key];
   }

   return _ret = (_temp = (_this = _possibleConstructorReturn(this, _React$Component.call.apply(_React$Component, [this].concat(args))), _this), _this._wrapChild = function (child) {
     // We need to provide this childFactory so that
     // ReactCSSTransitionGroupChild can receive updates to name, enter, and
     // leave while it is leaving.
     return React.createElement(ReactCSSTransitionGroupChild, {
       name: _this.props.transitionName,
       appear: _this.props.transitionAppear,
       enter: _this.props.transitionEnter,
       leave: _this.props.transitionLeave,
       appearTimeout: _this.props.transitionAppearTimeout,
       enterTimeout: _this.props.transitionEnterTimeout,
       leaveTimeout: _this.props.transitionLeaveTimeout
     }, child);
   }, _temp), _possibleConstructorReturn(_this, _ret);
 }

 ReactCSSTransitionGroup.prototype.render = function render() {
   return React.createElement(ReactTransitionGroup, _assign({}, this.props, { childFactory: this._wrapChild }));
 };

 return ReactCSSTransitionGroup;
}(React.Component);

ReactCSSTransitionGroup.displayName = 'ReactCSSTransitionGroup';
ReactCSSTransitionGroup.propTypes = {
 transitionName: ReactCSSTransitionGroupChild.propTypes.name,

 transitionAppear: React.PropTypes.bool,
 transitionEnter: React.PropTypes.bool,
 transitionLeave: React.PropTypes.bool,
 transitionAppearTimeout: createTransitionTimeoutPropValidator('Appear'),
 transitionEnterTimeout: createTransitionTimeoutPropValidator('Enter'),
 transitionLeaveTimeout: createTransitionTimeoutPropValidator('Leave')
};
ReactCSSTransitionGroup.defaultProps = {
 transitionAppear: false,
 transitionEnter: true,
 transitionLeave: true
};


module.exports = ReactCSSTransitionGroup;
},{"29":29,"49":49,"5":5,"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';

var React = _dereq_(5);
var ReactAddonsDOMDependencies = _dereq_(6);

var CSSCore = _dereq_(42);
var ReactTransitionEvents = _dereq_(28);

var onlyChild = _dereq_(37);

var TICK = 17;

var ReactCSSTransitionGroupChild = React.createClass({
 displayName: 'ReactCSSTransitionGroupChild',

 propTypes: {
   name: React.PropTypes.oneOfType([React.PropTypes.string, React.PropTypes.shape({
     enter: React.PropTypes.string,
     leave: React.PropTypes.string,
     active: React.PropTypes.string
   }), React.PropTypes.shape({
     enter: React.PropTypes.string,
     enterActive: React.PropTypes.string,
     leave: React.PropTypes.string,
     leaveActive: React.PropTypes.string,
     appear: React.PropTypes.string,
     appearActive: React.PropTypes.string
   })]).isRequired,

   // Once we require timeouts to be specified, we can remove the
   // boolean flags (appear etc.) and just accept a number
   // or a bool for the timeout flags (appearTimeout etc.)
   appear: React.PropTypes.bool,
   enter: React.PropTypes.bool,
   leave: React.PropTypes.bool,
   appearTimeout: React.PropTypes.number,
   enterTimeout: React.PropTypes.number,
   leaveTimeout: React.PropTypes.number
 },

 transition: function (animationType, finishCallback, userSpecifiedDelay) {
   var node = ReactAddonsDOMDependencies.getReactDOM().findDOMNode(this);

   if (!node) {
     if (finishCallback) {
       finishCallback();
     }
     return;
   }

   var className = this.props.name[animationType] || this.props.name + '-' + animationType;
   var activeClassName = this.props.name[animationType + 'Active'] || className + '-active';
   var timeout = null;

   var endListener = function (e) {
     if (e && e.target !== node) {
       return;
     }

     clearTimeout(timeout);

     CSSCore.removeClass(node, className);
     CSSCore.removeClass(node, activeClassName);

     ReactTransitionEvents.removeEndEventListener(node, endListener);

     // Usually this optional callback is used for informing an owner of
     // a leave animation and telling it to remove the child.
     if (finishCallback) {
       finishCallback();
     }
   };

   CSSCore.addClass(node, className);

   // Need to do this to actually trigger a transition.
   this.queueClassAndNode(activeClassName, node);

   // If the user specified a timeout delay.
   if (userSpecifiedDelay) {
     // Clean-up the animation after the specified delay
     timeout = setTimeout(endListener, userSpecifiedDelay);
     this.transitionTimeouts.push(timeout);
   } else {
     // DEPRECATED: this listener will be removed in a future version of react
     ReactTransitionEvents.addEndEventListener(node, endListener);
   }
 },

 queueClassAndNode: function (className, node) {
   this.classNameAndNodeQueue.push({
     className: className,
     node: node
   });

   if (!this.timeout) {
     this.timeout = setTimeout(this.flushClassNameAndNodeQueue, TICK);
   }
 },

 flushClassNameAndNodeQueue: function () {
   if (this.isMounted()) {
     this.classNameAndNodeQueue.forEach(function (obj) {
       CSSCore.addClass(obj.node, obj.className);
     });
   }
   this.classNameAndNodeQueue.length = 0;
   this.timeout = null;
 },

 componentWillMount: function () {
   this.classNameAndNodeQueue = [];
   this.transitionTimeouts = [];
 },

 componentWillUnmount: function () {
   if (this.timeout) {
     clearTimeout(this.timeout);
   }
   this.transitionTimeouts.forEach(function (timeout) {
     clearTimeout(timeout);
   });

   this.classNameAndNodeQueue.length = 0;
 },

 componentWillAppear: function (done) {
   if (this.props.appear) {
     this.transition('appear', done, this.props.appearTimeout);
   } else {
     done();
   }
 },

 componentWillEnter: function (done) {
   if (this.props.enter) {
     this.transition('enter', done, this.props.enterTimeout);
   } else {
     done();
   }
 },

 componentWillLeave: function (done) {
   if (this.props.leave) {
     this.transition('leave', done, this.props.leaveTimeout);
   } else {
     done();
   }
 },

 render: function () {
   return onlyChild(this.props.children);
 }
});

module.exports = ReactCSSTransitionGroupChild;
},{"28":28,"37":37,"42":42,"5":5,"6":6}],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 PooledClass = _dereq_(4);
var ReactElement = _dereq_(16);

var emptyFunction = _dereq_(44);
var traverseAllChildren = _dereq_(40);

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;
},{"16":16,"4":4,"40":40,"44":44}],10:[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_(38),
   _assign = _dereq_(49);

var ReactComponent = _dereq_(11);
var ReactElement = _dereq_(16);
var ReactPropTypeLocationNames = _dereq_(22);
var ReactNoopUpdateQueue = _dereq_(21);

var emptyObject = _dereq_(45);
var invariant = _dereq_(46);
var warning = _dereq_(48);

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}
  * @nosideeffects
  * @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);

/**
* 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) {
   // 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;
},{"11":11,"16":16,"21":21,"22":22,"38":38,"45":45,"46":46,"48":48,"49":49}],11:[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_(38);

var ReactNoopUpdateQueue = _dereq_(21);

var canDefineProperty = _dereq_(33);
var emptyObject = _dereq_(45);
var invariant = _dereq_(46);
var warning = _dereq_(48);

/**
* 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;
},{"21":21,"33":33,"38":38,"45":45,"46":46,"48":48}],12:[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_(38);

var ReactCurrentOwner = _dereq_(14);

var invariant = _dereq_(46);
var warning = _dereq_(48);

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;
},{"14":14,"38":38,"46":46,"48":48}],13:[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 shallowCompare = _dereq_(39);

/**
* If your React component's render function is "pure", e.g. it will render the
* same result given the same props and state, provide this mixin for a
* considerable performance boost.
*
* Most React components have pure render functions.
*
* Example:
*
*   var ReactComponentWithPureRenderMixin =
*     require('ReactComponentWithPureRenderMixin');
*   React.createClass({
*     mixins: [ReactComponentWithPureRenderMixin],
*
*     render: function() {
*       return <div className={this.props.className}>foo</div>;
*     }
*   });
*
* Note: This only checks shallow equality for props and state. If these contain
* complex data structures this mixin may have false-negatives for deeper
* differences. Only mixin to components which have simple props and state, or
* use `forceUpdate()` when you know deep data structures have changed.
*
* See https://facebook.github.io/react/docs/pure-render-mixin.html
*/
var ReactComponentWithPureRenderMixin = {
 shouldComponentUpdate: function (nextProps, nextState) {
   return shallowCompare(this, nextProps, nextState);
 }
};

module.exports = ReactComponentWithPureRenderMixin;
},{"39":39}],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';

/**
* 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;
},{}],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 ReactElement = _dereq_(16);

/**
* Create a factory that creates HTML tag elements.
*
* @private
*/
var createDOMFactory = ReactElement.createFactory;
if ("development" !== 'production') {
 var ReactElementValidator = _dereq_(18);
 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;
},{"16":16,"18":18}],16:[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_(49);

var ReactCurrentOwner = _dereq_(14);

var warning = _dereq_(48);
var canDefineProperty = _dereq_(33);
var hasOwnProperty = Object.prototype.hasOwnProperty;

var REACT_ELEMENT_TYPE = _dereq_(17);

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;
},{"14":14,"17":17,"33":33,"48":48,"49":49}],17:[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;
},{}],18:[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_(14);
var ReactComponentTreeHook = _dereq_(12);
var ReactElement = _dereq_(16);

var checkReactTypeSpec = _dereq_(34);

var canDefineProperty = _dereq_(33);
var getIteratorFn = _dereq_(36);
var warning = _dereq_(48);

function getDeclarationErrorAddendum() {
 if (ReactCurrentOwner.current) {
   var name = ReactCurrentOwner.current.getName();
   if (name) {
     return ' Check the render method of `' + name + '`.';
   }
 }
 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) {
     "development" !== 'production' ? warning(false, 'React.createElement: type should not be null, undefined, boolean, or ' + 'number. It should be a string (for DOM elements) or a ReactClass ' + '(for composite components).%s', getDeclarationErrorAddendum()) : 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;
},{"12":12,"14":14,"16":16,"33":33,"34":34,"36":36,"48":48}],19:[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 _prodInvariant = _dereq_(38);

var ReactChildren = _dereq_(9);
var ReactElement = _dereq_(16);

var emptyFunction = _dereq_(44);
var invariant = _dereq_(46);
var warning = _dereq_(48);

/**
* We used to allow keyed objects to serve as a collection of ReactElements,
* or nested sets. This allowed us a way to explicitly key a set or fragment of
* components. This is now being replaced with an opaque data structure.
* The upgrade path is to call React.addons.createFragment({ key: value }) to
* create a keyed fragment. The resulting data structure is an array.
*/

var numericPropertyRegex = /^\d+$/;

var warnedAboutNumeric = false;

var ReactFragment = {
 /**
  * Wrap a keyed object in an opaque proxy that warns you if you access any
  * of its properties.
  * See https://facebook.github.io/react/docs/create-fragment.html
  */
 create: function (object) {
   if (typeof object !== 'object' || !object || Array.isArray(object)) {
     "development" !== 'production' ? warning(false, 'React.addons.createFragment only accepts a single object. Got: %s', object) : void 0;
     return object;
   }
   if (ReactElement.isValidElement(object)) {
     "development" !== 'production' ? warning(false, 'React.addons.createFragment does not accept a ReactElement ' + 'without a wrapper object.') : void 0;
     return object;
   }

   !(object.nodeType !== 1) ? "development" !== 'production' ? invariant(false, 'React.addons.createFragment(...): Encountered an invalid child; DOM elements are not valid children of React components.') : _prodInvariant('0') : void 0;

   var result = [];

   for (var key in object) {
     if ("development" !== 'production') {
       if (!warnedAboutNumeric && numericPropertyRegex.test(key)) {
         "development" !== 'production' ? warning(false, 'React.addons.createFragment(...): Child objects should have ' + 'non-numeric keys so ordering is preserved.') : void 0;
         warnedAboutNumeric = true;
       }
     }
     ReactChildren.mapIntoWithKeyPrefixInternal(object[key], result, key, emptyFunction.thatReturnsArgument);
   }

   return result;
 }
};

module.exports = ReactFragment;
},{"16":16,"38":38,"44":44,"46":46,"48":48,"9":9}],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';

/**
* ReactLink encapsulates a common pattern in which a component wants to modify
* a prop received from its parent. ReactLink allows the parent to pass down a
* value coupled with a callback that, when invoked, expresses an intent to
* modify that value. For example:
*
* React.createClass({
*   getInitialState: function() {
*     return {value: ''};
*   },
*   render: function() {
*     var valueLink = new ReactLink(this.state.value, this._handleValueChange);
*     return <input valueLink={valueLink} />;
*   },
*   _handleValueChange: function(newValue) {
*     this.setState({value: newValue});
*   }
* });
*
* We have provided some sugary mixins to make the creation and
* consumption of ReactLink easier; see LinkedValueUtils and LinkedStateMixin.
*/

var React = _dereq_(5);

/**
* Deprecated: An an easy way to express two-way binding with React.
* See https://facebook.github.io/react/docs/two-way-binding-helpers.html
*
* @param {*} value current value of the link
* @param {function} requestChange callback to request a change
*/
function ReactLink(value, requestChange) {
 this.value = value;
 this.requestChange = requestChange;
}

/**
* Creates a PropType that enforces the ReactLink API and optionally checks the
* type of the value being passed inside the link. Example:
*
* MyComponent.propTypes = {
*   tabIndexLink: ReactLink.PropTypes.link(React.PropTypes.number)
* }
*/
function createLinkTypeChecker(linkType) {
 var shapes = {
   value: linkType === undefined ? React.PropTypes.any.isRequired : linkType.isRequired,
   requestChange: React.PropTypes.func.isRequired
 };
 return React.PropTypes.shape(shapes);
}

ReactLink.PropTypes = {
 link: createLinkTypeChecker
};

module.exports = ReactLink;
},{"5":5}],21:[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_(48);

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;
},{"48":48}],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';

var ReactPropTypeLocationNames = {};

if ("development" !== 'production') {
 ReactPropTypeLocationNames = {
   prop: 'prop',
   context: 'context',
   childContext: 'child context'
 };
}

module.exports = ReactPropTypeLocationNames;
},{}],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 ReactElement = _dereq_(16);
var ReactPropTypeLocationNames = _dereq_(22);
var ReactPropTypesSecret = _dereq_(24);

var emptyFunction = _dereq_(44);
var getIteratorFn = _dereq_(36);
var warning = _dereq_(48);

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

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 ("development" !== 'production') {
     if (secret !== ReactPropTypesSecret && typeof console !== 'undefined') {
       var cacheKey = componentName + ':' + propName;
       if (!manualPropTypeCallCache[cacheKey]) {
         "development" !== 'production' ? warning(false, 'You are manually calling a React.PropTypes validation ' + 'function for the `%s` prop on `%s`. This is deprecated ' + 'and will not work in production with the next major version. ' + '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) : void 0;
         manualPropTypeCallCache[cacheKey] = true;
       }
     }
   }
   if (props[propName] == null) {
     var locationName = ReactPropTypeLocationNames[location];
     if (isRequired) {
       if (props[propName] === null) {
         return new PropTypeError('The ' + locationName + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));
       }
       return new PropTypeError('The ' + locationName + ' `' + 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) {
     var locationName = ReactPropTypeLocationNames[location];
     // `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 ' + locationName + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'));
   }
   return null;
 }
 return createChainableTypeChecker(validate);
}

function createAnyTypeChecker() {
 return createChainableTypeChecker(emptyFunction.thatReturns(null));
}

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 locationName = ReactPropTypeLocationNames[location];
     var propType = getPropType(propValue);
     return new PropTypeError('Invalid ' + locationName + ' `' + 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 (!ReactElement.isValidElement(propValue)) {
     var locationName = ReactPropTypeLocationNames[location];
     var propType = getPropType(propValue);
     return new PropTypeError('Invalid ' + locationName + ' `' + 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 locationName = ReactPropTypeLocationNames[location];
     var expectedClassName = expectedClass.name || ANONYMOUS;
     var actualClassName = getClassName(props[propName]);
     return new PropTypeError('Invalid ' + locationName + ' `' + 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 locationName = ReactPropTypeLocationNames[location];
   var valuesString = JSON.stringify(expectedValues);
   return new PropTypeError('Invalid ' + locationName + ' `' + 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') {
     var locationName = ReactPropTypeLocationNames[location];
     return new PropTypeError('Invalid ' + locationName + ' `' + 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;
     }
   }

   var locationName = ReactPropTypeLocationNames[location];
   return new PropTypeError('Invalid ' + locationName + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`.'));
 }
 return createChainableTypeChecker(validate);
}

function createNodeChecker() {
 function validate(props, propName, componentName, location, propFullName) {
   if (!isNode(props[propName])) {
     var locationName = ReactPropTypeLocationNames[location];
     return new PropTypeError('Invalid ' + locationName + ' `' + 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') {
     var locationName = ReactPropTypeLocationNames[location];
     return new PropTypeError('Invalid ' + locationName + ' `' + 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 || ReactElement.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;
}

module.exports = ReactPropTypes;
},{"16":16,"22":22,"24":24,"36":36,"44":44,"48":48}],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 ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';

module.exports = ReactPropTypesSecret;
},{}],25:[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_(49);

var ReactComponent = _dereq_(11);
var ReactNoopUpdateQueue = _dereq_(21);

var emptyObject = _dereq_(45);

/**
* 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;
},{"11":11,"21":21,"45":45,"49":49}],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 ReactStateSetters = {
 /**
  * Returns a function that calls the provided function, and uses the result
  * of that to set the component's state.
  *
  * @param {ReactCompositeComponent} component
  * @param {function} funcReturningState Returned callback uses this to
  *                                      determine how to update state.
  * @return {function} callback that when invoked uses funcReturningState to
  *                    determined the object literal to setState.
  */
 createStateSetter: function (component, funcReturningState) {
   return function (a, b, c, d, e, f) {
     var partialState = funcReturningState.call(component, a, b, c, d, e, f);
     if (partialState) {
       component.setState(partialState);
     }
   };
 },

 /**
  * Returns a single-argument callback that can be used to update a single
  * key in the component's state.
  *
  * Note: this is memoized function, which makes it inexpensive to call.
  *
  * @param {ReactCompositeComponent} component
  * @param {string} key The key in the state that you should update.
  * @return {function} callback of 1 argument which calls setState() with
  *                    the provided keyName and callback argument.
  */
 createStateKeySetter: function (component, key) {
   // Memoize the setters.
   var cache = component.__keySetters || (component.__keySetters = {});
   return cache[key] || (cache[key] = createStateKeySetter(component, key));
 }
};

function createStateKeySetter(component, key) {
 // Partial state is allocated outside of the function closure so it can be
 // reused with every call, avoiding memory allocation when this function
 // is called.
 var partialState = {};
 return function stateKeySetter(value) {
   partialState[key] = value;
   component.setState(partialState);
 };
}

ReactStateSetters.Mixin = {
 /**
  * Returns a function that calls the provided function, and uses the result
  * of that to set the component's state.
  *
  * For example, these statements are equivalent:
  *
  *   this.setState({x: 1});
  *   this.createStateSetter(function(xValue) {
  *     return {x: xValue};
  *   })(1);
  *
  * @param {function} funcReturningState Returned callback uses this to
  *                                      determine how to update state.
  * @return {function} callback that when invoked uses funcReturningState to
  *                    determined the object literal to setState.
  */
 createStateSetter: function (funcReturningState) {
   return ReactStateSetters.createStateSetter(this, funcReturningState);
 },

 /**
  * Returns a single-argument callback that can be used to update a single
  * key in the component's state.
  *
  * For example, these statements are equivalent:
  *
  *   this.setState({x: 1});
  *   this.createStateKeySetter('x')(1);
  *
  * Note: this is memoized function, which makes it inexpensive to call.
  *
  * @param {string} key The key in the state that you should update.
  * @return {function} callback of 1 argument which calls setState() with
  *                    the provided keyName and callback argument.
  */
 createStateKeySetter: function (key) {
   return ReactStateSetters.createStateKeySetter(this, key);
 }
};

module.exports = ReactStateSetters;
},{}],27:[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 flattenChildren = _dereq_(35);

var ReactTransitionChildMapping = {
 /**
  * Given `this.props.children`, return an object mapping key to child. Just
  * simple syntactic sugar around flattenChildren().
  *
  * @param {*} children `this.props.children`
  * @param {number=} selfDebugID Optional debugID of the current internal instance.
  * @return {object} Mapping of key to child
  */
 getChildMapping: function (children, selfDebugID) {
   if (!children) {
     return children;
   }

   if ("development" !== 'production') {
     return flattenChildren(children, selfDebugID);
   }

   return flattenChildren(children);
 },

 /**
  * When you're adding or removing children some may be added or removed in the
  * same render pass. We want to show *both* since we want to simultaneously
  * animate elements in and out. This function takes a previous set of keys
  * and a new set of keys and merges them with its best guess of the correct
  * ordering. In the future we may expose some of the utilities in
  * ReactMultiChild to make this easy, but for now React itself does not
  * directly have this concept of the union of prevChildren and nextChildren
  * so we implement it here.
  *
  * @param {object} prev prev children as returned from
  * `ReactTransitionChildMapping.getChildMapping()`.
  * @param {object} next next children as returned from
  * `ReactTransitionChildMapping.getChildMapping()`.
  * @return {object} a key set that contains all keys in `prev` and all keys
  * in `next` in a reasonable order.
  */
 mergeChildMappings: function (prev, next) {
   prev = prev || {};
   next = next || {};

   function getValueForKey(key) {
     if (next.hasOwnProperty(key)) {
       return next[key];
     } else {
       return prev[key];
     }
   }

   // For each key of `next`, the list of keys to insert before that key in
   // the combined list
   var nextKeysPending = {};

   var pendingKeys = [];
   for (var prevKey in prev) {
     if (next.hasOwnProperty(prevKey)) {
       if (pendingKeys.length) {
         nextKeysPending[prevKey] = pendingKeys;
         pendingKeys = [];
       }
     } else {
       pendingKeys.push(prevKey);
     }
   }

   var i;
   var childMapping = {};
   for (var nextKey in next) {
     if (nextKeysPending.hasOwnProperty(nextKey)) {
       for (i = 0; i < nextKeysPending[nextKey].length; i++) {
         var pendingNextKey = nextKeysPending[nextKey][i];
         childMapping[nextKeysPending[nextKey][i]] = getValueForKey(pendingNextKey);
       }
     }
     childMapping[nextKey] = getValueForKey(nextKey);
   }

   // Finally, add the keys which didn't appear before any key in `next`
   for (i = 0; i < pendingKeys.length; i++) {
     childMapping[pendingKeys[i]] = getValueForKey(pendingKeys[i]);
   }

   return childMapping;
 }
};

module.exports = ReactTransitionChildMapping;
},{"35":35}],28:[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 ExecutionEnvironment = _dereq_(43);

var getVendorPrefixedEventName = _dereq_(1);

var endEvents = [];

function detectEvents() {
 var animEnd = getVendorPrefixedEventName('animationend');
 var transEnd = getVendorPrefixedEventName('transitionend');

 if (animEnd) {
   endEvents.push(animEnd);
 }

 if (transEnd) {
   endEvents.push(transEnd);
 }
}

if (ExecutionEnvironment.canUseDOM) {
 detectEvents();
}

// We use the raw {add|remove}EventListener() call because EventListener
// does not know how to remove event listeners and we really should
// clean up. Also, these events are not triggered in older browsers
// so we should be A-OK here.

function addEventListener(node, eventName, eventListener) {
 node.addEventListener(eventName, eventListener, false);
}

function removeEventListener(node, eventName, eventListener) {
 node.removeEventListener(eventName, eventListener, false);
}

var ReactTransitionEvents = {
 addEndEventListener: function (node, eventListener) {
   if (endEvents.length === 0) {
     // If CSS transitions are not supported, trigger an "end animation"
     // event immediately.
     window.setTimeout(eventListener, 0);
     return;
   }
   endEvents.forEach(function (endEvent) {
     addEventListener(node, endEvent, eventListener);
   });
 },

 removeEndEventListener: function (node, eventListener) {
   if (endEvents.length === 0) {
     return;
   }
   endEvents.forEach(function (endEvent) {
     removeEventListener(node, endEvent, eventListener);
   });
 }
};

module.exports = ReactTransitionEvents;
},{"1":1,"43":43}],29:[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_(49);

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

var React = _dereq_(5);
var ReactAddonsDOMDependencies = _dereq_(6);
var ReactTransitionChildMapping = _dereq_(27);

var emptyFunction = _dereq_(44);

/**
* A basis for animations. When children are declaratively added or removed,
* special lifecycle hooks are called.
* See https://facebook.github.io/react/docs/animation.html#low-level-api-reacttransitiongroup
*/

var ReactTransitionGroup = function (_React$Component) {
 _inherits(ReactTransitionGroup, _React$Component);

 function ReactTransitionGroup() {
   var _temp, _this, _ret;

   _classCallCheck(this, ReactTransitionGroup);

   for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
     args[_key] = arguments[_key];
   }

   return _ret = (_temp = (_this = _possibleConstructorReturn(this, _React$Component.call.apply(_React$Component, [this].concat(args))), _this), _this.state = {
     // TODO: can we get useful debug information to show at this point?
     children: ReactTransitionChildMapping.getChildMapping(_this.props.children)
   }, _this.performAppear = function (key) {
     _this.currentlyTransitioningKeys[key] = true;

     var component = _this.refs[key];

     if (component.componentWillAppear) {
       component.componentWillAppear(_this._handleDoneAppearing.bind(_this, key));
     } else {
       _this._handleDoneAppearing(key);
     }
   }, _this._handleDoneAppearing = function (key) {
     var component = _this.refs[key];
     if (component.componentDidAppear) {
       component.componentDidAppear();
     }

     delete _this.currentlyTransitioningKeys[key];

     var currentChildMapping;
     if ("development" !== 'production') {
       currentChildMapping = ReactTransitionChildMapping.getChildMapping(_this.props.children, ReactAddonsDOMDependencies.getReactInstanceMap().get(_this)._debugID);
     } else {
       currentChildMapping = ReactTransitionChildMapping.getChildMapping(_this.props.children);
     }

     if (!currentChildMapping || !currentChildMapping.hasOwnProperty(key)) {
       // This was removed before it had fully appeared. Remove it.
       _this.performLeave(key);
     }
   }, _this.performEnter = function (key) {
     _this.currentlyTransitioningKeys[key] = true;

     var component = _this.refs[key];

     if (component.componentWillEnter) {
       component.componentWillEnter(_this._handleDoneEntering.bind(_this, key));
     } else {
       _this._handleDoneEntering(key);
     }
   }, _this._handleDoneEntering = function (key) {
     var component = _this.refs[key];
     if (component.componentDidEnter) {
       component.componentDidEnter();
     }

     delete _this.currentlyTransitioningKeys[key];

     var currentChildMapping;
     if ("development" !== 'production') {
       currentChildMapping = ReactTransitionChildMapping.getChildMapping(_this.props.children, ReactAddonsDOMDependencies.getReactInstanceMap().get(_this)._debugID);
     } else {
       currentChildMapping = ReactTransitionChildMapping.getChildMapping(_this.props.children);
     }

     if (!currentChildMapping || !currentChildMapping.hasOwnProperty(key)) {
       // This was removed before it had fully entered. Remove it.
       _this.performLeave(key);
     }
   }, _this.performLeave = function (key) {
     _this.currentlyTransitioningKeys[key] = true;

     var component = _this.refs[key];
     if (component.componentWillLeave) {
       component.componentWillLeave(_this._handleDoneLeaving.bind(_this, key));
     } else {
       // Note that this is somewhat dangerous b/c it calls setState()
       // again, effectively mutating the component before all the work
       // is done.
       _this._handleDoneLeaving(key);
     }
   }, _this._handleDoneLeaving = function (key) {
     var component = _this.refs[key];

     if (component.componentDidLeave) {
       component.componentDidLeave();
     }

     delete _this.currentlyTransitioningKeys[key];

     var currentChildMapping;
     if ("development" !== 'production') {
       currentChildMapping = ReactTransitionChildMapping.getChildMapping(_this.props.children, ReactAddonsDOMDependencies.getReactInstanceMap().get(_this)._debugID);
     } else {
       currentChildMapping = ReactTransitionChildMapping.getChildMapping(_this.props.children);
     }

     if (currentChildMapping && currentChildMapping.hasOwnProperty(key)) {
       // This entered again before it fully left. Add it again.
       _this.performEnter(key);
     } else {
       _this.setState(function (state) {
         var newChildren = _assign({}, state.children);
         delete newChildren[key];
         return { children: newChildren };
       });
     }
   }, _temp), _possibleConstructorReturn(_this, _ret);
 }

 ReactTransitionGroup.prototype.componentWillMount = function componentWillMount() {
   this.currentlyTransitioningKeys = {};
   this.keysToEnter = [];
   this.keysToLeave = [];
 };

 ReactTransitionGroup.prototype.componentDidMount = function componentDidMount() {
   var initialChildMapping = this.state.children;
   for (var key in initialChildMapping) {
     if (initialChildMapping[key]) {
       this.performAppear(key);
     }
   }
 };

 ReactTransitionGroup.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {
   var nextChildMapping;
   if ("development" !== 'production') {
     nextChildMapping = ReactTransitionChildMapping.getChildMapping(nextProps.children, ReactAddonsDOMDependencies.getReactInstanceMap().get(this)._debugID);
   } else {
     nextChildMapping = ReactTransitionChildMapping.getChildMapping(nextProps.children);
   }
   var prevChildMapping = this.state.children;

   this.setState({
     children: ReactTransitionChildMapping.mergeChildMappings(prevChildMapping, nextChildMapping)
   });

   var key;

   for (key in nextChildMapping) {
     var hasPrev = prevChildMapping && prevChildMapping.hasOwnProperty(key);
     if (nextChildMapping[key] && !hasPrev && !this.currentlyTransitioningKeys[key]) {
       this.keysToEnter.push(key);
     }
   }

   for (key in prevChildMapping) {
     var hasNext = nextChildMapping && nextChildMapping.hasOwnProperty(key);
     if (prevChildMapping[key] && !hasNext && !this.currentlyTransitioningKeys[key]) {
       this.keysToLeave.push(key);
     }
   }

   // If we want to someday check for reordering, we could do it here.
 };

 ReactTransitionGroup.prototype.componentDidUpdate = function componentDidUpdate() {
   var keysToEnter = this.keysToEnter;
   this.keysToEnter = [];
   keysToEnter.forEach(this.performEnter);

   var keysToLeave = this.keysToLeave;
   this.keysToLeave = [];
   keysToLeave.forEach(this.performLeave);
 };

 ReactTransitionGroup.prototype.render = function render() {
   // TODO: we could get rid of the need for the wrapper node
   // by cloning a single child
   var childrenToRender = [];
   for (var key in this.state.children) {
     var child = this.state.children[key];
     if (child) {
       // You may need to apply reactive updates to a child as it is leaving.
       // The normal React way to do it won't work since the child will have
       // already been removed. In case you need this behavior you can provide
       // a childFactory function to wrap every child, even the ones that are
       // leaving.
       childrenToRender.push(React.cloneElement(this.props.childFactory(child), { ref: key, key: key }));
     }
   }

   // Do not forward ReactTransitionGroup props to primitive DOM nodes
   var props = _assign({}, this.props);
   delete props.transitionLeave;
   delete props.transitionName;
   delete props.transitionAppear;
   delete props.transitionEnter;
   delete props.childFactory;
   delete props.transitionLeaveTimeout;
   delete props.transitionEnterTimeout;
   delete props.transitionAppearTimeout;
   delete props.component;

   return React.createElement(this.props.component, props, childrenToRender);
 };

 return ReactTransitionGroup;
}(React.Component);

ReactTransitionGroup.displayName = 'ReactTransitionGroup';
ReactTransitionGroup.propTypes = {
 component: React.PropTypes.any,
 childFactory: React.PropTypes.func
};
ReactTransitionGroup.defaultProps = {
 component: 'span',
 childFactory: emptyFunction.thatReturnsArgument
};


module.exports = ReactTransitionGroup;
},{"27":27,"44":44,"49":49,"5":5,"6":6}],30:[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.4.1';
},{}],31:[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 LinkedStateMixin = _dereq_(3);
var React = _dereq_(5);
var ReactAddonsDOMDependencies = _dereq_(6);
var ReactComponentWithPureRenderMixin = _dereq_(13);
var ReactCSSTransitionGroup = _dereq_(7);
var ReactFragment = _dereq_(19);
var ReactTransitionGroup = _dereq_(29);

var shallowCompare = _dereq_(39);
var update = _dereq_(41);

React.addons = {
 CSSTransitionGroup: ReactCSSTransitionGroup,
 LinkedStateMixin: LinkedStateMixin,
 PureRenderMixin: ReactComponentWithPureRenderMixin,
 TransitionGroup: ReactTransitionGroup,

 createFragment: ReactFragment.create,
 shallowCompare: shallowCompare,
 update: update
};

if ("development" !== 'production') {
 // For the UMD build we get these lazily from the global since they're tied
 // to the DOM renderer and it hasn't loaded yet.
 Object.defineProperty(React.addons, 'Perf', {
   enumerable: true,
   get: function () {
     return ReactAddonsDOMDependencies.getReactPerf();
   }
 });
 Object.defineProperty(React.addons, 'TestUtils', {
   enumerable: true,
   get: function () {
     return ReactAddonsDOMDependencies.getReactTestUtils();
   }
 });
}

module.exports = React;
},{"13":13,"19":19,"29":29,"3":3,"39":39,"41":41,"5":5,"6":6,"7":7}],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';

var _assign = _dereq_(49);

var ReactWithAddons = _dereq_(31);

// `version` will be added here by the React module.
var ReactWithAddonsUMDEntry = _assign({
 __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: {
   ReactCurrentOwner: _dereq_(14)
 }
}, ReactWithAddons);

if ("development" !== 'production') {
 _assign(ReactWithAddonsUMDEntry.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED, {
   // ReactComponentTreeHook should not be included in production.
   ReactComponentTreeHook: _dereq_(12)
 });
}

module.exports = ReactWithAddonsUMDEntry;
},{"12":12,"14":14,"31":31,"49":49}],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';

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;
},{}],34:[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_(38);

var ReactPropTypeLocationNames = _dereq_(22);
var ReactPropTypesSecret = _dereq_(24);

var invariant = _dereq_(46);
var warning = _dereq_(48);

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_(12);
}

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_(12);
         }
         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)
},{"12":12,"22":22,"24":24,"38":38,"46":46,"48":48}],35:[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 KeyEscapeUtils = _dereq_(2);
var traverseAllChildren = _dereq_(40);
var warning = _dereq_(48);

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_(12);
}

/**
* @param {function} traverseContext Context passed through traversal.
* @param {?ReactComponent} child React child component.
* @param {!string} name String name of key path to child.
* @param {number=} selfDebugID Optional debugID of the current internal instance.
*/
function flattenSingleChildIntoContext(traverseContext, child, name, selfDebugID) {
 // We found a component instance.
 if (traverseContext && typeof traverseContext === 'object') {
   var result = traverseContext;
   var keyUnique = result[name] === undefined;
   if ("development" !== 'production') {
     if (!ReactComponentTreeHook) {
       ReactComponentTreeHook = _dereq_(12);
     }
     if (!keyUnique) {
       "development" !== 'production' ? warning(false, 'flattenChildren(...): Encountered two children with the same key, ' + '`%s`. Child keys must be unique; when two children share a key, only ' + 'the first child will be used.%s', KeyEscapeUtils.unescape(name), ReactComponentTreeHook.getStackAddendumByID(selfDebugID)) : void 0;
     }
   }
   if (keyUnique && child != null) {
     result[name] = child;
   }
 }
}

/**
* Flattens children that are typically specified as `props.children`. Any null
* children will not be included in the resulting object.
* @return {!object} flattened children keyed by name.
*/
function flattenChildren(children, selfDebugID) {
 if (children == null) {
   return children;
 }
 var result = {};

 if ("development" !== 'production') {
   traverseAllChildren(children, function (traverseContext, child, name) {
     return flattenSingleChildIntoContext(traverseContext, child, name, selfDebugID);
   }, result);
 } else {
   traverseAllChildren(children, flattenSingleChildIntoContext, result);
 }
 return result;
}

module.exports = flattenChildren;
}).call(this,undefined)
},{"12":12,"2":2,"40":40,"48":48}],36:[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;
},{}],37:[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_(38);

var ReactElement = _dereq_(16);

var invariant = _dereq_(46);

/**
* 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;
},{"16":16,"38":38,"46":46}],38:[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;
},{}],39:[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 shallowEqual = _dereq_(47);

/**
* Does a shallow comparison for props and state.
* See ReactComponentWithPureRenderMixin
* See also https://facebook.github.io/react/docs/shallow-compare.html
*/
function shallowCompare(instance, nextProps, nextState) {
 return !shallowEqual(instance.props, nextProps) || !shallowEqual(instance.state, nextState);
}

module.exports = shallowCompare;
},{"47":47}],40:[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_(38);

var ReactCurrentOwner = _dereq_(14);
var REACT_ELEMENT_TYPE = _dereq_(17);

var getIteratorFn = _dereq_(36);
var invariant = _dereq_(46);
var KeyEscapeUtils = _dereq_(2);
var warning = _dereq_(48);

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;
},{"14":14,"17":17,"2":2,"36":36,"38":38,"46":46,"48":48}],41:[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.
*
*/

/* global hasOwnProperty:true */

'use strict';

var _prodInvariant = _dereq_(38),
   _assign = _dereq_(49);

var invariant = _dereq_(46);
var hasOwnProperty = {}.hasOwnProperty;

function shallowCopy(x) {
 if (Array.isArray(x)) {
   return x.concat();
 } else if (x && typeof x === 'object') {
   return _assign(new x.constructor(), x);
 } else {
   return x;
 }
}

var COMMAND_PUSH = '$push';
var COMMAND_UNSHIFT = '$unshift';
var COMMAND_SPLICE = '$splice';
var COMMAND_SET = '$set';
var COMMAND_MERGE = '$merge';
var COMMAND_APPLY = '$apply';

var ALL_COMMANDS_LIST = [COMMAND_PUSH, COMMAND_UNSHIFT, COMMAND_SPLICE, COMMAND_SET, COMMAND_MERGE, COMMAND_APPLY];

var ALL_COMMANDS_SET = {};

ALL_COMMANDS_LIST.forEach(function (command) {
 ALL_COMMANDS_SET[command] = true;
});

function invariantArrayCase(value, spec, command) {
 !Array.isArray(value) ? "development" !== 'production' ? invariant(false, 'update(): expected target of %s to be an array; got %s.', command, value) : _prodInvariant('1', command, value) : void 0;
 var specValue = spec[command];
 !Array.isArray(specValue) ? "development" !== 'production' ? invariant(false, 'update(): expected spec of %s to be an array; got %s. Did you forget to wrap your parameter in an array?', command, specValue) : _prodInvariant('2', command, specValue) : void 0;
}

/**
* Returns a updated shallow copy of an object without mutating the original.
* See https://facebook.github.io/react/docs/update.html for details.
*/
function update(value, spec) {
 !(typeof spec === 'object') ? "development" !== 'production' ? invariant(false, 'update(): You provided a key path to update() that did not contain one of %s. Did you forget to include {%s: ...}?', ALL_COMMANDS_LIST.join(', '), COMMAND_SET) : _prodInvariant('3', ALL_COMMANDS_LIST.join(', '), COMMAND_SET) : void 0;

 if (hasOwnProperty.call(spec, COMMAND_SET)) {
   !(Object.keys(spec).length === 1) ? "development" !== 'production' ? invariant(false, 'Cannot have more than one key in an object with %s', COMMAND_SET) : _prodInvariant('4', COMMAND_SET) : void 0;

   return spec[COMMAND_SET];
 }

 var nextValue = shallowCopy(value);

 if (hasOwnProperty.call(spec, COMMAND_MERGE)) {
   var mergeObj = spec[COMMAND_MERGE];
   !(mergeObj && typeof mergeObj === 'object') ? "development" !== 'production' ? invariant(false, 'update(): %s expects a spec of type \'object\'; got %s', COMMAND_MERGE, mergeObj) : _prodInvariant('5', COMMAND_MERGE, mergeObj) : void 0;
   !(nextValue && typeof nextValue === 'object') ? "development" !== 'production' ? invariant(false, 'update(): %s expects a target of type \'object\'; got %s', COMMAND_MERGE, nextValue) : _prodInvariant('6', COMMAND_MERGE, nextValue) : void 0;
   _assign(nextValue, spec[COMMAND_MERGE]);
 }

 if (hasOwnProperty.call(spec, COMMAND_PUSH)) {
   invariantArrayCase(value, spec, COMMAND_PUSH);
   spec[COMMAND_PUSH].forEach(function (item) {
     nextValue.push(item);
   });
 }

 if (hasOwnProperty.call(spec, COMMAND_UNSHIFT)) {
   invariantArrayCase(value, spec, COMMAND_UNSHIFT);
   spec[COMMAND_UNSHIFT].forEach(function (item) {
     nextValue.unshift(item);
   });
 }

 if (hasOwnProperty.call(spec, COMMAND_SPLICE)) {
   !Array.isArray(value) ? "development" !== 'production' ? invariant(false, 'Expected %s target to be an array; got %s', COMMAND_SPLICE, value) : _prodInvariant('7', COMMAND_SPLICE, value) : void 0;
   !Array.isArray(spec[COMMAND_SPLICE]) ? "development" !== 'production' ? invariant(false, 'update(): expected spec of %s to be an array of arrays; got %s. Did you forget to wrap your parameters in an array?', COMMAND_SPLICE, spec[COMMAND_SPLICE]) : _prodInvariant('8', COMMAND_SPLICE, spec[COMMAND_SPLICE]) : void 0;
   spec[COMMAND_SPLICE].forEach(function (args) {
     !Array.isArray(args) ? "development" !== 'production' ? invariant(false, 'update(): expected spec of %s to be an array of arrays; got %s. Did you forget to wrap your parameters in an array?', COMMAND_SPLICE, spec[COMMAND_SPLICE]) : _prodInvariant('8', COMMAND_SPLICE, spec[COMMAND_SPLICE]) : void 0;
     nextValue.splice.apply(nextValue, args);
   });
 }

 if (hasOwnProperty.call(spec, COMMAND_APPLY)) {
   !(typeof spec[COMMAND_APPLY] === 'function') ? "development" !== 'production' ? invariant(false, 'update(): expected spec of %s to be a function; got %s.', COMMAND_APPLY, spec[COMMAND_APPLY]) : _prodInvariant('9', COMMAND_APPLY, spec[COMMAND_APPLY]) : void 0;
   nextValue = spec[COMMAND_APPLY](nextValue);
 }

 for (var k in spec) {
   if (!(ALL_COMMANDS_SET.hasOwnProperty(k) && ALL_COMMANDS_SET[k])) {
     nextValue[k] = update(value[k], spec[k]);
   }
 }

 return nextValue;
}

module.exports = update;
},{"38":38,"46":46,"49":49}],42:[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.
*
* @typechecks
*/

var invariant = _dereq_(46);

/**
* The CSSCore module specifies the API (and implements most of the methods)
* that should be used when dealing with the display of elements (via their
* CSS classes and visibility on screen. It is an API focused on mutating the
* display and not reading it as no logical state should be encoded in the
* display of elements.
*/

/* Slow implementation for browsers that don't natively support .matches() */
function matchesSelector_SLOW(element, selector) {
 var root = element;
 while (root.parentNode) {
   root = root.parentNode;
 }

 var all = root.querySelectorAll(selector);
 return Array.prototype.indexOf.call(all, element) !== -1;
}

var CSSCore = {

 /**
  * Adds the class passed in to the element if it doesn't already have it.
  *
  * @param {DOMElement} element the element to set the class on
  * @param {string} className the CSS className
  * @return {DOMElement} the element passed in
  */
 addClass: function addClass(element, className) {
   !!/\s/.test(className) ? "development" !== 'production' ? invariant(false, 'CSSCore.addClass takes only a single class name. "%s" contains ' + 'multiple classes.', className) : invariant(false) : void 0;

   if (className) {
     if (element.classList) {
       element.classList.add(className);
     } else if (!CSSCore.hasClass(element, className)) {
       element.className = element.className + ' ' + className;
     }
   }
   return element;
 },

 /**
  * Removes the class passed in from the element
  *
  * @param {DOMElement} element the element to set the class on
  * @param {string} className the CSS className
  * @return {DOMElement} the element passed in
  */
 removeClass: function removeClass(element, className) {
   !!/\s/.test(className) ? "development" !== 'production' ? invariant(false, 'CSSCore.removeClass takes only a single class name. "%s" contains ' + 'multiple classes.', className) : invariant(false) : void 0;

   if (className) {
     if (element.classList) {
       element.classList.remove(className);
     } else if (CSSCore.hasClass(element, className)) {
       element.className = element.className.replace(new RegExp('(^|\\s)' + className + '(?:\\s|$)', 'g'), '$1').replace(/\s+/g, ' ') // multiple spaces to one
       .replace(/^\s*|\s*$/g, ''); // trim the ends
     }
   }
   return element;
 },

 /**
  * Helper to add or remove a class from an element based on a condition.
  *
  * @param {DOMElement} element the element to set the class on
  * @param {string} className the CSS className
  * @param {*} bool condition to whether to add or remove the class
  * @return {DOMElement} the element passed in
  */
 conditionClass: function conditionClass(element, className, bool) {
   return (bool ? CSSCore.addClass : CSSCore.removeClass)(element, className);
 },

 /**
  * Tests whether the element has the class specified.
  *
  * @param {DOMNode|DOMWindow} element the element to check the class on
  * @param {string} className the CSS className
  * @return {boolean} true if the element has the class, false if not
  */
 hasClass: function hasClass(element, className) {
   !!/\s/.test(className) ? "development" !== 'production' ? invariant(false, 'CSS.hasClass takes only a single class name.') : invariant(false) : void 0;
   if (element.classList) {
     return !!className && element.classList.contains(className);
   }
   return (' ' + element.className + ' ').indexOf(' ' + className + ' ') > -1;
 },

 /**
  * Tests whether the element matches the selector specified
  *
  * @param {DOMNode|DOMWindow} element the element that we are querying
  * @param {string} selector the CSS selector
  * @return {boolean} true if the element matches the selector, false if not
  */
 matchesSelector: function matchesSelector(element, selector) {
   var matchesImpl = element.matches || element.webkitMatchesSelector || element.mozMatchesSelector || element.msMatchesSelector || function (s) {
     return matchesSelector_SLOW(element, s);
   };
   return matchesImpl.call(element, selector);
 }

};

module.exports = CSSCore;
},{"46":46}],43:[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 canUseDOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement);

/**
* Simple, lightweight module assisting with the detection and context of
* Worker. Helps avoid circular dependencies and allows code to reason about
* whether or not they are in a Worker, even if they never include the main
* `ReactWorker` dependency.
*/
var ExecutionEnvironment = {

 canUseDOM: canUseDOM,

 canUseWorkers: typeof Worker !== 'undefined',

 canUseEventListeners: canUseDOM && !!(window.addEventListener || window.attachEvent),

 canUseViewport: canUseDOM && !!window.screen,

 isInWorker: !canUseDOM // For now, this is true - might change in the future.

};

module.exports = ExecutionEnvironment;
},{}],44:[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;
},{}],45:[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;
},{}],46:[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.
*/

function invariant(condition, format, a, b, c, d, e, f) {
 if ("development" !== 'production') {
   if (format === undefined) {
     throw new Error('invariant requires an error message argument');
   }
 }

 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;
},{}],47:[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.
*
* @typechecks
*
*/

/*eslint-disable no-self-compare */

'use strict';

var hasOwnProperty = Object.prototype.hasOwnProperty;

/**
* 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
*/
function is(x, y) {
 // SameValue algorithm
 if (x === y) {
   // Steps 1-5, 7-10
   // Steps 6.b-6.e: +0 != -0
   // Added the nonzero y check to make Flow happy, but it is redundant
   return x !== 0 || y !== 0 || 1 / x === 1 / y;
 } else {
   // Step 6.a: NaN == NaN
   return x !== x && y !== y;
 }
}

/**
* Performs equality by iterating through keys on an object and returning false
* when any key has values which are not strictly equal between the arguments.
* Returns true when the values of all keys are strictly equal.
*/
function shallowEqual(objA, objB) {
 if (is(objA, objB)) {
   return true;
 }

 if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {
   return false;
 }

 var keysA = Object.keys(objA);
 var keysB = Object.keys(objB);

 if (keysA.length !== keysB.length) {
   return false;
 }

 // Test for A's keys different from B.
 for (var i = 0; i < keysA.length; i++) {
   if (!hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) {
     return false;
   }
 }

 return true;
}

module.exports = shallowEqual;
},{}],48:[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_(44);

/**
* 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;
},{"44":44}],49:[function(_dereq_,module,exports){
'use strict';
/* eslint-disable no-unused-vars */
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
   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 (e) {
   // 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 (Object.getOwnPropertySymbols) {
     symbols = Object.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])(32);
});