, document.body);\n * });\n *\n * Returns the newly created router.\n *\n * Note: If you need to specify further options for your router such\n * as error/abort handling or custom scroll behavior, use Router.create\n * instead.\n *\n * var router = Router.create(options);\n * router.run(function (Handler) {\n * // ...\n * });\n */\nfunction runRouter(routes, location, callback) {\n if (typeof location === 'function') {\n callback = location;\n location = null;\n }\n\n var router = createRouter({\n routes: routes,\n location: location\n });\n\n router.run(callback);\n\n return router;\n}\n\nmodule.exports = runRouter;\n\n/*****************\n ** WEBPACK FOOTER\n ** ../~/react-router/lib/runRouter.js\n ** module id = 46\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///../~/react-router/lib/runRouter.js?")},function(module,exports,__webpack_require__){eval('var Link, React, Router, find, includes, prune;\n\nReact = __webpack_require__(4);\n\nRouter = __webpack_require__(11);\n\nLink = Router.Link;\n\nprune = __webpack_require__(112);\n\nincludes = __webpack_require__(15);\n\nfind = __webpack_require__(5);\n\nmodule.exports = React.createClass({\n render: function() {\n var body, fontSizeToMS, html, nextPost, readNext, ref, rhythm;\n ref = this.props.typography, rhythm = ref.rhythm, fontSizeToMS = ref.fontSizeToMS;\n readNext = this.props.post.readNext;\n if (readNext != null) {\n nextPost = find(this.props.pages, function(page) {\n return includes(page.path, readNext.slice(1, -1));\n });\n }\n if (!nextPost) {\n return React.createElement("noscript", null);\n } else {\n nextPost = find(this.props.pages, function(page) {\n return includes(page.path, readNext.slice(1, -1));\n });\n html = nextPost.data.body;\n body = prune(html.replace(/<[^>]*>/g, \'\'), 200);\n return React.createElement("div", null, React.createElement("h6", {\n "style": {\n margin: 0,\n fontSize: fontSizeToMS(-1).fontSize,\n lineHeight: fontSizeToMS(-1).lineHeight,\n letterSpacing: -0.5\n }\n }, "READ THIS NEXT:"), React.createElement("h3", {\n "style": {\n marginBottom: rhythm(1 / 4)\n }\n }, React.createElement(Link, {\n "to": nextPost.path,\n "query": {\n readNext: true\n }\n }, nextPost.data.title)), React.createElement("p", null, body), React.createElement("hr", null));\n }\n }\n});\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ../components/ReadNext.cjsx\n ** module id = 47\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///../components/ReadNext.cjsx?')},function(module,exports,__webpack_require__){eval('var Breakpoint, Container, Grid, Link, React, RouteHandler, Router, Span, Typography, fontSizeToMS, link, ref, rhythm, typography;\n\nReact = __webpack_require__(4);\n\nRouter = __webpack_require__(11);\n\nRouteHandler = Router.RouteHandler, Link = Router.Link;\n\nref = __webpack_require__(196), Container = ref.Container, Grid = ref.Grid, Breakpoint = ref.Breakpoint, Span = ref.Span;\n\nTypography = __webpack_require__(195);\n\n__webpack_require__(113);\n\nlink = __webpack_require__(115).link;\n\ntypography = Typography();\n\nrhythm = typography.rhythm, fontSizeToMS = typography.fontSizeToMS;\n\nmodule.exports = React.createClass({\n render: function() {\n var header;\n if (this.props.state.path === link(\'/\')) {\n header = React.createElement("h1", {\n "style": {\n fontSize: fontSizeToMS(2.5).fontSize,\n lineHeight: fontSizeToMS(2.5).lineHeight,\n marginBottom: rhythm(1.5)\n }\n }, React.createElement(Link, {\n "style": {\n textDecoration: \'none\',\n color: \'inherit\'\n },\n "to": link(\'/\')\n }, this.props.config.blogTitle));\n } else {\n header = React.createElement("h3", null, React.createElement(Link, {\n "style": {\n textDecoration: \'none\',\n color: \'inherit\'\n },\n "to": link(\'/\')\n }, this.props.config.blogTitle));\n }\n return React.createElement(Container, {\n "style": {\n maxWidth: rhythm(24),\n padding: (rhythm(2)) + " " + (rhythm(1 / 2))\n }\n }, header, React.createElement(RouteHandler, React.__spread({\n "typography": typography\n }, this.props)));\n }\n});\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./_template.cjsx\n ** module id = 48\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./_template.cjsx?')},function(module,exports,__webpack_require__){eval('var Link, React, RouteHandler, Router, link, sortBy;\n\nReact = __webpack_require__(4);\n\nRouter = __webpack_require__(11);\n\nRouteHandler = Router.RouteHandler, Link = Router.Link;\n\nsortBy = __webpack_require__(9);\n\nlink = __webpack_require__(115).link;\n\nmodule.exports = React.createClass({\n statics: {\n data: function() {\n return {\n yo: true\n };\n }\n },\n render: function() {\n var i, len, page, pageLinks, ref, ref1, ref2, rhythm, title;\n rhythm = this.props.typography.rhythm;\n pageLinks = [];\n ref = sortBy(this.props.pages, function(page) {\n var ref;\n return (ref = page.data) != null ? ref.date : void 0;\n }).reverse();\n for (i = 0, len = ref.length; i < len; i++) {\n page = ref[i];\n title = ((ref1 = page.data) != null ? ref1.title : void 0) || page.path;\n if (page.path !== link("/") && !((ref2 = page.data) != null ? ref2.draft : void 0)) {\n pageLinks.push(React.createElement("li", {\n "key": page.path,\n "style": {\n marginBottom: rhythm(1 / 4)\n }\n }, React.createElement(Link, {\n "to": page.path\n }, title)));\n }\n }\n return React.createElement("div", null, React.createElement("p", {\n "style": {\n marginBottom: rhythm(2.5)\n }\n }, React.createElement("img", {\n "src": "./kyle-round-small-pantheon.jpg",\n "style": {\n float: \'left\',\n marginRight: rhythm(1 / 4),\n marginBottom: 0,\n width: rhythm(2),\n height: rhythm(2)\n }\n }), "Written by ", React.createElement("strong", null, this.props.config.authorName), " who lives and works in San Francisco building useful things. ", React.createElement("a", {\n "href": "https://twitter.com/kylemathews"\n }, "You should follow him on Twitter")), React.createElement("ul", null, pageLinks));\n }\n});\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ./index.cjsx\n ** module id = 49\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./index.cjsx?')},function(module,exports,__webpack_require__){eval("/**\n * Ensure some object is a coerced to a string\n **/\nmodule.exports = function makeString(object) {\n if (object == null) return '';\n return '' + object;\n};\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ../~/underscore.string/helper/makeString.js\n ** module id = 50\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///../~/underscore.string/helper/makeString.js?")},function(module,exports,__webpack_require__){eval("'use strict';\n\nvar React = __webpack_require__(4),\n createSideEffect = __webpack_require__(198);\n\nvar _serverTitle = null;\n\nfunction getTitleFromPropsList(propsList) {\n var innermostProps = propsList[propsList.length - 1];\n if (innermostProps) {\n return innermostProps.title;\n }\n}\n\nvar DocumentTitle = createSideEffect(function handleChange(propsList) {\n var title = getTitleFromPropsList(propsList);\n\n if (typeof document !== 'undefined') {\n document.title = title || '';\n } else {\n _serverTitle = title || null;\n }\n}, {\n displayName: 'DocumentTitle',\n\n propTypes: {\n title: React.PropTypes.string.isRequired\n },\n\n statics: {\n peek: function () {\n return _serverTitle;\n },\n\n rewind: function () {\n var title = _serverTitle;\n this.dispose();\n return title;\n }\n }\n});\n\nmodule.exports = DocumentTitle;\n\n/*****************\n ** WEBPACK FOOTER\n ** ../~/react-document-title/index.js\n ** module id = 51\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///../~/react-document-title/index.js?")},function(module,exports,__webpack_require__){eval('module.exports = {"title":"Hello World","date":"2015-05-01T22:12:03.284Z","layout":"post","readNext":"/my-second-post/","path":"/hello-world/","body":"This is my first post on my new fake blog! How exciting!
\\nI’m sure I’ll write a lot more interesting things in the future.
\\nOh, and here’s a great quote from this Wikipedia on salted duck eggs.
\\n\\nA salted duck egg is a Chinese preserved food product made by soaking duck eggs in brine, or packing each egg in damp, salted charcoal. In Asian supermarkets, these eggs are sometimes sold covered in a thick layer of salted charcoal paste. The eggs may also be sold with the salted paste removed, wrapped in plastic, and vacuum packed. From the salt curing process, the salted duck eggs have a briny aroma, a gelatin-like egg white and a firm-textured, round yolk that is bright orange-red in color.
\\n
\\n\\n"}\n\n/*****************\n ** WEBPACK FOOTER\n ** ./2015-05-01-hello-world/index.md\n ** module id = 52\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./2015-05-01-hello-world/index.md?')},function(module,exports,__webpack_require__){eval('module.exports = {"title":"My Second Post!","date":"2015-05-06T23:46:37.121Z","layout":"post","readNext":"/hi-folks/","path":"/my-second-post/","body":"Wow! I love blogging so much already.
\\nDid you know that “despite its name, salted duck eggs can also be made from chicken eggs, though the taste and texture will be somewhat different, and the egg yolk will be less rich.”? (Wikipedia Link)
\\nYeah, I didn’t either.
\\n"}\n\n/*****************\n ** WEBPACK FOOTER\n ** ./2015-05-06-my-second-post/index.md\n ** module id = 53\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./2015-05-06-my-second-post/index.md?')},function(module,exports,__webpack_require__){eval('module.exports = {"title":"New Beginnings","date":"2015-05-28T22:40:32.169Z","layout":"post","readNext":"/hosting-static-sites-with-docker-and-nginx/","path":"/hi-folks/","body":"This post is going to be a little hard to read for those that don’t speak latin.
\\nLorem ipsum dolor sit amet, consectetur adipiscing elit. Integer vel neque dignissim mi maximus interdum. Cras dictum quam et ex molestie facilisis. Proin dapibus sed sapien nec gravida. Praesent at leo ut erat varius rhoncus at non mi. Quisque cursus non leo et varius. Maecenas porttitor scelerisque sapien at venenatis. Proin pellentesque gravida elementum. Nam eget porttitor ligula. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; Aenean nec commodo lacus, eu mollis nisi. Nullam felis mi, tempus ac ipsum a, venenatis blandit magna. Sed mattis magna est, quis tincidunt massa aliquam vitae. Ut in ipsum blandit, ultrices lacus a, condimentum nibh. Sed commodo, lorem eget interdum molestie, lacus nisi lacinia velit, tempus commodo lacus erat porttitor dolor.
\\nPhasellus vitae ante justo. Fusce dui elit, finibus non posuere sed, ullamcorper at odio. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Pellentesque molestie lorem dolor, eget tincidunt ligula suscipit sit amet. Maecenas tempor nulla orci, sed scelerisque massa convallis id. Fusce iaculis nibh et lectus bibendum viverra. Nulla volutpat vehicula tortor non cursus. Maecenas vulputate mi nec accumsan ultricies. Praesent vitae tellus ligula. Praesent placerat fringilla purus, ac fermentum ipsum faucibus sed. Fusce semper, sapien hendrerit fringilla sagittis, lacus felis accumsan tellus, ac mollis ex arcu vitae lorem. Duis vitae semper felis. Duis consectetur, diam id laoreet suscipit, felis felis imperdiet sem, vel posuere leo ligula nec sapien. Maecenas at imperdiet nulla. Quisque quam nibh, feugiat vitae rhoncus ac, hendrerit eu quam. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus.
\\nNullam vehicula lorem sed felis rutrum gravida. Nam mattis cursus lacinia. Cras sit amet interdum elit. Morbi viverra, est a tincidunt facilisis, est est maximus urna, id rhoncus mi metus et lacus. Pellentesque finibus ex vel nulla fermentum tempus. Nunc vel lorem enim. Sed varius scelerisque nulla, nec ultrices ligula gravida eu. Curabitur eu turpis sit amet nisl vehicula tempor ultrices eu lacus. Curabitur malesuada nulla neque. Aenean mattis lectus ex, molestie ultricies elit fringilla eget. Quisque iaculis volutpat nisl, vitae lobortis ipsum elementum sed. Nulla facilisi. Maecenas cursus turpis ac lacus efficitur, non bibendum ligula consequat. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Mauris accumsan placerat felis, at bibendum ante.
\\nQuisque varius dui vel commodo lobortis. Vestibulum eu metus vel dui lobortis volutpat. Cras vitae neque ornare, vehicula urna et, efficitur dolor. Nunc congue euismod leo non rhoncus. Nulla mollis libero a ullamcorper placerat. Morbi bibendum viverra orci in auctor. Donec in est varius, hendrerit risus vitae, commodo purus. Praesent eget rhoncus ligula. Suspendisse quis ultricies ligula. Nullam tincidunt rutrum nisl eget luctus. Phasellus eget nulla semper, varius ligula a, gravida urna. Etiam tempor feugiat elit eu cursus. Donec tristique ligula a aliquam tempor.
\\nProin nec nunc tellus. Donec sapien leo, ornare quis condimentum a, euismod sit amet augue. Aliquam tincidunt mauris at arcu suscipit, quis scelerisque justo rhoncus. Vestibulum lobortis dui at odio lacinia mattis. Praesent nunc urna, bibendum ut dui eget, consequat suscipit leo. Curabitur auctor vel dui fermentum auctor. Sed ultrices ligula mauris, id blandit sapien ultrices id. Morbi volutpat tortor quis ex convallis aliquam. Nunc eleifend risus eget dui condimentum scelerisque.
\\n"}\n\n/*****************\n ** WEBPACK FOOTER\n ** ./2015-05-28-hi-folks/index.md\n ** module id = 54\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///./2015-05-28-hi-folks/index.md?')},function(module,exports,__webpack_require__){eval("/**\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 = __webpack_require__(117);\n\nvar invariant = __webpack_require__(95);\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 (false) {\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 (false) {\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 (false) {\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 (false) {\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 (false) {\n validateEventDispatches(event);\n }\n var dispatchListener = event._dispatchListeners;\n var dispatchID = event._dispatchIDs;\n (false ? 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 ** WEBPACK FOOTER\n ** ../~/react/lib/EventPluginUtils.js\n ** module id = 55\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///../~/react/lib/EventPluginUtils.js?")},function(module,exports,__webpack_require__){eval("/**\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 = __webpack_require__(118);\nvar ReactFragment = __webpack_require__(119);\n\nvar traverseAllChildren = __webpack_require__(120);\nvar warning = __webpack_require__(99);\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 (false) {\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 ** WEBPACK FOOTER\n ** ../~/react/lib/ReactChildren.js\n ** module id = 56\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///../~/react/lib/ReactChildren.js?")},function(module,exports,__webpack_require__){eval("/**\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 = __webpack_require__(121);\n\nvar invariant = __webpack_require__(95);\nvar warning = __webpack_require__(99);\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 (false ? 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 (false) {\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 (false) {\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 ** WEBPACK FOOTER\n ** ../~/react/lib/ReactComponent.js\n ** module id = 57\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///../~/react/lib/ReactComponent.js?");
-},function(module,exports,__webpack_require__){eval("/**\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 = __webpack_require__(57);\nvar ReactCurrentOwner = __webpack_require__(60);\nvar ReactElement = __webpack_require__(61);\nvar ReactErrorUtils = __webpack_require__(123);\nvar ReactInstanceMap = __webpack_require__(124);\nvar ReactLifeCycle = __webpack_require__(125);\nvar ReactPropTypeLocations = __webpack_require__(126);\nvar ReactPropTypeLocationNames = __webpack_require__(127);\nvar ReactUpdateQueue = __webpack_require__(121);\n\nvar assign = __webpack_require__(72);\nvar invariant = __webpack_require__(95);\nvar keyMirror = __webpack_require__(128);\nvar keyOf = __webpack_require__(129);\nvar warning = __webpack_require__(99);\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 (false) {\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 (false) {\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 (false) {\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 (false ? 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 (false ? 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 (false ? 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 (false ? 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 (false ? 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 (false ? 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 (false) {\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 (false ? 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 (false ? 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 (false ? 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 (false ? 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 (false) {\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 (false ? 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 (false) {\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 (false) {\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 (false) {\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 (false ? 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 (false) {\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 (false ? invariant(\n Constructor.prototype.render,\n 'createClass(...): Class specification must implement a `render` method.'\n ) : invariant(Constructor.prototype.render));\n\n if (false) {\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 (false) {\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 ** WEBPACK FOOTER\n ** ../~/react/lib/ReactClass.js\n ** module id = 58\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///../~/react/lib/ReactClass.js?")},function(module,exports,__webpack_require__){eval("/**\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 = __webpack_require__(72);\nvar emptyObject = __webpack_require__(122);\nvar warning = __webpack_require__(99);\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 (false) {\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 ** WEBPACK FOOTER\n ** ../~/react/lib/ReactContext.js\n ** module id = 59\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///../~/react/lib/ReactContext.js?");
-},function(module,exports,__webpack_require__){eval("/**\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 ** WEBPACK FOOTER\n ** ../~/react/lib/ReactCurrentOwner.js\n ** module id = 60\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///../~/react/lib/ReactCurrentOwner.js?")},function(module,exports,__webpack_require__){eval("/**\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 = __webpack_require__(59);\nvar ReactCurrentOwner = __webpack_require__(60);\n\nvar assign = __webpack_require__(72);\nvar warning = __webpack_require__(99);\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 (false ? 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 (false) {\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 (false) {\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 (false) {\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 ** WEBPACK FOOTER\n ** ../~/react/lib/ReactElement.js\n ** module id = 61\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///../~/react/lib/ReactElement.js?")},function(module,exports,__webpack_require__){eval("/**\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 = __webpack_require__(61);\nvar ReactFragment = __webpack_require__(119);\nvar ReactPropTypeLocations = __webpack_require__(126);\nvar ReactPropTypeLocationNames = __webpack_require__(127);\nvar ReactCurrentOwner = __webpack_require__(60);\nvar ReactNativeComponent = __webpack_require__(131);\n\nvar getIteratorFn = __webpack_require__(130);\nvar invariant = __webpack_require__(95);\nvar warning = __webpack_require__(99);\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 (false ? 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 (false ? 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 (false ? 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 (false ? 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 (false ? 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 (false ? 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 (false) {\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 ** WEBPACK FOOTER\n ** ../~/react/lib/ReactElementValidator.js\n ** module id = 62\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///../~/react/lib/ReactElementValidator.js?")},function(module,exports,__webpack_require__){eval("/**\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 = __webpack_require__(61);\nvar ReactElementValidator = __webpack_require__(62);\n\nvar mapObject = __webpack_require__(132);\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 (false) {\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 ** WEBPACK FOOTER\n ** ../~/react/lib/ReactDOM.js\n ** module id = 63\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///../~/react/lib/ReactDOM.js?")},function(module,exports,__webpack_require__){eval("/**\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 = __webpack_require__(133);\nvar ReactComponentBrowserEnvironment =\n __webpack_require__(134);\nvar ReactDOMComponent = __webpack_require__(135);\n\nvar assign = __webpack_require__(72);\nvar escapeTextContentForBrowser = __webpack_require__(136);\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 ** WEBPACK FOOTER\n ** ../~/react/lib/ReactDOMTextComponent.js\n ** module id = 64\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///../~/react/lib/ReactDOMTextComponent.js?")},function(module,exports,__webpack_require__){eval("/**\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 ReactDefaultInjection\n */\n\n'use strict';\n\nvar BeforeInputEventPlugin = __webpack_require__(139);\nvar ChangeEventPlugin = __webpack_require__(140);\nvar ClientReactRootIndex = __webpack_require__(141);\nvar DefaultEventPluginOrder = __webpack_require__(142);\nvar EnterLeaveEventPlugin = __webpack_require__(143);\nvar ExecutionEnvironment = __webpack_require__(98);\nvar HTMLDOMPropertyConfig = __webpack_require__(144);\nvar MobileSafariClickEventPlugin = __webpack_require__(145);\nvar ReactBrowserComponentMixin = __webpack_require__(146);\nvar ReactClass = __webpack_require__(58);\nvar ReactComponentBrowserEnvironment =\n __webpack_require__(134);\nvar ReactDefaultBatchingStrategy = __webpack_require__(147);\nvar ReactDOMComponent = __webpack_require__(135);\nvar ReactDOMButton = __webpack_require__(148);\nvar ReactDOMForm = __webpack_require__(149);\nvar ReactDOMImg = __webpack_require__(150);\nvar ReactDOMIDOperations = __webpack_require__(151);\nvar ReactDOMIframe = __webpack_require__(138);\nvar ReactDOMInput = __webpack_require__(152);\nvar ReactDOMOption = __webpack_require__(153);\nvar ReactDOMSelect = __webpack_require__(154);\nvar ReactDOMTextarea = __webpack_require__(155);\nvar ReactDOMTextComponent = __webpack_require__(64);\nvar ReactElement = __webpack_require__(61);\nvar ReactEventListener = __webpack_require__(156);\nvar ReactInjection = __webpack_require__(157);\nvar ReactInstanceHandles = __webpack_require__(66);\nvar ReactMount = __webpack_require__(67);\nvar ReactReconcileTransaction = __webpack_require__(158);\nvar SelectEventPlugin = __webpack_require__(159);\nvar ServerReactRootIndex = __webpack_require__(160);\nvar SimpleEventPlugin = __webpack_require__(161);\nvar SVGDOMPropertyConfig = __webpack_require__(162);\n\nvar createFullPageComponent = __webpack_require__(163);\n\nfunction autoGenerateWrapperClass(type) {\n return ReactClass.createClass({\n tagName: type.toUpperCase(),\n render: function() {\n return new ReactElement(\n type,\n null,\n null,\n null,\n null,\n this.props\n );\n }\n });\n}\n\nfunction inject() {\n ReactInjection.EventEmitter.injectReactEventListener(\n ReactEventListener\n );\n\n /**\n * Inject modules for resolving DOM hierarchy and plugin ordering.\n */\n ReactInjection.EventPluginHub.injectEventPluginOrder(DefaultEventPluginOrder);\n ReactInjection.EventPluginHub.injectInstanceHandle(ReactInstanceHandles);\n ReactInjection.EventPluginHub.injectMount(ReactMount);\n\n /**\n * Some important event plugins included by default (without having to require\n * them).\n */\n ReactInjection.EventPluginHub.injectEventPluginsByName({\n SimpleEventPlugin: SimpleEventPlugin,\n EnterLeaveEventPlugin: EnterLeaveEventPlugin,\n ChangeEventPlugin: ChangeEventPlugin,\n MobileSafariClickEventPlugin: MobileSafariClickEventPlugin,\n SelectEventPlugin: SelectEventPlugin,\n BeforeInputEventPlugin: BeforeInputEventPlugin\n });\n\n ReactInjection.NativeComponent.injectGenericComponentClass(\n ReactDOMComponent\n );\n\n ReactInjection.NativeComponent.injectTextComponentClass(\n ReactDOMTextComponent\n );\n\n ReactInjection.NativeComponent.injectAutoWrapper(\n autoGenerateWrapperClass\n );\n\n // This needs to happen before createFullPageComponent() otherwise the mixin\n // won't be included.\n ReactInjection.Class.injectMixin(ReactBrowserComponentMixin);\n\n ReactInjection.NativeComponent.injectComponentClasses({\n 'button': ReactDOMButton,\n 'form': ReactDOMForm,\n 'iframe': ReactDOMIframe,\n 'img': ReactDOMImg,\n 'input': ReactDOMInput,\n 'option': ReactDOMOption,\n 'select': ReactDOMSelect,\n 'textarea': ReactDOMTextarea,\n\n 'html': createFullPageComponent('html'),\n 'head': createFullPageComponent('head'),\n 'body': createFullPageComponent('body')\n });\n\n ReactInjection.DOMProperty.injectDOMPropertyConfig(HTMLDOMPropertyConfig);\n ReactInjection.DOMProperty.injectDOMPropertyConfig(SVGDOMPropertyConfig);\n\n ReactInjection.EmptyComponent.injectEmptyComponent('noscript');\n\n ReactInjection.Updates.injectReconcileTransaction(\n ReactReconcileTransaction\n );\n ReactInjection.Updates.injectBatchingStrategy(\n ReactDefaultBatchingStrategy\n );\n\n ReactInjection.RootIndex.injectCreateReactRootIndex(\n ExecutionEnvironment.canUseDOM ?\n ClientReactRootIndex.createReactRootIndex :\n ServerReactRootIndex.createReactRootIndex\n );\n\n ReactInjection.Component.injectEnvironment(ReactComponentBrowserEnvironment);\n ReactInjection.DOMComponent.injectIDOperations(ReactDOMIDOperations);\n\n if (false) {\n var url = (ExecutionEnvironment.canUseDOM && window.location.href) || '';\n if ((/[?&]react_perf\\b/).test(url)) {\n var ReactDefaultPerf = require(\"./ReactDefaultPerf\");\n ReactDefaultPerf.start();\n }\n }\n}\n\nmodule.exports = {\n inject: inject\n};\n\n\n/*****************\n ** WEBPACK FOOTER\n ** ../~/react/lib/ReactDefaultInjection.js\n ** module id = 65\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///../~/react/lib/ReactDefaultInjection.js?");
-},function(module,exports,__webpack_require__){eval("/**\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 = __webpack_require__(137);\n\nvar invariant = __webpack_require__(95);\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 (false ? 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 (false ? 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 (false ? 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 (false ? 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 (false ? 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 (false ? 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 ** WEBPACK FOOTER\n ** ../~/react/lib/ReactInstanceHandles.js\n ** module id = 66\n ** module chunks = 0\n **/\n//# sourceURL=webpack:///../~/react/lib/ReactInstanceHandles.js?")},function(module,exports,__webpack_require__){eval("/**\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 ReactMount\n */\n\n'use strict';\n\nvar DOMProperty = __webpack_require__(164);\nvar ReactBrowserEventEmitter = __webpack_require__(1);\nvar ReactCurrentOwner = __webpack_require__(60);\nvar ReactElement = __webpack_require__(61);\nvar ReactElementValidator = __webpack_require__(62);\nvar ReactEmptyComponent = __webpack_require__(166);\nvar ReactInstanceHandles = __webpack_require__(66);\nvar ReactInstanceMap = __webpack_require__(124);\nvar ReactMarkupChecksum = __webpack_require__(167);\nvar ReactPerf = __webpack_require__(68);\nvar ReactReconciler = __webpack_require__(70);\nvar ReactUpdateQueue = __webpack_require__(121);\nvar ReactUpdates = __webpack_require__(168);\n\nvar emptyObject = __webpack_require__(122);\nvar containsNode = __webpack_require__(169);\nvar getReactRootElementInContainer = __webpack_require__(170);\nvar instantiateReactComponent = __webpack_require__(171);\nvar invariant = __webpack_require__(95);\nvar setInnerHTML = __webpack_require__(172);\nvar shouldUpdateReactComponent = __webpack_require__(173);\nvar warning = __webpack_require__(99);\n\nvar SEPARATOR = ReactInstanceHandles.SEPARATOR;\n\nvar ATTR_NAME = DOMProperty.ID_ATTRIBUTE_NAME;\nvar nodeCache = {};\n\nvar ELEMENT_NODE_TYPE = 1;\nvar DOC_NODE_TYPE = 9;\n\n/** Mapping from reactRootID to React component instance. */\nvar instancesByReactRootID = {};\n\n/** Mapping from reactRootID to `container` nodes. */\nvar containersByReactRootID = {};\n\nif (false) {\n /** __DEV__-only mapping from reactRootID to root elements. */\n var rootElementsByReactRootID = {};\n}\n\n// Used to store breadth-first search state in findComponentRoot.\nvar findComponentRootReusableArray = [];\n\n/**\n * Finds the index of the first character\n * that's not common between the two given strings.\n *\n * @return {number} the index of the character where the strings diverge\n */\nfunction firstDifferenceIndex(string1, string2) {\n var minLen = Math.min(string1.length, string2.length);\n for (var i = 0; i < minLen; i++) {\n if (string1.charAt(i) !== string2.charAt(i)) {\n return i;\n }\n }\n return string1.length === string2.length ? -1 : minLen;\n}\n\n/**\n * @param {DOMElement} container DOM element that may contain a React component.\n * @return {?string} A \"reactRoot\" ID, if a React component is rendered.\n */\nfunction getReactRootID(container) {\n var rootElement = getReactRootElementInContainer(container);\n return rootElement && ReactMount.getID(rootElement);\n}\n\n/**\n * Accessing node[ATTR_NAME] or calling getAttribute(ATTR_NAME) on a form\n * element can return its control whose name or ID equals ATTR_NAME. All\n * DOM nodes support `getAttributeNode` but this can also get called on\n * other objects so just return '' if we're given something other than a\n * DOM node (such as window).\n *\n * @param {?DOMElement|DOMWindow|DOMDocument|DOMTextNode} node DOM node.\n * @return {string} ID of the supplied `domNode`.\n */\nfunction getID(node) {\n var id = internalGetID(node);\n if (id) {\n if (nodeCache.hasOwnProperty(id)) {\n var cached = nodeCache[id];\n if (cached !== node) {\n (false ? invariant(\n !isValid(cached, id),\n 'ReactMount: Two valid but unequal nodes with the same `%s`: %s',\n ATTR_NAME, id\n ) : invariant(!isValid(cached, id)));\n\n nodeCache[id] = node;\n }\n } else {\n nodeCache[id] = node;\n }\n }\n\n return id;\n}\n\nfunction internalGetID(node) {\n // If node is something like a window, document, or text node, none of\n // which support attributes or a .getAttribute method, gracefully return\n // the empty string, as if the attribute were missing.\n return node && node.getAttribute && node.getAttribute(ATTR_NAME) || '';\n}\n\n/**\n * Sets the React-specific ID of the given node.\n *\n * @param {DOMElement} node The DOM node whose ID will be set.\n * @param {string} id The value of the ID attribute.\n */\nfunction setID(node, id) {\n var oldID = internalGetID(node);\n if (oldID !== id) {\n delete nodeCache[oldID];\n }\n node.setAttribute(ATTR_NAME, id);\n nodeCache[id] = node;\n}\n\n/**\n * Finds the node with the supplied React-generated DOM ID.\n *\n * @param {string} id A React-generated DOM ID.\n * @return {DOMElement} DOM node with the suppled `id`.\n * @internal\n */\nfunction getNode(id) {\n if (!nodeCache.hasOwnProperty(id) || !isValid(nodeCache[id], id)) {\n nodeCache[id] = ReactMount.findReactNodeByID(id);\n }\n return nodeCache[id];\n}\n\n/**\n * Finds the node with the supplied public React instance.\n *\n * @param {*} instance A public React instance.\n * @return {?DOMElement} DOM node with the suppled `id`.\n * @internal\n */\nfunction getNodeFromInstance(instance) {\n var id = ReactInstanceMap.get(instance)._rootNodeID;\n if (ReactEmptyComponent.isNullComponentID(id)) {\n return null;\n }\n if (!nodeCache.hasOwnProperty(id) || !isValid(nodeCache[id], id)) {\n nodeCache[id] = ReactMount.findReactNodeByID(id);\n }\n return nodeCache[id];\n}\n\n/**\n * A node is \"valid\" if it is contained by a currently mounted container.\n *\n * This means that the node does not have to be contained by a document in\n * order to be considered valid.\n *\n * @param {?DOMElement} node The candidate DOM node.\n * @param {string} id The expected ID of the node.\n * @return {boolean} Whether the node is contained by a mounted container.\n */\nfunction isValid(node, id) {\n if (node) {\n (false ? invariant(\n internalGetID(node) === id,\n 'ReactMount: Unexpected modification of `%s`',\n ATTR_NAME\n ) : invariant(internalGetID(node) === id));\n\n var container = ReactMount.findReactContainerForID(id);\n if (container && containsNode(container, node)) {\n return true;\n }\n }\n\n return false;\n}\n\n/**\n * Causes the cache to forget about one React-specific ID.\n *\n * @param {string} id The ID to forget.\n */\nfunction purgeID(id) {\n delete nodeCache[id];\n}\n\nvar deepestNodeSoFar = null;\nfunction findDeepestCachedAncestorImpl(ancestorID) {\n var ancestor = nodeCache[ancestorID];\n if (ancestor && isValid(ancestor, ancestorID)) {\n deepestNodeSoFar = ancestor;\n } else {\n // This node isn't populated in the cache, so presumably none of its\n // descendants are. Break out of the loop.\n return false;\n }\n}\n\n/**\n * Return the deepest cached node whose ID is a prefix of `targetID`.\n */\nfunction findDeepestCachedAncestor(targetID) {\n deepestNodeSoFar = null;\n ReactInstanceHandles.traverseAncestors(\n targetID,\n findDeepestCachedAncestorImpl\n );\n\n var foundNode = deepestNodeSoFar;\n deepestNodeSoFar = null;\n return foundNode;\n}\n\n/**\n * Mounts this component and inserts it into the DOM.\n *\n * @param {ReactComponent} componentInstance The instance to mount.\n * @param {string} rootID DOM ID of the root node.\n * @param {DOMElement} container DOM element to mount into.\n * @param {ReactReconcileTransaction} transaction\n * @param {boolean} shouldReuseMarkup If true, do not insert markup\n */\nfunction mountComponentIntoNode(\n componentInstance,\n rootID,\n container,\n transaction,\n shouldReuseMarkup) {\n var markup = ReactReconciler.mountComponent(\n componentInstance, rootID, transaction, emptyObject\n );\n componentInstance._isTopLevel = true;\n ReactMount._mountImageIntoNode(markup, container, shouldReuseMarkup);\n}\n\n/**\n * Batched mount.\n *\n * @param {ReactComponent} componentInstance The instance to mount.\n * @param {string} rootID DOM ID of the root node.\n * @param {DOMElement} container DOM element to mount into.\n * @param {boolean} shouldReuseMarkup If true, do not insert markup\n */\nfunction batchedMountComponentIntoNode(\n componentInstance,\n rootID,\n container,\n shouldReuseMarkup) {\n var transaction = ReactUpdates.ReactReconcileTransaction.getPooled();\n transaction.perform(\n mountComponentIntoNode,\n null,\n componentInstance,\n rootID,\n container,\n transaction,\n shouldReuseMarkup\n );\n ReactUpdates.ReactReconcileTransaction.release(transaction);\n}\n\n/**\n * Mounting is the process of initializing a React component by creating its\n * representative DOM elements and inserting them into a supplied `container`.\n * Any prior content inside `container` is destroyed in the process.\n *\n * ReactMount.render(\n * component,\n * document.getElementById('container')\n * );\n *\n * <-- Supplied `container`.\n *
<-- Rendered reactRoot of React\n * // ... component.\n *
\n *
\n *\n * Inside of `container`, the first element rendered is the \"reactRoot\".\n */\nvar ReactMount = {\n /** Exposed for debugging purposes **/\n _instancesByReactRootID: instancesByReactRootID,\n\n /**\n * This is a hook provided to support rendering React components while\n * ensuring that the apparent scroll position of its `container` does not\n * change.\n *\n * @param {DOMElement} container The `container` being rendered into.\n * @param {function} renderCallback This must be called once to do the render.\n */\n scrollMonitor: function(container, renderCallback) {\n renderCallback();\n },\n\n /**\n * Take a component that's already mounted into the DOM and replace its props\n * @param {ReactComponent} prevComponent component instance already in the DOM\n * @param {ReactElement} nextElement component instance to render\n * @param {DOMElement} container container to render into\n * @param {?function} callback function triggered on completion\n */\n _updateRootComponent: function(\n prevComponent,\n nextElement,\n container,\n callback) {\n if (false) {\n ReactElementValidator.checkAndWarnForMutatedProps(nextElement);\n }\n\n ReactMount.scrollMonitor(container, function() {\n ReactUpdateQueue.enqueueElementInternal(prevComponent, nextElement);\n if (callback) {\n ReactUpdateQueue.enqueueCallbackInternal(prevComponent, callback);\n }\n });\n\n if (false) {\n // Record the root element in case it later gets transplanted.\n rootElementsByReactRootID[getReactRootID(container)] =\n getReactRootElementInContainer(container);\n }\n\n return prevComponent;\n },\n\n /**\n * Register a component into the instance map and starts scroll value\n * monitoring\n * @param {ReactComponent} nextComponent component instance to render\n * @param {DOMElement} container container to render into\n * @return {string} reactRoot ID prefix\n */\n _registerComponent: function(nextComponent, container) {\n (false ? invariant(\n container && (\n (container.nodeType === ELEMENT_NODE_TYPE || container.nodeType === DOC_NODE_TYPE)\n ),\n '_registerComponent(...): Target container is not a DOM element.'\n ) : invariant(container && (\n (container.nodeType === ELEMENT_NODE_TYPE || container.nodeType === DOC_NODE_TYPE)\n )));\n\n ReactBrowserEventEmitter.ensureScrollValueMonitoring();\n\n var reactRootID = ReactMount.registerContainer(container);\n instancesByReactRootID[reactRootID] = nextComponent;\n return reactRootID;\n },\n\n /**\n * Render a new component into the DOM.\n * @param {ReactElement} nextElement element to render\n * @param {DOMElement} container container to render into\n * @param {boolean} shouldReuseMarkup if we should skip the markup insertion\n * @return {ReactComponent} nextComponent\n */\n _renderNewRootComponent: function(\n nextElement,\n container,\n shouldReuseMarkup\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.\n (false ? warning(\n ReactCurrentOwner.current == null,\n '_renderNewRootComponent(): Render methods should be a pure function ' +\n 'of props and state; triggering nested component updates from ' +\n 'render is not allowed. If necessary, trigger nested updates in ' +\n 'componentDidUpdate.'\n ) : null);\n\n var componentInstance = instantiateReactComponent(nextElement, null);\n var reactRootID = ReactMount._registerComponent(\n componentInstance,\n container\n );\n\n // The initial render is synchronous but any updates that happen during\n // rendering, in componentWillMount or componentDidMount, will be batched\n // according to the current batching strategy.\n\n ReactUpdates.batchedUpdates(\n batchedMountComponentIntoNode,\n componentInstance,\n reactRootID,\n container,\n shouldReuseMarkup\n );\n\n if (false) {\n // Record the root element in case it later gets transplanted.\n rootElementsByReactRootID[reactRootID] =\n getReactRootElementInContainer(container);\n }\n\n return componentInstance;\n },\n\n /**\n * Renders a React component into the DOM in the supplied `container`.\n *\n * If the React component was previously rendered into `container`, this will\n * perform an update on it and only mutate the DOM as necessary to reflect the\n * latest React component.\n *\n * @param {ReactElement} nextElement Component element to render.\n * @param {DOMElement} container DOM element to render into.\n * @param {?function} callback function triggered on completion\n * @return {ReactComponent} Component instance rendered in `container`.\n */\n render: function(nextElement, container, callback) {\n (false ? invariant(\n ReactElement.isValidElement(nextElement),\n 'React.render(): Invalid component element.%s',\n (\n typeof nextElement === 'string' ?\n ' Instead of passing an element string, make sure to instantiate ' +\n 'it by passing it to React.createElement.' :\n typeof nextElement === 'function' ?\n ' Instead of passing a component class, make sure to instantiate ' +\n 'it by passing it to React.createElement.' :\n // Check if it quacks like an element\n nextElement != null && nextElement.props !== undefined ?\n ' This may be caused by unintentionally loading two independent ' +\n 'copies of React.' :\n ''\n )\n ) : invariant(ReactElement.isValidElement(nextElement)));\n\n var prevComponent = instancesByReactRootID[getReactRootID(container)];\n\n if (prevComponent) {\n var prevElement = prevComponent._currentElement;\n if (shouldUpdateReactComponent(prevElement, nextElement)) {\n return ReactMount._updateRootComponent(\n prevComponent,\n nextElement,\n container,\n callback\n ).getPublicInstance();\n } else {\n ReactMount.unmountComponentAtNode(container);\n }\n }\n\n var reactRootElement = getReactRootElementInContainer(container);\n var containerHasReactMarkup =\n reactRootElement && ReactMount.isRenderedByReact(reactRootElement);\n\n if (false) {\n if (!containerHasReactMarkup || reactRootElement.nextSibling) {\n var rootElementSibling = reactRootElement;\n while (rootElementSibling) {\n if (ReactMount.isRenderedByReact(rootElementSibling)) {\n (\"production\" !== process.env.NODE_ENV ? warning(\n false,\n 'render(): Target node has markup rendered by React, but there ' +\n 'are unrelated nodes as well. This is most commonly caused by ' +\n 'white-space inserted around server-rendered markup.'\n ) : null);\n break;\n }\n\n rootElementSibling = rootElementSibling.nextSibling;\n }\n }\n }\n\n var shouldReuseMarkup = containerHasReactMarkup && !prevComponent;\n\n var component = ReactMount._renderNewRootComponent(\n nextElement,\n container,\n shouldReuseMarkup\n ).getPublicInstance();\n if (callback) {\n callback.call(component);\n }\n return component;\n },\n\n /**\n * Constructs a component instance of `constructor` with `initialProps` and\n * renders it into the supplied `container`.\n *\n * @param {function} constructor React component constructor.\n * @param {?object} props Initial props of the component instance.\n * @param {DOMElement} container DOM element to render into.\n * @return {ReactComponent} Component instance rendered in `container`.\n */\n constructAndRenderComponent: function(constructor, props, container) {\n var element = ReactElement.createElement(constructor, props);\n return ReactMount.render(element, container);\n },\n\n /**\n * Constructs a component instance of `constructor` with `initialProps` and\n * renders it into a container node identified by supplied `id`.\n *\n * @param {function} componentConstructor React component constructor\n * @param {?object} props Initial props of the component instance.\n * @param {string} id ID of the DOM element to render into.\n * @return {ReactComponent} Component instance rendered in the container node.\n */\n constructAndRenderComponentByID: function(constructor, props, id) {\n var domNode = document.getElementById(id);\n (false ? invariant(\n domNode,\n 'Tried to get element with id of \"%s\" but it is not present on the page.',\n id\n ) : invariant(domNode));\n return ReactMount.constructAndRenderComponent(constructor, props, domNode);\n },\n\n /**\n * Registers a container node into which React components will be rendered.\n * This also creates the \"reactRoot\" ID that will be assigned to the element\n * rendered within.\n *\n * @param {DOMElement} container DOM element to register as a container.\n * @return {string} The \"reactRoot\" ID of elements rendered within.\n */\n registerContainer: function(container) {\n var reactRootID = getReactRootID(container);\n if (reactRootID) {\n // If one exists, make sure it is a valid \"reactRoot\" ID.\n reactRootID = ReactInstanceHandles.getReactRootIDFromNodeID(reactRootID);\n }\n if (!reactRootID) {\n // No valid \"reactRoot\" ID found, create one.\n reactRootID = ReactInstanceHandles.createReactRootID();\n }\n containersByReactRootID[reactRootID] = container;\n return reactRootID;\n },\n\n /**\n * Unmounts and destroys the React component rendered in the `container`.\n *\n * @param {DOMElement} container DOM element containing a React component.\n * @return {boolean} True if a component was found in and unmounted from\n * `container`\n */\n unmountComponentAtNode: function(container) {\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. (Strictly speaking, unmounting won't cause a\n // render but we still don't expect to be in a render call here.)\n (false ? warning(\n ReactCurrentOwner.current == null,\n 'unmountComponentAtNode(): Render methods should be a pure function of ' +\n 'props and state; triggering nested component updates from render is ' +\n 'not allowed. If necessary, trigger nested updates in ' +\n 'componentDidUpdate.'\n ) : null);\n\n (false ? invariant(\n container && (\n (container.nodeType === ELEMENT_NODE_TYPE || container.nodeType === DOC_NODE_TYPE)\n ),\n 'unmountComponentAtNode(...): Target container is not a DOM element.'\n ) : invariant(container && (\n (container.nodeType === ELEMENT_NODE_TYPE || container.nodeType === DOC_NODE_TYPE)\n )));\n\n var reactRootID = getReactRootID(container);\n var component = instancesByReactRootID[reactRootID];\n if (!component) {\n return false;\n }\n ReactMount.unmountComponentFromNode(component, container);\n delete instancesByReactRootID[reactRootID];\n delete containersByReactRootID[reactRootID];\n if (false) {\n delete rootElementsByReactRootID[reactRootID];\n }\n return true;\n },\n\n /**\n * Unmounts a component and removes it from the DOM.\n *\n * @param {ReactComponent} instance React component instance.\n * @param {DOMElement} container DOM element to unmount from.\n * @final\n * @internal\n * @see {ReactMount.unmountComponentAtNode}\n */\n unmountComponentFromNode: function(instance, container) {\n ReactReconciler.unmountComponent(instance);\n\n if (container.nodeType === DOC_NODE_TYPE) {\n container = container.documentElement;\n }\n\n // http://jsperf.com/emptying-a-node\n while (container.lastChild) {\n container.removeChild(container.lastChild);\n }\n },\n\n /**\n * Finds the container DOM element that contains React component to which the\n * supplied DOM `id` belongs.\n *\n * @param {string} id The ID of an element rendered by a React component.\n * @return {?DOMElement} DOM element that contains the `id`.\n */\n findReactContainerForID: function(id) {\n var reactRootID = ReactInstanceHandles.getReactRootIDFromNodeID(id);\n var container = containersByReactRootID[reactRootID];\n\n if (false) {\n var rootElement = rootElementsByReactRootID[reactRootID];\n if (rootElement && rootElement.parentNode !== container) {\n (\"production\" !== process.env.NODE_ENV ? invariant(\n // Call internalGetID here because getID calls isValid which calls\n // findReactContainerForID (this function).\n internalGetID(rootElement) === reactRootID,\n 'ReactMount: Root element ID differed from reactRootID.'\n ) : invariant(// Call internalGetID here because getID calls isValid which calls\n // findReactContainerForID (this function).\n internalGetID(rootElement) === reactRootID));\n\n var containerChild = container.firstChild;\n if (containerChild &&\n reactRootID === internalGetID(containerChild)) {\n // If the container has a new child with the same ID as the old\n // root element, then rootElementsByReactRootID[reactRootID] is\n // just stale and needs to be updated. The case that deserves a\n // warning is when the container is empty.\n rootElementsByReactRootID[reactRootID] = containerChild;\n } else {\n (\"production\" !== process.env.NODE_ENV ? warning(\n false,\n 'ReactMount: Root element has been removed from its original ' +\n 'container. New container:', rootElement.parentNode\n ) : null);\n }\n }\n }\n\n return container;\n },\n\n /**\n * Finds an element rendered by React with the supplied ID.\n *\n * @param {string} id ID of a DOM node in the React component.\n * @return {DOMElement} Root DOM node of the React component.\n */\n findReactNodeByID: function(id) {\n var reactRoot = ReactMount.findReactContainerForID(id);\n return ReactMount.findComponentRoot(reactRoot, id);\n },\n\n /**\n * True if the supplied `node` is rendered by React.\n *\n * @param {*} node DOM Element to check.\n * @return {boolean} True if the DOM Element appears to be rendered by React.\n * @internal\n */\n isRenderedByReact: function(node) {\n if (node.nodeType !== 1) {\n // Not a DOMElement, therefore not a React component\n return false;\n }\n var id = ReactMount.getID(node);\n return id ? id.charAt(0) === SEPARATOR : false;\n },\n\n /**\n * Traverses up the ancestors of the supplied node to find a node that is a\n * DOM representation of a React component.\n *\n * @param {*} node\n * @return {?DOMEventTarget}\n * @internal\n */\n getFirstReactDOM: function(node) {\n var current = node;\n while (current && current.parentNode !== current) {\n if (ReactMount.isRenderedByReact(current)) {\n return current;\n }\n current = current.parentNode;\n }\n return null;\n },\n\n /**\n * Finds a node with the supplied `targetID` inside of the supplied\n * `ancestorNode`. Exploits the ID naming scheme to perform the search\n * quickly.\n *\n * @param {DOMEventTarget} ancestorNode Search from this root.\n * @pararm {string} targetID ID of the DOM representation of the component.\n * @return {DOMEventTarget} DOM node with the supplied `targetID`.\n * @internal\n */\n findComponentRoot: function(ancestorNode, targetID) {\n var firstChildren = findComponentRootReusableArray;\n var childIndex = 0;\n\n var deepestAncestor = findDeepestCachedAncestor(targetID) || ancestorNode;\n\n firstChildren[0] = deepestAncestor.firstChild;\n firstChildren.length = 1;\n\n while (childIndex < firstChildren.length) {\n var child = firstChildren[childIndex++];\n var targetChild;\n\n while (child) {\n var childID = ReactMount.getID(child);\n if (childID) {\n // Even if we find the node we're looking for, we finish looping\n // through its siblings to ensure they're cached so that we don't have\n // to revisit this node again. Otherwise, we make n^2 calls to getID\n // when visiting the many children of a single node in order.\n\n if (targetID === childID) {\n targetChild = child;\n } else if (ReactInstanceHandles.isAncestorIDOf(childID, targetID)) {\n // If we find a child whose ID is an ancestor of the given ID,\n // then we can be sure that we only want to search the subtree\n // rooted at this child, so we can throw out the rest of the\n // search state.\n firstChildren.length = childIndex = 0;\n firstChildren.push(child.firstChild);\n }\n\n } else {\n // If this child had no ID, then there's a chance that it was\n // injected automatically by the browser, as when a ``\n // element sprouts an extra `` child as a side effect of\n // `.innerHTML` parsing. Optimistically continue down this\n // branch, but not before examining the other siblings.\n firstChildren.push(child.firstChild);\n }\n\n child = child.nextSibling;\n }\n\n if (targetChild) {\n // Emptying firstChildren/findComponentRootReusableArray is\n // not necessary for correctness, but it helps the GC reclaim\n // any nodes that were left at the end of the search.\n firstChildren.length = 0;\n\n return targetChild;\n }\n }\n\n firstChildren.length = 0;\n\n (false ? invariant(\n false,\n 'findComponentRoot(..., %s): Unable to find element. This probably ' +\n 'means the DOM was unexpectedly mutated (e.g., by the browser), ' +\n 'usually due to forgetting a when using tables, nesting tags ' +\n 'like