\n );\n },\n\n showTooltip(show) {\n this.setState({\n showTooltip: show,\n });\n },\n\n _trimAlignValue(v, propsArg) {\n let val = v;\n const props = propsArg || this.props;\n const step = props.marks.length > 0 ? (props.max - props.min) / (props.marks.length - 1) : props.step;\n\n if (val <= props.min) {\n val = props.min;\n }\n if (val >= props.max) {\n val = props.max;\n }\n\n const valModStep = (val - props.min) % step;\n let alignValue = val - valModStep;\n\n if (Math.abs(valModStep) * 2 >= step) {\n alignValue += (valModStep > 0) ? step : (-step);\n }\n\n return parseFloat(alignValue.toFixed(5));\n },\n\n _calcOffset(value) {\n const ratio = (value - this.props.min) / (this.props.max - this.props.min);\n return ratio * 100 + '%';\n },\n\n _calcValue(offset) {\n const ratio = offset / this.getSliderLength();\n return ratio * (this.props.max - this.props.min) + this.props.min;\n },\n\n _calValueByPos(position) {\n const pixelOffset = position - this.getSliderStart();\n // pixelOffset -= (this.state.onSize / 2);\n const nextValue = this._trimAlignValue(this._calcValue(pixelOffset));\n this.setState({\n value: nextValue,\n });\n return nextValue;\n },\n\n _getTouchPosition(e) {\n const touch = e.touches[0];\n return touch.pageX;\n },\n\n _triggerEvents(event, v) {\n const props = this.props;\n const hasMarks = props.marks && props.marks.length > 0;\n if (props[event]) {\n let data;\n if (hasMarks) {\n data = this.getIndex(v);\n } else if (v === undefined) {\n data = this.state.value;\n } else {\n data = v;\n }\n props[event](data);\n }\n },\n\n _addDocumentEvents(type) {\n if (type === 'touch') {\n // just work for chrome iOS Safari and Android Browser\n this.onTouchMoveListener = DomUtils.addEventListener(document, 'touchmove', this.onTouchMove);\n this.onTouchUpListener = DomUtils.addEventListener(document, 'touchend', this.onTouchUp);\n } else if (type === 'mouse') {\n this.onMouseMoveListener = DomUtils.addEventListener(document, 'mousemove', this.onMouseMove);\n this.onMouseUpListener = DomUtils.addEventListener(document, 'mouseup', this.onMouseUp);\n }\n },\n\n _removeEventons(type) {\n if (type === 'touch') {\n this.onTouchMoveListener.remove();\n this.onTouchUpListener.remove();\n } else if (type === 'mouse') {\n this.onMouseMoveListener.remove();\n this.onMouseUpListener.remove();\n }\n },\n\n _start(position, value) {\n this._triggerEvents('onBeforeChange');\n this.startValue = value;\n this.startPosition = position;\n this.setState({\n dragging: true,\n });\n },\n\n _end(type, showToolTip) {\n this._removeEventons(type);\n this._triggerEvents('onAfterChange');\n this.setState({\n dragging: false,\n showTooltip: !!showToolTip,\n });\n },\n});\n\nexport default Slider;\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/Slider.jsx\n **/","module.exports = require('./lib/React');\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/react.js\n ** module id = 6\n ** module chunks = 0\n **/","/**\n * Copyright 2013-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule React\n */\n\n/* globals __REACT_DEVTOOLS_GLOBAL_HOOK__*/\n\n'use strict';\n\nvar EventPluginUtils = require(\"./EventPluginUtils\");\nvar ReactChildren = require(\"./ReactChildren\");\nvar ReactComponent = require(\"./ReactComponent\");\nvar ReactClass = require(\"./ReactClass\");\nvar ReactContext = require(\"./ReactContext\");\nvar ReactCurrentOwner = require(\"./ReactCurrentOwner\");\nvar ReactElement = require(\"./ReactElement\");\nvar ReactElementValidator = require(\"./ReactElementValidator\");\nvar ReactDOM = require(\"./ReactDOM\");\nvar ReactDOMTextComponent = require(\"./ReactDOMTextComponent\");\nvar ReactDefaultInjection = require(\"./ReactDefaultInjection\");\nvar ReactInstanceHandles = require(\"./ReactInstanceHandles\");\nvar ReactMount = require(\"./ReactMount\");\nvar ReactPerf = require(\"./ReactPerf\");\nvar ReactPropTypes = require(\"./ReactPropTypes\");\nvar ReactReconciler = require(\"./ReactReconciler\");\nvar ReactServerRendering = require(\"./ReactServerRendering\");\n\nvar assign = require(\"./Object.assign\");\nvar findDOMNode = require(\"./findDOMNode\");\nvar onlyChild = require(\"./onlyChild\");\n\nReactDefaultInjection.inject();\n\nvar createElement = ReactElement.createElement;\nvar createFactory = ReactElement.createFactory;\nvar cloneElement = ReactElement.cloneElement;\n\nif (\"production\" !== process.env.NODE_ENV) {\n createElement = ReactElementValidator.createElement;\n createFactory = ReactElementValidator.createFactory;\n cloneElement = ReactElementValidator.cloneElement;\n}\n\nvar render = ReactPerf.measure('React', 'render', ReactMount.render);\n\nvar React = {\n Children: {\n map: ReactChildren.map,\n forEach: ReactChildren.forEach,\n count: ReactChildren.count,\n only: onlyChild\n },\n Component: ReactComponent,\n DOM: ReactDOM,\n PropTypes: ReactPropTypes,\n initializeTouchEvents: function(shouldUseTouch) {\n EventPluginUtils.useTouchEvents = shouldUseTouch;\n },\n createClass: ReactClass.createClass,\n createElement: createElement,\n cloneElement: cloneElement,\n createFactory: createFactory,\n createMixin: function(mixin) {\n // Currently a noop. Will be used to validate and trace mixins.\n return mixin;\n },\n constructAndRenderComponent: ReactMount.constructAndRenderComponent,\n constructAndRenderComponentByID: ReactMount.constructAndRenderComponentByID,\n findDOMNode: findDOMNode,\n render: render,\n renderToString: ReactServerRendering.renderToString,\n renderToStaticMarkup: ReactServerRendering.renderToStaticMarkup,\n unmountComponentAtNode: ReactMount.unmountComponentAtNode,\n isValidElement: ReactElement.isValidElement,\n withContext: ReactContext.withContext,\n\n // Hook for JSX spread, don't use this for anything else.\n __spread: assign\n};\n\n// Inject the runtime into a devtools global hook regardless of browser.\n// Allows for debugging when the hook is injected on the page.\nif (\n typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&\n typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.inject === 'function') {\n __REACT_DEVTOOLS_GLOBAL_HOOK__.inject({\n CurrentOwner: ReactCurrentOwner,\n InstanceHandles: ReactInstanceHandles,\n Mount: ReactMount,\n Reconciler: ReactReconciler,\n TextComponent: ReactDOMTextComponent\n });\n}\n\nif (\"production\" !== process.env.NODE_ENV) {\n var ExecutionEnvironment = require(\"./ExecutionEnvironment\");\n if (ExecutionEnvironment.canUseDOM && window.top === window.self) {\n\n // If we're in Chrome, look for the devtools marker and provide a download\n // link if not installed.\n if (navigator.userAgent.indexOf('Chrome') > -1) {\n if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === 'undefined') {\n console.debug(\n 'Download the React DevTools for a better development experience: ' +\n 'https://fb.me/react-devtools'\n );\n }\n }\n\n var expectedFeatures = [\n // shims\n Array.isArray,\n Array.prototype.every,\n Array.prototype.forEach,\n Array.prototype.indexOf,\n Array.prototype.map,\n Date.now,\n Function.prototype.bind,\n Object.keys,\n String.prototype.split,\n String.prototype.trim,\n\n // shams\n Object.create,\n Object.freeze\n ];\n\n for (var i = 0; i < expectedFeatures.length; i++) {\n if (!expectedFeatures[i]) {\n console.error(\n 'One or more ES5 shim/shams expected by React are not available: ' +\n 'https://fb.me/react-warning-polyfills'\n );\n break;\n }\n }\n }\n}\n\nReact.version = '0.13.3';\n\nmodule.exports = React;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/React.js\n ** module id = 7\n ** module chunks = 0\n **/","// shim for using process in browser\n\nvar process = module.exports = {};\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n draining = false;\n if (currentQueue.length) {\n queue = currentQueue.concat(queue);\n } else {\n queueIndex = -1;\n }\n if (queue.length) {\n drainQueue();\n }\n}\n\nfunction drainQueue() {\n if (draining) {\n return;\n }\n var timeout = setTimeout(cleanUpNextTick);\n draining = true;\n\n var len = queue.length;\n while(len) {\n currentQueue = queue;\n queue = [];\n while (++queueIndex < len) {\n if (currentQueue) {\n currentQueue[queueIndex].run();\n }\n }\n queueIndex = -1;\n len = queue.length;\n }\n currentQueue = null;\n draining = false;\n clearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n var args = new Array(arguments.length - 1);\n if (arguments.length > 1) {\n for (var i = 1; i < arguments.length; i++) {\n args[i - 1] = arguments[i];\n }\n }\n queue.push(new Item(fun, args));\n if (queue.length === 1 && !draining) {\n setTimeout(drainQueue, 0);\n }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n this.fun = fun;\n this.array = array;\n}\nItem.prototype.run = function () {\n this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\n\nprocess.binding = function (name) {\n throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** (webpack)/~/node-libs-browser/~/process/browser.js\n ** module id = 8\n ** module chunks = 0\n **/","/**\n * Copyright 2013-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule EventPluginUtils\n */\n\n'use strict';\n\nvar EventConstants = require(\"./EventConstants\");\n\nvar invariant = require(\"./invariant\");\n\n/**\n * Injected dependencies:\n */\n\n/**\n * - `Mount`: [required] Module that can convert between React dom IDs and\n * actual node references.\n */\nvar injection = {\n Mount: null,\n injectMount: function(InjectedMount) {\n injection.Mount = InjectedMount;\n if (\"production\" !== process.env.NODE_ENV) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n InjectedMount && InjectedMount.getNode,\n 'EventPluginUtils.injection.injectMount(...): Injected Mount module ' +\n 'is missing getNode.'\n ) : invariant(InjectedMount && InjectedMount.getNode));\n }\n }\n};\n\nvar topLevelTypes = EventConstants.topLevelTypes;\n\nfunction isEndish(topLevelType) {\n return topLevelType === topLevelTypes.topMouseUp ||\n topLevelType === topLevelTypes.topTouchEnd ||\n topLevelType === topLevelTypes.topTouchCancel;\n}\n\nfunction isMoveish(topLevelType) {\n return topLevelType === topLevelTypes.topMouseMove ||\n topLevelType === topLevelTypes.topTouchMove;\n}\nfunction isStartish(topLevelType) {\n return topLevelType === topLevelTypes.topMouseDown ||\n topLevelType === topLevelTypes.topTouchStart;\n}\n\n\nvar validateEventDispatches;\nif (\"production\" !== process.env.NODE_ENV) {\n validateEventDispatches = function(event) {\n var dispatchListeners = event._dispatchListeners;\n var dispatchIDs = event._dispatchIDs;\n\n var listenersIsArr = Array.isArray(dispatchListeners);\n var idsIsArr = Array.isArray(dispatchIDs);\n var IDsLen = idsIsArr ? dispatchIDs.length : dispatchIDs ? 1 : 0;\n var listenersLen = listenersIsArr ?\n dispatchListeners.length :\n dispatchListeners ? 1 : 0;\n\n (\"production\" !== process.env.NODE_ENV ? invariant(\n idsIsArr === listenersIsArr && IDsLen === listenersLen,\n 'EventPluginUtils: Invalid `event`.'\n ) : invariant(idsIsArr === listenersIsArr && IDsLen === listenersLen));\n };\n}\n\n/**\n * Invokes `cb(event, listener, id)`. Avoids using call if no scope is\n * provided. The `(listener,id)` pair effectively forms the \"dispatch\" but are\n * kept separate to conserve memory.\n */\nfunction forEachEventDispatch(event, cb) {\n var dispatchListeners = event._dispatchListeners;\n var dispatchIDs = event._dispatchIDs;\n if (\"production\" !== process.env.NODE_ENV) {\n validateEventDispatches(event);\n }\n if (Array.isArray(dispatchListeners)) {\n for (var i = 0; i < dispatchListeners.length; i++) {\n if (event.isPropagationStopped()) {\n break;\n }\n // Listeners and IDs are two parallel arrays that are always in sync.\n cb(event, dispatchListeners[i], dispatchIDs[i]);\n }\n } else if (dispatchListeners) {\n cb(event, dispatchListeners, dispatchIDs);\n }\n}\n\n/**\n * Default implementation of PluginModule.executeDispatch().\n * @param {SyntheticEvent} SyntheticEvent to handle\n * @param {function} Application-level callback\n * @param {string} domID DOM id to pass to the callback.\n */\nfunction executeDispatch(event, listener, domID) {\n event.currentTarget = injection.Mount.getNode(domID);\n var returnValue = listener(event, domID);\n event.currentTarget = null;\n return returnValue;\n}\n\n/**\n * Standard/simple iteration through an event's collected dispatches.\n */\nfunction executeDispatchesInOrder(event, cb) {\n forEachEventDispatch(event, cb);\n event._dispatchListeners = null;\n event._dispatchIDs = null;\n}\n\n/**\n * Standard/simple iteration through an event's collected dispatches, but stops\n * at the first dispatch execution returning true, and returns that id.\n *\n * @return id of the first dispatch execution who's listener returns true, or\n * null if no listener returned true.\n */\nfunction executeDispatchesInOrderStopAtTrueImpl(event) {\n var dispatchListeners = event._dispatchListeners;\n var dispatchIDs = event._dispatchIDs;\n if (\"production\" !== process.env.NODE_ENV) {\n validateEventDispatches(event);\n }\n if (Array.isArray(dispatchListeners)) {\n for (var i = 0; i < dispatchListeners.length; i++) {\n if (event.isPropagationStopped()) {\n break;\n }\n // Listeners and IDs are two parallel arrays that are always in sync.\n if (dispatchListeners[i](event, dispatchIDs[i])) {\n return dispatchIDs[i];\n }\n }\n } else if (dispatchListeners) {\n if (dispatchListeners(event, dispatchIDs)) {\n return dispatchIDs;\n }\n }\n return null;\n}\n\n/**\n * @see executeDispatchesInOrderStopAtTrueImpl\n */\nfunction executeDispatchesInOrderStopAtTrue(event) {\n var ret = executeDispatchesInOrderStopAtTrueImpl(event);\n event._dispatchIDs = null;\n event._dispatchListeners = null;\n return ret;\n}\n\n/**\n * Execution of a \"direct\" dispatch - there must be at most one dispatch\n * accumulated on the event or it is considered an error. It doesn't really make\n * sense for an event with multiple dispatches (bubbled) to keep track of the\n * return values at each dispatch execution, but it does tend to make sense when\n * dealing with \"direct\" dispatches.\n *\n * @return The return value of executing the single dispatch.\n */\nfunction executeDirectDispatch(event) {\n if (\"production\" !== process.env.NODE_ENV) {\n validateEventDispatches(event);\n }\n var dispatchListener = event._dispatchListeners;\n var dispatchID = event._dispatchIDs;\n (\"production\" !== process.env.NODE_ENV ? invariant(\n !Array.isArray(dispatchListener),\n 'executeDirectDispatch(...): Invalid `event`.'\n ) : invariant(!Array.isArray(dispatchListener)));\n var res = dispatchListener ?\n dispatchListener(event, dispatchID) :\n null;\n event._dispatchListeners = null;\n event._dispatchIDs = null;\n return res;\n}\n\n/**\n * @param {SyntheticEvent} event\n * @return {bool} True iff number of dispatches accumulated is greater than 0.\n */\nfunction hasDispatches(event) {\n return !!event._dispatchListeners;\n}\n\n/**\n * General utilities that are useful in creating custom Event Plugins.\n */\nvar EventPluginUtils = {\n isEndish: isEndish,\n isMoveish: isMoveish,\n isStartish: isStartish,\n\n executeDirectDispatch: executeDirectDispatch,\n executeDispatch: executeDispatch,\n executeDispatchesInOrder: executeDispatchesInOrder,\n executeDispatchesInOrderStopAtTrue: executeDispatchesInOrderStopAtTrue,\n hasDispatches: hasDispatches,\n injection: injection,\n useTouchEvents: false\n};\n\nmodule.exports = EventPluginUtils;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/EventPluginUtils.js\n ** module id = 9\n ** module chunks = 0\n **/","/**\n * Copyright 2013-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule EventConstants\n */\n\n'use strict';\n\nvar keyMirror = require(\"./keyMirror\");\n\nvar PropagationPhases = keyMirror({bubbled: null, captured: null});\n\n/**\n * Types of raw signals from the browser caught at the top level.\n */\nvar topLevelTypes = keyMirror({\n topBlur: null,\n topChange: null,\n topClick: null,\n topCompositionEnd: null,\n topCompositionStart: null,\n topCompositionUpdate: null,\n topContextMenu: null,\n topCopy: null,\n topCut: null,\n topDoubleClick: null,\n topDrag: null,\n topDragEnd: null,\n topDragEnter: null,\n topDragExit: null,\n topDragLeave: null,\n topDragOver: null,\n topDragStart: null,\n topDrop: null,\n topError: null,\n topFocus: null,\n topInput: null,\n topKeyDown: null,\n topKeyPress: null,\n topKeyUp: null,\n topLoad: null,\n topMouseDown: null,\n topMouseMove: null,\n topMouseOut: null,\n topMouseOver: null,\n topMouseUp: null,\n topPaste: null,\n topReset: null,\n topScroll: null,\n topSelectionChange: null,\n topSubmit: null,\n topTextInput: null,\n topTouchCancel: null,\n topTouchEnd: null,\n topTouchMove: null,\n topTouchStart: null,\n topWheel: null\n});\n\nvar EventConstants = {\n topLevelTypes: topLevelTypes,\n PropagationPhases: PropagationPhases\n};\n\nmodule.exports = EventConstants;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/EventConstants.js\n ** module id = 10\n ** module chunks = 0\n **/","/**\n * Copyright 2013-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule keyMirror\n * @typechecks static-only\n */\n\n'use strict';\n\nvar invariant = require(\"./invariant\");\n\n/**\n * Constructs an enumeration with keys equal to their value.\n *\n * For example:\n *\n * var COLORS = keyMirror({blue: null, red: null});\n * var myColor = COLORS.blue;\n * var isColorValid = !!COLORS[myColor];\n *\n * The last line could not be performed if the values of the generated enum were\n * not equal to their keys.\n *\n * Input: {key1: val1, key2: val2}\n * Output: {key1: key1, key2: key2}\n *\n * @param {object} obj\n * @return {object}\n */\nvar keyMirror = function(obj) {\n var ret = {};\n var key;\n (\"production\" !== process.env.NODE_ENV ? invariant(\n obj instanceof Object && !Array.isArray(obj),\n 'keyMirror(...): Argument must be an object.'\n ) : invariant(obj instanceof Object && !Array.isArray(obj)));\n for (key in obj) {\n if (!obj.hasOwnProperty(key)) {\n continue;\n }\n ret[key] = key;\n }\n return ret;\n};\n\nmodule.exports = keyMirror;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/keyMirror.js\n ** module id = 11\n ** module chunks = 0\n **/","/**\n * Copyright 2013-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule invariant\n */\n\n\"use strict\";\n\n/**\n * Use invariant() to assert state which your program assumes to be true.\n *\n * Provide sprintf-style format (only %s is supported) and arguments\n * to provide information about what broke and what you were\n * expecting.\n *\n * The invariant message will be stripped in production, but the invariant\n * will remain to ensure logic does not differ in production.\n */\n\nvar invariant = function(condition, format, a, b, c, d, e, f) {\n if (\"production\" !== process.env.NODE_ENV) {\n if (format === undefined) {\n throw new Error('invariant requires an error message argument');\n }\n }\n\n if (!condition) {\n var error;\n if (format === undefined) {\n error = new Error(\n 'Minified exception occurred; use the non-minified dev environment ' +\n 'for the full error message and additional helpful warnings.'\n );\n } else {\n var args = [a, b, c, d, e, f];\n var argIndex = 0;\n error = new Error(\n 'Invariant Violation: ' +\n format.replace(/%s/g, function() { return args[argIndex++]; })\n );\n }\n\n error.framesToPop = 1; // we don't care about invariant's own frame\n throw error;\n }\n};\n\nmodule.exports = invariant;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/invariant.js\n ** module id = 12\n ** module chunks = 0\n **/","/**\n * Copyright 2013-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule ReactChildren\n */\n\n'use strict';\n\nvar PooledClass = require(\"./PooledClass\");\nvar ReactFragment = require(\"./ReactFragment\");\n\nvar traverseAllChildren = require(\"./traverseAllChildren\");\nvar warning = require(\"./warning\");\n\nvar twoArgumentPooler = PooledClass.twoArgumentPooler;\nvar threeArgumentPooler = PooledClass.threeArgumentPooler;\n\n/**\n * PooledClass representing the bookkeeping associated with performing a child\n * traversal. Allows avoiding binding callbacks.\n *\n * @constructor ForEachBookKeeping\n * @param {!function} forEachFunction Function to perform traversal with.\n * @param {?*} forEachContext Context to perform context with.\n */\nfunction ForEachBookKeeping(forEachFunction, forEachContext) {\n this.forEachFunction = forEachFunction;\n this.forEachContext = forEachContext;\n}\nPooledClass.addPoolingTo(ForEachBookKeeping, twoArgumentPooler);\n\nfunction forEachSingleChild(traverseContext, child, name, i) {\n var forEachBookKeeping = traverseContext;\n forEachBookKeeping.forEachFunction.call(\n forEachBookKeeping.forEachContext, child, i);\n}\n\n/**\n * Iterates through children that are typically specified as `props.children`.\n *\n * The provided forEachFunc(child, index) will be called for each\n * leaf child.\n *\n * @param {?*} children Children tree container.\n * @param {function(*, int)} forEachFunc.\n * @param {*} forEachContext Context for forEachContext.\n */\nfunction forEachChildren(children, forEachFunc, forEachContext) {\n if (children == null) {\n return children;\n }\n\n var traverseContext =\n ForEachBookKeeping.getPooled(forEachFunc, forEachContext);\n traverseAllChildren(children, forEachSingleChild, traverseContext);\n ForEachBookKeeping.release(traverseContext);\n}\n\n/**\n * PooledClass representing the bookkeeping associated with performing a child\n * mapping. Allows avoiding binding callbacks.\n *\n * @constructor MapBookKeeping\n * @param {!*} mapResult Object containing the ordered map of results.\n * @param {!function} mapFunction Function to perform mapping with.\n * @param {?*} mapContext Context to perform mapping with.\n */\nfunction MapBookKeeping(mapResult, mapFunction, mapContext) {\n this.mapResult = mapResult;\n this.mapFunction = mapFunction;\n this.mapContext = mapContext;\n}\nPooledClass.addPoolingTo(MapBookKeeping, threeArgumentPooler);\n\nfunction mapSingleChildIntoContext(traverseContext, child, name, i) {\n var mapBookKeeping = traverseContext;\n var mapResult = mapBookKeeping.mapResult;\n\n var keyUnique = !mapResult.hasOwnProperty(name);\n if (\"production\" !== process.env.NODE_ENV) {\n (\"production\" !== process.env.NODE_ENV ? warning(\n keyUnique,\n 'ReactChildren.map(...): Encountered two children with the same key, ' +\n '`%s`. Child keys must be unique; when two children share a key, only ' +\n 'the first child will be used.',\n name\n ) : null);\n }\n\n if (keyUnique) {\n var mappedChild =\n mapBookKeeping.mapFunction.call(mapBookKeeping.mapContext, child, i);\n mapResult[name] = mappedChild;\n }\n}\n\n/**\n * Maps children that are typically specified as `props.children`.\n *\n * The provided mapFunction(child, key, index) will be called for each\n * leaf child.\n *\n * TODO: This may likely break any calls to `ReactChildren.map` that were\n * previously relying on the fact that we guarded against null children.\n *\n * @param {?*} children Children tree container.\n * @param {function(*, int)} mapFunction.\n * @param {*} mapContext Context for mapFunction.\n * @return {object} Object containing the ordered map of results.\n */\nfunction mapChildren(children, func, context) {\n if (children == null) {\n return children;\n }\n\n var mapResult = {};\n var traverseContext = MapBookKeeping.getPooled(mapResult, func, context);\n traverseAllChildren(children, mapSingleChildIntoContext, traverseContext);\n MapBookKeeping.release(traverseContext);\n return ReactFragment.create(mapResult);\n}\n\nfunction forEachSingleChildDummy(traverseContext, child, name, i) {\n return null;\n}\n\n/**\n * Count the number of children that are typically specified as\n * `props.children`.\n *\n * @param {?*} children Children tree container.\n * @return {number} The number of children.\n */\nfunction countChildren(children, context) {\n return traverseAllChildren(children, forEachSingleChildDummy, null);\n}\n\nvar ReactChildren = {\n forEach: forEachChildren,\n map: mapChildren,\n count: countChildren\n};\n\nmodule.exports = ReactChildren;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactChildren.js\n ** module id = 13\n ** module chunks = 0\n **/","/**\n * Copyright 2013-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule PooledClass\n */\n\n'use strict';\n\nvar invariant = require(\"./invariant\");\n\n/**\n * Static poolers. Several custom versions for each potential number of\n * arguments. A completely generic pooler is easy to implement, but would\n * require accessing the `arguments` object. In each of these, `this` refers to\n * the Class itself, not an instance. If any others are needed, simply add them\n * here, or in their own files.\n */\nvar oneArgumentPooler = function(copyFieldsFrom) {\n var Klass = this;\n if (Klass.instancePool.length) {\n var instance = Klass.instancePool.pop();\n Klass.call(instance, copyFieldsFrom);\n return instance;\n } else {\n return new Klass(copyFieldsFrom);\n }\n};\n\nvar twoArgumentPooler = function(a1, a2) {\n var Klass = this;\n if (Klass.instancePool.length) {\n var instance = Klass.instancePool.pop();\n Klass.call(instance, a1, a2);\n return instance;\n } else {\n return new Klass(a1, a2);\n }\n};\n\nvar threeArgumentPooler = function(a1, a2, a3) {\n var Klass = this;\n if (Klass.instancePool.length) {\n var instance = Klass.instancePool.pop();\n Klass.call(instance, a1, a2, a3);\n return instance;\n } else {\n return new Klass(a1, a2, a3);\n }\n};\n\nvar fiveArgumentPooler = function(a1, a2, a3, a4, a5) {\n var Klass = this;\n if (Klass.instancePool.length) {\n var instance = Klass.instancePool.pop();\n Klass.call(instance, a1, a2, a3, a4, a5);\n return instance;\n } else {\n return new Klass(a1, a2, a3, a4, a5);\n }\n};\n\nvar standardReleaser = function(instance) {\n var Klass = this;\n (\"production\" !== process.env.NODE_ENV ? invariant(\n instance instanceof Klass,\n 'Trying to release an instance into a pool of a different type.'\n ) : invariant(instance instanceof Klass));\n if (instance.destructor) {\n instance.destructor();\n }\n if (Klass.instancePool.length < Klass.poolSize) {\n Klass.instancePool.push(instance);\n }\n};\n\nvar DEFAULT_POOL_SIZE = 10;\nvar DEFAULT_POOLER = oneArgumentPooler;\n\n/**\n * Augments `CopyConstructor` to be a poolable class, augmenting only the class\n * itself (statically) not adding any prototypical fields. Any CopyConstructor\n * you give this may have a `poolSize` property, and will look for a\n * prototypical `destructor` on instances (optional).\n *\n * @param {Function} CopyConstructor Constructor that can be used to reset.\n * @param {Function} pooler Customizable pooler.\n */\nvar addPoolingTo = function(CopyConstructor, pooler) {\n var NewKlass = CopyConstructor;\n NewKlass.instancePool = [];\n NewKlass.getPooled = pooler || DEFAULT_POOLER;\n if (!NewKlass.poolSize) {\n NewKlass.poolSize = DEFAULT_POOL_SIZE;\n }\n NewKlass.release = standardReleaser;\n return NewKlass;\n};\n\nvar PooledClass = {\n addPoolingTo: addPoolingTo,\n oneArgumentPooler: oneArgumentPooler,\n twoArgumentPooler: twoArgumentPooler,\n threeArgumentPooler: threeArgumentPooler,\n fiveArgumentPooler: fiveArgumentPooler\n};\n\nmodule.exports = PooledClass;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/PooledClass.js\n ** module id = 14\n ** module chunks = 0\n **/","/**\n * Copyright 2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n* @providesModule ReactFragment\n*/\n\n'use strict';\n\nvar ReactElement = require(\"./ReactElement\");\n\nvar warning = require(\"./warning\");\n\n/**\n * We used to allow keyed objects to serve as a collection of ReactElements,\n * or nested sets. This allowed us a way to explicitly key a set a fragment of\n * components. This is now being replaced with an opaque data structure.\n * The upgrade path is to call React.addons.createFragment({ key: value }) to\n * create a keyed fragment. The resulting data structure is opaque, for now.\n */\n\nif (\"production\" !== process.env.NODE_ENV) {\n var fragmentKey = '_reactFragment';\n var didWarnKey = '_reactDidWarn';\n var canWarnForReactFragment = false;\n\n try {\n // Feature test. Don't even try to issue this warning if we can't use\n // enumerable: false.\n\n var dummy = function() {\n return 1;\n };\n\n Object.defineProperty(\n {},\n fragmentKey,\n {enumerable: false, value: true}\n );\n\n Object.defineProperty(\n {},\n 'key',\n {enumerable: true, get: dummy}\n );\n\n canWarnForReactFragment = true;\n } catch (x) { }\n\n var proxyPropertyAccessWithWarning = function(obj, key) {\n Object.defineProperty(obj, key, {\n enumerable: true,\n get: function() {\n (\"production\" !== process.env.NODE_ENV ? warning(\n this[didWarnKey],\n 'A ReactFragment is an opaque type. Accessing any of its ' +\n 'properties is deprecated. Pass it to one of the React.Children ' +\n 'helpers.'\n ) : null);\n this[didWarnKey] = true;\n return this[fragmentKey][key];\n },\n set: function(value) {\n (\"production\" !== process.env.NODE_ENV ? warning(\n this[didWarnKey],\n 'A ReactFragment is an immutable opaque type. Mutating its ' +\n 'properties is deprecated.'\n ) : null);\n this[didWarnKey] = true;\n this[fragmentKey][key] = value;\n }\n });\n };\n\n var issuedWarnings = {};\n\n var didWarnForFragment = function(fragment) {\n // We use the keys and the type of the value as a heuristic to dedupe the\n // warning to avoid spamming too much.\n var fragmentCacheKey = '';\n for (var key in fragment) {\n fragmentCacheKey += key + ':' + (typeof fragment[key]) + ',';\n }\n var alreadyWarnedOnce = !!issuedWarnings[fragmentCacheKey];\n issuedWarnings[fragmentCacheKey] = true;\n return alreadyWarnedOnce;\n };\n}\n\nvar ReactFragment = {\n // Wrap a keyed object in an opaque proxy that warns you if you access any\n // of its properties.\n create: function(object) {\n if (\"production\" !== process.env.NODE_ENV) {\n if (typeof object !== 'object' || !object || Array.isArray(object)) {\n (\"production\" !== process.env.NODE_ENV ? warning(\n false,\n 'React.addons.createFragment only accepts a single object.',\n object\n ) : null);\n return object;\n }\n if (ReactElement.isValidElement(object)) {\n (\"production\" !== process.env.NODE_ENV ? warning(\n false,\n 'React.addons.createFragment does not accept a ReactElement ' +\n 'without a wrapper object.'\n ) : null);\n return object;\n }\n if (canWarnForReactFragment) {\n var proxy = {};\n Object.defineProperty(proxy, fragmentKey, {\n enumerable: false,\n value: object\n });\n Object.defineProperty(proxy, didWarnKey, {\n writable: true,\n enumerable: false,\n value: false\n });\n for (var key in object) {\n proxyPropertyAccessWithWarning(proxy, key);\n }\n Object.preventExtensions(proxy);\n return proxy;\n }\n }\n return object;\n },\n // Extract the original keyed object from the fragment opaque type. Warn if\n // a plain object is passed here.\n extract: function(fragment) {\n if (\"production\" !== process.env.NODE_ENV) {\n if (canWarnForReactFragment) {\n if (!fragment[fragmentKey]) {\n (\"production\" !== process.env.NODE_ENV ? warning(\n didWarnForFragment(fragment),\n 'Any use of a keyed object should be wrapped in ' +\n 'React.addons.createFragment(object) before being passed as a ' +\n 'child.'\n ) : null);\n return fragment;\n }\n return fragment[fragmentKey];\n }\n }\n return fragment;\n },\n // Check if this is a fragment and if so, extract the keyed object. If it\n // is a fragment-like object, warn that it should be wrapped. Ignore if we\n // can't determine what kind of object this is.\n extractIfFragment: function(fragment) {\n if (\"production\" !== process.env.NODE_ENV) {\n if (canWarnForReactFragment) {\n // If it is the opaque type, return the keyed object.\n if (fragment[fragmentKey]) {\n return fragment[fragmentKey];\n }\n // Otherwise, check each property if it has an element, if it does\n // it is probably meant as a fragment, so we can warn early. Defer,\n // the warning to extract.\n for (var key in fragment) {\n if (fragment.hasOwnProperty(key) &&\n ReactElement.isValidElement(fragment[key])) {\n // This looks like a fragment object, we should provide an\n // early warning.\n return ReactFragment.extract(fragment);\n }\n }\n }\n }\n return fragment;\n }\n};\n\nmodule.exports = ReactFragment;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactFragment.js\n ** module id = 15\n ** module chunks = 0\n **/","/**\n * Copyright 2014-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule ReactElement\n */\n\n'use strict';\n\nvar ReactContext = require(\"./ReactContext\");\nvar ReactCurrentOwner = require(\"./ReactCurrentOwner\");\n\nvar assign = require(\"./Object.assign\");\nvar warning = require(\"./warning\");\n\nvar RESERVED_PROPS = {\n key: true,\n ref: true\n};\n\n/**\n * Warn for mutations.\n *\n * @internal\n * @param {object} object\n * @param {string} key\n */\nfunction defineWarningProperty(object, key) {\n Object.defineProperty(object, key, {\n\n configurable: false,\n enumerable: true,\n\n get: function() {\n if (!this._store) {\n return null;\n }\n return this._store[key];\n },\n\n set: function(value) {\n (\"production\" !== process.env.NODE_ENV ? warning(\n false,\n 'Don\\'t set the %s property of the React element. Instead, ' +\n 'specify the correct value when initially creating the element.',\n key\n ) : null);\n this._store[key] = value;\n }\n\n });\n}\n\n/**\n * This is updated to true if the membrane is successfully created.\n */\nvar useMutationMembrane = false;\n\n/**\n * Warn for mutations.\n *\n * @internal\n * @param {object} element\n */\nfunction defineMutationMembrane(prototype) {\n try {\n var pseudoFrozenProperties = {\n props: true\n };\n for (var key in pseudoFrozenProperties) {\n defineWarningProperty(prototype, key);\n }\n useMutationMembrane = true;\n } catch (x) {\n // IE will fail on defineProperty\n }\n}\n\n/**\n * Base constructor for all React elements. This is only used to make this\n * work with a dynamic instanceof check. Nothing should live on this prototype.\n *\n * @param {*} type\n * @param {string|object} ref\n * @param {*} key\n * @param {*} props\n * @internal\n */\nvar ReactElement = function(type, key, ref, owner, context, props) {\n // Built-in properties that belong on the element\n this.type = type;\n this.key = key;\n this.ref = ref;\n\n // Record the component responsible for creating this element.\n this._owner = owner;\n\n // TODO: Deprecate withContext, and then the context becomes accessible\n // through the owner.\n this._context = context;\n\n if (\"production\" !== process.env.NODE_ENV) {\n // The validation flag and props are currently mutative. We put them on\n // an external backing store so that we can freeze the whole object.\n // This can be replaced with a WeakMap once they are implemented in\n // commonly used development environments.\n this._store = {props: props, originalProps: assign({}, props)};\n\n // To make comparing ReactElements easier for testing purposes, we make\n // the validation flag non-enumerable (where possible, which should\n // include every environment we run tests in), so the test framework\n // ignores it.\n try {\n Object.defineProperty(this._store, 'validated', {\n configurable: false,\n enumerable: false,\n writable: true\n });\n } catch (x) {\n }\n this._store.validated = false;\n\n // We're not allowed to set props directly on the object so we early\n // return and rely on the prototype membrane to forward to the backing\n // store.\n if (useMutationMembrane) {\n Object.freeze(this);\n return;\n }\n }\n\n this.props = props;\n};\n\n// We intentionally don't expose the function on the constructor property.\n// ReactElement should be indistinguishable from a plain object.\nReactElement.prototype = {\n _isReactElement: true\n};\n\nif (\"production\" !== process.env.NODE_ENV) {\n defineMutationMembrane(ReactElement.prototype);\n}\n\nReactElement.createElement = function(type, config, children) {\n var propName;\n\n // Reserved names are extracted\n var props = {};\n\n var key = null;\n var ref = null;\n\n if (config != null) {\n ref = config.ref === undefined ? null : config.ref;\n key = config.key === undefined ? null : '' + config.key;\n // Remaining properties are added to a new props object\n for (propName in config) {\n if (config.hasOwnProperty(propName) &&\n !RESERVED_PROPS.hasOwnProperty(propName)) {\n props[propName] = config[propName];\n }\n }\n }\n\n // Children can be more than one argument, and those are transferred onto\n // the newly allocated props object.\n var childrenLength = arguments.length - 2;\n if (childrenLength === 1) {\n props.children = children;\n } else if (childrenLength > 1) {\n var childArray = Array(childrenLength);\n for (var i = 0; i < childrenLength; i++) {\n childArray[i] = arguments[i + 2];\n }\n props.children = childArray;\n }\n\n // Resolve default props\n if (type && type.defaultProps) {\n var defaultProps = type.defaultProps;\n for (propName in defaultProps) {\n if (typeof props[propName] === 'undefined') {\n props[propName] = defaultProps[propName];\n }\n }\n }\n\n return new ReactElement(\n type,\n key,\n ref,\n ReactCurrentOwner.current,\n ReactContext.current,\n props\n );\n};\n\nReactElement.createFactory = function(type) {\n var factory = ReactElement.createElement.bind(null, type);\n // Expose the type on the factory and the prototype so that it can be\n // easily accessed on elements. E.g. .type === Foo.type.\n // This should not be named `constructor` since this may not be the function\n // that created the element, and it may not even be a constructor.\n // Legacy hook TODO: Warn if this is accessed\n factory.type = type;\n return factory;\n};\n\nReactElement.cloneAndReplaceProps = function(oldElement, newProps) {\n var newElement = new ReactElement(\n oldElement.type,\n oldElement.key,\n oldElement.ref,\n oldElement._owner,\n oldElement._context,\n newProps\n );\n\n if (\"production\" !== process.env.NODE_ENV) {\n // If the key on the original is valid, then the clone is valid\n newElement._store.validated = oldElement._store.validated;\n }\n return newElement;\n};\n\nReactElement.cloneElement = function(element, config, children) {\n var propName;\n\n // Original props are copied\n var props = assign({}, element.props);\n\n // Reserved names are extracted\n var key = element.key;\n var ref = element.ref;\n\n // Owner will be preserved, unless ref is overridden\n var owner = element._owner;\n\n if (config != null) {\n if (config.ref !== undefined) {\n // Silently steal the ref from the parent.\n ref = config.ref;\n owner = ReactCurrentOwner.current;\n }\n if (config.key !== undefined) {\n key = '' + config.key;\n }\n // Remaining properties override existing props\n for (propName in config) {\n if (config.hasOwnProperty(propName) &&\n !RESERVED_PROPS.hasOwnProperty(propName)) {\n props[propName] = config[propName];\n }\n }\n }\n\n // Children can be more than one argument, and those are transferred onto\n // the newly allocated props object.\n var childrenLength = arguments.length - 2;\n if (childrenLength === 1) {\n props.children = children;\n } else if (childrenLength > 1) {\n var childArray = Array(childrenLength);\n for (var i = 0; i < childrenLength; i++) {\n childArray[i] = arguments[i + 2];\n }\n props.children = childArray;\n }\n\n return new ReactElement(\n element.type,\n key,\n ref,\n owner,\n element._context,\n props\n );\n};\n\n/**\n * @param {?object} object\n * @return {boolean} True if `object` is a valid component.\n * @final\n */\nReactElement.isValidElement = function(object) {\n // ReactTestUtils is often used outside of beforeEach where as React is\n // within it. This leads to two different instances of React on the same\n // page. To identify a element from a different React instance we use\n // a flag instead of an instanceof check.\n var isElement = !!(object && object._isReactElement);\n // if (isElement && !(object instanceof ReactElement)) {\n // This is an indicator that you're using multiple versions of React at the\n // same time. This will screw with ownership and stuff. Fix it, please.\n // TODO: We could possibly warn here.\n // }\n return isElement;\n};\n\nmodule.exports = ReactElement;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactElement.js\n ** module id = 16\n ** module chunks = 0\n **/","/**\n * Copyright 2013-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule ReactContext\n */\n\n'use strict';\n\nvar assign = require(\"./Object.assign\");\nvar emptyObject = require(\"./emptyObject\");\nvar warning = require(\"./warning\");\n\nvar didWarn = false;\n\n/**\n * Keeps track of the current context.\n *\n * The context is automatically passed down the component ownership hierarchy\n * and is accessible via `this.context` on ReactCompositeComponents.\n */\nvar ReactContext = {\n\n /**\n * @internal\n * @type {object}\n */\n current: emptyObject,\n\n /**\n * Temporarily extends the current context while executing scopedCallback.\n *\n * A typical use case might look like\n *\n * render: function() {\n * var children = ReactContext.withContext({foo: 'foo'}, () => (\n *\n * ));\n * return
{children}
;\n * }\n *\n * @param {object} newContext New context to merge into the existing context\n * @param {function} scopedCallback Callback to run with the new context\n * @return {ReactComponent|array}\n */\n withContext: function(newContext, scopedCallback) {\n if (\"production\" !== process.env.NODE_ENV) {\n (\"production\" !== process.env.NODE_ENV ? warning(\n didWarn,\n 'withContext is deprecated and will be removed in a future version. ' +\n 'Use a wrapper component with getChildContext instead.'\n ) : null);\n\n didWarn = true;\n }\n\n var result;\n var previousContext = ReactContext.current;\n ReactContext.current = assign({}, previousContext, newContext);\n try {\n result = scopedCallback();\n } finally {\n ReactContext.current = previousContext;\n }\n return result;\n }\n\n};\n\nmodule.exports = ReactContext;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactContext.js\n ** module id = 17\n ** module chunks = 0\n **/","/**\n * Copyright 2014-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule Object.assign\n */\n\n// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-object.assign\n\n'use strict';\n\nfunction assign(target, sources) {\n if (target == null) {\n throw new TypeError('Object.assign target cannot be null or undefined');\n }\n\n var to = Object(target);\n var hasOwnProperty = Object.prototype.hasOwnProperty;\n\n for (var nextIndex = 1; nextIndex < arguments.length; nextIndex++) {\n var nextSource = arguments[nextIndex];\n if (nextSource == null) {\n continue;\n }\n\n var from = Object(nextSource);\n\n // We don't currently support accessors nor proxies. Therefore this\n // copy cannot throw. If we ever supported this then we must handle\n // exceptions and side-effects. We don't support symbols so they won't\n // be transferred.\n\n for (var key in from) {\n if (hasOwnProperty.call(from, key)) {\n to[key] = from[key];\n }\n }\n }\n\n return to;\n}\n\nmodule.exports = assign;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/Object.assign.js\n ** module id = 18\n ** module chunks = 0\n **/","/**\n * Copyright 2013-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule emptyObject\n */\n\n\"use strict\";\n\nvar emptyObject = {};\n\nif (\"production\" !== process.env.NODE_ENV) {\n Object.freeze(emptyObject);\n}\n\nmodule.exports = emptyObject;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/emptyObject.js\n ** module id = 19\n ** module chunks = 0\n **/","/**\n * Copyright 2014-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule warning\n */\n\n\"use strict\";\n\nvar emptyFunction = require(\"./emptyFunction\");\n\n/**\n * Similar to invariant but only logs a warning if the condition is not met.\n * This can be used to log issues in development environments in critical\n * paths. Removing the logging code for production environments will keep the\n * same logic and follow the same code paths.\n */\n\nvar warning = emptyFunction;\n\nif (\"production\" !== process.env.NODE_ENV) {\n warning = function(condition, format ) {for (var args=[],$__0=2,$__1=arguments.length;$__0<$__1;$__0++) args.push(arguments[$__0]);\n if (format === undefined) {\n throw new Error(\n '`warning(condition, format, ...args)` requires a warning ' +\n 'message argument'\n );\n }\n\n if (format.length < 10 || /^[s\\W]*$/.test(format)) {\n throw new Error(\n 'The warning format should be able to uniquely identify this ' +\n 'warning. Please, use a more descriptive format than: ' + format\n );\n }\n\n if (format.indexOf('Failed Composite propType: ') === 0) {\n return; // Ignore CompositeComponent proptype check.\n }\n\n if (!condition) {\n var argIndex = 0;\n var message = 'Warning: ' + format.replace(/%s/g, function() {return args[argIndex++];});\n console.warn(message);\n try {\n // --- Welcome to debugging React ---\n // This error was thrown as a convenience so that you can use this stack\n // to find the callsite that caused this warning to fire.\n throw new Error(message);\n } catch(x) {}\n }\n };\n}\n\nmodule.exports = warning;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/warning.js\n ** module id = 20\n ** module chunks = 0\n **/","/**\n * Copyright 2013-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule emptyFunction\n */\n\nfunction makeEmptyFunction(arg) {\n return function() {\n return arg;\n };\n}\n\n/**\n * This function accepts and discards inputs; it has no side effects. This is\n * primarily useful idiomatically for overridable function endpoints which\n * always need to be callable, since JS lacks a null-call idiom ala Cocoa.\n */\nfunction emptyFunction() {}\n\nemptyFunction.thatReturns = makeEmptyFunction;\nemptyFunction.thatReturnsFalse = makeEmptyFunction(false);\nemptyFunction.thatReturnsTrue = makeEmptyFunction(true);\nemptyFunction.thatReturnsNull = makeEmptyFunction(null);\nemptyFunction.thatReturnsThis = function() { return this; };\nemptyFunction.thatReturnsArgument = function(arg) { return arg; };\n\nmodule.exports = emptyFunction;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/emptyFunction.js\n ** module id = 21\n ** module chunks = 0\n **/","/**\n * Copyright 2013-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule ReactCurrentOwner\n */\n\n'use strict';\n\n/**\n * Keeps track of the current owner.\n *\n * The current owner is the component who should own any components that are\n * currently being constructed.\n *\n * The depth indicate how many composite components are above this render level.\n */\nvar ReactCurrentOwner = {\n\n /**\n * @internal\n * @type {ReactComponent}\n */\n current: null\n\n};\n\nmodule.exports = ReactCurrentOwner;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactCurrentOwner.js\n ** module id = 22\n ** module chunks = 0\n **/","/**\n * Copyright 2013-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule traverseAllChildren\n */\n\n'use strict';\n\nvar ReactElement = require(\"./ReactElement\");\nvar ReactFragment = require(\"./ReactFragment\");\nvar ReactInstanceHandles = require(\"./ReactInstanceHandles\");\n\nvar getIteratorFn = require(\"./getIteratorFn\");\nvar invariant = require(\"./invariant\");\nvar warning = require(\"./warning\");\n\nvar SEPARATOR = ReactInstanceHandles.SEPARATOR;\nvar SUBSEPARATOR = ':';\n\n/**\n * TODO: Test that a single child and an array with one item have the same key\n * pattern.\n */\n\nvar userProvidedKeyEscaperLookup = {\n '=': '=0',\n '.': '=1',\n ':': '=2'\n};\n\nvar userProvidedKeyEscapeRegex = /[=.:]/g;\n\nvar didWarnAboutMaps = false;\n\nfunction userProvidedKeyEscaper(match) {\n return userProvidedKeyEscaperLookup[match];\n}\n\n/**\n * Generate a key string that identifies a component within a set.\n *\n * @param {*} component A component that could contain a manual key.\n * @param {number} index Index that is used if a manual key is not provided.\n * @return {string}\n */\nfunction getComponentKey(component, index) {\n if (component && component.key != null) {\n // Explicit key\n return wrapUserProvidedKey(component.key);\n }\n // Implicit key determined by the index in the set\n return index.toString(36);\n}\n\n/**\n * Escape a component key so that it is safe to use in a reactid.\n *\n * @param {*} key Component key to be escaped.\n * @return {string} An escaped string.\n */\nfunction escapeUserProvidedKey(text) {\n return ('' + text).replace(\n userProvidedKeyEscapeRegex,\n userProvidedKeyEscaper\n );\n}\n\n/**\n * Wrap a `key` value explicitly provided by the user to distinguish it from\n * implicitly-generated keys generated by a component's index in its parent.\n *\n * @param {string} key Value of a user-provided `key` attribute\n * @return {string}\n */\nfunction wrapUserProvidedKey(key) {\n return '$' + escapeUserProvidedKey(key);\n}\n\n/**\n * @param {?*} children Children tree container.\n * @param {!string} nameSoFar Name of the key path so far.\n * @param {!number} indexSoFar Number of children encountered until this point.\n * @param {!function} callback Callback to invoke with each child found.\n * @param {?*} traverseContext Used to pass information throughout the traversal\n * process.\n * @return {!number} The number of children in this subtree.\n */\nfunction traverseAllChildrenImpl(\n children,\n nameSoFar,\n indexSoFar,\n callback,\n traverseContext\n) {\n var type = typeof children;\n\n if (type === 'undefined' || type === 'boolean') {\n // All of the above are perceived as null.\n children = null;\n }\n\n if (children === null ||\n type === 'string' ||\n type === 'number' ||\n ReactElement.isValidElement(children)) {\n callback(\n traverseContext,\n children,\n // If it's the only child, treat the name as if it was wrapped in an array\n // so that it's consistent if the number of children grows.\n nameSoFar === '' ? SEPARATOR + getComponentKey(children, 0) : nameSoFar,\n indexSoFar\n );\n return 1;\n }\n\n var child, nextName, nextIndex;\n var subtreeCount = 0; // Count of children found in the current subtree.\n\n if (Array.isArray(children)) {\n for (var i = 0; i < children.length; i++) {\n child = children[i];\n nextName = (\n (nameSoFar !== '' ? nameSoFar + SUBSEPARATOR : SEPARATOR) +\n getComponentKey(child, i)\n );\n nextIndex = indexSoFar + subtreeCount;\n subtreeCount += traverseAllChildrenImpl(\n child,\n nextName,\n nextIndex,\n callback,\n traverseContext\n );\n }\n } else {\n var iteratorFn = getIteratorFn(children);\n if (iteratorFn) {\n var iterator = iteratorFn.call(children);\n var step;\n if (iteratorFn !== children.entries) {\n var ii = 0;\n while (!(step = iterator.next()).done) {\n child = step.value;\n nextName = (\n (nameSoFar !== '' ? nameSoFar + SUBSEPARATOR : SEPARATOR) +\n getComponentKey(child, ii++)\n );\n nextIndex = indexSoFar + subtreeCount;\n subtreeCount += traverseAllChildrenImpl(\n child,\n nextName,\n nextIndex,\n callback,\n traverseContext\n );\n }\n } else {\n if (\"production\" !== process.env.NODE_ENV) {\n (\"production\" !== process.env.NODE_ENV ? warning(\n didWarnAboutMaps,\n 'Using Maps as children is not yet fully supported. It is an ' +\n 'experimental feature that might be removed. Convert it to a ' +\n 'sequence / iterable of keyed ReactElements instead.'\n ) : null);\n didWarnAboutMaps = true;\n }\n // Iterator will provide entry [k,v] tuples rather than values.\n while (!(step = iterator.next()).done) {\n var entry = step.value;\n if (entry) {\n child = entry[1];\n nextName = (\n (nameSoFar !== '' ? nameSoFar + SUBSEPARATOR : SEPARATOR) +\n wrapUserProvidedKey(entry[0]) + SUBSEPARATOR +\n getComponentKey(child, 0)\n );\n nextIndex = indexSoFar + subtreeCount;\n subtreeCount += traverseAllChildrenImpl(\n child,\n nextName,\n nextIndex,\n callback,\n traverseContext\n );\n }\n }\n }\n } else if (type === 'object') {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n children.nodeType !== 1,\n 'traverseAllChildren(...): Encountered an invalid child; DOM ' +\n 'elements are not valid children of React components.'\n ) : invariant(children.nodeType !== 1));\n var fragment = ReactFragment.extract(children);\n for (var key in fragment) {\n if (fragment.hasOwnProperty(key)) {\n child = fragment[key];\n nextName = (\n (nameSoFar !== '' ? nameSoFar + SUBSEPARATOR : SEPARATOR) +\n wrapUserProvidedKey(key) + SUBSEPARATOR +\n getComponentKey(child, 0)\n );\n nextIndex = indexSoFar + subtreeCount;\n subtreeCount += traverseAllChildrenImpl(\n child,\n nextName,\n nextIndex,\n callback,\n traverseContext\n );\n }\n }\n }\n }\n\n return subtreeCount;\n}\n\n/**\n * Traverses children that are typically specified as `props.children`, but\n * might also be specified through attributes:\n *\n * - `traverseAllChildren(this.props.children, ...)`\n * - `traverseAllChildren(this.props.leftPanelChildren, ...)`\n *\n * The `traverseContext` is an optional argument that is passed through the\n * entire traversal. It can be used to store accumulations or anything else that\n * the callback might find relevant.\n *\n * @param {?*} children Children tree object.\n * @param {!function} callback To invoke upon traversing each child.\n * @param {?*} traverseContext Context for traversal.\n * @return {!number} The number of children in this subtree.\n */\nfunction traverseAllChildren(children, callback, traverseContext) {\n if (children == null) {\n return 0;\n }\n\n return traverseAllChildrenImpl(children, '', 0, callback, traverseContext);\n}\n\nmodule.exports = traverseAllChildren;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/traverseAllChildren.js\n ** module id = 23\n ** module chunks = 0\n **/","/**\n * Copyright 2013-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule ReactInstanceHandles\n * @typechecks static-only\n */\n\n'use strict';\n\nvar ReactRootIndex = require(\"./ReactRootIndex\");\n\nvar invariant = require(\"./invariant\");\n\nvar SEPARATOR = '.';\nvar SEPARATOR_LENGTH = SEPARATOR.length;\n\n/**\n * Maximum depth of traversals before we consider the possibility of a bad ID.\n */\nvar MAX_TREE_DEPTH = 100;\n\n/**\n * Creates a DOM ID prefix to use when mounting React components.\n *\n * @param {number} index A unique integer\n * @return {string} React root ID.\n * @internal\n */\nfunction getReactRootIDString(index) {\n return SEPARATOR + index.toString(36);\n}\n\n/**\n * Checks if a character in the supplied ID is a separator or the end.\n *\n * @param {string} id A React DOM ID.\n * @param {number} index Index of the character to check.\n * @return {boolean} True if the character is a separator or end of the ID.\n * @private\n */\nfunction isBoundary(id, index) {\n return id.charAt(index) === SEPARATOR || index === id.length;\n}\n\n/**\n * Checks if the supplied string is a valid React DOM ID.\n *\n * @param {string} id A React DOM ID, maybe.\n * @return {boolean} True if the string is a valid React DOM ID.\n * @private\n */\nfunction isValidID(id) {\n return id === '' || (\n id.charAt(0) === SEPARATOR && id.charAt(id.length - 1) !== SEPARATOR\n );\n}\n\n/**\n * Checks if the first ID is an ancestor of or equal to the second ID.\n *\n * @param {string} ancestorID\n * @param {string} descendantID\n * @return {boolean} True if `ancestorID` is an ancestor of `descendantID`.\n * @internal\n */\nfunction isAncestorIDOf(ancestorID, descendantID) {\n return (\n descendantID.indexOf(ancestorID) === 0 &&\n isBoundary(descendantID, ancestorID.length)\n );\n}\n\n/**\n * Gets the parent ID of the supplied React DOM ID, `id`.\n *\n * @param {string} id ID of a component.\n * @return {string} ID of the parent, or an empty string.\n * @private\n */\nfunction getParentID(id) {\n return id ? id.substr(0, id.lastIndexOf(SEPARATOR)) : '';\n}\n\n/**\n * Gets the next DOM ID on the tree path from the supplied `ancestorID` to the\n * supplied `destinationID`. If they are equal, the ID is returned.\n *\n * @param {string} ancestorID ID of an ancestor node of `destinationID`.\n * @param {string} destinationID ID of the destination node.\n * @return {string} Next ID on the path from `ancestorID` to `destinationID`.\n * @private\n */\nfunction getNextDescendantID(ancestorID, destinationID) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n isValidID(ancestorID) && isValidID(destinationID),\n 'getNextDescendantID(%s, %s): Received an invalid React DOM ID.',\n ancestorID,\n destinationID\n ) : invariant(isValidID(ancestorID) && isValidID(destinationID)));\n (\"production\" !== process.env.NODE_ENV ? invariant(\n isAncestorIDOf(ancestorID, destinationID),\n 'getNextDescendantID(...): React has made an invalid assumption about ' +\n 'the DOM hierarchy. Expected `%s` to be an ancestor of `%s`.',\n ancestorID,\n destinationID\n ) : invariant(isAncestorIDOf(ancestorID, destinationID)));\n if (ancestorID === destinationID) {\n return ancestorID;\n }\n // Skip over the ancestor and the immediate separator. Traverse until we hit\n // another separator or we reach the end of `destinationID`.\n var start = ancestorID.length + SEPARATOR_LENGTH;\n var i;\n for (i = start; i < destinationID.length; i++) {\n if (isBoundary(destinationID, i)) {\n break;\n }\n }\n return destinationID.substr(0, i);\n}\n\n/**\n * Gets the nearest common ancestor ID of two IDs.\n *\n * Using this ID scheme, the nearest common ancestor ID is the longest common\n * prefix of the two IDs that immediately preceded a \"marker\" in both strings.\n *\n * @param {string} oneID\n * @param {string} twoID\n * @return {string} Nearest common ancestor ID, or the empty string if none.\n * @private\n */\nfunction getFirstCommonAncestorID(oneID, twoID) {\n var minLength = Math.min(oneID.length, twoID.length);\n if (minLength === 0) {\n return '';\n }\n var lastCommonMarkerIndex = 0;\n // Use `<=` to traverse until the \"EOL\" of the shorter string.\n for (var i = 0; i <= minLength; i++) {\n if (isBoundary(oneID, i) && isBoundary(twoID, i)) {\n lastCommonMarkerIndex = i;\n } else if (oneID.charAt(i) !== twoID.charAt(i)) {\n break;\n }\n }\n var longestCommonID = oneID.substr(0, lastCommonMarkerIndex);\n (\"production\" !== process.env.NODE_ENV ? invariant(\n isValidID(longestCommonID),\n 'getFirstCommonAncestorID(%s, %s): Expected a valid React DOM ID: %s',\n oneID,\n twoID,\n longestCommonID\n ) : invariant(isValidID(longestCommonID)));\n return longestCommonID;\n}\n\n/**\n * Traverses the parent path between two IDs (either up or down). The IDs must\n * not be the same, and there must exist a parent path between them. If the\n * callback returns `false`, traversal is stopped.\n *\n * @param {?string} start ID at which to start traversal.\n * @param {?string} stop ID at which to end traversal.\n * @param {function} cb Callback to invoke each ID with.\n * @param {?boolean} skipFirst Whether or not to skip the first node.\n * @param {?boolean} skipLast Whether or not to skip the last node.\n * @private\n */\nfunction traverseParentPath(start, stop, cb, arg, skipFirst, skipLast) {\n start = start || '';\n stop = stop || '';\n (\"production\" !== process.env.NODE_ENV ? invariant(\n start !== stop,\n 'traverseParentPath(...): Cannot traverse from and to the same ID, `%s`.',\n start\n ) : invariant(start !== stop));\n var traverseUp = isAncestorIDOf(stop, start);\n (\"production\" !== process.env.NODE_ENV ? invariant(\n traverseUp || isAncestorIDOf(start, stop),\n 'traverseParentPath(%s, %s, ...): Cannot traverse from two IDs that do ' +\n 'not have a parent path.',\n start,\n stop\n ) : invariant(traverseUp || isAncestorIDOf(start, stop)));\n // Traverse from `start` to `stop` one depth at a time.\n var depth = 0;\n var traverse = traverseUp ? getParentID : getNextDescendantID;\n for (var id = start; /* until break */; id = traverse(id, stop)) {\n var ret;\n if ((!skipFirst || id !== start) && (!skipLast || id !== stop)) {\n ret = cb(id, traverseUp, arg);\n }\n if (ret === false || id === stop) {\n // Only break //after// visiting `stop`.\n break;\n }\n (\"production\" !== process.env.NODE_ENV ? invariant(\n depth++ < MAX_TREE_DEPTH,\n 'traverseParentPath(%s, %s, ...): Detected an infinite loop while ' +\n 'traversing the React DOM ID tree. This may be due to malformed IDs: %s',\n start, stop\n ) : invariant(depth++ < MAX_TREE_DEPTH));\n }\n}\n\n/**\n * Manages the IDs assigned to DOM representations of React components. This\n * uses a specific scheme in order to traverse the DOM efficiently (e.g. in\n * order to simulate events).\n *\n * @internal\n */\nvar ReactInstanceHandles = {\n\n /**\n * Constructs a React root ID\n * @return {string} A React root ID.\n */\n createReactRootID: function() {\n return getReactRootIDString(ReactRootIndex.createReactRootIndex());\n },\n\n /**\n * Constructs a React ID by joining a root ID with a name.\n *\n * @param {string} rootID Root ID of a parent component.\n * @param {string} name A component's name (as flattened children).\n * @return {string} A React ID.\n * @internal\n */\n createReactID: function(rootID, name) {\n return rootID + name;\n },\n\n /**\n * Gets the DOM ID of the React component that is the root of the tree that\n * contains the React component with the supplied DOM ID.\n *\n * @param {string} id DOM ID of a React component.\n * @return {?string} DOM ID of the React component that is the root.\n * @internal\n */\n getReactRootIDFromNodeID: function(id) {\n if (id && id.charAt(0) === SEPARATOR && id.length > 1) {\n var index = id.indexOf(SEPARATOR, 1);\n return index > -1 ? id.substr(0, index) : id;\n }\n return null;\n },\n\n /**\n * Traverses the ID hierarchy and invokes the supplied `cb` on any IDs that\n * should would receive a `mouseEnter` or `mouseLeave` event.\n *\n * NOTE: Does not invoke the callback on the nearest common ancestor because\n * nothing \"entered\" or \"left\" that element.\n *\n * @param {string} leaveID ID being left.\n * @param {string} enterID ID being entered.\n * @param {function} cb Callback to invoke on each entered/left ID.\n * @param {*} upArg Argument to invoke the callback with on left IDs.\n * @param {*} downArg Argument to invoke the callback with on entered IDs.\n * @internal\n */\n traverseEnterLeave: function(leaveID, enterID, cb, upArg, downArg) {\n var ancestorID = getFirstCommonAncestorID(leaveID, enterID);\n if (ancestorID !== leaveID) {\n traverseParentPath(leaveID, ancestorID, cb, upArg, false, true);\n }\n if (ancestorID !== enterID) {\n traverseParentPath(ancestorID, enterID, cb, downArg, true, false);\n }\n },\n\n /**\n * Simulates the traversal of a two-phase, capture/bubble event dispatch.\n *\n * NOTE: This traversal happens on IDs without touching the DOM.\n *\n * @param {string} targetID ID of the target node.\n * @param {function} cb Callback to invoke.\n * @param {*} arg Argument to invoke the callback with.\n * @internal\n */\n traverseTwoPhase: function(targetID, cb, arg) {\n if (targetID) {\n traverseParentPath('', targetID, cb, arg, true, false);\n traverseParentPath(targetID, '', cb, arg, false, true);\n }\n },\n\n /**\n * Traverse a node ID, calling the supplied `cb` for each ancestor ID. For\n * example, passing `.0.$row-0.1` would result in `cb` getting called\n * with `.0`, `.0.$row-0`, and `.0.$row-0.1`.\n *\n * NOTE: This traversal happens on IDs without touching the DOM.\n *\n * @param {string} targetID ID of the target node.\n * @param {function} cb Callback to invoke.\n * @param {*} arg Argument to invoke the callback with.\n * @internal\n */\n traverseAncestors: function(targetID, cb, arg) {\n traverseParentPath('', targetID, cb, arg, true, false);\n },\n\n /**\n * Exposed for unit testing.\n * @private\n */\n _getFirstCommonAncestorID: getFirstCommonAncestorID,\n\n /**\n * Exposed for unit testing.\n * @private\n */\n _getNextDescendantID: getNextDescendantID,\n\n isAncestorIDOf: isAncestorIDOf,\n\n SEPARATOR: SEPARATOR\n\n};\n\nmodule.exports = ReactInstanceHandles;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactInstanceHandles.js\n ** module id = 24\n ** module chunks = 0\n **/","/**\n * Copyright 2013-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule ReactRootIndex\n * @typechecks\n */\n\n'use strict';\n\nvar ReactRootIndexInjection = {\n /**\n * @param {function} _createReactRootIndex\n */\n injectCreateReactRootIndex: function(_createReactRootIndex) {\n ReactRootIndex.createReactRootIndex = _createReactRootIndex;\n }\n};\n\nvar ReactRootIndex = {\n createReactRootIndex: null,\n injection: ReactRootIndexInjection\n};\n\nmodule.exports = ReactRootIndex;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactRootIndex.js\n ** module id = 25\n ** module chunks = 0\n **/","/**\n * Copyright 2013-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule getIteratorFn\n * @typechecks static-only\n */\n\n'use strict';\n\n/* global Symbol */\nvar ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;\nvar FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.\n\n/**\n * Returns the iterator method function contained on the iterable object.\n *\n * Be sure to invoke the function with the iterable as context:\n *\n * var iteratorFn = getIteratorFn(myIterable);\n * if (iteratorFn) {\n * var iterator = iteratorFn.call(myIterable);\n * ...\n * }\n *\n * @param {?object} maybeIterable\n * @return {?function}\n */\nfunction getIteratorFn(maybeIterable) {\n var iteratorFn = maybeIterable && (\n (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL])\n );\n if (typeof iteratorFn === 'function') {\n return iteratorFn;\n }\n}\n\nmodule.exports = getIteratorFn;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/getIteratorFn.js\n ** module id = 26\n ** module chunks = 0\n **/","/**\n * Copyright 2013-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule ReactComponent\n */\n\n'use strict';\n\nvar ReactUpdateQueue = require(\"./ReactUpdateQueue\");\n\nvar invariant = require(\"./invariant\");\nvar warning = require(\"./warning\");\n\n/**\n * Base class helpers for the updating state of a component.\n */\nfunction ReactComponent(props, context) {\n this.props = props;\n this.context = context;\n}\n\n/**\n * Sets a subset of the state. Always use this to mutate\n * state. You should treat `this.state` as immutable.\n *\n * There is no guarantee that `this.state` will be immediately updated, so\n * accessing `this.state` after calling this method may return the old value.\n *\n * There is no guarantee that calls to `setState` will run synchronously,\n * as they may eventually be batched together. You can provide an optional\n * callback that will be executed when the call to setState is actually\n * completed.\n *\n * When a function is provided to setState, it will be called at some point in\n * the future (not synchronously). It will be called with the up to date\n * component arguments (state, props, context). These values can be different\n * from this.* because your function may be called after receiveProps but before\n * shouldComponentUpdate, and this new state, props, and context will not yet be\n * assigned to this.\n *\n * @param {object|function} partialState Next partial state or function to\n * produce next partial state to be merged with current state.\n * @param {?function} callback Called after state is updated.\n * @final\n * @protected\n */\nReactComponent.prototype.setState = function(partialState, callback) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n typeof partialState === 'object' ||\n typeof partialState === 'function' ||\n partialState == null,\n 'setState(...): takes an object of state variables to update or a ' +\n 'function which returns an object of state variables.'\n ) : invariant(typeof partialState === 'object' ||\n typeof partialState === 'function' ||\n partialState == null));\n if (\"production\" !== process.env.NODE_ENV) {\n (\"production\" !== process.env.NODE_ENV ? warning(\n partialState != null,\n 'setState(...): You passed an undefined or null state object; ' +\n 'instead, use forceUpdate().'\n ) : null);\n }\n ReactUpdateQueue.enqueueSetState(this, partialState);\n if (callback) {\n ReactUpdateQueue.enqueueCallback(this, callback);\n }\n};\n\n/**\n * Forces an update. This should only be invoked when it is known with\n * certainty that we are **not** in a DOM transaction.\n *\n * You may want to call this when you know that some deeper aspect of the\n * component's state has changed but `setState` was not called.\n *\n * This will not invoke `shouldComponentUpdate`, but it will invoke\n * `componentWillUpdate` and `componentDidUpdate`.\n *\n * @param {?function} callback Called after update is complete.\n * @final\n * @protected\n */\nReactComponent.prototype.forceUpdate = function(callback) {\n ReactUpdateQueue.enqueueForceUpdate(this);\n if (callback) {\n ReactUpdateQueue.enqueueCallback(this, callback);\n }\n};\n\n/**\n * Deprecated APIs. These APIs used to exist on classic React classes but since\n * we would like to deprecate them, we're not going to move them over to this\n * modern base class. Instead, we define a getter that warns if it's accessed.\n */\nif (\"production\" !== process.env.NODE_ENV) {\n var deprecatedAPIs = {\n getDOMNode: [\n 'getDOMNode',\n 'Use React.findDOMNode(component) instead.'\n ],\n isMounted: [\n 'isMounted',\n 'Instead, make sure to clean up subscriptions and pending requests in ' +\n 'componentWillUnmount to prevent memory leaks.'\n ],\n replaceProps: [\n 'replaceProps',\n 'Instead, call React.render again at the top level.'\n ],\n replaceState: [\n 'replaceState',\n 'Refactor your code to use setState instead (see ' +\n 'https://github.com/facebook/react/issues/3236).'\n ],\n setProps: [\n 'setProps',\n 'Instead, call React.render again at the top level.'\n ]\n };\n var defineDeprecationWarning = function(methodName, info) {\n try {\n Object.defineProperty(ReactComponent.prototype, methodName, {\n get: function() {\n (\"production\" !== process.env.NODE_ENV ? warning(\n false,\n '%s(...) is deprecated in plain JavaScript React classes. %s',\n info[0],\n info[1]\n ) : null);\n return undefined;\n }\n });\n } catch (x) {\n // IE will fail on defineProperty (es5-shim/sham too)\n }\n };\n for (var fnName in deprecatedAPIs) {\n if (deprecatedAPIs.hasOwnProperty(fnName)) {\n defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);\n }\n }\n}\n\nmodule.exports = ReactComponent;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactComponent.js\n ** module id = 27\n ** module chunks = 0\n **/","/**\n * Copyright 2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule ReactUpdateQueue\n */\n\n'use strict';\n\nvar ReactLifeCycle = require(\"./ReactLifeCycle\");\nvar ReactCurrentOwner = require(\"./ReactCurrentOwner\");\nvar ReactElement = require(\"./ReactElement\");\nvar ReactInstanceMap = require(\"./ReactInstanceMap\");\nvar ReactUpdates = require(\"./ReactUpdates\");\n\nvar assign = require(\"./Object.assign\");\nvar invariant = require(\"./invariant\");\nvar warning = require(\"./warning\");\n\nfunction enqueueUpdate(internalInstance) {\n if (internalInstance !== ReactLifeCycle.currentlyMountingInstance) {\n // If we're in a componentWillMount handler, don't enqueue a rerender\n // because ReactUpdates assumes we're in a browser context (which is\n // wrong for server rendering) and we're about to do a render anyway.\n // See bug in #1740.\n ReactUpdates.enqueueUpdate(internalInstance);\n }\n}\n\nfunction getInternalInstanceReadyForUpdate(publicInstance, callerName) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n ReactCurrentOwner.current == null,\n '%s(...): Cannot update during an existing state transition ' +\n '(such as within `render`). Render methods should be a pure function ' +\n 'of props and state.',\n callerName\n ) : invariant(ReactCurrentOwner.current == null));\n\n var internalInstance = ReactInstanceMap.get(publicInstance);\n if (!internalInstance) {\n if (\"production\" !== process.env.NODE_ENV) {\n // Only warn when we have a callerName. Otherwise we should be silent.\n // We're probably calling from enqueueCallback. We don't want to warn\n // there because we already warned for the corresponding lifecycle method.\n (\"production\" !== process.env.NODE_ENV ? warning(\n !callerName,\n '%s(...): Can only update a mounted or mounting component. ' +\n 'This usually means you called %s() on an unmounted ' +\n 'component. This is a no-op.',\n callerName,\n callerName\n ) : null);\n }\n return null;\n }\n\n if (internalInstance === ReactLifeCycle.currentlyUnmountingInstance) {\n return null;\n }\n\n return internalInstance;\n}\n\n/**\n * ReactUpdateQueue allows for state updates to be scheduled into a later\n * reconciliation step.\n */\nvar ReactUpdateQueue = {\n\n /**\n * Enqueue a callback that will be executed after all the pending updates\n * have processed.\n *\n * @param {ReactClass} publicInstance The instance to use as `this` context.\n * @param {?function} callback Called after state is updated.\n * @internal\n */\n enqueueCallback: function(publicInstance, callback) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n typeof callback === 'function',\n 'enqueueCallback(...): You called `setProps`, `replaceProps`, ' +\n '`setState`, `replaceState`, or `forceUpdate` with a callback that ' +\n 'isn\\'t callable.'\n ) : invariant(typeof callback === 'function'));\n var internalInstance = getInternalInstanceReadyForUpdate(publicInstance);\n\n // Previously we would throw an error if we didn't have an internal\n // instance. Since we want to make it a no-op instead, we mirror the same\n // behavior we have in other enqueue* methods.\n // We also need to ignore callbacks in componentWillMount. See\n // enqueueUpdates.\n if (!internalInstance ||\n internalInstance === ReactLifeCycle.currentlyMountingInstance) {\n return null;\n }\n\n if (internalInstance._pendingCallbacks) {\n internalInstance._pendingCallbacks.push(callback);\n } else {\n internalInstance._pendingCallbacks = [callback];\n }\n // TODO: The callback here is ignored when setState is called from\n // componentWillMount. Either fix it or disallow doing so completely in\n // favor of getInitialState. Alternatively, we can disallow\n // componentWillMount during server-side rendering.\n enqueueUpdate(internalInstance);\n },\n\n enqueueCallbackInternal: function(internalInstance, callback) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n typeof callback === 'function',\n 'enqueueCallback(...): You called `setProps`, `replaceProps`, ' +\n '`setState`, `replaceState`, or `forceUpdate` with a callback that ' +\n 'isn\\'t callable.'\n ) : invariant(typeof callback === 'function'));\n if (internalInstance._pendingCallbacks) {\n internalInstance._pendingCallbacks.push(callback);\n } else {\n internalInstance._pendingCallbacks = [callback];\n }\n enqueueUpdate(internalInstance);\n },\n\n /**\n * Forces an update. This should only be invoked when it is known with\n * certainty that we are **not** in a DOM transaction.\n *\n * You may want to call this when you know that some deeper aspect of the\n * component's state has changed but `setState` was not called.\n *\n * This will not invoke `shouldUpdateComponent`, but it will invoke\n * `componentWillUpdate` and `componentDidUpdate`.\n *\n * @param {ReactClass} publicInstance The instance that should rerender.\n * @internal\n */\n enqueueForceUpdate: function(publicInstance) {\n var internalInstance = getInternalInstanceReadyForUpdate(\n publicInstance,\n 'forceUpdate'\n );\n\n if (!internalInstance) {\n return;\n }\n\n internalInstance._pendingForceUpdate = true;\n\n enqueueUpdate(internalInstance);\n },\n\n /**\n * Replaces all of the state. Always use this or `setState` to mutate state.\n * You should treat `this.state` as immutable.\n *\n * There is no guarantee that `this.state` will be immediately updated, so\n * accessing `this.state` after calling this method may return the old value.\n *\n * @param {ReactClass} publicInstance The instance that should rerender.\n * @param {object} completeState Next state.\n * @internal\n */\n enqueueReplaceState: function(publicInstance, completeState) {\n var internalInstance = getInternalInstanceReadyForUpdate(\n publicInstance,\n 'replaceState'\n );\n\n if (!internalInstance) {\n return;\n }\n\n internalInstance._pendingStateQueue = [completeState];\n internalInstance._pendingReplaceState = true;\n\n enqueueUpdate(internalInstance);\n },\n\n /**\n * Sets a subset of the state. This only exists because _pendingState is\n * internal. This provides a merging strategy that is not available to deep\n * properties which is confusing. TODO: Expose pendingState or don't use it\n * during the merge.\n *\n * @param {ReactClass} publicInstance The instance that should rerender.\n * @param {object} partialState Next partial state to be merged with state.\n * @internal\n */\n enqueueSetState: function(publicInstance, partialState) {\n var internalInstance = getInternalInstanceReadyForUpdate(\n publicInstance,\n 'setState'\n );\n\n if (!internalInstance) {\n return;\n }\n\n var queue =\n internalInstance._pendingStateQueue ||\n (internalInstance._pendingStateQueue = []);\n queue.push(partialState);\n\n enqueueUpdate(internalInstance);\n },\n\n /**\n * Sets a subset of the props.\n *\n * @param {ReactClass} publicInstance The instance that should rerender.\n * @param {object} partialProps Subset of the next props.\n * @internal\n */\n enqueueSetProps: function(publicInstance, partialProps) {\n var internalInstance = getInternalInstanceReadyForUpdate(\n publicInstance,\n 'setProps'\n );\n\n if (!internalInstance) {\n return;\n }\n\n (\"production\" !== process.env.NODE_ENV ? invariant(\n internalInstance._isTopLevel,\n 'setProps(...): You called `setProps` on a ' +\n 'component with a parent. This is an anti-pattern since props will ' +\n 'get reactively updated when rendered. Instead, change the owner\\'s ' +\n '`render` method to pass the correct value as props to the component ' +\n 'where it is created.'\n ) : invariant(internalInstance._isTopLevel));\n\n // Merge with the pending element if it exists, otherwise with existing\n // element props.\n var element = internalInstance._pendingElement ||\n internalInstance._currentElement;\n var props = assign({}, element.props, partialProps);\n internalInstance._pendingElement = ReactElement.cloneAndReplaceProps(\n element,\n props\n );\n\n enqueueUpdate(internalInstance);\n },\n\n /**\n * Replaces all of the props.\n *\n * @param {ReactClass} publicInstance The instance that should rerender.\n * @param {object} props New props.\n * @internal\n */\n enqueueReplaceProps: function(publicInstance, props) {\n var internalInstance = getInternalInstanceReadyForUpdate(\n publicInstance,\n 'replaceProps'\n );\n\n if (!internalInstance) {\n return;\n }\n\n (\"production\" !== process.env.NODE_ENV ? invariant(\n internalInstance._isTopLevel,\n 'replaceProps(...): You called `replaceProps` on a ' +\n 'component with a parent. This is an anti-pattern since props will ' +\n 'get reactively updated when rendered. Instead, change the owner\\'s ' +\n '`render` method to pass the correct value as props to the component ' +\n 'where it is created.'\n ) : invariant(internalInstance._isTopLevel));\n\n // Merge with the pending element if it exists, otherwise with existing\n // element props.\n var element = internalInstance._pendingElement ||\n internalInstance._currentElement;\n internalInstance._pendingElement = ReactElement.cloneAndReplaceProps(\n element,\n props\n );\n\n enqueueUpdate(internalInstance);\n },\n\n enqueueElementInternal: function(internalInstance, newElement) {\n internalInstance._pendingElement = newElement;\n enqueueUpdate(internalInstance);\n }\n\n};\n\nmodule.exports = ReactUpdateQueue;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactUpdateQueue.js\n ** module id = 28\n ** module chunks = 0\n **/","/**\n * Copyright 2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule ReactLifeCycle\n */\n\n'use strict';\n\n/**\n * This module manages the bookkeeping when a component is in the process\n * of being mounted or being unmounted. This is used as a way to enforce\n * invariants (or warnings) when it is not recommended to call\n * setState/forceUpdate.\n *\n * currentlyMountingInstance: During the construction phase, it is not possible\n * to trigger an update since the instance is not fully mounted yet. However, we\n * currently allow this as a convenience for mutating the initial state.\n *\n * currentlyUnmountingInstance: During the unmounting phase, the instance is\n * still mounted and can therefore schedule an update. However, this is not\n * recommended and probably an error since it's about to be unmounted.\n * Therefore we still want to trigger in an error for that case.\n */\n\nvar ReactLifeCycle = {\n currentlyMountingInstance: null,\n currentlyUnmountingInstance: null\n};\n\nmodule.exports = ReactLifeCycle;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactLifeCycle.js\n ** module id = 29\n ** module chunks = 0\n **/","/**\n * Copyright 2013-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule ReactInstanceMap\n */\n\n'use strict';\n\n/**\n * `ReactInstanceMap` maintains a mapping from a public facing stateful\n * instance (key) and the internal representation (value). This allows public\n * methods to accept the user facing instance as an argument and map them back\n * to internal methods.\n */\n\n// TODO: Replace this with ES6: var ReactInstanceMap = new Map();\nvar ReactInstanceMap = {\n\n /**\n * This API should be called `delete` but we'd have to make sure to always\n * transform these to strings for IE support. When this transform is fully\n * supported we can rename it.\n */\n remove: function(key) {\n key._reactInternalInstance = undefined;\n },\n\n get: function(key) {\n return key._reactInternalInstance;\n },\n\n has: function(key) {\n return key._reactInternalInstance !== undefined;\n },\n\n set: function(key, value) {\n key._reactInternalInstance = value;\n }\n\n};\n\nmodule.exports = ReactInstanceMap;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactInstanceMap.js\n ** module id = 30\n ** module chunks = 0\n **/","/**\n * Copyright 2013-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule ReactUpdates\n */\n\n'use strict';\n\nvar CallbackQueue = require(\"./CallbackQueue\");\nvar PooledClass = require(\"./PooledClass\");\nvar ReactCurrentOwner = require(\"./ReactCurrentOwner\");\nvar ReactPerf = require(\"./ReactPerf\");\nvar ReactReconciler = require(\"./ReactReconciler\");\nvar Transaction = require(\"./Transaction\");\n\nvar assign = require(\"./Object.assign\");\nvar invariant = require(\"./invariant\");\nvar warning = require(\"./warning\");\n\nvar dirtyComponents = [];\nvar asapCallbackQueue = CallbackQueue.getPooled();\nvar asapEnqueued = false;\n\nvar batchingStrategy = null;\n\nfunction ensureInjected() {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n ReactUpdates.ReactReconcileTransaction && batchingStrategy,\n 'ReactUpdates: must inject a reconcile transaction class and batching ' +\n 'strategy'\n ) : invariant(ReactUpdates.ReactReconcileTransaction && batchingStrategy));\n}\n\nvar NESTED_UPDATES = {\n initialize: function() {\n this.dirtyComponentsLength = dirtyComponents.length;\n },\n close: function() {\n if (this.dirtyComponentsLength !== dirtyComponents.length) {\n // Additional updates were enqueued by componentDidUpdate handlers or\n // similar; before our own UPDATE_QUEUEING wrapper closes, we want to run\n // these new updates so that if A's componentDidUpdate calls setState on\n // B, B will update before the callback A's updater provided when calling\n // setState.\n dirtyComponents.splice(0, this.dirtyComponentsLength);\n flushBatchedUpdates();\n } else {\n dirtyComponents.length = 0;\n }\n }\n};\n\nvar UPDATE_QUEUEING = {\n initialize: function() {\n this.callbackQueue.reset();\n },\n close: function() {\n this.callbackQueue.notifyAll();\n }\n};\n\nvar TRANSACTION_WRAPPERS = [NESTED_UPDATES, UPDATE_QUEUEING];\n\nfunction ReactUpdatesFlushTransaction() {\n this.reinitializeTransaction();\n this.dirtyComponentsLength = null;\n this.callbackQueue = CallbackQueue.getPooled();\n this.reconcileTransaction =\n ReactUpdates.ReactReconcileTransaction.getPooled();\n}\n\nassign(\n ReactUpdatesFlushTransaction.prototype,\n Transaction.Mixin, {\n getTransactionWrappers: function() {\n return TRANSACTION_WRAPPERS;\n },\n\n destructor: function() {\n this.dirtyComponentsLength = null;\n CallbackQueue.release(this.callbackQueue);\n this.callbackQueue = null;\n ReactUpdates.ReactReconcileTransaction.release(this.reconcileTransaction);\n this.reconcileTransaction = null;\n },\n\n perform: function(method, scope, a) {\n // Essentially calls `this.reconcileTransaction.perform(method, scope, a)`\n // with this transaction's wrappers around it.\n return Transaction.Mixin.perform.call(\n this,\n this.reconcileTransaction.perform,\n this.reconcileTransaction,\n method,\n scope,\n a\n );\n }\n});\n\nPooledClass.addPoolingTo(ReactUpdatesFlushTransaction);\n\nfunction batchedUpdates(callback, a, b, c, d) {\n ensureInjected();\n batchingStrategy.batchedUpdates(callback, a, b, c, d);\n}\n\n/**\n * Array comparator for ReactComponents by mount ordering.\n *\n * @param {ReactComponent} c1 first component you're comparing\n * @param {ReactComponent} c2 second component you're comparing\n * @return {number} Return value usable by Array.prototype.sort().\n */\nfunction mountOrderComparator(c1, c2) {\n return c1._mountOrder - c2._mountOrder;\n}\n\nfunction runBatchedUpdates(transaction) {\n var len = transaction.dirtyComponentsLength;\n (\"production\" !== process.env.NODE_ENV ? invariant(\n len === dirtyComponents.length,\n 'Expected flush transaction\\'s stored dirty-components length (%s) to ' +\n 'match dirty-components array length (%s).',\n len,\n dirtyComponents.length\n ) : invariant(len === dirtyComponents.length));\n\n // Since reconciling a component higher in the owner hierarchy usually (not\n // always -- see shouldComponentUpdate()) will reconcile children, reconcile\n // them before their children by sorting the array.\n dirtyComponents.sort(mountOrderComparator);\n\n for (var i = 0; i < len; i++) {\n // If a component is unmounted before pending changes apply, it will still\n // be here, but we assume that it has cleared its _pendingCallbacks and\n // that performUpdateIfNecessary is a noop.\n var component = dirtyComponents[i];\n\n // If performUpdateIfNecessary happens to enqueue any new updates, we\n // shouldn't execute the callbacks until the next render happens, so\n // stash the callbacks first\n var callbacks = component._pendingCallbacks;\n component._pendingCallbacks = null;\n\n ReactReconciler.performUpdateIfNecessary(\n component,\n transaction.reconcileTransaction\n );\n\n if (callbacks) {\n for (var j = 0; j < callbacks.length; j++) {\n transaction.callbackQueue.enqueue(\n callbacks[j],\n component.getPublicInstance()\n );\n }\n }\n }\n}\n\nvar flushBatchedUpdates = function() {\n // ReactUpdatesFlushTransaction's wrappers will clear the dirtyComponents\n // array and perform any updates enqueued by mount-ready handlers (i.e.,\n // componentDidUpdate) but we need to check here too in order to catch\n // updates enqueued by setState callbacks and asap calls.\n while (dirtyComponents.length || asapEnqueued) {\n if (dirtyComponents.length) {\n var transaction = ReactUpdatesFlushTransaction.getPooled();\n transaction.perform(runBatchedUpdates, null, transaction);\n ReactUpdatesFlushTransaction.release(transaction);\n }\n\n if (asapEnqueued) {\n asapEnqueued = false;\n var queue = asapCallbackQueue;\n asapCallbackQueue = CallbackQueue.getPooled();\n queue.notifyAll();\n CallbackQueue.release(queue);\n }\n }\n};\nflushBatchedUpdates = ReactPerf.measure(\n 'ReactUpdates',\n 'flushBatchedUpdates',\n flushBatchedUpdates\n);\n\n/**\n * Mark a component as needing a rerender, adding an optional callback to a\n * list of functions which will be executed once the rerender occurs.\n */\nfunction enqueueUpdate(component) {\n ensureInjected();\n\n // Various parts of our code (such as ReactCompositeComponent's\n // _renderValidatedComponent) assume that calls to render aren't nested;\n // verify that that's the case. (This is called by each top-level update\n // function, like setProps, setState, forceUpdate, etc.; creation and\n // destruction of top-level components is guarded in ReactMount.)\n (\"production\" !== process.env.NODE_ENV ? warning(\n ReactCurrentOwner.current == null,\n 'enqueueUpdate(): Render methods should be a pure function of props ' +\n 'and state; triggering nested component updates from render is not ' +\n 'allowed. If necessary, trigger nested updates in ' +\n 'componentDidUpdate.'\n ) : null);\n\n if (!batchingStrategy.isBatchingUpdates) {\n batchingStrategy.batchedUpdates(enqueueUpdate, component);\n return;\n }\n\n dirtyComponents.push(component);\n}\n\n/**\n * Enqueue a callback to be run at the end of the current batching cycle. Throws\n * if no updates are currently being performed.\n */\nfunction asap(callback, context) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n batchingStrategy.isBatchingUpdates,\n 'ReactUpdates.asap: Can\\'t enqueue an asap callback in a context where' +\n 'updates are not being batched.'\n ) : invariant(batchingStrategy.isBatchingUpdates));\n asapCallbackQueue.enqueue(callback, context);\n asapEnqueued = true;\n}\n\nvar ReactUpdatesInjection = {\n injectReconcileTransaction: function(ReconcileTransaction) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n ReconcileTransaction,\n 'ReactUpdates: must provide a reconcile transaction class'\n ) : invariant(ReconcileTransaction));\n ReactUpdates.ReactReconcileTransaction = ReconcileTransaction;\n },\n\n injectBatchingStrategy: function(_batchingStrategy) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n _batchingStrategy,\n 'ReactUpdates: must provide a batching strategy'\n ) : invariant(_batchingStrategy));\n (\"production\" !== process.env.NODE_ENV ? invariant(\n typeof _batchingStrategy.batchedUpdates === 'function',\n 'ReactUpdates: must provide a batchedUpdates() function'\n ) : invariant(typeof _batchingStrategy.batchedUpdates === 'function'));\n (\"production\" !== process.env.NODE_ENV ? invariant(\n typeof _batchingStrategy.isBatchingUpdates === 'boolean',\n 'ReactUpdates: must provide an isBatchingUpdates boolean attribute'\n ) : invariant(typeof _batchingStrategy.isBatchingUpdates === 'boolean'));\n batchingStrategy = _batchingStrategy;\n }\n};\n\nvar ReactUpdates = {\n /**\n * React references `ReactReconcileTransaction` using this property in order\n * to allow dependency injection.\n *\n * @internal\n */\n ReactReconcileTransaction: null,\n\n batchedUpdates: batchedUpdates,\n enqueueUpdate: enqueueUpdate,\n flushBatchedUpdates: flushBatchedUpdates,\n injection: ReactUpdatesInjection,\n asap: asap\n};\n\nmodule.exports = ReactUpdates;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactUpdates.js\n ** module id = 31\n ** module chunks = 0\n **/","/**\n * Copyright 2013-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule CallbackQueue\n */\n\n'use strict';\n\nvar PooledClass = require(\"./PooledClass\");\n\nvar assign = require(\"./Object.assign\");\nvar invariant = require(\"./invariant\");\n\n/**\n * A specialized pseudo-event module to help keep track of components waiting to\n * be notified when their DOM representations are available for use.\n *\n * This implements `PooledClass`, so you should never need to instantiate this.\n * Instead, use `CallbackQueue.getPooled()`.\n *\n * @class ReactMountReady\n * @implements PooledClass\n * @internal\n */\nfunction CallbackQueue() {\n this._callbacks = null;\n this._contexts = null;\n}\n\nassign(CallbackQueue.prototype, {\n\n /**\n * Enqueues a callback to be invoked when `notifyAll` is invoked.\n *\n * @param {function} callback Invoked when `notifyAll` is invoked.\n * @param {?object} context Context to call `callback` with.\n * @internal\n */\n enqueue: function(callback, context) {\n this._callbacks = this._callbacks || [];\n this._contexts = this._contexts || [];\n this._callbacks.push(callback);\n this._contexts.push(context);\n },\n\n /**\n * Invokes all enqueued callbacks and clears the queue. This is invoked after\n * the DOM representation of a component has been created or updated.\n *\n * @internal\n */\n notifyAll: function() {\n var callbacks = this._callbacks;\n var contexts = this._contexts;\n if (callbacks) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n callbacks.length === contexts.length,\n 'Mismatched list of contexts in callback queue'\n ) : invariant(callbacks.length === contexts.length));\n this._callbacks = null;\n this._contexts = null;\n for (var i = 0, l = callbacks.length; i < l; i++) {\n callbacks[i].call(contexts[i]);\n }\n callbacks.length = 0;\n contexts.length = 0;\n }\n },\n\n /**\n * Resets the internal queue.\n *\n * @internal\n */\n reset: function() {\n this._callbacks = null;\n this._contexts = null;\n },\n\n /**\n * `PooledClass` looks for this.\n */\n destructor: function() {\n this.reset();\n }\n\n});\n\nPooledClass.addPoolingTo(CallbackQueue);\n\nmodule.exports = CallbackQueue;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/CallbackQueue.js\n ** module id = 32\n ** module chunks = 0\n **/","/**\n * Copyright 2013-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule ReactPerf\n * @typechecks static-only\n */\n\n'use strict';\n\n/**\n * ReactPerf is a general AOP system designed to measure performance. This\n * module only has the hooks: see ReactDefaultPerf for the analysis tool.\n */\nvar ReactPerf = {\n /**\n * Boolean to enable/disable measurement. Set to false by default to prevent\n * accidental logging and perf loss.\n */\n enableMeasure: false,\n\n /**\n * Holds onto the measure function in use. By default, don't measure\n * anything, but we'll override this if we inject a measure function.\n */\n storedMeasure: _noMeasure,\n\n /**\n * @param {object} object\n * @param {string} objectName\n * @param {object} methodNames\n */\n measureMethods: function(object, objectName, methodNames) {\n if (\"production\" !== process.env.NODE_ENV) {\n for (var key in methodNames) {\n if (!methodNames.hasOwnProperty(key)) {\n continue;\n }\n object[key] = ReactPerf.measure(\n objectName,\n methodNames[key],\n object[key]\n );\n }\n }\n },\n\n /**\n * Use this to wrap methods you want to measure. Zero overhead in production.\n *\n * @param {string} objName\n * @param {string} fnName\n * @param {function} func\n * @return {function}\n */\n measure: function(objName, fnName, func) {\n if (\"production\" !== process.env.NODE_ENV) {\n var measuredFunc = null;\n var wrapper = function() {\n if (ReactPerf.enableMeasure) {\n if (!measuredFunc) {\n measuredFunc = ReactPerf.storedMeasure(objName, fnName, func);\n }\n return measuredFunc.apply(this, arguments);\n }\n return func.apply(this, arguments);\n };\n wrapper.displayName = objName + '_' + fnName;\n return wrapper;\n }\n return func;\n },\n\n injection: {\n /**\n * @param {function} measure\n */\n injectMeasure: function(measure) {\n ReactPerf.storedMeasure = measure;\n }\n }\n};\n\n/**\n * Simply passes through the measured function, without measuring it.\n *\n * @param {string} objName\n * @param {string} fnName\n * @param {function} func\n * @return {function}\n */\nfunction _noMeasure(objName, fnName, func) {\n return func;\n}\n\nmodule.exports = ReactPerf;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactPerf.js\n ** module id = 33\n ** module chunks = 0\n **/","/**\n * Copyright 2013-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule ReactReconciler\n */\n\n'use strict';\n\nvar ReactRef = require(\"./ReactRef\");\nvar ReactElementValidator = require(\"./ReactElementValidator\");\n\n/**\n * Helper to call ReactRef.attachRefs with this composite component, split out\n * to avoid allocations in the transaction mount-ready queue.\n */\nfunction attachRefs() {\n ReactRef.attachRefs(this, this._currentElement);\n}\n\nvar ReactReconciler = {\n\n /**\n * Initializes the component, renders markup, and registers event listeners.\n *\n * @param {ReactComponent} internalInstance\n * @param {string} rootID DOM ID of the root node.\n * @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction\n * @return {?string} Rendered markup to be inserted into the DOM.\n * @final\n * @internal\n */\n mountComponent: function(internalInstance, rootID, transaction, context) {\n var markup = internalInstance.mountComponent(rootID, transaction, context);\n if (\"production\" !== process.env.NODE_ENV) {\n ReactElementValidator.checkAndWarnForMutatedProps(\n internalInstance._currentElement\n );\n }\n transaction.getReactMountReady().enqueue(attachRefs, internalInstance);\n return markup;\n },\n\n /**\n * Releases any resources allocated by `mountComponent`.\n *\n * @final\n * @internal\n */\n unmountComponent: function(internalInstance) {\n ReactRef.detachRefs(internalInstance, internalInstance._currentElement);\n internalInstance.unmountComponent();\n },\n\n /**\n * Update a component using a new element.\n *\n * @param {ReactComponent} internalInstance\n * @param {ReactElement} nextElement\n * @param {ReactReconcileTransaction} transaction\n * @param {object} context\n * @internal\n */\n receiveComponent: function(\n internalInstance, nextElement, transaction, context\n ) {\n var prevElement = internalInstance._currentElement;\n\n if (nextElement === prevElement && nextElement._owner != null) {\n // Since elements are immutable after the owner is rendered,\n // we can do a cheap identity compare here to determine if this is a\n // superfluous reconcile. It's possible for state to be mutable but such\n // change should trigger an update of the owner which would recreate\n // the element. We explicitly check for the existence of an owner since\n // it's possible for an element created outside a composite to be\n // deeply mutated and reused.\n return;\n }\n\n if (\"production\" !== process.env.NODE_ENV) {\n ReactElementValidator.checkAndWarnForMutatedProps(nextElement);\n }\n\n var refsChanged = ReactRef.shouldUpdateRefs(\n prevElement,\n nextElement\n );\n\n if (refsChanged) {\n ReactRef.detachRefs(internalInstance, prevElement);\n }\n\n internalInstance.receiveComponent(nextElement, transaction, context);\n\n if (refsChanged) {\n transaction.getReactMountReady().enqueue(attachRefs, internalInstance);\n }\n },\n\n /**\n * Flush any dirty changes in a component.\n *\n * @param {ReactComponent} internalInstance\n * @param {ReactReconcileTransaction} transaction\n * @internal\n */\n performUpdateIfNecessary: function(\n internalInstance,\n transaction\n ) {\n internalInstance.performUpdateIfNecessary(transaction);\n }\n\n};\n\nmodule.exports = ReactReconciler;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactReconciler.js\n ** module id = 34\n ** module chunks = 0\n **/","/**\n * Copyright 2013-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule ReactRef\n */\n\n'use strict';\n\nvar ReactOwner = require(\"./ReactOwner\");\n\nvar ReactRef = {};\n\nfunction attachRef(ref, component, owner) {\n if (typeof ref === 'function') {\n ref(component.getPublicInstance());\n } else {\n // Legacy ref\n ReactOwner.addComponentAsRefTo(component, ref, owner);\n }\n}\n\nfunction detachRef(ref, component, owner) {\n if (typeof ref === 'function') {\n ref(null);\n } else {\n // Legacy ref\n ReactOwner.removeComponentAsRefFrom(component, ref, owner);\n }\n}\n\nReactRef.attachRefs = function(instance, element) {\n var ref = element.ref;\n if (ref != null) {\n attachRef(ref, instance, element._owner);\n }\n};\n\nReactRef.shouldUpdateRefs = function(prevElement, nextElement) {\n // If either the owner or a `ref` has changed, make sure the newest owner\n // has stored a reference to `this`, and the previous owner (if different)\n // has forgotten the reference to `this`. We use the element instead\n // of the public this.props because the post processing cannot determine\n // a ref. The ref conceptually lives on the element.\n\n // TODO: Should this even be possible? The owner cannot change because\n // it's forbidden by shouldUpdateReactComponent. The ref can change\n // if you swap the keys of but not the refs. Reconsider where this check\n // is made. It probably belongs where the key checking and\n // instantiateReactComponent is done.\n\n return (\n nextElement._owner !== prevElement._owner ||\n nextElement.ref !== prevElement.ref\n );\n};\n\nReactRef.detachRefs = function(instance, element) {\n var ref = element.ref;\n if (ref != null) {\n detachRef(ref, instance, element._owner);\n }\n};\n\nmodule.exports = ReactRef;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactRef.js\n ** module id = 35\n ** module chunks = 0\n **/","/**\n * Copyright 2013-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule ReactOwner\n */\n\n'use strict';\n\nvar invariant = require(\"./invariant\");\n\n/**\n * ReactOwners are capable of storing references to owned components.\n *\n * All components are capable of //being// referenced by owner components, but\n * only ReactOwner components are capable of //referencing// owned components.\n * The named reference is known as a \"ref\".\n *\n * Refs are available when mounted and updated during reconciliation.\n *\n * var MyComponent = React.createClass({\n * render: function() {\n * return (\n *
\n * \n *
\n * );\n * },\n * handleClick: function() {\n * this.refs.custom.handleClick();\n * },\n * componentDidMount: function() {\n * this.refs.custom.initialize();\n * }\n * });\n *\n * Refs should rarely be used. When refs are used, they should only be done to\n * control data that is not handled by React's data flow.\n *\n * @class ReactOwner\n */\nvar ReactOwner = {\n\n /**\n * @param {?object} object\n * @return {boolean} True if `object` is a valid owner.\n * @final\n */\n isValidOwner: function(object) {\n return !!(\n (object &&\n typeof object.attachRef === 'function' && typeof object.detachRef === 'function')\n );\n },\n\n /**\n * Adds a component by ref to an owner component.\n *\n * @param {ReactComponent} component Component to reference.\n * @param {string} ref Name by which to refer to the component.\n * @param {ReactOwner} owner Component on which to record the ref.\n * @final\n * @internal\n */\n addComponentAsRefTo: function(component, ref, owner) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n ReactOwner.isValidOwner(owner),\n 'addComponentAsRefTo(...): Only a ReactOwner can have refs. This ' +\n 'usually means that you\\'re trying to add a ref to a component that ' +\n 'doesn\\'t have an owner (that is, was not created inside of another ' +\n 'component\\'s `render` method). Try rendering this component inside of ' +\n 'a new top-level component which will hold the ref.'\n ) : invariant(ReactOwner.isValidOwner(owner)));\n owner.attachRef(ref, component);\n },\n\n /**\n * Removes a component by ref from an owner component.\n *\n * @param {ReactComponent} component Component to dereference.\n * @param {string} ref Name of the ref to remove.\n * @param {ReactOwner} owner Component on which the ref is recorded.\n * @final\n * @internal\n */\n removeComponentAsRefFrom: function(component, ref, owner) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n ReactOwner.isValidOwner(owner),\n 'removeComponentAsRefFrom(...): Only a ReactOwner can have refs. This ' +\n 'usually means that you\\'re trying to remove a ref to a component that ' +\n 'doesn\\'t have an owner (that is, was not created inside of another ' +\n 'component\\'s `render` method). Try rendering this component inside of ' +\n 'a new top-level component which will hold the ref.'\n ) : invariant(ReactOwner.isValidOwner(owner)));\n // Check that `component` is still the current ref because we do not want to\n // detach the ref if another component stole it.\n if (owner.getPublicInstance().refs[ref] === component.getPublicInstance()) {\n owner.detachRef(ref);\n }\n }\n\n};\n\nmodule.exports = ReactOwner;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactOwner.js\n ** module id = 36\n ** module chunks = 0\n **/","/**\n * Copyright 2014-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule ReactElementValidator\n */\n\n/**\n * ReactElementValidator provides a wrapper around a element factory\n * which validates the props passed to the element. This is intended to be\n * used only in DEV and could be replaced by a static type checker for languages\n * that support it.\n */\n\n'use strict';\n\nvar ReactElement = require(\"./ReactElement\");\nvar ReactFragment = require(\"./ReactFragment\");\nvar ReactPropTypeLocations = require(\"./ReactPropTypeLocations\");\nvar ReactPropTypeLocationNames = require(\"./ReactPropTypeLocationNames\");\nvar ReactCurrentOwner = require(\"./ReactCurrentOwner\");\nvar ReactNativeComponent = require(\"./ReactNativeComponent\");\n\nvar getIteratorFn = require(\"./getIteratorFn\");\nvar invariant = require(\"./invariant\");\nvar warning = require(\"./warning\");\n\nfunction getDeclarationErrorAddendum() {\n if (ReactCurrentOwner.current) {\n var name = ReactCurrentOwner.current.getName();\n if (name) {\n return ' Check the render method of `' + name + '`.';\n }\n }\n return '';\n}\n\n/**\n * Warn if there's no key explicitly set on dynamic arrays of children or\n * object keys are not valid. This allows us to keep track of children between\n * updates.\n */\nvar ownerHasKeyUseWarning = {};\n\nvar loggedTypeFailures = {};\n\nvar NUMERIC_PROPERTY_REGEX = /^\\d+$/;\n\n/**\n * Gets the instance's name for use in warnings.\n *\n * @internal\n * @return {?string} Display name or undefined\n */\nfunction getName(instance) {\n var publicInstance = instance && instance.getPublicInstance();\n if (!publicInstance) {\n return undefined;\n }\n var constructor = publicInstance.constructor;\n if (!constructor) {\n return undefined;\n }\n return constructor.displayName || constructor.name || undefined;\n}\n\n/**\n * Gets the current owner's displayName for use in warnings.\n *\n * @internal\n * @return {?string} Display name or undefined\n */\nfunction getCurrentOwnerDisplayName() {\n var current = ReactCurrentOwner.current;\n return (\n current && getName(current) || undefined\n );\n}\n\n/**\n * Warn if the element doesn't have an explicit key assigned to it.\n * This element is in an array. The array could grow and shrink or be\n * reordered. All children that haven't already been validated are required to\n * have a \"key\" property assigned to it.\n *\n * @internal\n * @param {ReactElement} element Element that requires a key.\n * @param {*} parentType element's parent's type.\n */\nfunction validateExplicitKey(element, parentType) {\n if (element._store.validated || element.key != null) {\n return;\n }\n element._store.validated = true;\n\n warnAndMonitorForKeyUse(\n 'Each child in an array or iterator should have a unique \"key\" prop.',\n element,\n parentType\n );\n}\n\n/**\n * Warn if the key is being defined as an object property but has an incorrect\n * value.\n *\n * @internal\n * @param {string} name Property name of the key.\n * @param {ReactElement} element Component that requires a key.\n * @param {*} parentType element's parent's type.\n */\nfunction validatePropertyKey(name, element, parentType) {\n if (!NUMERIC_PROPERTY_REGEX.test(name)) {\n return;\n }\n warnAndMonitorForKeyUse(\n 'Child objects should have non-numeric keys so ordering is preserved.',\n element,\n parentType\n );\n}\n\n/**\n * Shared warning and monitoring code for the key warnings.\n *\n * @internal\n * @param {string} message The base warning that gets output.\n * @param {ReactElement} element Component that requires a key.\n * @param {*} parentType element's parent's type.\n */\nfunction warnAndMonitorForKeyUse(message, element, parentType) {\n var ownerName = getCurrentOwnerDisplayName();\n var parentName = typeof parentType === 'string' ?\n parentType : parentType.displayName || parentType.name;\n\n var useName = ownerName || parentName;\n var memoizer = ownerHasKeyUseWarning[message] || (\n (ownerHasKeyUseWarning[message] = {})\n );\n if (memoizer.hasOwnProperty(useName)) {\n return;\n }\n memoizer[useName] = true;\n\n var parentOrOwnerAddendum =\n ownerName ? (\" Check the render method of \" + ownerName + \".\") :\n parentName ? (\" Check the React.render call using <\" + parentName + \">.\") :\n '';\n\n // Usually the current owner is the offender, but if it accepts children as a\n // property, it may be the creator of the child that's responsible for\n // assigning it a key.\n var childOwnerAddendum = '';\n if (element &&\n element._owner &&\n element._owner !== ReactCurrentOwner.current) {\n // Name of the component that originally created this child.\n var childOwnerName = getName(element._owner);\n\n childOwnerAddendum = (\" It was passed a child from \" + childOwnerName + \".\");\n }\n\n (\"production\" !== process.env.NODE_ENV ? warning(\n false,\n message + '%s%s See https://fb.me/react-warning-keys for more information.',\n parentOrOwnerAddendum,\n childOwnerAddendum\n ) : null);\n}\n\n/**\n * Ensure that every element either is passed in a static location, in an\n * array with an explicit keys property defined, or in an object literal\n * with valid key property.\n *\n * @internal\n * @param {ReactNode} node Statically passed child of any type.\n * @param {*} parentType node's parent's type.\n */\nfunction validateChildKeys(node, parentType) {\n if (Array.isArray(node)) {\n for (var i = 0; i < node.length; i++) {\n var child = node[i];\n if (ReactElement.isValidElement(child)) {\n validateExplicitKey(child, parentType);\n }\n }\n } else if (ReactElement.isValidElement(node)) {\n // This element was passed in a valid location.\n node._store.validated = true;\n } else if (node) {\n var iteratorFn = getIteratorFn(node);\n // Entry iterators provide implicit keys.\n if (iteratorFn) {\n if (iteratorFn !== node.entries) {\n var iterator = iteratorFn.call(node);\n var step;\n while (!(step = iterator.next()).done) {\n if (ReactElement.isValidElement(step.value)) {\n validateExplicitKey(step.value, parentType);\n }\n }\n }\n } else if (typeof node === 'object') {\n var fragment = ReactFragment.extractIfFragment(node);\n for (var key in fragment) {\n if (fragment.hasOwnProperty(key)) {\n validatePropertyKey(key, fragment[key], parentType);\n }\n }\n }\n }\n}\n\n/**\n * Assert that the props are valid\n *\n * @param {string} componentName Name of the component for error messages.\n * @param {object} propTypes Map of prop name to a ReactPropType\n * @param {object} props\n * @param {string} location e.g. \"prop\", \"context\", \"child context\"\n * @private\n */\nfunction checkPropTypes(componentName, propTypes, props, location) {\n for (var propName in propTypes) {\n if (propTypes.hasOwnProperty(propName)) {\n var error;\n // Prop type validation may throw. In case they do, we don't want to\n // fail the render phase where it didn't fail before. So we log it.\n // After these have been cleaned up, we'll let them throw.\n try {\n // This is intentionally an invariant that gets caught. It's the same\n // behavior as without this statement except with a better message.\n (\"production\" !== process.env.NODE_ENV ? invariant(\n typeof propTypes[propName] === 'function',\n '%s: %s type `%s` is invalid; it must be a function, usually from ' +\n 'React.PropTypes.',\n componentName || 'React class',\n ReactPropTypeLocationNames[location],\n propName\n ) : invariant(typeof propTypes[propName] === 'function'));\n error = propTypes[propName](props, propName, componentName, location);\n } catch (ex) {\n error = ex;\n }\n if (error instanceof Error && !(error.message in loggedTypeFailures)) {\n // Only monitor this failure once because there tends to be a lot of the\n // same error.\n loggedTypeFailures[error.message] = true;\n\n var addendum = getDeclarationErrorAddendum(this);\n (\"production\" !== process.env.NODE_ENV ? warning(false, 'Failed propType: %s%s', error.message, addendum) : null);\n }\n }\n }\n}\n\nvar warnedPropsMutations = {};\n\n/**\n * Warn about mutating props when setting `propName` on `element`.\n *\n * @param {string} propName The string key within props that was set\n * @param {ReactElement} element\n */\nfunction warnForPropsMutation(propName, element) {\n var type = element.type;\n var elementName = typeof type === 'string' ? type : type.displayName;\n var ownerName = element._owner ?\n element._owner.getPublicInstance().constructor.displayName : null;\n\n var warningKey = propName + '|' + elementName + '|' + ownerName;\n if (warnedPropsMutations.hasOwnProperty(warningKey)) {\n return;\n }\n warnedPropsMutations[warningKey] = true;\n\n var elementInfo = '';\n if (elementName) {\n elementInfo = ' <' + elementName + ' />';\n }\n var ownerInfo = '';\n if (ownerName) {\n ownerInfo = ' The element was created by ' + ownerName + '.';\n }\n\n (\"production\" !== process.env.NODE_ENV ? warning(\n false,\n 'Don\\'t set .props.%s of the React component%s. Instead, specify the ' +\n 'correct value when initially creating the element or use ' +\n 'React.cloneElement to make a new element with updated props.%s',\n propName,\n elementInfo,\n ownerInfo\n ) : null);\n}\n\n// Inline Object.is polyfill\nfunction is(a, b) {\n if (a !== a) {\n // NaN\n return b !== b;\n }\n if (a === 0 && b === 0) {\n // +-0\n return 1 / a === 1 / b;\n }\n return a === b;\n}\n\n/**\n * Given an element, check if its props have been mutated since element\n * creation (or the last call to this function). In particular, check if any\n * new props have been added, which we can't directly catch by defining warning\n * properties on the props object.\n *\n * @param {ReactElement} element\n */\nfunction checkAndWarnForMutatedProps(element) {\n if (!element._store) {\n // Element was created using `new ReactElement` directly or with\n // `ReactElement.createElement`; skip mutation checking\n return;\n }\n\n var originalProps = element._store.originalProps;\n var props = element.props;\n\n for (var propName in props) {\n if (props.hasOwnProperty(propName)) {\n if (!originalProps.hasOwnProperty(propName) ||\n !is(originalProps[propName], props[propName])) {\n warnForPropsMutation(propName, element);\n\n // Copy over the new value so that the two props objects match again\n originalProps[propName] = props[propName];\n }\n }\n }\n}\n\n/**\n * Given an element, validate that its props follow the propTypes definition,\n * provided by the type.\n *\n * @param {ReactElement} element\n */\nfunction validatePropTypes(element) {\n if (element.type == null) {\n // This has already warned. Don't throw.\n return;\n }\n // Extract the component class from the element. Converts string types\n // to a composite class which may have propTypes.\n // TODO: Validating a string's propTypes is not decoupled from the\n // rendering target which is problematic.\n var componentClass = ReactNativeComponent.getComponentClassForElement(\n element\n );\n var name = componentClass.displayName || componentClass.name;\n if (componentClass.propTypes) {\n checkPropTypes(\n name,\n componentClass.propTypes,\n element.props,\n ReactPropTypeLocations.prop\n );\n }\n if (typeof componentClass.getDefaultProps === 'function') {\n (\"production\" !== process.env.NODE_ENV ? warning(\n componentClass.getDefaultProps.isReactClassApproved,\n 'getDefaultProps is only used on classic React.createClass ' +\n 'definitions. Use a static property named `defaultProps` instead.'\n ) : null);\n }\n}\n\nvar ReactElementValidator = {\n\n checkAndWarnForMutatedProps: checkAndWarnForMutatedProps,\n\n createElement: function(type, props, children) {\n // We warn in this case but don't throw. We expect the element creation to\n // succeed and there will likely be errors in render.\n (\"production\" !== process.env.NODE_ENV ? warning(\n type != null,\n 'React.createElement: type should not be null or undefined. It should ' +\n 'be a string (for DOM elements) or a ReactClass (for composite ' +\n 'components).'\n ) : null);\n\n var element = ReactElement.createElement.apply(this, arguments);\n\n // The result can be nullish if a mock or a custom function is used.\n // TODO: Drop this when these are no longer allowed as the type argument.\n if (element == null) {\n return element;\n }\n\n for (var i = 2; i < arguments.length; i++) {\n validateChildKeys(arguments[i], type);\n }\n\n validatePropTypes(element);\n\n return element;\n },\n\n createFactory: function(type) {\n var validatedFactory = ReactElementValidator.createElement.bind(\n null,\n type\n );\n // Legacy hook TODO: Warn if this is accessed\n validatedFactory.type = type;\n\n if (\"production\" !== process.env.NODE_ENV) {\n try {\n Object.defineProperty(\n validatedFactory,\n 'type',\n {\n enumerable: false,\n get: function() {\n (\"production\" !== process.env.NODE_ENV ? warning(\n false,\n 'Factory.type is deprecated. Access the class directly ' +\n 'before passing it to createFactory.'\n ) : null);\n Object.defineProperty(this, 'type', {\n value: type\n });\n return type;\n }\n }\n );\n } catch (x) {\n // IE will fail on defineProperty (es5-shim/sham too)\n }\n }\n\n\n return validatedFactory;\n },\n\n cloneElement: function(element, props, children) {\n var newElement = ReactElement.cloneElement.apply(this, arguments);\n for (var i = 2; i < arguments.length; i++) {\n validateChildKeys(arguments[i], newElement.type);\n }\n validatePropTypes(newElement);\n return newElement;\n }\n\n};\n\nmodule.exports = ReactElementValidator;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactElementValidator.js\n ** module id = 37\n ** module chunks = 0\n **/","/**\n * Copyright 2013-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule ReactPropTypeLocations\n */\n\n'use strict';\n\nvar keyMirror = require(\"./keyMirror\");\n\nvar ReactPropTypeLocations = keyMirror({\n prop: null,\n context: null,\n childContext: null\n});\n\nmodule.exports = ReactPropTypeLocations;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactPropTypeLocations.js\n ** module id = 38\n ** module chunks = 0\n **/","/**\n * Copyright 2013-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule ReactPropTypeLocationNames\n */\n\n'use strict';\n\nvar ReactPropTypeLocationNames = {};\n\nif (\"production\" !== process.env.NODE_ENV) {\n ReactPropTypeLocationNames = {\n prop: 'prop',\n context: 'context',\n childContext: 'child context'\n };\n}\n\nmodule.exports = ReactPropTypeLocationNames;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactPropTypeLocationNames.js\n ** module id = 39\n ** module chunks = 0\n **/","/**\n * Copyright 2014-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule ReactNativeComponent\n */\n\n'use strict';\n\nvar assign = require(\"./Object.assign\");\nvar invariant = require(\"./invariant\");\n\nvar autoGenerateWrapperClass = null;\nvar genericComponentClass = null;\n// This registry keeps track of wrapper classes around native tags\nvar tagToComponentClass = {};\nvar textComponentClass = null;\n\nvar ReactNativeComponentInjection = {\n // This accepts a class that receives the tag string. This is a catch all\n // that can render any kind of tag.\n injectGenericComponentClass: function(componentClass) {\n genericComponentClass = componentClass;\n },\n // This accepts a text component class that takes the text string to be\n // rendered as props.\n injectTextComponentClass: function(componentClass) {\n textComponentClass = componentClass;\n },\n // This accepts a keyed object with classes as values. Each key represents a\n // tag. That particular tag will use this class instead of the generic one.\n injectComponentClasses: function(componentClasses) {\n assign(tagToComponentClass, componentClasses);\n },\n // Temporary hack since we expect DOM refs to behave like composites,\n // for this release.\n injectAutoWrapper: function(wrapperFactory) {\n autoGenerateWrapperClass = wrapperFactory;\n }\n};\n\n/**\n * Get a composite component wrapper class for a specific tag.\n *\n * @param {ReactElement} element The tag for which to get the class.\n * @return {function} The React class constructor function.\n */\nfunction getComponentClassForElement(element) {\n if (typeof element.type === 'function') {\n return element.type;\n }\n var tag = element.type;\n var componentClass = tagToComponentClass[tag];\n if (componentClass == null) {\n tagToComponentClass[tag] = componentClass = autoGenerateWrapperClass(tag);\n }\n return componentClass;\n}\n\n/**\n * Get a native internal component class for a specific tag.\n *\n * @param {ReactElement} element The element to create.\n * @return {function} The internal class constructor function.\n */\nfunction createInternalComponent(element) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n genericComponentClass,\n 'There is no registered component for the tag %s',\n element.type\n ) : invariant(genericComponentClass));\n return new genericComponentClass(element.type, element.props);\n}\n\n/**\n * @param {ReactText} text\n * @return {ReactComponent}\n */\nfunction createInstanceForText(text) {\n return new textComponentClass(text);\n}\n\n/**\n * @param {ReactComponent} component\n * @return {boolean}\n */\nfunction isTextComponent(component) {\n return component instanceof textComponentClass;\n}\n\nvar ReactNativeComponent = {\n getComponentClassForElement: getComponentClassForElement,\n createInternalComponent: createInternalComponent,\n createInstanceForText: createInstanceForText,\n isTextComponent: isTextComponent,\n injection: ReactNativeComponentInjection\n};\n\nmodule.exports = ReactNativeComponent;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactNativeComponent.js\n ** module id = 40\n ** module chunks = 0\n **/","/**\n * Copyright 2013-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule Transaction\n */\n\n'use strict';\n\nvar invariant = require(\"./invariant\");\n\n/**\n * `Transaction` creates a black box that is able to wrap any method such that\n * certain invariants are maintained before and after the method is invoked\n * (Even if an exception is thrown while invoking the wrapped method). Whoever\n * instantiates a transaction can provide enforcers of the invariants at\n * creation time. The `Transaction` class itself will supply one additional\n * automatic invariant for you - the invariant that any transaction instance\n * should not be run while it is already being run. You would typically create a\n * single instance of a `Transaction` for reuse multiple times, that potentially\n * is used to wrap several different methods. Wrappers are extremely simple -\n * they only require implementing two methods.\n *\n *
\n *\n * Use cases:\n * - Preserving the input selection ranges before/after reconciliation.\n * Restoring selection even in the event of an unexpected error.\n * - Deactivating events while rearranging the DOM, preventing blurs/focuses,\n * while guaranteeing that afterwards, the event system is reactivated.\n * - Flushing a queue of collected DOM mutations to the main UI thread after a\n * reconciliation takes place in a worker thread.\n * - Invoking any collected `componentDidUpdate` callbacks after rendering new\n * content.\n * - (Future use case): Wrapping particular flushes of the `ReactWorker` queue\n * to preserve the `scrollTop` (an automatic scroll aware DOM).\n * - (Future use case): Layout calculations before and after DOM updates.\n *\n * Transactional plugin API:\n * - A module that has an `initialize` method that returns any precomputation.\n * - and a `close` method that accepts the precomputation. `close` is invoked\n * when the wrapped process is completed, or has failed.\n *\n * @param {Array} transactionWrapper Wrapper modules\n * that implement `initialize` and `close`.\n * @return {Transaction} Single transaction for reuse in thread.\n *\n * @class Transaction\n */\nvar Mixin = {\n /**\n * Sets up this instance so that it is prepared for collecting metrics. Does\n * so such that this setup method may be used on an instance that is already\n * initialized, in a way that does not consume additional memory upon reuse.\n * That can be useful if you decide to make your subclass of this mixin a\n * \"PooledClass\".\n */\n reinitializeTransaction: function() {\n this.transactionWrappers = this.getTransactionWrappers();\n if (!this.wrapperInitData) {\n this.wrapperInitData = [];\n } else {\n this.wrapperInitData.length = 0;\n }\n this._isInTransaction = false;\n },\n\n _isInTransaction: false,\n\n /**\n * @abstract\n * @return {Array} Array of transaction wrappers.\n */\n getTransactionWrappers: null,\n\n isInTransaction: function() {\n return !!this._isInTransaction;\n },\n\n /**\n * Executes the function within a safety window. Use this for the top level\n * methods that result in large amounts of computation/mutations that would\n * need to be safety checked.\n *\n * @param {function} method Member of scope to call.\n * @param {Object} scope Scope to invoke from.\n * @param {Object?=} args... Arguments to pass to the method (optional).\n * Helps prevent need to bind in many cases.\n * @return Return value from `method`.\n */\n perform: function(method, scope, a, b, c, d, e, f) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n !this.isInTransaction(),\n 'Transaction.perform(...): Cannot initialize a transaction when there ' +\n 'is already an outstanding transaction.'\n ) : invariant(!this.isInTransaction()));\n var errorThrown;\n var ret;\n try {\n this._isInTransaction = true;\n // Catching errors makes debugging more difficult, so we start with\n // errorThrown set to true before setting it to false after calling\n // close -- if it's still set to true in the finally block, it means\n // one of these calls threw.\n errorThrown = true;\n this.initializeAll(0);\n ret = method.call(scope, a, b, c, d, e, f);\n errorThrown = false;\n } finally {\n try {\n if (errorThrown) {\n // If `method` throws, prefer to show that stack trace over any thrown\n // by invoking `closeAll`.\n try {\n this.closeAll(0);\n } catch (err) {\n }\n } else {\n // Since `method` didn't throw, we don't want to silence the exception\n // here.\n this.closeAll(0);\n }\n } finally {\n this._isInTransaction = false;\n }\n }\n return ret;\n },\n\n initializeAll: function(startIndex) {\n var transactionWrappers = this.transactionWrappers;\n for (var i = startIndex; i < transactionWrappers.length; i++) {\n var wrapper = transactionWrappers[i];\n try {\n // Catching errors makes debugging more difficult, so we start with the\n // OBSERVED_ERROR state before overwriting it with the real return value\n // of initialize -- if it's still set to OBSERVED_ERROR in the finally\n // block, it means wrapper.initialize threw.\n this.wrapperInitData[i] = Transaction.OBSERVED_ERROR;\n this.wrapperInitData[i] = wrapper.initialize ?\n wrapper.initialize.call(this) :\n null;\n } finally {\n if (this.wrapperInitData[i] === Transaction.OBSERVED_ERROR) {\n // The initializer for wrapper i threw an error; initialize the\n // remaining wrappers but silence any exceptions from them to ensure\n // that the first error is the one to bubble up.\n try {\n this.initializeAll(i + 1);\n } catch (err) {\n }\n }\n }\n }\n },\n\n /**\n * Invokes each of `this.transactionWrappers.close[i]` functions, passing into\n * them the respective return values of `this.transactionWrappers.init[i]`\n * (`close`rs that correspond to initializers that failed will not be\n * invoked).\n */\n closeAll: function(startIndex) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n this.isInTransaction(),\n 'Transaction.closeAll(): Cannot close transaction when none are open.'\n ) : invariant(this.isInTransaction()));\n var transactionWrappers = this.transactionWrappers;\n for (var i = startIndex; i < transactionWrappers.length; i++) {\n var wrapper = transactionWrappers[i];\n var initData = this.wrapperInitData[i];\n var errorThrown;\n try {\n // Catching errors makes debugging more difficult, so we start with\n // errorThrown set to true before setting it to false after calling\n // close -- if it's still set to true in the finally block, it means\n // wrapper.close threw.\n errorThrown = true;\n if (initData !== Transaction.OBSERVED_ERROR && wrapper.close) {\n wrapper.close.call(this, initData);\n }\n errorThrown = false;\n } finally {\n if (errorThrown) {\n // The closer for wrapper i threw an error; close the remaining\n // wrappers but silence any exceptions from them to ensure that the\n // first error is the one to bubble up.\n try {\n this.closeAll(i + 1);\n } catch (e) {\n }\n }\n }\n }\n this.wrapperInitData.length = 0;\n }\n};\n\nvar Transaction = {\n\n Mixin: Mixin,\n\n /**\n * Token to look for to determine if an error occured.\n */\n OBSERVED_ERROR: {}\n\n};\n\nmodule.exports = Transaction;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/Transaction.js\n ** module id = 41\n ** module chunks = 0\n **/","/**\n * Copyright 2013-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule ReactClass\n */\n\n'use strict';\n\nvar ReactComponent = require(\"./ReactComponent\");\nvar ReactCurrentOwner = require(\"./ReactCurrentOwner\");\nvar ReactElement = require(\"./ReactElement\");\nvar ReactErrorUtils = require(\"./ReactErrorUtils\");\nvar ReactInstanceMap = require(\"./ReactInstanceMap\");\nvar ReactLifeCycle = require(\"./ReactLifeCycle\");\nvar ReactPropTypeLocations = require(\"./ReactPropTypeLocations\");\nvar ReactPropTypeLocationNames = require(\"./ReactPropTypeLocationNames\");\nvar ReactUpdateQueue = require(\"./ReactUpdateQueue\");\n\nvar assign = require(\"./Object.assign\");\nvar invariant = require(\"./invariant\");\nvar keyMirror = require(\"./keyMirror\");\nvar keyOf = require(\"./keyOf\");\nvar warning = require(\"./warning\");\n\nvar MIXINS_KEY = keyOf({mixins: null});\n\n/**\n * Policies that describe methods in `ReactClassInterface`.\n */\nvar SpecPolicy = keyMirror({\n /**\n * These methods may be defined only once by the class specification or mixin.\n */\n DEFINE_ONCE: null,\n /**\n * These methods may be defined by both the class specification and mixins.\n * Subsequent definitions will be chained. These methods must return void.\n */\n DEFINE_MANY: null,\n /**\n * These methods are overriding the base class.\n */\n OVERRIDE_BASE: null,\n /**\n * These methods are similar to DEFINE_MANY, except we assume they return\n * objects. We try to merge the keys of the return values of all the mixed in\n * functions. If there is a key conflict we throw.\n */\n DEFINE_MANY_MERGED: null\n});\n\n\nvar injectedMixins = [];\n\n/**\n * Composite components are higher-level components that compose other composite\n * or native components.\n *\n * To create a new type of `ReactClass`, pass a specification of\n * your new class to `React.createClass`. The only requirement of your class\n * specification is that you implement a `render` method.\n *\n * var MyComponent = React.createClass({\n * render: function() {\n * return
Hello World
;\n * }\n * });\n *\n * The class specification supports a specific protocol of methods that have\n * special meaning (e.g. `render`). See `ReactClassInterface` for\n * more the comprehensive protocol. Any other properties and methods in the\n * class specification will available on the prototype.\n *\n * @interface ReactClassInterface\n * @internal\n */\nvar ReactClassInterface = {\n\n /**\n * An array of Mixin objects to include when defining your component.\n *\n * @type {array}\n * @optional\n */\n mixins: SpecPolicy.DEFINE_MANY,\n\n /**\n * An object containing properties and methods that should be defined on\n * the component's constructor instead of its prototype (static methods).\n *\n * @type {object}\n * @optional\n */\n statics: SpecPolicy.DEFINE_MANY,\n\n /**\n * Definition of prop types for this component.\n *\n * @type {object}\n * @optional\n */\n propTypes: SpecPolicy.DEFINE_MANY,\n\n /**\n * Definition of context types for this component.\n *\n * @type {object}\n * @optional\n */\n contextTypes: SpecPolicy.DEFINE_MANY,\n\n /**\n * Definition of context types this component sets for its children.\n *\n * @type {object}\n * @optional\n */\n childContextTypes: SpecPolicy.DEFINE_MANY,\n\n // ==== Definition methods ====\n\n /**\n * Invoked when the component is mounted. Values in the mapping will be set on\n * `this.props` if that prop is not specified (i.e. using an `in` check).\n *\n * This method is invoked before `getInitialState` and therefore cannot rely\n * on `this.state` or use `this.setState`.\n *\n * @return {object}\n * @optional\n */\n getDefaultProps: SpecPolicy.DEFINE_MANY_MERGED,\n\n /**\n * Invoked once before the component is mounted. The return value will be used\n * as the initial value of `this.state`.\n *\n * getInitialState: function() {\n * return {\n * isOn: false,\n * fooBaz: new BazFoo()\n * }\n * }\n *\n * @return {object}\n * @optional\n */\n getInitialState: SpecPolicy.DEFINE_MANY_MERGED,\n\n /**\n * @return {object}\n * @optional\n */\n getChildContext: SpecPolicy.DEFINE_MANY_MERGED,\n\n /**\n * Uses props from `this.props` and state from `this.state` to render the\n * structure of the component.\n *\n * No guarantees are made about when or how often this method is invoked, so\n * it must not have side effects.\n *\n * render: function() {\n * var name = this.props.name;\n * return
Hello, {name}!
;\n * }\n *\n * @return {ReactComponent}\n * @nosideeffects\n * @required\n */\n render: SpecPolicy.DEFINE_ONCE,\n\n\n\n // ==== Delegate methods ====\n\n /**\n * Invoked when the component is initially created and about to be mounted.\n * This may have side effects, but any external subscriptions or data created\n * by this method must be cleaned up in `componentWillUnmount`.\n *\n * @optional\n */\n componentWillMount: SpecPolicy.DEFINE_MANY,\n\n /**\n * Invoked when the component has been mounted and has a DOM representation.\n * However, there is no guarantee that the DOM node is in the document.\n *\n * Use this as an opportunity to operate on the DOM when the component has\n * been mounted (initialized and rendered) for the first time.\n *\n * @param {DOMElement} rootNode DOM element representing the component.\n * @optional\n */\n componentDidMount: SpecPolicy.DEFINE_MANY,\n\n /**\n * Invoked before the component receives new props.\n *\n * Use this as an opportunity to react to a prop transition by updating the\n * state using `this.setState`. Current props are accessed via `this.props`.\n *\n * componentWillReceiveProps: function(nextProps, nextContext) {\n * this.setState({\n * likesIncreasing: nextProps.likeCount > this.props.likeCount\n * });\n * }\n *\n * NOTE: There is no equivalent `componentWillReceiveState`. An incoming prop\n * transition may cause a state change, but the opposite is not true. If you\n * need it, you are probably looking for `componentWillUpdate`.\n *\n * @param {object} nextProps\n * @optional\n */\n componentWillReceiveProps: SpecPolicy.DEFINE_MANY,\n\n /**\n * Invoked while deciding if the component should be updated as a result of\n * receiving new props, state and/or context.\n *\n * Use this as an opportunity to `return false` when you're certain that the\n * transition to the new props/state/context will not require a component\n * update.\n *\n * shouldComponentUpdate: function(nextProps, nextState, nextContext) {\n * return !equal(nextProps, this.props) ||\n * !equal(nextState, this.state) ||\n * !equal(nextContext, this.context);\n * }\n *\n * @param {object} nextProps\n * @param {?object} nextState\n * @param {?object} nextContext\n * @return {boolean} True if the component should update.\n * @optional\n */\n shouldComponentUpdate: SpecPolicy.DEFINE_ONCE,\n\n /**\n * Invoked when the component is about to update due to a transition from\n * `this.props`, `this.state` and `this.context` to `nextProps`, `nextState`\n * and `nextContext`.\n *\n * Use this as an opportunity to perform preparation before an update occurs.\n *\n * NOTE: You **cannot** use `this.setState()` in this method.\n *\n * @param {object} nextProps\n * @param {?object} nextState\n * @param {?object} nextContext\n * @param {ReactReconcileTransaction} transaction\n * @optional\n */\n componentWillUpdate: SpecPolicy.DEFINE_MANY,\n\n /**\n * Invoked when the component's DOM representation has been updated.\n *\n * Use this as an opportunity to operate on the DOM when the component has\n * been updated.\n *\n * @param {object} prevProps\n * @param {?object} prevState\n * @param {?object} prevContext\n * @param {DOMElement} rootNode DOM element representing the component.\n * @optional\n */\n componentDidUpdate: SpecPolicy.DEFINE_MANY,\n\n /**\n * Invoked when the component is about to be removed from its parent and have\n * its DOM representation destroyed.\n *\n * Use this as an opportunity to deallocate any external resources.\n *\n * NOTE: There is no `componentDidUnmount` since your component will have been\n * destroyed by that point.\n *\n * @optional\n */\n componentWillUnmount: SpecPolicy.DEFINE_MANY,\n\n\n\n // ==== Advanced methods ====\n\n /**\n * Updates the component's currently mounted DOM representation.\n *\n * By default, this implements React's rendering and reconciliation algorithm.\n * Sophisticated clients may wish to override this.\n *\n * @param {ReactReconcileTransaction} transaction\n * @internal\n * @overridable\n */\n updateComponent: SpecPolicy.OVERRIDE_BASE\n\n};\n\n/**\n * Mapping from class specification keys to special processing functions.\n *\n * Although these are declared like instance properties in the specification\n * when defining classes using `React.createClass`, they are actually static\n * and are accessible on the constructor instead of the prototype. Despite\n * being static, they must be defined outside of the \"statics\" key under\n * which all other static methods are defined.\n */\nvar RESERVED_SPEC_KEYS = {\n displayName: function(Constructor, displayName) {\n Constructor.displayName = displayName;\n },\n mixins: function(Constructor, mixins) {\n if (mixins) {\n for (var i = 0; i < mixins.length; i++) {\n mixSpecIntoComponent(Constructor, mixins[i]);\n }\n }\n },\n childContextTypes: function(Constructor, childContextTypes) {\n if (\"production\" !== process.env.NODE_ENV) {\n validateTypeDef(\n Constructor,\n childContextTypes,\n ReactPropTypeLocations.childContext\n );\n }\n Constructor.childContextTypes = assign(\n {},\n Constructor.childContextTypes,\n childContextTypes\n );\n },\n contextTypes: function(Constructor, contextTypes) {\n if (\"production\" !== process.env.NODE_ENV) {\n validateTypeDef(\n Constructor,\n contextTypes,\n ReactPropTypeLocations.context\n );\n }\n Constructor.contextTypes = assign(\n {},\n Constructor.contextTypes,\n contextTypes\n );\n },\n /**\n * Special case getDefaultProps which should move into statics but requires\n * automatic merging.\n */\n getDefaultProps: function(Constructor, getDefaultProps) {\n if (Constructor.getDefaultProps) {\n Constructor.getDefaultProps = createMergedResultFunction(\n Constructor.getDefaultProps,\n getDefaultProps\n );\n } else {\n Constructor.getDefaultProps = getDefaultProps;\n }\n },\n propTypes: function(Constructor, propTypes) {\n if (\"production\" !== process.env.NODE_ENV) {\n validateTypeDef(\n Constructor,\n propTypes,\n ReactPropTypeLocations.prop\n );\n }\n Constructor.propTypes = assign(\n {},\n Constructor.propTypes,\n propTypes\n );\n },\n statics: function(Constructor, statics) {\n mixStaticSpecIntoComponent(Constructor, statics);\n }\n};\n\nfunction validateTypeDef(Constructor, typeDef, location) {\n for (var propName in typeDef) {\n if (typeDef.hasOwnProperty(propName)) {\n // use a warning instead of an invariant so components\n // don't show up in prod but not in __DEV__\n (\"production\" !== process.env.NODE_ENV ? warning(\n typeof typeDef[propName] === 'function',\n '%s: %s type `%s` is invalid; it must be a function, usually from ' +\n 'React.PropTypes.',\n Constructor.displayName || 'ReactClass',\n ReactPropTypeLocationNames[location],\n propName\n ) : null);\n }\n }\n}\n\nfunction validateMethodOverride(proto, name) {\n var specPolicy = ReactClassInterface.hasOwnProperty(name) ?\n ReactClassInterface[name] :\n null;\n\n // Disallow overriding of base class methods unless explicitly allowed.\n if (ReactClassMixin.hasOwnProperty(name)) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n specPolicy === SpecPolicy.OVERRIDE_BASE,\n 'ReactClassInterface: You are attempting to override ' +\n '`%s` from your class specification. Ensure that your method names ' +\n 'do not overlap with React methods.',\n name\n ) : invariant(specPolicy === SpecPolicy.OVERRIDE_BASE));\n }\n\n // Disallow defining methods more than once unless explicitly allowed.\n if (proto.hasOwnProperty(name)) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n specPolicy === SpecPolicy.DEFINE_MANY ||\n specPolicy === SpecPolicy.DEFINE_MANY_MERGED,\n 'ReactClassInterface: You are attempting to define ' +\n '`%s` on your component more than once. This conflict may be due ' +\n 'to a mixin.',\n name\n ) : invariant(specPolicy === SpecPolicy.DEFINE_MANY ||\n specPolicy === SpecPolicy.DEFINE_MANY_MERGED));\n }\n}\n\n/**\n * Mixin helper which handles policy validation and reserved\n * specification keys when building React classses.\n */\nfunction mixSpecIntoComponent(Constructor, spec) {\n if (!spec) {\n return;\n }\n\n (\"production\" !== process.env.NODE_ENV ? invariant(\n typeof spec !== 'function',\n 'ReactClass: You\\'re attempting to ' +\n 'use a component class as a mixin. Instead, just use a regular object.'\n ) : invariant(typeof spec !== 'function'));\n (\"production\" !== process.env.NODE_ENV ? invariant(\n !ReactElement.isValidElement(spec),\n 'ReactClass: You\\'re attempting to ' +\n 'use a component as a mixin. Instead, just use a regular object.'\n ) : invariant(!ReactElement.isValidElement(spec)));\n\n var proto = Constructor.prototype;\n\n // By handling mixins before any other properties, we ensure the same\n // chaining order is applied to methods with DEFINE_MANY policy, whether\n // mixins are listed before or after these methods in the spec.\n if (spec.hasOwnProperty(MIXINS_KEY)) {\n RESERVED_SPEC_KEYS.mixins(Constructor, spec.mixins);\n }\n\n for (var name in spec) {\n if (!spec.hasOwnProperty(name)) {\n continue;\n }\n\n if (name === MIXINS_KEY) {\n // We have already handled mixins in a special case above\n continue;\n }\n\n var property = spec[name];\n validateMethodOverride(proto, name);\n\n if (RESERVED_SPEC_KEYS.hasOwnProperty(name)) {\n RESERVED_SPEC_KEYS[name](Constructor, property);\n } else {\n // Setup methods on prototype:\n // The following member methods should not be automatically bound:\n // 1. Expected ReactClass methods (in the \"interface\").\n // 2. Overridden methods (that were mixed in).\n var isReactClassMethod =\n ReactClassInterface.hasOwnProperty(name);\n var isAlreadyDefined = proto.hasOwnProperty(name);\n var markedDontBind = property && property.__reactDontBind;\n var isFunction = typeof property === 'function';\n var shouldAutoBind =\n isFunction &&\n !isReactClassMethod &&\n !isAlreadyDefined &&\n !markedDontBind;\n\n if (shouldAutoBind) {\n if (!proto.__reactAutoBindMap) {\n proto.__reactAutoBindMap = {};\n }\n proto.__reactAutoBindMap[name] = property;\n proto[name] = property;\n } else {\n if (isAlreadyDefined) {\n var specPolicy = ReactClassInterface[name];\n\n // These cases should already be caught by validateMethodOverride\n (\"production\" !== process.env.NODE_ENV ? invariant(\n isReactClassMethod && (\n (specPolicy === SpecPolicy.DEFINE_MANY_MERGED || specPolicy === SpecPolicy.DEFINE_MANY)\n ),\n 'ReactClass: Unexpected spec policy %s for key %s ' +\n 'when mixing in component specs.',\n specPolicy,\n name\n ) : invariant(isReactClassMethod && (\n (specPolicy === SpecPolicy.DEFINE_MANY_MERGED || specPolicy === SpecPolicy.DEFINE_MANY)\n )));\n\n // For methods which are defined more than once, call the existing\n // methods before calling the new property, merging if appropriate.\n if (specPolicy === SpecPolicy.DEFINE_MANY_MERGED) {\n proto[name] = createMergedResultFunction(proto[name], property);\n } else if (specPolicy === SpecPolicy.DEFINE_MANY) {\n proto[name] = createChainedFunction(proto[name], property);\n }\n } else {\n proto[name] = property;\n if (\"production\" !== process.env.NODE_ENV) {\n // Add verbose displayName to the function, which helps when looking\n // at profiling tools.\n if (typeof property === 'function' && spec.displayName) {\n proto[name].displayName = spec.displayName + '_' + name;\n }\n }\n }\n }\n }\n }\n}\n\nfunction mixStaticSpecIntoComponent(Constructor, statics) {\n if (!statics) {\n return;\n }\n for (var name in statics) {\n var property = statics[name];\n if (!statics.hasOwnProperty(name)) {\n continue;\n }\n\n var isReserved = name in RESERVED_SPEC_KEYS;\n (\"production\" !== process.env.NODE_ENV ? invariant(\n !isReserved,\n 'ReactClass: You are attempting to define a reserved ' +\n 'property, `%s`, that shouldn\\'t be on the \"statics\" key. Define it ' +\n 'as an instance property instead; it will still be accessible on the ' +\n 'constructor.',\n name\n ) : invariant(!isReserved));\n\n var isInherited = name in Constructor;\n (\"production\" !== process.env.NODE_ENV ? invariant(\n !isInherited,\n 'ReactClass: You are attempting to define ' +\n '`%s` on your component more than once. This conflict may be ' +\n 'due to a mixin.',\n name\n ) : invariant(!isInherited));\n Constructor[name] = property;\n }\n}\n\n/**\n * Merge two objects, but throw if both contain the same key.\n *\n * @param {object} one The first object, which is mutated.\n * @param {object} two The second object\n * @return {object} one after it has been mutated to contain everything in two.\n */\nfunction mergeIntoWithNoDuplicateKeys(one, two) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n one && two && typeof one === 'object' && typeof two === 'object',\n 'mergeIntoWithNoDuplicateKeys(): Cannot merge non-objects.'\n ) : invariant(one && two && typeof one === 'object' && typeof two === 'object'));\n\n for (var key in two) {\n if (two.hasOwnProperty(key)) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n one[key] === undefined,\n 'mergeIntoWithNoDuplicateKeys(): ' +\n 'Tried to merge two objects with the same key: `%s`. This conflict ' +\n 'may be due to a mixin; in particular, this may be caused by two ' +\n 'getInitialState() or getDefaultProps() methods returning objects ' +\n 'with clashing keys.',\n key\n ) : invariant(one[key] === undefined));\n one[key] = two[key];\n }\n }\n return one;\n}\n\n/**\n * Creates a function that invokes two functions and merges their return values.\n *\n * @param {function} one Function to invoke first.\n * @param {function} two Function to invoke second.\n * @return {function} Function that invokes the two argument functions.\n * @private\n */\nfunction createMergedResultFunction(one, two) {\n return function mergedResult() {\n var a = one.apply(this, arguments);\n var b = two.apply(this, arguments);\n if (a == null) {\n return b;\n } else if (b == null) {\n return a;\n }\n var c = {};\n mergeIntoWithNoDuplicateKeys(c, a);\n mergeIntoWithNoDuplicateKeys(c, b);\n return c;\n };\n}\n\n/**\n * Creates a function that invokes two functions and ignores their return vales.\n *\n * @param {function} one Function to invoke first.\n * @param {function} two Function to invoke second.\n * @return {function} Function that invokes the two argument functions.\n * @private\n */\nfunction createChainedFunction(one, two) {\n return function chainedFunction() {\n one.apply(this, arguments);\n two.apply(this, arguments);\n };\n}\n\n/**\n * Binds a method to the component.\n *\n * @param {object} component Component whose method is going to be bound.\n * @param {function} method Method to be bound.\n * @return {function} The bound method.\n */\nfunction bindAutoBindMethod(component, method) {\n var boundMethod = method.bind(component);\n if (\"production\" !== process.env.NODE_ENV) {\n boundMethod.__reactBoundContext = component;\n boundMethod.__reactBoundMethod = method;\n boundMethod.__reactBoundArguments = null;\n var componentName = component.constructor.displayName;\n var _bind = boundMethod.bind;\n /* eslint-disable block-scoped-var, no-undef */\n boundMethod.bind = function(newThis ) {for (var args=[],$__0=1,$__1=arguments.length;$__0<$__1;$__0++) args.push(arguments[$__0]);\n // User is trying to bind() an autobound method; we effectively will\n // ignore the value of \"this\" that the user is trying to use, so\n // let's warn.\n if (newThis !== component && newThis !== null) {\n (\"production\" !== process.env.NODE_ENV ? warning(\n false,\n 'bind(): React component methods may only be bound to the ' +\n 'component instance. See %s',\n componentName\n ) : null);\n } else if (!args.length) {\n (\"production\" !== process.env.NODE_ENV ? warning(\n false,\n 'bind(): You are binding a component method to the component. ' +\n 'React does this for you automatically in a high-performance ' +\n 'way, so you can safely remove this call. See %s',\n componentName\n ) : null);\n return boundMethod;\n }\n var reboundMethod = _bind.apply(boundMethod, arguments);\n reboundMethod.__reactBoundContext = component;\n reboundMethod.__reactBoundMethod = method;\n reboundMethod.__reactBoundArguments = args;\n return reboundMethod;\n /* eslint-enable */\n };\n }\n return boundMethod;\n}\n\n/**\n * Binds all auto-bound methods in a component.\n *\n * @param {object} component Component whose method is going to be bound.\n */\nfunction bindAutoBindMethods(component) {\n for (var autoBindKey in component.__reactAutoBindMap) {\n if (component.__reactAutoBindMap.hasOwnProperty(autoBindKey)) {\n var method = component.__reactAutoBindMap[autoBindKey];\n component[autoBindKey] = bindAutoBindMethod(\n component,\n ReactErrorUtils.guard(\n method,\n component.constructor.displayName + '.' + autoBindKey\n )\n );\n }\n }\n}\n\nvar typeDeprecationDescriptor = {\n enumerable: false,\n get: function() {\n var displayName = this.displayName || this.name || 'Component';\n (\"production\" !== process.env.NODE_ENV ? warning(\n false,\n '%s.type is deprecated. Use %s directly to access the class.',\n displayName,\n displayName\n ) : null);\n Object.defineProperty(this, 'type', {\n value: this\n });\n return this;\n }\n};\n\n/**\n * Add more to the ReactClass base class. These are all legacy features and\n * therefore not already part of the modern ReactComponent.\n */\nvar ReactClassMixin = {\n\n /**\n * TODO: This will be deprecated because state should always keep a consistent\n * type signature and the only use case for this, is to avoid that.\n */\n replaceState: function(newState, callback) {\n ReactUpdateQueue.enqueueReplaceState(this, newState);\n if (callback) {\n ReactUpdateQueue.enqueueCallback(this, callback);\n }\n },\n\n /**\n * Checks whether or not this composite component is mounted.\n * @return {boolean} True if mounted, false otherwise.\n * @protected\n * @final\n */\n isMounted: function() {\n if (\"production\" !== process.env.NODE_ENV) {\n var owner = ReactCurrentOwner.current;\n if (owner !== null) {\n (\"production\" !== process.env.NODE_ENV ? warning(\n owner._warnedAboutRefsInRender,\n '%s is accessing isMounted inside its render() function. ' +\n 'render() should be a pure function of props and state. It should ' +\n 'never access something that requires stale data from the previous ' +\n 'render, such as refs. Move this logic to componentDidMount and ' +\n 'componentDidUpdate instead.',\n owner.getName() || 'A component'\n ) : null);\n owner._warnedAboutRefsInRender = true;\n }\n }\n var internalInstance = ReactInstanceMap.get(this);\n return (\n internalInstance &&\n internalInstance !== ReactLifeCycle.currentlyMountingInstance\n );\n },\n\n /**\n * Sets a subset of the props.\n *\n * @param {object} partialProps Subset of the next props.\n * @param {?function} callback Called after props are updated.\n * @final\n * @public\n * @deprecated\n */\n setProps: function(partialProps, callback) {\n ReactUpdateQueue.enqueueSetProps(this, partialProps);\n if (callback) {\n ReactUpdateQueue.enqueueCallback(this, callback);\n }\n },\n\n /**\n * Replace all the props.\n *\n * @param {object} newProps Subset of the next props.\n * @param {?function} callback Called after props are updated.\n * @final\n * @public\n * @deprecated\n */\n replaceProps: function(newProps, callback) {\n ReactUpdateQueue.enqueueReplaceProps(this, newProps);\n if (callback) {\n ReactUpdateQueue.enqueueCallback(this, callback);\n }\n }\n};\n\nvar ReactClassComponent = function() {};\nassign(\n ReactClassComponent.prototype,\n ReactComponent.prototype,\n ReactClassMixin\n);\n\n/**\n * Module for creating composite components.\n *\n * @class ReactClass\n */\nvar ReactClass = {\n\n /**\n * Creates a composite component class given a class specification.\n *\n * @param {object} spec Class specification (which must define `render`).\n * @return {function} Component constructor function.\n * @public\n */\n createClass: function(spec) {\n var Constructor = function(props, context) {\n // This constructor is overridden by mocks. The argument is used\n // by mocks to assert on what gets mounted.\n\n if (\"production\" !== process.env.NODE_ENV) {\n (\"production\" !== process.env.NODE_ENV ? warning(\n this instanceof Constructor,\n 'Something is calling a React component directly. Use a factory or ' +\n 'JSX instead. See: https://fb.me/react-legacyfactory'\n ) : null);\n }\n\n // Wire up auto-binding\n if (this.__reactAutoBindMap) {\n bindAutoBindMethods(this);\n }\n\n this.props = props;\n this.context = context;\n this.state = null;\n\n // ReactClasses doesn't have constructors. Instead, they use the\n // getInitialState and componentWillMount methods for initialization.\n\n var initialState = this.getInitialState ? this.getInitialState() : null;\n if (\"production\" !== process.env.NODE_ENV) {\n // We allow auto-mocks to proceed as if they're returning null.\n if (typeof initialState === 'undefined' &&\n this.getInitialState._isMockFunction) {\n // This is probably bad practice. Consider warning here and\n // deprecating this convenience.\n initialState = null;\n }\n }\n (\"production\" !== process.env.NODE_ENV ? invariant(\n typeof initialState === 'object' && !Array.isArray(initialState),\n '%s.getInitialState(): must return an object or null',\n Constructor.displayName || 'ReactCompositeComponent'\n ) : invariant(typeof initialState === 'object' && !Array.isArray(initialState)));\n\n this.state = initialState;\n };\n Constructor.prototype = new ReactClassComponent();\n Constructor.prototype.constructor = Constructor;\n\n injectedMixins.forEach(\n mixSpecIntoComponent.bind(null, Constructor)\n );\n\n mixSpecIntoComponent(Constructor, spec);\n\n // Initialize the defaultProps property after all mixins have been merged\n if (Constructor.getDefaultProps) {\n Constructor.defaultProps = Constructor.getDefaultProps();\n }\n\n if (\"production\" !== process.env.NODE_ENV) {\n // This is a tag to indicate that the use of these method names is ok,\n // since it's used with createClass. If it's not, then it's likely a\n // mistake so we'll warn you to use the static property, property\n // initializer or constructor respectively.\n if (Constructor.getDefaultProps) {\n Constructor.getDefaultProps.isReactClassApproved = {};\n }\n if (Constructor.prototype.getInitialState) {\n Constructor.prototype.getInitialState.isReactClassApproved = {};\n }\n }\n\n (\"production\" !== process.env.NODE_ENV ? invariant(\n Constructor.prototype.render,\n 'createClass(...): Class specification must implement a `render` method.'\n ) : invariant(Constructor.prototype.render));\n\n if (\"production\" !== process.env.NODE_ENV) {\n (\"production\" !== process.env.NODE_ENV ? warning(\n !Constructor.prototype.componentShouldUpdate,\n '%s has a method called ' +\n 'componentShouldUpdate(). Did you mean shouldComponentUpdate()? ' +\n 'The name is phrased as a question because the function is ' +\n 'expected to return a value.',\n spec.displayName || 'A component'\n ) : null);\n }\n\n // Reduce time spent doing lookups by setting these on the prototype.\n for (var methodName in ReactClassInterface) {\n if (!Constructor.prototype[methodName]) {\n Constructor.prototype[methodName] = null;\n }\n }\n\n // Legacy hook\n Constructor.type = Constructor;\n if (\"production\" !== process.env.NODE_ENV) {\n try {\n Object.defineProperty(Constructor, 'type', typeDeprecationDescriptor);\n } catch (x) {\n // IE will fail on defineProperty (es5-shim/sham too)\n }\n }\n\n return Constructor;\n },\n\n injection: {\n injectMixin: function(mixin) {\n injectedMixins.push(mixin);\n }\n }\n\n};\n\nmodule.exports = ReactClass;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactClass.js\n ** module id = 42\n ** module chunks = 0\n **/","/**\n * Copyright 2013-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule ReactErrorUtils\n * @typechecks\n */\n\n\"use strict\";\n\nvar ReactErrorUtils = {\n /**\n * Creates a guarded version of a function. This is supposed to make debugging\n * of event handlers easier. To aid debugging with the browser's debugger,\n * this currently simply returns the original function.\n *\n * @param {function} func Function to be executed\n * @param {string} name The name of the guard\n * @return {function}\n */\n guard: function(func, name) {\n return func;\n }\n};\n\nmodule.exports = ReactErrorUtils;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactErrorUtils.js\n ** module id = 43\n ** module chunks = 0\n **/","/**\n * Copyright 2013-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule keyOf\n */\n\n/**\n * Allows extraction of a minified key. Let's the build system minify keys\n * without loosing the ability to dynamically use key strings as values\n * themselves. Pass in an object with a single key/val pair and it will return\n * you the string key of that single record. Suppose you want to grab the\n * value for a key 'className' inside of an object. Key/val minification may\n * have aliased that key to be 'xa12'. keyOf({className: null}) will return\n * 'xa12' in that case. Resolve keys you want to use once at startup time, then\n * reuse those resolutions.\n */\nvar keyOf = function(oneKeyObj) {\n var key;\n for (key in oneKeyObj) {\n if (!oneKeyObj.hasOwnProperty(key)) {\n continue;\n }\n return key;\n }\n return null;\n};\n\n\nmodule.exports = keyOf;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/keyOf.js\n ** module id = 44\n ** module chunks = 0\n **/","/**\n * Copyright 2013-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule ReactDOM\n * @typechecks static-only\n */\n\n'use strict';\n\nvar ReactElement = require(\"./ReactElement\");\nvar ReactElementValidator = require(\"./ReactElementValidator\");\n\nvar mapObject = require(\"./mapObject\");\n\n/**\n * Create a factory that creates HTML tag elements.\n *\n * @param {string} tag Tag name (e.g. `div`).\n * @private\n */\nfunction createDOMFactory(tag) {\n if (\"production\" !== process.env.NODE_ENV) {\n return ReactElementValidator.createFactory(tag);\n }\n return ReactElement.createFactory(tag);\n}\n\n/**\n * Creates a mapping from supported HTML tags to `ReactDOMComponent` classes.\n * This is also accessible via `React.DOM`.\n *\n * @public\n */\nvar ReactDOM = mapObject({\n a: 'a',\n abbr: 'abbr',\n address: 'address',\n area: 'area',\n article: 'article',\n aside: 'aside',\n audio: 'audio',\n b: 'b',\n base: 'base',\n bdi: 'bdi',\n bdo: 'bdo',\n big: 'big',\n blockquote: 'blockquote',\n body: 'body',\n br: 'br',\n button: 'button',\n canvas: 'canvas',\n caption: 'caption',\n cite: 'cite',\n code: 'code',\n col: 'col',\n colgroup: 'colgroup',\n data: 'data',\n datalist: 'datalist',\n dd: 'dd',\n del: 'del',\n details: 'details',\n dfn: 'dfn',\n dialog: 'dialog',\n div: 'div',\n dl: 'dl',\n dt: 'dt',\n em: 'em',\n embed: 'embed',\n fieldset: 'fieldset',\n figcaption: 'figcaption',\n figure: 'figure',\n footer: 'footer',\n form: 'form',\n h1: 'h1',\n h2: 'h2',\n h3: 'h3',\n h4: 'h4',\n h5: 'h5',\n h6: 'h6',\n head: 'head',\n header: 'header',\n hr: 'hr',\n html: 'html',\n i: 'i',\n iframe: 'iframe',\n img: 'img',\n input: 'input',\n ins: 'ins',\n kbd: 'kbd',\n keygen: 'keygen',\n label: 'label',\n legend: 'legend',\n li: 'li',\n link: 'link',\n main: 'main',\n map: 'map',\n mark: 'mark',\n menu: 'menu',\n menuitem: 'menuitem',\n meta: 'meta',\n meter: 'meter',\n nav: 'nav',\n noscript: 'noscript',\n object: 'object',\n ol: 'ol',\n optgroup: 'optgroup',\n option: 'option',\n output: 'output',\n p: 'p',\n param: 'param',\n picture: 'picture',\n pre: 'pre',\n progress: 'progress',\n q: 'q',\n rp: 'rp',\n rt: 'rt',\n ruby: 'ruby',\n s: 's',\n samp: 'samp',\n script: 'script',\n section: 'section',\n select: 'select',\n small: 'small',\n source: 'source',\n span: 'span',\n strong: 'strong',\n style: 'style',\n sub: 'sub',\n summary: 'summary',\n sup: 'sup',\n table: 'table',\n tbody: 'tbody',\n td: 'td',\n textarea: 'textarea',\n tfoot: 'tfoot',\n th: 'th',\n thead: 'thead',\n time: 'time',\n title: 'title',\n tr: 'tr',\n track: 'track',\n u: 'u',\n ul: 'ul',\n 'var': 'var',\n video: 'video',\n wbr: 'wbr',\n\n // SVG\n circle: 'circle',\n clipPath: 'clipPath',\n defs: 'defs',\n ellipse: 'ellipse',\n g: 'g',\n line: 'line',\n linearGradient: 'linearGradient',\n mask: 'mask',\n path: 'path',\n pattern: 'pattern',\n polygon: 'polygon',\n polyline: 'polyline',\n radialGradient: 'radialGradient',\n rect: 'rect',\n stop: 'stop',\n svg: 'svg',\n text: 'text',\n tspan: 'tspan'\n\n}, createDOMFactory);\n\nmodule.exports = ReactDOM;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactDOM.js\n ** module id = 45\n ** module chunks = 0\n **/","/**\n * Copyright 2013-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule mapObject\n */\n\n'use strict';\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\n/**\n * Executes the provided `callback` once for each enumerable own property in the\n * object and constructs a new object from the results. The `callback` is\n * invoked with three arguments:\n *\n * - the property value\n * - the property name\n * - the object being traversed\n *\n * Properties that are added after the call to `mapObject` will not be visited\n * by `callback`. If the values of existing properties are changed, the value\n * passed to `callback` will be the value at the time `mapObject` visits them.\n * Properties that are deleted before being visited are not visited.\n *\n * @grep function objectMap()\n * @grep function objMap()\n *\n * @param {?object} object\n * @param {function} callback\n * @param {*} context\n * @return {?object}\n */\nfunction mapObject(object, callback, context) {\n if (!object) {\n return null;\n }\n var result = {};\n for (var name in object) {\n if (hasOwnProperty.call(object, name)) {\n result[name] = callback.call(context, object[name], name, object);\n }\n }\n return result;\n}\n\nmodule.exports = mapObject;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/mapObject.js\n ** module id = 46\n ** module chunks = 0\n **/","/**\n * Copyright 2013-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule ReactDOMTextComponent\n * @typechecks static-only\n */\n\n'use strict';\n\nvar DOMPropertyOperations = require(\"./DOMPropertyOperations\");\nvar ReactComponentBrowserEnvironment =\n require(\"./ReactComponentBrowserEnvironment\");\nvar ReactDOMComponent = require(\"./ReactDOMComponent\");\n\nvar assign = require(\"./Object.assign\");\nvar escapeTextContentForBrowser = require(\"./escapeTextContentForBrowser\");\n\n/**\n * Text nodes violate a couple assumptions that React makes about components:\n *\n * - When mounting text into the DOM, adjacent text nodes are merged.\n * - Text nodes cannot be assigned a React root ID.\n *\n * This component is used to wrap strings in elements so that they can undergo\n * the same reconciliation that is applied to elements.\n *\n * TODO: Investigate representing React components in the DOM with text nodes.\n *\n * @class ReactDOMTextComponent\n * @extends ReactComponent\n * @internal\n */\nvar ReactDOMTextComponent = function(props) {\n // This constructor and its argument is currently used by mocks.\n};\n\nassign(ReactDOMTextComponent.prototype, {\n\n /**\n * @param {ReactText} text\n * @internal\n */\n construct: function(text) {\n // TODO: This is really a ReactText (ReactNode), not a ReactElement\n this._currentElement = text;\n this._stringText = '' + text;\n\n // Properties\n this._rootNodeID = null;\n this._mountIndex = 0;\n },\n\n /**\n * Creates the markup for this text node. This node is not intended to have\n * any features besides containing text content.\n *\n * @param {string} rootID DOM ID of the root node.\n * @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction\n * @return {string} Markup for this text node.\n * @internal\n */\n mountComponent: function(rootID, transaction, context) {\n this._rootNodeID = rootID;\n var escapedText = escapeTextContentForBrowser(this._stringText);\n\n if (transaction.renderToStaticMarkup) {\n // Normally we'd wrap this in a `span` for the reasons stated above, but\n // since this is a situation where React won't take over (static pages),\n // we can simply return the text as it is.\n return escapedText;\n }\n\n return (\n '' +\n escapedText +\n ''\n );\n },\n\n /**\n * Updates this component by updating the text content.\n *\n * @param {ReactText} nextText The next text content\n * @param {ReactReconcileTransaction} transaction\n * @internal\n */\n receiveComponent: function(nextText, transaction) {\n if (nextText !== this._currentElement) {\n this._currentElement = nextText;\n var nextStringText = '' + nextText;\n if (nextStringText !== this._stringText) {\n // TODO: Save this as pending props and use performUpdateIfNecessary\n // and/or updateComponent to do the actual update for consistency with\n // other component types?\n this._stringText = nextStringText;\n ReactDOMComponent.BackendIDOperations.updateTextContentByID(\n this._rootNodeID,\n nextStringText\n );\n }\n }\n },\n\n unmountComponent: function() {\n ReactComponentBrowserEnvironment.unmountIDFromEnvironment(this._rootNodeID);\n }\n\n});\n\nmodule.exports = ReactDOMTextComponent;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactDOMTextComponent.js\n ** module id = 47\n ** module chunks = 0\n **/","/**\n * Copyright 2013-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DOMPropertyOperations\n * @typechecks static-only\n */\n\n'use strict';\n\nvar DOMProperty = require(\"./DOMProperty\");\n\nvar quoteAttributeValueForBrowser = require(\"./quoteAttributeValueForBrowser\");\nvar warning = require(\"./warning\");\n\nfunction shouldIgnoreValue(name, value) {\n return value == null ||\n (DOMProperty.hasBooleanValue[name] && !value) ||\n (DOMProperty.hasNumericValue[name] && isNaN(value)) ||\n (DOMProperty.hasPositiveNumericValue[name] && (value < 1)) ||\n (DOMProperty.hasOverloadedBooleanValue[name] && value === false);\n}\n\nif (\"production\" !== process.env.NODE_ENV) {\n var reactProps = {\n children: true,\n dangerouslySetInnerHTML: true,\n key: true,\n ref: true\n };\n var warnedProperties = {};\n\n var warnUnknownProperty = function(name) {\n if (reactProps.hasOwnProperty(name) && reactProps[name] ||\n warnedProperties.hasOwnProperty(name) && warnedProperties[name]) {\n return;\n }\n\n warnedProperties[name] = true;\n var lowerCasedName = name.toLowerCase();\n\n // data-* attributes should be lowercase; suggest the lowercase version\n var standardName = (\n DOMProperty.isCustomAttribute(lowerCasedName) ?\n lowerCasedName :\n DOMProperty.getPossibleStandardName.hasOwnProperty(lowerCasedName) ?\n DOMProperty.getPossibleStandardName[lowerCasedName] :\n null\n );\n\n // For now, only warn when we have a suggested correction. This prevents\n // logging too much when using transferPropsTo.\n (\"production\" !== process.env.NODE_ENV ? warning(\n standardName == null,\n 'Unknown DOM property %s. Did you mean %s?',\n name,\n standardName\n ) : null);\n\n };\n}\n\n/**\n * Operations for dealing with DOM properties.\n */\nvar DOMPropertyOperations = {\n\n /**\n * Creates markup for the ID property.\n *\n * @param {string} id Unescaped ID.\n * @return {string} Markup string.\n */\n createMarkupForID: function(id) {\n return DOMProperty.ID_ATTRIBUTE_NAME + '=' +\n quoteAttributeValueForBrowser(id);\n },\n\n /**\n * Creates markup for a property.\n *\n * @param {string} name\n * @param {*} value\n * @return {?string} Markup string, or null if the property was invalid.\n */\n createMarkupForProperty: function(name, value) {\n if (DOMProperty.isStandardName.hasOwnProperty(name) &&\n DOMProperty.isStandardName[name]) {\n if (shouldIgnoreValue(name, value)) {\n return '';\n }\n var attributeName = DOMProperty.getAttributeName[name];\n if (DOMProperty.hasBooleanValue[name] ||\n (DOMProperty.hasOverloadedBooleanValue[name] && value === true)) {\n return attributeName;\n }\n return attributeName + '=' + quoteAttributeValueForBrowser(value);\n } else if (DOMProperty.isCustomAttribute(name)) {\n if (value == null) {\n return '';\n }\n return name + '=' + quoteAttributeValueForBrowser(value);\n } else if (\"production\" !== process.env.NODE_ENV) {\n warnUnknownProperty(name);\n }\n return null;\n },\n\n /**\n * Sets the value for a property on a node.\n *\n * @param {DOMElement} node\n * @param {string} name\n * @param {*} value\n */\n setValueForProperty: function(node, name, value) {\n if (DOMProperty.isStandardName.hasOwnProperty(name) &&\n DOMProperty.isStandardName[name]) {\n var mutationMethod = DOMProperty.getMutationMethod[name];\n if (mutationMethod) {\n mutationMethod(node, value);\n } else if (shouldIgnoreValue(name, value)) {\n this.deleteValueForProperty(node, name);\n } else if (DOMProperty.mustUseAttribute[name]) {\n // `setAttribute` with objects becomes only `[object]` in IE8/9,\n // ('' + value) makes it output the correct toString()-value.\n node.setAttribute(DOMProperty.getAttributeName[name], '' + value);\n } else {\n var propName = DOMProperty.getPropertyName[name];\n // Must explicitly cast values for HAS_SIDE_EFFECTS-properties to the\n // property type before comparing; only `value` does and is string.\n if (!DOMProperty.hasSideEffects[name] ||\n ('' + node[propName]) !== ('' + value)) {\n // Contrary to `setAttribute`, object properties are properly\n // `toString`ed by IE8/9.\n node[propName] = value;\n }\n }\n } else if (DOMProperty.isCustomAttribute(name)) {\n if (value == null) {\n node.removeAttribute(name);\n } else {\n node.setAttribute(name, '' + value);\n }\n } else if (\"production\" !== process.env.NODE_ENV) {\n warnUnknownProperty(name);\n }\n },\n\n /**\n * Deletes the value for a property on a node.\n *\n * @param {DOMElement} node\n * @param {string} name\n */\n deleteValueForProperty: function(node, name) {\n if (DOMProperty.isStandardName.hasOwnProperty(name) &&\n DOMProperty.isStandardName[name]) {\n var mutationMethod = DOMProperty.getMutationMethod[name];\n if (mutationMethod) {\n mutationMethod(node, undefined);\n } else if (DOMProperty.mustUseAttribute[name]) {\n node.removeAttribute(DOMProperty.getAttributeName[name]);\n } else {\n var propName = DOMProperty.getPropertyName[name];\n var defaultValue = DOMProperty.getDefaultValueForProperty(\n node.nodeName,\n propName\n );\n if (!DOMProperty.hasSideEffects[name] ||\n ('' + node[propName]) !== defaultValue) {\n node[propName] = defaultValue;\n }\n }\n } else if (DOMProperty.isCustomAttribute(name)) {\n node.removeAttribute(name);\n } else if (\"production\" !== process.env.NODE_ENV) {\n warnUnknownProperty(name);\n }\n }\n\n};\n\nmodule.exports = DOMPropertyOperations;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/DOMPropertyOperations.js\n ** module id = 48\n ** module chunks = 0\n **/","/**\n * Copyright 2013-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule DOMProperty\n * @typechecks static-only\n */\n\n/*jslint bitwise: true */\n\n'use strict';\n\nvar invariant = require(\"./invariant\");\n\nfunction checkMask(value, bitmask) {\n return (value & bitmask) === bitmask;\n}\n\nvar DOMPropertyInjection = {\n /**\n * Mapping from normalized, camelcased property names to a configuration that\n * specifies how the associated DOM property should be accessed or rendered.\n */\n MUST_USE_ATTRIBUTE: 0x1,\n MUST_USE_PROPERTY: 0x2,\n HAS_SIDE_EFFECTS: 0x4,\n HAS_BOOLEAN_VALUE: 0x8,\n HAS_NUMERIC_VALUE: 0x10,\n HAS_POSITIVE_NUMERIC_VALUE: 0x20 | 0x10,\n HAS_OVERLOADED_BOOLEAN_VALUE: 0x40,\n\n /**\n * Inject some specialized knowledge about the DOM. This takes a config object\n * with the following properties:\n *\n * isCustomAttribute: function that given an attribute name will return true\n * if it can be inserted into the DOM verbatim. Useful for data-* or aria-*\n * attributes where it's impossible to enumerate all of the possible\n * attribute names,\n *\n * Properties: object mapping DOM property name to one of the\n * DOMPropertyInjection constants or null. If your attribute isn't in here,\n * it won't get written to the DOM.\n *\n * DOMAttributeNames: object mapping React attribute name to the DOM\n * attribute name. Attribute names not specified use the **lowercase**\n * normalized name.\n *\n * DOMPropertyNames: similar to DOMAttributeNames but for DOM properties.\n * Property names not specified use the normalized name.\n *\n * DOMMutationMethods: Properties that require special mutation methods. If\n * `value` is undefined, the mutation method should unset the property.\n *\n * @param {object} domPropertyConfig the config as described above.\n */\n injectDOMPropertyConfig: function(domPropertyConfig) {\n var Properties = domPropertyConfig.Properties || {};\n var DOMAttributeNames = domPropertyConfig.DOMAttributeNames || {};\n var DOMPropertyNames = domPropertyConfig.DOMPropertyNames || {};\n var DOMMutationMethods = domPropertyConfig.DOMMutationMethods || {};\n\n if (domPropertyConfig.isCustomAttribute) {\n DOMProperty._isCustomAttributeFunctions.push(\n domPropertyConfig.isCustomAttribute\n );\n }\n\n for (var propName in Properties) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n !DOMProperty.isStandardName.hasOwnProperty(propName),\n 'injectDOMPropertyConfig(...): You\\'re trying to inject DOM property ' +\n '\\'%s\\' which has already been injected. You may be accidentally ' +\n 'injecting the same DOM property config twice, or you may be ' +\n 'injecting two configs that have conflicting property names.',\n propName\n ) : invariant(!DOMProperty.isStandardName.hasOwnProperty(propName)));\n\n DOMProperty.isStandardName[propName] = true;\n\n var lowerCased = propName.toLowerCase();\n DOMProperty.getPossibleStandardName[lowerCased] = propName;\n\n if (DOMAttributeNames.hasOwnProperty(propName)) {\n var attributeName = DOMAttributeNames[propName];\n DOMProperty.getPossibleStandardName[attributeName] = propName;\n DOMProperty.getAttributeName[propName] = attributeName;\n } else {\n DOMProperty.getAttributeName[propName] = lowerCased;\n }\n\n DOMProperty.getPropertyName[propName] =\n DOMPropertyNames.hasOwnProperty(propName) ?\n DOMPropertyNames[propName] :\n propName;\n\n if (DOMMutationMethods.hasOwnProperty(propName)) {\n DOMProperty.getMutationMethod[propName] = DOMMutationMethods[propName];\n } else {\n DOMProperty.getMutationMethod[propName] = null;\n }\n\n var propConfig = Properties[propName];\n DOMProperty.mustUseAttribute[propName] =\n checkMask(propConfig, DOMPropertyInjection.MUST_USE_ATTRIBUTE);\n DOMProperty.mustUseProperty[propName] =\n checkMask(propConfig, DOMPropertyInjection.MUST_USE_PROPERTY);\n DOMProperty.hasSideEffects[propName] =\n checkMask(propConfig, DOMPropertyInjection.HAS_SIDE_EFFECTS);\n DOMProperty.hasBooleanValue[propName] =\n checkMask(propConfig, DOMPropertyInjection.HAS_BOOLEAN_VALUE);\n DOMProperty.hasNumericValue[propName] =\n checkMask(propConfig, DOMPropertyInjection.HAS_NUMERIC_VALUE);\n DOMProperty.hasPositiveNumericValue[propName] =\n checkMask(propConfig, DOMPropertyInjection.HAS_POSITIVE_NUMERIC_VALUE);\n DOMProperty.hasOverloadedBooleanValue[propName] =\n checkMask(propConfig, DOMPropertyInjection.HAS_OVERLOADED_BOOLEAN_VALUE);\n\n (\"production\" !== process.env.NODE_ENV ? invariant(\n !DOMProperty.mustUseAttribute[propName] ||\n !DOMProperty.mustUseProperty[propName],\n 'DOMProperty: Cannot require using both attribute and property: %s',\n propName\n ) : invariant(!DOMProperty.mustUseAttribute[propName] ||\n !DOMProperty.mustUseProperty[propName]));\n (\"production\" !== process.env.NODE_ENV ? invariant(\n DOMProperty.mustUseProperty[propName] ||\n !DOMProperty.hasSideEffects[propName],\n 'DOMProperty: Properties that have side effects must use property: %s',\n propName\n ) : invariant(DOMProperty.mustUseProperty[propName] ||\n !DOMProperty.hasSideEffects[propName]));\n (\"production\" !== process.env.NODE_ENV ? invariant(\n !!DOMProperty.hasBooleanValue[propName] +\n !!DOMProperty.hasNumericValue[propName] +\n !!DOMProperty.hasOverloadedBooleanValue[propName] <= 1,\n 'DOMProperty: Value can be one of boolean, overloaded boolean, or ' +\n 'numeric value, but not a combination: %s',\n propName\n ) : invariant(!!DOMProperty.hasBooleanValue[propName] +\n !!DOMProperty.hasNumericValue[propName] +\n !!DOMProperty.hasOverloadedBooleanValue[propName] <= 1));\n }\n }\n};\nvar defaultValueCache = {};\n\n/**\n * DOMProperty exports lookup objects that can be used like functions:\n *\n * > DOMProperty.isValid['id']\n * true\n * > DOMProperty.isValid['foobar']\n * undefined\n *\n * Although this may be confusing, it performs better in general.\n *\n * @see http://jsperf.com/key-exists\n * @see http://jsperf.com/key-missing\n */\nvar DOMProperty = {\n\n ID_ATTRIBUTE_NAME: 'data-reactid',\n\n /**\n * Checks whether a property name is a standard property.\n * @type {Object}\n */\n isStandardName: {},\n\n /**\n * Mapping from lowercase property names to the properly cased version, used\n * to warn in the case of missing properties.\n * @type {Object}\n */\n getPossibleStandardName: {},\n\n /**\n * Mapping from normalized names to attribute names that differ. Attribute\n * names are used when rendering markup or with `*Attribute()`.\n * @type {Object}\n */\n getAttributeName: {},\n\n /**\n * Mapping from normalized names to properties on DOM node instances.\n * (This includes properties that mutate due to external factors.)\n * @type {Object}\n */\n getPropertyName: {},\n\n /**\n * Mapping from normalized names to mutation methods. This will only exist if\n * mutation cannot be set simply by the property or `setAttribute()`.\n * @type {Object}\n */\n getMutationMethod: {},\n\n /**\n * Whether the property must be accessed and mutated as an object property.\n * @type {Object}\n */\n mustUseAttribute: {},\n\n /**\n * Whether the property must be accessed and mutated using `*Attribute()`.\n * (This includes anything that fails ` in `.)\n * @type {Object}\n */\n mustUseProperty: {},\n\n /**\n * Whether or not setting a value causes side effects such as triggering\n * resources to be loaded or text selection changes. We must ensure that\n * the value is only set if it has changed.\n * @type {Object}\n */\n hasSideEffects: {},\n\n /**\n * Whether the property should be removed when set to a falsey value.\n * @type {Object}\n */\n hasBooleanValue: {},\n\n /**\n * Whether the property must be numeric or parse as a\n * numeric and should be removed when set to a falsey value.\n * @type {Object}\n */\n hasNumericValue: {},\n\n /**\n * Whether the property must be positive numeric or parse as a positive\n * numeric and should be removed when set to a falsey value.\n * @type {Object}\n */\n hasPositiveNumericValue: {},\n\n /**\n * Whether the property can be used as a flag as well as with a value. Removed\n * when strictly equal to false; present without a value when strictly equal\n * to true; present with a value otherwise.\n * @type {Object}\n */\n hasOverloadedBooleanValue: {},\n\n /**\n * All of the isCustomAttribute() functions that have been injected.\n */\n _isCustomAttributeFunctions: [],\n\n /**\n * Checks whether a property name is a custom attribute.\n * @method\n */\n isCustomAttribute: function(attributeName) {\n for (var i = 0; i < DOMProperty._isCustomAttributeFunctions.length; i++) {\n var isCustomAttributeFn = DOMProperty._isCustomAttributeFunctions[i];\n if (isCustomAttributeFn(attributeName)) {\n return true;\n }\n }\n return false;\n },\n\n /**\n * Returns the default property value for a DOM property (i.e., not an\n * attribute). Most default values are '' or false, but not all. Worse yet,\n * some (in particular, `type`) vary depending on the type of element.\n *\n * TODO: Is it better to grab all the possible properties when creating an\n * element to avoid having to create the same element twice?\n */\n getDefaultValueForProperty: function(nodeName, prop) {\n var nodeDefaults = defaultValueCache[nodeName];\n var testElement;\n if (!nodeDefaults) {\n defaultValueCache[nodeName] = nodeDefaults = {};\n }\n if (!(prop in nodeDefaults)) {\n testElement = document.createElement(nodeName);\n nodeDefaults[prop] = testElement[prop];\n }\n return nodeDefaults[prop];\n },\n\n injection: DOMPropertyInjection\n};\n\nmodule.exports = DOMProperty;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/DOMProperty.js\n ** module id = 49\n ** module chunks = 0\n **/","/**\n * Copyright 2013-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule quoteAttributeValueForBrowser\n */\n\n'use strict';\n\nvar escapeTextContentForBrowser = require(\"./escapeTextContentForBrowser\");\n\n/**\n * Escapes attribute value to prevent scripting attacks.\n *\n * @param {*} value Value to escape.\n * @return {string} An escaped string.\n */\nfunction quoteAttributeValueForBrowser(value) {\n return '\"' + escapeTextContentForBrowser(value) + '\"';\n}\n\nmodule.exports = quoteAttributeValueForBrowser;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/quoteAttributeValueForBrowser.js\n ** module id = 50\n ** module chunks = 0\n **/","/**\n * Copyright 2013-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule escapeTextContentForBrowser\n */\n\n'use strict';\n\nvar ESCAPE_LOOKUP = {\n '&': '&',\n '>': '>',\n '<': '<',\n '\"': '"',\n '\\'': '''\n};\n\nvar ESCAPE_REGEX = /[&><\"']/g;\n\nfunction escaper(match) {\n return ESCAPE_LOOKUP[match];\n}\n\n/**\n * Escapes text to prevent scripting attacks.\n *\n * @param {*} text Text value to escape.\n * @return {string} An escaped string.\n */\nfunction escapeTextContentForBrowser(text) {\n return ('' + text).replace(ESCAPE_REGEX, escaper);\n}\n\nmodule.exports = escapeTextContentForBrowser;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/escapeTextContentForBrowser.js\n ** module id = 51\n ** module chunks = 0\n **/","/**\n * Copyright 2013-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule ReactComponentBrowserEnvironment\n */\n\n/*jslint evil: true */\n\n'use strict';\n\nvar ReactDOMIDOperations = require(\"./ReactDOMIDOperations\");\nvar ReactMount = require(\"./ReactMount\");\n\n/**\n * Abstracts away all functionality of the reconciler that requires knowledge of\n * the browser context. TODO: These callers should be refactored to avoid the\n * need for this injection.\n */\nvar ReactComponentBrowserEnvironment = {\n\n processChildrenUpdates:\n ReactDOMIDOperations.dangerouslyProcessChildrenUpdates,\n\n replaceNodeWithMarkupByID:\n ReactDOMIDOperations.dangerouslyReplaceNodeWithMarkupByID,\n\n /**\n * If a particular environment requires that some resources be cleaned up,\n * specify this in the injected Mixin. In the DOM, we would likely want to\n * purge any cached node ID lookups.\n *\n * @private\n */\n unmountIDFromEnvironment: function(rootNodeID) {\n ReactMount.purgeID(rootNodeID);\n }\n\n};\n\nmodule.exports = ReactComponentBrowserEnvironment;\n\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./~/react/lib/ReactComponentBrowserEnvironment.js\n ** module id = 52\n ** module chunks = 0\n **/","/**\n * Copyright 2013-2015, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * LICENSE file in the root directory of this source tree. An additional grant\n * of patent rights can be found in the PATENTS file in the same directory.\n *\n * @providesModule ReactDOMIDOperations\n * @typechecks static-only\n */\n\n/*jslint evil: true */\n\n'use strict';\n\nvar CSSPropertyOperations = require(\"./CSSPropertyOperations\");\nvar DOMChildrenOperations = require(\"./DOMChildrenOperations\");\nvar DOMPropertyOperations = require(\"./DOMPropertyOperations\");\nvar ReactMount = require(\"./ReactMount\");\nvar ReactPerf = require(\"./ReactPerf\");\n\nvar invariant = require(\"./invariant\");\nvar setInnerHTML = require(\"./setInnerHTML\");\n\n/**\n * Errors for properties that should not be updated with `updatePropertyById()`.\n *\n * @type {object}\n * @private\n */\nvar INVALID_PROPERTY_ERRORS = {\n dangerouslySetInnerHTML:\n '`dangerouslySetInnerHTML` must be set using `updateInnerHTMLByID()`.',\n style: '`style` must be set using `updateStylesByID()`.'\n};\n\n/**\n * Operations used to process updates to DOM nodes. This is made injectable via\n * `ReactDOMComponent.BackendIDOperations`.\n */\nvar ReactDOMIDOperations = {\n\n /**\n * Updates a DOM node with new property values. This should only be used to\n * update DOM properties in `DOMProperty`.\n *\n * @param {string} id ID of the node to update.\n * @param {string} name A valid property name, see `DOMProperty`.\n * @param {*} value New value of the property.\n * @internal\n */\n updatePropertyByID: function(id, name, value) {\n var node = ReactMount.getNode(id);\n (\"production\" !== process.env.NODE_ENV ? invariant(\n !INVALID_PROPERTY_ERRORS.hasOwnProperty(name),\n 'updatePropertyByID(...): %s',\n INVALID_PROPERTY_ERRORS[name]\n ) : invariant(!INVALID_PROPERTY_ERRORS.hasOwnProperty(name)));\n\n // If we're updating to null or undefined, we should remove the property\n // from the DOM node instead of inadvertantly setting to a string. This\n // brings us in line with the same behavior we have on initial render.\n if (value != null) {\n DOMPropertyOperations.setValueForProperty(node, name, value);\n } else {\n DOMPropertyOperations.deleteValueForProperty(node, name);\n }\n },\n\n /**\n * Updates a DOM node to remove a property. This should only be used to remove\n * DOM properties in `DOMProperty`.\n *\n * @param {string} id ID of the node to update.\n * @param {string} name A property name to remove, see `DOMProperty`.\n * @internal\n */\n deletePropertyByID: function(id, name, value) {\n var node = ReactMount.getNode(id);\n (\"production\" !== process.env.NODE_ENV ? invariant(\n !INVALID_PROPERTY_ERRORS.hasOwnProperty(name),\n 'updatePropertyByID(...): %s',\n INVALID_PROPERTY_ERRORS[name]\n ) : invariant(!INVALID_PROPERTY_ERRORS.hasOwnProperty(name)));\n DOMPropertyOperations.deleteValueForProperty(node, name, value);\n },\n\n /**\n * Updates a DOM node with new style values. If a value is specified as '',\n * the corresponding style property will be unset.\n *\n * @param {string} id ID of the node to update.\n * @param {object} styles Mapping from styles to values.\n * @internal\n */\n updateStylesByID: function(id, styles) {\n var node = ReactMount.getNode(id);\n CSSPropertyOperations.setValueForStyles(node, styles);\n },\n\n /**\n * Updates a DOM node's innerHTML.\n *\n * @param {string} id ID of the node to update.\n * @param {string} html An HTML string.\n * @internal\n */\n updateInnerHTMLByID: function(id, html) {\n var node = ReactMount.getNode(id);\n setInnerHTML(node, html);\n },\n\n /**\n * Updates a DOM node's text content set by `props.content`.\n *\n * @param {string} id ID of the node to update.\n * @param {string} content Text content.\n * @internal\n */\n updateTextContentByID: function(id, content) {\n var node = ReactMount.getNode(id);\n DOMChildrenOperations.updateTextContent(node, content);\n },\n\n /**\n * Replaces a DOM node that exists in the document with markup.\n *\n * @param {string} id ID of child to be replaced.\n * @param {string} markup Dangerous markup to inject in place of child.\n * @internal\n * @see {Danger.dangerouslyReplaceNodeWithMarkup}\n */\n dangerouslyReplaceNodeWithMarkupByID: function(id, markup) {\n var node = ReactMount.getNode(id);\n DOMChildrenOperations.dangerouslyReplaceNodeWithMarkup(node, markup);\n },\n\n /**\n * Updates a component's children by processing a series of updates.\n *\n * @param {array