/**1* React v0.13.32*/3(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.React = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){4/**5* Copyright 2013-2015, Facebook, Inc.6* All rights reserved.7*8* This source code is licensed under the BSD-style license found in the9* LICENSE file in the root directory of this source tree. An additional grant10* of patent rights can be found in the PATENTS file in the same directory.11*12* @providesModule React13*/1415/* globals __REACT_DEVTOOLS_GLOBAL_HOOK__*/1617'use strict';1819var EventPluginUtils = _dereq_(19);20var ReactChildren = _dereq_(32);21var ReactComponent = _dereq_(34);22var ReactClass = _dereq_(33);23var ReactContext = _dereq_(38);24var ReactCurrentOwner = _dereq_(39);25var ReactElement = _dereq_(57);26var ReactElementValidator = _dereq_(58);27var ReactDOM = _dereq_(40);28var ReactDOMTextComponent = _dereq_(51);29var ReactDefaultInjection = _dereq_(54);30var ReactInstanceHandles = _dereq_(66);31var ReactMount = _dereq_(70);32var ReactPerf = _dereq_(75);33var ReactPropTypes = _dereq_(78);34var ReactReconciler = _dereq_(81);35var ReactServerRendering = _dereq_(84);3637var assign = _dereq_(27);38var findDOMNode = _dereq_(117);39var onlyChild = _dereq_(144);4041ReactDefaultInjection.inject();4243var createElement = ReactElement.createElement;44var createFactory = ReactElement.createFactory;45var cloneElement = ReactElement.cloneElement;4647if ("production" !== "development") {48createElement = ReactElementValidator.createElement;49createFactory = ReactElementValidator.createFactory;50cloneElement = ReactElementValidator.cloneElement;51}5253var render = ReactPerf.measure('React', 'render', ReactMount.render);5455var React = {56Children: {57map: ReactChildren.map,58forEach: ReactChildren.forEach,59count: ReactChildren.count,60only: onlyChild61},62Component: ReactComponent,63DOM: ReactDOM,64PropTypes: ReactPropTypes,65initializeTouchEvents: function(shouldUseTouch) {66EventPluginUtils.useTouchEvents = shouldUseTouch;67},68createClass: ReactClass.createClass,69createElement: createElement,70cloneElement: cloneElement,71createFactory: createFactory,72createMixin: function(mixin) {73// Currently a noop. Will be used to validate and trace mixins.74return mixin;75},76constructAndRenderComponent: ReactMount.constructAndRenderComponent,77constructAndRenderComponentByID: ReactMount.constructAndRenderComponentByID,78findDOMNode: findDOMNode,79render: render,80renderToString: ReactServerRendering.renderToString,81renderToStaticMarkup: ReactServerRendering.renderToStaticMarkup,82unmountComponentAtNode: ReactMount.unmountComponentAtNode,83isValidElement: ReactElement.isValidElement,84withContext: ReactContext.withContext,8586// Hook for JSX spread, don't use this for anything else.87__spread: assign88};8990// Inject the runtime into a devtools global hook regardless of browser.91// Allows for debugging when the hook is injected on the page.92if (93typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&94typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.inject === 'function') {95__REACT_DEVTOOLS_GLOBAL_HOOK__.inject({96CurrentOwner: ReactCurrentOwner,97InstanceHandles: ReactInstanceHandles,98Mount: ReactMount,99Reconciler: ReactReconciler,100TextComponent: ReactDOMTextComponent101});102}103104if ("production" !== "development") {105var ExecutionEnvironment = _dereq_(21);106if (ExecutionEnvironment.canUseDOM && window.top === window.self) {107108// If we're in Chrome, look for the devtools marker and provide a download109// link if not installed.110if (navigator.userAgent.indexOf('Chrome') > -1) {111if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === 'undefined') {112console.debug(113'Download the React DevTools for a better development experience: ' +114'https://fb.me/react-devtools'115);116}117}118119var expectedFeatures = [120// shims121Array.isArray,122Array.prototype.every,123Array.prototype.forEach,124Array.prototype.indexOf,125Array.prototype.map,126Date.now,127Function.prototype.bind,128Object.keys,129String.prototype.split,130String.prototype.trim,131132// shams133Object.create,134Object.freeze135];136137for (var i = 0; i < expectedFeatures.length; i++) {138if (!expectedFeatures[i]) {139console.error(140'One or more ES5 shim/shams expected by React are not available: ' +141'https://fb.me/react-warning-polyfills'142);143break;144}145}146}147}148149React.version = '0.13.3';150151module.exports = React;152153},{"117":117,"144":144,"19":19,"21":21,"27":27,"32":32,"33":33,"34":34,"38":38,"39":39,"40":40,"51":51,"54":54,"57":57,"58":58,"66":66,"70":70,"75":75,"78":78,"81":81,"84":84}],2:[function(_dereq_,module,exports){154/**155* Copyright 2013-2015, Facebook, Inc.156* All rights reserved.157*158* This source code is licensed under the BSD-style license found in the159* LICENSE file in the root directory of this source tree. An additional grant160* of patent rights can be found in the PATENTS file in the same directory.161*162* @providesModule AutoFocusMixin163* @typechecks static-only164*/165166'use strict';167168var focusNode = _dereq_(119);169170var AutoFocusMixin = {171componentDidMount: function() {172if (this.props.autoFocus) {173focusNode(this.getDOMNode());174}175}176};177178module.exports = AutoFocusMixin;179180},{"119":119}],3:[function(_dereq_,module,exports){181/**182* Copyright 2013-2015 Facebook, Inc.183* All rights reserved.184*185* This source code is licensed under the BSD-style license found in the186* LICENSE file in the root directory of this source tree. An additional grant187* of patent rights can be found in the PATENTS file in the same directory.188*189* @providesModule BeforeInputEventPlugin190* @typechecks static-only191*/192193'use strict';194195var EventConstants = _dereq_(15);196var EventPropagators = _dereq_(20);197var ExecutionEnvironment = _dereq_(21);198var FallbackCompositionState = _dereq_(22);199var SyntheticCompositionEvent = _dereq_(93);200var SyntheticInputEvent = _dereq_(97);201202var keyOf = _dereq_(141);203204var END_KEYCODES = [9, 13, 27, 32]; // Tab, Return, Esc, Space205var START_KEYCODE = 229;206207var canUseCompositionEvent = (208ExecutionEnvironment.canUseDOM &&209'CompositionEvent' in window210);211212var documentMode = null;213if (ExecutionEnvironment.canUseDOM && 'documentMode' in document) {214documentMode = document.documentMode;215}216217// Webkit offers a very useful `textInput` event that can be used to218// directly represent `beforeInput`. The IE `textinput` event is not as219// useful, so we don't use it.220var canUseTextInputEvent = (221ExecutionEnvironment.canUseDOM &&222'TextEvent' in window &&223!documentMode &&224!isPresto()225);226227// In IE9+, we have access to composition events, but the data supplied228// by the native compositionend event may be incorrect. Japanese ideographic229// spaces, for instance (\u3000) are not recorded correctly.230var useFallbackCompositionData = (231ExecutionEnvironment.canUseDOM &&232(233(!canUseCompositionEvent || documentMode && documentMode > 8 && documentMode <= 11)234)235);236237/**238* Opera <= 12 includes TextEvent in window, but does not fire239* text input events. Rely on keypress instead.240*/241function isPresto() {242var opera = window.opera;243return (244typeof opera === 'object' &&245typeof opera.version === 'function' &&246parseInt(opera.version(), 10) <= 12247);248}249250var SPACEBAR_CODE = 32;251var SPACEBAR_CHAR = String.fromCharCode(SPACEBAR_CODE);252253var topLevelTypes = EventConstants.topLevelTypes;254255// Events and their corresponding property names.256var eventTypes = {257beforeInput: {258phasedRegistrationNames: {259bubbled: keyOf({onBeforeInput: null}),260captured: keyOf({onBeforeInputCapture: null})261},262dependencies: [263topLevelTypes.topCompositionEnd,264topLevelTypes.topKeyPress,265topLevelTypes.topTextInput,266topLevelTypes.topPaste267]268},269compositionEnd: {270phasedRegistrationNames: {271bubbled: keyOf({onCompositionEnd: null}),272captured: keyOf({onCompositionEndCapture: null})273},274dependencies: [275topLevelTypes.topBlur,276topLevelTypes.topCompositionEnd,277topLevelTypes.topKeyDown,278topLevelTypes.topKeyPress,279topLevelTypes.topKeyUp,280topLevelTypes.topMouseDown281]282},283compositionStart: {284phasedRegistrationNames: {285bubbled: keyOf({onCompositionStart: null}),286captured: keyOf({onCompositionStartCapture: null})287},288dependencies: [289topLevelTypes.topBlur,290topLevelTypes.topCompositionStart,291topLevelTypes.topKeyDown,292topLevelTypes.topKeyPress,293topLevelTypes.topKeyUp,294topLevelTypes.topMouseDown295]296},297compositionUpdate: {298phasedRegistrationNames: {299bubbled: keyOf({onCompositionUpdate: null}),300captured: keyOf({onCompositionUpdateCapture: null})301},302dependencies: [303topLevelTypes.topBlur,304topLevelTypes.topCompositionUpdate,305topLevelTypes.topKeyDown,306topLevelTypes.topKeyPress,307topLevelTypes.topKeyUp,308topLevelTypes.topMouseDown309]310}311};312313// Track whether we've ever handled a keypress on the space key.314var hasSpaceKeypress = false;315316/**317* Return whether a native keypress event is assumed to be a command.318* This is required because Firefox fires `keypress` events for key commands319* (cut, copy, select-all, etc.) even though no character is inserted.320*/321function isKeypressCommand(nativeEvent) {322return (323(nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) &&324// ctrlKey && altKey is equivalent to AltGr, and is not a command.325!(nativeEvent.ctrlKey && nativeEvent.altKey)326);327}328329330/**331* Translate native top level events into event types.332*333* @param {string} topLevelType334* @return {object}335*/336function getCompositionEventType(topLevelType) {337switch (topLevelType) {338case topLevelTypes.topCompositionStart:339return eventTypes.compositionStart;340case topLevelTypes.topCompositionEnd:341return eventTypes.compositionEnd;342case topLevelTypes.topCompositionUpdate:343return eventTypes.compositionUpdate;344}345}346347/**348* Does our fallback best-guess model think this event signifies that349* composition has begun?350*351* @param {string} topLevelType352* @param {object} nativeEvent353* @return {boolean}354*/355function isFallbackCompositionStart(topLevelType, nativeEvent) {356return (357topLevelType === topLevelTypes.topKeyDown &&358nativeEvent.keyCode === START_KEYCODE359);360}361362/**363* Does our fallback mode think that this event is the end of composition?364*365* @param {string} topLevelType366* @param {object} nativeEvent367* @return {boolean}368*/369function isFallbackCompositionEnd(topLevelType, nativeEvent) {370switch (topLevelType) {371case topLevelTypes.topKeyUp:372// Command keys insert or clear IME input.373return (END_KEYCODES.indexOf(nativeEvent.keyCode) !== -1);374case topLevelTypes.topKeyDown:375// Expect IME keyCode on each keydown. If we get any other376// code we must have exited earlier.377return (nativeEvent.keyCode !== START_KEYCODE);378case topLevelTypes.topKeyPress:379case topLevelTypes.topMouseDown:380case topLevelTypes.topBlur:381// Events are not possible without cancelling IME.382return true;383default:384return false;385}386}387388/**389* Google Input Tools provides composition data via a CustomEvent,390* with the `data` property populated in the `detail` object. If this391* is available on the event object, use it. If not, this is a plain392* composition event and we have nothing special to extract.393*394* @param {object} nativeEvent395* @return {?string}396*/397function getDataFromCustomEvent(nativeEvent) {398var detail = nativeEvent.detail;399if (typeof detail === 'object' && 'data' in detail) {400return detail.data;401}402return null;403}404405// Track the current IME composition fallback object, if any.406var currentComposition = null;407408/**409* @param {string} topLevelType Record from `EventConstants`.410* @param {DOMEventTarget} topLevelTarget The listening component root node.411* @param {string} topLevelTargetID ID of `topLevelTarget`.412* @param {object} nativeEvent Native browser event.413* @return {?object} A SyntheticCompositionEvent.414*/415function extractCompositionEvent(416topLevelType,417topLevelTarget,418topLevelTargetID,419nativeEvent420) {421var eventType;422var fallbackData;423424if (canUseCompositionEvent) {425eventType = getCompositionEventType(topLevelType);426} else if (!currentComposition) {427if (isFallbackCompositionStart(topLevelType, nativeEvent)) {428eventType = eventTypes.compositionStart;429}430} else if (isFallbackCompositionEnd(topLevelType, nativeEvent)) {431eventType = eventTypes.compositionEnd;432}433434if (!eventType) {435return null;436}437438if (useFallbackCompositionData) {439// The current composition is stored statically and must not be440// overwritten while composition continues.441if (!currentComposition && eventType === eventTypes.compositionStart) {442currentComposition = FallbackCompositionState.getPooled(topLevelTarget);443} else if (eventType === eventTypes.compositionEnd) {444if (currentComposition) {445fallbackData = currentComposition.getData();446}447}448}449450var event = SyntheticCompositionEvent.getPooled(451eventType,452topLevelTargetID,453nativeEvent454);455456if (fallbackData) {457// Inject data generated from fallback path into the synthetic event.458// This matches the property of native CompositionEventInterface.459event.data = fallbackData;460} else {461var customData = getDataFromCustomEvent(nativeEvent);462if (customData !== null) {463event.data = customData;464}465}466467EventPropagators.accumulateTwoPhaseDispatches(event);468return event;469}470471/**472* @param {string} topLevelType Record from `EventConstants`.473* @param {object} nativeEvent Native browser event.474* @return {?string} The string corresponding to this `beforeInput` event.475*/476function getNativeBeforeInputChars(topLevelType, nativeEvent) {477switch (topLevelType) {478case topLevelTypes.topCompositionEnd:479return getDataFromCustomEvent(nativeEvent);480case topLevelTypes.topKeyPress:481/**482* If native `textInput` events are available, our goal is to make483* use of them. However, there is a special case: the spacebar key.484* In Webkit, preventing default on a spacebar `textInput` event485* cancels character insertion, but it *also* causes the browser486* to fall back to its default spacebar behavior of scrolling the487* page.488*489* Tracking at:490* https://code.google.com/p/chromium/issues/detail?id=355103491*492* To avoid this issue, use the keypress event as if no `textInput`493* event is available.494*/495var which = nativeEvent.which;496if (which !== SPACEBAR_CODE) {497return null;498}499500hasSpaceKeypress = true;501return SPACEBAR_CHAR;502503case topLevelTypes.topTextInput:504// Record the characters to be added to the DOM.505var chars = nativeEvent.data;506507// If it's a spacebar character, assume that we have already handled508// it at the keypress level and bail immediately. Android Chrome509// doesn't give us keycodes, so we need to blacklist it.510if (chars === SPACEBAR_CHAR && hasSpaceKeypress) {511return null;512}513514return chars;515516default:517// For other native event types, do nothing.518return null;519}520}521522/**523* For browsers that do not provide the `textInput` event, extract the524* appropriate string to use for SyntheticInputEvent.525*526* @param {string} topLevelType Record from `EventConstants`.527* @param {object} nativeEvent Native browser event.528* @return {?string} The fallback string for this `beforeInput` event.529*/530function getFallbackBeforeInputChars(topLevelType, nativeEvent) {531// If we are currently composing (IME) and using a fallback to do so,532// try to extract the composed characters from the fallback object.533if (currentComposition) {534if (535topLevelType === topLevelTypes.topCompositionEnd ||536isFallbackCompositionEnd(topLevelType, nativeEvent)537) {538var chars = currentComposition.getData();539FallbackCompositionState.release(currentComposition);540currentComposition = null;541return chars;542}543return null;544}545546switch (topLevelType) {547case topLevelTypes.topPaste:548// If a paste event occurs after a keypress, throw out the input549// chars. Paste events should not lead to BeforeInput events.550return null;551case topLevelTypes.topKeyPress:552/**553* As of v27, Firefox may fire keypress events even when no character554* will be inserted. A few possibilities:555*556* - `which` is `0`. Arrow keys, Esc key, etc.557*558* - `which` is the pressed key code, but no char is available.559* Ex: 'AltGr + d` in Polish. There is no modified character for560* this key combination and no character is inserted into the561* document, but FF fires the keypress for char code `100` anyway.562* No `input` event will occur.563*564* - `which` is the pressed key code, but a command combination is565* being used. Ex: `Cmd+C`. No character is inserted, and no566* `input` event will occur.567*/568if (nativeEvent.which && !isKeypressCommand(nativeEvent)) {569return String.fromCharCode(nativeEvent.which);570}571return null;572case topLevelTypes.topCompositionEnd:573return useFallbackCompositionData ? null : nativeEvent.data;574default:575return null;576}577}578579/**580* Extract a SyntheticInputEvent for `beforeInput`, based on either native581* `textInput` or fallback behavior.582*583* @param {string} topLevelType Record from `EventConstants`.584* @param {DOMEventTarget} topLevelTarget The listening component root node.585* @param {string} topLevelTargetID ID of `topLevelTarget`.586* @param {object} nativeEvent Native browser event.587* @return {?object} A SyntheticInputEvent.588*/589function extractBeforeInputEvent(590topLevelType,591topLevelTarget,592topLevelTargetID,593nativeEvent594) {595var chars;596597if (canUseTextInputEvent) {598chars = getNativeBeforeInputChars(topLevelType, nativeEvent);599} else {600chars = getFallbackBeforeInputChars(topLevelType, nativeEvent);601}602603// If no characters are being inserted, no BeforeInput event should604// be fired.605if (!chars) {606return null;607}608609var event = SyntheticInputEvent.getPooled(610eventTypes.beforeInput,611topLevelTargetID,612nativeEvent613);614615event.data = chars;616EventPropagators.accumulateTwoPhaseDispatches(event);617return event;618}619620/**621* Create an `onBeforeInput` event to match622* http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105/#events-inputevents.623*624* This event plugin is based on the native `textInput` event625* available in Chrome, Safari, Opera, and IE. This event fires after626* `onKeyPress` and `onCompositionEnd`, but before `onInput`.627*628* `beforeInput` is spec'd but not implemented in any browsers, and629* the `input` event does not provide any useful information about what has630* actually been added, contrary to the spec. Thus, `textInput` is the best631* available event to identify the characters that have actually been inserted632* into the target node.633*634* This plugin is also responsible for emitting `composition` events, thus635* allowing us to share composition fallback code for both `beforeInput` and636* `composition` event types.637*/638var BeforeInputEventPlugin = {639640eventTypes: eventTypes,641642/**643* @param {string} topLevelType Record from `EventConstants`.644* @param {DOMEventTarget} topLevelTarget The listening component root node.645* @param {string} topLevelTargetID ID of `topLevelTarget`.646* @param {object} nativeEvent Native browser event.647* @return {*} An accumulation of synthetic events.648* @see {EventPluginHub.extractEvents}649*/650extractEvents: function(651topLevelType,652topLevelTarget,653topLevelTargetID,654nativeEvent655) {656return [657extractCompositionEvent(658topLevelType,659topLevelTarget,660topLevelTargetID,661nativeEvent662),663extractBeforeInputEvent(664topLevelType,665topLevelTarget,666topLevelTargetID,667nativeEvent668)669];670}671};672673module.exports = BeforeInputEventPlugin;674675},{"141":141,"15":15,"20":20,"21":21,"22":22,"93":93,"97":97}],4:[function(_dereq_,module,exports){676/**677* Copyright 2013-2015, Facebook, Inc.678* All rights reserved.679*680* This source code is licensed under the BSD-style license found in the681* LICENSE file in the root directory of this source tree. An additional grant682* of patent rights can be found in the PATENTS file in the same directory.683*684* @providesModule CSSProperty685*/686687'use strict';688689/**690* CSS properties which accept numbers but are not in units of "px".691*/692var isUnitlessNumber = {693boxFlex: true,694boxFlexGroup: true,695columnCount: true,696flex: true,697flexGrow: true,698flexPositive: true,699flexShrink: true,700flexNegative: true,701fontWeight: true,702lineClamp: true,703lineHeight: true,704opacity: true,705order: true,706orphans: true,707widows: true,708zIndex: true,709zoom: true,710711// SVG-related properties712fillOpacity: true,713strokeDashoffset: true,714strokeOpacity: true,715strokeWidth: true716};717718/**719* @param {string} prefix vendor-specific prefix, eg: Webkit720* @param {string} key style name, eg: transitionDuration721* @return {string} style name prefixed with `prefix`, properly camelCased, eg:722* WebkitTransitionDuration723*/724function prefixKey(prefix, key) {725return prefix + key.charAt(0).toUpperCase() + key.substring(1);726}727728/**729* Support style names that may come passed in prefixed by adding permutations730* of vendor prefixes.731*/732var prefixes = ['Webkit', 'ms', 'Moz', 'O'];733734// Using Object.keys here, or else the vanilla for-in loop makes IE8 go into an735// infinite loop, because it iterates over the newly added props too.736Object.keys(isUnitlessNumber).forEach(function(prop) {737prefixes.forEach(function(prefix) {738isUnitlessNumber[prefixKey(prefix, prop)] = isUnitlessNumber[prop];739});740});741742/**743* Most style properties can be unset by doing .style[prop] = '' but IE8744* doesn't like doing that with shorthand properties so for the properties that745* IE8 breaks on, which are listed here, we instead unset each of the746* individual properties. See http://bugs.jquery.com/ticket/12385.747* The 4-value 'clock' properties like margin, padding, border-width seem to748* behave without any problems. Curiously, list-style works too without any749* special prodding.750*/751var shorthandPropertyExpansions = {752background: {753backgroundImage: true,754backgroundPosition: true,755backgroundRepeat: true,756backgroundColor: true757},758border: {759borderWidth: true,760borderStyle: true,761borderColor: true762},763borderBottom: {764borderBottomWidth: true,765borderBottomStyle: true,766borderBottomColor: true767},768borderLeft: {769borderLeftWidth: true,770borderLeftStyle: true,771borderLeftColor: true772},773borderRight: {774borderRightWidth: true,775borderRightStyle: true,776borderRightColor: true777},778borderTop: {779borderTopWidth: true,780borderTopStyle: true,781borderTopColor: true782},783font: {784fontStyle: true,785fontVariant: true,786fontWeight: true,787fontSize: true,788lineHeight: true,789fontFamily: true790}791};792793var CSSProperty = {794isUnitlessNumber: isUnitlessNumber,795shorthandPropertyExpansions: shorthandPropertyExpansions796};797798module.exports = CSSProperty;799800},{}],5:[function(_dereq_,module,exports){801/**802* Copyright 2013-2015, Facebook, Inc.803* All rights reserved.804*805* This source code is licensed under the BSD-style license found in the806* LICENSE file in the root directory of this source tree. An additional grant807* of patent rights can be found in the PATENTS file in the same directory.808*809* @providesModule CSSPropertyOperations810* @typechecks static-only811*/812813'use strict';814815var CSSProperty = _dereq_(4);816var ExecutionEnvironment = _dereq_(21);817818var camelizeStyleName = _dereq_(108);819var dangerousStyleValue = _dereq_(113);820var hyphenateStyleName = _dereq_(133);821var memoizeStringOnly = _dereq_(143);822var warning = _dereq_(154);823824var processStyleName = memoizeStringOnly(function(styleName) {825return hyphenateStyleName(styleName);826});827828var styleFloatAccessor = 'cssFloat';829if (ExecutionEnvironment.canUseDOM) {830// IE8 only supports accessing cssFloat (standard) as styleFloat831if (document.documentElement.style.cssFloat === undefined) {832styleFloatAccessor = 'styleFloat';833}834}835836if ("production" !== "development") {837// 'msTransform' is correct, but the other prefixes should be capitalized838var badVendoredStyleNamePattern = /^(?:webkit|moz|o)[A-Z]/;839840// style values shouldn't contain a semicolon841var badStyleValueWithSemicolonPattern = /;\s*$/;842843var warnedStyleNames = {};844var warnedStyleValues = {};845846var warnHyphenatedStyleName = function(name) {847if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {848return;849}850851warnedStyleNames[name] = true;852("production" !== "development" ? warning(853false,854'Unsupported style property %s. Did you mean %s?',855name,856camelizeStyleName(name)857) : null);858};859860var warnBadVendoredStyleName = function(name) {861if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {862return;863}864865warnedStyleNames[name] = true;866("production" !== "development" ? warning(867false,868'Unsupported vendor-prefixed style property %s. Did you mean %s?',869name,870name.charAt(0).toUpperCase() + name.slice(1)871) : null);872};873874var warnStyleValueWithSemicolon = function(name, value) {875if (warnedStyleValues.hasOwnProperty(value) && warnedStyleValues[value]) {876return;877}878879warnedStyleValues[value] = true;880("production" !== "development" ? warning(881false,882'Style property values shouldn\'t contain a semicolon. ' +883'Try "%s: %s" instead.',884name,885value.replace(badStyleValueWithSemicolonPattern, '')886) : null);887};888889/**890* @param {string} name891* @param {*} value892*/893var warnValidStyle = function(name, value) {894if (name.indexOf('-') > -1) {895warnHyphenatedStyleName(name);896} else if (badVendoredStyleNamePattern.test(name)) {897warnBadVendoredStyleName(name);898} else if (badStyleValueWithSemicolonPattern.test(value)) {899warnStyleValueWithSemicolon(name, value);900}901};902}903904/**905* Operations for dealing with CSS properties.906*/907var CSSPropertyOperations = {908909/**910* Serializes a mapping of style properties for use as inline styles:911*912* > createMarkupForStyles({width: '200px', height: 0})913* "width:200px;height:0;"914*915* Undefined values are ignored so that declarative programming is easier.916* The result should be HTML-escaped before insertion into the DOM.917*918* @param {object} styles919* @return {?string}920*/921createMarkupForStyles: function(styles) {922var serialized = '';923for (var styleName in styles) {924if (!styles.hasOwnProperty(styleName)) {925continue;926}927var styleValue = styles[styleName];928if ("production" !== "development") {929warnValidStyle(styleName, styleValue);930}931if (styleValue != null) {932serialized += processStyleName(styleName) + ':';933serialized += dangerousStyleValue(styleName, styleValue) + ';';934}935}936return serialized || null;937},938939/**940* Sets the value for multiple styles on a node. If a value is specified as941* '' (empty string), the corresponding style property will be unset.942*943* @param {DOMElement} node944* @param {object} styles945*/946setValueForStyles: function(node, styles) {947var style = node.style;948for (var styleName in styles) {949if (!styles.hasOwnProperty(styleName)) {950continue;951}952if ("production" !== "development") {953warnValidStyle(styleName, styles[styleName]);954}955var styleValue = dangerousStyleValue(styleName, styles[styleName]);956if (styleName === 'float') {957styleName = styleFloatAccessor;958}959if (styleValue) {960style[styleName] = styleValue;961} else {962var expansion = CSSProperty.shorthandPropertyExpansions[styleName];963if (expansion) {964// Shorthand property that IE8 won't like unsetting, so unset each965// component to placate it966for (var individualStyleName in expansion) {967style[individualStyleName] = '';968}969} else {970style[styleName] = '';971}972}973}974}975976};977978module.exports = CSSPropertyOperations;979980},{"108":108,"113":113,"133":133,"143":143,"154":154,"21":21,"4":4}],6:[function(_dereq_,module,exports){981/**982* Copyright 2013-2015, Facebook, Inc.983* All rights reserved.984*985* This source code is licensed under the BSD-style license found in the986* LICENSE file in the root directory of this source tree. An additional grant987* of patent rights can be found in the PATENTS file in the same directory.988*989* @providesModule CallbackQueue990*/991992'use strict';993994var PooledClass = _dereq_(28);995996var assign = _dereq_(27);997var invariant = _dereq_(135);998999/**1000* A specialized pseudo-event module to help keep track of components waiting to1001* be notified when their DOM representations are available for use.1002*1003* This implements `PooledClass`, so you should never need to instantiate this.1004* Instead, use `CallbackQueue.getPooled()`.1005*1006* @class ReactMountReady1007* @implements PooledClass1008* @internal1009*/1010function CallbackQueue() {1011this._callbacks = null;1012this._contexts = null;1013}10141015assign(CallbackQueue.prototype, {10161017/**1018* Enqueues a callback to be invoked when `notifyAll` is invoked.1019*1020* @param {function} callback Invoked when `notifyAll` is invoked.1021* @param {?object} context Context to call `callback` with.1022* @internal1023*/1024enqueue: function(callback, context) {1025this._callbacks = this._callbacks || [];1026this._contexts = this._contexts || [];1027this._callbacks.push(callback);1028this._contexts.push(context);1029},10301031/**1032* Invokes all enqueued callbacks and clears the queue. This is invoked after1033* the DOM representation of a component has been created or updated.1034*1035* @internal1036*/1037notifyAll: function() {1038var callbacks = this._callbacks;1039var contexts = this._contexts;1040if (callbacks) {1041("production" !== "development" ? invariant(1042callbacks.length === contexts.length,1043'Mismatched list of contexts in callback queue'1044) : invariant(callbacks.length === contexts.length));1045this._callbacks = null;1046this._contexts = null;1047for (var i = 0, l = callbacks.length; i < l; i++) {1048callbacks[i].call(contexts[i]);1049}1050callbacks.length = 0;1051contexts.length = 0;1052}1053},10541055/**1056* Resets the internal queue.1057*1058* @internal1059*/1060reset: function() {1061this._callbacks = null;1062this._contexts = null;1063},10641065/**1066* `PooledClass` looks for this.1067*/1068destructor: function() {1069this.reset();1070}10711072});10731074PooledClass.addPoolingTo(CallbackQueue);10751076module.exports = CallbackQueue;10771078},{"135":135,"27":27,"28":28}],7:[function(_dereq_,module,exports){1079/**1080* Copyright 2013-2015, Facebook, Inc.1081* All rights reserved.1082*1083* This source code is licensed under the BSD-style license found in the1084* LICENSE file in the root directory of this source tree. An additional grant1085* of patent rights can be found in the PATENTS file in the same directory.1086*1087* @providesModule ChangeEventPlugin1088*/10891090'use strict';10911092var EventConstants = _dereq_(15);1093var EventPluginHub = _dereq_(17);1094var EventPropagators = _dereq_(20);1095var ExecutionEnvironment = _dereq_(21);1096var ReactUpdates = _dereq_(87);1097var SyntheticEvent = _dereq_(95);10981099var isEventSupported = _dereq_(136);1100var isTextInputElement = _dereq_(138);1101var keyOf = _dereq_(141);11021103var topLevelTypes = EventConstants.topLevelTypes;11041105var eventTypes = {1106change: {1107phasedRegistrationNames: {1108bubbled: keyOf({onChange: null}),1109captured: keyOf({onChangeCapture: null})1110},1111dependencies: [1112topLevelTypes.topBlur,1113topLevelTypes.topChange,1114topLevelTypes.topClick,1115topLevelTypes.topFocus,1116topLevelTypes.topInput,1117topLevelTypes.topKeyDown,1118topLevelTypes.topKeyUp,1119topLevelTypes.topSelectionChange1120]1121}1122};11231124/**1125* For IE shims1126*/1127var activeElement = null;1128var activeElementID = null;1129var activeElementValue = null;1130var activeElementValueProp = null;11311132/**1133* SECTION: handle `change` event1134*/1135function shouldUseChangeEvent(elem) {1136return (1137elem.nodeName === 'SELECT' ||1138(elem.nodeName === 'INPUT' && elem.type === 'file')1139);1140}11411142var doesChangeEventBubble = false;1143if (ExecutionEnvironment.canUseDOM) {1144// See `handleChange` comment below1145doesChangeEventBubble = isEventSupported('change') && (1146(!('documentMode' in document) || document.documentMode > 8)1147);1148}11491150function manualDispatchChangeEvent(nativeEvent) {1151var event = SyntheticEvent.getPooled(1152eventTypes.change,1153activeElementID,1154nativeEvent1155);1156EventPropagators.accumulateTwoPhaseDispatches(event);11571158// If change and propertychange bubbled, we'd just bind to it like all the1159// other events and have it go through ReactBrowserEventEmitter. Since it1160// doesn't, we manually listen for the events and so we have to enqueue and1161// process the abstract event manually.1162//1163// Batching is necessary here in order to ensure that all event handlers run1164// before the next rerender (including event handlers attached to ancestor1165// elements instead of directly on the input). Without this, controlled1166// components don't work properly in conjunction with event bubbling because1167// the component is rerendered and the value reverted before all the event1168// handlers can run. See https://github.com/facebook/react/issues/708.1169ReactUpdates.batchedUpdates(runEventInBatch, event);1170}11711172function runEventInBatch(event) {1173EventPluginHub.enqueueEvents(event);1174EventPluginHub.processEventQueue();1175}11761177function startWatchingForChangeEventIE8(target, targetID) {1178activeElement = target;1179activeElementID = targetID;1180activeElement.attachEvent('onchange', manualDispatchChangeEvent);1181}11821183function stopWatchingForChangeEventIE8() {1184if (!activeElement) {1185return;1186}1187activeElement.detachEvent('onchange', manualDispatchChangeEvent);1188activeElement = null;1189activeElementID = null;1190}11911192function getTargetIDForChangeEvent(1193topLevelType,1194topLevelTarget,1195topLevelTargetID) {1196if (topLevelType === topLevelTypes.topChange) {1197return topLevelTargetID;1198}1199}1200function handleEventsForChangeEventIE8(1201topLevelType,1202topLevelTarget,1203topLevelTargetID) {1204if (topLevelType === topLevelTypes.topFocus) {1205// stopWatching() should be a noop here but we call it just in case we1206// missed a blur event somehow.1207stopWatchingForChangeEventIE8();1208startWatchingForChangeEventIE8(topLevelTarget, topLevelTargetID);1209} else if (topLevelType === topLevelTypes.topBlur) {1210stopWatchingForChangeEventIE8();1211}1212}121312141215/**1216* SECTION: handle `input` event1217*/1218var isInputEventSupported = false;1219if (ExecutionEnvironment.canUseDOM) {1220// IE9 claims to support the input event but fails to trigger it when1221// deleting text, so we ignore its input events1222isInputEventSupported = isEventSupported('input') && (1223(!('documentMode' in document) || document.documentMode > 9)1224);1225}12261227/**1228* (For old IE.) Replacement getter/setter for the `value` property that gets1229* set on the active element.1230*/1231var newValueProp = {1232get: function() {1233return activeElementValueProp.get.call(this);1234},1235set: function(val) {1236// Cast to a string so we can do equality checks.1237activeElementValue = '' + val;1238activeElementValueProp.set.call(this, val);1239}1240};12411242/**1243* (For old IE.) Starts tracking propertychange events on the passed-in element1244* and override the value property so that we can distinguish user events from1245* value changes in JS.1246*/1247function startWatchingForValueChange(target, targetID) {1248activeElement = target;1249activeElementID = targetID;1250activeElementValue = target.value;1251activeElementValueProp = Object.getOwnPropertyDescriptor(1252target.constructor.prototype,1253'value'1254);12551256Object.defineProperty(activeElement, 'value', newValueProp);1257activeElement.attachEvent('onpropertychange', handlePropertyChange);1258}12591260/**1261* (For old IE.) Removes the event listeners from the currently-tracked element,1262* if any exists.1263*/1264function stopWatchingForValueChange() {1265if (!activeElement) {1266return;1267}12681269// delete restores the original property definition1270delete activeElement.value;1271activeElement.detachEvent('onpropertychange', handlePropertyChange);12721273activeElement = null;1274activeElementID = null;1275activeElementValue = null;1276activeElementValueProp = null;1277}12781279/**1280* (For old IE.) Handles a propertychange event, sending a `change` event if1281* the value of the active element has changed.1282*/1283function handlePropertyChange(nativeEvent) {1284if (nativeEvent.propertyName !== 'value') {1285return;1286}1287var value = nativeEvent.srcElement.value;1288if (value === activeElementValue) {1289return;1290}1291activeElementValue = value;12921293manualDispatchChangeEvent(nativeEvent);1294}12951296/**1297* If a `change` event should be fired, returns the target's ID.1298*/1299function getTargetIDForInputEvent(1300topLevelType,1301topLevelTarget,1302topLevelTargetID) {1303if (topLevelType === topLevelTypes.topInput) {1304// In modern browsers (i.e., not IE8 or IE9), the input event is exactly1305// what we want so fall through here and trigger an abstract event1306return topLevelTargetID;1307}1308}13091310// For IE8 and IE9.1311function handleEventsForInputEventIE(1312topLevelType,1313topLevelTarget,1314topLevelTargetID) {1315if (topLevelType === topLevelTypes.topFocus) {1316// In IE8, we can capture almost all .value changes by adding a1317// propertychange handler and looking for events with propertyName1318// equal to 'value'1319// In IE9, propertychange fires for most input events but is buggy and1320// doesn't fire when text is deleted, but conveniently, selectionchange1321// appears to fire in all of the remaining cases so we catch those and1322// forward the event if the value has changed1323// In either case, we don't want to call the event handler if the value1324// is changed from JS so we redefine a setter for `.value` that updates1325// our activeElementValue variable, allowing us to ignore those changes1326//1327// stopWatching() should be a noop here but we call it just in case we1328// missed a blur event somehow.1329stopWatchingForValueChange();1330startWatchingForValueChange(topLevelTarget, topLevelTargetID);1331} else if (topLevelType === topLevelTypes.topBlur) {1332stopWatchingForValueChange();1333}1334}13351336// For IE8 and IE9.1337function getTargetIDForInputEventIE(1338topLevelType,1339topLevelTarget,1340topLevelTargetID) {1341if (topLevelType === topLevelTypes.topSelectionChange ||1342topLevelType === topLevelTypes.topKeyUp ||1343topLevelType === topLevelTypes.topKeyDown) {1344// On the selectionchange event, the target is just document which isn't1345// helpful for us so just check activeElement instead.1346//1347// 99% of the time, keydown and keyup aren't necessary. IE8 fails to fire1348// propertychange on the first input event after setting `value` from a1349// script and fires only keydown, keypress, keyup. Catching keyup usually1350// gets it and catching keydown lets us fire an event for the first1351// keystroke if user does a key repeat (it'll be a little delayed: right1352// before the second keystroke). Other input methods (e.g., paste) seem to1353// fire selectionchange normally.1354if (activeElement && activeElement.value !== activeElementValue) {1355activeElementValue = activeElement.value;1356return activeElementID;1357}1358}1359}136013611362/**1363* SECTION: handle `click` event1364*/1365function shouldUseClickEvent(elem) {1366// Use the `click` event to detect changes to checkbox and radio inputs.1367// This approach works across all browsers, whereas `change` does not fire1368// until `blur` in IE8.1369return (1370elem.nodeName === 'INPUT' &&1371(elem.type === 'checkbox' || elem.type === 'radio')1372);1373}13741375function getTargetIDForClickEvent(1376topLevelType,1377topLevelTarget,1378topLevelTargetID) {1379if (topLevelType === topLevelTypes.topClick) {1380return topLevelTargetID;1381}1382}13831384/**1385* This plugin creates an `onChange` event that normalizes change events1386* across form elements. This event fires at a time when it's possible to1387* change the element's value without seeing a flicker.1388*1389* Supported elements are:1390* - input (see `isTextInputElement`)1391* - textarea1392* - select1393*/1394var ChangeEventPlugin = {13951396eventTypes: eventTypes,13971398/**1399* @param {string} topLevelType Record from `EventConstants`.1400* @param {DOMEventTarget} topLevelTarget The listening component root node.1401* @param {string} topLevelTargetID ID of `topLevelTarget`.1402* @param {object} nativeEvent Native browser event.1403* @return {*} An accumulation of synthetic events.1404* @see {EventPluginHub.extractEvents}1405*/1406extractEvents: function(1407topLevelType,1408topLevelTarget,1409topLevelTargetID,1410nativeEvent) {14111412var getTargetIDFunc, handleEventFunc;1413if (shouldUseChangeEvent(topLevelTarget)) {1414if (doesChangeEventBubble) {1415getTargetIDFunc = getTargetIDForChangeEvent;1416} else {1417handleEventFunc = handleEventsForChangeEventIE8;1418}1419} else if (isTextInputElement(topLevelTarget)) {1420if (isInputEventSupported) {1421getTargetIDFunc = getTargetIDForInputEvent;1422} else {1423getTargetIDFunc = getTargetIDForInputEventIE;1424handleEventFunc = handleEventsForInputEventIE;1425}1426} else if (shouldUseClickEvent(topLevelTarget)) {1427getTargetIDFunc = getTargetIDForClickEvent;1428}14291430if (getTargetIDFunc) {1431var targetID = getTargetIDFunc(1432topLevelType,1433topLevelTarget,1434topLevelTargetID1435);1436if (targetID) {1437var event = SyntheticEvent.getPooled(1438eventTypes.change,1439targetID,1440nativeEvent1441);1442EventPropagators.accumulateTwoPhaseDispatches(event);1443return event;1444}1445}14461447if (handleEventFunc) {1448handleEventFunc(1449topLevelType,1450topLevelTarget,1451topLevelTargetID1452);1453}1454}14551456};14571458module.exports = ChangeEventPlugin;14591460},{"136":136,"138":138,"141":141,"15":15,"17":17,"20":20,"21":21,"87":87,"95":95}],8:[function(_dereq_,module,exports){1461/**1462* Copyright 2013-2015, Facebook, Inc.1463* All rights reserved.1464*1465* This source code is licensed under the BSD-style license found in the1466* LICENSE file in the root directory of this source tree. An additional grant1467* of patent rights can be found in the PATENTS file in the same directory.1468*1469* @providesModule ClientReactRootIndex1470* @typechecks1471*/14721473'use strict';14741475var nextReactRootIndex = 0;14761477var ClientReactRootIndex = {1478createReactRootIndex: function() {1479return nextReactRootIndex++;1480}1481};14821483module.exports = ClientReactRootIndex;14841485},{}],9:[function(_dereq_,module,exports){1486/**1487* Copyright 2013-2015, Facebook, Inc.1488* All rights reserved.1489*1490* This source code is licensed under the BSD-style license found in the1491* LICENSE file in the root directory of this source tree. An additional grant1492* of patent rights can be found in the PATENTS file in the same directory.1493*1494* @providesModule DOMChildrenOperations1495* @typechecks static-only1496*/14971498'use strict';14991500var Danger = _dereq_(12);1501var ReactMultiChildUpdateTypes = _dereq_(72);15021503var setTextContent = _dereq_(149);1504var invariant = _dereq_(135);15051506/**1507* Inserts `childNode` as a child of `parentNode` at the `index`.1508*1509* @param {DOMElement} parentNode Parent node in which to insert.1510* @param {DOMElement} childNode Child node to insert.1511* @param {number} index Index at which to insert the child.1512* @internal1513*/1514function insertChildAt(parentNode, childNode, index) {1515// By exploiting arrays returning `undefined` for an undefined index, we can1516// rely exclusively on `insertBefore(node, null)` instead of also using1517// `appendChild(node)`. However, using `undefined` is not allowed by all1518// browsers so we must replace it with `null`.1519parentNode.insertBefore(1520childNode,1521parentNode.childNodes[index] || null1522);1523}15241525/**1526* Operations for updating with DOM children.1527*/1528var DOMChildrenOperations = {15291530dangerouslyReplaceNodeWithMarkup: Danger.dangerouslyReplaceNodeWithMarkup,15311532updateTextContent: setTextContent,15331534/**1535* Updates a component's children by processing a series of updates. The1536* update configurations are each expected to have a `parentNode` property.1537*1538* @param {array<object>} updates List of update configurations.1539* @param {array<string>} markupList List of markup strings.1540* @internal1541*/1542processUpdates: function(updates, markupList) {1543var update;1544// Mapping from parent IDs to initial child orderings.1545var initialChildren = null;1546// List of children that will be moved or removed.1547var updatedChildren = null;15481549for (var i = 0; i < updates.length; i++) {1550update = updates[i];1551if (update.type === ReactMultiChildUpdateTypes.MOVE_EXISTING ||1552update.type === ReactMultiChildUpdateTypes.REMOVE_NODE) {1553var updatedIndex = update.fromIndex;1554var updatedChild = update.parentNode.childNodes[updatedIndex];1555var parentID = update.parentID;15561557("production" !== "development" ? invariant(1558updatedChild,1559'processUpdates(): Unable to find child %s of element. This ' +1560'probably means the DOM was unexpectedly mutated (e.g., by the ' +1561'browser), usually due to forgetting a <tbody> when using tables, ' +1562'nesting tags like <form>, <p>, or <a>, or using non-SVG elements ' +1563'in an <svg> parent. Try inspecting the child nodes of the element ' +1564'with React ID `%s`.',1565updatedIndex,1566parentID1567) : invariant(updatedChild));15681569initialChildren = initialChildren || {};1570initialChildren[parentID] = initialChildren[parentID] || [];1571initialChildren[parentID][updatedIndex] = updatedChild;15721573updatedChildren = updatedChildren || [];1574updatedChildren.push(updatedChild);1575}1576}15771578var renderedMarkup = Danger.dangerouslyRenderMarkup(markupList);15791580// Remove updated children first so that `toIndex` is consistent.1581if (updatedChildren) {1582for (var j = 0; j < updatedChildren.length; j++) {1583updatedChildren[j].parentNode.removeChild(updatedChildren[j]);1584}1585}15861587for (var k = 0; k < updates.length; k++) {1588update = updates[k];1589switch (update.type) {1590case ReactMultiChildUpdateTypes.INSERT_MARKUP:1591insertChildAt(1592update.parentNode,1593renderedMarkup[update.markupIndex],1594update.toIndex1595);1596break;1597case ReactMultiChildUpdateTypes.MOVE_EXISTING:1598insertChildAt(1599update.parentNode,1600initialChildren[update.parentID][update.fromIndex],1601update.toIndex1602);1603break;1604case ReactMultiChildUpdateTypes.TEXT_CONTENT:1605setTextContent(1606update.parentNode,1607update.textContent1608);1609break;1610case ReactMultiChildUpdateTypes.REMOVE_NODE:1611// Already removed by the for-loop above.1612break;1613}1614}1615}16161617};16181619module.exports = DOMChildrenOperations;16201621},{"12":12,"135":135,"149":149,"72":72}],10:[function(_dereq_,module,exports){1622/**1623* Copyright 2013-2015, Facebook, Inc.1624* All rights reserved.1625*1626* This source code is licensed under the BSD-style license found in the1627* LICENSE file in the root directory of this source tree. An additional grant1628* of patent rights can be found in the PATENTS file in the same directory.1629*1630* @providesModule DOMProperty1631* @typechecks static-only1632*/16331634/*jslint bitwise: true */16351636'use strict';16371638var invariant = _dereq_(135);16391640function checkMask(value, bitmask) {1641return (value & bitmask) === bitmask;1642}16431644var DOMPropertyInjection = {1645/**1646* Mapping from normalized, camelcased property names to a configuration that1647* specifies how the associated DOM property should be accessed or rendered.1648*/1649MUST_USE_ATTRIBUTE: 0x1,1650MUST_USE_PROPERTY: 0x2,1651HAS_SIDE_EFFECTS: 0x4,1652HAS_BOOLEAN_VALUE: 0x8,1653HAS_NUMERIC_VALUE: 0x10,1654HAS_POSITIVE_NUMERIC_VALUE: 0x20 | 0x10,1655HAS_OVERLOADED_BOOLEAN_VALUE: 0x40,16561657/**1658* Inject some specialized knowledge about the DOM. This takes a config object1659* with the following properties:1660*1661* isCustomAttribute: function that given an attribute name will return true1662* if it can be inserted into the DOM verbatim. Useful for data-* or aria-*1663* attributes where it's impossible to enumerate all of the possible1664* attribute names,1665*1666* Properties: object mapping DOM property name to one of the1667* DOMPropertyInjection constants or null. If your attribute isn't in here,1668* it won't get written to the DOM.1669*1670* DOMAttributeNames: object mapping React attribute name to the DOM1671* attribute name. Attribute names not specified use the **lowercase**1672* normalized name.1673*1674* DOMPropertyNames: similar to DOMAttributeNames but for DOM properties.1675* Property names not specified use the normalized name.1676*1677* DOMMutationMethods: Properties that require special mutation methods. If1678* `value` is undefined, the mutation method should unset the property.1679*1680* @param {object} domPropertyConfig the config as described above.1681*/1682injectDOMPropertyConfig: function(domPropertyConfig) {1683var Properties = domPropertyConfig.Properties || {};1684var DOMAttributeNames = domPropertyConfig.DOMAttributeNames || {};1685var DOMPropertyNames = domPropertyConfig.DOMPropertyNames || {};1686var DOMMutationMethods = domPropertyConfig.DOMMutationMethods || {};16871688if (domPropertyConfig.isCustomAttribute) {1689DOMProperty._isCustomAttributeFunctions.push(1690domPropertyConfig.isCustomAttribute1691);1692}16931694for (var propName in Properties) {1695("production" !== "development" ? invariant(1696!DOMProperty.isStandardName.hasOwnProperty(propName),1697'injectDOMPropertyConfig(...): You\'re trying to inject DOM property ' +1698'\'%s\' which has already been injected. You may be accidentally ' +1699'injecting the same DOM property config twice, or you may be ' +1700'injecting two configs that have conflicting property names.',1701propName1702) : invariant(!DOMProperty.isStandardName.hasOwnProperty(propName)));17031704DOMProperty.isStandardName[propName] = true;17051706var lowerCased = propName.toLowerCase();1707DOMProperty.getPossibleStandardName[lowerCased] = propName;17081709if (DOMAttributeNames.hasOwnProperty(propName)) {1710var attributeName = DOMAttributeNames[propName];1711DOMProperty.getPossibleStandardName[attributeName] = propName;1712DOMProperty.getAttributeName[propName] = attributeName;1713} else {1714DOMProperty.getAttributeName[propName] = lowerCased;1715}17161717DOMProperty.getPropertyName[propName] =1718DOMPropertyNames.hasOwnProperty(propName) ?1719DOMPropertyNames[propName] :1720propName;17211722if (DOMMutationMethods.hasOwnProperty(propName)) {1723DOMProperty.getMutationMethod[propName] = DOMMutationMethods[propName];1724} else {1725DOMProperty.getMutationMethod[propName] = null;1726}17271728var propConfig = Properties[propName];1729DOMProperty.mustUseAttribute[propName] =1730checkMask(propConfig, DOMPropertyInjection.MUST_USE_ATTRIBUTE);1731DOMProperty.mustUseProperty[propName] =1732checkMask(propConfig, DOMPropertyInjection.MUST_USE_PROPERTY);1733DOMProperty.hasSideEffects[propName] =1734checkMask(propConfig, DOMPropertyInjection.HAS_SIDE_EFFECTS);1735DOMProperty.hasBooleanValue[propName] =1736checkMask(propConfig, DOMPropertyInjection.HAS_BOOLEAN_VALUE);1737DOMProperty.hasNumericValue[propName] =1738checkMask(propConfig, DOMPropertyInjection.HAS_NUMERIC_VALUE);1739DOMProperty.hasPositiveNumericValue[propName] =1740checkMask(propConfig, DOMPropertyInjection.HAS_POSITIVE_NUMERIC_VALUE);1741DOMProperty.hasOverloadedBooleanValue[propName] =1742checkMask(propConfig, DOMPropertyInjection.HAS_OVERLOADED_BOOLEAN_VALUE);17431744("production" !== "development" ? invariant(1745!DOMProperty.mustUseAttribute[propName] ||1746!DOMProperty.mustUseProperty[propName],1747'DOMProperty: Cannot require using both attribute and property: %s',1748propName1749) : invariant(!DOMProperty.mustUseAttribute[propName] ||1750!DOMProperty.mustUseProperty[propName]));1751("production" !== "development" ? invariant(1752DOMProperty.mustUseProperty[propName] ||1753!DOMProperty.hasSideEffects[propName],1754'DOMProperty: Properties that have side effects must use property: %s',1755propName1756) : invariant(DOMProperty.mustUseProperty[propName] ||1757!DOMProperty.hasSideEffects[propName]));1758("production" !== "development" ? invariant(1759!!DOMProperty.hasBooleanValue[propName] +1760!!DOMProperty.hasNumericValue[propName] +1761!!DOMProperty.hasOverloadedBooleanValue[propName] <= 1,1762'DOMProperty: Value can be one of boolean, overloaded boolean, or ' +1763'numeric value, but not a combination: %s',1764propName1765) : invariant(!!DOMProperty.hasBooleanValue[propName] +1766!!DOMProperty.hasNumericValue[propName] +1767!!DOMProperty.hasOverloadedBooleanValue[propName] <= 1));1768}1769}1770};1771var defaultValueCache = {};17721773/**1774* DOMProperty exports lookup objects that can be used like functions:1775*1776* > DOMProperty.isValid['id']1777* true1778* > DOMProperty.isValid['foobar']1779* undefined1780*1781* Although this may be confusing, it performs better in general.1782*1783* @see http://jsperf.com/key-exists1784* @see http://jsperf.com/key-missing1785*/1786var DOMProperty = {17871788ID_ATTRIBUTE_NAME: 'data-reactid',17891790/**1791* Checks whether a property name is a standard property.1792* @type {Object}1793*/1794isStandardName: {},17951796/**1797* Mapping from lowercase property names to the properly cased version, used1798* to warn in the case of missing properties.1799* @type {Object}1800*/1801getPossibleStandardName: {},18021803/**1804* Mapping from normalized names to attribute names that differ. Attribute1805* names are used when rendering markup or with `*Attribute()`.1806* @type {Object}1807*/1808getAttributeName: {},18091810/**1811* Mapping from normalized names to properties on DOM node instances.1812* (This includes properties that mutate due to external factors.)1813* @type {Object}1814*/1815getPropertyName: {},18161817/**1818* Mapping from normalized names to mutation methods. This will only exist if1819* mutation cannot be set simply by the property or `setAttribute()`.1820* @type {Object}1821*/1822getMutationMethod: {},18231824/**1825* Whether the property must be accessed and mutated as an object property.1826* @type {Object}1827*/1828mustUseAttribute: {},18291830/**1831* Whether the property must be accessed and mutated using `*Attribute()`.1832* (This includes anything that fails `<propName> in <element>`.)1833* @type {Object}1834*/1835mustUseProperty: {},18361837/**1838* Whether or not setting a value causes side effects such as triggering1839* resources to be loaded or text selection changes. We must ensure that1840* the value is only set if it has changed.1841* @type {Object}1842*/1843hasSideEffects: {},18441845/**1846* Whether the property should be removed when set to a falsey value.1847* @type {Object}1848*/1849hasBooleanValue: {},18501851/**1852* Whether the property must be numeric or parse as a1853* numeric and should be removed when set to a falsey value.1854* @type {Object}1855*/1856hasNumericValue: {},18571858/**1859* Whether the property must be positive numeric or parse as a positive1860* numeric and should be removed when set to a falsey value.1861* @type {Object}1862*/1863hasPositiveNumericValue: {},18641865/**1866* Whether the property can be used as a flag as well as with a value. Removed1867* when strictly equal to false; present without a value when strictly equal1868* to true; present with a value otherwise.1869* @type {Object}1870*/1871hasOverloadedBooleanValue: {},18721873/**1874* All of the isCustomAttribute() functions that have been injected.1875*/1876_isCustomAttributeFunctions: [],18771878/**1879* Checks whether a property name is a custom attribute.1880* @method1881*/1882isCustomAttribute: function(attributeName) {1883for (var i = 0; i < DOMProperty._isCustomAttributeFunctions.length; i++) {1884var isCustomAttributeFn = DOMProperty._isCustomAttributeFunctions[i];1885if (isCustomAttributeFn(attributeName)) {1886return true;1887}1888}1889return false;1890},18911892/**1893* Returns the default property value for a DOM property (i.e., not an1894* attribute). Most default values are '' or false, but not all. Worse yet,1895* some (in particular, `type`) vary depending on the type of element.1896*1897* TODO: Is it better to grab all the possible properties when creating an1898* element to avoid having to create the same element twice?1899*/1900getDefaultValueForProperty: function(nodeName, prop) {1901var nodeDefaults = defaultValueCache[nodeName];1902var testElement;1903if (!nodeDefaults) {1904defaultValueCache[nodeName] = nodeDefaults = {};1905}1906if (!(prop in nodeDefaults)) {1907testElement = document.createElement(nodeName);1908nodeDefaults[prop] = testElement[prop];1909}1910return nodeDefaults[prop];1911},19121913injection: DOMPropertyInjection1914};19151916module.exports = DOMProperty;19171918},{"135":135}],11:[function(_dereq_,module,exports){1919/**1920* Copyright 2013-2015, Facebook, Inc.1921* All rights reserved.1922*1923* This source code is licensed under the BSD-style license found in the1924* LICENSE file in the root directory of this source tree. An additional grant1925* of patent rights can be found in the PATENTS file in the same directory.1926*1927* @providesModule DOMPropertyOperations1928* @typechecks static-only1929*/19301931'use strict';19321933var DOMProperty = _dereq_(10);19341935var quoteAttributeValueForBrowser = _dereq_(147);1936var warning = _dereq_(154);19371938function shouldIgnoreValue(name, value) {1939return value == null ||1940(DOMProperty.hasBooleanValue[name] && !value) ||1941(DOMProperty.hasNumericValue[name] && isNaN(value)) ||1942(DOMProperty.hasPositiveNumericValue[name] && (value < 1)) ||1943(DOMProperty.hasOverloadedBooleanValue[name] && value === false);1944}19451946if ("production" !== "development") {1947var reactProps = {1948children: true,1949dangerouslySetInnerHTML: true,1950key: true,1951ref: true1952};1953var warnedProperties = {};19541955var warnUnknownProperty = function(name) {1956if (reactProps.hasOwnProperty(name) && reactProps[name] ||1957warnedProperties.hasOwnProperty(name) && warnedProperties[name]) {1958return;1959}19601961warnedProperties[name] = true;1962var lowerCasedName = name.toLowerCase();19631964// data-* attributes should be lowercase; suggest the lowercase version1965var standardName = (1966DOMProperty.isCustomAttribute(lowerCasedName) ?1967lowerCasedName :1968DOMProperty.getPossibleStandardName.hasOwnProperty(lowerCasedName) ?1969DOMProperty.getPossibleStandardName[lowerCasedName] :1970null1971);19721973// For now, only warn when we have a suggested correction. This prevents1974// logging too much when using transferPropsTo.1975("production" !== "development" ? warning(1976standardName == null,1977'Unknown DOM property %s. Did you mean %s?',1978name,1979standardName1980) : null);19811982};1983}19841985/**1986* Operations for dealing with DOM properties.1987*/1988var DOMPropertyOperations = {19891990/**1991* Creates markup for the ID property.1992*1993* @param {string} id Unescaped ID.1994* @return {string} Markup string.1995*/1996createMarkupForID: function(id) {1997return DOMProperty.ID_ATTRIBUTE_NAME + '=' +1998quoteAttributeValueForBrowser(id);1999},20002001/**2002* Creates markup for a property.2003*2004* @param {string} name2005* @param {*} value2006* @return {?string} Markup string, or null if the property was invalid.2007*/2008createMarkupForProperty: function(name, value) {2009if (DOMProperty.isStandardName.hasOwnProperty(name) &&2010DOMProperty.isStandardName[name]) {2011if (shouldIgnoreValue(name, value)) {2012return '';2013}2014var attributeName = DOMProperty.getAttributeName[name];2015if (DOMProperty.hasBooleanValue[name] ||2016(DOMProperty.hasOverloadedBooleanValue[name] && value === true)) {2017return attributeName;2018}2019return attributeName + '=' + quoteAttributeValueForBrowser(value);2020} else if (DOMProperty.isCustomAttribute(name)) {2021if (value == null) {2022return '';2023}2024return name + '=' + quoteAttributeValueForBrowser(value);2025} else if ("production" !== "development") {2026warnUnknownProperty(name);2027}2028return null;2029},20302031/**2032* Sets the value for a property on a node.2033*2034* @param {DOMElement} node2035* @param {string} name2036* @param {*} value2037*/2038setValueForProperty: function(node, name, value) {2039if (DOMProperty.isStandardName.hasOwnProperty(name) &&2040DOMProperty.isStandardName[name]) {2041var mutationMethod = DOMProperty.getMutationMethod[name];2042if (mutationMethod) {2043mutationMethod(node, value);2044} else if (shouldIgnoreValue(name, value)) {2045this.deleteValueForProperty(node, name);2046} else if (DOMProperty.mustUseAttribute[name]) {2047// `setAttribute` with objects becomes only `[object]` in IE8/9,2048// ('' + value) makes it output the correct toString()-value.2049node.setAttribute(DOMProperty.getAttributeName[name], '' + value);2050} else {2051var propName = DOMProperty.getPropertyName[name];2052// Must explicitly cast values for HAS_SIDE_EFFECTS-properties to the2053// property type before comparing; only `value` does and is string.2054if (!DOMProperty.hasSideEffects[name] ||2055('' + node[propName]) !== ('' + value)) {2056// Contrary to `setAttribute`, object properties are properly2057// `toString`ed by IE8/9.2058node[propName] = value;2059}2060}2061} else if (DOMProperty.isCustomAttribute(name)) {2062if (value == null) {2063node.removeAttribute(name);2064} else {2065node.setAttribute(name, '' + value);2066}2067} else if ("production" !== "development") {2068warnUnknownProperty(name);2069}2070},20712072/**2073* Deletes the value for a property on a node.2074*2075* @param {DOMElement} node2076* @param {string} name2077*/2078deleteValueForProperty: function(node, name) {2079if (DOMProperty.isStandardName.hasOwnProperty(name) &&2080DOMProperty.isStandardName[name]) {2081var mutationMethod = DOMProperty.getMutationMethod[name];2082if (mutationMethod) {2083mutationMethod(node, undefined);2084} else if (DOMProperty.mustUseAttribute[name]) {2085node.removeAttribute(DOMProperty.getAttributeName[name]);2086} else {2087var propName = DOMProperty.getPropertyName[name];2088var defaultValue = DOMProperty.getDefaultValueForProperty(2089node.nodeName,2090propName2091);2092if (!DOMProperty.hasSideEffects[name] ||2093('' + node[propName]) !== defaultValue) {2094node[propName] = defaultValue;2095}2096}2097} else if (DOMProperty.isCustomAttribute(name)) {2098node.removeAttribute(name);2099} else if ("production" !== "development") {2100warnUnknownProperty(name);2101}2102}21032104};21052106module.exports = DOMPropertyOperations;21072108},{"10":10,"147":147,"154":154}],12:[function(_dereq_,module,exports){2109/**2110* Copyright 2013-2015, Facebook, Inc.2111* All rights reserved.2112*2113* This source code is licensed under the BSD-style license found in the2114* LICENSE file in the root directory of this source tree. An additional grant2115* of patent rights can be found in the PATENTS file in the same directory.2116*2117* @providesModule Danger2118* @typechecks static-only2119*/21202121/*jslint evil: true, sub: true */21222123'use strict';21242125var ExecutionEnvironment = _dereq_(21);21262127var createNodesFromMarkup = _dereq_(112);2128var emptyFunction = _dereq_(114);2129var getMarkupWrap = _dereq_(127);2130var invariant = _dereq_(135);21312132var OPEN_TAG_NAME_EXP = /^(<[^ \/>]+)/;2133var RESULT_INDEX_ATTR = 'data-danger-index';21342135/**2136* Extracts the `nodeName` from a string of markup.2137*2138* NOTE: Extracting the `nodeName` does not require a regular expression match2139* because we make assumptions about React-generated markup (i.e. there are no2140* spaces surrounding the opening tag and there is at least one attribute).2141*2142* @param {string} markup String of markup.2143* @return {string} Node name of the supplied markup.2144* @see http://jsperf.com/extract-nodename2145*/2146function getNodeName(markup) {2147return markup.substring(1, markup.indexOf(' '));2148}21492150var Danger = {21512152/**2153* Renders markup into an array of nodes. The markup is expected to render2154* into a list of root nodes. Also, the length of `resultList` and2155* `markupList` should be the same.2156*2157* @param {array<string>} markupList List of markup strings to render.2158* @return {array<DOMElement>} List of rendered nodes.2159* @internal2160*/2161dangerouslyRenderMarkup: function(markupList) {2162("production" !== "development" ? invariant(2163ExecutionEnvironment.canUseDOM,2164'dangerouslyRenderMarkup(...): Cannot render markup in a worker ' +2165'thread. Make sure `window` and `document` are available globally ' +2166'before requiring React when unit testing or use ' +2167'React.renderToString for server rendering.'2168) : invariant(ExecutionEnvironment.canUseDOM));2169var nodeName;2170var markupByNodeName = {};2171// Group markup by `nodeName` if a wrap is necessary, else by '*'.2172for (var i = 0; i < markupList.length; i++) {2173("production" !== "development" ? invariant(2174markupList[i],2175'dangerouslyRenderMarkup(...): Missing markup.'2176) : invariant(markupList[i]));2177nodeName = getNodeName(markupList[i]);2178nodeName = getMarkupWrap(nodeName) ? nodeName : '*';2179markupByNodeName[nodeName] = markupByNodeName[nodeName] || [];2180markupByNodeName[nodeName][i] = markupList[i];2181}2182var resultList = [];2183var resultListAssignmentCount = 0;2184for (nodeName in markupByNodeName) {2185if (!markupByNodeName.hasOwnProperty(nodeName)) {2186continue;2187}2188var markupListByNodeName = markupByNodeName[nodeName];21892190// This for-in loop skips the holes of the sparse array. The order of2191// iteration should follow the order of assignment, which happens to match2192// numerical index order, but we don't rely on that.2193var resultIndex;2194for (resultIndex in markupListByNodeName) {2195if (markupListByNodeName.hasOwnProperty(resultIndex)) {2196var markup = markupListByNodeName[resultIndex];21972198// Push the requested markup with an additional RESULT_INDEX_ATTR2199// attribute. If the markup does not start with a < character, it2200// will be discarded below (with an appropriate console.error).2201markupListByNodeName[resultIndex] = markup.replace(2202OPEN_TAG_NAME_EXP,2203// This index will be parsed back out below.2204'$1 ' + RESULT_INDEX_ATTR + '="' + resultIndex + '" '2205);2206}2207}22082209// Render each group of markup with similar wrapping `nodeName`.2210var renderNodes = createNodesFromMarkup(2211markupListByNodeName.join(''),2212emptyFunction // Do nothing special with <script> tags.2213);22142215for (var j = 0; j < renderNodes.length; ++j) {2216var renderNode = renderNodes[j];2217if (renderNode.hasAttribute &&2218renderNode.hasAttribute(RESULT_INDEX_ATTR)) {22192220resultIndex = +renderNode.getAttribute(RESULT_INDEX_ATTR);2221renderNode.removeAttribute(RESULT_INDEX_ATTR);22222223("production" !== "development" ? invariant(2224!resultList.hasOwnProperty(resultIndex),2225'Danger: Assigning to an already-occupied result index.'2226) : invariant(!resultList.hasOwnProperty(resultIndex)));22272228resultList[resultIndex] = renderNode;22292230// This should match resultList.length and markupList.length when2231// we're done.2232resultListAssignmentCount += 1;22332234} else if ("production" !== "development") {2235console.error(2236'Danger: Discarding unexpected node:',2237renderNode2238);2239}2240}2241}22422243// Although resultList was populated out of order, it should now be a dense2244// array.2245("production" !== "development" ? invariant(2246resultListAssignmentCount === resultList.length,2247'Danger: Did not assign to every index of resultList.'2248) : invariant(resultListAssignmentCount === resultList.length));22492250("production" !== "development" ? invariant(2251resultList.length === markupList.length,2252'Danger: Expected markup to render %s nodes, but rendered %s.',2253markupList.length,2254resultList.length2255) : invariant(resultList.length === markupList.length));22562257return resultList;2258},22592260/**2261* Replaces a node with a string of markup at its current position within its2262* parent. The markup must render into a single root node.2263*2264* @param {DOMElement} oldChild Child node to replace.2265* @param {string} markup Markup to render in place of the child node.2266* @internal2267*/2268dangerouslyReplaceNodeWithMarkup: function(oldChild, markup) {2269("production" !== "development" ? invariant(2270ExecutionEnvironment.canUseDOM,2271'dangerouslyReplaceNodeWithMarkup(...): Cannot render markup in a ' +2272'worker thread. Make sure `window` and `document` are available ' +2273'globally before requiring React when unit testing or use ' +2274'React.renderToString for server rendering.'2275) : invariant(ExecutionEnvironment.canUseDOM));2276("production" !== "development" ? invariant(markup, 'dangerouslyReplaceNodeWithMarkup(...): Missing markup.') : invariant(markup));2277("production" !== "development" ? invariant(2278oldChild.tagName.toLowerCase() !== 'html',2279'dangerouslyReplaceNodeWithMarkup(...): Cannot replace markup of the ' +2280'<html> node. This is because browser quirks make this unreliable ' +2281'and/or slow. If you want to render to the root you must use ' +2282'server rendering. See React.renderToString().'2283) : invariant(oldChild.tagName.toLowerCase() !== 'html'));22842285var newChild = createNodesFromMarkup(markup, emptyFunction)[0];2286oldChild.parentNode.replaceChild(newChild, oldChild);2287}22882289};22902291module.exports = Danger;22922293},{"112":112,"114":114,"127":127,"135":135,"21":21}],13:[function(_dereq_,module,exports){2294/**2295* Copyright 2013-2015, Facebook, Inc.2296* All rights reserved.2297*2298* This source code is licensed under the BSD-style license found in the2299* LICENSE file in the root directory of this source tree. An additional grant2300* of patent rights can be found in the PATENTS file in the same directory.2301*2302* @providesModule DefaultEventPluginOrder2303*/23042305'use strict';23062307var keyOf = _dereq_(141);23082309/**2310* Module that is injectable into `EventPluginHub`, that specifies a2311* deterministic ordering of `EventPlugin`s. A convenient way to reason about2312* plugins, without having to package every one of them. This is better than2313* having plugins be ordered in the same order that they are injected because2314* that ordering would be influenced by the packaging order.2315* `ResponderEventPlugin` must occur before `SimpleEventPlugin` so that2316* preventing default on events is convenient in `SimpleEventPlugin` handlers.2317*/2318var DefaultEventPluginOrder = [2319keyOf({ResponderEventPlugin: null}),2320keyOf({SimpleEventPlugin: null}),2321keyOf({TapEventPlugin: null}),2322keyOf({EnterLeaveEventPlugin: null}),2323keyOf({ChangeEventPlugin: null}),2324keyOf({SelectEventPlugin: null}),2325keyOf({BeforeInputEventPlugin: null}),2326keyOf({AnalyticsEventPlugin: null}),2327keyOf({MobileSafariClickEventPlugin: null})2328];23292330module.exports = DefaultEventPluginOrder;23312332},{"141":141}],14:[function(_dereq_,module,exports){2333/**2334* Copyright 2013-2015, Facebook, Inc.2335* All rights reserved.2336*2337* This source code is licensed under the BSD-style license found in the2338* LICENSE file in the root directory of this source tree. An additional grant2339* of patent rights can be found in the PATENTS file in the same directory.2340*2341* @providesModule EnterLeaveEventPlugin2342* @typechecks static-only2343*/23442345'use strict';23462347var EventConstants = _dereq_(15);2348var EventPropagators = _dereq_(20);2349var SyntheticMouseEvent = _dereq_(99);23502351var ReactMount = _dereq_(70);2352var keyOf = _dereq_(141);23532354var topLevelTypes = EventConstants.topLevelTypes;2355var getFirstReactDOM = ReactMount.getFirstReactDOM;23562357var eventTypes = {2358mouseEnter: {2359registrationName: keyOf({onMouseEnter: null}),2360dependencies: [2361topLevelTypes.topMouseOut,2362topLevelTypes.topMouseOver2363]2364},2365mouseLeave: {2366registrationName: keyOf({onMouseLeave: null}),2367dependencies: [2368topLevelTypes.topMouseOut,2369topLevelTypes.topMouseOver2370]2371}2372};23732374var extractedEvents = [null, null];23752376var EnterLeaveEventPlugin = {23772378eventTypes: eventTypes,23792380/**2381* For almost every interaction we care about, there will be both a top-level2382* `mouseover` and `mouseout` event that occurs. Only use `mouseout` so that2383* we do not extract duplicate events. However, moving the mouse into the2384* browser from outside will not fire a `mouseout` event. In this case, we use2385* the `mouseover` top-level event.2386*2387* @param {string} topLevelType Record from `EventConstants`.2388* @param {DOMEventTarget} topLevelTarget The listening component root node.2389* @param {string} topLevelTargetID ID of `topLevelTarget`.2390* @param {object} nativeEvent Native browser event.2391* @return {*} An accumulation of synthetic events.2392* @see {EventPluginHub.extractEvents}2393*/2394extractEvents: function(2395topLevelType,2396topLevelTarget,2397topLevelTargetID,2398nativeEvent) {2399if (topLevelType === topLevelTypes.topMouseOver &&2400(nativeEvent.relatedTarget || nativeEvent.fromElement)) {2401return null;2402}2403if (topLevelType !== topLevelTypes.topMouseOut &&2404topLevelType !== topLevelTypes.topMouseOver) {2405// Must not be a mouse in or mouse out - ignoring.2406return null;2407}24082409var win;2410if (topLevelTarget.window === topLevelTarget) {2411// `topLevelTarget` is probably a window object.2412win = topLevelTarget;2413} else {2414// TODO: Figure out why `ownerDocument` is sometimes undefined in IE8.2415var doc = topLevelTarget.ownerDocument;2416if (doc) {2417win = doc.defaultView || doc.parentWindow;2418} else {2419win = window;2420}2421}24222423var from, to;2424if (topLevelType === topLevelTypes.topMouseOut) {2425from = topLevelTarget;2426to =2427getFirstReactDOM(nativeEvent.relatedTarget || nativeEvent.toElement) ||2428win;2429} else {2430from = win;2431to = topLevelTarget;2432}24332434if (from === to) {2435// Nothing pertains to our managed components.2436return null;2437}24382439var fromID = from ? ReactMount.getID(from) : '';2440var toID = to ? ReactMount.getID(to) : '';24412442var leave = SyntheticMouseEvent.getPooled(2443eventTypes.mouseLeave,2444fromID,2445nativeEvent2446);2447leave.type = 'mouseleave';2448leave.target = from;2449leave.relatedTarget = to;24502451var enter = SyntheticMouseEvent.getPooled(2452eventTypes.mouseEnter,2453toID,2454nativeEvent2455);2456enter.type = 'mouseenter';2457enter.target = to;2458enter.relatedTarget = from;24592460EventPropagators.accumulateEnterLeaveDispatches(leave, enter, fromID, toID);24612462extractedEvents[0] = leave;2463extractedEvents[1] = enter;24642465return extractedEvents;2466}24672468};24692470module.exports = EnterLeaveEventPlugin;24712472},{"141":141,"15":15,"20":20,"70":70,"99":99}],15:[function(_dereq_,module,exports){2473/**2474* Copyright 2013-2015, Facebook, Inc.2475* All rights reserved.2476*2477* This source code is licensed under the BSD-style license found in the2478* LICENSE file in the root directory of this source tree. An additional grant2479* of patent rights can be found in the PATENTS file in the same directory.2480*2481* @providesModule EventConstants2482*/24832484'use strict';24852486var keyMirror = _dereq_(140);24872488var PropagationPhases = keyMirror({bubbled: null, captured: null});24892490/**2491* Types of raw signals from the browser caught at the top level.2492*/2493var topLevelTypes = keyMirror({2494topBlur: null,2495topChange: null,2496topClick: null,2497topCompositionEnd: null,2498topCompositionStart: null,2499topCompositionUpdate: null,2500topContextMenu: null,2501topCopy: null,2502topCut: null,2503topDoubleClick: null,2504topDrag: null,2505topDragEnd: null,2506topDragEnter: null,2507topDragExit: null,2508topDragLeave: null,2509topDragOver: null,2510topDragStart: null,2511topDrop: null,2512topError: null,2513topFocus: null,2514topInput: null,2515topKeyDown: null,2516topKeyPress: null,2517topKeyUp: null,2518topLoad: null,2519topMouseDown: null,2520topMouseMove: null,2521topMouseOut: null,2522topMouseOver: null,2523topMouseUp: null,2524topPaste: null,2525topReset: null,2526topScroll: null,2527topSelectionChange: null,2528topSubmit: null,2529topTextInput: null,2530topTouchCancel: null,2531topTouchEnd: null,2532topTouchMove: null,2533topTouchStart: null,2534topWheel: null2535});25362537var EventConstants = {2538topLevelTypes: topLevelTypes,2539PropagationPhases: PropagationPhases2540};25412542module.exports = EventConstants;25432544},{"140":140}],16:[function(_dereq_,module,exports){2545/**2546* Copyright 2013-2015, Facebook, Inc.2547*2548* Licensed under the Apache License, Version 2.0 (the "License");2549* you may not use this file except in compliance with the License.2550* You may obtain a copy of the License at2551*2552* http://www.apache.org/licenses/LICENSE-2.02553*2554* Unless required by applicable law or agreed to in writing, software2555* distributed under the License is distributed on an "AS IS" BASIS,2556* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.2557* See the License for the specific language governing permissions and2558* limitations under the License.2559*2560* @providesModule EventListener2561* @typechecks2562*/25632564var emptyFunction = _dereq_(114);25652566/**2567* Upstream version of event listener. Does not take into account specific2568* nature of platform.2569*/2570var EventListener = {2571/**2572* Listen to DOM events during the bubble phase.2573*2574* @param {DOMEventTarget} target DOM element to register listener on.2575* @param {string} eventType Event type, e.g. 'click' or 'mouseover'.2576* @param {function} callback Callback function.2577* @return {object} Object with a `remove` method.2578*/2579listen: function(target, eventType, callback) {2580if (target.addEventListener) {2581target.addEventListener(eventType, callback, false);2582return {2583remove: function() {2584target.removeEventListener(eventType, callback, false);2585}2586};2587} else if (target.attachEvent) {2588target.attachEvent('on' + eventType, callback);2589return {2590remove: function() {2591target.detachEvent('on' + eventType, callback);2592}2593};2594}2595},25962597/**2598* Listen to DOM events during the capture phase.2599*2600* @param {DOMEventTarget} target DOM element to register listener on.2601* @param {string} eventType Event type, e.g. 'click' or 'mouseover'.2602* @param {function} callback Callback function.2603* @return {object} Object with a `remove` method.2604*/2605capture: function(target, eventType, callback) {2606if (!target.addEventListener) {2607if ("production" !== "development") {2608console.error(2609'Attempted to listen to events during the capture phase on a ' +2610'browser that does not support the capture phase. Your application ' +2611'will not receive some events.'2612);2613}2614return {2615remove: emptyFunction2616};2617} else {2618target.addEventListener(eventType, callback, true);2619return {2620remove: function() {2621target.removeEventListener(eventType, callback, true);2622}2623};2624}2625},26262627registerDefault: function() {}2628};26292630module.exports = EventListener;26312632},{"114":114}],17:[function(_dereq_,module,exports){2633/**2634* Copyright 2013-2015, Facebook, Inc.2635* All rights reserved.2636*2637* This source code is licensed under the BSD-style license found in the2638* LICENSE file in the root directory of this source tree. An additional grant2639* of patent rights can be found in the PATENTS file in the same directory.2640*2641* @providesModule EventPluginHub2642*/26432644'use strict';26452646var EventPluginRegistry = _dereq_(18);2647var EventPluginUtils = _dereq_(19);26482649var accumulateInto = _dereq_(105);2650var forEachAccumulated = _dereq_(120);2651var invariant = _dereq_(135);26522653/**2654* Internal store for event listeners2655*/2656var listenerBank = {};26572658/**2659* Internal queue of events that have accumulated their dispatches and are2660* waiting to have their dispatches executed.2661*/2662var eventQueue = null;26632664/**2665* Dispatches an event and releases it back into the pool, unless persistent.2666*2667* @param {?object} event Synthetic event to be dispatched.2668* @private2669*/2670var executeDispatchesAndRelease = function(event) {2671if (event) {2672var executeDispatch = EventPluginUtils.executeDispatch;2673// Plugins can provide custom behavior when dispatching events.2674var PluginModule = EventPluginRegistry.getPluginModuleForEvent(event);2675if (PluginModule && PluginModule.executeDispatch) {2676executeDispatch = PluginModule.executeDispatch;2677}2678EventPluginUtils.executeDispatchesInOrder(event, executeDispatch);26792680if (!event.isPersistent()) {2681event.constructor.release(event);2682}2683}2684};26852686/**2687* - `InstanceHandle`: [required] Module that performs logical traversals of DOM2688* hierarchy given ids of the logical DOM elements involved.2689*/2690var InstanceHandle = null;26912692function validateInstanceHandle() {2693var valid =2694InstanceHandle &&2695InstanceHandle.traverseTwoPhase &&2696InstanceHandle.traverseEnterLeave;2697("production" !== "development" ? invariant(2698valid,2699'InstanceHandle not injected before use!'2700) : invariant(valid));2701}27022703/**2704* This is a unified interface for event plugins to be installed and configured.2705*2706* Event plugins can implement the following properties:2707*2708* `extractEvents` {function(string, DOMEventTarget, string, object): *}2709* Required. When a top-level event is fired, this method is expected to2710* extract synthetic events that will in turn be queued and dispatched.2711*2712* `eventTypes` {object}2713* Optional, plugins that fire events must publish a mapping of registration2714* names that are used to register listeners. Values of this mapping must2715* be objects that contain `registrationName` or `phasedRegistrationNames`.2716*2717* `executeDispatch` {function(object, function, string)}2718* Optional, allows plugins to override how an event gets dispatched. By2719* default, the listener is simply invoked.2720*2721* Each plugin that is injected into `EventsPluginHub` is immediately operable.2722*2723* @public2724*/2725var EventPluginHub = {27262727/**2728* Methods for injecting dependencies.2729*/2730injection: {27312732/**2733* @param {object} InjectedMount2734* @public2735*/2736injectMount: EventPluginUtils.injection.injectMount,27372738/**2739* @param {object} InjectedInstanceHandle2740* @public2741*/2742injectInstanceHandle: function(InjectedInstanceHandle) {2743InstanceHandle = InjectedInstanceHandle;2744if ("production" !== "development") {2745validateInstanceHandle();2746}2747},27482749getInstanceHandle: function() {2750if ("production" !== "development") {2751validateInstanceHandle();2752}2753return InstanceHandle;2754},27552756/**2757* @param {array} InjectedEventPluginOrder2758* @public2759*/2760injectEventPluginOrder: EventPluginRegistry.injectEventPluginOrder,27612762/**2763* @param {object} injectedNamesToPlugins Map from names to plugin modules.2764*/2765injectEventPluginsByName: EventPluginRegistry.injectEventPluginsByName27662767},27682769eventNameDispatchConfigs: EventPluginRegistry.eventNameDispatchConfigs,27702771registrationNameModules: EventPluginRegistry.registrationNameModules,27722773/**2774* Stores `listener` at `listenerBank[registrationName][id]`. Is idempotent.2775*2776* @param {string} id ID of the DOM element.2777* @param {string} registrationName Name of listener (e.g. `onClick`).2778* @param {?function} listener The callback to store.2779*/2780putListener: function(id, registrationName, listener) {2781("production" !== "development" ? invariant(2782!listener || typeof listener === 'function',2783'Expected %s listener to be a function, instead got type %s',2784registrationName, typeof listener2785) : invariant(!listener || typeof listener === 'function'));27862787var bankForRegistrationName =2788listenerBank[registrationName] || (listenerBank[registrationName] = {});2789bankForRegistrationName[id] = listener;2790},27912792/**2793* @param {string} id ID of the DOM element.2794* @param {string} registrationName Name of listener (e.g. `onClick`).2795* @return {?function} The stored callback.2796*/2797getListener: function(id, registrationName) {2798var bankForRegistrationName = listenerBank[registrationName];2799return bankForRegistrationName && bankForRegistrationName[id];2800},28012802/**2803* Deletes a listener from the registration bank.2804*2805* @param {string} id ID of the DOM element.2806* @param {string} registrationName Name of listener (e.g. `onClick`).2807*/2808deleteListener: function(id, registrationName) {2809var bankForRegistrationName = listenerBank[registrationName];2810if (bankForRegistrationName) {2811delete bankForRegistrationName[id];2812}2813},28142815/**2816* Deletes all listeners for the DOM element with the supplied ID.2817*2818* @param {string} id ID of the DOM element.2819*/2820deleteAllListeners: function(id) {2821for (var registrationName in listenerBank) {2822delete listenerBank[registrationName][id];2823}2824},28252826/**2827* Allows registered plugins an opportunity to extract events from top-level2828* native browser events.2829*2830* @param {string} topLevelType Record from `EventConstants`.2831* @param {DOMEventTarget} topLevelTarget The listening component root node.2832* @param {string} topLevelTargetID ID of `topLevelTarget`.2833* @param {object} nativeEvent Native browser event.2834* @return {*} An accumulation of synthetic events.2835* @internal2836*/2837extractEvents: function(2838topLevelType,2839topLevelTarget,2840topLevelTargetID,2841nativeEvent) {2842var events;2843var plugins = EventPluginRegistry.plugins;2844for (var i = 0, l = plugins.length; i < l; i++) {2845// Not every plugin in the ordering may be loaded at runtime.2846var possiblePlugin = plugins[i];2847if (possiblePlugin) {2848var extractedEvents = possiblePlugin.extractEvents(2849topLevelType,2850topLevelTarget,2851topLevelTargetID,2852nativeEvent2853);2854if (extractedEvents) {2855events = accumulateInto(events, extractedEvents);2856}2857}2858}2859return events;2860},28612862/**2863* Enqueues a synthetic event that should be dispatched when2864* `processEventQueue` is invoked.2865*2866* @param {*} events An accumulation of synthetic events.2867* @internal2868*/2869enqueueEvents: function(events) {2870if (events) {2871eventQueue = accumulateInto(eventQueue, events);2872}2873},28742875/**2876* Dispatches all synthetic events on the event queue.2877*2878* @internal2879*/2880processEventQueue: function() {2881// Set `eventQueue` to null before processing it so that we can tell if more2882// events get enqueued while processing.2883var processingEventQueue = eventQueue;2884eventQueue = null;2885forEachAccumulated(processingEventQueue, executeDispatchesAndRelease);2886("production" !== "development" ? invariant(2887!eventQueue,2888'processEventQueue(): Additional events were enqueued while processing ' +2889'an event queue. Support for this has not yet been implemented.'2890) : invariant(!eventQueue));2891},28922893/**2894* These are needed for tests only. Do not use!2895*/2896__purge: function() {2897listenerBank = {};2898},28992900__getListenerBank: function() {2901return listenerBank;2902}29032904};29052906module.exports = EventPluginHub;29072908},{"105":105,"120":120,"135":135,"18":18,"19":19}],18:[function(_dereq_,module,exports){2909/**2910* Copyright 2013-2015, Facebook, Inc.2911* All rights reserved.2912*2913* This source code is licensed under the BSD-style license found in the2914* LICENSE file in the root directory of this source tree. An additional grant2915* of patent rights can be found in the PATENTS file in the same directory.2916*2917* @providesModule EventPluginRegistry2918* @typechecks static-only2919*/29202921'use strict';29222923var invariant = _dereq_(135);29242925/**2926* Injectable ordering of event plugins.2927*/2928var EventPluginOrder = null;29292930/**2931* Injectable mapping from names to event plugin modules.2932*/2933var namesToPlugins = {};29342935/**2936* Recomputes the plugin list using the injected plugins and plugin ordering.2937*2938* @private2939*/2940function recomputePluginOrdering() {2941if (!EventPluginOrder) {2942// Wait until an `EventPluginOrder` is injected.2943return;2944}2945for (var pluginName in namesToPlugins) {2946var PluginModule = namesToPlugins[pluginName];2947var pluginIndex = EventPluginOrder.indexOf(pluginName);2948("production" !== "development" ? invariant(2949pluginIndex > -1,2950'EventPluginRegistry: Cannot inject event plugins that do not exist in ' +2951'the plugin ordering, `%s`.',2952pluginName2953) : invariant(pluginIndex > -1));2954if (EventPluginRegistry.plugins[pluginIndex]) {2955continue;2956}2957("production" !== "development" ? invariant(2958PluginModule.extractEvents,2959'EventPluginRegistry: Event plugins must implement an `extractEvents` ' +2960'method, but `%s` does not.',2961pluginName2962) : invariant(PluginModule.extractEvents));2963EventPluginRegistry.plugins[pluginIndex] = PluginModule;2964var publishedEvents = PluginModule.eventTypes;2965for (var eventName in publishedEvents) {2966("production" !== "development" ? invariant(2967publishEventForPlugin(2968publishedEvents[eventName],2969PluginModule,2970eventName2971),2972'EventPluginRegistry: Failed to publish event `%s` for plugin `%s`.',2973eventName,2974pluginName2975) : invariant(publishEventForPlugin(2976publishedEvents[eventName],2977PluginModule,2978eventName2979)));2980}2981}2982}29832984/**2985* Publishes an event so that it can be dispatched by the supplied plugin.2986*2987* @param {object} dispatchConfig Dispatch configuration for the event.2988* @param {object} PluginModule Plugin publishing the event.2989* @return {boolean} True if the event was successfully published.2990* @private2991*/2992function publishEventForPlugin(dispatchConfig, PluginModule, eventName) {2993("production" !== "development" ? invariant(2994!EventPluginRegistry.eventNameDispatchConfigs.hasOwnProperty(eventName),2995'EventPluginHub: More than one plugin attempted to publish the same ' +2996'event name, `%s`.',2997eventName2998) : invariant(!EventPluginRegistry.eventNameDispatchConfigs.hasOwnProperty(eventName)));2999EventPluginRegistry.eventNameDispatchConfigs[eventName] = dispatchConfig;30003001var phasedRegistrationNames = dispatchConfig.phasedRegistrationNames;3002if (phasedRegistrationNames) {3003for (var phaseName in phasedRegistrationNames) {3004if (phasedRegistrationNames.hasOwnProperty(phaseName)) {3005var phasedRegistrationName = phasedRegistrationNames[phaseName];3006publishRegistrationName(3007phasedRegistrationName,3008PluginModule,3009eventName3010);3011}3012}3013return true;3014} else if (dispatchConfig.registrationName) {3015publishRegistrationName(3016dispatchConfig.registrationName,3017PluginModule,3018eventName3019);3020return true;3021}3022return false;3023}30243025/**3026* Publishes a registration name that is used to identify dispatched events and3027* can be used with `EventPluginHub.putListener` to register listeners.3028*3029* @param {string} registrationName Registration name to add.3030* @param {object} PluginModule Plugin publishing the event.3031* @private3032*/3033function publishRegistrationName(registrationName, PluginModule, eventName) {3034("production" !== "development" ? invariant(3035!EventPluginRegistry.registrationNameModules[registrationName],3036'EventPluginHub: More than one plugin attempted to publish the same ' +3037'registration name, `%s`.',3038registrationName3039) : invariant(!EventPluginRegistry.registrationNameModules[registrationName]));3040EventPluginRegistry.registrationNameModules[registrationName] = PluginModule;3041EventPluginRegistry.registrationNameDependencies[registrationName] =3042PluginModule.eventTypes[eventName].dependencies;3043}30443045/**3046* Registers plugins so that they can extract and dispatch events.3047*3048* @see {EventPluginHub}3049*/3050var EventPluginRegistry = {30513052/**3053* Ordered list of injected plugins.3054*/3055plugins: [],30563057/**3058* Mapping from event name to dispatch config3059*/3060eventNameDispatchConfigs: {},30613062/**3063* Mapping from registration name to plugin module3064*/3065registrationNameModules: {},30663067/**3068* Mapping from registration name to event name3069*/3070registrationNameDependencies: {},30713072/**3073* Injects an ordering of plugins (by plugin name). This allows the ordering3074* to be decoupled from injection of the actual plugins so that ordering is3075* always deterministic regardless of packaging, on-the-fly injection, etc.3076*3077* @param {array} InjectedEventPluginOrder3078* @internal3079* @see {EventPluginHub.injection.injectEventPluginOrder}3080*/3081injectEventPluginOrder: function(InjectedEventPluginOrder) {3082("production" !== "development" ? invariant(3083!EventPluginOrder,3084'EventPluginRegistry: Cannot inject event plugin ordering more than ' +3085'once. You are likely trying to load more than one copy of React.'3086) : invariant(!EventPluginOrder));3087// Clone the ordering so it cannot be dynamically mutated.3088EventPluginOrder = Array.prototype.slice.call(InjectedEventPluginOrder);3089recomputePluginOrdering();3090},30913092/**3093* Injects plugins to be used by `EventPluginHub`. The plugin names must be3094* in the ordering injected by `injectEventPluginOrder`.3095*3096* Plugins can be injected as part of page initialization or on-the-fly.3097*3098* @param {object} injectedNamesToPlugins Map from names to plugin modules.3099* @internal3100* @see {EventPluginHub.injection.injectEventPluginsByName}3101*/3102injectEventPluginsByName: function(injectedNamesToPlugins) {3103var isOrderingDirty = false;3104for (var pluginName in injectedNamesToPlugins) {3105if (!injectedNamesToPlugins.hasOwnProperty(pluginName)) {3106continue;3107}3108var PluginModule = injectedNamesToPlugins[pluginName];3109if (!namesToPlugins.hasOwnProperty(pluginName) ||3110namesToPlugins[pluginName] !== PluginModule) {3111("production" !== "development" ? invariant(3112!namesToPlugins[pluginName],3113'EventPluginRegistry: Cannot inject two different event plugins ' +3114'using the same name, `%s`.',3115pluginName3116) : invariant(!namesToPlugins[pluginName]));3117namesToPlugins[pluginName] = PluginModule;3118isOrderingDirty = true;3119}3120}3121if (isOrderingDirty) {3122recomputePluginOrdering();3123}3124},31253126/**3127* Looks up the plugin for the supplied event.3128*3129* @param {object} event A synthetic event.3130* @return {?object} The plugin that created the supplied event.3131* @internal3132*/3133getPluginModuleForEvent: function(event) {3134var dispatchConfig = event.dispatchConfig;3135if (dispatchConfig.registrationName) {3136return EventPluginRegistry.registrationNameModules[3137dispatchConfig.registrationName3138] || null;3139}3140for (var phase in dispatchConfig.phasedRegistrationNames) {3141if (!dispatchConfig.phasedRegistrationNames.hasOwnProperty(phase)) {3142continue;3143}3144var PluginModule = EventPluginRegistry.registrationNameModules[3145dispatchConfig.phasedRegistrationNames[phase]3146];3147if (PluginModule) {3148return PluginModule;3149}3150}3151return null;3152},31533154/**3155* Exposed for unit testing.3156* @private3157*/3158_resetEventPlugins: function() {3159EventPluginOrder = null;3160for (var pluginName in namesToPlugins) {3161if (namesToPlugins.hasOwnProperty(pluginName)) {3162delete namesToPlugins[pluginName];3163}3164}3165EventPluginRegistry.plugins.length = 0;31663167var eventNameDispatchConfigs = EventPluginRegistry.eventNameDispatchConfigs;3168for (var eventName in eventNameDispatchConfigs) {3169if (eventNameDispatchConfigs.hasOwnProperty(eventName)) {3170delete eventNameDispatchConfigs[eventName];3171}3172}31733174var registrationNameModules = EventPluginRegistry.registrationNameModules;3175for (var registrationName in registrationNameModules) {3176if (registrationNameModules.hasOwnProperty(registrationName)) {3177delete registrationNameModules[registrationName];3178}3179}3180}31813182};31833184module.exports = EventPluginRegistry;31853186},{"135":135}],19:[function(_dereq_,module,exports){3187/**3188* Copyright 2013-2015, Facebook, Inc.3189* All rights reserved.3190*3191* This source code is licensed under the BSD-style license found in the3192* LICENSE file in the root directory of this source tree. An additional grant3193* of patent rights can be found in the PATENTS file in the same directory.3194*3195* @providesModule EventPluginUtils3196*/31973198'use strict';31993200var EventConstants = _dereq_(15);32013202var invariant = _dereq_(135);32033204/**3205* Injected dependencies:3206*/32073208/**3209* - `Mount`: [required] Module that can convert between React dom IDs and3210* actual node references.3211*/3212var injection = {3213Mount: null,3214injectMount: function(InjectedMount) {3215injection.Mount = InjectedMount;3216if ("production" !== "development") {3217("production" !== "development" ? invariant(3218InjectedMount && InjectedMount.getNode,3219'EventPluginUtils.injection.injectMount(...): Injected Mount module ' +3220'is missing getNode.'3221) : invariant(InjectedMount && InjectedMount.getNode));3222}3223}3224};32253226var topLevelTypes = EventConstants.topLevelTypes;32273228function isEndish(topLevelType) {3229return topLevelType === topLevelTypes.topMouseUp ||3230topLevelType === topLevelTypes.topTouchEnd ||3231topLevelType === topLevelTypes.topTouchCancel;3232}32333234function isMoveish(topLevelType) {3235return topLevelType === topLevelTypes.topMouseMove ||3236topLevelType === topLevelTypes.topTouchMove;3237}3238function isStartish(topLevelType) {3239return topLevelType === topLevelTypes.topMouseDown ||3240topLevelType === topLevelTypes.topTouchStart;3241}324232433244var validateEventDispatches;3245if ("production" !== "development") {3246validateEventDispatches = function(event) {3247var dispatchListeners = event._dispatchListeners;3248var dispatchIDs = event._dispatchIDs;32493250var listenersIsArr = Array.isArray(dispatchListeners);3251var idsIsArr = Array.isArray(dispatchIDs);3252var IDsLen = idsIsArr ? dispatchIDs.length : dispatchIDs ? 1 : 0;3253var listenersLen = listenersIsArr ?3254dispatchListeners.length :3255dispatchListeners ? 1 : 0;32563257("production" !== "development" ? invariant(3258idsIsArr === listenersIsArr && IDsLen === listenersLen,3259'EventPluginUtils: Invalid `event`.'3260) : invariant(idsIsArr === listenersIsArr && IDsLen === listenersLen));3261};3262}32633264/**3265* Invokes `cb(event, listener, id)`. Avoids using call if no scope is3266* provided. The `(listener,id)` pair effectively forms the "dispatch" but are3267* kept separate to conserve memory.3268*/3269function forEachEventDispatch(event, cb) {3270var dispatchListeners = event._dispatchListeners;3271var dispatchIDs = event._dispatchIDs;3272if ("production" !== "development") {3273validateEventDispatches(event);3274}3275if (Array.isArray(dispatchListeners)) {3276for (var i = 0; i < dispatchListeners.length; i++) {3277if (event.isPropagationStopped()) {3278break;3279}3280// Listeners and IDs are two parallel arrays that are always in sync.3281cb(event, dispatchListeners[i], dispatchIDs[i]);3282}3283} else if (dispatchListeners) {3284cb(event, dispatchListeners, dispatchIDs);3285}3286}32873288/**3289* Default implementation of PluginModule.executeDispatch().3290* @param {SyntheticEvent} SyntheticEvent to handle3291* @param {function} Application-level callback3292* @param {string} domID DOM id to pass to the callback.3293*/3294function executeDispatch(event, listener, domID) {3295event.currentTarget = injection.Mount.getNode(domID);3296var returnValue = listener(event, domID);3297event.currentTarget = null;3298return returnValue;3299}33003301/**3302* Standard/simple iteration through an event's collected dispatches.3303*/3304function executeDispatchesInOrder(event, cb) {3305forEachEventDispatch(event, cb);3306event._dispatchListeners = null;3307event._dispatchIDs = null;3308}33093310/**3311* Standard/simple iteration through an event's collected dispatches, but stops3312* at the first dispatch execution returning true, and returns that id.3313*3314* @return id of the first dispatch execution who's listener returns true, or3315* null if no listener returned true.3316*/3317function executeDispatchesInOrderStopAtTrueImpl(event) {3318var dispatchListeners = event._dispatchListeners;3319var dispatchIDs = event._dispatchIDs;3320if ("production" !== "development") {3321validateEventDispatches(event);3322}3323if (Array.isArray(dispatchListeners)) {3324for (var i = 0; i < dispatchListeners.length; i++) {3325if (event.isPropagationStopped()) {3326break;3327}3328// Listeners and IDs are two parallel arrays that are always in sync.3329if (dispatchListeners[i](event, dispatchIDs[i])) {3330return dispatchIDs[i];3331}3332}3333} else if (dispatchListeners) {3334if (dispatchListeners(event, dispatchIDs)) {3335return dispatchIDs;3336}3337}3338return null;3339}33403341/**3342* @see executeDispatchesInOrderStopAtTrueImpl3343*/3344function executeDispatchesInOrderStopAtTrue(event) {3345var ret = executeDispatchesInOrderStopAtTrueImpl(event);3346event._dispatchIDs = null;3347event._dispatchListeners = null;3348return ret;3349}33503351/**3352* Execution of a "direct" dispatch - there must be at most one dispatch3353* accumulated on the event or it is considered an error. It doesn't really make3354* sense for an event with multiple dispatches (bubbled) to keep track of the3355* return values at each dispatch execution, but it does tend to make sense when3356* dealing with "direct" dispatches.3357*3358* @return The return value of executing the single dispatch.3359*/3360function executeDirectDispatch(event) {3361if ("production" !== "development") {3362validateEventDispatches(event);3363}3364var dispatchListener = event._dispatchListeners;3365var dispatchID = event._dispatchIDs;3366("production" !== "development" ? invariant(3367!Array.isArray(dispatchListener),3368'executeDirectDispatch(...): Invalid `event`.'3369) : invariant(!Array.isArray(dispatchListener)));3370var res = dispatchListener ?3371dispatchListener(event, dispatchID) :3372null;3373event._dispatchListeners = null;3374event._dispatchIDs = null;3375return res;3376}33773378/**3379* @param {SyntheticEvent} event3380* @return {bool} True iff number of dispatches accumulated is greater than 0.3381*/3382function hasDispatches(event) {3383return !!event._dispatchListeners;3384}33853386/**3387* General utilities that are useful in creating custom Event Plugins.3388*/3389var EventPluginUtils = {3390isEndish: isEndish,3391isMoveish: isMoveish,3392isStartish: isStartish,33933394executeDirectDispatch: executeDirectDispatch,3395executeDispatch: executeDispatch,3396executeDispatchesInOrder: executeDispatchesInOrder,3397executeDispatchesInOrderStopAtTrue: executeDispatchesInOrderStopAtTrue,3398hasDispatches: hasDispatches,3399injection: injection,3400useTouchEvents: false3401};34023403module.exports = EventPluginUtils;34043405},{"135":135,"15":15}],20:[function(_dereq_,module,exports){3406/**3407* Copyright 2013-2015, Facebook, Inc.3408* All rights reserved.3409*3410* This source code is licensed under the BSD-style license found in the3411* LICENSE file in the root directory of this source tree. An additional grant3412* of patent rights can be found in the PATENTS file in the same directory.3413*3414* @providesModule EventPropagators3415*/34163417'use strict';34183419var EventConstants = _dereq_(15);3420var EventPluginHub = _dereq_(17);34213422var accumulateInto = _dereq_(105);3423var forEachAccumulated = _dereq_(120);34243425var PropagationPhases = EventConstants.PropagationPhases;3426var getListener = EventPluginHub.getListener;34273428/**3429* Some event types have a notion of different registration names for different3430* "phases" of propagation. This finds listeners by a given phase.3431*/3432function listenerAtPhase(id, event, propagationPhase) {3433var registrationName =3434event.dispatchConfig.phasedRegistrationNames[propagationPhase];3435return getListener(id, registrationName);3436}34373438/**3439* Tags a `SyntheticEvent` with dispatched listeners. Creating this function3440* here, allows us to not have to bind or create functions for each event.3441* Mutating the event's members allows us to not have to create a wrapping3442* "dispatch" object that pairs the event with the listener.3443*/3444function accumulateDirectionalDispatches(domID, upwards, event) {3445if ("production" !== "development") {3446if (!domID) {3447throw new Error('Dispatching id must not be null');3448}3449}3450var phase = upwards ? PropagationPhases.bubbled : PropagationPhases.captured;3451var listener = listenerAtPhase(domID, event, phase);3452if (listener) {3453event._dispatchListeners =3454accumulateInto(event._dispatchListeners, listener);3455event._dispatchIDs = accumulateInto(event._dispatchIDs, domID);3456}3457}34583459/**3460* Collect dispatches (must be entirely collected before dispatching - see unit3461* tests). Lazily allocate the array to conserve memory. We must loop through3462* each event and perform the traversal for each one. We can not perform a3463* single traversal for the entire collection of events because each event may3464* have a different target.3465*/3466function accumulateTwoPhaseDispatchesSingle(event) {3467if (event && event.dispatchConfig.phasedRegistrationNames) {3468EventPluginHub.injection.getInstanceHandle().traverseTwoPhase(3469event.dispatchMarker,3470accumulateDirectionalDispatches,3471event3472);3473}3474}347534763477/**3478* Accumulates without regard to direction, does not look for phased3479* registration names. Same as `accumulateDirectDispatchesSingle` but without3480* requiring that the `dispatchMarker` be the same as the dispatched ID.3481*/3482function accumulateDispatches(id, ignoredDirection, event) {3483if (event && event.dispatchConfig.registrationName) {3484var registrationName = event.dispatchConfig.registrationName;3485var listener = getListener(id, registrationName);3486if (listener) {3487event._dispatchListeners =3488accumulateInto(event._dispatchListeners, listener);3489event._dispatchIDs = accumulateInto(event._dispatchIDs, id);3490}3491}3492}34933494/**3495* Accumulates dispatches on an `SyntheticEvent`, but only for the3496* `dispatchMarker`.3497* @param {SyntheticEvent} event3498*/3499function accumulateDirectDispatchesSingle(event) {3500if (event && event.dispatchConfig.registrationName) {3501accumulateDispatches(event.dispatchMarker, null, event);3502}3503}35043505function accumulateTwoPhaseDispatches(events) {3506forEachAccumulated(events, accumulateTwoPhaseDispatchesSingle);3507}35083509function accumulateEnterLeaveDispatches(leave, enter, fromID, toID) {3510EventPluginHub.injection.getInstanceHandle().traverseEnterLeave(3511fromID,3512toID,3513accumulateDispatches,3514leave,3515enter3516);3517}351835193520function accumulateDirectDispatches(events) {3521forEachAccumulated(events, accumulateDirectDispatchesSingle);3522}3523352435253526/**3527* A small set of propagation patterns, each of which will accept a small amount3528* of information, and generate a set of "dispatch ready event objects" - which3529* are sets of events that have already been annotated with a set of dispatched3530* listener functions/ids. The API is designed this way to discourage these3531* propagation strategies from actually executing the dispatches, since we3532* always want to collect the entire set of dispatches before executing event a3533* single one.3534*3535* @constructor EventPropagators3536*/3537var EventPropagators = {3538accumulateTwoPhaseDispatches: accumulateTwoPhaseDispatches,3539accumulateDirectDispatches: accumulateDirectDispatches,3540accumulateEnterLeaveDispatches: accumulateEnterLeaveDispatches3541};35423543module.exports = EventPropagators;35443545},{"105":105,"120":120,"15":15,"17":17}],21:[function(_dereq_,module,exports){3546/**3547* Copyright 2013-2015, Facebook, Inc.3548* All rights reserved.3549*3550* This source code is licensed under the BSD-style license found in the3551* LICENSE file in the root directory of this source tree. An additional grant3552* of patent rights can be found in the PATENTS file in the same directory.3553*3554* @providesModule ExecutionEnvironment3555*/35563557/*jslint evil: true */35583559"use strict";35603561var canUseDOM = !!(3562(typeof window !== 'undefined' &&3563window.document && window.document.createElement)3564);35653566/**3567* Simple, lightweight module assisting with the detection and context of3568* Worker. Helps avoid circular dependencies and allows code to reason about3569* whether or not they are in a Worker, even if they never include the main3570* `ReactWorker` dependency.3571*/3572var ExecutionEnvironment = {35733574canUseDOM: canUseDOM,35753576canUseWorkers: typeof Worker !== 'undefined',35773578canUseEventListeners:3579canUseDOM && !!(window.addEventListener || window.attachEvent),35803581canUseViewport: canUseDOM && !!window.screen,35823583isInWorker: !canUseDOM // For now, this is true - might change in the future.35843585};35863587module.exports = ExecutionEnvironment;35883589},{}],22:[function(_dereq_,module,exports){3590/**3591* Copyright 2013-2015, Facebook, Inc.3592* All rights reserved.3593*3594* This source code is licensed under the BSD-style license found in the3595* LICENSE file in the root directory of this source tree. An additional grant3596* of patent rights can be found in the PATENTS file in the same directory.3597*3598* @providesModule FallbackCompositionState3599* @typechecks static-only3600*/36013602'use strict';36033604var PooledClass = _dereq_(28);36053606var assign = _dereq_(27);3607var getTextContentAccessor = _dereq_(130);36083609/**3610* This helper class stores information about text content of a target node,3611* allowing comparison of content before and after a given event.3612*3613* Identify the node where selection currently begins, then observe3614* both its text content and its current position in the DOM. Since the3615* browser may natively replace the target node during composition, we can3616* use its position to find its replacement.3617*3618* @param {DOMEventTarget} root3619*/3620function FallbackCompositionState(root) {3621this._root = root;3622this._startText = this.getText();3623this._fallbackText = null;3624}36253626assign(FallbackCompositionState.prototype, {3627/**3628* Get current text of input.3629*3630* @return {string}3631*/3632getText: function() {3633if ('value' in this._root) {3634return this._root.value;3635}3636return this._root[getTextContentAccessor()];3637},36383639/**3640* Determine the differing substring between the initially stored3641* text content and the current content.3642*3643* @return {string}3644*/3645getData: function() {3646if (this._fallbackText) {3647return this._fallbackText;3648}36493650var start;3651var startValue = this._startText;3652var startLength = startValue.length;3653var end;3654var endValue = this.getText();3655var endLength = endValue.length;36563657for (start = 0; start < startLength; start++) {3658if (startValue[start] !== endValue[start]) {3659break;3660}3661}36623663var minEnd = startLength - start;3664for (end = 1; end <= minEnd; end++) {3665if (startValue[startLength - end] !== endValue[endLength - end]) {3666break;3667}3668}36693670var sliceTail = end > 1 ? 1 - end : undefined;3671this._fallbackText = endValue.slice(start, sliceTail);3672return this._fallbackText;3673}3674});36753676PooledClass.addPoolingTo(FallbackCompositionState);36773678module.exports = FallbackCompositionState;36793680},{"130":130,"27":27,"28":28}],23:[function(_dereq_,module,exports){3681/**3682* Copyright 2013-2015, Facebook, Inc.3683* All rights reserved.3684*3685* This source code is licensed under the BSD-style license found in the3686* LICENSE file in the root directory of this source tree. An additional grant3687* of patent rights can be found in the PATENTS file in the same directory.3688*3689* @providesModule HTMLDOMPropertyConfig3690*/36913692/*jslint bitwise: true*/36933694'use strict';36953696var DOMProperty = _dereq_(10);3697var ExecutionEnvironment = _dereq_(21);36983699var MUST_USE_ATTRIBUTE = DOMProperty.injection.MUST_USE_ATTRIBUTE;3700var MUST_USE_PROPERTY = DOMProperty.injection.MUST_USE_PROPERTY;3701var HAS_BOOLEAN_VALUE = DOMProperty.injection.HAS_BOOLEAN_VALUE;3702var HAS_SIDE_EFFECTS = DOMProperty.injection.HAS_SIDE_EFFECTS;3703var HAS_NUMERIC_VALUE = DOMProperty.injection.HAS_NUMERIC_VALUE;3704var HAS_POSITIVE_NUMERIC_VALUE =3705DOMProperty.injection.HAS_POSITIVE_NUMERIC_VALUE;3706var HAS_OVERLOADED_BOOLEAN_VALUE =3707DOMProperty.injection.HAS_OVERLOADED_BOOLEAN_VALUE;37083709var hasSVG;3710if (ExecutionEnvironment.canUseDOM) {3711var implementation = document.implementation;3712hasSVG = (3713implementation &&3714implementation.hasFeature &&3715implementation.hasFeature(3716'http://www.w3.org/TR/SVG11/feature#BasicStructure',3717'1.1'3718)3719);3720}372137223723var HTMLDOMPropertyConfig = {3724isCustomAttribute: RegExp.prototype.test.bind(3725/^(data|aria)-[a-z_][a-z\d_.\-]*$/3726),3727Properties: {3728/**3729* Standard Properties3730*/3731accept: null,3732acceptCharset: null,3733accessKey: null,3734action: null,3735allowFullScreen: MUST_USE_ATTRIBUTE | HAS_BOOLEAN_VALUE,3736allowTransparency: MUST_USE_ATTRIBUTE,3737alt: null,3738async: HAS_BOOLEAN_VALUE,3739autoComplete: null,3740// autoFocus is polyfilled/normalized by AutoFocusMixin3741// autoFocus: HAS_BOOLEAN_VALUE,3742autoPlay: HAS_BOOLEAN_VALUE,3743cellPadding: null,3744cellSpacing: null,3745charSet: MUST_USE_ATTRIBUTE,3746checked: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,3747classID: MUST_USE_ATTRIBUTE,3748// To set className on SVG elements, it's necessary to use .setAttribute;3749// this works on HTML elements too in all browsers except IE8. Conveniently,3750// IE8 doesn't support SVG and so we can simply use the attribute in3751// browsers that support SVG and the property in browsers that don't,3752// regardless of whether the element is HTML or SVG.3753className: hasSVG ? MUST_USE_ATTRIBUTE : MUST_USE_PROPERTY,3754cols: MUST_USE_ATTRIBUTE | HAS_POSITIVE_NUMERIC_VALUE,3755colSpan: null,3756content: null,3757contentEditable: null,3758contextMenu: MUST_USE_ATTRIBUTE,3759controls: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,3760coords: null,3761crossOrigin: null,3762data: null, // For `<object />` acts as `src`.3763dateTime: MUST_USE_ATTRIBUTE,3764defer: HAS_BOOLEAN_VALUE,3765dir: null,3766disabled: MUST_USE_ATTRIBUTE | HAS_BOOLEAN_VALUE,3767download: HAS_OVERLOADED_BOOLEAN_VALUE,3768draggable: null,3769encType: null,3770form: MUST_USE_ATTRIBUTE,3771formAction: MUST_USE_ATTRIBUTE,3772formEncType: MUST_USE_ATTRIBUTE,3773formMethod: MUST_USE_ATTRIBUTE,3774formNoValidate: HAS_BOOLEAN_VALUE,3775formTarget: MUST_USE_ATTRIBUTE,3776frameBorder: MUST_USE_ATTRIBUTE,3777headers: null,3778height: MUST_USE_ATTRIBUTE,3779hidden: MUST_USE_ATTRIBUTE | HAS_BOOLEAN_VALUE,3780high: null,3781href: null,3782hrefLang: null,3783htmlFor: null,3784httpEquiv: null,3785icon: null,3786id: MUST_USE_PROPERTY,3787label: null,3788lang: null,3789list: MUST_USE_ATTRIBUTE,3790loop: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,3791low: null,3792manifest: MUST_USE_ATTRIBUTE,3793marginHeight: null,3794marginWidth: null,3795max: null,3796maxLength: MUST_USE_ATTRIBUTE,3797media: MUST_USE_ATTRIBUTE,3798mediaGroup: null,3799method: null,3800min: null,3801multiple: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,3802muted: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,3803name: null,3804noValidate: HAS_BOOLEAN_VALUE,3805open: HAS_BOOLEAN_VALUE,3806optimum: null,3807pattern: null,3808placeholder: null,3809poster: null,3810preload: null,3811radioGroup: null,3812readOnly: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,3813rel: null,3814required: HAS_BOOLEAN_VALUE,3815role: MUST_USE_ATTRIBUTE,3816rows: MUST_USE_ATTRIBUTE | HAS_POSITIVE_NUMERIC_VALUE,3817rowSpan: null,3818sandbox: null,3819scope: null,3820scoped: HAS_BOOLEAN_VALUE,3821scrolling: null,3822seamless: MUST_USE_ATTRIBUTE | HAS_BOOLEAN_VALUE,3823selected: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,3824shape: null,3825size: MUST_USE_ATTRIBUTE | HAS_POSITIVE_NUMERIC_VALUE,3826sizes: MUST_USE_ATTRIBUTE,3827span: HAS_POSITIVE_NUMERIC_VALUE,3828spellCheck: null,3829src: null,3830srcDoc: MUST_USE_PROPERTY,3831srcSet: MUST_USE_ATTRIBUTE,3832start: HAS_NUMERIC_VALUE,3833step: null,3834style: null,3835tabIndex: null,3836target: null,3837title: null,3838type: null,3839useMap: null,3840value: MUST_USE_PROPERTY | HAS_SIDE_EFFECTS,3841width: MUST_USE_ATTRIBUTE,3842wmode: MUST_USE_ATTRIBUTE,38433844/**3845* Non-standard Properties3846*/3847// autoCapitalize and autoCorrect are supported in Mobile Safari for3848// keyboard hints.3849autoCapitalize: null,3850autoCorrect: null,3851// itemProp, itemScope, itemType are for3852// Microdata support. See http://schema.org/docs/gs.html3853itemProp: MUST_USE_ATTRIBUTE,3854itemScope: MUST_USE_ATTRIBUTE | HAS_BOOLEAN_VALUE,3855itemType: MUST_USE_ATTRIBUTE,3856// itemID and itemRef are for Microdata support as well but3857// only specified in the the WHATWG spec document. See3858// https://html.spec.whatwg.org/multipage/microdata.html#microdata-dom-api3859itemID: MUST_USE_ATTRIBUTE,3860itemRef: MUST_USE_ATTRIBUTE,3861// property is supported for OpenGraph in meta tags.3862property: null,3863// IE-only attribute that controls focus behavior3864unselectable: MUST_USE_ATTRIBUTE3865},3866DOMAttributeNames: {3867acceptCharset: 'accept-charset',3868className: 'class',3869htmlFor: 'for',3870httpEquiv: 'http-equiv'3871},3872DOMPropertyNames: {3873autoCapitalize: 'autocapitalize',3874autoComplete: 'autocomplete',3875autoCorrect: 'autocorrect',3876autoFocus: 'autofocus',3877autoPlay: 'autoplay',3878// `encoding` is equivalent to `enctype`, IE8 lacks an `enctype` setter.3879// http://www.w3.org/TR/html5/forms.html#dom-fs-encoding3880encType: 'encoding',3881hrefLang: 'hreflang',3882radioGroup: 'radiogroup',3883spellCheck: 'spellcheck',3884srcDoc: 'srcdoc',3885srcSet: 'srcset'3886}3887};38883889module.exports = HTMLDOMPropertyConfig;38903891},{"10":10,"21":21}],24:[function(_dereq_,module,exports){3892/**3893* Copyright 2013-2015, Facebook, Inc.3894* All rights reserved.3895*3896* This source code is licensed under the BSD-style license found in the3897* LICENSE file in the root directory of this source tree. An additional grant3898* of patent rights can be found in the PATENTS file in the same directory.3899*3900* @providesModule LinkedValueUtils3901* @typechecks static-only3902*/39033904'use strict';39053906var ReactPropTypes = _dereq_(78);39073908var invariant = _dereq_(135);39093910var hasReadOnlyValue = {3911'button': true,3912'checkbox': true,3913'image': true,3914'hidden': true,3915'radio': true,3916'reset': true,3917'submit': true3918};39193920function _assertSingleLink(input) {3921("production" !== "development" ? invariant(3922input.props.checkedLink == null || input.props.valueLink == null,3923'Cannot provide a checkedLink and a valueLink. If you want to use ' +3924'checkedLink, you probably don\'t want to use valueLink and vice versa.'3925) : invariant(input.props.checkedLink == null || input.props.valueLink == null));3926}3927function _assertValueLink(input) {3928_assertSingleLink(input);3929("production" !== "development" ? invariant(3930input.props.value == null && input.props.onChange == null,3931'Cannot provide a valueLink and a value or onChange event. If you want ' +3932'to use value or onChange, you probably don\'t want to use valueLink.'3933) : invariant(input.props.value == null && input.props.onChange == null));3934}39353936function _assertCheckedLink(input) {3937_assertSingleLink(input);3938("production" !== "development" ? invariant(3939input.props.checked == null && input.props.onChange == null,3940'Cannot provide a checkedLink and a checked property or onChange event. ' +3941'If you want to use checked or onChange, you probably don\'t want to ' +3942'use checkedLink'3943) : invariant(input.props.checked == null && input.props.onChange == null));3944}39453946/**3947* @param {SyntheticEvent} e change event to handle3948*/3949function _handleLinkedValueChange(e) {3950/*jshint validthis:true */3951this.props.valueLink.requestChange(e.target.value);3952}39533954/**3955* @param {SyntheticEvent} e change event to handle3956*/3957function _handleLinkedCheckChange(e) {3958/*jshint validthis:true */3959this.props.checkedLink.requestChange(e.target.checked);3960}39613962/**3963* Provide a linked `value` attribute for controlled forms. You should not use3964* this outside of the ReactDOM controlled form components.3965*/3966var LinkedValueUtils = {3967Mixin: {3968propTypes: {3969value: function(props, propName, componentName) {3970if (!props[propName] ||3971hasReadOnlyValue[props.type] ||3972props.onChange ||3973props.readOnly ||3974props.disabled) {3975return null;3976}3977return new Error(3978'You provided a `value` prop to a form field without an ' +3979'`onChange` handler. This will render a read-only field. If ' +3980'the field should be mutable use `defaultValue`. Otherwise, ' +3981'set either `onChange` or `readOnly`.'3982);3983},3984checked: function(props, propName, componentName) {3985if (!props[propName] ||3986props.onChange ||3987props.readOnly ||3988props.disabled) {3989return null;3990}3991return new Error(3992'You provided a `checked` prop to a form field without an ' +3993'`onChange` handler. This will render a read-only field. If ' +3994'the field should be mutable use `defaultChecked`. Otherwise, ' +3995'set either `onChange` or `readOnly`.'3996);3997},3998onChange: ReactPropTypes.func3999}4000},40014002/**4003* @param {ReactComponent} input Form component4004* @return {*} current value of the input either from value prop or link.4005*/4006getValue: function(input) {4007if (input.props.valueLink) {4008_assertValueLink(input);4009return input.props.valueLink.value;4010}4011return input.props.value;4012},40134014/**4015* @param {ReactComponent} input Form component4016* @return {*} current checked status of the input either from checked prop4017* or link.4018*/4019getChecked: function(input) {4020if (input.props.checkedLink) {4021_assertCheckedLink(input);4022return input.props.checkedLink.value;4023}4024return input.props.checked;4025},40264027/**4028* @param {ReactComponent} input Form component4029* @return {function} change callback either from onChange prop or link.4030*/4031getOnChange: function(input) {4032if (input.props.valueLink) {4033_assertValueLink(input);4034return _handleLinkedValueChange;4035} else if (input.props.checkedLink) {4036_assertCheckedLink(input);4037return _handleLinkedCheckChange;4038}4039return input.props.onChange;4040}4041};40424043module.exports = LinkedValueUtils;40444045},{"135":135,"78":78}],25:[function(_dereq_,module,exports){4046/**4047* Copyright 2014-2015, Facebook, Inc.4048* All rights reserved.4049*4050* This source code is licensed under the BSD-style license found in the4051* LICENSE file in the root directory of this source tree. An additional grant4052* of patent rights can be found in the PATENTS file in the same directory.4053*4054* @providesModule LocalEventTrapMixin4055*/40564057'use strict';40584059var ReactBrowserEventEmitter = _dereq_(30);40604061var accumulateInto = _dereq_(105);4062var forEachAccumulated = _dereq_(120);4063var invariant = _dereq_(135);40644065function remove(event) {4066event.remove();4067}40684069var LocalEventTrapMixin = {4070trapBubbledEvent:function(topLevelType, handlerBaseName) {4071("production" !== "development" ? invariant(this.isMounted(), 'Must be mounted to trap events') : invariant(this.isMounted()));4072// If a component renders to null or if another component fatals and causes4073// the state of the tree to be corrupted, `node` here can be null.4074var node = this.getDOMNode();4075("production" !== "development" ? invariant(4076node,4077'LocalEventTrapMixin.trapBubbledEvent(...): Requires node to be rendered.'4078) : invariant(node));4079var listener = ReactBrowserEventEmitter.trapBubbledEvent(4080topLevelType,4081handlerBaseName,4082node4083);4084this._localEventListeners =4085accumulateInto(this._localEventListeners, listener);4086},40874088// trapCapturedEvent would look nearly identical. We don't implement that4089// method because it isn't currently needed.40904091componentWillUnmount:function() {4092if (this._localEventListeners) {4093forEachAccumulated(this._localEventListeners, remove);4094}4095}4096};40974098module.exports = LocalEventTrapMixin;40994100},{"105":105,"120":120,"135":135,"30":30}],26:[function(_dereq_,module,exports){4101/**4102* Copyright 2013-2015, Facebook, Inc.4103* All rights reserved.4104*4105* This source code is licensed under the BSD-style license found in the4106* LICENSE file in the root directory of this source tree. An additional grant4107* of patent rights can be found in the PATENTS file in the same directory.4108*4109* @providesModule MobileSafariClickEventPlugin4110* @typechecks static-only4111*/41124113'use strict';41144115var EventConstants = _dereq_(15);41164117var emptyFunction = _dereq_(114);41184119var topLevelTypes = EventConstants.topLevelTypes;41204121/**4122* Mobile Safari does not fire properly bubble click events on non-interactive4123* elements, which means delegated click listeners do not fire. The workaround4124* for this bug involves attaching an empty click listener on the target node.4125*4126* This particular plugin works around the bug by attaching an empty click4127* listener on `touchstart` (which does fire on every element).4128*/4129var MobileSafariClickEventPlugin = {41304131eventTypes: null,41324133/**4134* @param {string} topLevelType Record from `EventConstants`.4135* @param {DOMEventTarget} topLevelTarget The listening component root node.4136* @param {string} topLevelTargetID ID of `topLevelTarget`.4137* @param {object} nativeEvent Native browser event.4138* @return {*} An accumulation of synthetic events.4139* @see {EventPluginHub.extractEvents}4140*/4141extractEvents: function(4142topLevelType,4143topLevelTarget,4144topLevelTargetID,4145nativeEvent) {4146if (topLevelType === topLevelTypes.topTouchStart) {4147var target = nativeEvent.target;4148if (target && !target.onclick) {4149target.onclick = emptyFunction;4150}4151}4152}41534154};41554156module.exports = MobileSafariClickEventPlugin;41574158},{"114":114,"15":15}],27:[function(_dereq_,module,exports){4159/**4160* Copyright 2014-2015, Facebook, Inc.4161* All rights reserved.4162*4163* This source code is licensed under the BSD-style license found in the4164* LICENSE file in the root directory of this source tree. An additional grant4165* of patent rights can be found in the PATENTS file in the same directory.4166*4167* @providesModule Object.assign4168*/41694170// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-object.assign41714172'use strict';41734174function assign(target, sources) {4175if (target == null) {4176throw new TypeError('Object.assign target cannot be null or undefined');4177}41784179var to = Object(target);4180var hasOwnProperty = Object.prototype.hasOwnProperty;41814182for (var nextIndex = 1; nextIndex < arguments.length; nextIndex++) {4183var nextSource = arguments[nextIndex];4184if (nextSource == null) {4185continue;4186}41874188var from = Object(nextSource);41894190// We don't currently support accessors nor proxies. Therefore this4191// copy cannot throw. If we ever supported this then we must handle4192// exceptions and side-effects. We don't support symbols so they won't4193// be transferred.41944195for (var key in from) {4196if (hasOwnProperty.call(from, key)) {4197to[key] = from[key];4198}4199}4200}42014202return to;4203}42044205module.exports = assign;42064207},{}],28:[function(_dereq_,module,exports){4208/**4209* Copyright 2013-2015, Facebook, Inc.4210* All rights reserved.4211*4212* This source code is licensed under the BSD-style license found in the4213* LICENSE file in the root directory of this source tree. An additional grant4214* of patent rights can be found in the PATENTS file in the same directory.4215*4216* @providesModule PooledClass4217*/42184219'use strict';42204221var invariant = _dereq_(135);42224223/**4224* Static poolers. Several custom versions for each potential number of4225* arguments. A completely generic pooler is easy to implement, but would4226* require accessing the `arguments` object. In each of these, `this` refers to4227* the Class itself, not an instance. If any others are needed, simply add them4228* here, or in their own files.4229*/4230var oneArgumentPooler = function(copyFieldsFrom) {4231var Klass = this;4232if (Klass.instancePool.length) {4233var instance = Klass.instancePool.pop();4234Klass.call(instance, copyFieldsFrom);4235return instance;4236} else {4237return new Klass(copyFieldsFrom);4238}4239};42404241var twoArgumentPooler = function(a1, a2) {4242var Klass = this;4243if (Klass.instancePool.length) {4244var instance = Klass.instancePool.pop();4245Klass.call(instance, a1, a2);4246return instance;4247} else {4248return new Klass(a1, a2);4249}4250};42514252var threeArgumentPooler = function(a1, a2, a3) {4253var Klass = this;4254if (Klass.instancePool.length) {4255var instance = Klass.instancePool.pop();4256Klass.call(instance, a1, a2, a3);4257return instance;4258} else {4259return new Klass(a1, a2, a3);4260}4261};42624263var fiveArgumentPooler = function(a1, a2, a3, a4, a5) {4264var Klass = this;4265if (Klass.instancePool.length) {4266var instance = Klass.instancePool.pop();4267Klass.call(instance, a1, a2, a3, a4, a5);4268return instance;4269} else {4270return new Klass(a1, a2, a3, a4, a5);4271}4272};42734274var standardReleaser = function(instance) {4275var Klass = this;4276("production" !== "development" ? invariant(4277instance instanceof Klass,4278'Trying to release an instance into a pool of a different type.'4279) : invariant(instance instanceof Klass));4280if (instance.destructor) {4281instance.destructor();4282}4283if (Klass.instancePool.length < Klass.poolSize) {4284Klass.instancePool.push(instance);4285}4286};42874288var DEFAULT_POOL_SIZE = 10;4289var DEFAULT_POOLER = oneArgumentPooler;42904291/**4292* Augments `CopyConstructor` to be a poolable class, augmenting only the class4293* itself (statically) not adding any prototypical fields. Any CopyConstructor4294* you give this may have a `poolSize` property, and will look for a4295* prototypical `destructor` on instances (optional).4296*4297* @param {Function} CopyConstructor Constructor that can be used to reset.4298* @param {Function} pooler Customizable pooler.4299*/4300var addPoolingTo = function(CopyConstructor, pooler) {4301var NewKlass = CopyConstructor;4302NewKlass.instancePool = [];4303NewKlass.getPooled = pooler || DEFAULT_POOLER;4304if (!NewKlass.poolSize) {4305NewKlass.poolSize = DEFAULT_POOL_SIZE;4306}4307NewKlass.release = standardReleaser;4308return NewKlass;4309};43104311var PooledClass = {4312addPoolingTo: addPoolingTo,4313oneArgumentPooler: oneArgumentPooler,4314twoArgumentPooler: twoArgumentPooler,4315threeArgumentPooler: threeArgumentPooler,4316fiveArgumentPooler: fiveArgumentPooler4317};43184319module.exports = PooledClass;43204321},{"135":135}],29:[function(_dereq_,module,exports){4322/**4323* Copyright 2013-2015, Facebook, Inc.4324* All rights reserved.4325*4326* This source code is licensed under the BSD-style license found in the4327* LICENSE file in the root directory of this source tree. An additional grant4328* of patent rights can be found in the PATENTS file in the same directory.4329*4330* @providesModule ReactBrowserComponentMixin4331*/43324333'use strict';43344335var findDOMNode = _dereq_(117);43364337var ReactBrowserComponentMixin = {4338/**4339* Returns the DOM node rendered by this component.4340*4341* @return {DOMElement} The root node of this component.4342* @final4343* @protected4344*/4345getDOMNode: function() {4346return findDOMNode(this);4347}4348};43494350module.exports = ReactBrowserComponentMixin;43514352},{"117":117}],30:[function(_dereq_,module,exports){4353/**4354* Copyright 2013-2015, Facebook, Inc.4355* All rights reserved.4356*4357* This source code is licensed under the BSD-style license found in the4358* LICENSE file in the root directory of this source tree. An additional grant4359* of patent rights can be found in the PATENTS file in the same directory.4360*4361* @providesModule ReactBrowserEventEmitter4362* @typechecks static-only4363*/43644365'use strict';43664367var EventConstants = _dereq_(15);4368var EventPluginHub = _dereq_(17);4369var EventPluginRegistry = _dereq_(18);4370var ReactEventEmitterMixin = _dereq_(61);4371var ViewportMetrics = _dereq_(104);43724373var assign = _dereq_(27);4374var isEventSupported = _dereq_(136);43754376/**4377* Summary of `ReactBrowserEventEmitter` event handling:4378*4379* - Top-level delegation is used to trap most native browser events. This4380* may only occur in the main thread and is the responsibility of4381* ReactEventListener, which is injected and can therefore support pluggable4382* event sources. This is the only work that occurs in the main thread.4383*4384* - We normalize and de-duplicate events to account for browser quirks. This4385* may be done in the worker thread.4386*4387* - Forward these native events (with the associated top-level type used to4388* trap it) to `EventPluginHub`, which in turn will ask plugins if they want4389* to extract any synthetic events.4390*4391* - The `EventPluginHub` will then process each event by annotating them with4392* "dispatches", a sequence of listeners and IDs that care about that event.4393*4394* - The `EventPluginHub` then dispatches the events.4395*4396* Overview of React and the event system:4397*4398* +------------+ .4399* | DOM | .4400* +------------+ .4401* | .4402* v .4403* +------------+ .4404* | ReactEvent | .4405* | Listener | .4406* +------------+ . +-----------+4407* | . +--------+|SimpleEvent|4408* | . | |Plugin |4409* +-----|------+ . v +-----------+4410* | | | . +--------------+ +------------+4411* | +-----------.--->|EventPluginHub| | Event |4412* | | . | | +-----------+ | Propagators|4413* | ReactEvent | . | | |TapEvent | |------------|4414* | Emitter | . | |<---+|Plugin | |other plugin|4415* | | . | | +-----------+ | utilities |4416* | +-----------.--->| | +------------+4417* | | | . +--------------+4418* +-----|------+ . ^ +-----------+4419* | . | |Enter/Leave|4420* + . +-------+|Plugin |4421* +-------------+ . +-----------+4422* | application | .4423* |-------------| .4424* | | .4425* | | .4426* +-------------+ .4427* .4428* React Core . General Purpose Event Plugin System4429*/44304431var alreadyListeningTo = {};4432var isMonitoringScrollValue = false;4433var reactTopListenersCounter = 0;44344435// For events like 'submit' which don't consistently bubble (which we trap at a4436// lower node than `document`), binding at `document` would cause duplicate4437// events so we don't include them here4438var topEventMapping = {4439topBlur: 'blur',4440topChange: 'change',4441topClick: 'click',4442topCompositionEnd: 'compositionend',4443topCompositionStart: 'compositionstart',4444topCompositionUpdate: 'compositionupdate',4445topContextMenu: 'contextmenu',4446topCopy: 'copy',4447topCut: 'cut',4448topDoubleClick: 'dblclick',4449topDrag: 'drag',4450topDragEnd: 'dragend',4451topDragEnter: 'dragenter',4452topDragExit: 'dragexit',4453topDragLeave: 'dragleave',4454topDragOver: 'dragover',4455topDragStart: 'dragstart',4456topDrop: 'drop',4457topFocus: 'focus',4458topInput: 'input',4459topKeyDown: 'keydown',4460topKeyPress: 'keypress',4461topKeyUp: 'keyup',4462topMouseDown: 'mousedown',4463topMouseMove: 'mousemove',4464topMouseOut: 'mouseout',4465topMouseOver: 'mouseover',4466topMouseUp: 'mouseup',4467topPaste: 'paste',4468topScroll: 'scroll',4469topSelectionChange: 'selectionchange',4470topTextInput: 'textInput',4471topTouchCancel: 'touchcancel',4472topTouchEnd: 'touchend',4473topTouchMove: 'touchmove',4474topTouchStart: 'touchstart',4475topWheel: 'wheel'4476};44774478/**4479* To ensure no conflicts with other potential React instances on the page4480*/4481var topListenersIDKey = '_reactListenersID' + String(Math.random()).slice(2);44824483function getListeningForDocument(mountAt) {4484// In IE8, `mountAt` is a host object and doesn't have `hasOwnProperty`4485// directly.4486if (!Object.prototype.hasOwnProperty.call(mountAt, topListenersIDKey)) {4487mountAt[topListenersIDKey] = reactTopListenersCounter++;4488alreadyListeningTo[mountAt[topListenersIDKey]] = {};4489}4490return alreadyListeningTo[mountAt[topListenersIDKey]];4491}44924493/**4494* `ReactBrowserEventEmitter` is used to attach top-level event listeners. For4495* example:4496*4497* ReactBrowserEventEmitter.putListener('myID', 'onClick', myFunction);4498*4499* This would allocate a "registration" of `('onClick', myFunction)` on 'myID'.4500*4501* @internal4502*/4503var ReactBrowserEventEmitter = assign({}, ReactEventEmitterMixin, {45044505/**4506* Injectable event backend4507*/4508ReactEventListener: null,45094510injection: {4511/**4512* @param {object} ReactEventListener4513*/4514injectReactEventListener: function(ReactEventListener) {4515ReactEventListener.setHandleTopLevel(4516ReactBrowserEventEmitter.handleTopLevel4517);4518ReactBrowserEventEmitter.ReactEventListener = ReactEventListener;4519}4520},45214522/**4523* Sets whether or not any created callbacks should be enabled.4524*4525* @param {boolean} enabled True if callbacks should be enabled.4526*/4527setEnabled: function(enabled) {4528if (ReactBrowserEventEmitter.ReactEventListener) {4529ReactBrowserEventEmitter.ReactEventListener.setEnabled(enabled);4530}4531},45324533/**4534* @return {boolean} True if callbacks are enabled.4535*/4536isEnabled: function() {4537return !!(4538(ReactBrowserEventEmitter.ReactEventListener && ReactBrowserEventEmitter.ReactEventListener.isEnabled())4539);4540},45414542/**4543* We listen for bubbled touch events on the document object.4544*4545* Firefox v8.01 (and possibly others) exhibited strange behavior when4546* mounting `onmousemove` events at some node that was not the document4547* element. The symptoms were that if your mouse is not moving over something4548* contained within that mount point (for example on the background) the4549* top-level listeners for `onmousemove` won't be called. However, if you4550* register the `mousemove` on the document object, then it will of course4551* catch all `mousemove`s. This along with iOS quirks, justifies restricting4552* top-level listeners to the document object only, at least for these4553* movement types of events and possibly all events.4554*4555* @see http://www.quirksmode.org/blog/archives/2010/09/click_event_del.html4556*4557* Also, `keyup`/`keypress`/`keydown` do not bubble to the window on IE, but4558* they bubble to document.4559*4560* @param {string} registrationName Name of listener (e.g. `onClick`).4561* @param {object} contentDocumentHandle Document which owns the container4562*/4563listenTo: function(registrationName, contentDocumentHandle) {4564var mountAt = contentDocumentHandle;4565var isListening = getListeningForDocument(mountAt);4566var dependencies = EventPluginRegistry.4567registrationNameDependencies[registrationName];45684569var topLevelTypes = EventConstants.topLevelTypes;4570for (var i = 0, l = dependencies.length; i < l; i++) {4571var dependency = dependencies[i];4572if (!(4573(isListening.hasOwnProperty(dependency) && isListening[dependency])4574)) {4575if (dependency === topLevelTypes.topWheel) {4576if (isEventSupported('wheel')) {4577ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(4578topLevelTypes.topWheel,4579'wheel',4580mountAt4581);4582} else if (isEventSupported('mousewheel')) {4583ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(4584topLevelTypes.topWheel,4585'mousewheel',4586mountAt4587);4588} else {4589// Firefox needs to capture a different mouse scroll event.4590// @see http://www.quirksmode.org/dom/events/tests/scroll.html4591ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(4592topLevelTypes.topWheel,4593'DOMMouseScroll',4594mountAt4595);4596}4597} else if (dependency === topLevelTypes.topScroll) {45984599if (isEventSupported('scroll', true)) {4600ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent(4601topLevelTypes.topScroll,4602'scroll',4603mountAt4604);4605} else {4606ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(4607topLevelTypes.topScroll,4608'scroll',4609ReactBrowserEventEmitter.ReactEventListener.WINDOW_HANDLE4610);4611}4612} else if (dependency === topLevelTypes.topFocus ||4613dependency === topLevelTypes.topBlur) {46144615if (isEventSupported('focus', true)) {4616ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent(4617topLevelTypes.topFocus,4618'focus',4619mountAt4620);4621ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent(4622topLevelTypes.topBlur,4623'blur',4624mountAt4625);4626} else if (isEventSupported('focusin')) {4627// IE has `focusin` and `focusout` events which bubble.4628// @see http://www.quirksmode.org/blog/archives/2008/04/delegating_the.html4629ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(4630topLevelTypes.topFocus,4631'focusin',4632mountAt4633);4634ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(4635topLevelTypes.topBlur,4636'focusout',4637mountAt4638);4639}46404641// to make sure blur and focus event listeners are only attached once4642isListening[topLevelTypes.topBlur] = true;4643isListening[topLevelTypes.topFocus] = true;4644} else if (topEventMapping.hasOwnProperty(dependency)) {4645ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(4646dependency,4647topEventMapping[dependency],4648mountAt4649);4650}46514652isListening[dependency] = true;4653}4654}4655},46564657trapBubbledEvent: function(topLevelType, handlerBaseName, handle) {4658return ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(4659topLevelType,4660handlerBaseName,4661handle4662);4663},46644665trapCapturedEvent: function(topLevelType, handlerBaseName, handle) {4666return ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent(4667topLevelType,4668handlerBaseName,4669handle4670);4671},46724673/**4674* Listens to window scroll and resize events. We cache scroll values so that4675* application code can access them without triggering reflows.4676*4677* NOTE: Scroll events do not bubble.4678*4679* @see http://www.quirksmode.org/dom/events/scroll.html4680*/4681ensureScrollValueMonitoring: function() {4682if (!isMonitoringScrollValue) {4683var refresh = ViewportMetrics.refreshScrollValues;4684ReactBrowserEventEmitter.ReactEventListener.monitorScrollValue(refresh);4685isMonitoringScrollValue = true;4686}4687},46884689eventNameDispatchConfigs: EventPluginHub.eventNameDispatchConfigs,46904691registrationNameModules: EventPluginHub.registrationNameModules,46924693putListener: EventPluginHub.putListener,46944695getListener: EventPluginHub.getListener,46964697deleteListener: EventPluginHub.deleteListener,46984699deleteAllListeners: EventPluginHub.deleteAllListeners47004701});47024703module.exports = ReactBrowserEventEmitter;47044705},{"104":104,"136":136,"15":15,"17":17,"18":18,"27":27,"61":61}],31:[function(_dereq_,module,exports){4706/**4707* Copyright 2014-2015, Facebook, Inc.4708* All rights reserved.4709*4710* This source code is licensed under the BSD-style license found in the4711* LICENSE file in the root directory of this source tree. An additional grant4712* of patent rights can be found in the PATENTS file in the same directory.4713*4714* @providesModule ReactChildReconciler4715* @typechecks static-only4716*/47174718'use strict';47194720var ReactReconciler = _dereq_(81);47214722var flattenChildren = _dereq_(118);4723var instantiateReactComponent = _dereq_(134);4724var shouldUpdateReactComponent = _dereq_(151);47254726/**4727* ReactChildReconciler provides helpers for initializing or updating a set of4728* children. Its output is suitable for passing it onto ReactMultiChild which4729* does diffed reordering and insertion.4730*/4731var ReactChildReconciler = {47324733/**4734* Generates a "mount image" for each of the supplied children. In the case4735* of `ReactDOMComponent`, a mount image is a string of markup.4736*4737* @param {?object} nestedChildNodes Nested child maps.4738* @return {?object} A set of child instances.4739* @internal4740*/4741instantiateChildren: function(nestedChildNodes, transaction, context) {4742var children = flattenChildren(nestedChildNodes);4743for (var name in children) {4744if (children.hasOwnProperty(name)) {4745var child = children[name];4746// The rendered children must be turned into instances as they're4747// mounted.4748var childInstance = instantiateReactComponent(child, null);4749children[name] = childInstance;4750}4751}4752return children;4753},47544755/**4756* Updates the rendered children and returns a new set of children.4757*4758* @param {?object} prevChildren Previously initialized set of children.4759* @param {?object} nextNestedChildNodes Nested child maps.4760* @param {ReactReconcileTransaction} transaction4761* @param {object} context4762* @return {?object} A new set of child instances.4763* @internal4764*/4765updateChildren: function(4766prevChildren,4767nextNestedChildNodes,4768transaction,4769context) {4770// We currently don't have a way to track moves here but if we use iterators4771// instead of for..in we can zip the iterators and check if an item has4772// moved.4773// TODO: If nothing has changed, return the prevChildren object so that we4774// can quickly bailout if nothing has changed.4775var nextChildren = flattenChildren(nextNestedChildNodes);4776if (!nextChildren && !prevChildren) {4777return null;4778}4779var name;4780for (name in nextChildren) {4781if (!nextChildren.hasOwnProperty(name)) {4782continue;4783}4784var prevChild = prevChildren && prevChildren[name];4785var prevElement = prevChild && prevChild._currentElement;4786var nextElement = nextChildren[name];4787if (shouldUpdateReactComponent(prevElement, nextElement)) {4788ReactReconciler.receiveComponent(4789prevChild, nextElement, transaction, context4790);4791nextChildren[name] = prevChild;4792} else {4793if (prevChild) {4794ReactReconciler.unmountComponent(prevChild, name);4795}4796// The child must be instantiated before it's mounted.4797var nextChildInstance = instantiateReactComponent(4798nextElement,4799null4800);4801nextChildren[name] = nextChildInstance;4802}4803}4804// Unmount children that are no longer present.4805for (name in prevChildren) {4806if (prevChildren.hasOwnProperty(name) &&4807!(nextChildren && nextChildren.hasOwnProperty(name))) {4808ReactReconciler.unmountComponent(prevChildren[name]);4809}4810}4811return nextChildren;4812},48134814/**4815* Unmounts all rendered children. This should be used to clean up children4816* when this component is unmounted.4817*4818* @param {?object} renderedChildren Previously initialized set of children.4819* @internal4820*/4821unmountChildren: function(renderedChildren) {4822for (var name in renderedChildren) {4823var renderedChild = renderedChildren[name];4824ReactReconciler.unmountComponent(renderedChild);4825}4826}48274828};48294830module.exports = ReactChildReconciler;48314832},{"118":118,"134":134,"151":151,"81":81}],32:[function(_dereq_,module,exports){4833/**4834* Copyright 2013-2015, Facebook, Inc.4835* All rights reserved.4836*4837* This source code is licensed under the BSD-style license found in the4838* LICENSE file in the root directory of this source tree. An additional grant4839* of patent rights can be found in the PATENTS file in the same directory.4840*4841* @providesModule ReactChildren4842*/48434844'use strict';48454846var PooledClass = _dereq_(28);4847var ReactFragment = _dereq_(63);48484849var traverseAllChildren = _dereq_(153);4850var warning = _dereq_(154);48514852var twoArgumentPooler = PooledClass.twoArgumentPooler;4853var threeArgumentPooler = PooledClass.threeArgumentPooler;48544855/**4856* PooledClass representing the bookkeeping associated with performing a child4857* traversal. Allows avoiding binding callbacks.4858*4859* @constructor ForEachBookKeeping4860* @param {!function} forEachFunction Function to perform traversal with.4861* @param {?*} forEachContext Context to perform context with.4862*/4863function ForEachBookKeeping(forEachFunction, forEachContext) {4864this.forEachFunction = forEachFunction;4865this.forEachContext = forEachContext;4866}4867PooledClass.addPoolingTo(ForEachBookKeeping, twoArgumentPooler);48684869function forEachSingleChild(traverseContext, child, name, i) {4870var forEachBookKeeping = traverseContext;4871forEachBookKeeping.forEachFunction.call(4872forEachBookKeeping.forEachContext, child, i);4873}48744875/**4876* Iterates through children that are typically specified as `props.children`.4877*4878* The provided forEachFunc(child, index) will be called for each4879* leaf child.4880*4881* @param {?*} children Children tree container.4882* @param {function(*, int)} forEachFunc.4883* @param {*} forEachContext Context for forEachContext.4884*/4885function forEachChildren(children, forEachFunc, forEachContext) {4886if (children == null) {4887return children;4888}48894890var traverseContext =4891ForEachBookKeeping.getPooled(forEachFunc, forEachContext);4892traverseAllChildren(children, forEachSingleChild, traverseContext);4893ForEachBookKeeping.release(traverseContext);4894}48954896/**4897* PooledClass representing the bookkeeping associated with performing a child4898* mapping. Allows avoiding binding callbacks.4899*4900* @constructor MapBookKeeping4901* @param {!*} mapResult Object containing the ordered map of results.4902* @param {!function} mapFunction Function to perform mapping with.4903* @param {?*} mapContext Context to perform mapping with.4904*/4905function MapBookKeeping(mapResult, mapFunction, mapContext) {4906this.mapResult = mapResult;4907this.mapFunction = mapFunction;4908this.mapContext = mapContext;4909}4910PooledClass.addPoolingTo(MapBookKeeping, threeArgumentPooler);49114912function mapSingleChildIntoContext(traverseContext, child, name, i) {4913var mapBookKeeping = traverseContext;4914var mapResult = mapBookKeeping.mapResult;49154916var keyUnique = !mapResult.hasOwnProperty(name);4917if ("production" !== "development") {4918("production" !== "development" ? warning(4919keyUnique,4920'ReactChildren.map(...): Encountered two children with the same key, ' +4921'`%s`. Child keys must be unique; when two children share a key, only ' +4922'the first child will be used.',4923name4924) : null);4925}49264927if (keyUnique) {4928var mappedChild =4929mapBookKeeping.mapFunction.call(mapBookKeeping.mapContext, child, i);4930mapResult[name] = mappedChild;4931}4932}49334934/**4935* Maps children that are typically specified as `props.children`.4936*4937* The provided mapFunction(child, key, index) will be called for each4938* leaf child.4939*4940* TODO: This may likely break any calls to `ReactChildren.map` that were4941* previously relying on the fact that we guarded against null children.4942*4943* @param {?*} children Children tree container.4944* @param {function(*, int)} mapFunction.4945* @param {*} mapContext Context for mapFunction.4946* @return {object} Object containing the ordered map of results.4947*/4948function mapChildren(children, func, context) {4949if (children == null) {4950return children;4951}49524953var mapResult = {};4954var traverseContext = MapBookKeeping.getPooled(mapResult, func, context);4955traverseAllChildren(children, mapSingleChildIntoContext, traverseContext);4956MapBookKeeping.release(traverseContext);4957return ReactFragment.create(mapResult);4958}49594960function forEachSingleChildDummy(traverseContext, child, name, i) {4961return null;4962}49634964/**4965* Count the number of children that are typically specified as4966* `props.children`.4967*4968* @param {?*} children Children tree container.4969* @return {number} The number of children.4970*/4971function countChildren(children, context) {4972return traverseAllChildren(children, forEachSingleChildDummy, null);4973}49744975var ReactChildren = {4976forEach: forEachChildren,4977map: mapChildren,4978count: countChildren4979};49804981module.exports = ReactChildren;49824983},{"153":153,"154":154,"28":28,"63":63}],33:[function(_dereq_,module,exports){4984/**4985* Copyright 2013-2015, Facebook, Inc.4986* All rights reserved.4987*4988* This source code is licensed under the BSD-style license found in the4989* LICENSE file in the root directory of this source tree. An additional grant4990* of patent rights can be found in the PATENTS file in the same directory.4991*4992* @providesModule ReactClass4993*/49944995'use strict';49964997var ReactComponent = _dereq_(34);4998var ReactCurrentOwner = _dereq_(39);4999var ReactElement = _dereq_(57);5000var ReactErrorUtils = _dereq_(60);5001var ReactInstanceMap = _dereq_(67);5002var ReactLifeCycle = _dereq_(68);5003var ReactPropTypeLocations = _dereq_(77);5004var ReactPropTypeLocationNames = _dereq_(76);5005var ReactUpdateQueue = _dereq_(86);50065007var assign = _dereq_(27);5008var invariant = _dereq_(135);5009var keyMirror = _dereq_(140);5010var keyOf = _dereq_(141);5011var warning = _dereq_(154);50125013var MIXINS_KEY = keyOf({mixins: null});50145015/**5016* Policies that describe methods in `ReactClassInterface`.5017*/5018var SpecPolicy = keyMirror({5019/**5020* These methods may be defined only once by the class specification or mixin.5021*/5022DEFINE_ONCE: null,5023/**5024* These methods may be defined by both the class specification and mixins.5025* Subsequent definitions will be chained. These methods must return void.5026*/5027DEFINE_MANY: null,5028/**5029* These methods are overriding the base class.5030*/5031OVERRIDE_BASE: null,5032/**5033* These methods are similar to DEFINE_MANY, except we assume they return5034* objects. We try to merge the keys of the return values of all the mixed in5035* functions. If there is a key conflict we throw.5036*/5037DEFINE_MANY_MERGED: null5038});503950405041var injectedMixins = [];50425043/**5044* Composite components are higher-level components that compose other composite5045* or native components.5046*5047* To create a new type of `ReactClass`, pass a specification of5048* your new class to `React.createClass`. The only requirement of your class5049* specification is that you implement a `render` method.5050*5051* var MyComponent = React.createClass({5052* render: function() {5053* return <div>Hello World</div>;5054* }5055* });5056*5057* The class specification supports a specific protocol of methods that have5058* special meaning (e.g. `render`). See `ReactClassInterface` for5059* more the comprehensive protocol. Any other properties and methods in the5060* class specification will available on the prototype.5061*5062* @interface ReactClassInterface5063* @internal5064*/5065var ReactClassInterface = {50665067/**5068* An array of Mixin objects to include when defining your component.5069*5070* @type {array}5071* @optional5072*/5073mixins: SpecPolicy.DEFINE_MANY,50745075/**5076* An object containing properties and methods that should be defined on5077* the component's constructor instead of its prototype (static methods).5078*5079* @type {object}5080* @optional5081*/5082statics: SpecPolicy.DEFINE_MANY,50835084/**5085* Definition of prop types for this component.5086*5087* @type {object}5088* @optional5089*/5090propTypes: SpecPolicy.DEFINE_MANY,50915092/**5093* Definition of context types for this component.5094*5095* @type {object}5096* @optional5097*/5098contextTypes: SpecPolicy.DEFINE_MANY,50995100/**5101* Definition of context types this component sets for its children.5102*5103* @type {object}5104* @optional5105*/5106childContextTypes: SpecPolicy.DEFINE_MANY,51075108// ==== Definition methods ====51095110/**5111* Invoked when the component is mounted. Values in the mapping will be set on5112* `this.props` if that prop is not specified (i.e. using an `in` check).5113*5114* This method is invoked before `getInitialState` and therefore cannot rely5115* on `this.state` or use `this.setState`.5116*5117* @return {object}5118* @optional5119*/5120getDefaultProps: SpecPolicy.DEFINE_MANY_MERGED,51215122/**5123* Invoked once before the component is mounted. The return value will be used5124* as the initial value of `this.state`.5125*5126* getInitialState: function() {5127* return {5128* isOn: false,5129* fooBaz: new BazFoo()5130* }5131* }5132*5133* @return {object}5134* @optional5135*/5136getInitialState: SpecPolicy.DEFINE_MANY_MERGED,51375138/**5139* @return {object}5140* @optional5141*/5142getChildContext: SpecPolicy.DEFINE_MANY_MERGED,51435144/**5145* Uses props from `this.props` and state from `this.state` to render the5146* structure of the component.5147*5148* No guarantees are made about when or how often this method is invoked, so5149* it must not have side effects.5150*5151* render: function() {5152* var name = this.props.name;5153* return <div>Hello, {name}!</div>;5154* }5155*5156* @return {ReactComponent}5157* @nosideeffects5158* @required5159*/5160render: SpecPolicy.DEFINE_ONCE,5161516251635164// ==== Delegate methods ====51655166/**5167* Invoked when the component is initially created and about to be mounted.5168* This may have side effects, but any external subscriptions or data created5169* by this method must be cleaned up in `componentWillUnmount`.5170*5171* @optional5172*/5173componentWillMount: SpecPolicy.DEFINE_MANY,51745175/**5176* Invoked when the component has been mounted and has a DOM representation.5177* However, there is no guarantee that the DOM node is in the document.5178*5179* Use this as an opportunity to operate on the DOM when the component has5180* been mounted (initialized and rendered) for the first time.5181*5182* @param {DOMElement} rootNode DOM element representing the component.5183* @optional5184*/5185componentDidMount: SpecPolicy.DEFINE_MANY,51865187/**5188* Invoked before the component receives new props.5189*5190* Use this as an opportunity to react to a prop transition by updating the5191* state using `this.setState`. Current props are accessed via `this.props`.5192*5193* componentWillReceiveProps: function(nextProps, nextContext) {5194* this.setState({5195* likesIncreasing: nextProps.likeCount > this.props.likeCount5196* });5197* }5198*5199* NOTE: There is no equivalent `componentWillReceiveState`. An incoming prop5200* transition may cause a state change, but the opposite is not true. If you5201* need it, you are probably looking for `componentWillUpdate`.5202*5203* @param {object} nextProps5204* @optional5205*/5206componentWillReceiveProps: SpecPolicy.DEFINE_MANY,52075208/**5209* Invoked while deciding if the component should be updated as a result of5210* receiving new props, state and/or context.5211*5212* Use this as an opportunity to `return false` when you're certain that the5213* transition to the new props/state/context will not require a component5214* update.5215*5216* shouldComponentUpdate: function(nextProps, nextState, nextContext) {5217* return !equal(nextProps, this.props) ||5218* !equal(nextState, this.state) ||5219* !equal(nextContext, this.context);5220* }5221*5222* @param {object} nextProps5223* @param {?object} nextState5224* @param {?object} nextContext5225* @return {boolean} True if the component should update.5226* @optional5227*/5228shouldComponentUpdate: SpecPolicy.DEFINE_ONCE,52295230/**5231* Invoked when the component is about to update due to a transition from5232* `this.props`, `this.state` and `this.context` to `nextProps`, `nextState`5233* and `nextContext`.5234*5235* Use this as an opportunity to perform preparation before an update occurs.5236*5237* NOTE: You **cannot** use `this.setState()` in this method.5238*5239* @param {object} nextProps5240* @param {?object} nextState5241* @param {?object} nextContext5242* @param {ReactReconcileTransaction} transaction5243* @optional5244*/5245componentWillUpdate: SpecPolicy.DEFINE_MANY,52465247/**5248* Invoked when the component's DOM representation has been updated.5249*5250* Use this as an opportunity to operate on the DOM when the component has5251* been updated.5252*5253* @param {object} prevProps5254* @param {?object} prevState5255* @param {?object} prevContext5256* @param {DOMElement} rootNode DOM element representing the component.5257* @optional5258*/5259componentDidUpdate: SpecPolicy.DEFINE_MANY,52605261/**5262* Invoked when the component is about to be removed from its parent and have5263* its DOM representation destroyed.5264*5265* Use this as an opportunity to deallocate any external resources.5266*5267* NOTE: There is no `componentDidUnmount` since your component will have been5268* destroyed by that point.5269*5270* @optional5271*/5272componentWillUnmount: SpecPolicy.DEFINE_MANY,5273527452755276// ==== Advanced methods ====52775278/**5279* Updates the component's currently mounted DOM representation.5280*5281* By default, this implements React's rendering and reconciliation algorithm.5282* Sophisticated clients may wish to override this.5283*5284* @param {ReactReconcileTransaction} transaction5285* @internal5286* @overridable5287*/5288updateComponent: SpecPolicy.OVERRIDE_BASE52895290};52915292/**5293* Mapping from class specification keys to special processing functions.5294*5295* Although these are declared like instance properties in the specification5296* when defining classes using `React.createClass`, they are actually static5297* and are accessible on the constructor instead of the prototype. Despite5298* being static, they must be defined outside of the "statics" key under5299* which all other static methods are defined.5300*/5301var RESERVED_SPEC_KEYS = {5302displayName: function(Constructor, displayName) {5303Constructor.displayName = displayName;5304},5305mixins: function(Constructor, mixins) {5306if (mixins) {5307for (var i = 0; i < mixins.length; i++) {5308mixSpecIntoComponent(Constructor, mixins[i]);5309}5310}5311},5312childContextTypes: function(Constructor, childContextTypes) {5313if ("production" !== "development") {5314validateTypeDef(5315Constructor,5316childContextTypes,5317ReactPropTypeLocations.childContext5318);5319}5320Constructor.childContextTypes = assign(5321{},5322Constructor.childContextTypes,5323childContextTypes5324);5325},5326contextTypes: function(Constructor, contextTypes) {5327if ("production" !== "development") {5328validateTypeDef(5329Constructor,5330contextTypes,5331ReactPropTypeLocations.context5332);5333}5334Constructor.contextTypes = assign(5335{},5336Constructor.contextTypes,5337contextTypes5338);5339},5340/**5341* Special case getDefaultProps which should move into statics but requires5342* automatic merging.5343*/5344getDefaultProps: function(Constructor, getDefaultProps) {5345if (Constructor.getDefaultProps) {5346Constructor.getDefaultProps = createMergedResultFunction(5347Constructor.getDefaultProps,5348getDefaultProps5349);5350} else {5351Constructor.getDefaultProps = getDefaultProps;5352}5353},5354propTypes: function(Constructor, propTypes) {5355if ("production" !== "development") {5356validateTypeDef(5357Constructor,5358propTypes,5359ReactPropTypeLocations.prop5360);5361}5362Constructor.propTypes = assign(5363{},5364Constructor.propTypes,5365propTypes5366);5367},5368statics: function(Constructor, statics) {5369mixStaticSpecIntoComponent(Constructor, statics);5370}5371};53725373function validateTypeDef(Constructor, typeDef, location) {5374for (var propName in typeDef) {5375if (typeDef.hasOwnProperty(propName)) {5376// use a warning instead of an invariant so components5377// don't show up in prod but not in __DEV__5378("production" !== "development" ? warning(5379typeof typeDef[propName] === 'function',5380'%s: %s type `%s` is invalid; it must be a function, usually from ' +5381'React.PropTypes.',5382Constructor.displayName || 'ReactClass',5383ReactPropTypeLocationNames[location],5384propName5385) : null);5386}5387}5388}53895390function validateMethodOverride(proto, name) {5391var specPolicy = ReactClassInterface.hasOwnProperty(name) ?5392ReactClassInterface[name] :5393null;53945395// Disallow overriding of base class methods unless explicitly allowed.5396if (ReactClassMixin.hasOwnProperty(name)) {5397("production" !== "development" ? invariant(5398specPolicy === SpecPolicy.OVERRIDE_BASE,5399'ReactClassInterface: You are attempting to override ' +5400'`%s` from your class specification. Ensure that your method names ' +5401'do not overlap with React methods.',5402name5403) : invariant(specPolicy === SpecPolicy.OVERRIDE_BASE));5404}54055406// Disallow defining methods more than once unless explicitly allowed.5407if (proto.hasOwnProperty(name)) {5408("production" !== "development" ? invariant(5409specPolicy === SpecPolicy.DEFINE_MANY ||5410specPolicy === SpecPolicy.DEFINE_MANY_MERGED,5411'ReactClassInterface: You are attempting to define ' +5412'`%s` on your component more than once. This conflict may be due ' +5413'to a mixin.',5414name5415) : invariant(specPolicy === SpecPolicy.DEFINE_MANY ||5416specPolicy === SpecPolicy.DEFINE_MANY_MERGED));5417}5418}54195420/**5421* Mixin helper which handles policy validation and reserved5422* specification keys when building React classses.5423*/5424function mixSpecIntoComponent(Constructor, spec) {5425if (!spec) {5426return;5427}54285429("production" !== "development" ? invariant(5430typeof spec !== 'function',5431'ReactClass: You\'re attempting to ' +5432'use a component class as a mixin. Instead, just use a regular object.'5433) : invariant(typeof spec !== 'function'));5434("production" !== "development" ? invariant(5435!ReactElement.isValidElement(spec),5436'ReactClass: You\'re attempting to ' +5437'use a component as a mixin. Instead, just use a regular object.'5438) : invariant(!ReactElement.isValidElement(spec)));54395440var proto = Constructor.prototype;54415442// By handling mixins before any other properties, we ensure the same5443// chaining order is applied to methods with DEFINE_MANY policy, whether5444// mixins are listed before or after these methods in the spec.5445if (spec.hasOwnProperty(MIXINS_KEY)) {5446RESERVED_SPEC_KEYS.mixins(Constructor, spec.mixins);5447}54485449for (var name in spec) {5450if (!spec.hasOwnProperty(name)) {5451continue;5452}54535454if (name === MIXINS_KEY) {5455// We have already handled mixins in a special case above5456continue;5457}54585459var property = spec[name];5460validateMethodOverride(proto, name);54615462if (RESERVED_SPEC_KEYS.hasOwnProperty(name)) {5463RESERVED_SPEC_KEYS[name](Constructor, property);5464} else {5465// Setup methods on prototype:5466// The following member methods should not be automatically bound:5467// 1. Expected ReactClass methods (in the "interface").5468// 2. Overridden methods (that were mixed in).5469var isReactClassMethod =5470ReactClassInterface.hasOwnProperty(name);5471var isAlreadyDefined = proto.hasOwnProperty(name);5472var markedDontBind = property && property.__reactDontBind;5473var isFunction = typeof property === 'function';5474var shouldAutoBind =5475isFunction &&5476!isReactClassMethod &&5477!isAlreadyDefined &&5478!markedDontBind;54795480if (shouldAutoBind) {5481if (!proto.__reactAutoBindMap) {5482proto.__reactAutoBindMap = {};5483}5484proto.__reactAutoBindMap[name] = property;5485proto[name] = property;5486} else {5487if (isAlreadyDefined) {5488var specPolicy = ReactClassInterface[name];54895490// These cases should already be caught by validateMethodOverride5491("production" !== "development" ? invariant(5492isReactClassMethod && (5493(specPolicy === SpecPolicy.DEFINE_MANY_MERGED || specPolicy === SpecPolicy.DEFINE_MANY)5494),5495'ReactClass: Unexpected spec policy %s for key %s ' +5496'when mixing in component specs.',5497specPolicy,5498name5499) : invariant(isReactClassMethod && (5500(specPolicy === SpecPolicy.DEFINE_MANY_MERGED || specPolicy === SpecPolicy.DEFINE_MANY)5501)));55025503// For methods which are defined more than once, call the existing5504// methods before calling the new property, merging if appropriate.5505if (specPolicy === SpecPolicy.DEFINE_MANY_MERGED) {5506proto[name] = createMergedResultFunction(proto[name], property);5507} else if (specPolicy === SpecPolicy.DEFINE_MANY) {5508proto[name] = createChainedFunction(proto[name], property);5509}5510} else {5511proto[name] = property;5512if ("production" !== "development") {5513// Add verbose displayName to the function, which helps when looking5514// at profiling tools.5515if (typeof property === 'function' && spec.displayName) {5516proto[name].displayName = spec.displayName + '_' + name;5517}5518}5519}5520}5521}5522}5523}55245525function mixStaticSpecIntoComponent(Constructor, statics) {5526if (!statics) {5527return;5528}5529for (var name in statics) {5530var property = statics[name];5531if (!statics.hasOwnProperty(name)) {5532continue;5533}55345535var isReserved = name in RESERVED_SPEC_KEYS;5536("production" !== "development" ? invariant(5537!isReserved,5538'ReactClass: You are attempting to define a reserved ' +5539'property, `%s`, that shouldn\'t be on the "statics" key. Define it ' +5540'as an instance property instead; it will still be accessible on the ' +5541'constructor.',5542name5543) : invariant(!isReserved));55445545var isInherited = name in Constructor;5546("production" !== "development" ? invariant(5547!isInherited,5548'ReactClass: You are attempting to define ' +5549'`%s` on your component more than once. This conflict may be ' +5550'due to a mixin.',5551name5552) : invariant(!isInherited));5553Constructor[name] = property;5554}5555}55565557/**5558* Merge two objects, but throw if both contain the same key.5559*5560* @param {object} one The first object, which is mutated.5561* @param {object} two The second object5562* @return {object} one after it has been mutated to contain everything in two.5563*/5564function mergeIntoWithNoDuplicateKeys(one, two) {5565("production" !== "development" ? invariant(5566one && two && typeof one === 'object' && typeof two === 'object',5567'mergeIntoWithNoDuplicateKeys(): Cannot merge non-objects.'5568) : invariant(one && two && typeof one === 'object' && typeof two === 'object'));55695570for (var key in two) {5571if (two.hasOwnProperty(key)) {5572("production" !== "development" ? invariant(5573one[key] === undefined,5574'mergeIntoWithNoDuplicateKeys(): ' +5575'Tried to merge two objects with the same key: `%s`. This conflict ' +5576'may be due to a mixin; in particular, this may be caused by two ' +5577'getInitialState() or getDefaultProps() methods returning objects ' +5578'with clashing keys.',5579key5580) : invariant(one[key] === undefined));5581one[key] = two[key];5582}5583}5584return one;5585}55865587/**5588* Creates a function that invokes two functions and merges their return values.5589*5590* @param {function} one Function to invoke first.5591* @param {function} two Function to invoke second.5592* @return {function} Function that invokes the two argument functions.5593* @private5594*/5595function createMergedResultFunction(one, two) {5596return function mergedResult() {5597var a = one.apply(this, arguments);5598var b = two.apply(this, arguments);5599if (a == null) {5600return b;5601} else if (b == null) {5602return a;5603}5604var c = {};5605mergeIntoWithNoDuplicateKeys(c, a);5606mergeIntoWithNoDuplicateKeys(c, b);5607return c;5608};5609}56105611/**5612* Creates a function that invokes two functions and ignores their return vales.5613*5614* @param {function} one Function to invoke first.5615* @param {function} two Function to invoke second.5616* @return {function} Function that invokes the two argument functions.5617* @private5618*/5619function createChainedFunction(one, two) {5620return function chainedFunction() {5621one.apply(this, arguments);5622two.apply(this, arguments);5623};5624}56255626/**5627* Binds a method to the component.5628*5629* @param {object} component Component whose method is going to be bound.5630* @param {function} method Method to be bound.5631* @return {function} The bound method.5632*/5633function bindAutoBindMethod(component, method) {5634var boundMethod = method.bind(component);5635if ("production" !== "development") {5636boundMethod.__reactBoundContext = component;5637boundMethod.__reactBoundMethod = method;5638boundMethod.__reactBoundArguments = null;5639var componentName = component.constructor.displayName;5640var _bind = boundMethod.bind;5641/* eslint-disable block-scoped-var, no-undef */5642boundMethod.bind = function(newThis ) {for (var args=[],$__0=1,$__1=arguments.length;$__0<$__1;$__0++) args.push(arguments[$__0]);5643// User is trying to bind() an autobound method; we effectively will5644// ignore the value of "this" that the user is trying to use, so5645// let's warn.5646if (newThis !== component && newThis !== null) {5647("production" !== "development" ? warning(5648false,5649'bind(): React component methods may only be bound to the ' +5650'component instance. See %s',5651componentName5652) : null);5653} else if (!args.length) {5654("production" !== "development" ? warning(5655false,5656'bind(): You are binding a component method to the component. ' +5657'React does this for you automatically in a high-performance ' +5658'way, so you can safely remove this call. See %s',5659componentName5660) : null);5661return boundMethod;5662}5663var reboundMethod = _bind.apply(boundMethod, arguments);5664reboundMethod.__reactBoundContext = component;5665reboundMethod.__reactBoundMethod = method;5666reboundMethod.__reactBoundArguments = args;5667return reboundMethod;5668/* eslint-enable */5669};5670}5671return boundMethod;5672}56735674/**5675* Binds all auto-bound methods in a component.5676*5677* @param {object} component Component whose method is going to be bound.5678*/5679function bindAutoBindMethods(component) {5680for (var autoBindKey in component.__reactAutoBindMap) {5681if (component.__reactAutoBindMap.hasOwnProperty(autoBindKey)) {5682var method = component.__reactAutoBindMap[autoBindKey];5683component[autoBindKey] = bindAutoBindMethod(5684component,5685ReactErrorUtils.guard(5686method,5687component.constructor.displayName + '.' + autoBindKey5688)5689);5690}5691}5692}56935694var typeDeprecationDescriptor = {5695enumerable: false,5696get: function() {5697var displayName = this.displayName || this.name || 'Component';5698("production" !== "development" ? warning(5699false,5700'%s.type is deprecated. Use %s directly to access the class.',5701displayName,5702displayName5703) : null);5704Object.defineProperty(this, 'type', {5705value: this5706});5707return this;5708}5709};57105711/**5712* Add more to the ReactClass base class. These are all legacy features and5713* therefore not already part of the modern ReactComponent.5714*/5715var ReactClassMixin = {57165717/**5718* TODO: This will be deprecated because state should always keep a consistent5719* type signature and the only use case for this, is to avoid that.5720*/5721replaceState: function(newState, callback) {5722ReactUpdateQueue.enqueueReplaceState(this, newState);5723if (callback) {5724ReactUpdateQueue.enqueueCallback(this, callback);5725}5726},57275728/**5729* Checks whether or not this composite component is mounted.5730* @return {boolean} True if mounted, false otherwise.5731* @protected5732* @final5733*/5734isMounted: function() {5735if ("production" !== "development") {5736var owner = ReactCurrentOwner.current;5737if (owner !== null) {5738("production" !== "development" ? warning(5739owner._warnedAboutRefsInRender,5740'%s is accessing isMounted inside its render() function. ' +5741'render() should be a pure function of props and state. It should ' +5742'never access something that requires stale data from the previous ' +5743'render, such as refs. Move this logic to componentDidMount and ' +5744'componentDidUpdate instead.',5745owner.getName() || 'A component'5746) : null);5747owner._warnedAboutRefsInRender = true;5748}5749}5750var internalInstance = ReactInstanceMap.get(this);5751return (5752internalInstance &&5753internalInstance !== ReactLifeCycle.currentlyMountingInstance5754);5755},57565757/**5758* Sets a subset of the props.5759*5760* @param {object} partialProps Subset of the next props.5761* @param {?function} callback Called after props are updated.5762* @final5763* @public5764* @deprecated5765*/5766setProps: function(partialProps, callback) {5767ReactUpdateQueue.enqueueSetProps(this, partialProps);5768if (callback) {5769ReactUpdateQueue.enqueueCallback(this, callback);5770}5771},57725773/**5774* Replace all the props.5775*5776* @param {object} newProps Subset of the next props.5777* @param {?function} callback Called after props are updated.5778* @final5779* @public5780* @deprecated5781*/5782replaceProps: function(newProps, callback) {5783ReactUpdateQueue.enqueueReplaceProps(this, newProps);5784if (callback) {5785ReactUpdateQueue.enqueueCallback(this, callback);5786}5787}5788};57895790var ReactClassComponent = function() {};5791assign(5792ReactClassComponent.prototype,5793ReactComponent.prototype,5794ReactClassMixin5795);57965797/**5798* Module for creating composite components.5799*5800* @class ReactClass5801*/5802var ReactClass = {58035804/**5805* Creates a composite component class given a class specification.5806*5807* @param {object} spec Class specification (which must define `render`).5808* @return {function} Component constructor function.5809* @public5810*/5811createClass: function(spec) {5812var Constructor = function(props, context) {5813// This constructor is overridden by mocks. The argument is used5814// by mocks to assert on what gets mounted.58155816if ("production" !== "development") {5817("production" !== "development" ? warning(5818this instanceof Constructor,5819'Something is calling a React component directly. Use a factory or ' +5820'JSX instead. See: https://fb.me/react-legacyfactory'5821) : null);5822}58235824// Wire up auto-binding5825if (this.__reactAutoBindMap) {5826bindAutoBindMethods(this);5827}58285829this.props = props;5830this.context = context;5831this.state = null;58325833// ReactClasses doesn't have constructors. Instead, they use the5834// getInitialState and componentWillMount methods for initialization.58355836var initialState = this.getInitialState ? this.getInitialState() : null;5837if ("production" !== "development") {5838// We allow auto-mocks to proceed as if they're returning null.5839if (typeof initialState === 'undefined' &&5840this.getInitialState._isMockFunction) {5841// This is probably bad practice. Consider warning here and5842// deprecating this convenience.5843initialState = null;5844}5845}5846("production" !== "development" ? invariant(5847typeof initialState === 'object' && !Array.isArray(initialState),5848'%s.getInitialState(): must return an object or null',5849Constructor.displayName || 'ReactCompositeComponent'5850) : invariant(typeof initialState === 'object' && !Array.isArray(initialState)));58515852this.state = initialState;5853};5854Constructor.prototype = new ReactClassComponent();5855Constructor.prototype.constructor = Constructor;58565857injectedMixins.forEach(5858mixSpecIntoComponent.bind(null, Constructor)5859);58605861mixSpecIntoComponent(Constructor, spec);58625863// Initialize the defaultProps property after all mixins have been merged5864if (Constructor.getDefaultProps) {5865Constructor.defaultProps = Constructor.getDefaultProps();5866}58675868if ("production" !== "development") {5869// This is a tag to indicate that the use of these method names is ok,5870// since it's used with createClass. If it's not, then it's likely a5871// mistake so we'll warn you to use the static property, property5872// initializer or constructor respectively.5873if (Constructor.getDefaultProps) {5874Constructor.getDefaultProps.isReactClassApproved = {};5875}5876if (Constructor.prototype.getInitialState) {5877Constructor.prototype.getInitialState.isReactClassApproved = {};5878}5879}58805881("production" !== "development" ? invariant(5882Constructor.prototype.render,5883'createClass(...): Class specification must implement a `render` method.'5884) : invariant(Constructor.prototype.render));58855886if ("production" !== "development") {5887("production" !== "development" ? warning(5888!Constructor.prototype.componentShouldUpdate,5889'%s has a method called ' +5890'componentShouldUpdate(). Did you mean shouldComponentUpdate()? ' +5891'The name is phrased as a question because the function is ' +5892'expected to return a value.',5893spec.displayName || 'A component'5894) : null);5895}58965897// Reduce time spent doing lookups by setting these on the prototype.5898for (var methodName in ReactClassInterface) {5899if (!Constructor.prototype[methodName]) {5900Constructor.prototype[methodName] = null;5901}5902}59035904// Legacy hook5905Constructor.type = Constructor;5906if ("production" !== "development") {5907try {5908Object.defineProperty(Constructor, 'type', typeDeprecationDescriptor);5909} catch (x) {5910// IE will fail on defineProperty (es5-shim/sham too)5911}5912}59135914return Constructor;5915},59165917injection: {5918injectMixin: function(mixin) {5919injectedMixins.push(mixin);5920}5921}59225923};59245925module.exports = ReactClass;59265927},{"135":135,"140":140,"141":141,"154":154,"27":27,"34":34,"39":39,"57":57,"60":60,"67":67,"68":68,"76":76,"77":77,"86":86}],34:[function(_dereq_,module,exports){5928/**5929* Copyright 2013-2015, Facebook, Inc.5930* All rights reserved.5931*5932* This source code is licensed under the BSD-style license found in the5933* LICENSE file in the root directory of this source tree. An additional grant5934* of patent rights can be found in the PATENTS file in the same directory.5935*5936* @providesModule ReactComponent5937*/59385939'use strict';59405941var ReactUpdateQueue = _dereq_(86);59425943var invariant = _dereq_(135);5944var warning = _dereq_(154);59455946/**5947* Base class helpers for the updating state of a component.5948*/5949function ReactComponent(props, context) {5950this.props = props;5951this.context = context;5952}59535954/**5955* Sets a subset of the state. Always use this to mutate5956* state. You should treat `this.state` as immutable.5957*5958* There is no guarantee that `this.state` will be immediately updated, so5959* accessing `this.state` after calling this method may return the old value.5960*5961* There is no guarantee that calls to `setState` will run synchronously,5962* as they may eventually be batched together. You can provide an optional5963* callback that will be executed when the call to setState is actually5964* completed.5965*5966* When a function is provided to setState, it will be called at some point in5967* the future (not synchronously). It will be called with the up to date5968* component arguments (state, props, context). These values can be different5969* from this.* because your function may be called after receiveProps but before5970* shouldComponentUpdate, and this new state, props, and context will not yet be5971* assigned to this.5972*5973* @param {object|function} partialState Next partial state or function to5974* produce next partial state to be merged with current state.5975* @param {?function} callback Called after state is updated.5976* @final5977* @protected5978*/5979ReactComponent.prototype.setState = function(partialState, callback) {5980("production" !== "development" ? invariant(5981typeof partialState === 'object' ||5982typeof partialState === 'function' ||5983partialState == null,5984'setState(...): takes an object of state variables to update or a ' +5985'function which returns an object of state variables.'5986) : invariant(typeof partialState === 'object' ||5987typeof partialState === 'function' ||5988partialState == null));5989if ("production" !== "development") {5990("production" !== "development" ? warning(5991partialState != null,5992'setState(...): You passed an undefined or null state object; ' +5993'instead, use forceUpdate().'5994) : null);5995}5996ReactUpdateQueue.enqueueSetState(this, partialState);5997if (callback) {5998ReactUpdateQueue.enqueueCallback(this, callback);5999}6000};60016002/**6003* Forces an update. This should only be invoked when it is known with6004* certainty that we are **not** in a DOM transaction.6005*6006* You may want to call this when you know that some deeper aspect of the6007* component's state has changed but `setState` was not called.6008*6009* This will not invoke `shouldComponentUpdate`, but it will invoke6010* `componentWillUpdate` and `componentDidUpdate`.6011*6012* @param {?function} callback Called after update is complete.6013* @final6014* @protected6015*/6016ReactComponent.prototype.forceUpdate = function(callback) {6017ReactUpdateQueue.enqueueForceUpdate(this);6018if (callback) {6019ReactUpdateQueue.enqueueCallback(this, callback);6020}6021};60226023/**6024* Deprecated APIs. These APIs used to exist on classic React classes but since6025* we would like to deprecate them, we're not going to move them over to this6026* modern base class. Instead, we define a getter that warns if it's accessed.6027*/6028if ("production" !== "development") {6029var deprecatedAPIs = {6030getDOMNode: [6031'getDOMNode',6032'Use React.findDOMNode(component) instead.'6033],6034isMounted: [6035'isMounted',6036'Instead, make sure to clean up subscriptions and pending requests in ' +6037'componentWillUnmount to prevent memory leaks.'6038],6039replaceProps: [6040'replaceProps',6041'Instead call React.render again at the top level.'6042],6043replaceState: [6044'replaceState',6045'Refactor your code to use setState instead (see ' +6046'https://github.com/facebook/react/issues/3236).'6047],6048setProps: [6049'setProps',6050'Instead call React.render again at the top level.'6051]6052};6053var defineDeprecationWarning = function(methodName, info) {6054try {6055Object.defineProperty(ReactComponent.prototype, methodName, {6056get: function() {6057("production" !== "development" ? warning(6058false,6059'%s(...) is deprecated in plain JavaScript React classes. %s',6060info[0],6061info[1]6062) : null);6063return undefined;6064}6065});6066} catch (x) {6067// IE will fail on defineProperty (es5-shim/sham too)6068}6069};6070for (var fnName in deprecatedAPIs) {6071if (deprecatedAPIs.hasOwnProperty(fnName)) {6072defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);6073}6074}6075}60766077module.exports = ReactComponent;60786079},{"135":135,"154":154,"86":86}],35:[function(_dereq_,module,exports){6080/**6081* Copyright 2013-2015, Facebook, Inc.6082* All rights reserved.6083*6084* This source code is licensed under the BSD-style license found in the6085* LICENSE file in the root directory of this source tree. An additional grant6086* of patent rights can be found in the PATENTS file in the same directory.6087*6088* @providesModule ReactComponentBrowserEnvironment6089*/60906091/*jslint evil: true */60926093'use strict';60946095var ReactDOMIDOperations = _dereq_(44);6096var ReactMount = _dereq_(70);60976098/**6099* Abstracts away all functionality of the reconciler that requires knowledge of6100* the browser context. TODO: These callers should be refactored to avoid the6101* need for this injection.6102*/6103var ReactComponentBrowserEnvironment = {61046105processChildrenUpdates:6106ReactDOMIDOperations.dangerouslyProcessChildrenUpdates,61076108replaceNodeWithMarkupByID:6109ReactDOMIDOperations.dangerouslyReplaceNodeWithMarkupByID,61106111/**6112* If a particular environment requires that some resources be cleaned up,6113* specify this in the injected Mixin. In the DOM, we would likely want to6114* purge any cached node ID lookups.6115*6116* @private6117*/6118unmountIDFromEnvironment: function(rootNodeID) {6119ReactMount.purgeID(rootNodeID);6120}61216122};61236124module.exports = ReactComponentBrowserEnvironment;61256126},{"44":44,"70":70}],36:[function(_dereq_,module,exports){6127/**6128* Copyright 2014-2015, Facebook, Inc.6129* All rights reserved.6130*6131* This source code is licensed under the BSD-style license found in the6132* LICENSE file in the root directory of this source tree. An additional grant6133* of patent rights can be found in the PATENTS file in the same directory.6134*6135* @providesModule ReactComponentEnvironment6136*/61376138'use strict';61396140var invariant = _dereq_(135);61416142var injected = false;61436144var ReactComponentEnvironment = {61456146/**6147* Optionally injectable environment dependent cleanup hook. (server vs.6148* browser etc). Example: A browser system caches DOM nodes based on component6149* ID and must remove that cache entry when this instance is unmounted.6150*/6151unmountIDFromEnvironment: null,61526153/**6154* Optionally injectable hook for swapping out mount images in the middle of6155* the tree.6156*/6157replaceNodeWithMarkupByID: null,61586159/**6160* Optionally injectable hook for processing a queue of child updates. Will6161* later move into MultiChildComponents.6162*/6163processChildrenUpdates: null,61646165injection: {6166injectEnvironment: function(environment) {6167("production" !== "development" ? invariant(6168!injected,6169'ReactCompositeComponent: injectEnvironment() can only be called once.'6170) : invariant(!injected));6171ReactComponentEnvironment.unmountIDFromEnvironment =6172environment.unmountIDFromEnvironment;6173ReactComponentEnvironment.replaceNodeWithMarkupByID =6174environment.replaceNodeWithMarkupByID;6175ReactComponentEnvironment.processChildrenUpdates =6176environment.processChildrenUpdates;6177injected = true;6178}6179}61806181};61826183module.exports = ReactComponentEnvironment;61846185},{"135":135}],37:[function(_dereq_,module,exports){6186/**6187* Copyright 2013-2015, Facebook, Inc.6188* All rights reserved.6189*6190* This source code is licensed under the BSD-style license found in the6191* LICENSE file in the root directory of this source tree. An additional grant6192* of patent rights can be found in the PATENTS file in the same directory.6193*6194* @providesModule ReactCompositeComponent6195*/61966197'use strict';61986199var ReactComponentEnvironment = _dereq_(36);6200var ReactContext = _dereq_(38);6201var ReactCurrentOwner = _dereq_(39);6202var ReactElement = _dereq_(57);6203var ReactElementValidator = _dereq_(58);6204var ReactInstanceMap = _dereq_(67);6205var ReactLifeCycle = _dereq_(68);6206var ReactNativeComponent = _dereq_(73);6207var ReactPerf = _dereq_(75);6208var ReactPropTypeLocations = _dereq_(77);6209var ReactPropTypeLocationNames = _dereq_(76);6210var ReactReconciler = _dereq_(81);6211var ReactUpdates = _dereq_(87);62126213var assign = _dereq_(27);6214var emptyObject = _dereq_(115);6215var invariant = _dereq_(135);6216var shouldUpdateReactComponent = _dereq_(151);6217var warning = _dereq_(154);62186219function getDeclarationErrorAddendum(component) {6220var owner = component._currentElement._owner || null;6221if (owner) {6222var name = owner.getName();6223if (name) {6224return ' Check the render method of `' + name + '`.';6225}6226}6227return '';6228}62296230/**6231* ------------------ The Life-Cycle of a Composite Component ------------------6232*6233* - constructor: Initialization of state. The instance is now retained.6234* - componentWillMount6235* - render6236* - [children's constructors]6237* - [children's componentWillMount and render]6238* - [children's componentDidMount]6239* - componentDidMount6240*6241* Update Phases:6242* - componentWillReceiveProps (only called if parent updated)6243* - shouldComponentUpdate6244* - componentWillUpdate6245* - render6246* - [children's constructors or receive props phases]6247* - componentDidUpdate6248*6249* - componentWillUnmount6250* - [children's componentWillUnmount]6251* - [children destroyed]6252* - (destroyed): The instance is now blank, released by React and ready for GC.6253*6254* -----------------------------------------------------------------------------6255*/62566257/**6258* An incrementing ID assigned to each component when it is mounted. This is6259* used to enforce the order in which `ReactUpdates` updates dirty components.6260*6261* @private6262*/6263var nextMountID = 1;62646265/**6266* @lends {ReactCompositeComponent.prototype}6267*/6268var ReactCompositeComponentMixin = {62696270/**6271* Base constructor for all composite component.6272*6273* @param {ReactElement} element6274* @final6275* @internal6276*/6277construct: function(element) {6278this._currentElement = element;6279this._rootNodeID = null;6280this._instance = null;62816282// See ReactUpdateQueue6283this._pendingElement = null;6284this._pendingStateQueue = null;6285this._pendingReplaceState = false;6286this._pendingForceUpdate = false;62876288this._renderedComponent = null;62896290this._context = null;6291this._mountOrder = 0;6292this._isTopLevel = false;62936294// See ReactUpdates and ReactUpdateQueue.6295this._pendingCallbacks = null;6296},62976298/**6299* Initializes the component, renders markup, and registers event listeners.6300*6301* @param {string} rootID DOM ID of the root node.6302* @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction6303* @return {?string} Rendered markup to be inserted into the DOM.6304* @final6305* @internal6306*/6307mountComponent: function(rootID, transaction, context) {6308this._context = context;6309this._mountOrder = nextMountID++;6310this._rootNodeID = rootID;63116312var publicProps = this._processProps(this._currentElement.props);6313var publicContext = this._processContext(this._currentElement._context);63146315var Component = ReactNativeComponent.getComponentClassForElement(6316this._currentElement6317);63186319// Initialize the public class6320var inst = new Component(publicProps, publicContext);63216322if ("production" !== "development") {6323// This will throw later in _renderValidatedComponent, but add an early6324// warning now to help debugging6325("production" !== "development" ? warning(6326inst.render != null,6327'%s(...): No `render` method found on the returned component ' +6328'instance: you may have forgotten to define `render` in your ' +6329'component or you may have accidentally tried to render an element ' +6330'whose type is a function that isn\'t a React component.',6331Component.displayName || Component.name || 'Component'6332) : null);6333}63346335// These should be set up in the constructor, but as a convenience for6336// simpler class abstractions, we set them up after the fact.6337inst.props = publicProps;6338inst.context = publicContext;6339inst.refs = emptyObject;63406341this._instance = inst;63426343// Store a reference from the instance back to the internal representation6344ReactInstanceMap.set(inst, this);63456346if ("production" !== "development") {6347this._warnIfContextsDiffer(this._currentElement._context, context);6348}63496350if ("production" !== "development") {6351// Since plain JS classes are defined without any special initialization6352// logic, we can not catch common errors early. Therefore, we have to6353// catch them here, at initialization time, instead.6354("production" !== "development" ? warning(6355!inst.getInitialState ||6356inst.getInitialState.isReactClassApproved,6357'getInitialState was defined on %s, a plain JavaScript class. ' +6358'This is only supported for classes created using React.createClass. ' +6359'Did you mean to define a state property instead?',6360this.getName() || 'a component'6361) : null);6362("production" !== "development" ? warning(6363!inst.getDefaultProps ||6364inst.getDefaultProps.isReactClassApproved,6365'getDefaultProps was defined on %s, a plain JavaScript class. ' +6366'This is only supported for classes created using React.createClass. ' +6367'Use a static property to define defaultProps instead.',6368this.getName() || 'a component'6369) : null);6370("production" !== "development" ? warning(6371!inst.propTypes,6372'propTypes was defined as an instance property on %s. Use a static ' +6373'property to define propTypes instead.',6374this.getName() || 'a component'6375) : null);6376("production" !== "development" ? warning(6377!inst.contextTypes,6378'contextTypes was defined as an instance property on %s. Use a ' +6379'static property to define contextTypes instead.',6380this.getName() || 'a component'6381) : null);6382("production" !== "development" ? warning(6383typeof inst.componentShouldUpdate !== 'function',6384'%s has a method called ' +6385'componentShouldUpdate(). Did you mean shouldComponentUpdate()? ' +6386'The name is phrased as a question because the function is ' +6387'expected to return a value.',6388(this.getName() || 'A component')6389) : null);6390}63916392var initialState = inst.state;6393if (initialState === undefined) {6394inst.state = initialState = null;6395}6396("production" !== "development" ? invariant(6397typeof initialState === 'object' && !Array.isArray(initialState),6398'%s.state: must be set to an object or null',6399this.getName() || 'ReactCompositeComponent'6400) : invariant(typeof initialState === 'object' && !Array.isArray(initialState)));64016402this._pendingStateQueue = null;6403this._pendingReplaceState = false;6404this._pendingForceUpdate = false;64056406var childContext;6407var renderedElement;64086409var previouslyMounting = ReactLifeCycle.currentlyMountingInstance;6410ReactLifeCycle.currentlyMountingInstance = this;6411try {6412if (inst.componentWillMount) {6413inst.componentWillMount();6414// When mounting, calls to `setState` by `componentWillMount` will set6415// `this._pendingStateQueue` without triggering a re-render.6416if (this._pendingStateQueue) {6417inst.state = this._processPendingState(inst.props, inst.context);6418}6419}64206421childContext = this._getValidatedChildContext(context);6422renderedElement = this._renderValidatedComponent(childContext);6423} finally {6424ReactLifeCycle.currentlyMountingInstance = previouslyMounting;6425}64266427this._renderedComponent = this._instantiateReactComponent(6428renderedElement,6429this._currentElement.type // The wrapping type6430);64316432var markup = ReactReconciler.mountComponent(6433this._renderedComponent,6434rootID,6435transaction,6436this._mergeChildContext(context, childContext)6437);6438if (inst.componentDidMount) {6439transaction.getReactMountReady().enqueue(inst.componentDidMount, inst);6440}64416442return markup;6443},64446445/**6446* Releases any resources allocated by `mountComponent`.6447*6448* @final6449* @internal6450*/6451unmountComponent: function() {6452var inst = this._instance;64536454if (inst.componentWillUnmount) {6455var previouslyUnmounting = ReactLifeCycle.currentlyUnmountingInstance;6456ReactLifeCycle.currentlyUnmountingInstance = this;6457try {6458inst.componentWillUnmount();6459} finally {6460ReactLifeCycle.currentlyUnmountingInstance = previouslyUnmounting;6461}6462}64636464ReactReconciler.unmountComponent(this._renderedComponent);6465this._renderedComponent = null;64666467// Reset pending fields6468this._pendingStateQueue = null;6469this._pendingReplaceState = false;6470this._pendingForceUpdate = false;6471this._pendingCallbacks = null;6472this._pendingElement = null;64736474// These fields do not really need to be reset since this object is no6475// longer accessible.6476this._context = null;6477this._rootNodeID = null;64786479// Delete the reference from the instance to this internal representation6480// which allow the internals to be properly cleaned up even if the user6481// leaks a reference to the public instance.6482ReactInstanceMap.remove(inst);64836484// Some existing components rely on inst.props even after they've been6485// destroyed (in event handlers).6486// TODO: inst.props = null;6487// TODO: inst.state = null;6488// TODO: inst.context = null;6489},64906491/**6492* Schedule a partial update to the props. Only used for internal testing.6493*6494* @param {object} partialProps Subset of the next props.6495* @param {?function} callback Called after props are updated.6496* @final6497* @internal6498*/6499_setPropsInternal: function(partialProps, callback) {6500// This is a deoptimized path. We optimize for always having an element.6501// This creates an extra internal element.6502var element = this._pendingElement || this._currentElement;6503this._pendingElement = ReactElement.cloneAndReplaceProps(6504element,6505assign({}, element.props, partialProps)6506);6507ReactUpdates.enqueueUpdate(this, callback);6508},65096510/**6511* Filters the context object to only contain keys specified in6512* `contextTypes`6513*6514* @param {object} context6515* @return {?object}6516* @private6517*/6518_maskContext: function(context) {6519var maskedContext = null;6520// This really should be getting the component class for the element,6521// but we know that we're not going to need it for built-ins.6522if (typeof this._currentElement.type === 'string') {6523return emptyObject;6524}6525var contextTypes = this._currentElement.type.contextTypes;6526if (!contextTypes) {6527return emptyObject;6528}6529maskedContext = {};6530for (var contextName in contextTypes) {6531maskedContext[contextName] = context[contextName];6532}6533return maskedContext;6534},65356536/**6537* Filters the context object to only contain keys specified in6538* `contextTypes`, and asserts that they are valid.6539*6540* @param {object} context6541* @return {?object}6542* @private6543*/6544_processContext: function(context) {6545var maskedContext = this._maskContext(context);6546if ("production" !== "development") {6547var Component = ReactNativeComponent.getComponentClassForElement(6548this._currentElement6549);6550if (Component.contextTypes) {6551this._checkPropTypes(6552Component.contextTypes,6553maskedContext,6554ReactPropTypeLocations.context6555);6556}6557}6558return maskedContext;6559},65606561/**6562* @param {object} currentContext6563* @return {object}6564* @private6565*/6566_getValidatedChildContext: function(currentContext) {6567var inst = this._instance;6568var childContext = inst.getChildContext && inst.getChildContext();6569if (childContext) {6570("production" !== "development" ? invariant(6571typeof inst.constructor.childContextTypes === 'object',6572'%s.getChildContext(): childContextTypes must be defined in order to ' +6573'use getChildContext().',6574this.getName() || 'ReactCompositeComponent'6575) : invariant(typeof inst.constructor.childContextTypes === 'object'));6576if ("production" !== "development") {6577this._checkPropTypes(6578inst.constructor.childContextTypes,6579childContext,6580ReactPropTypeLocations.childContext6581);6582}6583for (var name in childContext) {6584("production" !== "development" ? invariant(6585name in inst.constructor.childContextTypes,6586'%s.getChildContext(): key "%s" is not defined in childContextTypes.',6587this.getName() || 'ReactCompositeComponent',6588name6589) : invariant(name in inst.constructor.childContextTypes));6590}6591return childContext;6592}6593return null;6594},65956596_mergeChildContext: function(currentContext, childContext) {6597if (childContext) {6598return assign({}, currentContext, childContext);6599}6600return currentContext;6601},66026603/**6604* Processes props by setting default values for unspecified props and6605* asserting that the props are valid. Does not mutate its argument; returns6606* a new props object with defaults merged in.6607*6608* @param {object} newProps6609* @return {object}6610* @private6611*/6612_processProps: function(newProps) {6613if ("production" !== "development") {6614var Component = ReactNativeComponent.getComponentClassForElement(6615this._currentElement6616);6617if (Component.propTypes) {6618this._checkPropTypes(6619Component.propTypes,6620newProps,6621ReactPropTypeLocations.prop6622);6623}6624}6625return newProps;6626},66276628/**6629* Assert that the props are valid6630*6631* @param {object} propTypes Map of prop name to a ReactPropType6632* @param {object} props6633* @param {string} location e.g. "prop", "context", "child context"6634* @private6635*/6636_checkPropTypes: function(propTypes, props, location) {6637// TODO: Stop validating prop types here and only use the element6638// validation.6639var componentName = this.getName();6640for (var propName in propTypes) {6641if (propTypes.hasOwnProperty(propName)) {6642var error;6643try {6644// This is intentionally an invariant that gets caught. It's the same6645// behavior as without this statement except with a better message.6646("production" !== "development" ? invariant(6647typeof propTypes[propName] === 'function',6648'%s: %s type `%s` is invalid; it must be a function, usually ' +6649'from React.PropTypes.',6650componentName || 'React class',6651ReactPropTypeLocationNames[location],6652propName6653) : invariant(typeof propTypes[propName] === 'function'));6654error = propTypes[propName](props, propName, componentName, location);6655} catch (ex) {6656error = ex;6657}6658if (error instanceof Error) {6659// We may want to extend this logic for similar errors in6660// React.render calls, so I'm abstracting it away into6661// a function to minimize refactoring in the future6662var addendum = getDeclarationErrorAddendum(this);66636664if (location === ReactPropTypeLocations.prop) {6665// Preface gives us something to blacklist in warning module6666("production" !== "development" ? warning(6667false,6668'Failed Composite propType: %s%s',6669error.message,6670addendum6671) : null);6672} else {6673("production" !== "development" ? warning(6674false,6675'Failed Context Types: %s%s',6676error.message,6677addendum6678) : null);6679}6680}6681}6682}6683},66846685receiveComponent: function(nextElement, transaction, nextContext) {6686var prevElement = this._currentElement;6687var prevContext = this._context;66886689this._pendingElement = null;66906691this.updateComponent(6692transaction,6693prevElement,6694nextElement,6695prevContext,6696nextContext6697);6698},66996700/**6701* If any of `_pendingElement`, `_pendingStateQueue`, or `_pendingForceUpdate`6702* is set, update the component.6703*6704* @param {ReactReconcileTransaction} transaction6705* @internal6706*/6707performUpdateIfNecessary: function(transaction) {6708if (this._pendingElement != null) {6709ReactReconciler.receiveComponent(6710this,6711this._pendingElement || this._currentElement,6712transaction,6713this._context6714);6715}67166717if (this._pendingStateQueue !== null || this._pendingForceUpdate) {6718if ("production" !== "development") {6719ReactElementValidator.checkAndWarnForMutatedProps(6720this._currentElement6721);6722}67236724this.updateComponent(6725transaction,6726this._currentElement,6727this._currentElement,6728this._context,6729this._context6730);6731}6732},67336734/**6735* Compare two contexts, warning if they are different6736* TODO: Remove this check when owner-context is removed6737*/6738_warnIfContextsDiffer: function(ownerBasedContext, parentBasedContext) {6739ownerBasedContext = this._maskContext(ownerBasedContext);6740parentBasedContext = this._maskContext(parentBasedContext);6741var parentKeys = Object.keys(parentBasedContext).sort();6742var displayName = this.getName() || 'ReactCompositeComponent';6743for (var i = 0; i < parentKeys.length; i++) {6744var key = parentKeys[i];6745("production" !== "development" ? warning(6746ownerBasedContext[key] === parentBasedContext[key],6747'owner-based and parent-based contexts differ ' +6748'(values: `%s` vs `%s`) for key (%s) while mounting %s ' +6749'(see: http://fb.me/react-context-by-parent)',6750ownerBasedContext[key],6751parentBasedContext[key],6752key,6753displayName6754) : null);6755}6756},67576758/**6759* Perform an update to a mounted component. The componentWillReceiveProps and6760* shouldComponentUpdate methods are called, then (assuming the update isn't6761* skipped) the remaining update lifecycle methods are called and the DOM6762* representation is updated.6763*6764* By default, this implements React's rendering and reconciliation algorithm.6765* Sophisticated clients may wish to override this.6766*6767* @param {ReactReconcileTransaction} transaction6768* @param {ReactElement} prevParentElement6769* @param {ReactElement} nextParentElement6770* @internal6771* @overridable6772*/6773updateComponent: function(6774transaction,6775prevParentElement,6776nextParentElement,6777prevUnmaskedContext,6778nextUnmaskedContext6779) {6780var inst = this._instance;67816782var nextContext = inst.context;6783var nextProps = inst.props;67846785// Distinguish between a props update versus a simple state update6786if (prevParentElement !== nextParentElement) {6787nextContext = this._processContext(nextParentElement._context);6788nextProps = this._processProps(nextParentElement.props);67896790if ("production" !== "development") {6791if (nextUnmaskedContext != null) {6792this._warnIfContextsDiffer(6793nextParentElement._context,6794nextUnmaskedContext6795);6796}6797}67986799// An update here will schedule an update but immediately set6800// _pendingStateQueue which will ensure that any state updates gets6801// immediately reconciled instead of waiting for the next batch.68026803if (inst.componentWillReceiveProps) {6804inst.componentWillReceiveProps(nextProps, nextContext);6805}6806}68076808var nextState = this._processPendingState(nextProps, nextContext);68096810var shouldUpdate =6811this._pendingForceUpdate ||6812!inst.shouldComponentUpdate ||6813inst.shouldComponentUpdate(nextProps, nextState, nextContext);68146815if ("production" !== "development") {6816("production" !== "development" ? warning(6817typeof shouldUpdate !== 'undefined',6818'%s.shouldComponentUpdate(): Returned undefined instead of a ' +6819'boolean value. Make sure to return true or false.',6820this.getName() || 'ReactCompositeComponent'6821) : null);6822}68236824if (shouldUpdate) {6825this._pendingForceUpdate = false;6826// Will set `this.props`, `this.state` and `this.context`.6827this._performComponentUpdate(6828nextParentElement,6829nextProps,6830nextState,6831nextContext,6832transaction,6833nextUnmaskedContext6834);6835} else {6836// If it's determined that a component should not update, we still want6837// to set props and state but we shortcut the rest of the update.6838this._currentElement = nextParentElement;6839this._context = nextUnmaskedContext;6840inst.props = nextProps;6841inst.state = nextState;6842inst.context = nextContext;6843}6844},68456846_processPendingState: function(props, context) {6847var inst = this._instance;6848var queue = this._pendingStateQueue;6849var replace = this._pendingReplaceState;6850this._pendingReplaceState = false;6851this._pendingStateQueue = null;68526853if (!queue) {6854return inst.state;6855}68566857if (replace && queue.length === 1) {6858return queue[0];6859}68606861var nextState = assign({}, replace ? queue[0] : inst.state);6862for (var i = replace ? 1 : 0; i < queue.length; i++) {6863var partial = queue[i];6864assign(6865nextState,6866typeof partial === 'function' ?6867partial.call(inst, nextState, props, context) :6868partial6869);6870}68716872return nextState;6873},68746875/**6876* Merges new props and state, notifies delegate methods of update and6877* performs update.6878*6879* @param {ReactElement} nextElement Next element6880* @param {object} nextProps Next public object to set as properties.6881* @param {?object} nextState Next object to set as state.6882* @param {?object} nextContext Next public object to set as context.6883* @param {ReactReconcileTransaction} transaction6884* @param {?object} unmaskedContext6885* @private6886*/6887_performComponentUpdate: function(6888nextElement,6889nextProps,6890nextState,6891nextContext,6892transaction,6893unmaskedContext6894) {6895var inst = this._instance;68966897var prevProps = inst.props;6898var prevState = inst.state;6899var prevContext = inst.context;69006901if (inst.componentWillUpdate) {6902inst.componentWillUpdate(nextProps, nextState, nextContext);6903}69046905this._currentElement = nextElement;6906this._context = unmaskedContext;6907inst.props = nextProps;6908inst.state = nextState;6909inst.context = nextContext;69106911this._updateRenderedComponent(transaction, unmaskedContext);69126913if (inst.componentDidUpdate) {6914transaction.getReactMountReady().enqueue(6915inst.componentDidUpdate.bind(inst, prevProps, prevState, prevContext),6916inst6917);6918}6919},69206921/**6922* Call the component's `render` method and update the DOM accordingly.6923*6924* @param {ReactReconcileTransaction} transaction6925* @internal6926*/6927_updateRenderedComponent: function(transaction, context) {6928var prevComponentInstance = this._renderedComponent;6929var prevRenderedElement = prevComponentInstance._currentElement;6930var childContext = this._getValidatedChildContext();6931var nextRenderedElement = this._renderValidatedComponent(childContext);6932if (shouldUpdateReactComponent(prevRenderedElement, nextRenderedElement)) {6933ReactReconciler.receiveComponent(6934prevComponentInstance,6935nextRenderedElement,6936transaction,6937this._mergeChildContext(context, childContext)6938);6939} else {6940// These two IDs are actually the same! But nothing should rely on that.6941var thisID = this._rootNodeID;6942var prevComponentID = prevComponentInstance._rootNodeID;6943ReactReconciler.unmountComponent(prevComponentInstance);69446945this._renderedComponent = this._instantiateReactComponent(6946nextRenderedElement,6947this._currentElement.type6948);6949var nextMarkup = ReactReconciler.mountComponent(6950this._renderedComponent,6951thisID,6952transaction,6953this._mergeChildContext(context, childContext)6954);6955this._replaceNodeWithMarkupByID(prevComponentID, nextMarkup);6956}6957},69586959/**6960* @protected6961*/6962_replaceNodeWithMarkupByID: function(prevComponentID, nextMarkup) {6963ReactComponentEnvironment.replaceNodeWithMarkupByID(6964prevComponentID,6965nextMarkup6966);6967},69686969/**6970* @protected6971*/6972_renderValidatedComponentWithoutOwnerOrContext: function() {6973var inst = this._instance;6974var renderedComponent = inst.render();6975if ("production" !== "development") {6976// We allow auto-mocks to proceed as if they're returning null.6977if (typeof renderedComponent === 'undefined' &&6978inst.render._isMockFunction) {6979// This is probably bad practice. Consider warning here and6980// deprecating this convenience.6981renderedComponent = null;6982}6983}69846985return renderedComponent;6986},69876988/**6989* @private6990*/6991_renderValidatedComponent: function(childContext) {6992var renderedComponent;6993var previousContext = ReactContext.current;6994ReactContext.current = this._mergeChildContext(6995this._currentElement._context,6996childContext6997);6998ReactCurrentOwner.current = this;6999try {7000renderedComponent =7001this._renderValidatedComponentWithoutOwnerOrContext();7002} finally {7003ReactContext.current = previousContext;7004ReactCurrentOwner.current = null;7005}7006("production" !== "development" ? invariant(7007// TODO: An `isValidNode` function would probably be more appropriate7008renderedComponent === null || renderedComponent === false ||7009ReactElement.isValidElement(renderedComponent),7010'%s.render(): A valid ReactComponent must be returned. You may have ' +7011'returned undefined, an array or some other invalid object.',7012this.getName() || 'ReactCompositeComponent'7013) : invariant(// TODO: An `isValidNode` function would probably be more appropriate7014renderedComponent === null || renderedComponent === false ||7015ReactElement.isValidElement(renderedComponent)));7016return renderedComponent;7017},70187019/**7020* Lazily allocates the refs object and stores `component` as `ref`.7021*7022* @param {string} ref Reference name.7023* @param {component} component Component to store as `ref`.7024* @final7025* @private7026*/7027attachRef: function(ref, component) {7028var inst = this.getPublicInstance();7029var refs = inst.refs === emptyObject ? (inst.refs = {}) : inst.refs;7030refs[ref] = component.getPublicInstance();7031},70327033/**7034* Detaches a reference name.7035*7036* @param {string} ref Name to dereference.7037* @final7038* @private7039*/7040detachRef: function(ref) {7041var refs = this.getPublicInstance().refs;7042delete refs[ref];7043},70447045/**7046* Get a text description of the component that can be used to identify it7047* in error messages.7048* @return {string} The name or null.7049* @internal7050*/7051getName: function() {7052var type = this._currentElement.type;7053var constructor = this._instance && this._instance.constructor;7054return (7055type.displayName || (constructor && constructor.displayName) ||7056type.name || (constructor && constructor.name) ||7057null7058);7059},70607061/**7062* Get the publicly accessible representation of this component - i.e. what7063* is exposed by refs and returned by React.render. Can be null for stateless7064* components.7065*7066* @return {ReactComponent} the public component instance.7067* @internal7068*/7069getPublicInstance: function() {7070return this._instance;7071},70727073// Stub7074_instantiateReactComponent: null70757076};70777078ReactPerf.measureMethods(7079ReactCompositeComponentMixin,7080'ReactCompositeComponent',7081{7082mountComponent: 'mountComponent',7083updateComponent: 'updateComponent',7084_renderValidatedComponent: '_renderValidatedComponent'7085}7086);70877088var ReactCompositeComponent = {70897090Mixin: ReactCompositeComponentMixin70917092};70937094module.exports = ReactCompositeComponent;70957096},{"115":115,"135":135,"151":151,"154":154,"27":27,"36":36,"38":38,"39":39,"57":57,"58":58,"67":67,"68":68,"73":73,"75":75,"76":76,"77":77,"81":81,"87":87}],38:[function(_dereq_,module,exports){7097/**7098* Copyright 2013-2015, Facebook, Inc.7099* All rights reserved.7100*7101* This source code is licensed under the BSD-style license found in the7102* LICENSE file in the root directory of this source tree. An additional grant7103* of patent rights can be found in the PATENTS file in the same directory.7104*7105* @providesModule ReactContext7106*/71077108'use strict';71097110var assign = _dereq_(27);7111var emptyObject = _dereq_(115);7112var warning = _dereq_(154);71137114var didWarn = false;71157116/**7117* Keeps track of the current context.7118*7119* The context is automatically passed down the component ownership hierarchy7120* and is accessible via `this.context` on ReactCompositeComponents.7121*/7122var ReactContext = {71237124/**7125* @internal7126* @type {object}7127*/7128current: emptyObject,71297130/**7131* Temporarily extends the current context while executing scopedCallback.7132*7133* A typical use case might look like7134*7135* render: function() {7136* var children = ReactContext.withContext({foo: 'foo'}, () => (7137*7138* ));7139* return <div>{children}</div>;7140* }7141*7142* @param {object} newContext New context to merge into the existing context7143* @param {function} scopedCallback Callback to run with the new context7144* @return {ReactComponent|array<ReactComponent>}7145*/7146withContext: function(newContext, scopedCallback) {7147if ("production" !== "development") {7148("production" !== "development" ? warning(7149didWarn,7150'withContext is deprecated and will be removed in a future version. ' +7151'Use a wrapper component with getChildContext instead.'7152) : null);71537154didWarn = true;7155}71567157var result;7158var previousContext = ReactContext.current;7159ReactContext.current = assign({}, previousContext, newContext);7160try {7161result = scopedCallback();7162} finally {7163ReactContext.current = previousContext;7164}7165return result;7166}71677168};71697170module.exports = ReactContext;71717172},{"115":115,"154":154,"27":27}],39:[function(_dereq_,module,exports){7173/**7174* Copyright 2013-2015, Facebook, Inc.7175* All rights reserved.7176*7177* This source code is licensed under the BSD-style license found in the7178* LICENSE file in the root directory of this source tree. An additional grant7179* of patent rights can be found in the PATENTS file in the same directory.7180*7181* @providesModule ReactCurrentOwner7182*/71837184'use strict';71857186/**7187* Keeps track of the current owner.7188*7189* The current owner is the component who should own any components that are7190* currently being constructed.7191*7192* The depth indicate how many composite components are above this render level.7193*/7194var ReactCurrentOwner = {71957196/**7197* @internal7198* @type {ReactComponent}7199*/7200current: null72017202};72037204module.exports = ReactCurrentOwner;72057206},{}],40:[function(_dereq_,module,exports){7207/**7208* Copyright 2013-2015, Facebook, Inc.7209* All rights reserved.7210*7211* This source code is licensed under the BSD-style license found in the7212* LICENSE file in the root directory of this source tree. An additional grant7213* of patent rights can be found in the PATENTS file in the same directory.7214*7215* @providesModule ReactDOM7216* @typechecks static-only7217*/72187219'use strict';72207221var ReactElement = _dereq_(57);7222var ReactElementValidator = _dereq_(58);72237224var mapObject = _dereq_(142);72257226/**7227* Create a factory that creates HTML tag elements.7228*7229* @param {string} tag Tag name (e.g. `div`).7230* @private7231*/7232function createDOMFactory(tag) {7233if ("production" !== "development") {7234return ReactElementValidator.createFactory(tag);7235}7236return ReactElement.createFactory(tag);7237}72387239/**7240* Creates a mapping from supported HTML tags to `ReactDOMComponent` classes.7241* This is also accessible via `React.DOM`.7242*7243* @public7244*/7245var ReactDOM = mapObject({7246a: 'a',7247abbr: 'abbr',7248address: 'address',7249area: 'area',7250article: 'article',7251aside: 'aside',7252audio: 'audio',7253b: 'b',7254base: 'base',7255bdi: 'bdi',7256bdo: 'bdo',7257big: 'big',7258blockquote: 'blockquote',7259body: 'body',7260br: 'br',7261button: 'button',7262canvas: 'canvas',7263caption: 'caption',7264cite: 'cite',7265code: 'code',7266col: 'col',7267colgroup: 'colgroup',7268data: 'data',7269datalist: 'datalist',7270dd: 'dd',7271del: 'del',7272details: 'details',7273dfn: 'dfn',7274dialog: 'dialog',7275div: 'div',7276dl: 'dl',7277dt: 'dt',7278em: 'em',7279embed: 'embed',7280fieldset: 'fieldset',7281figcaption: 'figcaption',7282figure: 'figure',7283footer: 'footer',7284form: 'form',7285h1: 'h1',7286h2: 'h2',7287h3: 'h3',7288h4: 'h4',7289h5: 'h5',7290h6: 'h6',7291head: 'head',7292header: 'header',7293hr: 'hr',7294html: 'html',7295i: 'i',7296iframe: 'iframe',7297img: 'img',7298input: 'input',7299ins: 'ins',7300kbd: 'kbd',7301keygen: 'keygen',7302label: 'label',7303legend: 'legend',7304li: 'li',7305link: 'link',7306main: 'main',7307map: 'map',7308mark: 'mark',7309menu: 'menu',7310menuitem: 'menuitem',7311meta: 'meta',7312meter: 'meter',7313nav: 'nav',7314noscript: 'noscript',7315object: 'object',7316ol: 'ol',7317optgroup: 'optgroup',7318option: 'option',7319output: 'output',7320p: 'p',7321param: 'param',7322picture: 'picture',7323pre: 'pre',7324progress: 'progress',7325q: 'q',7326rp: 'rp',7327rt: 'rt',7328ruby: 'ruby',7329s: 's',7330samp: 'samp',7331script: 'script',7332section: 'section',7333select: 'select',7334small: 'small',7335source: 'source',7336span: 'span',7337strong: 'strong',7338style: 'style',7339sub: 'sub',7340summary: 'summary',7341sup: 'sup',7342table: 'table',7343tbody: 'tbody',7344td: 'td',7345textarea: 'textarea',7346tfoot: 'tfoot',7347th: 'th',7348thead: 'thead',7349time: 'time',7350title: 'title',7351tr: 'tr',7352track: 'track',7353u: 'u',7354ul: 'ul',7355'var': 'var',7356video: 'video',7357wbr: 'wbr',73587359// SVG7360circle: 'circle',7361clipPath: 'clipPath',7362defs: 'defs',7363ellipse: 'ellipse',7364g: 'g',7365line: 'line',7366linearGradient: 'linearGradient',7367mask: 'mask',7368path: 'path',7369pattern: 'pattern',7370polygon: 'polygon',7371polyline: 'polyline',7372radialGradient: 'radialGradient',7373rect: 'rect',7374stop: 'stop',7375svg: 'svg',7376text: 'text',7377tspan: 'tspan'73787379}, createDOMFactory);73807381module.exports = ReactDOM;73827383},{"142":142,"57":57,"58":58}],41:[function(_dereq_,module,exports){7384/**7385* Copyright 2013-2015, Facebook, Inc.7386* All rights reserved.7387*7388* This source code is licensed under the BSD-style license found in the7389* LICENSE file in the root directory of this source tree. An additional grant7390* of patent rights can be found in the PATENTS file in the same directory.7391*7392* @providesModule ReactDOMButton7393*/73947395'use strict';73967397var AutoFocusMixin = _dereq_(2);7398var ReactBrowserComponentMixin = _dereq_(29);7399var ReactClass = _dereq_(33);7400var ReactElement = _dereq_(57);74017402var keyMirror = _dereq_(140);74037404var button = ReactElement.createFactory('button');74057406var mouseListenerNames = keyMirror({7407onClick: true,7408onDoubleClick: true,7409onMouseDown: true,7410onMouseMove: true,7411onMouseUp: true,7412onClickCapture: true,7413onDoubleClickCapture: true,7414onMouseDownCapture: true,7415onMouseMoveCapture: true,7416onMouseUpCapture: true7417});74187419/**7420* Implements a <button> native component that does not receive mouse events7421* when `disabled` is set.7422*/7423var ReactDOMButton = ReactClass.createClass({7424displayName: 'ReactDOMButton',7425tagName: 'BUTTON',74267427mixins: [AutoFocusMixin, ReactBrowserComponentMixin],74287429render: function() {7430var props = {};74317432// Copy the props; except the mouse listeners if we're disabled7433for (var key in this.props) {7434if (this.props.hasOwnProperty(key) &&7435(!this.props.disabled || !mouseListenerNames[key])) {7436props[key] = this.props[key];7437}7438}74397440return button(props, this.props.children);7441}74427443});74447445module.exports = ReactDOMButton;74467447},{"140":140,"2":2,"29":29,"33":33,"57":57}],42:[function(_dereq_,module,exports){7448/**7449* Copyright 2013-2015, Facebook, Inc.7450* All rights reserved.7451*7452* This source code is licensed under the BSD-style license found in the7453* LICENSE file in the root directory of this source tree. An additional grant7454* of patent rights can be found in the PATENTS file in the same directory.7455*7456* @providesModule ReactDOMComponent7457* @typechecks static-only7458*/74597460/* global hasOwnProperty:true */74617462'use strict';74637464var CSSPropertyOperations = _dereq_(5);7465var DOMProperty = _dereq_(10);7466var DOMPropertyOperations = _dereq_(11);7467var ReactBrowserEventEmitter = _dereq_(30);7468var ReactComponentBrowserEnvironment =7469_dereq_(35);7470var ReactMount = _dereq_(70);7471var ReactMultiChild = _dereq_(71);7472var ReactPerf = _dereq_(75);74737474var assign = _dereq_(27);7475var escapeTextContentForBrowser = _dereq_(116);7476var invariant = _dereq_(135);7477var isEventSupported = _dereq_(136);7478var keyOf = _dereq_(141);7479var warning = _dereq_(154);74807481var deleteListener = ReactBrowserEventEmitter.deleteListener;7482var listenTo = ReactBrowserEventEmitter.listenTo;7483var registrationNameModules = ReactBrowserEventEmitter.registrationNameModules;74847485// For quickly matching children type, to test if can be treated as content.7486var CONTENT_TYPES = {'string': true, 'number': true};74877488var STYLE = keyOf({style: null});74897490var ELEMENT_NODE_TYPE = 1;74917492/**7493* Optionally injectable operations for mutating the DOM7494*/7495var BackendIDOperations = null;74967497/**7498* @param {?object} props7499*/7500function assertValidProps(props) {7501if (!props) {7502return;7503}7504// Note the use of `==` which checks for null or undefined.7505if (props.dangerouslySetInnerHTML != null) {7506("production" !== "development" ? invariant(7507props.children == null,7508'Can only set one of `children` or `props.dangerouslySetInnerHTML`.'7509) : invariant(props.children == null));7510("production" !== "development" ? invariant(7511typeof props.dangerouslySetInnerHTML === 'object' &&7512'__html' in props.dangerouslySetInnerHTML,7513'`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. ' +7514'Please visit https://fb.me/react-invariant-dangerously-set-inner-html ' +7515'for more information.'7516) : invariant(typeof props.dangerouslySetInnerHTML === 'object' &&7517'__html' in props.dangerouslySetInnerHTML));7518}7519if ("production" !== "development") {7520("production" !== "development" ? warning(7521props.innerHTML == null,7522'Directly setting property `innerHTML` is not permitted. ' +7523'For more information, lookup documentation on `dangerouslySetInnerHTML`.'7524) : null);7525("production" !== "development" ? warning(7526!props.contentEditable || props.children == null,7527'A component is `contentEditable` and contains `children` managed by ' +7528'React. It is now your responsibility to guarantee that none of ' +7529'those nodes are unexpectedly modified or duplicated. This is ' +7530'probably not intentional.'7531) : null);7532}7533("production" !== "development" ? invariant(7534props.style == null || typeof props.style === 'object',7535'The `style` prop expects a mapping from style properties to values, ' +7536'not a string. For example, style={{marginRight: spacing + \'em\'}} when ' +7537'using JSX.'7538) : invariant(props.style == null || typeof props.style === 'object'));7539}75407541function putListener(id, registrationName, listener, transaction) {7542if ("production" !== "development") {7543// IE8 has no API for event capturing and the `onScroll` event doesn't7544// bubble.7545("production" !== "development" ? warning(7546registrationName !== 'onScroll' || isEventSupported('scroll', true),7547'This browser doesn\'t support the `onScroll` event'7548) : null);7549}7550var container = ReactMount.findReactContainerForID(id);7551if (container) {7552var doc = container.nodeType === ELEMENT_NODE_TYPE ?7553container.ownerDocument :7554container;7555listenTo(registrationName, doc);7556}7557transaction.getPutListenerQueue().enqueuePutListener(7558id,7559registrationName,7560listener7561);7562}75637564// For HTML, certain tags should omit their close tag. We keep a whitelist for7565// those special cased tags.75667567var omittedCloseTags = {7568'area': true,7569'base': true,7570'br': true,7571'col': true,7572'embed': true,7573'hr': true,7574'img': true,7575'input': true,7576'keygen': true,7577'link': true,7578'meta': true,7579'param': true,7580'source': true,7581'track': true,7582'wbr': true7583// NOTE: menuitem's close tag should be omitted, but that causes problems.7584};75857586// We accept any tag to be rendered but since this gets injected into abitrary7587// HTML, we want to make sure that it's a safe tag.7588// http://www.w3.org/TR/REC-xml/#NT-Name75897590var VALID_TAG_REGEX = /^[a-zA-Z][a-zA-Z:_\.\-\d]*$/; // Simplified subset7591var validatedTagCache = {};7592var hasOwnProperty = {}.hasOwnProperty;75937594function validateDangerousTag(tag) {7595if (!hasOwnProperty.call(validatedTagCache, tag)) {7596("production" !== "development" ? invariant(VALID_TAG_REGEX.test(tag), 'Invalid tag: %s', tag) : invariant(VALID_TAG_REGEX.test(tag)));7597validatedTagCache[tag] = true;7598}7599}76007601/**7602* Creates a new React class that is idempotent and capable of containing other7603* React components. It accepts event listeners and DOM properties that are7604* valid according to `DOMProperty`.7605*7606* - Event listeners: `onClick`, `onMouseDown`, etc.7607* - DOM properties: `className`, `name`, `title`, etc.7608*7609* The `style` property functions differently from the DOM API. It accepts an7610* object mapping of style properties to values.7611*7612* @constructor ReactDOMComponent7613* @extends ReactMultiChild7614*/7615function ReactDOMComponent(tag) {7616validateDangerousTag(tag);7617this._tag = tag;7618this._renderedChildren = null;7619this._previousStyleCopy = null;7620this._rootNodeID = null;7621}76227623ReactDOMComponent.displayName = 'ReactDOMComponent';76247625ReactDOMComponent.Mixin = {76267627construct: function(element) {7628this._currentElement = element;7629},76307631/**7632* Generates root tag markup then recurses. This method has side effects and7633* is not idempotent.7634*7635* @internal7636* @param {string} rootID The root DOM ID for this node.7637* @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction7638* @return {string} The computed markup.7639*/7640mountComponent: function(rootID, transaction, context) {7641this._rootNodeID = rootID;7642assertValidProps(this._currentElement.props);7643var closeTag = omittedCloseTags[this._tag] ? '' : '</' + this._tag + '>';7644return (7645this._createOpenTagMarkupAndPutListeners(transaction) +7646this._createContentMarkup(transaction, context) +7647closeTag7648);7649},76507651/**7652* Creates markup for the open tag and all attributes.7653*7654* This method has side effects because events get registered.7655*7656* Iterating over object properties is faster than iterating over arrays.7657* @see http://jsperf.com/obj-vs-arr-iteration7658*7659* @private7660* @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction7661* @return {string} Markup of opening tag.7662*/7663_createOpenTagMarkupAndPutListeners: function(transaction) {7664var props = this._currentElement.props;7665var ret = '<' + this._tag;76667667for (var propKey in props) {7668if (!props.hasOwnProperty(propKey)) {7669continue;7670}7671var propValue = props[propKey];7672if (propValue == null) {7673continue;7674}7675if (registrationNameModules.hasOwnProperty(propKey)) {7676putListener(this._rootNodeID, propKey, propValue, transaction);7677} else {7678if (propKey === STYLE) {7679if (propValue) {7680propValue = this._previousStyleCopy = assign({}, props.style);7681}7682propValue = CSSPropertyOperations.createMarkupForStyles(propValue);7683}7684var markup =7685DOMPropertyOperations.createMarkupForProperty(propKey, propValue);7686if (markup) {7687ret += ' ' + markup;7688}7689}7690}76917692// For static pages, no need to put React ID and checksum. Saves lots of7693// bytes.7694if (transaction.renderToStaticMarkup) {7695return ret + '>';7696}76977698var markupForID = DOMPropertyOperations.createMarkupForID(this._rootNodeID);7699return ret + ' ' + markupForID + '>';7700},77017702/**7703* Creates markup for the content between the tags.7704*7705* @private7706* @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction7707* @param {object} context7708* @return {string} Content markup.7709*/7710_createContentMarkup: function(transaction, context) {7711var prefix = '';7712if (this._tag === 'listing' ||7713this._tag === 'pre' ||7714this._tag === 'textarea') {7715// Add an initial newline because browsers ignore the first newline in7716// a <listing>, <pre>, or <textarea> as an "authoring convenience" -- see7717// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inbody.7718prefix = '\n';7719}77207721var props = this._currentElement.props;77227723// Intentional use of != to avoid catching zero/false.7724var innerHTML = props.dangerouslySetInnerHTML;7725if (innerHTML != null) {7726if (innerHTML.__html != null) {7727return prefix + innerHTML.__html;7728}7729} else {7730var contentToUse =7731CONTENT_TYPES[typeof props.children] ? props.children : null;7732var childrenToUse = contentToUse != null ? null : props.children;7733if (contentToUse != null) {7734return prefix + escapeTextContentForBrowser(contentToUse);7735} else if (childrenToUse != null) {7736var mountImages = this.mountChildren(7737childrenToUse,7738transaction,7739context7740);7741return prefix + mountImages.join('');7742}7743}7744return prefix;7745},77467747receiveComponent: function(nextElement, transaction, context) {7748var prevElement = this._currentElement;7749this._currentElement = nextElement;7750this.updateComponent(transaction, prevElement, nextElement, context);7751},77527753/**7754* Updates a native DOM component after it has already been allocated and7755* attached to the DOM. Reconciles the root DOM node, then recurses.7756*7757* @param {ReactReconcileTransaction} transaction7758* @param {ReactElement} prevElement7759* @param {ReactElement} nextElement7760* @internal7761* @overridable7762*/7763updateComponent: function(transaction, prevElement, nextElement, context) {7764assertValidProps(this._currentElement.props);7765this._updateDOMProperties(prevElement.props, transaction);7766this._updateDOMChildren(prevElement.props, transaction, context);7767},77687769/**7770* Reconciles the properties by detecting differences in property values and7771* updating the DOM as necessary. This function is probably the single most7772* critical path for performance optimization.7773*7774* TODO: Benchmark whether checking for changed values in memory actually7775* improves performance (especially statically positioned elements).7776* TODO: Benchmark the effects of putting this at the top since 99% of props7777* do not change for a given reconciliation.7778* TODO: Benchmark areas that can be improved with caching.7779*7780* @private7781* @param {object} lastProps7782* @param {ReactReconcileTransaction} transaction7783*/7784_updateDOMProperties: function(lastProps, transaction) {7785var nextProps = this._currentElement.props;7786var propKey;7787var styleName;7788var styleUpdates;7789for (propKey in lastProps) {7790if (nextProps.hasOwnProperty(propKey) ||7791!lastProps.hasOwnProperty(propKey)) {7792continue;7793}7794if (propKey === STYLE) {7795var lastStyle = this._previousStyleCopy;7796for (styleName in lastStyle) {7797if (lastStyle.hasOwnProperty(styleName)) {7798styleUpdates = styleUpdates || {};7799styleUpdates[styleName] = '';7800}7801}7802this._previousStyleCopy = null;7803} else if (registrationNameModules.hasOwnProperty(propKey)) {7804deleteListener(this._rootNodeID, propKey);7805} else if (7806DOMProperty.isStandardName[propKey] ||7807DOMProperty.isCustomAttribute(propKey)) {7808BackendIDOperations.deletePropertyByID(7809this._rootNodeID,7810propKey7811);7812}7813}7814for (propKey in nextProps) {7815var nextProp = nextProps[propKey];7816var lastProp = propKey === STYLE ?7817this._previousStyleCopy :7818lastProps[propKey];7819if (!nextProps.hasOwnProperty(propKey) || nextProp === lastProp) {7820continue;7821}7822if (propKey === STYLE) {7823if (nextProp) {7824nextProp = this._previousStyleCopy = assign({}, nextProp);7825} else {7826this._previousStyleCopy = null;7827}7828if (lastProp) {7829// Unset styles on `lastProp` but not on `nextProp`.7830for (styleName in lastProp) {7831if (lastProp.hasOwnProperty(styleName) &&7832(!nextProp || !nextProp.hasOwnProperty(styleName))) {7833styleUpdates = styleUpdates || {};7834styleUpdates[styleName] = '';7835}7836}7837// Update styles that changed since `lastProp`.7838for (styleName in nextProp) {7839if (nextProp.hasOwnProperty(styleName) &&7840lastProp[styleName] !== nextProp[styleName]) {7841styleUpdates = styleUpdates || {};7842styleUpdates[styleName] = nextProp[styleName];7843}7844}7845} else {7846// Relies on `updateStylesByID` not mutating `styleUpdates`.7847styleUpdates = nextProp;7848}7849} else if (registrationNameModules.hasOwnProperty(propKey)) {7850putListener(this._rootNodeID, propKey, nextProp, transaction);7851} else if (7852DOMProperty.isStandardName[propKey] ||7853DOMProperty.isCustomAttribute(propKey)) {7854BackendIDOperations.updatePropertyByID(7855this._rootNodeID,7856propKey,7857nextProp7858);7859}7860}7861if (styleUpdates) {7862BackendIDOperations.updateStylesByID(7863this._rootNodeID,7864styleUpdates7865);7866}7867},78687869/**7870* Reconciles the children with the various properties that affect the7871* children content.7872*7873* @param {object} lastProps7874* @param {ReactReconcileTransaction} transaction7875*/7876_updateDOMChildren: function(lastProps, transaction, context) {7877var nextProps = this._currentElement.props;78787879var lastContent =7880CONTENT_TYPES[typeof lastProps.children] ? lastProps.children : null;7881var nextContent =7882CONTENT_TYPES[typeof nextProps.children] ? nextProps.children : null;78837884var lastHtml =7885lastProps.dangerouslySetInnerHTML &&7886lastProps.dangerouslySetInnerHTML.__html;7887var nextHtml =7888nextProps.dangerouslySetInnerHTML &&7889nextProps.dangerouslySetInnerHTML.__html;78907891// Note the use of `!=` which checks for null or undefined.7892var lastChildren = lastContent != null ? null : lastProps.children;7893var nextChildren = nextContent != null ? null : nextProps.children;78947895// If we're switching from children to content/html or vice versa, remove7896// the old content7897var lastHasContentOrHtml = lastContent != null || lastHtml != null;7898var nextHasContentOrHtml = nextContent != null || nextHtml != null;7899if (lastChildren != null && nextChildren == null) {7900this.updateChildren(null, transaction, context);7901} else if (lastHasContentOrHtml && !nextHasContentOrHtml) {7902this.updateTextContent('');7903}79047905if (nextContent != null) {7906if (lastContent !== nextContent) {7907this.updateTextContent('' + nextContent);7908}7909} else if (nextHtml != null) {7910if (lastHtml !== nextHtml) {7911BackendIDOperations.updateInnerHTMLByID(7912this._rootNodeID,7913nextHtml7914);7915}7916} else if (nextChildren != null) {7917this.updateChildren(nextChildren, transaction, context);7918}7919},79207921/**7922* Destroys all event registrations for this instance. Does not remove from7923* the DOM. That must be done by the parent.7924*7925* @internal7926*/7927unmountComponent: function() {7928this.unmountChildren();7929ReactBrowserEventEmitter.deleteAllListeners(this._rootNodeID);7930ReactComponentBrowserEnvironment.unmountIDFromEnvironment(this._rootNodeID);7931this._rootNodeID = null;7932}79337934};79357936ReactPerf.measureMethods(ReactDOMComponent, 'ReactDOMComponent', {7937mountComponent: 'mountComponent',7938updateComponent: 'updateComponent'7939});79407941assign(7942ReactDOMComponent.prototype,7943ReactDOMComponent.Mixin,7944ReactMultiChild.Mixin7945);79467947ReactDOMComponent.injection = {7948injectIDOperations: function(IDOperations) {7949ReactDOMComponent.BackendIDOperations = BackendIDOperations = IDOperations;7950}7951};79527953module.exports = ReactDOMComponent;79547955},{"10":10,"11":11,"116":116,"135":135,"136":136,"141":141,"154":154,"27":27,"30":30,"35":35,"5":5,"70":70,"71":71,"75":75}],43:[function(_dereq_,module,exports){7956/**7957* Copyright 2013-2015, Facebook, Inc.7958* All rights reserved.7959*7960* This source code is licensed under the BSD-style license found in the7961* LICENSE file in the root directory of this source tree. An additional grant7962* of patent rights can be found in the PATENTS file in the same directory.7963*7964* @providesModule ReactDOMForm7965*/79667967'use strict';79687969var EventConstants = _dereq_(15);7970var LocalEventTrapMixin = _dereq_(25);7971var ReactBrowserComponentMixin = _dereq_(29);7972var ReactClass = _dereq_(33);7973var ReactElement = _dereq_(57);79747975var form = ReactElement.createFactory('form');79767977/**7978* Since onSubmit doesn't bubble OR capture on the top level in IE8, we need7979* to capture it on the <form> element itself. There are lots of hacks we could7980* do to accomplish this, but the most reliable is to make <form> a7981* composite component and use `componentDidMount` to attach the event handlers.7982*/7983var ReactDOMForm = ReactClass.createClass({7984displayName: 'ReactDOMForm',7985tagName: 'FORM',79867987mixins: [ReactBrowserComponentMixin, LocalEventTrapMixin],79887989render: function() {7990// TODO: Instead of using `ReactDOM` directly, we should use JSX. However,7991// `jshint` fails to parse JSX so in order for linting to work in the open7992// source repo, we need to just use `ReactDOM.form`.7993return form(this.props);7994},79957996componentDidMount: function() {7997this.trapBubbledEvent(EventConstants.topLevelTypes.topReset, 'reset');7998this.trapBubbledEvent(EventConstants.topLevelTypes.topSubmit, 'submit');7999}8000});80018002module.exports = ReactDOMForm;80038004},{"15":15,"25":25,"29":29,"33":33,"57":57}],44:[function(_dereq_,module,exports){8005/**8006* Copyright 2013-2015, Facebook, Inc.8007* All rights reserved.8008*8009* This source code is licensed under the BSD-style license found in the8010* LICENSE file in the root directory of this source tree. An additional grant8011* of patent rights can be found in the PATENTS file in the same directory.8012*8013* @providesModule ReactDOMIDOperations8014* @typechecks static-only8015*/80168017/*jslint evil: true */80188019'use strict';80208021var CSSPropertyOperations = _dereq_(5);8022var DOMChildrenOperations = _dereq_(9);8023var DOMPropertyOperations = _dereq_(11);8024var ReactMount = _dereq_(70);8025var ReactPerf = _dereq_(75);80268027var invariant = _dereq_(135);8028var setInnerHTML = _dereq_(148);80298030/**8031* Errors for properties that should not be updated with `updatePropertyById()`.8032*8033* @type {object}8034* @private8035*/8036var INVALID_PROPERTY_ERRORS = {8037dangerouslySetInnerHTML:8038'`dangerouslySetInnerHTML` must be set using `updateInnerHTMLByID()`.',8039style: '`style` must be set using `updateStylesByID()`.'8040};80418042/**8043* Operations used to process updates to DOM nodes. This is made injectable via8044* `ReactDOMComponent.BackendIDOperations`.8045*/8046var ReactDOMIDOperations = {80478048/**8049* Updates a DOM node with new property values. This should only be used to8050* update DOM properties in `DOMProperty`.8051*8052* @param {string} id ID of the node to update.8053* @param {string} name A valid property name, see `DOMProperty`.8054* @param {*} value New value of the property.8055* @internal8056*/8057updatePropertyByID: function(id, name, value) {8058var node = ReactMount.getNode(id);8059("production" !== "development" ? invariant(8060!INVALID_PROPERTY_ERRORS.hasOwnProperty(name),8061'updatePropertyByID(...): %s',8062INVALID_PROPERTY_ERRORS[name]8063) : invariant(!INVALID_PROPERTY_ERRORS.hasOwnProperty(name)));80648065// If we're updating to null or undefined, we should remove the property8066// from the DOM node instead of inadvertantly setting to a string. This8067// brings us in line with the same behavior we have on initial render.8068if (value != null) {8069DOMPropertyOperations.setValueForProperty(node, name, value);8070} else {8071DOMPropertyOperations.deleteValueForProperty(node, name);8072}8073},80748075/**8076* Updates a DOM node to remove a property. This should only be used to remove8077* DOM properties in `DOMProperty`.8078*8079* @param {string} id ID of the node to update.8080* @param {string} name A property name to remove, see `DOMProperty`.8081* @internal8082*/8083deletePropertyByID: function(id, name, value) {8084var node = ReactMount.getNode(id);8085("production" !== "development" ? invariant(8086!INVALID_PROPERTY_ERRORS.hasOwnProperty(name),8087'updatePropertyByID(...): %s',8088INVALID_PROPERTY_ERRORS[name]8089) : invariant(!INVALID_PROPERTY_ERRORS.hasOwnProperty(name)));8090DOMPropertyOperations.deleteValueForProperty(node, name, value);8091},80928093/**8094* Updates a DOM node with new style values. If a value is specified as '',8095* the corresponding style property will be unset.8096*8097* @param {string} id ID of the node to update.8098* @param {object} styles Mapping from styles to values.8099* @internal8100*/8101updateStylesByID: function(id, styles) {8102var node = ReactMount.getNode(id);8103CSSPropertyOperations.setValueForStyles(node, styles);8104},81058106/**8107* Updates a DOM node's innerHTML.8108*8109* @param {string} id ID of the node to update.8110* @param {string} html An HTML string.8111* @internal8112*/8113updateInnerHTMLByID: function(id, html) {8114var node = ReactMount.getNode(id);8115setInnerHTML(node, html);8116},81178118/**8119* Updates a DOM node's text content set by `props.content`.8120*8121* @param {string} id ID of the node to update.8122* @param {string} content Text content.8123* @internal8124*/8125updateTextContentByID: function(id, content) {8126var node = ReactMount.getNode(id);8127DOMChildrenOperations.updateTextContent(node, content);8128},81298130/**8131* Replaces a DOM node that exists in the document with markup.8132*8133* @param {string} id ID of child to be replaced.8134* @param {string} markup Dangerous markup to inject in place of child.8135* @internal8136* @see {Danger.dangerouslyReplaceNodeWithMarkup}8137*/8138dangerouslyReplaceNodeWithMarkupByID: function(id, markup) {8139var node = ReactMount.getNode(id);8140DOMChildrenOperations.dangerouslyReplaceNodeWithMarkup(node, markup);8141},81428143/**8144* Updates a component's children by processing a series of updates.8145*8146* @param {array<object>} updates List of update configurations.8147* @param {array<string>} markup List of markup strings.8148* @internal8149*/8150dangerouslyProcessChildrenUpdates: function(updates, markup) {8151for (var i = 0; i < updates.length; i++) {8152updates[i].parentNode = ReactMount.getNode(updates[i].parentID);8153}8154DOMChildrenOperations.processUpdates(updates, markup);8155}8156};81578158ReactPerf.measureMethods(ReactDOMIDOperations, 'ReactDOMIDOperations', {8159updatePropertyByID: 'updatePropertyByID',8160deletePropertyByID: 'deletePropertyByID',8161updateStylesByID: 'updateStylesByID',8162updateInnerHTMLByID: 'updateInnerHTMLByID',8163updateTextContentByID: 'updateTextContentByID',8164dangerouslyReplaceNodeWithMarkupByID: 'dangerouslyReplaceNodeWithMarkupByID',8165dangerouslyProcessChildrenUpdates: 'dangerouslyProcessChildrenUpdates'8166});81678168module.exports = ReactDOMIDOperations;81698170},{"11":11,"135":135,"148":148,"5":5,"70":70,"75":75,"9":9}],45:[function(_dereq_,module,exports){8171/**8172* Copyright 2013-2015, Facebook, Inc.8173* All rights reserved.8174*8175* This source code is licensed under the BSD-style license found in the8176* LICENSE file in the root directory of this source tree. An additional grant8177* of patent rights can be found in the PATENTS file in the same directory.8178*8179* @providesModule ReactDOMIframe8180*/81818182'use strict';81838184var EventConstants = _dereq_(15);8185var LocalEventTrapMixin = _dereq_(25);8186var ReactBrowserComponentMixin = _dereq_(29);8187var ReactClass = _dereq_(33);8188var ReactElement = _dereq_(57);81898190var iframe = ReactElement.createFactory('iframe');81918192/**8193* Since onLoad doesn't bubble OR capture on the top level in IE8, we need to8194* capture it on the <iframe> element itself. There are lots of hacks we could8195* do to accomplish this, but the most reliable is to make <iframe> a composite8196* component and use `componentDidMount` to attach the event handlers.8197*/8198var ReactDOMIframe = ReactClass.createClass({8199displayName: 'ReactDOMIframe',8200tagName: 'IFRAME',82018202mixins: [ReactBrowserComponentMixin, LocalEventTrapMixin],82038204render: function() {8205return iframe(this.props);8206},82078208componentDidMount: function() {8209this.trapBubbledEvent(EventConstants.topLevelTypes.topLoad, 'load');8210}8211});82128213module.exports = ReactDOMIframe;82148215},{"15":15,"25":25,"29":29,"33":33,"57":57}],46:[function(_dereq_,module,exports){8216/**8217* Copyright 2013-2015, Facebook, Inc.8218* All rights reserved.8219*8220* This source code is licensed under the BSD-style license found in the8221* LICENSE file in the root directory of this source tree. An additional grant8222* of patent rights can be found in the PATENTS file in the same directory.8223*8224* @providesModule ReactDOMImg8225*/82268227'use strict';82288229var EventConstants = _dereq_(15);8230var LocalEventTrapMixin = _dereq_(25);8231var ReactBrowserComponentMixin = _dereq_(29);8232var ReactClass = _dereq_(33);8233var ReactElement = _dereq_(57);82348235var img = ReactElement.createFactory('img');82368237/**8238* Since onLoad doesn't bubble OR capture on the top level in IE8, we need to8239* capture it on the <img> element itself. There are lots of hacks we could do8240* to accomplish this, but the most reliable is to make <img> a composite8241* component and use `componentDidMount` to attach the event handlers.8242*/8243var ReactDOMImg = ReactClass.createClass({8244displayName: 'ReactDOMImg',8245tagName: 'IMG',82468247mixins: [ReactBrowserComponentMixin, LocalEventTrapMixin],82488249render: function() {8250return img(this.props);8251},82528253componentDidMount: function() {8254this.trapBubbledEvent(EventConstants.topLevelTypes.topLoad, 'load');8255this.trapBubbledEvent(EventConstants.topLevelTypes.topError, 'error');8256}8257});82588259module.exports = ReactDOMImg;82608261},{"15":15,"25":25,"29":29,"33":33,"57":57}],47:[function(_dereq_,module,exports){8262/**8263* Copyright 2013-2015, Facebook, Inc.8264* All rights reserved.8265*8266* This source code is licensed under the BSD-style license found in the8267* LICENSE file in the root directory of this source tree. An additional grant8268* of patent rights can be found in the PATENTS file in the same directory.8269*8270* @providesModule ReactDOMInput8271*/82728273'use strict';82748275var AutoFocusMixin = _dereq_(2);8276var DOMPropertyOperations = _dereq_(11);8277var LinkedValueUtils = _dereq_(24);8278var ReactBrowserComponentMixin = _dereq_(29);8279var ReactClass = _dereq_(33);8280var ReactElement = _dereq_(57);8281var ReactMount = _dereq_(70);8282var ReactUpdates = _dereq_(87);82838284var assign = _dereq_(27);8285var invariant = _dereq_(135);82868287var input = ReactElement.createFactory('input');82888289var instancesByReactID = {};82908291function forceUpdateIfMounted() {8292/*jshint validthis:true */8293if (this.isMounted()) {8294this.forceUpdate();8295}8296}82978298/**8299* Implements an <input> native component that allows setting these optional8300* props: `checked`, `value`, `defaultChecked`, and `defaultValue`.8301*8302* If `checked` or `value` are not supplied (or null/undefined), user actions8303* that affect the checked state or value will trigger updates to the element.8304*8305* If they are supplied (and not null/undefined), the rendered element will not8306* trigger updates to the element. Instead, the props must change in order for8307* the rendered element to be updated.8308*8309* The rendered element will be initialized as unchecked (or `defaultChecked`)8310* with an empty value (or `defaultValue`).8311*8312* @see http://www.w3.org/TR/2012/WD-html5-20121025/the-input-element.html8313*/8314var ReactDOMInput = ReactClass.createClass({8315displayName: 'ReactDOMInput',8316tagName: 'INPUT',83178318mixins: [AutoFocusMixin, LinkedValueUtils.Mixin, ReactBrowserComponentMixin],83198320getInitialState: function() {8321var defaultValue = this.props.defaultValue;8322return {8323initialChecked: this.props.defaultChecked || false,8324initialValue: defaultValue != null ? defaultValue : null8325};8326},83278328render: function() {8329// Clone `this.props` so we don't mutate the input.8330var props = assign({}, this.props);83318332props.defaultChecked = null;8333props.defaultValue = null;83348335var value = LinkedValueUtils.getValue(this);8336props.value = value != null ? value : this.state.initialValue;83378338var checked = LinkedValueUtils.getChecked(this);8339props.checked = checked != null ? checked : this.state.initialChecked;83408341props.onChange = this._handleChange;83428343return input(props, this.props.children);8344},83458346componentDidMount: function() {8347var id = ReactMount.getID(this.getDOMNode());8348instancesByReactID[id] = this;8349},83508351componentWillUnmount: function() {8352var rootNode = this.getDOMNode();8353var id = ReactMount.getID(rootNode);8354delete instancesByReactID[id];8355},83568357componentDidUpdate: function(prevProps, prevState, prevContext) {8358var rootNode = this.getDOMNode();8359if (this.props.checked != null) {8360DOMPropertyOperations.setValueForProperty(8361rootNode,8362'checked',8363this.props.checked || false8364);8365}83668367var value = LinkedValueUtils.getValue(this);8368if (value != null) {8369// Cast `value` to a string to ensure the value is set correctly. While8370// browsers typically do this as necessary, jsdom doesn't.8371DOMPropertyOperations.setValueForProperty(rootNode, 'value', '' + value);8372}8373},83748375_handleChange: function(event) {8376var returnValue;8377var onChange = LinkedValueUtils.getOnChange(this);8378if (onChange) {8379returnValue = onChange.call(this, event);8380}8381// Here we use asap to wait until all updates have propagated, which8382// is important when using controlled components within layers:8383// https://github.com/facebook/react/issues/16988384ReactUpdates.asap(forceUpdateIfMounted, this);83858386var name = this.props.name;8387if (this.props.type === 'radio' && name != null) {8388var rootNode = this.getDOMNode();8389var queryRoot = rootNode;83908391while (queryRoot.parentNode) {8392queryRoot = queryRoot.parentNode;8393}83948395// If `rootNode.form` was non-null, then we could try `form.elements`,8396// but that sometimes behaves strangely in IE8. We could also try using8397// `form.getElementsByName`, but that will only return direct children8398// and won't include inputs that use the HTML5 `form=` attribute. Since8399// the input might not even be in a form, let's just use the global8400// `querySelectorAll` to ensure we don't miss anything.8401var group = queryRoot.querySelectorAll(8402'input[name=' + JSON.stringify('' + name) + '][type="radio"]');84038404for (var i = 0, groupLen = group.length; i < groupLen; i++) {8405var otherNode = group[i];8406if (otherNode === rootNode ||8407otherNode.form !== rootNode.form) {8408continue;8409}8410var otherID = ReactMount.getID(otherNode);8411("production" !== "development" ? invariant(8412otherID,8413'ReactDOMInput: Mixing React and non-React radio inputs with the ' +8414'same `name` is not supported.'8415) : invariant(otherID));8416var otherInstance = instancesByReactID[otherID];8417("production" !== "development" ? invariant(8418otherInstance,8419'ReactDOMInput: Unknown radio button ID %s.',8420otherID8421) : invariant(otherInstance));8422// If this is a controlled radio button group, forcing the input that8423// was previously checked to update will cause it to be come re-checked8424// as appropriate.8425ReactUpdates.asap(forceUpdateIfMounted, otherInstance);8426}8427}84288429return returnValue;8430}84318432});84338434module.exports = ReactDOMInput;84358436},{"11":11,"135":135,"2":2,"24":24,"27":27,"29":29,"33":33,"57":57,"70":70,"87":87}],48:[function(_dereq_,module,exports){8437/**8438* Copyright 2013-2015, Facebook, Inc.8439* All rights reserved.8440*8441* This source code is licensed under the BSD-style license found in the8442* LICENSE file in the root directory of this source tree. An additional grant8443* of patent rights can be found in the PATENTS file in the same directory.8444*8445* @providesModule ReactDOMOption8446*/84478448'use strict';84498450var ReactBrowserComponentMixin = _dereq_(29);8451var ReactClass = _dereq_(33);8452var ReactElement = _dereq_(57);84538454var warning = _dereq_(154);84558456var option = ReactElement.createFactory('option');84578458/**8459* Implements an <option> native component that warns when `selected` is set.8460*/8461var ReactDOMOption = ReactClass.createClass({8462displayName: 'ReactDOMOption',8463tagName: 'OPTION',84648465mixins: [ReactBrowserComponentMixin],84668467componentWillMount: function() {8468// TODO (yungsters): Remove support for `selected` in <option>.8469if ("production" !== "development") {8470("production" !== "development" ? warning(8471this.props.selected == null,8472'Use the `defaultValue` or `value` props on <select> instead of ' +8473'setting `selected` on <option>.'8474) : null);8475}8476},84778478render: function() {8479return option(this.props, this.props.children);8480}84818482});84838484module.exports = ReactDOMOption;84858486},{"154":154,"29":29,"33":33,"57":57}],49:[function(_dereq_,module,exports){8487/**8488* Copyright 2013-2015, Facebook, Inc.8489* All rights reserved.8490*8491* This source code is licensed under the BSD-style license found in the8492* LICENSE file in the root directory of this source tree. An additional grant8493* of patent rights can be found in the PATENTS file in the same directory.8494*8495* @providesModule ReactDOMSelect8496*/84978498'use strict';84998500var AutoFocusMixin = _dereq_(2);8501var LinkedValueUtils = _dereq_(24);8502var ReactBrowserComponentMixin = _dereq_(29);8503var ReactClass = _dereq_(33);8504var ReactElement = _dereq_(57);8505var ReactUpdates = _dereq_(87);85068507var assign = _dereq_(27);85088509var select = ReactElement.createFactory('select');85108511function updateOptionsIfPendingUpdateAndMounted() {8512/*jshint validthis:true */8513if (this._pendingUpdate) {8514this._pendingUpdate = false;8515var value = LinkedValueUtils.getValue(this);8516if (value != null && this.isMounted()) {8517updateOptions(this, value);8518}8519}8520}85218522/**8523* Validation function for `value` and `defaultValue`.8524* @private8525*/8526function selectValueType(props, propName, componentName) {8527if (props[propName] == null) {8528return null;8529}8530if (props.multiple) {8531if (!Array.isArray(props[propName])) {8532return new Error(8533("The `" + propName + "` prop supplied to <select> must be an array if ") +8534("`multiple` is true.")8535);8536}8537} else {8538if (Array.isArray(props[propName])) {8539return new Error(8540("The `" + propName + "` prop supplied to <select> must be a scalar ") +8541("value if `multiple` is false.")8542);8543}8544}8545}85468547/**8548* @param {ReactComponent} component Instance of ReactDOMSelect8549* @param {*} propValue A stringable (with `multiple`, a list of stringables).8550* @private8551*/8552function updateOptions(component, propValue) {8553var selectedValue, i, l;8554var options = component.getDOMNode().options;85558556if (component.props.multiple) {8557selectedValue = {};8558for (i = 0, l = propValue.length; i < l; i++) {8559selectedValue['' + propValue[i]] = true;8560}8561for (i = 0, l = options.length; i < l; i++) {8562var selected = selectedValue.hasOwnProperty(options[i].value);8563if (options[i].selected !== selected) {8564options[i].selected = selected;8565}8566}8567} else {8568// Do not set `select.value` as exact behavior isn't consistent across all8569// browsers for all cases.8570selectedValue = '' + propValue;8571for (i = 0, l = options.length; i < l; i++) {8572if (options[i].value === selectedValue) {8573options[i].selected = true;8574return;8575}8576}8577if (options.length) {8578options[0].selected = true;8579}8580}8581}85828583/**8584* Implements a <select> native component that allows optionally setting the8585* props `value` and `defaultValue`. If `multiple` is false, the prop must be a8586* stringable. If `multiple` is true, the prop must be an array of stringables.8587*8588* If `value` is not supplied (or null/undefined), user actions that change the8589* selected option will trigger updates to the rendered options.8590*8591* If it is supplied (and not null/undefined), the rendered options will not8592* update in response to user actions. Instead, the `value` prop must change in8593* order for the rendered options to update.8594*8595* If `defaultValue` is provided, any options with the supplied values will be8596* selected.8597*/8598var ReactDOMSelect = ReactClass.createClass({8599displayName: 'ReactDOMSelect',8600tagName: 'SELECT',86018602mixins: [AutoFocusMixin, LinkedValueUtils.Mixin, ReactBrowserComponentMixin],86038604propTypes: {8605defaultValue: selectValueType,8606value: selectValueType8607},86088609render: function() {8610// Clone `this.props` so we don't mutate the input.8611var props = assign({}, this.props);86128613props.onChange = this._handleChange;8614props.value = null;86158616return select(props, this.props.children);8617},86188619componentWillMount: function() {8620this._pendingUpdate = false;8621},86228623componentDidMount: function() {8624var value = LinkedValueUtils.getValue(this);8625if (value != null) {8626updateOptions(this, value);8627} else if (this.props.defaultValue != null) {8628updateOptions(this, this.props.defaultValue);8629}8630},86318632componentDidUpdate: function(prevProps) {8633var value = LinkedValueUtils.getValue(this);8634if (value != null) {8635this._pendingUpdate = false;8636updateOptions(this, value);8637} else if (!prevProps.multiple !== !this.props.multiple) {8638// For simplicity, reapply `defaultValue` if `multiple` is toggled.8639if (this.props.defaultValue != null) {8640updateOptions(this, this.props.defaultValue);8641} else {8642// Revert the select back to its default unselected state.8643updateOptions(this, this.props.multiple ? [] : '');8644}8645}8646},86478648_handleChange: function(event) {8649var returnValue;8650var onChange = LinkedValueUtils.getOnChange(this);8651if (onChange) {8652returnValue = onChange.call(this, event);8653}86548655this._pendingUpdate = true;8656ReactUpdates.asap(updateOptionsIfPendingUpdateAndMounted, this);8657return returnValue;8658}86598660});86618662module.exports = ReactDOMSelect;86638664},{"2":2,"24":24,"27":27,"29":29,"33":33,"57":57,"87":87}],50:[function(_dereq_,module,exports){8665/**8666* Copyright 2013-2015, Facebook, Inc.8667* All rights reserved.8668*8669* This source code is licensed under the BSD-style license found in the8670* LICENSE file in the root directory of this source tree. An additional grant8671* of patent rights can be found in the PATENTS file in the same directory.8672*8673* @providesModule ReactDOMSelection8674*/86758676'use strict';86778678var ExecutionEnvironment = _dereq_(21);86798680var getNodeForCharacterOffset = _dereq_(128);8681var getTextContentAccessor = _dereq_(130);86828683/**8684* While `isCollapsed` is available on the Selection object and `collapsed`8685* is available on the Range object, IE11 sometimes gets them wrong.8686* If the anchor/focus nodes and offsets are the same, the range is collapsed.8687*/8688function isCollapsed(anchorNode, anchorOffset, focusNode, focusOffset) {8689return anchorNode === focusNode && anchorOffset === focusOffset;8690}86918692/**8693* Get the appropriate anchor and focus node/offset pairs for IE.8694*8695* The catch here is that IE's selection API doesn't provide information8696* about whether the selection is forward or backward, so we have to8697* behave as though it's always forward.8698*8699* IE text differs from modern selection in that it behaves as though8700* block elements end with a new line. This means character offsets will8701* differ between the two APIs.8702*8703* @param {DOMElement} node8704* @return {object}8705*/8706function getIEOffsets(node) {8707var selection = document.selection;8708var selectedRange = selection.createRange();8709var selectedLength = selectedRange.text.length;87108711// Duplicate selection so we can move range without breaking user selection.8712var fromStart = selectedRange.duplicate();8713fromStart.moveToElementText(node);8714fromStart.setEndPoint('EndToStart', selectedRange);87158716var startOffset = fromStart.text.length;8717var endOffset = startOffset + selectedLength;87188719return {8720start: startOffset,8721end: endOffset8722};8723}87248725/**8726* @param {DOMElement} node8727* @return {?object}8728*/8729function getModernOffsets(node) {8730var selection = window.getSelection && window.getSelection();87318732if (!selection || selection.rangeCount === 0) {8733return null;8734}87358736var anchorNode = selection.anchorNode;8737var anchorOffset = selection.anchorOffset;8738var focusNode = selection.focusNode;8739var focusOffset = selection.focusOffset;87408741var currentRange = selection.getRangeAt(0);87428743// If the node and offset values are the same, the selection is collapsed.8744// `Selection.isCollapsed` is available natively, but IE sometimes gets8745// this value wrong.8746var isSelectionCollapsed = isCollapsed(8747selection.anchorNode,8748selection.anchorOffset,8749selection.focusNode,8750selection.focusOffset8751);87528753var rangeLength = isSelectionCollapsed ? 0 : currentRange.toString().length;87548755var tempRange = currentRange.cloneRange();8756tempRange.selectNodeContents(node);8757tempRange.setEnd(currentRange.startContainer, currentRange.startOffset);87588759var isTempRangeCollapsed = isCollapsed(8760tempRange.startContainer,8761tempRange.startOffset,8762tempRange.endContainer,8763tempRange.endOffset8764);87658766var start = isTempRangeCollapsed ? 0 : tempRange.toString().length;8767var end = start + rangeLength;87688769// Detect whether the selection is backward.8770var detectionRange = document.createRange();8771detectionRange.setStart(anchorNode, anchorOffset);8772detectionRange.setEnd(focusNode, focusOffset);8773var isBackward = detectionRange.collapsed;87748775return {8776start: isBackward ? end : start,8777end: isBackward ? start : end8778};8779}87808781/**8782* @param {DOMElement|DOMTextNode} node8783* @param {object} offsets8784*/8785function setIEOffsets(node, offsets) {8786var range = document.selection.createRange().duplicate();8787var start, end;87888789if (typeof offsets.end === 'undefined') {8790start = offsets.start;8791end = start;8792} else if (offsets.start > offsets.end) {8793start = offsets.end;8794end = offsets.start;8795} else {8796start = offsets.start;8797end = offsets.end;8798}87998800range.moveToElementText(node);8801range.moveStart('character', start);8802range.setEndPoint('EndToStart', range);8803range.moveEnd('character', end - start);8804range.select();8805}88068807/**8808* In modern non-IE browsers, we can support both forward and backward8809* selections.8810*8811* Note: IE10+ supports the Selection object, but it does not support8812* the `extend` method, which means that even in modern IE, it's not possible8813* to programatically create a backward selection. Thus, for all IE8814* versions, we use the old IE API to create our selections.8815*8816* @param {DOMElement|DOMTextNode} node8817* @param {object} offsets8818*/8819function setModernOffsets(node, offsets) {8820if (!window.getSelection) {8821return;8822}88238824var selection = window.getSelection();8825var length = node[getTextContentAccessor()].length;8826var start = Math.min(offsets.start, length);8827var end = typeof offsets.end === 'undefined' ?8828start : Math.min(offsets.end, length);88298830// IE 11 uses modern selection, but doesn't support the extend method.8831// Flip backward selections, so we can set with a single range.8832if (!selection.extend && start > end) {8833var temp = end;8834end = start;8835start = temp;8836}88378838var startMarker = getNodeForCharacterOffset(node, start);8839var endMarker = getNodeForCharacterOffset(node, end);88408841if (startMarker && endMarker) {8842var range = document.createRange();8843range.setStart(startMarker.node, startMarker.offset);8844selection.removeAllRanges();88458846if (start > end) {8847selection.addRange(range);8848selection.extend(endMarker.node, endMarker.offset);8849} else {8850range.setEnd(endMarker.node, endMarker.offset);8851selection.addRange(range);8852}8853}8854}88558856var useIEOffsets = (8857ExecutionEnvironment.canUseDOM &&8858'selection' in document &&8859!('getSelection' in window)8860);88618862var ReactDOMSelection = {8863/**8864* @param {DOMElement} node8865*/8866getOffsets: useIEOffsets ? getIEOffsets : getModernOffsets,88678868/**8869* @param {DOMElement|DOMTextNode} node8870* @param {object} offsets8871*/8872setOffsets: useIEOffsets ? setIEOffsets : setModernOffsets8873};88748875module.exports = ReactDOMSelection;88768877},{"128":128,"130":130,"21":21}],51:[function(_dereq_,module,exports){8878/**8879* Copyright 2013-2015, Facebook, Inc.8880* All rights reserved.8881*8882* This source code is licensed under the BSD-style license found in the8883* LICENSE file in the root directory of this source tree. An additional grant8884* of patent rights can be found in the PATENTS file in the same directory.8885*8886* @providesModule ReactDOMTextComponent8887* @typechecks static-only8888*/88898890'use strict';88918892var DOMPropertyOperations = _dereq_(11);8893var ReactComponentBrowserEnvironment =8894_dereq_(35);8895var ReactDOMComponent = _dereq_(42);88968897var assign = _dereq_(27);8898var escapeTextContentForBrowser = _dereq_(116);88998900/**8901* Text nodes violate a couple assumptions that React makes about components:8902*8903* - When mounting text into the DOM, adjacent text nodes are merged.8904* - Text nodes cannot be assigned a React root ID.8905*8906* This component is used to wrap strings in elements so that they can undergo8907* the same reconciliation that is applied to elements.8908*8909* TODO: Investigate representing React components in the DOM with text nodes.8910*8911* @class ReactDOMTextComponent8912* @extends ReactComponent8913* @internal8914*/8915var ReactDOMTextComponent = function(props) {8916// This constructor and its argument is currently used by mocks.8917};89188919assign(ReactDOMTextComponent.prototype, {89208921/**8922* @param {ReactText} text8923* @internal8924*/8925construct: function(text) {8926// TODO: This is really a ReactText (ReactNode), not a ReactElement8927this._currentElement = text;8928this._stringText = '' + text;89298930// Properties8931this._rootNodeID = null;8932this._mountIndex = 0;8933},89348935/**8936* Creates the markup for this text node. This node is not intended to have8937* any features besides containing text content.8938*8939* @param {string} rootID DOM ID of the root node.8940* @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction8941* @return {string} Markup for this text node.8942* @internal8943*/8944mountComponent: function(rootID, transaction, context) {8945this._rootNodeID = rootID;8946var escapedText = escapeTextContentForBrowser(this._stringText);89478948if (transaction.renderToStaticMarkup) {8949// Normally we'd wrap this in a `span` for the reasons stated above, but8950// since this is a situation where React won't take over (static pages),8951// we can simply return the text as it is.8952return escapedText;8953}89548955return (8956'<span ' + DOMPropertyOperations.createMarkupForID(rootID) + '>' +8957escapedText +8958'</span>'8959);8960},89618962/**8963* Updates this component by updating the text content.8964*8965* @param {ReactText} nextText The next text content8966* @param {ReactReconcileTransaction} transaction8967* @internal8968*/8969receiveComponent: function(nextText, transaction) {8970if (nextText !== this._currentElement) {8971this._currentElement = nextText;8972var nextStringText = '' + nextText;8973if (nextStringText !== this._stringText) {8974// TODO: Save this as pending props and use performUpdateIfNecessary8975// and/or updateComponent to do the actual update for consistency with8976// other component types?8977this._stringText = nextStringText;8978ReactDOMComponent.BackendIDOperations.updateTextContentByID(8979this._rootNodeID,8980nextStringText8981);8982}8983}8984},89858986unmountComponent: function() {8987ReactComponentBrowserEnvironment.unmountIDFromEnvironment(this._rootNodeID);8988}89898990});89918992module.exports = ReactDOMTextComponent;89938994},{"11":11,"116":116,"27":27,"35":35,"42":42}],52:[function(_dereq_,module,exports){8995/**8996* Copyright 2013-2015, Facebook, Inc.8997* All rights reserved.8998*8999* This source code is licensed under the BSD-style license found in the9000* LICENSE file in the root directory of this source tree. An additional grant9001* of patent rights can be found in the PATENTS file in the same directory.9002*9003* @providesModule ReactDOMTextarea9004*/90059006'use strict';90079008var AutoFocusMixin = _dereq_(2);9009var DOMPropertyOperations = _dereq_(11);9010var LinkedValueUtils = _dereq_(24);9011var ReactBrowserComponentMixin = _dereq_(29);9012var ReactClass = _dereq_(33);9013var ReactElement = _dereq_(57);9014var ReactUpdates = _dereq_(87);90159016var assign = _dereq_(27);9017var invariant = _dereq_(135);90189019var warning = _dereq_(154);90209021var textarea = ReactElement.createFactory('textarea');90229023function forceUpdateIfMounted() {9024/*jshint validthis:true */9025if (this.isMounted()) {9026this.forceUpdate();9027}9028}90299030/**9031* Implements a <textarea> native component that allows setting `value`, and9032* `defaultValue`. This differs from the traditional DOM API because value is9033* usually set as PCDATA children.9034*9035* If `value` is not supplied (or null/undefined), user actions that affect the9036* value will trigger updates to the element.9037*9038* If `value` is supplied (and not null/undefined), the rendered element will9039* not trigger updates to the element. Instead, the `value` prop must change in9040* order for the rendered element to be updated.9041*9042* The rendered element will be initialized with an empty value, the prop9043* `defaultValue` if specified, or the children content (deprecated).9044*/9045var ReactDOMTextarea = ReactClass.createClass({9046displayName: 'ReactDOMTextarea',9047tagName: 'TEXTAREA',90489049mixins: [AutoFocusMixin, LinkedValueUtils.Mixin, ReactBrowserComponentMixin],90509051getInitialState: function() {9052var defaultValue = this.props.defaultValue;9053// TODO (yungsters): Remove support for children content in <textarea>.9054var children = this.props.children;9055if (children != null) {9056if ("production" !== "development") {9057("production" !== "development" ? warning(9058false,9059'Use the `defaultValue` or `value` props instead of setting ' +9060'children on <textarea>.'9061) : null);9062}9063("production" !== "development" ? invariant(9064defaultValue == null,9065'If you supply `defaultValue` on a <textarea>, do not pass children.'9066) : invariant(defaultValue == null));9067if (Array.isArray(children)) {9068("production" !== "development" ? invariant(9069children.length <= 1,9070'<textarea> can only have at most one child.'9071) : invariant(children.length <= 1));9072children = children[0];9073}90749075defaultValue = '' + children;9076}9077if (defaultValue == null) {9078defaultValue = '';9079}9080var value = LinkedValueUtils.getValue(this);9081return {9082// We save the initial value so that `ReactDOMComponent` doesn't update9083// `textContent` (unnecessary since we update value).9084// The initial value can be a boolean or object so that's why it's9085// forced to be a string.9086initialValue: '' + (value != null ? value : defaultValue)9087};9088},90899090render: function() {9091// Clone `this.props` so we don't mutate the input.9092var props = assign({}, this.props);90939094("production" !== "development" ? invariant(9095props.dangerouslySetInnerHTML == null,9096'`dangerouslySetInnerHTML` does not make sense on <textarea>.'9097) : invariant(props.dangerouslySetInnerHTML == null));90989099props.defaultValue = null;9100props.value = null;9101props.onChange = this._handleChange;91029103// Always set children to the same thing. In IE9, the selection range will9104// get reset if `textContent` is mutated.9105return textarea(props, this.state.initialValue);9106},91079108componentDidUpdate: function(prevProps, prevState, prevContext) {9109var value = LinkedValueUtils.getValue(this);9110if (value != null) {9111var rootNode = this.getDOMNode();9112// Cast `value` to a string to ensure the value is set correctly. While9113// browsers typically do this as necessary, jsdom doesn't.9114DOMPropertyOperations.setValueForProperty(rootNode, 'value', '' + value);9115}9116},91179118_handleChange: function(event) {9119var returnValue;9120var onChange = LinkedValueUtils.getOnChange(this);9121if (onChange) {9122returnValue = onChange.call(this, event);9123}9124ReactUpdates.asap(forceUpdateIfMounted, this);9125return returnValue;9126}91279128});91299130module.exports = ReactDOMTextarea;91319132},{"11":11,"135":135,"154":154,"2":2,"24":24,"27":27,"29":29,"33":33,"57":57,"87":87}],53:[function(_dereq_,module,exports){9133/**9134* Copyright 2013-2015, Facebook, Inc.9135* All rights reserved.9136*9137* This source code is licensed under the BSD-style license found in the9138* LICENSE file in the root directory of this source tree. An additional grant9139* of patent rights can be found in the PATENTS file in the same directory.9140*9141* @providesModule ReactDefaultBatchingStrategy9142*/91439144'use strict';91459146var ReactUpdates = _dereq_(87);9147var Transaction = _dereq_(103);91489149var assign = _dereq_(27);9150var emptyFunction = _dereq_(114);91519152var RESET_BATCHED_UPDATES = {9153initialize: emptyFunction,9154close: function() {9155ReactDefaultBatchingStrategy.isBatchingUpdates = false;9156}9157};91589159var FLUSH_BATCHED_UPDATES = {9160initialize: emptyFunction,9161close: ReactUpdates.flushBatchedUpdates.bind(ReactUpdates)9162};91639164var TRANSACTION_WRAPPERS = [FLUSH_BATCHED_UPDATES, RESET_BATCHED_UPDATES];91659166function ReactDefaultBatchingStrategyTransaction() {9167this.reinitializeTransaction();9168}91699170assign(9171ReactDefaultBatchingStrategyTransaction.prototype,9172Transaction.Mixin,9173{9174getTransactionWrappers: function() {9175return TRANSACTION_WRAPPERS;9176}9177}9178);91799180var transaction = new ReactDefaultBatchingStrategyTransaction();91819182var ReactDefaultBatchingStrategy = {9183isBatchingUpdates: false,91849185/**9186* Call the provided function in a context within which calls to `setState`9187* and friends are batched such that components aren't updated unnecessarily.9188*/9189batchedUpdates: function(callback, a, b, c, d) {9190var alreadyBatchingUpdates = ReactDefaultBatchingStrategy.isBatchingUpdates;91919192ReactDefaultBatchingStrategy.isBatchingUpdates = true;91939194// The code is written this way to avoid extra allocations9195if (alreadyBatchingUpdates) {9196callback(a, b, c, d);9197} else {9198transaction.perform(callback, null, a, b, c, d);9199}9200}9201};92029203module.exports = ReactDefaultBatchingStrategy;92049205},{"103":103,"114":114,"27":27,"87":87}],54:[function(_dereq_,module,exports){9206/**9207* Copyright 2013-2015, Facebook, Inc.9208* All rights reserved.9209*9210* This source code is licensed under the BSD-style license found in the9211* LICENSE file in the root directory of this source tree. An additional grant9212* of patent rights can be found in the PATENTS file in the same directory.9213*9214* @providesModule ReactDefaultInjection9215*/92169217'use strict';92189219var BeforeInputEventPlugin = _dereq_(3);9220var ChangeEventPlugin = _dereq_(7);9221var ClientReactRootIndex = _dereq_(8);9222var DefaultEventPluginOrder = _dereq_(13);9223var EnterLeaveEventPlugin = _dereq_(14);9224var ExecutionEnvironment = _dereq_(21);9225var HTMLDOMPropertyConfig = _dereq_(23);9226var MobileSafariClickEventPlugin = _dereq_(26);9227var ReactBrowserComponentMixin = _dereq_(29);9228var ReactClass = _dereq_(33);9229var ReactComponentBrowserEnvironment =9230_dereq_(35);9231var ReactDefaultBatchingStrategy = _dereq_(53);9232var ReactDOMComponent = _dereq_(42);9233var ReactDOMButton = _dereq_(41);9234var ReactDOMForm = _dereq_(43);9235var ReactDOMImg = _dereq_(46);9236var ReactDOMIDOperations = _dereq_(44);9237var ReactDOMIframe = _dereq_(45);9238var ReactDOMInput = _dereq_(47);9239var ReactDOMOption = _dereq_(48);9240var ReactDOMSelect = _dereq_(49);9241var ReactDOMTextarea = _dereq_(52);9242var ReactDOMTextComponent = _dereq_(51);9243var ReactElement = _dereq_(57);9244var ReactEventListener = _dereq_(62);9245var ReactInjection = _dereq_(64);9246var ReactInstanceHandles = _dereq_(66);9247var ReactMount = _dereq_(70);9248var ReactReconcileTransaction = _dereq_(80);9249var SelectEventPlugin = _dereq_(89);9250var ServerReactRootIndex = _dereq_(90);9251var SimpleEventPlugin = _dereq_(91);9252var SVGDOMPropertyConfig = _dereq_(88);92539254var createFullPageComponent = _dereq_(111);92559256function autoGenerateWrapperClass(type) {9257return ReactClass.createClass({9258tagName: type.toUpperCase(),9259render: function() {9260return new ReactElement(9261type,9262null,9263null,9264null,9265null,9266this.props9267);9268}9269});9270}92719272function inject() {9273ReactInjection.EventEmitter.injectReactEventListener(9274ReactEventListener9275);92769277/**9278* Inject modules for resolving DOM hierarchy and plugin ordering.9279*/9280ReactInjection.EventPluginHub.injectEventPluginOrder(DefaultEventPluginOrder);9281ReactInjection.EventPluginHub.injectInstanceHandle(ReactInstanceHandles);9282ReactInjection.EventPluginHub.injectMount(ReactMount);92839284/**9285* Some important event plugins included by default (without having to require9286* them).9287*/9288ReactInjection.EventPluginHub.injectEventPluginsByName({9289SimpleEventPlugin: SimpleEventPlugin,9290EnterLeaveEventPlugin: EnterLeaveEventPlugin,9291ChangeEventPlugin: ChangeEventPlugin,9292MobileSafariClickEventPlugin: MobileSafariClickEventPlugin,9293SelectEventPlugin: SelectEventPlugin,9294BeforeInputEventPlugin: BeforeInputEventPlugin9295});92969297ReactInjection.NativeComponent.injectGenericComponentClass(9298ReactDOMComponent9299);93009301ReactInjection.NativeComponent.injectTextComponentClass(9302ReactDOMTextComponent9303);93049305ReactInjection.NativeComponent.injectAutoWrapper(9306autoGenerateWrapperClass9307);93089309// This needs to happen before createFullPageComponent() otherwise the mixin9310// won't be included.9311ReactInjection.Class.injectMixin(ReactBrowserComponentMixin);93129313ReactInjection.NativeComponent.injectComponentClasses({9314'button': ReactDOMButton,9315'form': ReactDOMForm,9316'iframe': ReactDOMIframe,9317'img': ReactDOMImg,9318'input': ReactDOMInput,9319'option': ReactDOMOption,9320'select': ReactDOMSelect,9321'textarea': ReactDOMTextarea,93229323'html': createFullPageComponent('html'),9324'head': createFullPageComponent('head'),9325'body': createFullPageComponent('body')9326});93279328ReactInjection.DOMProperty.injectDOMPropertyConfig(HTMLDOMPropertyConfig);9329ReactInjection.DOMProperty.injectDOMPropertyConfig(SVGDOMPropertyConfig);93309331ReactInjection.EmptyComponent.injectEmptyComponent('noscript');93329333ReactInjection.Updates.injectReconcileTransaction(9334ReactReconcileTransaction9335);9336ReactInjection.Updates.injectBatchingStrategy(9337ReactDefaultBatchingStrategy9338);93399340ReactInjection.RootIndex.injectCreateReactRootIndex(9341ExecutionEnvironment.canUseDOM ?9342ClientReactRootIndex.createReactRootIndex :9343ServerReactRootIndex.createReactRootIndex9344);93459346ReactInjection.Component.injectEnvironment(ReactComponentBrowserEnvironment);9347ReactInjection.DOMComponent.injectIDOperations(ReactDOMIDOperations);93489349if ("production" !== "development") {9350var url = (ExecutionEnvironment.canUseDOM && window.location.href) || '';9351if ((/[?&]react_perf\b/).test(url)) {9352var ReactDefaultPerf = _dereq_(55);9353ReactDefaultPerf.start();9354}9355}9356}93579358module.exports = {9359inject: inject9360};93619362},{"111":111,"13":13,"14":14,"21":21,"23":23,"26":26,"29":29,"3":3,"33":33,"35":35,"41":41,"42":42,"43":43,"44":44,"45":45,"46":46,"47":47,"48":48,"49":49,"51":51,"52":52,"53":53,"55":55,"57":57,"62":62,"64":64,"66":66,"7":7,"70":70,"8":8,"80":80,"88":88,"89":89,"90":90,"91":91}],55:[function(_dereq_,module,exports){9363/**9364* Copyright 2013-2015, Facebook, Inc.9365* All rights reserved.9366*9367* This source code is licensed under the BSD-style license found in the9368* LICENSE file in the root directory of this source tree. An additional grant9369* of patent rights can be found in the PATENTS file in the same directory.9370*9371* @providesModule ReactDefaultPerf9372* @typechecks static-only9373*/93749375'use strict';93769377var DOMProperty = _dereq_(10);9378var ReactDefaultPerfAnalysis = _dereq_(56);9379var ReactMount = _dereq_(70);9380var ReactPerf = _dereq_(75);93819382var performanceNow = _dereq_(146);93839384function roundFloat(val) {9385return Math.floor(val * 100) / 100;9386}93879388function addValue(obj, key, val) {9389obj[key] = (obj[key] || 0) + val;9390}93919392var ReactDefaultPerf = {9393_allMeasurements: [], // last item in the list is the current one9394_mountStack: [0],9395_injected: false,93969397start: function() {9398if (!ReactDefaultPerf._injected) {9399ReactPerf.injection.injectMeasure(ReactDefaultPerf.measure);9400}94019402ReactDefaultPerf._allMeasurements.length = 0;9403ReactPerf.enableMeasure = true;9404},94059406stop: function() {9407ReactPerf.enableMeasure = false;9408},94099410getLastMeasurements: function() {9411return ReactDefaultPerf._allMeasurements;9412},94139414printExclusive: function(measurements) {9415measurements = measurements || ReactDefaultPerf._allMeasurements;9416var summary = ReactDefaultPerfAnalysis.getExclusiveSummary(measurements);9417console.table(summary.map(function(item) {9418return {9419'Component class name': item.componentName,9420'Total inclusive time (ms)': roundFloat(item.inclusive),9421'Exclusive mount time (ms)': roundFloat(item.exclusive),9422'Exclusive render time (ms)': roundFloat(item.render),9423'Mount time per instance (ms)': roundFloat(item.exclusive / item.count),9424'Render time per instance (ms)': roundFloat(item.render / item.count),9425'Instances': item.count9426};9427}));9428// TODO: ReactDefaultPerfAnalysis.getTotalTime() does not return the correct9429// number.9430},94319432printInclusive: function(measurements) {9433measurements = measurements || ReactDefaultPerf._allMeasurements;9434var summary = ReactDefaultPerfAnalysis.getInclusiveSummary(measurements);9435console.table(summary.map(function(item) {9436return {9437'Owner > component': item.componentName,9438'Inclusive time (ms)': roundFloat(item.time),9439'Instances': item.count9440};9441}));9442console.log(9443'Total time:',9444ReactDefaultPerfAnalysis.getTotalTime(measurements).toFixed(2) + ' ms'9445);9446},94479448getMeasurementsSummaryMap: function(measurements) {9449var summary = ReactDefaultPerfAnalysis.getInclusiveSummary(9450measurements,9451true9452);9453return summary.map(function(item) {9454return {9455'Owner > component': item.componentName,9456'Wasted time (ms)': item.time,9457'Instances': item.count9458};9459});9460},94619462printWasted: function(measurements) {9463measurements = measurements || ReactDefaultPerf._allMeasurements;9464console.table(ReactDefaultPerf.getMeasurementsSummaryMap(measurements));9465console.log(9466'Total time:',9467ReactDefaultPerfAnalysis.getTotalTime(measurements).toFixed(2) + ' ms'9468);9469},94709471printDOM: function(measurements) {9472measurements = measurements || ReactDefaultPerf._allMeasurements;9473var summary = ReactDefaultPerfAnalysis.getDOMSummary(measurements);9474console.table(summary.map(function(item) {9475var result = {};9476result[DOMProperty.ID_ATTRIBUTE_NAME] = item.id;9477result['type'] = item.type;9478result['args'] = JSON.stringify(item.args);9479return result;9480}));9481console.log(9482'Total time:',9483ReactDefaultPerfAnalysis.getTotalTime(measurements).toFixed(2) + ' ms'9484);9485},94869487_recordWrite: function(id, fnName, totalTime, args) {9488// TODO: totalTime isn't that useful since it doesn't count paints/reflows9489var writes =9490ReactDefaultPerf9491._allMeasurements[ReactDefaultPerf._allMeasurements.length - 1]9492.writes;9493writes[id] = writes[id] || [];9494writes[id].push({9495type: fnName,9496time: totalTime,9497args: args9498});9499},95009501measure: function(moduleName, fnName, func) {9502return function() {for (var args=[],$__0=0,$__1=arguments.length;$__0<$__1;$__0++) args.push(arguments[$__0]);9503var totalTime;9504var rv;9505var start;95069507if (fnName === '_renderNewRootComponent' ||9508fnName === 'flushBatchedUpdates') {9509// A "measurement" is a set of metrics recorded for each flush. We want9510// to group the metrics for a given flush together so we can look at the9511// components that rendered and the DOM operations that actually9512// happened to determine the amount of "wasted work" performed.9513ReactDefaultPerf._allMeasurements.push({9514exclusive: {},9515inclusive: {},9516render: {},9517counts: {},9518writes: {},9519displayNames: {},9520totalTime: 09521});9522start = performanceNow();9523rv = func.apply(this, args);9524ReactDefaultPerf._allMeasurements[9525ReactDefaultPerf._allMeasurements.length - 19526].totalTime = performanceNow() - start;9527return rv;9528} else if (fnName === '_mountImageIntoNode' ||9529moduleName === 'ReactDOMIDOperations') {9530start = performanceNow();9531rv = func.apply(this, args);9532totalTime = performanceNow() - start;95339534if (fnName === '_mountImageIntoNode') {9535var mountID = ReactMount.getID(args[1]);9536ReactDefaultPerf._recordWrite(mountID, fnName, totalTime, args[0]);9537} else if (fnName === 'dangerouslyProcessChildrenUpdates') {9538// special format9539args[0].forEach(function(update) {9540var writeArgs = {};9541if (update.fromIndex !== null) {9542writeArgs.fromIndex = update.fromIndex;9543}9544if (update.toIndex !== null) {9545writeArgs.toIndex = update.toIndex;9546}9547if (update.textContent !== null) {9548writeArgs.textContent = update.textContent;9549}9550if (update.markupIndex !== null) {9551writeArgs.markup = args[1][update.markupIndex];9552}9553ReactDefaultPerf._recordWrite(9554update.parentID,9555update.type,9556totalTime,9557writeArgs9558);9559});9560} else {9561// basic format9562ReactDefaultPerf._recordWrite(9563args[0],9564fnName,9565totalTime,9566Array.prototype.slice.call(args, 1)9567);9568}9569return rv;9570} else if (moduleName === 'ReactCompositeComponent' && (9571(// TODO: receiveComponent()?9572(fnName === 'mountComponent' ||9573fnName === 'updateComponent' || fnName === '_renderValidatedComponent')))) {95749575if (typeof this._currentElement.type === 'string') {9576return func.apply(this, args);9577}95789579var rootNodeID = fnName === 'mountComponent' ?9580args[0] :9581this._rootNodeID;9582var isRender = fnName === '_renderValidatedComponent';9583var isMount = fnName === 'mountComponent';95849585var mountStack = ReactDefaultPerf._mountStack;9586var entry = ReactDefaultPerf._allMeasurements[9587ReactDefaultPerf._allMeasurements.length - 19588];95899590if (isRender) {9591addValue(entry.counts, rootNodeID, 1);9592} else if (isMount) {9593mountStack.push(0);9594}95959596start = performanceNow();9597rv = func.apply(this, args);9598totalTime = performanceNow() - start;95999600if (isRender) {9601addValue(entry.render, rootNodeID, totalTime);9602} else if (isMount) {9603var subMountTime = mountStack.pop();9604mountStack[mountStack.length - 1] += totalTime;9605addValue(entry.exclusive, rootNodeID, totalTime - subMountTime);9606addValue(entry.inclusive, rootNodeID, totalTime);9607} else {9608addValue(entry.inclusive, rootNodeID, totalTime);9609}96109611entry.displayNames[rootNodeID] = {9612current: this.getName(),9613owner: this._currentElement._owner ?9614this._currentElement._owner.getName() :9615'<root>'9616};96179618return rv;9619} else {9620return func.apply(this, args);9621}9622};9623}9624};96259626module.exports = ReactDefaultPerf;96279628},{"10":10,"146":146,"56":56,"70":70,"75":75}],56:[function(_dereq_,module,exports){9629/**9630* Copyright 2013-2015, Facebook, Inc.9631* All rights reserved.9632*9633* This source code is licensed under the BSD-style license found in the9634* LICENSE file in the root directory of this source tree. An additional grant9635* of patent rights can be found in the PATENTS file in the same directory.9636*9637* @providesModule ReactDefaultPerfAnalysis9638*/96399640var assign = _dereq_(27);96419642// Don't try to save users less than 1.2ms (a number I made up)9643var DONT_CARE_THRESHOLD = 1.2;9644var DOM_OPERATION_TYPES = {9645'_mountImageIntoNode': 'set innerHTML',9646INSERT_MARKUP: 'set innerHTML',9647MOVE_EXISTING: 'move',9648REMOVE_NODE: 'remove',9649TEXT_CONTENT: 'set textContent',9650'updatePropertyByID': 'update attribute',9651'deletePropertyByID': 'delete attribute',9652'updateStylesByID': 'update styles',9653'updateInnerHTMLByID': 'set innerHTML',9654'dangerouslyReplaceNodeWithMarkupByID': 'replace'9655};96569657function getTotalTime(measurements) {9658// TODO: return number of DOM ops? could be misleading.9659// TODO: measure dropped frames after reconcile?9660// TODO: log total time of each reconcile and the top-level component9661// class that triggered it.9662var totalTime = 0;9663for (var i = 0; i < measurements.length; i++) {9664var measurement = measurements[i];9665totalTime += measurement.totalTime;9666}9667return totalTime;9668}96699670function getDOMSummary(measurements) {9671var items = [];9672for (var i = 0; i < measurements.length; i++) {9673var measurement = measurements[i];9674var id;96759676for (id in measurement.writes) {9677measurement.writes[id].forEach(function(write) {9678items.push({9679id: id,9680type: DOM_OPERATION_TYPES[write.type] || write.type,9681args: write.args9682});9683});9684}9685}9686return items;9687}96889689function getExclusiveSummary(measurements) {9690var candidates = {};9691var displayName;96929693for (var i = 0; i < measurements.length; i++) {9694var measurement = measurements[i];9695var allIDs = assign(9696{},9697measurement.exclusive,9698measurement.inclusive9699);97009701for (var id in allIDs) {9702displayName = measurement.displayNames[id].current;97039704candidates[displayName] = candidates[displayName] || {9705componentName: displayName,9706inclusive: 0,9707exclusive: 0,9708render: 0,9709count: 09710};9711if (measurement.render[id]) {9712candidates[displayName].render += measurement.render[id];9713}9714if (measurement.exclusive[id]) {9715candidates[displayName].exclusive += measurement.exclusive[id];9716}9717if (measurement.inclusive[id]) {9718candidates[displayName].inclusive += measurement.inclusive[id];9719}9720if (measurement.counts[id]) {9721candidates[displayName].count += measurement.counts[id];9722}9723}9724}97259726// Now make a sorted array with the results.9727var arr = [];9728for (displayName in candidates) {9729if (candidates[displayName].exclusive >= DONT_CARE_THRESHOLD) {9730arr.push(candidates[displayName]);9731}9732}97339734arr.sort(function(a, b) {9735return b.exclusive - a.exclusive;9736});97379738return arr;9739}97409741function getInclusiveSummary(measurements, onlyClean) {9742var candidates = {};9743var inclusiveKey;97449745for (var i = 0; i < measurements.length; i++) {9746var measurement = measurements[i];9747var allIDs = assign(9748{},9749measurement.exclusive,9750measurement.inclusive9751);9752var cleanComponents;97539754if (onlyClean) {9755cleanComponents = getUnchangedComponents(measurement);9756}97579758for (var id in allIDs) {9759if (onlyClean && !cleanComponents[id]) {9760continue;9761}97629763var displayName = measurement.displayNames[id];97649765// Inclusive time is not useful for many components without knowing where9766// they are instantiated. So we aggregate inclusive time with both the9767// owner and current displayName as the key.9768inclusiveKey = displayName.owner + ' > ' + displayName.current;97699770candidates[inclusiveKey] = candidates[inclusiveKey] || {9771componentName: inclusiveKey,9772time: 0,9773count: 09774};97759776if (measurement.inclusive[id]) {9777candidates[inclusiveKey].time += measurement.inclusive[id];9778}9779if (measurement.counts[id]) {9780candidates[inclusiveKey].count += measurement.counts[id];9781}9782}9783}97849785// Now make a sorted array with the results.9786var arr = [];9787for (inclusiveKey in candidates) {9788if (candidates[inclusiveKey].time >= DONT_CARE_THRESHOLD) {9789arr.push(candidates[inclusiveKey]);9790}9791}97929793arr.sort(function(a, b) {9794return b.time - a.time;9795});97969797return arr;9798}97999800function getUnchangedComponents(measurement) {9801// For a given reconcile, look at which components did not actually9802// render anything to the DOM and return a mapping of their ID to9803// the amount of time it took to render the entire subtree.9804var cleanComponents = {};9805var dirtyLeafIDs = Object.keys(measurement.writes);9806var allIDs = assign({}, measurement.exclusive, measurement.inclusive);98079808for (var id in allIDs) {9809var isDirty = false;9810// For each component that rendered, see if a component that triggered9811// a DOM op is in its subtree.9812for (var i = 0; i < dirtyLeafIDs.length; i++) {9813if (dirtyLeafIDs[i].indexOf(id) === 0) {9814isDirty = true;9815break;9816}9817}9818if (!isDirty && measurement.counts[id] > 0) {9819cleanComponents[id] = true;9820}9821}9822return cleanComponents;9823}98249825var ReactDefaultPerfAnalysis = {9826getExclusiveSummary: getExclusiveSummary,9827getInclusiveSummary: getInclusiveSummary,9828getDOMSummary: getDOMSummary,9829getTotalTime: getTotalTime9830};98319832module.exports = ReactDefaultPerfAnalysis;98339834},{"27":27}],57:[function(_dereq_,module,exports){9835/**9836* Copyright 2014-2015, Facebook, Inc.9837* All rights reserved.9838*9839* This source code is licensed under the BSD-style license found in the9840* LICENSE file in the root directory of this source tree. An additional grant9841* of patent rights can be found in the PATENTS file in the same directory.9842*9843* @providesModule ReactElement9844*/98459846'use strict';98479848var ReactContext = _dereq_(38);9849var ReactCurrentOwner = _dereq_(39);98509851var assign = _dereq_(27);9852var warning = _dereq_(154);98539854var RESERVED_PROPS = {9855key: true,9856ref: true9857};98589859/**9860* Warn for mutations.9861*9862* @internal9863* @param {object} object9864* @param {string} key9865*/9866function defineWarningProperty(object, key) {9867Object.defineProperty(object, key, {98689869configurable: false,9870enumerable: true,98719872get: function() {9873if (!this._store) {9874return null;9875}9876return this._store[key];9877},98789879set: function(value) {9880("production" !== "development" ? warning(9881false,9882'Don\'t set the %s property of the React element. Instead, ' +9883'specify the correct value when initially creating the element.',9884key9885) : null);9886this._store[key] = value;9887}98889889});9890}98919892/**9893* This is updated to true if the membrane is successfully created.9894*/9895var useMutationMembrane = false;98969897/**9898* Warn for mutations.9899*9900* @internal9901* @param {object} element9902*/9903function defineMutationMembrane(prototype) {9904try {9905var pseudoFrozenProperties = {9906props: true9907};9908for (var key in pseudoFrozenProperties) {9909defineWarningProperty(prototype, key);9910}9911useMutationMembrane = true;9912} catch (x) {9913// IE will fail on defineProperty9914}9915}99169917/**9918* Base constructor for all React elements. This is only used to make this9919* work with a dynamic instanceof check. Nothing should live on this prototype.9920*9921* @param {*} type9922* @param {string|object} ref9923* @param {*} key9924* @param {*} props9925* @internal9926*/9927var ReactElement = function(type, key, ref, owner, context, props) {9928// Built-in properties that belong on the element9929this.type = type;9930this.key = key;9931this.ref = ref;99329933// Record the component responsible for creating this element.9934this._owner = owner;99359936// TODO: Deprecate withContext, and then the context becomes accessible9937// through the owner.9938this._context = context;99399940if ("production" !== "development") {9941// The validation flag and props are currently mutative. We put them on9942// an external backing store so that we can freeze the whole object.9943// This can be replaced with a WeakMap once they are implemented in9944// commonly used development environments.9945this._store = {props: props, originalProps: assign({}, props)};99469947// To make comparing ReactElements easier for testing purposes, we make9948// the validation flag non-enumerable (where possible, which should9949// include every environment we run tests in), so the test framework9950// ignores it.9951try {9952Object.defineProperty(this._store, 'validated', {9953configurable: false,9954enumerable: false,9955writable: true9956});9957} catch (x) {9958}9959this._store.validated = false;99609961// We're not allowed to set props directly on the object so we early9962// return and rely on the prototype membrane to forward to the backing9963// store.9964if (useMutationMembrane) {9965Object.freeze(this);9966return;9967}9968}99699970this.props = props;9971};99729973// We intentionally don't expose the function on the constructor property.9974// ReactElement should be indistinguishable from a plain object.9975ReactElement.prototype = {9976_isReactElement: true9977};99789979if ("production" !== "development") {9980defineMutationMembrane(ReactElement.prototype);9981}99829983ReactElement.createElement = function(type, config, children) {9984var propName;99859986// Reserved names are extracted9987var props = {};99889989var key = null;9990var ref = null;99919992if (config != null) {9993ref = config.ref === undefined ? null : config.ref;9994key = config.key === undefined ? null : '' + config.key;9995// Remaining properties are added to a new props object9996for (propName in config) {9997if (config.hasOwnProperty(propName) &&9998!RESERVED_PROPS.hasOwnProperty(propName)) {9999props[propName] = config[propName];10000}10001}10002}1000310004// Children can be more than one argument, and those are transferred onto10005// the newly allocated props object.10006var childrenLength = arguments.length - 2;10007if (childrenLength === 1) {10008props.children = children;10009} else if (childrenLength > 1) {10010var childArray = Array(childrenLength);10011for (var i = 0; i < childrenLength; i++) {10012childArray[i] = arguments[i + 2];10013}10014props.children = childArray;10015}1001610017// Resolve default props10018if (type && type.defaultProps) {10019var defaultProps = type.defaultProps;10020for (propName in defaultProps) {10021if (typeof props[propName] === 'undefined') {10022props[propName] = defaultProps[propName];10023}10024}10025}1002610027return new ReactElement(10028type,10029key,10030ref,10031ReactCurrentOwner.current,10032ReactContext.current,10033props10034);10035};1003610037ReactElement.createFactory = function(type) {10038var factory = ReactElement.createElement.bind(null, type);10039// Expose the type on the factory and the prototype so that it can be10040// easily accessed on elements. E.g. <Foo />.type === Foo.type.10041// This should not be named `constructor` since this may not be the function10042// that created the element, and it may not even be a constructor.10043// Legacy hook TODO: Warn if this is accessed10044factory.type = type;10045return factory;10046};1004710048ReactElement.cloneAndReplaceProps = function(oldElement, newProps) {10049var newElement = new ReactElement(10050oldElement.type,10051oldElement.key,10052oldElement.ref,10053oldElement._owner,10054oldElement._context,10055newProps10056);1005710058if ("production" !== "development") {10059// If the key on the original is valid, then the clone is valid10060newElement._store.validated = oldElement._store.validated;10061}10062return newElement;10063};1006410065ReactElement.cloneElement = function(element, config, children) {10066var propName;1006710068// Original props are copied10069var props = assign({}, element.props);1007010071// Reserved names are extracted10072var key = element.key;10073var ref = element.ref;1007410075// Owner will be preserved, unless ref is overridden10076var owner = element._owner;1007710078if (config != null) {10079if (config.ref !== undefined) {10080// Silently steal the ref from the parent.10081ref = config.ref;10082owner = ReactCurrentOwner.current;10083}10084if (config.key !== undefined) {10085key = '' + config.key;10086}10087// Remaining properties override existing props10088for (propName in config) {10089if (config.hasOwnProperty(propName) &&10090!RESERVED_PROPS.hasOwnProperty(propName)) {10091props[propName] = config[propName];10092}10093}10094}1009510096// Children can be more than one argument, and those are transferred onto10097// the newly allocated props object.10098var childrenLength = arguments.length - 2;10099if (childrenLength === 1) {10100props.children = children;10101} else if (childrenLength > 1) {10102var childArray = Array(childrenLength);10103for (var i = 0; i < childrenLength; i++) {10104childArray[i] = arguments[i + 2];10105}10106props.children = childArray;10107}1010810109return new ReactElement(10110element.type,10111key,10112ref,10113owner,10114element._context,10115props10116);10117};1011810119/**10120* @param {?object} object10121* @return {boolean} True if `object` is a valid component.10122* @final10123*/10124ReactElement.isValidElement = function(object) {10125// ReactTestUtils is often used outside of beforeEach where as React is10126// within it. This leads to two different instances of React on the same10127// page. To identify a element from a different React instance we use10128// a flag instead of an instanceof check.10129var isElement = !!(object && object._isReactElement);10130// if (isElement && !(object instanceof ReactElement)) {10131// This is an indicator that you're using multiple versions of React at the10132// same time. This will screw with ownership and stuff. Fix it, please.10133// TODO: We could possibly warn here.10134// }10135return isElement;10136};1013710138module.exports = ReactElement;1013910140},{"154":154,"27":27,"38":38,"39":39}],58:[function(_dereq_,module,exports){10141/**10142* Copyright 2014-2015, Facebook, Inc.10143* All rights reserved.10144*10145* This source code is licensed under the BSD-style license found in the10146* LICENSE file in the root directory of this source tree. An additional grant10147* of patent rights can be found in the PATENTS file in the same directory.10148*10149* @providesModule ReactElementValidator10150*/1015110152/**10153* ReactElementValidator provides a wrapper around a element factory10154* which validates the props passed to the element. This is intended to be10155* used only in DEV and could be replaced by a static type checker for languages10156* that support it.10157*/1015810159'use strict';1016010161var ReactElement = _dereq_(57);10162var ReactFragment = _dereq_(63);10163var ReactPropTypeLocations = _dereq_(77);10164var ReactPropTypeLocationNames = _dereq_(76);10165var ReactCurrentOwner = _dereq_(39);10166var ReactNativeComponent = _dereq_(73);1016710168var getIteratorFn = _dereq_(126);10169var invariant = _dereq_(135);10170var warning = _dereq_(154);1017110172function getDeclarationErrorAddendum() {10173if (ReactCurrentOwner.current) {10174var name = ReactCurrentOwner.current.getName();10175if (name) {10176return ' Check the render method of `' + name + '`.';10177}10178}10179return '';10180}1018110182/**10183* Warn if there's no key explicitly set on dynamic arrays of children or10184* object keys are not valid. This allows us to keep track of children between10185* updates.10186*/10187var ownerHasKeyUseWarning = {};1018810189var loggedTypeFailures = {};1019010191var NUMERIC_PROPERTY_REGEX = /^\d+$/;1019210193/**10194* Gets the instance's name for use in warnings.10195*10196* @internal10197* @return {?string} Display name or undefined10198*/10199function getName(instance) {10200var publicInstance = instance && instance.getPublicInstance();10201if (!publicInstance) {10202return undefined;10203}10204var constructor = publicInstance.constructor;10205if (!constructor) {10206return undefined;10207}10208return constructor.displayName || constructor.name || undefined;10209}1021010211/**10212* Gets the current owner's displayName for use in warnings.10213*10214* @internal10215* @return {?string} Display name or undefined10216*/10217function getCurrentOwnerDisplayName() {10218var current = ReactCurrentOwner.current;10219return (10220current && getName(current) || undefined10221);10222}1022310224/**10225* Warn if the element doesn't have an explicit key assigned to it.10226* This element is in an array. The array could grow and shrink or be10227* reordered. All children that haven't already been validated are required to10228* have a "key" property assigned to it.10229*10230* @internal10231* @param {ReactElement} element Element that requires a key.10232* @param {*} parentType element's parent's type.10233*/10234function validateExplicitKey(element, parentType) {10235if (element._store.validated || element.key != null) {10236return;10237}10238element._store.validated = true;1023910240warnAndMonitorForKeyUse(10241'Each child in an array or iterator should have a unique "key" prop.',10242element,10243parentType10244);10245}1024610247/**10248* Warn if the key is being defined as an object property but has an incorrect10249* value.10250*10251* @internal10252* @param {string} name Property name of the key.10253* @param {ReactElement} element Component that requires a key.10254* @param {*} parentType element's parent's type.10255*/10256function validatePropertyKey(name, element, parentType) {10257if (!NUMERIC_PROPERTY_REGEX.test(name)) {10258return;10259}10260warnAndMonitorForKeyUse(10261'Child objects should have non-numeric keys so ordering is preserved.',10262element,10263parentType10264);10265}1026610267/**10268* Shared warning and monitoring code for the key warnings.10269*10270* @internal10271* @param {string} message The base warning that gets output.10272* @param {ReactElement} element Component that requires a key.10273* @param {*} parentType element's parent's type.10274*/10275function warnAndMonitorForKeyUse(message, element, parentType) {10276var ownerName = getCurrentOwnerDisplayName();10277var parentName = typeof parentType === 'string' ?10278parentType : parentType.displayName || parentType.name;1027910280var useName = ownerName || parentName;10281var memoizer = ownerHasKeyUseWarning[message] || (10282(ownerHasKeyUseWarning[message] = {})10283);10284if (memoizer.hasOwnProperty(useName)) {10285return;10286}10287memoizer[useName] = true;1028810289var parentOrOwnerAddendum =10290ownerName ? (" Check the render method of " + ownerName + ".") :10291parentName ? (" Check the React.render call using <" + parentName + ">.") :10292'';1029310294// Usually the current owner is the offender, but if it accepts children as a10295// property, it may be the creator of the child that's responsible for10296// assigning it a key.10297var childOwnerAddendum = '';10298if (element &&10299element._owner &&10300element._owner !== ReactCurrentOwner.current) {10301// Name of the component that originally created this child.10302var childOwnerName = getName(element._owner);1030310304childOwnerAddendum = (" It was passed a child from " + childOwnerName + ".");10305}1030610307("production" !== "development" ? warning(10308false,10309message + '%s%s See https://fb.me/react-warning-keys for more information.',10310parentOrOwnerAddendum,10311childOwnerAddendum10312) : null);10313}1031410315/**10316* Ensure that every element either is passed in a static location, in an10317* array with an explicit keys property defined, or in an object literal10318* with valid key property.10319*10320* @internal10321* @param {ReactNode} node Statically passed child of any type.10322* @param {*} parentType node's parent's type.10323*/10324function validateChildKeys(node, parentType) {10325if (Array.isArray(node)) {10326for (var i = 0; i < node.length; i++) {10327var child = node[i];10328if (ReactElement.isValidElement(child)) {10329validateExplicitKey(child, parentType);10330}10331}10332} else if (ReactElement.isValidElement(node)) {10333// This element was passed in a valid location.10334node._store.validated = true;10335} else if (node) {10336var iteratorFn = getIteratorFn(node);10337// Entry iterators provide implicit keys.10338if (iteratorFn) {10339if (iteratorFn !== node.entries) {10340var iterator = iteratorFn.call(node);10341var step;10342while (!(step = iterator.next()).done) {10343if (ReactElement.isValidElement(step.value)) {10344validateExplicitKey(step.value, parentType);10345}10346}10347}10348} else if (typeof node === 'object') {10349var fragment = ReactFragment.extractIfFragment(node);10350for (var key in fragment) {10351if (fragment.hasOwnProperty(key)) {10352validatePropertyKey(key, fragment[key], parentType);10353}10354}10355}10356}10357}1035810359/**10360* Assert that the props are valid10361*10362* @param {string} componentName Name of the component for error messages.10363* @param {object} propTypes Map of prop name to a ReactPropType10364* @param {object} props10365* @param {string} location e.g. "prop", "context", "child context"10366* @private10367*/10368function checkPropTypes(componentName, propTypes, props, location) {10369for (var propName in propTypes) {10370if (propTypes.hasOwnProperty(propName)) {10371var error;10372// Prop type validation may throw. In case they do, we don't want to10373// fail the render phase where it didn't fail before. So we log it.10374// After these have been cleaned up, we'll let them throw.10375try {10376// This is intentionally an invariant that gets caught. It's the same10377// behavior as without this statement except with a better message.10378("production" !== "development" ? invariant(10379typeof propTypes[propName] === 'function',10380'%s: %s type `%s` is invalid; it must be a function, usually from ' +10381'React.PropTypes.',10382componentName || 'React class',10383ReactPropTypeLocationNames[location],10384propName10385) : invariant(typeof propTypes[propName] === 'function'));10386error = propTypes[propName](props, propName, componentName, location);10387} catch (ex) {10388error = ex;10389}10390if (error instanceof Error && !(error.message in loggedTypeFailures)) {10391// Only monitor this failure once because there tends to be a lot of the10392// same error.10393loggedTypeFailures[error.message] = true;1039410395var addendum = getDeclarationErrorAddendum(this);10396("production" !== "development" ? warning(false, 'Failed propType: %s%s', error.message, addendum) : null);10397}10398}10399}10400}1040110402var warnedPropsMutations = {};1040310404/**10405* Warn about mutating props when setting `propName` on `element`.10406*10407* @param {string} propName The string key within props that was set10408* @param {ReactElement} element10409*/10410function warnForPropsMutation(propName, element) {10411var type = element.type;10412var elementName = typeof type === 'string' ? type : type.displayName;10413var ownerName = element._owner ?10414element._owner.getPublicInstance().constructor.displayName : null;1041510416var warningKey = propName + '|' + elementName + '|' + ownerName;10417if (warnedPropsMutations.hasOwnProperty(warningKey)) {10418return;10419}10420warnedPropsMutations[warningKey] = true;1042110422var elementInfo = '';10423if (elementName) {10424elementInfo = ' <' + elementName + ' />';10425}10426var ownerInfo = '';10427if (ownerName) {10428ownerInfo = ' The element was created by ' + ownerName + '.';10429}1043010431("production" !== "development" ? warning(10432false,10433'Don\'t set .props.%s of the React component%s. Instead, specify the ' +10434'correct value when initially creating the element or use ' +10435'React.cloneElement to make a new element with updated props.%s',10436propName,10437elementInfo,10438ownerInfo10439) : null);10440}1044110442// Inline Object.is polyfill10443function is(a, b) {10444if (a !== a) {10445// NaN10446return b !== b;10447}10448if (a === 0 && b === 0) {10449// +-010450return 1 / a === 1 / b;10451}10452return a === b;10453}1045410455/**10456* Given an element, check if its props have been mutated since element10457* creation (or the last call to this function). In particular, check if any10458* new props have been added, which we can't directly catch by defining warning10459* properties on the props object.10460*10461* @param {ReactElement} element10462*/10463function checkAndWarnForMutatedProps(element) {10464if (!element._store) {10465// Element was created using `new ReactElement` directly or with10466// `ReactElement.createElement`; skip mutation checking10467return;10468}1046910470var originalProps = element._store.originalProps;10471var props = element.props;1047210473for (var propName in props) {10474if (props.hasOwnProperty(propName)) {10475if (!originalProps.hasOwnProperty(propName) ||10476!is(originalProps[propName], props[propName])) {10477warnForPropsMutation(propName, element);1047810479// Copy over the new value so that the two props objects match again10480originalProps[propName] = props[propName];10481}10482}10483}10484}1048510486/**10487* Given an element, validate that its props follow the propTypes definition,10488* provided by the type.10489*10490* @param {ReactElement} element10491*/10492function validatePropTypes(element) {10493if (element.type == null) {10494// This has already warned. Don't throw.10495return;10496}10497// Extract the component class from the element. Converts string types10498// to a composite class which may have propTypes.10499// TODO: Validating a string's propTypes is not decoupled from the10500// rendering target which is problematic.10501var componentClass = ReactNativeComponent.getComponentClassForElement(10502element10503);10504var name = componentClass.displayName || componentClass.name;10505if (componentClass.propTypes) {10506checkPropTypes(10507name,10508componentClass.propTypes,10509element.props,10510ReactPropTypeLocations.prop10511);10512}10513if (typeof componentClass.getDefaultProps === 'function') {10514("production" !== "development" ? warning(10515componentClass.getDefaultProps.isReactClassApproved,10516'getDefaultProps is only used on classic React.createClass ' +10517'definitions. Use a static property named `defaultProps` instead.'10518) : null);10519}10520}1052110522var ReactElementValidator = {1052310524checkAndWarnForMutatedProps: checkAndWarnForMutatedProps,1052510526createElement: function(type, props, children) {10527// We warn in this case but don't throw. We expect the element creation to10528// succeed and there will likely be errors in render.10529("production" !== "development" ? warning(10530type != null,10531'React.createElement: type should not be null or undefined. It should ' +10532'be a string (for DOM elements) or a ReactClass (for composite ' +10533'components).'10534) : null);1053510536var element = ReactElement.createElement.apply(this, arguments);1053710538// The result can be nullish if a mock or a custom function is used.10539// TODO: Drop this when these are no longer allowed as the type argument.10540if (element == null) {10541return element;10542}1054310544for (var i = 2; i < arguments.length; i++) {10545validateChildKeys(arguments[i], type);10546}1054710548validatePropTypes(element);1054910550return element;10551},1055210553createFactory: function(type) {10554var validatedFactory = ReactElementValidator.createElement.bind(10555null,10556type10557);10558// Legacy hook TODO: Warn if this is accessed10559validatedFactory.type = type;1056010561if ("production" !== "development") {10562try {10563Object.defineProperty(10564validatedFactory,10565'type',10566{10567enumerable: false,10568get: function() {10569("production" !== "development" ? warning(10570false,10571'Factory.type is deprecated. Access the class directly ' +10572'before passing it to createFactory.'10573) : null);10574Object.defineProperty(this, 'type', {10575value: type10576});10577return type;10578}10579}10580);10581} catch (x) {10582// IE will fail on defineProperty (es5-shim/sham too)10583}10584}105851058610587return validatedFactory;10588},1058910590cloneElement: function(element, props, children) {10591var newElement = ReactElement.cloneElement.apply(this, arguments);10592for (var i = 2; i < arguments.length; i++) {10593validateChildKeys(arguments[i], newElement.type);10594}10595validatePropTypes(newElement);10596return newElement;10597}1059810599};1060010601module.exports = ReactElementValidator;1060210603},{"126":126,"135":135,"154":154,"39":39,"57":57,"63":63,"73":73,"76":76,"77":77}],59:[function(_dereq_,module,exports){10604/**10605* Copyright 2014-2015, Facebook, Inc.10606* All rights reserved.10607*10608* This source code is licensed under the BSD-style license found in the10609* LICENSE file in the root directory of this source tree. An additional grant10610* of patent rights can be found in the PATENTS file in the same directory.10611*10612* @providesModule ReactEmptyComponent10613*/1061410615'use strict';1061610617var ReactElement = _dereq_(57);10618var ReactInstanceMap = _dereq_(67);1061910620var invariant = _dereq_(135);1062110622var component;10623// This registry keeps track of the React IDs of the components that rendered to10624// `null` (in reality a placeholder such as `noscript`)10625var nullComponentIDsRegistry = {};1062610627var ReactEmptyComponentInjection = {10628injectEmptyComponent: function(emptyComponent) {10629component = ReactElement.createFactory(emptyComponent);10630}10631};1063210633var ReactEmptyComponentType = function() {};10634ReactEmptyComponentType.prototype.componentDidMount = function() {10635var internalInstance = ReactInstanceMap.get(this);10636// TODO: Make sure we run these methods in the correct order, we shouldn't10637// need this check. We're going to assume if we're here it means we ran10638// componentWillUnmount already so there is no internal instance (it gets10639// removed as part of the unmounting process).10640if (!internalInstance) {10641return;10642}10643registerNullComponentID(internalInstance._rootNodeID);10644};10645ReactEmptyComponentType.prototype.componentWillUnmount = function() {10646var internalInstance = ReactInstanceMap.get(this);10647// TODO: Get rid of this check. See TODO in componentDidMount.10648if (!internalInstance) {10649return;10650}10651deregisterNullComponentID(internalInstance._rootNodeID);10652};10653ReactEmptyComponentType.prototype.render = function() {10654("production" !== "development" ? invariant(10655component,10656'Trying to return null from a render, but no null placeholder component ' +10657'was injected.'10658) : invariant(component));10659return component();10660};1066110662var emptyElement = ReactElement.createElement(ReactEmptyComponentType);1066310664/**10665* Mark the component as having rendered to null.10666* @param {string} id Component's `_rootNodeID`.10667*/10668function registerNullComponentID(id) {10669nullComponentIDsRegistry[id] = true;10670}1067110672/**10673* Unmark the component as having rendered to null: it renders to something now.10674* @param {string} id Component's `_rootNodeID`.10675*/10676function deregisterNullComponentID(id) {10677delete nullComponentIDsRegistry[id];10678}1067910680/**10681* @param {string} id Component's `_rootNodeID`.10682* @return {boolean} True if the component is rendered to null.10683*/10684function isNullComponentID(id) {10685return !!nullComponentIDsRegistry[id];10686}1068710688var ReactEmptyComponent = {10689emptyElement: emptyElement,10690injection: ReactEmptyComponentInjection,10691isNullComponentID: isNullComponentID10692};1069310694module.exports = ReactEmptyComponent;1069510696},{"135":135,"57":57,"67":67}],60:[function(_dereq_,module,exports){10697/**10698* Copyright 2013-2015, Facebook, Inc.10699* All rights reserved.10700*10701* This source code is licensed under the BSD-style license found in the10702* LICENSE file in the root directory of this source tree. An additional grant10703* of patent rights can be found in the PATENTS file in the same directory.10704*10705* @providesModule ReactErrorUtils10706* @typechecks10707*/1070810709"use strict";1071010711var ReactErrorUtils = {10712/**10713* Creates a guarded version of a function. This is supposed to make debugging10714* of event handlers easier. To aid debugging with the browser's debugger,10715* this currently simply returns the original function.10716*10717* @param {function} func Function to be executed10718* @param {string} name The name of the guard10719* @return {function}10720*/10721guard: function(func, name) {10722return func;10723}10724};1072510726module.exports = ReactErrorUtils;1072710728},{}],61:[function(_dereq_,module,exports){10729/**10730* Copyright 2013-2015, Facebook, Inc.10731* All rights reserved.10732*10733* This source code is licensed under the BSD-style license found in the10734* LICENSE file in the root directory of this source tree. An additional grant10735* of patent rights can be found in the PATENTS file in the same directory.10736*10737* @providesModule ReactEventEmitterMixin10738*/1073910740'use strict';1074110742var EventPluginHub = _dereq_(17);1074310744function runEventQueueInBatch(events) {10745EventPluginHub.enqueueEvents(events);10746EventPluginHub.processEventQueue();10747}1074810749var ReactEventEmitterMixin = {1075010751/**10752* Streams a fired top-level event to `EventPluginHub` where plugins have the10753* opportunity to create `ReactEvent`s to be dispatched.10754*10755* @param {string} topLevelType Record from `EventConstants`.10756* @param {object} topLevelTarget The listening component root node.10757* @param {string} topLevelTargetID ID of `topLevelTarget`.10758* @param {object} nativeEvent Native environment event.10759*/10760handleTopLevel: function(10761topLevelType,10762topLevelTarget,10763topLevelTargetID,10764nativeEvent) {10765var events = EventPluginHub.extractEvents(10766topLevelType,10767topLevelTarget,10768topLevelTargetID,10769nativeEvent10770);1077110772runEventQueueInBatch(events);10773}10774};1077510776module.exports = ReactEventEmitterMixin;1077710778},{"17":17}],62:[function(_dereq_,module,exports){10779/**10780* Copyright 2013-2015, Facebook, Inc.10781* All rights reserved.10782*10783* This source code is licensed under the BSD-style license found in the10784* LICENSE file in the root directory of this source tree. An additional grant10785* of patent rights can be found in the PATENTS file in the same directory.10786*10787* @providesModule ReactEventListener10788* @typechecks static-only10789*/1079010791'use strict';1079210793var EventListener = _dereq_(16);10794var ExecutionEnvironment = _dereq_(21);10795var PooledClass = _dereq_(28);10796var ReactInstanceHandles = _dereq_(66);10797var ReactMount = _dereq_(70);10798var ReactUpdates = _dereq_(87);1079910800var assign = _dereq_(27);10801var getEventTarget = _dereq_(125);10802var getUnboundedScrollPosition = _dereq_(131);1080310804/**10805* Finds the parent React component of `node`.10806*10807* @param {*} node10808* @return {?DOMEventTarget} Parent container, or `null` if the specified node10809* is not nested.10810*/10811function findParent(node) {10812// TODO: It may be a good idea to cache this to prevent unnecessary DOM10813// traversal, but caching is difficult to do correctly without using a10814// mutation observer to listen for all DOM changes.10815var nodeID = ReactMount.getID(node);10816var rootID = ReactInstanceHandles.getReactRootIDFromNodeID(nodeID);10817var container = ReactMount.findReactContainerForID(rootID);10818var parent = ReactMount.getFirstReactDOM(container);10819return parent;10820}1082110822// Used to store ancestor hierarchy in top level callback10823function TopLevelCallbackBookKeeping(topLevelType, nativeEvent) {10824this.topLevelType = topLevelType;10825this.nativeEvent = nativeEvent;10826this.ancestors = [];10827}10828assign(TopLevelCallbackBookKeeping.prototype, {10829destructor: function() {10830this.topLevelType = null;10831this.nativeEvent = null;10832this.ancestors.length = 0;10833}10834});10835PooledClass.addPoolingTo(10836TopLevelCallbackBookKeeping,10837PooledClass.twoArgumentPooler10838);1083910840function handleTopLevelImpl(bookKeeping) {10841var topLevelTarget = ReactMount.getFirstReactDOM(10842getEventTarget(bookKeeping.nativeEvent)10843) || window;1084410845// Loop through the hierarchy, in case there's any nested components.10846// It's important that we build the array of ancestors before calling any10847// event handlers, because event handlers can modify the DOM, leading to10848// inconsistencies with ReactMount's node cache. See #1105.10849var ancestor = topLevelTarget;10850while (ancestor) {10851bookKeeping.ancestors.push(ancestor);10852ancestor = findParent(ancestor);10853}1085410855for (var i = 0, l = bookKeeping.ancestors.length; i < l; i++) {10856topLevelTarget = bookKeeping.ancestors[i];10857var topLevelTargetID = ReactMount.getID(topLevelTarget) || '';10858ReactEventListener._handleTopLevel(10859bookKeeping.topLevelType,10860topLevelTarget,10861topLevelTargetID,10862bookKeeping.nativeEvent10863);10864}10865}1086610867function scrollValueMonitor(cb) {10868var scrollPosition = getUnboundedScrollPosition(window);10869cb(scrollPosition);10870}1087110872var ReactEventListener = {10873_enabled: true,10874_handleTopLevel: null,1087510876WINDOW_HANDLE: ExecutionEnvironment.canUseDOM ? window : null,1087710878setHandleTopLevel: function(handleTopLevel) {10879ReactEventListener._handleTopLevel = handleTopLevel;10880},1088110882setEnabled: function(enabled) {10883ReactEventListener._enabled = !!enabled;10884},1088510886isEnabled: function() {10887return ReactEventListener._enabled;10888},108891089010891/**10892* Traps top-level events by using event bubbling.10893*10894* @param {string} topLevelType Record from `EventConstants`.10895* @param {string} handlerBaseName Event name (e.g. "click").10896* @param {object} handle Element on which to attach listener.10897* @return {object} An object with a remove function which will forcefully10898* remove the listener.10899* @internal10900*/10901trapBubbledEvent: function(topLevelType, handlerBaseName, handle) {10902var element = handle;10903if (!element) {10904return null;10905}10906return EventListener.listen(10907element,10908handlerBaseName,10909ReactEventListener.dispatchEvent.bind(null, topLevelType)10910);10911},1091210913/**10914* Traps a top-level event by using event capturing.10915*10916* @param {string} topLevelType Record from `EventConstants`.10917* @param {string} handlerBaseName Event name (e.g. "click").10918* @param {object} handle Element on which to attach listener.10919* @return {object} An object with a remove function which will forcefully10920* remove the listener.10921* @internal10922*/10923trapCapturedEvent: function(topLevelType, handlerBaseName, handle) {10924var element = handle;10925if (!element) {10926return null;10927}10928return EventListener.capture(10929element,10930handlerBaseName,10931ReactEventListener.dispatchEvent.bind(null, topLevelType)10932);10933},1093410935monitorScrollValue: function(refresh) {10936var callback = scrollValueMonitor.bind(null, refresh);10937EventListener.listen(window, 'scroll', callback);10938},1093910940dispatchEvent: function(topLevelType, nativeEvent) {10941if (!ReactEventListener._enabled) {10942return;10943}1094410945var bookKeeping = TopLevelCallbackBookKeeping.getPooled(10946topLevelType,10947nativeEvent10948);10949try {10950// Event queue being processed in the same cycle allows10951// `preventDefault`.10952ReactUpdates.batchedUpdates(handleTopLevelImpl, bookKeeping);10953} finally {10954TopLevelCallbackBookKeeping.release(bookKeeping);10955}10956}10957};1095810959module.exports = ReactEventListener;1096010961},{"125":125,"131":131,"16":16,"21":21,"27":27,"28":28,"66":66,"70":70,"87":87}],63:[function(_dereq_,module,exports){10962/**10963* Copyright 2015, Facebook, Inc.10964* All rights reserved.10965*10966* This source code is licensed under the BSD-style license found in the10967* LICENSE file in the root directory of this source tree. An additional grant10968* of patent rights can be found in the PATENTS file in the same directory.10969*10970* @providesModule ReactFragment10971*/1097210973'use strict';1097410975var ReactElement = _dereq_(57);1097610977var warning = _dereq_(154);1097810979/**10980* We used to allow keyed objects to serve as a collection of ReactElements,10981* or nested sets. This allowed us a way to explicitly key a set a fragment of10982* components. This is now being replaced with an opaque data structure.10983* The upgrade path is to call React.addons.createFragment({ key: value }) to10984* create a keyed fragment. The resulting data structure is opaque, for now.10985*/1098610987if ("production" !== "development") {10988var fragmentKey = '_reactFragment';10989var didWarnKey = '_reactDidWarn';10990var canWarnForReactFragment = false;1099110992try {10993// Feature test. Don't even try to issue this warning if we can't use10994// enumerable: false.1099510996var dummy = function() {10997return 1;10998};1099911000Object.defineProperty(11001{},11002fragmentKey,11003{enumerable: false, value: true}11004);1100511006Object.defineProperty(11007{},11008'key',11009{enumerable: true, get: dummy}11010);1101111012canWarnForReactFragment = true;11013} catch (x) { }1101411015var proxyPropertyAccessWithWarning = function(obj, key) {11016Object.defineProperty(obj, key, {11017enumerable: true,11018get: function() {11019("production" !== "development" ? warning(11020this[didWarnKey],11021'A ReactFragment is an opaque type. Accessing any of its ' +11022'properties is deprecated. Pass it to one of the React.Children ' +11023'helpers.'11024) : null);11025this[didWarnKey] = true;11026return this[fragmentKey][key];11027},11028set: function(value) {11029("production" !== "development" ? warning(11030this[didWarnKey],11031'A ReactFragment is an immutable opaque type. Mutating its ' +11032'properties is deprecated.'11033) : null);11034this[didWarnKey] = true;11035this[fragmentKey][key] = value;11036}11037});11038};1103911040var issuedWarnings = {};1104111042var didWarnForFragment = function(fragment) {11043// We use the keys and the type of the value as a heuristic to dedupe the11044// warning to avoid spamming too much.11045var fragmentCacheKey = '';11046for (var key in fragment) {11047fragmentCacheKey += key + ':' + (typeof fragment[key]) + ',';11048}11049var alreadyWarnedOnce = !!issuedWarnings[fragmentCacheKey];11050issuedWarnings[fragmentCacheKey] = true;11051return alreadyWarnedOnce;11052};11053}1105411055var ReactFragment = {11056// Wrap a keyed object in an opaque proxy that warns you if you access any11057// of its properties.11058create: function(object) {11059if ("production" !== "development") {11060if (typeof object !== 'object' || !object || Array.isArray(object)) {11061("production" !== "development" ? warning(11062false,11063'React.addons.createFragment only accepts a single object.',11064object11065) : null);11066return object;11067}11068if (ReactElement.isValidElement(object)) {11069("production" !== "development" ? warning(11070false,11071'React.addons.createFragment does not accept a ReactElement ' +11072'without a wrapper object.'11073) : null);11074return object;11075}11076if (canWarnForReactFragment) {11077var proxy = {};11078Object.defineProperty(proxy, fragmentKey, {11079enumerable: false,11080value: object11081});11082Object.defineProperty(proxy, didWarnKey, {11083writable: true,11084enumerable: false,11085value: false11086});11087for (var key in object) {11088proxyPropertyAccessWithWarning(proxy, key);11089}11090Object.preventExtensions(proxy);11091return proxy;11092}11093}11094return object;11095},11096// Extract the original keyed object from the fragment opaque type. Warn if11097// a plain object is passed here.11098extract: function(fragment) {11099if ("production" !== "development") {11100if (canWarnForReactFragment) {11101if (!fragment[fragmentKey]) {11102("production" !== "development" ? warning(11103didWarnForFragment(fragment),11104'Any use of a keyed object should be wrapped in ' +11105'React.addons.createFragment(object) before being passed as a ' +11106'child.'11107) : null);11108return fragment;11109}11110return fragment[fragmentKey];11111}11112}11113return fragment;11114},11115// Check if this is a fragment and if so, extract the keyed object. If it11116// is a fragment-like object, warn that it should be wrapped. Ignore if we11117// can't determine what kind of object this is.11118extractIfFragment: function(fragment) {11119if ("production" !== "development") {11120if (canWarnForReactFragment) {11121// If it is the opaque type, return the keyed object.11122if (fragment[fragmentKey]) {11123return fragment[fragmentKey];11124}11125// Otherwise, check each property if it has an element, if it does11126// it is probably meant as a fragment, so we can warn early. Defer,11127// the warning to extract.11128for (var key in fragment) {11129if (fragment.hasOwnProperty(key) &&11130ReactElement.isValidElement(fragment[key])) {11131// This looks like a fragment object, we should provide an11132// early warning.11133return ReactFragment.extract(fragment);11134}11135}11136}11137}11138return fragment;11139}11140};1114111142module.exports = ReactFragment;1114311144},{"154":154,"57":57}],64:[function(_dereq_,module,exports){11145/**11146* Copyright 2013-2015, Facebook, Inc.11147* All rights reserved.11148*11149* This source code is licensed under the BSD-style license found in the11150* LICENSE file in the root directory of this source tree. An additional grant11151* of patent rights can be found in the PATENTS file in the same directory.11152*11153* @providesModule ReactInjection11154*/1115511156'use strict';1115711158var DOMProperty = _dereq_(10);11159var EventPluginHub = _dereq_(17);11160var ReactComponentEnvironment = _dereq_(36);11161var ReactClass = _dereq_(33);11162var ReactEmptyComponent = _dereq_(59);11163var ReactBrowserEventEmitter = _dereq_(30);11164var ReactNativeComponent = _dereq_(73);11165var ReactDOMComponent = _dereq_(42);11166var ReactPerf = _dereq_(75);11167var ReactRootIndex = _dereq_(83);11168var ReactUpdates = _dereq_(87);1116911170var ReactInjection = {11171Component: ReactComponentEnvironment.injection,11172Class: ReactClass.injection,11173DOMComponent: ReactDOMComponent.injection,11174DOMProperty: DOMProperty.injection,11175EmptyComponent: ReactEmptyComponent.injection,11176EventPluginHub: EventPluginHub.injection,11177EventEmitter: ReactBrowserEventEmitter.injection,11178NativeComponent: ReactNativeComponent.injection,11179Perf: ReactPerf.injection,11180RootIndex: ReactRootIndex.injection,11181Updates: ReactUpdates.injection11182};1118311184module.exports = ReactInjection;1118511186},{"10":10,"17":17,"30":30,"33":33,"36":36,"42":42,"59":59,"73":73,"75":75,"83":83,"87":87}],65:[function(_dereq_,module,exports){11187/**11188* Copyright 2013-2015, Facebook, Inc.11189* All rights reserved.11190*11191* This source code is licensed under the BSD-style license found in the11192* LICENSE file in the root directory of this source tree. An additional grant11193* of patent rights can be found in the PATENTS file in the same directory.11194*11195* @providesModule ReactInputSelection11196*/1119711198'use strict';1119911200var ReactDOMSelection = _dereq_(50);1120111202var containsNode = _dereq_(109);11203var focusNode = _dereq_(119);11204var getActiveElement = _dereq_(121);1120511206function isInDocument(node) {11207return containsNode(document.documentElement, node);11208}1120911210/**11211* @ReactInputSelection: React input selection module. Based on Selection.js,11212* but modified to be suitable for react and has a couple of bug fixes (doesn't11213* assume buttons have range selections allowed).11214* Input selection module for React.11215*/11216var ReactInputSelection = {1121711218hasSelectionCapabilities: function(elem) {11219return elem && (11220((elem.nodeName === 'INPUT' && elem.type === 'text') ||11221elem.nodeName === 'TEXTAREA' || elem.contentEditable === 'true')11222);11223},1122411225getSelectionInformation: function() {11226var focusedElem = getActiveElement();11227return {11228focusedElem: focusedElem,11229selectionRange:11230ReactInputSelection.hasSelectionCapabilities(focusedElem) ?11231ReactInputSelection.getSelection(focusedElem) :11232null11233};11234},1123511236/**11237* @restoreSelection: If any selection information was potentially lost,11238* restore it. This is useful when performing operations that could remove dom11239* nodes and place them back in, resulting in focus being lost.11240*/11241restoreSelection: function(priorSelectionInformation) {11242var curFocusedElem = getActiveElement();11243var priorFocusedElem = priorSelectionInformation.focusedElem;11244var priorSelectionRange = priorSelectionInformation.selectionRange;11245if (curFocusedElem !== priorFocusedElem &&11246isInDocument(priorFocusedElem)) {11247if (ReactInputSelection.hasSelectionCapabilities(priorFocusedElem)) {11248ReactInputSelection.setSelection(11249priorFocusedElem,11250priorSelectionRange11251);11252}11253focusNode(priorFocusedElem);11254}11255},1125611257/**11258* @getSelection: Gets the selection bounds of a focused textarea, input or11259* contentEditable node.11260* -@input: Look up selection bounds of this input11261* -@return {start: selectionStart, end: selectionEnd}11262*/11263getSelection: function(input) {11264var selection;1126511266if ('selectionStart' in input) {11267// Modern browser with input or textarea.11268selection = {11269start: input.selectionStart,11270end: input.selectionEnd11271};11272} else if (document.selection && input.nodeName === 'INPUT') {11273// IE8 input.11274var range = document.selection.createRange();11275// There can only be one selection per document in IE, so it must11276// be in our element.11277if (range.parentElement() === input) {11278selection = {11279start: -range.moveStart('character', -input.value.length),11280end: -range.moveEnd('character', -input.value.length)11281};11282}11283} else {11284// Content editable or old IE textarea.11285selection = ReactDOMSelection.getOffsets(input);11286}1128711288return selection || {start: 0, end: 0};11289},1129011291/**11292* @setSelection: Sets the selection bounds of a textarea or input and focuses11293* the input.11294* -@input Set selection bounds of this input or textarea11295* -@offsets Object of same form that is returned from get*11296*/11297setSelection: function(input, offsets) {11298var start = offsets.start;11299var end = offsets.end;11300if (typeof end === 'undefined') {11301end = start;11302}1130311304if ('selectionStart' in input) {11305input.selectionStart = start;11306input.selectionEnd = Math.min(end, input.value.length);11307} else if (document.selection && input.nodeName === 'INPUT') {11308var range = input.createTextRange();11309range.collapse(true);11310range.moveStart('character', start);11311range.moveEnd('character', end - start);11312range.select();11313} else {11314ReactDOMSelection.setOffsets(input, offsets);11315}11316}11317};1131811319module.exports = ReactInputSelection;1132011321},{"109":109,"119":119,"121":121,"50":50}],66:[function(_dereq_,module,exports){11322/**11323* Copyright 2013-2015, Facebook, Inc.11324* All rights reserved.11325*11326* This source code is licensed under the BSD-style license found in the11327* LICENSE file in the root directory of this source tree. An additional grant11328* of patent rights can be found in the PATENTS file in the same directory.11329*11330* @providesModule ReactInstanceHandles11331* @typechecks static-only11332*/1133311334'use strict';1133511336var ReactRootIndex = _dereq_(83);1133711338var invariant = _dereq_(135);1133911340var SEPARATOR = '.';11341var SEPARATOR_LENGTH = SEPARATOR.length;1134211343/**11344* Maximum depth of traversals before we consider the possibility of a bad ID.11345*/11346var MAX_TREE_DEPTH = 100;1134711348/**11349* Creates a DOM ID prefix to use when mounting React components.11350*11351* @param {number} index A unique integer11352* @return {string} React root ID.11353* @internal11354*/11355function getReactRootIDString(index) {11356return SEPARATOR + index.toString(36);11357}1135811359/**11360* Checks if a character in the supplied ID is a separator or the end.11361*11362* @param {string} id A React DOM ID.11363* @param {number} index Index of the character to check.11364* @return {boolean} True if the character is a separator or end of the ID.11365* @private11366*/11367function isBoundary(id, index) {11368return id.charAt(index) === SEPARATOR || index === id.length;11369}1137011371/**11372* Checks if the supplied string is a valid React DOM ID.11373*11374* @param {string} id A React DOM ID, maybe.11375* @return {boolean} True if the string is a valid React DOM ID.11376* @private11377*/11378function isValidID(id) {11379return id === '' || (11380id.charAt(0) === SEPARATOR && id.charAt(id.length - 1) !== SEPARATOR11381);11382}1138311384/**11385* Checks if the first ID is an ancestor of or equal to the second ID.11386*11387* @param {string} ancestorID11388* @param {string} descendantID11389* @return {boolean} True if `ancestorID` is an ancestor of `descendantID`.11390* @internal11391*/11392function isAncestorIDOf(ancestorID, descendantID) {11393return (11394descendantID.indexOf(ancestorID) === 0 &&11395isBoundary(descendantID, ancestorID.length)11396);11397}1139811399/**11400* Gets the parent ID of the supplied React DOM ID, `id`.11401*11402* @param {string} id ID of a component.11403* @return {string} ID of the parent, or an empty string.11404* @private11405*/11406function getParentID(id) {11407return id ? id.substr(0, id.lastIndexOf(SEPARATOR)) : '';11408}1140911410/**11411* Gets the next DOM ID on the tree path from the supplied `ancestorID` to the11412* supplied `destinationID`. If they are equal, the ID is returned.11413*11414* @param {string} ancestorID ID of an ancestor node of `destinationID`.11415* @param {string} destinationID ID of the destination node.11416* @return {string} Next ID on the path from `ancestorID` to `destinationID`.11417* @private11418*/11419function getNextDescendantID(ancestorID, destinationID) {11420("production" !== "development" ? invariant(11421isValidID(ancestorID) && isValidID(destinationID),11422'getNextDescendantID(%s, %s): Received an invalid React DOM ID.',11423ancestorID,11424destinationID11425) : invariant(isValidID(ancestorID) && isValidID(destinationID)));11426("production" !== "development" ? invariant(11427isAncestorIDOf(ancestorID, destinationID),11428'getNextDescendantID(...): React has made an invalid assumption about ' +11429'the DOM hierarchy. Expected `%s` to be an ancestor of `%s`.',11430ancestorID,11431destinationID11432) : invariant(isAncestorIDOf(ancestorID, destinationID)));11433if (ancestorID === destinationID) {11434return ancestorID;11435}11436// Skip over the ancestor and the immediate separator. Traverse until we hit11437// another separator or we reach the end of `destinationID`.11438var start = ancestorID.length + SEPARATOR_LENGTH;11439var i;11440for (i = start; i < destinationID.length; i++) {11441if (isBoundary(destinationID, i)) {11442break;11443}11444}11445return destinationID.substr(0, i);11446}1144711448/**11449* Gets the nearest common ancestor ID of two IDs.11450*11451* Using this ID scheme, the nearest common ancestor ID is the longest common11452* prefix of the two IDs that immediately preceded a "marker" in both strings.11453*11454* @param {string} oneID11455* @param {string} twoID11456* @return {string} Nearest common ancestor ID, or the empty string if none.11457* @private11458*/11459function getFirstCommonAncestorID(oneID, twoID) {11460var minLength = Math.min(oneID.length, twoID.length);11461if (minLength === 0) {11462return '';11463}11464var lastCommonMarkerIndex = 0;11465// Use `<=` to traverse until the "EOL" of the shorter string.11466for (var i = 0; i <= minLength; i++) {11467if (isBoundary(oneID, i) && isBoundary(twoID, i)) {11468lastCommonMarkerIndex = i;11469} else if (oneID.charAt(i) !== twoID.charAt(i)) {11470break;11471}11472}11473var longestCommonID = oneID.substr(0, lastCommonMarkerIndex);11474("production" !== "development" ? invariant(11475isValidID(longestCommonID),11476'getFirstCommonAncestorID(%s, %s): Expected a valid React DOM ID: %s',11477oneID,11478twoID,11479longestCommonID11480) : invariant(isValidID(longestCommonID)));11481return longestCommonID;11482}1148311484/**11485* Traverses the parent path between two IDs (either up or down). The IDs must11486* not be the same, and there must exist a parent path between them. If the11487* callback returns `false`, traversal is stopped.11488*11489* @param {?string} start ID at which to start traversal.11490* @param {?string} stop ID at which to end traversal.11491* @param {function} cb Callback to invoke each ID with.11492* @param {?boolean} skipFirst Whether or not to skip the first node.11493* @param {?boolean} skipLast Whether or not to skip the last node.11494* @private11495*/11496function traverseParentPath(start, stop, cb, arg, skipFirst, skipLast) {11497start = start || '';11498stop = stop || '';11499("production" !== "development" ? invariant(11500start !== stop,11501'traverseParentPath(...): Cannot traverse from and to the same ID, `%s`.',11502start11503) : invariant(start !== stop));11504var traverseUp = isAncestorIDOf(stop, start);11505("production" !== "development" ? invariant(11506traverseUp || isAncestorIDOf(start, stop),11507'traverseParentPath(%s, %s, ...): Cannot traverse from two IDs that do ' +11508'not have a parent path.',11509start,11510stop11511) : invariant(traverseUp || isAncestorIDOf(start, stop)));11512// Traverse from `start` to `stop` one depth at a time.11513var depth = 0;11514var traverse = traverseUp ? getParentID : getNextDescendantID;11515for (var id = start; /* until break */; id = traverse(id, stop)) {11516var ret;11517if ((!skipFirst || id !== start) && (!skipLast || id !== stop)) {11518ret = cb(id, traverseUp, arg);11519}11520if (ret === false || id === stop) {11521// Only break //after// visiting `stop`.11522break;11523}11524("production" !== "development" ? invariant(11525depth++ < MAX_TREE_DEPTH,11526'traverseParentPath(%s, %s, ...): Detected an infinite loop while ' +11527'traversing the React DOM ID tree. This may be due to malformed IDs: %s',11528start, stop11529) : invariant(depth++ < MAX_TREE_DEPTH));11530}11531}1153211533/**11534* Manages the IDs assigned to DOM representations of React components. This11535* uses a specific scheme in order to traverse the DOM efficiently (e.g. in11536* order to simulate events).11537*11538* @internal11539*/11540var ReactInstanceHandles = {1154111542/**11543* Constructs a React root ID11544* @return {string} A React root ID.11545*/11546createReactRootID: function() {11547return getReactRootIDString(ReactRootIndex.createReactRootIndex());11548},1154911550/**11551* Constructs a React ID by joining a root ID with a name.11552*11553* @param {string} rootID Root ID of a parent component.11554* @param {string} name A component's name (as flattened children).11555* @return {string} A React ID.11556* @internal11557*/11558createReactID: function(rootID, name) {11559return rootID + name;11560},1156111562/**11563* Gets the DOM ID of the React component that is the root of the tree that11564* contains the React component with the supplied DOM ID.11565*11566* @param {string} id DOM ID of a React component.11567* @return {?string} DOM ID of the React component that is the root.11568* @internal11569*/11570getReactRootIDFromNodeID: function(id) {11571if (id && id.charAt(0) === SEPARATOR && id.length > 1) {11572var index = id.indexOf(SEPARATOR, 1);11573return index > -1 ? id.substr(0, index) : id;11574}11575return null;11576},1157711578/**11579* Traverses the ID hierarchy and invokes the supplied `cb` on any IDs that11580* should would receive a `mouseEnter` or `mouseLeave` event.11581*11582* NOTE: Does not invoke the callback on the nearest common ancestor because11583* nothing "entered" or "left" that element.11584*11585* @param {string} leaveID ID being left.11586* @param {string} enterID ID being entered.11587* @param {function} cb Callback to invoke on each entered/left ID.11588* @param {*} upArg Argument to invoke the callback with on left IDs.11589* @param {*} downArg Argument to invoke the callback with on entered IDs.11590* @internal11591*/11592traverseEnterLeave: function(leaveID, enterID, cb, upArg, downArg) {11593var ancestorID = getFirstCommonAncestorID(leaveID, enterID);11594if (ancestorID !== leaveID) {11595traverseParentPath(leaveID, ancestorID, cb, upArg, false, true);11596}11597if (ancestorID !== enterID) {11598traverseParentPath(ancestorID, enterID, cb, downArg, true, false);11599}11600},1160111602/**11603* Simulates the traversal of a two-phase, capture/bubble event dispatch.11604*11605* NOTE: This traversal happens on IDs without touching the DOM.11606*11607* @param {string} targetID ID of the target node.11608* @param {function} cb Callback to invoke.11609* @param {*} arg Argument to invoke the callback with.11610* @internal11611*/11612traverseTwoPhase: function(targetID, cb, arg) {11613if (targetID) {11614traverseParentPath('', targetID, cb, arg, true, false);11615traverseParentPath(targetID, '', cb, arg, false, true);11616}11617},1161811619/**11620* Traverse a node ID, calling the supplied `cb` for each ancestor ID. For11621* example, passing `.0.$row-0.1` would result in `cb` getting called11622* with `.0`, `.0.$row-0`, and `.0.$row-0.1`.11623*11624* NOTE: This traversal happens on IDs without touching the DOM.11625*11626* @param {string} targetID ID of the target node.11627* @param {function} cb Callback to invoke.11628* @param {*} arg Argument to invoke the callback with.11629* @internal11630*/11631traverseAncestors: function(targetID, cb, arg) {11632traverseParentPath('', targetID, cb, arg, true, false);11633},1163411635/**11636* Exposed for unit testing.11637* @private11638*/11639_getFirstCommonAncestorID: getFirstCommonAncestorID,1164011641/**11642* Exposed for unit testing.11643* @private11644*/11645_getNextDescendantID: getNextDescendantID,1164611647isAncestorIDOf: isAncestorIDOf,1164811649SEPARATOR: SEPARATOR1165011651};1165211653module.exports = ReactInstanceHandles;1165411655},{"135":135,"83":83}],67:[function(_dereq_,module,exports){11656/**11657* Copyright 2013-2015, Facebook, Inc.11658* All rights reserved.11659*11660* This source code is licensed under the BSD-style license found in the11661* LICENSE file in the root directory of this source tree. An additional grant11662* of patent rights can be found in the PATENTS file in the same directory.11663*11664* @providesModule ReactInstanceMap11665*/1166611667'use strict';1166811669/**11670* `ReactInstanceMap` maintains a mapping from a public facing stateful11671* instance (key) and the internal representation (value). This allows public11672* methods to accept the user facing instance as an argument and map them back11673* to internal methods.11674*/1167511676// TODO: Replace this with ES6: var ReactInstanceMap = new Map();11677var ReactInstanceMap = {1167811679/**11680* This API should be called `delete` but we'd have to make sure to always11681* transform these to strings for IE support. When this transform is fully11682* supported we can rename it.11683*/11684remove: function(key) {11685key._reactInternalInstance = undefined;11686},1168711688get: function(key) {11689return key._reactInternalInstance;11690},1169111692has: function(key) {11693return key._reactInternalInstance !== undefined;11694},1169511696set: function(key, value) {11697key._reactInternalInstance = value;11698}1169911700};1170111702module.exports = ReactInstanceMap;1170311704},{}],68:[function(_dereq_,module,exports){11705/**11706* Copyright 2015, Facebook, Inc.11707* All rights reserved.11708*11709* This source code is licensed under the BSD-style license found in the11710* LICENSE file in the root directory of this source tree. An additional grant11711* of patent rights can be found in the PATENTS file in the same directory.11712*11713* @providesModule ReactLifeCycle11714*/1171511716'use strict';1171711718/**11719* This module manages the bookkeeping when a component is in the process11720* of being mounted or being unmounted. This is used as a way to enforce11721* invariants (or warnings) when it is not recommended to call11722* setState/forceUpdate.11723*11724* currentlyMountingInstance: During the construction phase, it is not possible11725* to trigger an update since the instance is not fully mounted yet. However, we11726* currently allow this as a convenience for mutating the initial state.11727*11728* currentlyUnmountingInstance: During the unmounting phase, the instance is11729* still mounted and can therefore schedule an update. However, this is not11730* recommended and probably an error since it's about to be unmounted.11731* Therefore we still want to trigger in an error for that case.11732*/1173311734var ReactLifeCycle = {11735currentlyMountingInstance: null,11736currentlyUnmountingInstance: null11737};1173811739module.exports = ReactLifeCycle;1174011741},{}],69:[function(_dereq_,module,exports){11742/**11743* Copyright 2013-2015, Facebook, Inc.11744* All rights reserved.11745*11746* This source code is licensed under the BSD-style license found in the11747* LICENSE file in the root directory of this source tree. An additional grant11748* of patent rights can be found in the PATENTS file in the same directory.11749*11750* @providesModule ReactMarkupChecksum11751*/1175211753'use strict';1175411755var adler32 = _dereq_(106);1175611757var ReactMarkupChecksum = {11758CHECKSUM_ATTR_NAME: 'data-react-checksum',1175911760/**11761* @param {string} markup Markup string11762* @return {string} Markup string with checksum attribute attached11763*/11764addChecksumToMarkup: function(markup) {11765var checksum = adler32(markup);11766return markup.replace(11767'>',11768' ' + ReactMarkupChecksum.CHECKSUM_ATTR_NAME + '="' + checksum + '">'11769);11770},1177111772/**11773* @param {string} markup to use11774* @param {DOMElement} element root React element11775* @returns {boolean} whether or not the markup is the same11776*/11777canReuseMarkup: function(markup, element) {11778var existingChecksum = element.getAttribute(11779ReactMarkupChecksum.CHECKSUM_ATTR_NAME11780);11781existingChecksum = existingChecksum && parseInt(existingChecksum, 10);11782var markupChecksum = adler32(markup);11783return markupChecksum === existingChecksum;11784}11785};1178611787module.exports = ReactMarkupChecksum;1178811789},{"106":106}],70:[function(_dereq_,module,exports){11790/**11791* Copyright 2013-2015, Facebook, Inc.11792* All rights reserved.11793*11794* This source code is licensed under the BSD-style license found in the11795* LICENSE file in the root directory of this source tree. An additional grant11796* of patent rights can be found in the PATENTS file in the same directory.11797*11798* @providesModule ReactMount11799*/1180011801'use strict';1180211803var DOMProperty = _dereq_(10);11804var ReactBrowserEventEmitter = _dereq_(30);11805var ReactCurrentOwner = _dereq_(39);11806var ReactElement = _dereq_(57);11807var ReactElementValidator = _dereq_(58);11808var ReactEmptyComponent = _dereq_(59);11809var ReactInstanceHandles = _dereq_(66);11810var ReactInstanceMap = _dereq_(67);11811var ReactMarkupChecksum = _dereq_(69);11812var ReactPerf = _dereq_(75);11813var ReactReconciler = _dereq_(81);11814var ReactUpdateQueue = _dereq_(86);11815var ReactUpdates = _dereq_(87);1181611817var emptyObject = _dereq_(115);11818var containsNode = _dereq_(109);11819var getReactRootElementInContainer = _dereq_(129);11820var instantiateReactComponent = _dereq_(134);11821var invariant = _dereq_(135);11822var setInnerHTML = _dereq_(148);11823var shouldUpdateReactComponent = _dereq_(151);11824var warning = _dereq_(154);1182511826var SEPARATOR = ReactInstanceHandles.SEPARATOR;1182711828var ATTR_NAME = DOMProperty.ID_ATTRIBUTE_NAME;11829var nodeCache = {};1183011831var ELEMENT_NODE_TYPE = 1;11832var DOC_NODE_TYPE = 9;1183311834/** Mapping from reactRootID to React component instance. */11835var instancesByReactRootID = {};1183611837/** Mapping from reactRootID to `container` nodes. */11838var containersByReactRootID = {};1183911840if ("production" !== "development") {11841/** __DEV__-only mapping from reactRootID to root elements. */11842var rootElementsByReactRootID = {};11843}1184411845// Used to store breadth-first search state in findComponentRoot.11846var findComponentRootReusableArray = [];1184711848/**11849* Finds the index of the first character11850* that's not common between the two given strings.11851*11852* @return {number} the index of the character where the strings diverge11853*/11854function firstDifferenceIndex(string1, string2) {11855var minLen = Math.min(string1.length, string2.length);11856for (var i = 0; i < minLen; i++) {11857if (string1.charAt(i) !== string2.charAt(i)) {11858return i;11859}11860}11861return string1.length === string2.length ? -1 : minLen;11862}1186311864/**11865* @param {DOMElement} container DOM element that may contain a React component.11866* @return {?string} A "reactRoot" ID, if a React component is rendered.11867*/11868function getReactRootID(container) {11869var rootElement = getReactRootElementInContainer(container);11870return rootElement && ReactMount.getID(rootElement);11871}1187211873/**11874* Accessing node[ATTR_NAME] or calling getAttribute(ATTR_NAME) on a form11875* element can return its control whose name or ID equals ATTR_NAME. All11876* DOM nodes support `getAttributeNode` but this can also get called on11877* other objects so just return '' if we're given something other than a11878* DOM node (such as window).11879*11880* @param {?DOMElement|DOMWindow|DOMDocument|DOMTextNode} node DOM node.11881* @return {string} ID of the supplied `domNode`.11882*/11883function getID(node) {11884var id = internalGetID(node);11885if (id) {11886if (nodeCache.hasOwnProperty(id)) {11887var cached = nodeCache[id];11888if (cached !== node) {11889("production" !== "development" ? invariant(11890!isValid(cached, id),11891'ReactMount: Two valid but unequal nodes with the same `%s`: %s',11892ATTR_NAME, id11893) : invariant(!isValid(cached, id)));1189411895nodeCache[id] = node;11896}11897} else {11898nodeCache[id] = node;11899}11900}1190111902return id;11903}1190411905function internalGetID(node) {11906// If node is something like a window, document, or text node, none of11907// which support attributes or a .getAttribute method, gracefully return11908// the empty string, as if the attribute were missing.11909return node && node.getAttribute && node.getAttribute(ATTR_NAME) || '';11910}1191111912/**11913* Sets the React-specific ID of the given node.11914*11915* @param {DOMElement} node The DOM node whose ID will be set.11916* @param {string} id The value of the ID attribute.11917*/11918function setID(node, id) {11919var oldID = internalGetID(node);11920if (oldID !== id) {11921delete nodeCache[oldID];11922}11923node.setAttribute(ATTR_NAME, id);11924nodeCache[id] = node;11925}1192611927/**11928* Finds the node with the supplied React-generated DOM ID.11929*11930* @param {string} id A React-generated DOM ID.11931* @return {DOMElement} DOM node with the suppled `id`.11932* @internal11933*/11934function getNode(id) {11935if (!nodeCache.hasOwnProperty(id) || !isValid(nodeCache[id], id)) {11936nodeCache[id] = ReactMount.findReactNodeByID(id);11937}11938return nodeCache[id];11939}1194011941/**11942* Finds the node with the supplied public React instance.11943*11944* @param {*} instance A public React instance.11945* @return {?DOMElement} DOM node with the suppled `id`.11946* @internal11947*/11948function getNodeFromInstance(instance) {11949var id = ReactInstanceMap.get(instance)._rootNodeID;11950if (ReactEmptyComponent.isNullComponentID(id)) {11951return null;11952}11953if (!nodeCache.hasOwnProperty(id) || !isValid(nodeCache[id], id)) {11954nodeCache[id] = ReactMount.findReactNodeByID(id);11955}11956return nodeCache[id];11957}1195811959/**11960* A node is "valid" if it is contained by a currently mounted container.11961*11962* This means that the node does not have to be contained by a document in11963* order to be considered valid.11964*11965* @param {?DOMElement} node The candidate DOM node.11966* @param {string} id The expected ID of the node.11967* @return {boolean} Whether the node is contained by a mounted container.11968*/11969function isValid(node, id) {11970if (node) {11971("production" !== "development" ? invariant(11972internalGetID(node) === id,11973'ReactMount: Unexpected modification of `%s`',11974ATTR_NAME11975) : invariant(internalGetID(node) === id));1197611977var container = ReactMount.findReactContainerForID(id);11978if (container && containsNode(container, node)) {11979return true;11980}11981}1198211983return false;11984}1198511986/**11987* Causes the cache to forget about one React-specific ID.11988*11989* @param {string} id The ID to forget.11990*/11991function purgeID(id) {11992delete nodeCache[id];11993}1199411995var deepestNodeSoFar = null;11996function findDeepestCachedAncestorImpl(ancestorID) {11997var ancestor = nodeCache[ancestorID];11998if (ancestor && isValid(ancestor, ancestorID)) {11999deepestNodeSoFar = ancestor;12000} else {12001// This node isn't populated in the cache, so presumably none of its12002// descendants are. Break out of the loop.12003return false;12004}12005}1200612007/**12008* Return the deepest cached node whose ID is a prefix of `targetID`.12009*/12010function findDeepestCachedAncestor(targetID) {12011deepestNodeSoFar = null;12012ReactInstanceHandles.traverseAncestors(12013targetID,12014findDeepestCachedAncestorImpl12015);1201612017var foundNode = deepestNodeSoFar;12018deepestNodeSoFar = null;12019return foundNode;12020}1202112022/**12023* Mounts this component and inserts it into the DOM.12024*12025* @param {ReactComponent} componentInstance The instance to mount.12026* @param {string} rootID DOM ID of the root node.12027* @param {DOMElement} container DOM element to mount into.12028* @param {ReactReconcileTransaction} transaction12029* @param {boolean} shouldReuseMarkup If true, do not insert markup12030*/12031function mountComponentIntoNode(12032componentInstance,12033rootID,12034container,12035transaction,12036shouldReuseMarkup) {12037var markup = ReactReconciler.mountComponent(12038componentInstance, rootID, transaction, emptyObject12039);12040componentInstance._isTopLevel = true;12041ReactMount._mountImageIntoNode(markup, container, shouldReuseMarkup);12042}1204312044/**12045* Batched mount.12046*12047* @param {ReactComponent} componentInstance The instance to mount.12048* @param {string} rootID DOM ID of the root node.12049* @param {DOMElement} container DOM element to mount into.12050* @param {boolean} shouldReuseMarkup If true, do not insert markup12051*/12052function batchedMountComponentIntoNode(12053componentInstance,12054rootID,12055container,12056shouldReuseMarkup) {12057var transaction = ReactUpdates.ReactReconcileTransaction.getPooled();12058transaction.perform(12059mountComponentIntoNode,12060null,12061componentInstance,12062rootID,12063container,12064transaction,12065shouldReuseMarkup12066);12067ReactUpdates.ReactReconcileTransaction.release(transaction);12068}1206912070/**12071* Mounting is the process of initializing a React component by creating its12072* representative DOM elements and inserting them into a supplied `container`.12073* Any prior content inside `container` is destroyed in the process.12074*12075* ReactMount.render(12076* component,12077* document.getElementById('container')12078* );12079*12080* <div id="container"> <-- Supplied `container`.12081* <div data-reactid=".3"> <-- Rendered reactRoot of React12082* // ... component.12083* </div>12084* </div>12085*12086* Inside of `container`, the first element rendered is the "reactRoot".12087*/12088var ReactMount = {12089/** Exposed for debugging purposes **/12090_instancesByReactRootID: instancesByReactRootID,1209112092/**12093* This is a hook provided to support rendering React components while12094* ensuring that the apparent scroll position of its `container` does not12095* change.12096*12097* @param {DOMElement} container The `container` being rendered into.12098* @param {function} renderCallback This must be called once to do the render.12099*/12100scrollMonitor: function(container, renderCallback) {12101renderCallback();12102},1210312104/**12105* Take a component that's already mounted into the DOM and replace its props12106* @param {ReactComponent} prevComponent component instance already in the DOM12107* @param {ReactElement} nextElement component instance to render12108* @param {DOMElement} container container to render into12109* @param {?function} callback function triggered on completion12110*/12111_updateRootComponent: function(12112prevComponent,12113nextElement,12114container,12115callback) {12116if ("production" !== "development") {12117ReactElementValidator.checkAndWarnForMutatedProps(nextElement);12118}1211912120ReactMount.scrollMonitor(container, function() {12121ReactUpdateQueue.enqueueElementInternal(prevComponent, nextElement);12122if (callback) {12123ReactUpdateQueue.enqueueCallbackInternal(prevComponent, callback);12124}12125});1212612127if ("production" !== "development") {12128// Record the root element in case it later gets transplanted.12129rootElementsByReactRootID[getReactRootID(container)] =12130getReactRootElementInContainer(container);12131}1213212133return prevComponent;12134},1213512136/**12137* Register a component into the instance map and starts scroll value12138* monitoring12139* @param {ReactComponent} nextComponent component instance to render12140* @param {DOMElement} container container to render into12141* @return {string} reactRoot ID prefix12142*/12143_registerComponent: function(nextComponent, container) {12144("production" !== "development" ? invariant(12145container && (12146(container.nodeType === ELEMENT_NODE_TYPE || container.nodeType === DOC_NODE_TYPE)12147),12148'_registerComponent(...): Target container is not a DOM element.'12149) : invariant(container && (12150(container.nodeType === ELEMENT_NODE_TYPE || container.nodeType === DOC_NODE_TYPE)12151)));1215212153ReactBrowserEventEmitter.ensureScrollValueMonitoring();1215412155var reactRootID = ReactMount.registerContainer(container);12156instancesByReactRootID[reactRootID] = nextComponent;12157return reactRootID;12158},1215912160/**12161* Render a new component into the DOM.12162* @param {ReactElement} nextElement element to render12163* @param {DOMElement} container container to render into12164* @param {boolean} shouldReuseMarkup if we should skip the markup insertion12165* @return {ReactComponent} nextComponent12166*/12167_renderNewRootComponent: function(12168nextElement,12169container,12170shouldReuseMarkup12171) {12172// Various parts of our code (such as ReactCompositeComponent's12173// _renderValidatedComponent) assume that calls to render aren't nested;12174// verify that that's the case.12175("production" !== "development" ? warning(12176ReactCurrentOwner.current == null,12177'_renderNewRootComponent(): Render methods should be a pure function ' +12178'of props and state; triggering nested component updates from ' +12179'render is not allowed. If necessary, trigger nested updates in ' +12180'componentDidUpdate.'12181) : null);1218212183var componentInstance = instantiateReactComponent(nextElement, null);12184var reactRootID = ReactMount._registerComponent(12185componentInstance,12186container12187);1218812189// The initial render is synchronous but any updates that happen during12190// rendering, in componentWillMount or componentDidMount, will be batched12191// according to the current batching strategy.1219212193ReactUpdates.batchedUpdates(12194batchedMountComponentIntoNode,12195componentInstance,12196reactRootID,12197container,12198shouldReuseMarkup12199);1220012201if ("production" !== "development") {12202// Record the root element in case it later gets transplanted.12203rootElementsByReactRootID[reactRootID] =12204getReactRootElementInContainer(container);12205}1220612207return componentInstance;12208},1220912210/**12211* Renders a React component into the DOM in the supplied `container`.12212*12213* If the React component was previously rendered into `container`, this will12214* perform an update on it and only mutate the DOM as necessary to reflect the12215* latest React component.12216*12217* @param {ReactElement} nextElement Component element to render.12218* @param {DOMElement} container DOM element to render into.12219* @param {?function} callback function triggered on completion12220* @return {ReactComponent} Component instance rendered in `container`.12221*/12222render: function(nextElement, container, callback) {12223("production" !== "development" ? invariant(12224ReactElement.isValidElement(nextElement),12225'React.render(): Invalid component element.%s',12226(12227typeof nextElement === 'string' ?12228' Instead of passing an element string, make sure to instantiate ' +12229'it by passing it to React.createElement.' :12230typeof nextElement === 'function' ?12231' Instead of passing a component class, make sure to instantiate ' +12232'it by passing it to React.createElement.' :12233// Check if it quacks like an element12234nextElement != null && nextElement.props !== undefined ?12235' This may be caused by unintentionally loading two independent ' +12236'copies of React.' :12237''12238)12239) : invariant(ReactElement.isValidElement(nextElement)));1224012241var prevComponent = instancesByReactRootID[getReactRootID(container)];1224212243if (prevComponent) {12244var prevElement = prevComponent._currentElement;12245if (shouldUpdateReactComponent(prevElement, nextElement)) {12246return ReactMount._updateRootComponent(12247prevComponent,12248nextElement,12249container,12250callback12251).getPublicInstance();12252} else {12253ReactMount.unmountComponentAtNode(container);12254}12255}1225612257var reactRootElement = getReactRootElementInContainer(container);12258var containerHasReactMarkup =12259reactRootElement && ReactMount.isRenderedByReact(reactRootElement);1226012261if ("production" !== "development") {12262if (!containerHasReactMarkup || reactRootElement.nextSibling) {12263var rootElementSibling = reactRootElement;12264while (rootElementSibling) {12265if (ReactMount.isRenderedByReact(rootElementSibling)) {12266("production" !== "development" ? warning(12267false,12268'render(): Target node has markup rendered by React, but there ' +12269'are unrelated nodes as well. This is most commonly caused by ' +12270'white-space inserted around server-rendered markup.'12271) : null);12272break;12273}1227412275rootElementSibling = rootElementSibling.nextSibling;12276}12277}12278}1227912280var shouldReuseMarkup = containerHasReactMarkup && !prevComponent;1228112282var component = ReactMount._renderNewRootComponent(12283nextElement,12284container,12285shouldReuseMarkup12286).getPublicInstance();12287if (callback) {12288callback.call(component);12289}12290return component;12291},1229212293/**12294* Constructs a component instance of `constructor` with `initialProps` and12295* renders it into the supplied `container`.12296*12297* @param {function} constructor React component constructor.12298* @param {?object} props Initial props of the component instance.12299* @param {DOMElement} container DOM element to render into.12300* @return {ReactComponent} Component instance rendered in `container`.12301*/12302constructAndRenderComponent: function(constructor, props, container) {12303var element = ReactElement.createElement(constructor, props);12304return ReactMount.render(element, container);12305},1230612307/**12308* Constructs a component instance of `constructor` with `initialProps` and12309* renders it into a container node identified by supplied `id`.12310*12311* @param {function} componentConstructor React component constructor12312* @param {?object} props Initial props of the component instance.12313* @param {string} id ID of the DOM element to render into.12314* @return {ReactComponent} Component instance rendered in the container node.12315*/12316constructAndRenderComponentByID: function(constructor, props, id) {12317var domNode = document.getElementById(id);12318("production" !== "development" ? invariant(12319domNode,12320'Tried to get element with id of "%s" but it is not present on the page.',12321id12322) : invariant(domNode));12323return ReactMount.constructAndRenderComponent(constructor, props, domNode);12324},1232512326/**12327* Registers a container node into which React components will be rendered.12328* This also creates the "reactRoot" ID that will be assigned to the element12329* rendered within.12330*12331* @param {DOMElement} container DOM element to register as a container.12332* @return {string} The "reactRoot" ID of elements rendered within.12333*/12334registerContainer: function(container) {12335var reactRootID = getReactRootID(container);12336if (reactRootID) {12337// If one exists, make sure it is a valid "reactRoot" ID.12338reactRootID = ReactInstanceHandles.getReactRootIDFromNodeID(reactRootID);12339}12340if (!reactRootID) {12341// No valid "reactRoot" ID found, create one.12342reactRootID = ReactInstanceHandles.createReactRootID();12343}12344containersByReactRootID[reactRootID] = container;12345return reactRootID;12346},1234712348/**12349* Unmounts and destroys the React component rendered in the `container`.12350*12351* @param {DOMElement} container DOM element containing a React component.12352* @return {boolean} True if a component was found in and unmounted from12353* `container`12354*/12355unmountComponentAtNode: function(container) {12356// Various parts of our code (such as ReactCompositeComponent's12357// _renderValidatedComponent) assume that calls to render aren't nested;12358// verify that that's the case. (Strictly speaking, unmounting won't cause a12359// render but we still don't expect to be in a render call here.)12360("production" !== "development" ? warning(12361ReactCurrentOwner.current == null,12362'unmountComponentAtNode(): Render methods should be a pure function of ' +12363'props and state; triggering nested component updates from render is ' +12364'not allowed. If necessary, trigger nested updates in ' +12365'componentDidUpdate.'12366) : null);1236712368("production" !== "development" ? invariant(12369container && (12370(container.nodeType === ELEMENT_NODE_TYPE || container.nodeType === DOC_NODE_TYPE)12371),12372'unmountComponentAtNode(...): Target container is not a DOM element.'12373) : invariant(container && (12374(container.nodeType === ELEMENT_NODE_TYPE || container.nodeType === DOC_NODE_TYPE)12375)));1237612377var reactRootID = getReactRootID(container);12378var component = instancesByReactRootID[reactRootID];12379if (!component) {12380return false;12381}12382ReactMount.unmountComponentFromNode(component, container);12383delete instancesByReactRootID[reactRootID];12384delete containersByReactRootID[reactRootID];12385if ("production" !== "development") {12386delete rootElementsByReactRootID[reactRootID];12387}12388return true;12389},1239012391/**12392* Unmounts a component and removes it from the DOM.12393*12394* @param {ReactComponent} instance React component instance.12395* @param {DOMElement} container DOM element to unmount from.12396* @final12397* @internal12398* @see {ReactMount.unmountComponentAtNode}12399*/12400unmountComponentFromNode: function(instance, container) {12401ReactReconciler.unmountComponent(instance);1240212403if (container.nodeType === DOC_NODE_TYPE) {12404container = container.documentElement;12405}1240612407// http://jsperf.com/emptying-a-node12408while (container.lastChild) {12409container.removeChild(container.lastChild);12410}12411},1241212413/**12414* Finds the container DOM element that contains React component to which the12415* supplied DOM `id` belongs.12416*12417* @param {string} id The ID of an element rendered by a React component.12418* @return {?DOMElement} DOM element that contains the `id`.12419*/12420findReactContainerForID: function(id) {12421var reactRootID = ReactInstanceHandles.getReactRootIDFromNodeID(id);12422var container = containersByReactRootID[reactRootID];1242312424if ("production" !== "development") {12425var rootElement = rootElementsByReactRootID[reactRootID];12426if (rootElement && rootElement.parentNode !== container) {12427("production" !== "development" ? invariant(12428// Call internalGetID here because getID calls isValid which calls12429// findReactContainerForID (this function).12430internalGetID(rootElement) === reactRootID,12431'ReactMount: Root element ID differed from reactRootID.'12432) : invariant(// Call internalGetID here because getID calls isValid which calls12433// findReactContainerForID (this function).12434internalGetID(rootElement) === reactRootID));1243512436var containerChild = container.firstChild;12437if (containerChild &&12438reactRootID === internalGetID(containerChild)) {12439// If the container has a new child with the same ID as the old12440// root element, then rootElementsByReactRootID[reactRootID] is12441// just stale and needs to be updated. The case that deserves a12442// warning is when the container is empty.12443rootElementsByReactRootID[reactRootID] = containerChild;12444} else {12445("production" !== "development" ? warning(12446false,12447'ReactMount: Root element has been removed from its original ' +12448'container. New container:', rootElement.parentNode12449) : null);12450}12451}12452}1245312454return container;12455},1245612457/**12458* Finds an element rendered by React with the supplied ID.12459*12460* @param {string} id ID of a DOM node in the React component.12461* @return {DOMElement} Root DOM node of the React component.12462*/12463findReactNodeByID: function(id) {12464var reactRoot = ReactMount.findReactContainerForID(id);12465return ReactMount.findComponentRoot(reactRoot, id);12466},1246712468/**12469* True if the supplied `node` is rendered by React.12470*12471* @param {*} node DOM Element to check.12472* @return {boolean} True if the DOM Element appears to be rendered by React.12473* @internal12474*/12475isRenderedByReact: function(node) {12476if (node.nodeType !== 1) {12477// Not a DOMElement, therefore not a React component12478return false;12479}12480var id = ReactMount.getID(node);12481return id ? id.charAt(0) === SEPARATOR : false;12482},1248312484/**12485* Traverses up the ancestors of the supplied node to find a node that is a12486* DOM representation of a React component.12487*12488* @param {*} node12489* @return {?DOMEventTarget}12490* @internal12491*/12492getFirstReactDOM: function(node) {12493var current = node;12494while (current && current.parentNode !== current) {12495if (ReactMount.isRenderedByReact(current)) {12496return current;12497}12498current = current.parentNode;12499}12500return null;12501},1250212503/**12504* Finds a node with the supplied `targetID` inside of the supplied12505* `ancestorNode`. Exploits the ID naming scheme to perform the search12506* quickly.12507*12508* @param {DOMEventTarget} ancestorNode Search from this root.12509* @pararm {string} targetID ID of the DOM representation of the component.12510* @return {DOMEventTarget} DOM node with the supplied `targetID`.12511* @internal12512*/12513findComponentRoot: function(ancestorNode, targetID) {12514var firstChildren = findComponentRootReusableArray;12515var childIndex = 0;1251612517var deepestAncestor = findDeepestCachedAncestor(targetID) || ancestorNode;1251812519firstChildren[0] = deepestAncestor.firstChild;12520firstChildren.length = 1;1252112522while (childIndex < firstChildren.length) {12523var child = firstChildren[childIndex++];12524var targetChild;1252512526while (child) {12527var childID = ReactMount.getID(child);12528if (childID) {12529// Even if we find the node we're looking for, we finish looping12530// through its siblings to ensure they're cached so that we don't have12531// to revisit this node again. Otherwise, we make n^2 calls to getID12532// when visiting the many children of a single node in order.1253312534if (targetID === childID) {12535targetChild = child;12536} else if (ReactInstanceHandles.isAncestorIDOf(childID, targetID)) {12537// If we find a child whose ID is an ancestor of the given ID,12538// then we can be sure that we only want to search the subtree12539// rooted at this child, so we can throw out the rest of the12540// search state.12541firstChildren.length = childIndex = 0;12542firstChildren.push(child.firstChild);12543}1254412545} else {12546// If this child had no ID, then there's a chance that it was12547// injected automatically by the browser, as when a `<table>`12548// element sprouts an extra `<tbody>` child as a side effect of12549// `.innerHTML` parsing. Optimistically continue down this12550// branch, but not before examining the other siblings.12551firstChildren.push(child.firstChild);12552}1255312554child = child.nextSibling;12555}1255612557if (targetChild) {12558// Emptying firstChildren/findComponentRootReusableArray is12559// not necessary for correctness, but it helps the GC reclaim12560// any nodes that were left at the end of the search.12561firstChildren.length = 0;1256212563return targetChild;12564}12565}1256612567firstChildren.length = 0;1256812569("production" !== "development" ? invariant(12570false,12571'findComponentRoot(..., %s): Unable to find element. This probably ' +12572'means the DOM was unexpectedly mutated (e.g., by the browser), ' +12573'usually due to forgetting a <tbody> when using tables, nesting tags ' +12574'like <form>, <p>, or <a>, or using non-SVG elements in an <svg> ' +12575'parent. ' +12576'Try inspecting the child nodes of the element with React ID `%s`.',12577targetID,12578ReactMount.getID(ancestorNode)12579) : invariant(false));12580},1258112582_mountImageIntoNode: function(markup, container, shouldReuseMarkup) {12583("production" !== "development" ? invariant(12584container && (12585(container.nodeType === ELEMENT_NODE_TYPE || container.nodeType === DOC_NODE_TYPE)12586),12587'mountComponentIntoNode(...): Target container is not valid.'12588) : invariant(container && (12589(container.nodeType === ELEMENT_NODE_TYPE || container.nodeType === DOC_NODE_TYPE)12590)));1259112592if (shouldReuseMarkup) {12593var rootElement = getReactRootElementInContainer(container);12594if (ReactMarkupChecksum.canReuseMarkup(markup, rootElement)) {12595return;12596} else {12597var checksum = rootElement.getAttribute(12598ReactMarkupChecksum.CHECKSUM_ATTR_NAME12599);12600rootElement.removeAttribute(ReactMarkupChecksum.CHECKSUM_ATTR_NAME);1260112602var rootMarkup = rootElement.outerHTML;12603rootElement.setAttribute(12604ReactMarkupChecksum.CHECKSUM_ATTR_NAME,12605checksum12606);1260712608var diffIndex = firstDifferenceIndex(markup, rootMarkup);12609var difference = ' (client) ' +12610markup.substring(diffIndex - 20, diffIndex + 20) +12611'\n (server) ' + rootMarkup.substring(diffIndex - 20, diffIndex + 20);1261212613("production" !== "development" ? invariant(12614container.nodeType !== DOC_NODE_TYPE,12615'You\'re trying to render a component to the document using ' +12616'server rendering but the checksum was invalid. This usually ' +12617'means you rendered a different component type or props on ' +12618'the client from the one on the server, or your render() ' +12619'methods are impure. React cannot handle this case due to ' +12620'cross-browser quirks by rendering at the document root. You ' +12621'should look for environment dependent code in your components ' +12622'and ensure the props are the same client and server side:\n%s',12623difference12624) : invariant(container.nodeType !== DOC_NODE_TYPE));1262512626if ("production" !== "development") {12627("production" !== "development" ? warning(12628false,12629'React attempted to reuse markup in a container but the ' +12630'checksum was invalid. This generally means that you are ' +12631'using server rendering and the markup generated on the ' +12632'server was not what the client was expecting. React injected ' +12633'new markup to compensate which works but you have lost many ' +12634'of the benefits of server rendering. Instead, figure out ' +12635'why the markup being generated is different on the client ' +12636'or server:\n%s',12637difference12638) : null);12639}12640}12641}1264212643("production" !== "development" ? invariant(12644container.nodeType !== DOC_NODE_TYPE,12645'You\'re trying to render a component to the document but ' +12646'you didn\'t use server rendering. We can\'t do this ' +12647'without using server rendering due to cross-browser quirks. ' +12648'See React.renderToString() for server rendering.'12649) : invariant(container.nodeType !== DOC_NODE_TYPE));1265012651setInnerHTML(container, markup);12652},1265312654/**12655* React ID utilities.12656*/1265712658getReactRootID: getReactRootID,1265912660getID: getID,1266112662setID: setID,1266312664getNode: getNode,1266512666getNodeFromInstance: getNodeFromInstance,1266712668purgeID: purgeID12669};1267012671ReactPerf.measureMethods(ReactMount, 'ReactMount', {12672_renderNewRootComponent: '_renderNewRootComponent',12673_mountImageIntoNode: '_mountImageIntoNode'12674});1267512676module.exports = ReactMount;1267712678},{"10":10,"109":109,"115":115,"129":129,"134":134,"135":135,"148":148,"151":151,"154":154,"30":30,"39":39,"57":57,"58":58,"59":59,"66":66,"67":67,"69":69,"75":75,"81":81,"86":86,"87":87}],71:[function(_dereq_,module,exports){12679/**12680* Copyright 2013-2015, Facebook, Inc.12681* All rights reserved.12682*12683* This source code is licensed under the BSD-style license found in the12684* LICENSE file in the root directory of this source tree. An additional grant12685* of patent rights can be found in the PATENTS file in the same directory.12686*12687* @providesModule ReactMultiChild12688* @typechecks static-only12689*/1269012691'use strict';1269212693var ReactComponentEnvironment = _dereq_(36);12694var ReactMultiChildUpdateTypes = _dereq_(72);1269512696var ReactReconciler = _dereq_(81);12697var ReactChildReconciler = _dereq_(31);1269812699/**12700* Updating children of a component may trigger recursive updates. The depth is12701* used to batch recursive updates to render markup more efficiently.12702*12703* @type {number}12704* @private12705*/12706var updateDepth = 0;1270712708/**12709* Queue of update configuration objects.12710*12711* Each object has a `type` property that is in `ReactMultiChildUpdateTypes`.12712*12713* @type {array<object>}12714* @private12715*/12716var updateQueue = [];1271712718/**12719* Queue of markup to be rendered.12720*12721* @type {array<string>}12722* @private12723*/12724var markupQueue = [];1272512726/**12727* Enqueues markup to be rendered and inserted at a supplied index.12728*12729* @param {string} parentID ID of the parent component.12730* @param {string} markup Markup that renders into an element.12731* @param {number} toIndex Destination index.12732* @private12733*/12734function enqueueMarkup(parentID, markup, toIndex) {12735// NOTE: Null values reduce hidden classes.12736updateQueue.push({12737parentID: parentID,12738parentNode: null,12739type: ReactMultiChildUpdateTypes.INSERT_MARKUP,12740markupIndex: markupQueue.push(markup) - 1,12741textContent: null,12742fromIndex: null,12743toIndex: toIndex12744});12745}1274612747/**12748* Enqueues moving an existing element to another index.12749*12750* @param {string} parentID ID of the parent component.12751* @param {number} fromIndex Source index of the existing element.12752* @param {number} toIndex Destination index of the element.12753* @private12754*/12755function enqueueMove(parentID, fromIndex, toIndex) {12756// NOTE: Null values reduce hidden classes.12757updateQueue.push({12758parentID: parentID,12759parentNode: null,12760type: ReactMultiChildUpdateTypes.MOVE_EXISTING,12761markupIndex: null,12762textContent: null,12763fromIndex: fromIndex,12764toIndex: toIndex12765});12766}1276712768/**12769* Enqueues removing an element at an index.12770*12771* @param {string} parentID ID of the parent component.12772* @param {number} fromIndex Index of the element to remove.12773* @private12774*/12775function enqueueRemove(parentID, fromIndex) {12776// NOTE: Null values reduce hidden classes.12777updateQueue.push({12778parentID: parentID,12779parentNode: null,12780type: ReactMultiChildUpdateTypes.REMOVE_NODE,12781markupIndex: null,12782textContent: null,12783fromIndex: fromIndex,12784toIndex: null12785});12786}1278712788/**12789* Enqueues setting the text content.12790*12791* @param {string} parentID ID of the parent component.12792* @param {string} textContent Text content to set.12793* @private12794*/12795function enqueueTextContent(parentID, textContent) {12796// NOTE: Null values reduce hidden classes.12797updateQueue.push({12798parentID: parentID,12799parentNode: null,12800type: ReactMultiChildUpdateTypes.TEXT_CONTENT,12801markupIndex: null,12802textContent: textContent,12803fromIndex: null,12804toIndex: null12805});12806}1280712808/**12809* Processes any enqueued updates.12810*12811* @private12812*/12813function processQueue() {12814if (updateQueue.length) {12815ReactComponentEnvironment.processChildrenUpdates(12816updateQueue,12817markupQueue12818);12819clearQueue();12820}12821}1282212823/**12824* Clears any enqueued updates.12825*12826* @private12827*/12828function clearQueue() {12829updateQueue.length = 0;12830markupQueue.length = 0;12831}1283212833/**12834* ReactMultiChild are capable of reconciling multiple children.12835*12836* @class ReactMultiChild12837* @internal12838*/12839var ReactMultiChild = {1284012841/**12842* Provides common functionality for components that must reconcile multiple12843* children. This is used by `ReactDOMComponent` to mount, update, and12844* unmount child components.12845*12846* @lends {ReactMultiChild.prototype}12847*/12848Mixin: {1284912850/**12851* Generates a "mount image" for each of the supplied children. In the case12852* of `ReactDOMComponent`, a mount image is a string of markup.12853*12854* @param {?object} nestedChildren Nested child maps.12855* @return {array} An array of mounted representations.12856* @internal12857*/12858mountChildren: function(nestedChildren, transaction, context) {12859var children = ReactChildReconciler.instantiateChildren(12860nestedChildren, transaction, context12861);12862this._renderedChildren = children;12863var mountImages = [];12864var index = 0;12865for (var name in children) {12866if (children.hasOwnProperty(name)) {12867var child = children[name];12868// Inlined for performance, see `ReactInstanceHandles.createReactID`.12869var rootID = this._rootNodeID + name;12870var mountImage = ReactReconciler.mountComponent(12871child,12872rootID,12873transaction,12874context12875);12876child._mountIndex = index;12877mountImages.push(mountImage);12878index++;12879}12880}12881return mountImages;12882},1288312884/**12885* Replaces any rendered children with a text content string.12886*12887* @param {string} nextContent String of content.12888* @internal12889*/12890updateTextContent: function(nextContent) {12891updateDepth++;12892var errorThrown = true;12893try {12894var prevChildren = this._renderedChildren;12895// Remove any rendered children.12896ReactChildReconciler.unmountChildren(prevChildren);12897// TODO: The setTextContent operation should be enough12898for (var name in prevChildren) {12899if (prevChildren.hasOwnProperty(name)) {12900this._unmountChildByName(prevChildren[name], name);12901}12902}12903// Set new text content.12904this.setTextContent(nextContent);12905errorThrown = false;12906} finally {12907updateDepth--;12908if (!updateDepth) {12909if (errorThrown) {12910clearQueue();12911} else {12912processQueue();12913}12914}12915}12916},1291712918/**12919* Updates the rendered children with new children.12920*12921* @param {?object} nextNestedChildren Nested child maps.12922* @param {ReactReconcileTransaction} transaction12923* @internal12924*/12925updateChildren: function(nextNestedChildren, transaction, context) {12926updateDepth++;12927var errorThrown = true;12928try {12929this._updateChildren(nextNestedChildren, transaction, context);12930errorThrown = false;12931} finally {12932updateDepth--;12933if (!updateDepth) {12934if (errorThrown) {12935clearQueue();12936} else {12937processQueue();12938}12939}1294012941}12942},1294312944/**12945* Improve performance by isolating this hot code path from the try/catch12946* block in `updateChildren`.12947*12948* @param {?object} nextNestedChildren Nested child maps.12949* @param {ReactReconcileTransaction} transaction12950* @final12951* @protected12952*/12953_updateChildren: function(nextNestedChildren, transaction, context) {12954var prevChildren = this._renderedChildren;12955var nextChildren = ReactChildReconciler.updateChildren(12956prevChildren, nextNestedChildren, transaction, context12957);12958this._renderedChildren = nextChildren;12959if (!nextChildren && !prevChildren) {12960return;12961}12962var name;12963// `nextIndex` will increment for each child in `nextChildren`, but12964// `lastIndex` will be the last index visited in `prevChildren`.12965var lastIndex = 0;12966var nextIndex = 0;12967for (name in nextChildren) {12968if (!nextChildren.hasOwnProperty(name)) {12969continue;12970}12971var prevChild = prevChildren && prevChildren[name];12972var nextChild = nextChildren[name];12973if (prevChild === nextChild) {12974this.moveChild(prevChild, nextIndex, lastIndex);12975lastIndex = Math.max(prevChild._mountIndex, lastIndex);12976prevChild._mountIndex = nextIndex;12977} else {12978if (prevChild) {12979// Update `lastIndex` before `_mountIndex` gets unset by unmounting.12980lastIndex = Math.max(prevChild._mountIndex, lastIndex);12981this._unmountChildByName(prevChild, name);12982}12983// The child must be instantiated before it's mounted.12984this._mountChildByNameAtIndex(12985nextChild, name, nextIndex, transaction, context12986);12987}12988nextIndex++;12989}12990// Remove children that are no longer present.12991for (name in prevChildren) {12992if (prevChildren.hasOwnProperty(name) &&12993!(nextChildren && nextChildren.hasOwnProperty(name))) {12994this._unmountChildByName(prevChildren[name], name);12995}12996}12997},1299812999/**13000* Unmounts all rendered children. This should be used to clean up children13001* when this component is unmounted.13002*13003* @internal13004*/13005unmountChildren: function() {13006var renderedChildren = this._renderedChildren;13007ReactChildReconciler.unmountChildren(renderedChildren);13008this._renderedChildren = null;13009},1301013011/**13012* Moves a child component to the supplied index.13013*13014* @param {ReactComponent} child Component to move.13015* @param {number} toIndex Destination index of the element.13016* @param {number} lastIndex Last index visited of the siblings of `child`.13017* @protected13018*/13019moveChild: function(child, toIndex, lastIndex) {13020// If the index of `child` is less than `lastIndex`, then it needs to13021// be moved. Otherwise, we do not need to move it because a child will be13022// inserted or moved before `child`.13023if (child._mountIndex < lastIndex) {13024enqueueMove(this._rootNodeID, child._mountIndex, toIndex);13025}13026},1302713028/**13029* Creates a child component.13030*13031* @param {ReactComponent} child Component to create.13032* @param {string} mountImage Markup to insert.13033* @protected13034*/13035createChild: function(child, mountImage) {13036enqueueMarkup(this._rootNodeID, mountImage, child._mountIndex);13037},1303813039/**13040* Removes a child component.13041*13042* @param {ReactComponent} child Child to remove.13043* @protected13044*/13045removeChild: function(child) {13046enqueueRemove(this._rootNodeID, child._mountIndex);13047},1304813049/**13050* Sets this text content string.13051*13052* @param {string} textContent Text content to set.13053* @protected13054*/13055setTextContent: function(textContent) {13056enqueueTextContent(this._rootNodeID, textContent);13057},1305813059/**13060* Mounts a child with the supplied name.13061*13062* NOTE: This is part of `updateChildren` and is here for readability.13063*13064* @param {ReactComponent} child Component to mount.13065* @param {string} name Name of the child.13066* @param {number} index Index at which to insert the child.13067* @param {ReactReconcileTransaction} transaction13068* @private13069*/13070_mountChildByNameAtIndex: function(13071child,13072name,13073index,13074transaction,13075context) {13076// Inlined for performance, see `ReactInstanceHandles.createReactID`.13077var rootID = this._rootNodeID + name;13078var mountImage = ReactReconciler.mountComponent(13079child,13080rootID,13081transaction,13082context13083);13084child._mountIndex = index;13085this.createChild(child, mountImage);13086},1308713088/**13089* Unmounts a rendered child by name.13090*13091* NOTE: This is part of `updateChildren` and is here for readability.13092*13093* @param {ReactComponent} child Component to unmount.13094* @param {string} name Name of the child in `this._renderedChildren`.13095* @private13096*/13097_unmountChildByName: function(child, name) {13098this.removeChild(child);13099child._mountIndex = null;13100}1310113102}1310313104};1310513106module.exports = ReactMultiChild;1310713108},{"31":31,"36":36,"72":72,"81":81}],72:[function(_dereq_,module,exports){13109/**13110* Copyright 2013-2015, Facebook, Inc.13111* All rights reserved.13112*13113* This source code is licensed under the BSD-style license found in the13114* LICENSE file in the root directory of this source tree. An additional grant13115* of patent rights can be found in the PATENTS file in the same directory.13116*13117* @providesModule ReactMultiChildUpdateTypes13118*/1311913120'use strict';1312113122var keyMirror = _dereq_(140);1312313124/**13125* When a component's children are updated, a series of update configuration13126* objects are created in order to batch and serialize the required changes.13127*13128* Enumerates all the possible types of update configurations.13129*13130* @internal13131*/13132var ReactMultiChildUpdateTypes = keyMirror({13133INSERT_MARKUP: null,13134MOVE_EXISTING: null,13135REMOVE_NODE: null,13136TEXT_CONTENT: null13137});1313813139module.exports = ReactMultiChildUpdateTypes;1314013141},{"140":140}],73:[function(_dereq_,module,exports){13142/**13143* Copyright 2014-2015, Facebook, Inc.13144* All rights reserved.13145*13146* This source code is licensed under the BSD-style license found in the13147* LICENSE file in the root directory of this source tree. An additional grant13148* of patent rights can be found in the PATENTS file in the same directory.13149*13150* @providesModule ReactNativeComponent13151*/1315213153'use strict';1315413155var assign = _dereq_(27);13156var invariant = _dereq_(135);1315713158var autoGenerateWrapperClass = null;13159var genericComponentClass = null;13160// This registry keeps track of wrapper classes around native tags13161var tagToComponentClass = {};13162var textComponentClass = null;1316313164var ReactNativeComponentInjection = {13165// This accepts a class that receives the tag string. This is a catch all13166// that can render any kind of tag.13167injectGenericComponentClass: function(componentClass) {13168genericComponentClass = componentClass;13169},13170// This accepts a text component class that takes the text string to be13171// rendered as props.13172injectTextComponentClass: function(componentClass) {13173textComponentClass = componentClass;13174},13175// This accepts a keyed object with classes as values. Each key represents a13176// tag. That particular tag will use this class instead of the generic one.13177injectComponentClasses: function(componentClasses) {13178assign(tagToComponentClass, componentClasses);13179},13180// Temporary hack since we expect DOM refs to behave like composites,13181// for this release.13182injectAutoWrapper: function(wrapperFactory) {13183autoGenerateWrapperClass = wrapperFactory;13184}13185};1318613187/**13188* Get a composite component wrapper class for a specific tag.13189*13190* @param {ReactElement} element The tag for which to get the class.13191* @return {function} The React class constructor function.13192*/13193function getComponentClassForElement(element) {13194if (typeof element.type === 'function') {13195return element.type;13196}13197var tag = element.type;13198var componentClass = tagToComponentClass[tag];13199if (componentClass == null) {13200tagToComponentClass[tag] = componentClass = autoGenerateWrapperClass(tag);13201}13202return componentClass;13203}1320413205/**13206* Get a native internal component class for a specific tag.13207*13208* @param {ReactElement} element The element to create.13209* @return {function} The internal class constructor function.13210*/13211function createInternalComponent(element) {13212("production" !== "development" ? invariant(13213genericComponentClass,13214'There is no registered component for the tag %s',13215element.type13216) : invariant(genericComponentClass));13217return new genericComponentClass(element.type, element.props);13218}1321913220/**13221* @param {ReactText} text13222* @return {ReactComponent}13223*/13224function createInstanceForText(text) {13225return new textComponentClass(text);13226}1322713228/**13229* @param {ReactComponent} component13230* @return {boolean}13231*/13232function isTextComponent(component) {13233return component instanceof textComponentClass;13234}1323513236var ReactNativeComponent = {13237getComponentClassForElement: getComponentClassForElement,13238createInternalComponent: createInternalComponent,13239createInstanceForText: createInstanceForText,13240isTextComponent: isTextComponent,13241injection: ReactNativeComponentInjection13242};1324313244module.exports = ReactNativeComponent;1324513246},{"135":135,"27":27}],74:[function(_dereq_,module,exports){13247/**13248* Copyright 2013-2015, Facebook, Inc.13249* All rights reserved.13250*13251* This source code is licensed under the BSD-style license found in the13252* LICENSE file in the root directory of this source tree. An additional grant13253* of patent rights can be found in the PATENTS file in the same directory.13254*13255* @providesModule ReactOwner13256*/1325713258'use strict';1325913260var invariant = _dereq_(135);1326113262/**13263* ReactOwners are capable of storing references to owned components.13264*13265* All components are capable of //being// referenced by owner components, but13266* only ReactOwner components are capable of //referencing// owned components.13267* The named reference is known as a "ref".13268*13269* Refs are available when mounted and updated during reconciliation.13270*13271* var MyComponent = React.createClass({13272* render: function() {13273* return (13274* <div onClick={this.handleClick}>13275* <CustomComponent ref="custom" />13276* </div>13277* );13278* },13279* handleClick: function() {13280* this.refs.custom.handleClick();13281* },13282* componentDidMount: function() {13283* this.refs.custom.initialize();13284* }13285* });13286*13287* Refs should rarely be used. When refs are used, they should only be done to13288* control data that is not handled by React's data flow.13289*13290* @class ReactOwner13291*/13292var ReactOwner = {1329313294/**13295* @param {?object} object13296* @return {boolean} True if `object` is a valid owner.13297* @final13298*/13299isValidOwner: function(object) {13300return !!(13301(object &&13302typeof object.attachRef === 'function' && typeof object.detachRef === 'function')13303);13304},1330513306/**13307* Adds a component by ref to an owner component.13308*13309* @param {ReactComponent} component Component to reference.13310* @param {string} ref Name by which to refer to the component.13311* @param {ReactOwner} owner Component on which to record the ref.13312* @final13313* @internal13314*/13315addComponentAsRefTo: function(component, ref, owner) {13316("production" !== "development" ? invariant(13317ReactOwner.isValidOwner(owner),13318'addComponentAsRefTo(...): Only a ReactOwner can have refs. This ' +13319'usually means that you\'re trying to add a ref to a component that ' +13320'doesn\'t have an owner (that is, was not created inside of another ' +13321'component\'s `render` method). Try rendering this component inside of ' +13322'a new top-level component which will hold the ref.'13323) : invariant(ReactOwner.isValidOwner(owner)));13324owner.attachRef(ref, component);13325},1332613327/**13328* Removes a component by ref from an owner component.13329*13330* @param {ReactComponent} component Component to dereference.13331* @param {string} ref Name of the ref to remove.13332* @param {ReactOwner} owner Component on which the ref is recorded.13333* @final13334* @internal13335*/13336removeComponentAsRefFrom: function(component, ref, owner) {13337("production" !== "development" ? invariant(13338ReactOwner.isValidOwner(owner),13339'removeComponentAsRefFrom(...): Only a ReactOwner can have refs. This ' +13340'usually means that you\'re trying to remove a ref to a component that ' +13341'doesn\'t have an owner (that is, was not created inside of another ' +13342'component\'s `render` method). Try rendering this component inside of ' +13343'a new top-level component which will hold the ref.'13344) : invariant(ReactOwner.isValidOwner(owner)));13345// Check that `component` is still the current ref because we do not want to13346// detach the ref if another component stole it.13347if (owner.getPublicInstance().refs[ref] === component.getPublicInstance()) {13348owner.detachRef(ref);13349}13350}1335113352};1335313354module.exports = ReactOwner;1335513356},{"135":135}],75:[function(_dereq_,module,exports){13357/**13358* Copyright 2013-2015, Facebook, Inc.13359* All rights reserved.13360*13361* This source code is licensed under the BSD-style license found in the13362* LICENSE file in the root directory of this source tree. An additional grant13363* of patent rights can be found in the PATENTS file in the same directory.13364*13365* @providesModule ReactPerf13366* @typechecks static-only13367*/1336813369'use strict';1337013371/**13372* ReactPerf is a general AOP system designed to measure performance. This13373* module only has the hooks: see ReactDefaultPerf for the analysis tool.13374*/13375var ReactPerf = {13376/**13377* Boolean to enable/disable measurement. Set to false by default to prevent13378* accidental logging and perf loss.13379*/13380enableMeasure: false,1338113382/**13383* Holds onto the measure function in use. By default, don't measure13384* anything, but we'll override this if we inject a measure function.13385*/13386storedMeasure: _noMeasure,1338713388/**13389* @param {object} object13390* @param {string} objectName13391* @param {object<string>} methodNames13392*/13393measureMethods: function(object, objectName, methodNames) {13394if ("production" !== "development") {13395for (var key in methodNames) {13396if (!methodNames.hasOwnProperty(key)) {13397continue;13398}13399object[key] = ReactPerf.measure(13400objectName,13401methodNames[key],13402object[key]13403);13404}13405}13406},1340713408/**13409* Use this to wrap methods you want to measure. Zero overhead in production.13410*13411* @param {string} objName13412* @param {string} fnName13413* @param {function} func13414* @return {function}13415*/13416measure: function(objName, fnName, func) {13417if ("production" !== "development") {13418var measuredFunc = null;13419var wrapper = function() {13420if (ReactPerf.enableMeasure) {13421if (!measuredFunc) {13422measuredFunc = ReactPerf.storedMeasure(objName, fnName, func);13423}13424return measuredFunc.apply(this, arguments);13425}13426return func.apply(this, arguments);13427};13428wrapper.displayName = objName + '_' + fnName;13429return wrapper;13430}13431return func;13432},1343313434injection: {13435/**13436* @param {function} measure13437*/13438injectMeasure: function(measure) {13439ReactPerf.storedMeasure = measure;13440}13441}13442};1344313444/**13445* Simply passes through the measured function, without measuring it.13446*13447* @param {string} objName13448* @param {string} fnName13449* @param {function} func13450* @return {function}13451*/13452function _noMeasure(objName, fnName, func) {13453return func;13454}1345513456module.exports = ReactPerf;1345713458},{}],76:[function(_dereq_,module,exports){13459/**13460* Copyright 2013-2015, Facebook, Inc.13461* All rights reserved.13462*13463* This source code is licensed under the BSD-style license found in the13464* LICENSE file in the root directory of this source tree. An additional grant13465* of patent rights can be found in the PATENTS file in the same directory.13466*13467* @providesModule ReactPropTypeLocationNames13468*/1346913470'use strict';1347113472var ReactPropTypeLocationNames = {};1347313474if ("production" !== "development") {13475ReactPropTypeLocationNames = {13476prop: 'prop',13477context: 'context',13478childContext: 'child context'13479};13480}1348113482module.exports = ReactPropTypeLocationNames;1348313484},{}],77:[function(_dereq_,module,exports){13485/**13486* Copyright 2013-2015, Facebook, Inc.13487* All rights reserved.13488*13489* This source code is licensed under the BSD-style license found in the13490* LICENSE file in the root directory of this source tree. An additional grant13491* of patent rights can be found in the PATENTS file in the same directory.13492*13493* @providesModule ReactPropTypeLocations13494*/1349513496'use strict';1349713498var keyMirror = _dereq_(140);1349913500var ReactPropTypeLocations = keyMirror({13501prop: null,13502context: null,13503childContext: null13504});1350513506module.exports = ReactPropTypeLocations;1350713508},{"140":140}],78:[function(_dereq_,module,exports){13509/**13510* Copyright 2013-2015, Facebook, Inc.13511* All rights reserved.13512*13513* This source code is licensed under the BSD-style license found in the13514* LICENSE file in the root directory of this source tree. An additional grant13515* of patent rights can be found in the PATENTS file in the same directory.13516*13517* @providesModule ReactPropTypes13518*/1351913520'use strict';1352113522var ReactElement = _dereq_(57);13523var ReactFragment = _dereq_(63);13524var ReactPropTypeLocationNames = _dereq_(76);1352513526var emptyFunction = _dereq_(114);1352713528/**13529* Collection of methods that allow declaration and validation of props that are13530* supplied to React components. Example usage:13531*13532* var Props = require('ReactPropTypes');13533* var MyArticle = React.createClass({13534* propTypes: {13535* // An optional string prop named "description".13536* description: Props.string,13537*13538* // A required enum prop named "category".13539* category: Props.oneOf(['News','Photos']).isRequired,13540*13541* // A prop named "dialog" that requires an instance of Dialog.13542* dialog: Props.instanceOf(Dialog).isRequired13543* },13544* render: function() { ... }13545* });13546*13547* A more formal specification of how these methods are used:13548*13549* type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...)13550* decl := ReactPropTypes.{type}(.isRequired)?13551*13552* Each and every declaration produces a function with the same signature. This13553* allows the creation of custom validation functions. For example:13554*13555* var MyLink = React.createClass({13556* propTypes: {13557* // An optional string or URI prop named "href".13558* href: function(props, propName, componentName) {13559* var propValue = props[propName];13560* if (propValue != null && typeof propValue !== 'string' &&13561* !(propValue instanceof URI)) {13562* return new Error(13563* 'Expected a string or an URI for ' + propName + ' in ' +13564* componentName13565* );13566* }13567* }13568* },13569* render: function() {...}13570* });13571*13572* @internal13573*/1357413575var ANONYMOUS = '<<anonymous>>';1357613577var elementTypeChecker = createElementTypeChecker();13578var nodeTypeChecker = createNodeChecker();1357913580var ReactPropTypes = {13581array: createPrimitiveTypeChecker('array'),13582bool: createPrimitiveTypeChecker('boolean'),13583func: createPrimitiveTypeChecker('function'),13584number: createPrimitiveTypeChecker('number'),13585object: createPrimitiveTypeChecker('object'),13586string: createPrimitiveTypeChecker('string'),1358713588any: createAnyTypeChecker(),13589arrayOf: createArrayOfTypeChecker,13590element: elementTypeChecker,13591instanceOf: createInstanceTypeChecker,13592node: nodeTypeChecker,13593objectOf: createObjectOfTypeChecker,13594oneOf: createEnumTypeChecker,13595oneOfType: createUnionTypeChecker,13596shape: createShapeTypeChecker13597};1359813599function createChainableTypeChecker(validate) {13600function checkType(isRequired, props, propName, componentName, location) {13601componentName = componentName || ANONYMOUS;13602if (props[propName] == null) {13603var locationName = ReactPropTypeLocationNames[location];13604if (isRequired) {13605return new Error(13606("Required " + locationName + " `" + propName + "` was not specified in ") +13607("`" + componentName + "`.")13608);13609}13610return null;13611} else {13612return validate(props, propName, componentName, location);13613}13614}1361513616var chainedCheckType = checkType.bind(null, false);13617chainedCheckType.isRequired = checkType.bind(null, true);1361813619return chainedCheckType;13620}1362113622function createPrimitiveTypeChecker(expectedType) {13623function validate(props, propName, componentName, location) {13624var propValue = props[propName];13625var propType = getPropType(propValue);13626if (propType !== expectedType) {13627var locationName = ReactPropTypeLocationNames[location];13628// `propValue` being instance of, say, date/regexp, pass the 'object'13629// check, but we can offer a more precise error message here rather than13630// 'of type `object`'.13631var preciseType = getPreciseType(propValue);1363213633return new Error(13634("Invalid " + locationName + " `" + propName + "` of type `" + preciseType + "` ") +13635("supplied to `" + componentName + "`, expected `" + expectedType + "`.")13636);13637}13638return null;13639}13640return createChainableTypeChecker(validate);13641}1364213643function createAnyTypeChecker() {13644return createChainableTypeChecker(emptyFunction.thatReturns(null));13645}1364613647function createArrayOfTypeChecker(typeChecker) {13648function validate(props, propName, componentName, location) {13649var propValue = props[propName];13650if (!Array.isArray(propValue)) {13651var locationName = ReactPropTypeLocationNames[location];13652var propType = getPropType(propValue);13653return new Error(13654("Invalid " + locationName + " `" + propName + "` of type ") +13655("`" + propType + "` supplied to `" + componentName + "`, expected an array.")13656);13657}13658for (var i = 0; i < propValue.length; i++) {13659var error = typeChecker(propValue, i, componentName, location);13660if (error instanceof Error) {13661return error;13662}13663}13664return null;13665}13666return createChainableTypeChecker(validate);13667}1366813669function createElementTypeChecker() {13670function validate(props, propName, componentName, location) {13671if (!ReactElement.isValidElement(props[propName])) {13672var locationName = ReactPropTypeLocationNames[location];13673return new Error(13674("Invalid " + locationName + " `" + propName + "` supplied to ") +13675("`" + componentName + "`, expected a ReactElement.")13676);13677}13678return null;13679}13680return createChainableTypeChecker(validate);13681}1368213683function createInstanceTypeChecker(expectedClass) {13684function validate(props, propName, componentName, location) {13685if (!(props[propName] instanceof expectedClass)) {13686var locationName = ReactPropTypeLocationNames[location];13687var expectedClassName = expectedClass.name || ANONYMOUS;13688return new Error(13689("Invalid " + locationName + " `" + propName + "` supplied to ") +13690("`" + componentName + "`, expected instance of `" + expectedClassName + "`.")13691);13692}13693return null;13694}13695return createChainableTypeChecker(validate);13696}1369713698function createEnumTypeChecker(expectedValues) {13699function validate(props, propName, componentName, location) {13700var propValue = props[propName];13701for (var i = 0; i < expectedValues.length; i++) {13702if (propValue === expectedValues[i]) {13703return null;13704}13705}1370613707var locationName = ReactPropTypeLocationNames[location];13708var valuesString = JSON.stringify(expectedValues);13709return new Error(13710("Invalid " + locationName + " `" + propName + "` of value `" + propValue + "` ") +13711("supplied to `" + componentName + "`, expected one of " + valuesString + ".")13712);13713}13714return createChainableTypeChecker(validate);13715}1371613717function createObjectOfTypeChecker(typeChecker) {13718function validate(props, propName, componentName, location) {13719var propValue = props[propName];13720var propType = getPropType(propValue);13721if (propType !== 'object') {13722var locationName = ReactPropTypeLocationNames[location];13723return new Error(13724("Invalid " + locationName + " `" + propName + "` of type ") +13725("`" + propType + "` supplied to `" + componentName + "`, expected an object.")13726);13727}13728for (var key in propValue) {13729if (propValue.hasOwnProperty(key)) {13730var error = typeChecker(propValue, key, componentName, location);13731if (error instanceof Error) {13732return error;13733}13734}13735}13736return null;13737}13738return createChainableTypeChecker(validate);13739}1374013741function createUnionTypeChecker(arrayOfTypeCheckers) {13742function validate(props, propName, componentName, location) {13743for (var i = 0; i < arrayOfTypeCheckers.length; i++) {13744var checker = arrayOfTypeCheckers[i];13745if (checker(props, propName, componentName, location) == null) {13746return null;13747}13748}1374913750var locationName = ReactPropTypeLocationNames[location];13751return new Error(13752("Invalid " + locationName + " `" + propName + "` supplied to ") +13753("`" + componentName + "`.")13754);13755}13756return createChainableTypeChecker(validate);13757}1375813759function createNodeChecker() {13760function validate(props, propName, componentName, location) {13761if (!isNode(props[propName])) {13762var locationName = ReactPropTypeLocationNames[location];13763return new Error(13764("Invalid " + locationName + " `" + propName + "` supplied to ") +13765("`" + componentName + "`, expected a ReactNode.")13766);13767}13768return null;13769}13770return createChainableTypeChecker(validate);13771}1377213773function createShapeTypeChecker(shapeTypes) {13774function validate(props, propName, componentName, location) {13775var propValue = props[propName];13776var propType = getPropType(propValue);13777if (propType !== 'object') {13778var locationName = ReactPropTypeLocationNames[location];13779return new Error(13780("Invalid " + locationName + " `" + propName + "` of type `" + propType + "` ") +13781("supplied to `" + componentName + "`, expected `object`.")13782);13783}13784for (var key in shapeTypes) {13785var checker = shapeTypes[key];13786if (!checker) {13787continue;13788}13789var error = checker(propValue, key, componentName, location);13790if (error) {13791return error;13792}13793}13794return null;13795}13796return createChainableTypeChecker(validate);13797}1379813799function isNode(propValue) {13800switch (typeof propValue) {13801case 'number':13802case 'string':13803case 'undefined':13804return true;13805case 'boolean':13806return !propValue;13807case 'object':13808if (Array.isArray(propValue)) {13809return propValue.every(isNode);13810}13811if (propValue === null || ReactElement.isValidElement(propValue)) {13812return true;13813}13814propValue = ReactFragment.extractIfFragment(propValue);13815for (var k in propValue) {13816if (!isNode(propValue[k])) {13817return false;13818}13819}13820return true;13821default:13822return false;13823}13824}1382513826// Equivalent of `typeof` but with special handling for array and regexp.13827function getPropType(propValue) {13828var propType = typeof propValue;13829if (Array.isArray(propValue)) {13830return 'array';13831}13832if (propValue instanceof RegExp) {13833// Old webkits (at least until Android 4.0) return 'function' rather than13834// 'object' for typeof a RegExp. We'll normalize this here so that /bla/13835// passes PropTypes.object.13836return 'object';13837}13838return propType;13839}1384013841// This handles more types than `getPropType`. Only used for error messages.13842// See `createPrimitiveTypeChecker`.13843function getPreciseType(propValue) {13844var propType = getPropType(propValue);13845if (propType === 'object') {13846if (propValue instanceof Date) {13847return 'date';13848} else if (propValue instanceof RegExp) {13849return 'regexp';13850}13851}13852return propType;13853}1385413855module.exports = ReactPropTypes;1385613857},{"114":114,"57":57,"63":63,"76":76}],79:[function(_dereq_,module,exports){13858/**13859* Copyright 2013-2015, Facebook, Inc.13860* All rights reserved.13861*13862* This source code is licensed under the BSD-style license found in the13863* LICENSE file in the root directory of this source tree. An additional grant13864* of patent rights can be found in the PATENTS file in the same directory.13865*13866* @providesModule ReactPutListenerQueue13867*/1386813869'use strict';1387013871var PooledClass = _dereq_(28);13872var ReactBrowserEventEmitter = _dereq_(30);1387313874var assign = _dereq_(27);1387513876function ReactPutListenerQueue() {13877this.listenersToPut = [];13878}1387913880assign(ReactPutListenerQueue.prototype, {13881enqueuePutListener: function(rootNodeID, propKey, propValue) {13882this.listenersToPut.push({13883rootNodeID: rootNodeID,13884propKey: propKey,13885propValue: propValue13886});13887},1388813889putListeners: function() {13890for (var i = 0; i < this.listenersToPut.length; i++) {13891var listenerToPut = this.listenersToPut[i];13892ReactBrowserEventEmitter.putListener(13893listenerToPut.rootNodeID,13894listenerToPut.propKey,13895listenerToPut.propValue13896);13897}13898},1389913900reset: function() {13901this.listenersToPut.length = 0;13902},1390313904destructor: function() {13905this.reset();13906}13907});1390813909PooledClass.addPoolingTo(ReactPutListenerQueue);1391013911module.exports = ReactPutListenerQueue;1391213913},{"27":27,"28":28,"30":30}],80:[function(_dereq_,module,exports){13914/**13915* Copyright 2013-2015, Facebook, Inc.13916* All rights reserved.13917*13918* This source code is licensed under the BSD-style license found in the13919* LICENSE file in the root directory of this source tree. An additional grant13920* of patent rights can be found in the PATENTS file in the same directory.13921*13922* @providesModule ReactReconcileTransaction13923* @typechecks static-only13924*/1392513926'use strict';1392713928var CallbackQueue = _dereq_(6);13929var PooledClass = _dereq_(28);13930var ReactBrowserEventEmitter = _dereq_(30);13931var ReactInputSelection = _dereq_(65);13932var ReactPutListenerQueue = _dereq_(79);13933var Transaction = _dereq_(103);1393413935var assign = _dereq_(27);1393613937/**13938* Ensures that, when possible, the selection range (currently selected text13939* input) is not disturbed by performing the transaction.13940*/13941var SELECTION_RESTORATION = {13942/**13943* @return {Selection} Selection information.13944*/13945initialize: ReactInputSelection.getSelectionInformation,13946/**13947* @param {Selection} sel Selection information returned from `initialize`.13948*/13949close: ReactInputSelection.restoreSelection13950};1395113952/**13953* Suppresses events (blur/focus) that could be inadvertently dispatched due to13954* high level DOM manipulations (like temporarily removing a text input from the13955* DOM).13956*/13957var EVENT_SUPPRESSION = {13958/**13959* @return {boolean} The enabled status of `ReactBrowserEventEmitter` before13960* the reconciliation.13961*/13962initialize: function() {13963var currentlyEnabled = ReactBrowserEventEmitter.isEnabled();13964ReactBrowserEventEmitter.setEnabled(false);13965return currentlyEnabled;13966},1396713968/**13969* @param {boolean} previouslyEnabled Enabled status of13970* `ReactBrowserEventEmitter` before the reconciliation occured. `close`13971* restores the previous value.13972*/13973close: function(previouslyEnabled) {13974ReactBrowserEventEmitter.setEnabled(previouslyEnabled);13975}13976};1397713978/**13979* Provides a queue for collecting `componentDidMount` and13980* `componentDidUpdate` callbacks during the the transaction.13981*/13982var ON_DOM_READY_QUEUEING = {13983/**13984* Initializes the internal `onDOMReady` queue.13985*/13986initialize: function() {13987this.reactMountReady.reset();13988},1398913990/**13991* After DOM is flushed, invoke all registered `onDOMReady` callbacks.13992*/13993close: function() {13994this.reactMountReady.notifyAll();13995}13996};1399713998var PUT_LISTENER_QUEUEING = {13999initialize: function() {14000this.putListenerQueue.reset();14001},1400214003close: function() {14004this.putListenerQueue.putListeners();14005}14006};1400714008/**14009* Executed within the scope of the `Transaction` instance. Consider these as14010* being member methods, but with an implied ordering while being isolated from14011* each other.14012*/14013var TRANSACTION_WRAPPERS = [14014PUT_LISTENER_QUEUEING,14015SELECTION_RESTORATION,14016EVENT_SUPPRESSION,14017ON_DOM_READY_QUEUEING14018];1401914020/**14021* Currently:14022* - The order that these are listed in the transaction is critical:14023* - Suppresses events.14024* - Restores selection range.14025*14026* Future:14027* - Restore document/overflow scroll positions that were unintentionally14028* modified via DOM insertions above the top viewport boundary.14029* - Implement/integrate with customized constraint based layout system and keep14030* track of which dimensions must be remeasured.14031*14032* @class ReactReconcileTransaction14033*/14034function ReactReconcileTransaction() {14035this.reinitializeTransaction();14036// Only server-side rendering really needs this option (see14037// `ReactServerRendering`), but server-side uses14038// `ReactServerRenderingTransaction` instead. This option is here so that it's14039// accessible and defaults to false when `ReactDOMComponent` and14040// `ReactTextComponent` checks it in `mountComponent`.`14041this.renderToStaticMarkup = false;14042this.reactMountReady = CallbackQueue.getPooled(null);14043this.putListenerQueue = ReactPutListenerQueue.getPooled();14044}1404514046var Mixin = {14047/**14048* @see Transaction14049* @abstract14050* @final14051* @return {array<object>} List of operation wrap proceedures.14052* TODO: convert to array<TransactionWrapper>14053*/14054getTransactionWrappers: function() {14055return TRANSACTION_WRAPPERS;14056},1405714058/**14059* @return {object} The queue to collect `onDOMReady` callbacks with.14060*/14061getReactMountReady: function() {14062return this.reactMountReady;14063},1406414065getPutListenerQueue: function() {14066return this.putListenerQueue;14067},1406814069/**14070* `PooledClass` looks for this, and will invoke this before allowing this14071* instance to be resused.14072*/14073destructor: function() {14074CallbackQueue.release(this.reactMountReady);14075this.reactMountReady = null;1407614077ReactPutListenerQueue.release(this.putListenerQueue);14078this.putListenerQueue = null;14079}14080};140811408214083assign(ReactReconcileTransaction.prototype, Transaction.Mixin, Mixin);1408414085PooledClass.addPoolingTo(ReactReconcileTransaction);1408614087module.exports = ReactReconcileTransaction;1408814089},{"103":103,"27":27,"28":28,"30":30,"6":6,"65":65,"79":79}],81:[function(_dereq_,module,exports){14090/**14091* Copyright 2013-2015, Facebook, Inc.14092* All rights reserved.14093*14094* This source code is licensed under the BSD-style license found in the14095* LICENSE file in the root directory of this source tree. An additional grant14096* of patent rights can be found in the PATENTS file in the same directory.14097*14098* @providesModule ReactReconciler14099*/1410014101'use strict';1410214103var ReactRef = _dereq_(82);14104var ReactElementValidator = _dereq_(58);1410514106/**14107* Helper to call ReactRef.attachRefs with this composite component, split out14108* to avoid allocations in the transaction mount-ready queue.14109*/14110function attachRefs() {14111ReactRef.attachRefs(this, this._currentElement);14112}1411314114var ReactReconciler = {1411514116/**14117* Initializes the component, renders markup, and registers event listeners.14118*14119* @param {ReactComponent} internalInstance14120* @param {string} rootID DOM ID of the root node.14121* @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction14122* @return {?string} Rendered markup to be inserted into the DOM.14123* @final14124* @internal14125*/14126mountComponent: function(internalInstance, rootID, transaction, context) {14127var markup = internalInstance.mountComponent(rootID, transaction, context);14128if ("production" !== "development") {14129ReactElementValidator.checkAndWarnForMutatedProps(14130internalInstance._currentElement14131);14132}14133transaction.getReactMountReady().enqueue(attachRefs, internalInstance);14134return markup;14135},1413614137/**14138* Releases any resources allocated by `mountComponent`.14139*14140* @final14141* @internal14142*/14143unmountComponent: function(internalInstance) {14144ReactRef.detachRefs(internalInstance, internalInstance._currentElement);14145internalInstance.unmountComponent();14146},1414714148/**14149* Update a component using a new element.14150*14151* @param {ReactComponent} internalInstance14152* @param {ReactElement} nextElement14153* @param {ReactReconcileTransaction} transaction14154* @param {object} context14155* @internal14156*/14157receiveComponent: function(14158internalInstance, nextElement, transaction, context14159) {14160var prevElement = internalInstance._currentElement;1416114162if (nextElement === prevElement && nextElement._owner != null) {14163// Since elements are immutable after the owner is rendered,14164// we can do a cheap identity compare here to determine if this is a14165// superfluous reconcile. It's possible for state to be mutable but such14166// change should trigger an update of the owner which would recreate14167// the element. We explicitly check for the existence of an owner since14168// it's possible for an element created outside a composite to be14169// deeply mutated and reused.14170return;14171}1417214173if ("production" !== "development") {14174ReactElementValidator.checkAndWarnForMutatedProps(nextElement);14175}1417614177var refsChanged = ReactRef.shouldUpdateRefs(14178prevElement,14179nextElement14180);1418114182if (refsChanged) {14183ReactRef.detachRefs(internalInstance, prevElement);14184}1418514186internalInstance.receiveComponent(nextElement, transaction, context);1418714188if (refsChanged) {14189transaction.getReactMountReady().enqueue(attachRefs, internalInstance);14190}14191},1419214193/**14194* Flush any dirty changes in a component.14195*14196* @param {ReactComponent} internalInstance14197* @param {ReactReconcileTransaction} transaction14198* @internal14199*/14200performUpdateIfNecessary: function(14201internalInstance,14202transaction14203) {14204internalInstance.performUpdateIfNecessary(transaction);14205}1420614207};1420814209module.exports = ReactReconciler;1421014211},{"58":58,"82":82}],82:[function(_dereq_,module,exports){14212/**14213* Copyright 2013-2015, Facebook, Inc.14214* All rights reserved.14215*14216* This source code is licensed under the BSD-style license found in the14217* LICENSE file in the root directory of this source tree. An additional grant14218* of patent rights can be found in the PATENTS file in the same directory.14219*14220* @providesModule ReactRef14221*/1422214223'use strict';1422414225var ReactOwner = _dereq_(74);1422614227var ReactRef = {};1422814229function attachRef(ref, component, owner) {14230if (typeof ref === 'function') {14231ref(component.getPublicInstance());14232} else {14233// Legacy ref14234ReactOwner.addComponentAsRefTo(component, ref, owner);14235}14236}1423714238function detachRef(ref, component, owner) {14239if (typeof ref === 'function') {14240ref(null);14241} else {14242// Legacy ref14243ReactOwner.removeComponentAsRefFrom(component, ref, owner);14244}14245}1424614247ReactRef.attachRefs = function(instance, element) {14248var ref = element.ref;14249if (ref != null) {14250attachRef(ref, instance, element._owner);14251}14252};1425314254ReactRef.shouldUpdateRefs = function(prevElement, nextElement) {14255// If either the owner or a `ref` has changed, make sure the newest owner14256// has stored a reference to `this`, and the previous owner (if different)14257// has forgotten the reference to `this`. We use the element instead14258// of the public this.props because the post processing cannot determine14259// a ref. The ref conceptually lives on the element.1426014261// TODO: Should this even be possible? The owner cannot change because14262// it's forbidden by shouldUpdateReactComponent. The ref can change14263// if you swap the keys of but not the refs. Reconsider where this check14264// is made. It probably belongs where the key checking and14265// instantiateReactComponent is done.1426614267return (14268nextElement._owner !== prevElement._owner ||14269nextElement.ref !== prevElement.ref14270);14271};1427214273ReactRef.detachRefs = function(instance, element) {14274var ref = element.ref;14275if (ref != null) {14276detachRef(ref, instance, element._owner);14277}14278};1427914280module.exports = ReactRef;1428114282},{"74":74}],83:[function(_dereq_,module,exports){14283/**14284* Copyright 2013-2015, Facebook, Inc.14285* All rights reserved.14286*14287* This source code is licensed under the BSD-style license found in the14288* LICENSE file in the root directory of this source tree. An additional grant14289* of patent rights can be found in the PATENTS file in the same directory.14290*14291* @providesModule ReactRootIndex14292* @typechecks14293*/1429414295'use strict';1429614297var ReactRootIndexInjection = {14298/**14299* @param {function} _createReactRootIndex14300*/14301injectCreateReactRootIndex: function(_createReactRootIndex) {14302ReactRootIndex.createReactRootIndex = _createReactRootIndex;14303}14304};1430514306var ReactRootIndex = {14307createReactRootIndex: null,14308injection: ReactRootIndexInjection14309};1431014311module.exports = ReactRootIndex;1431214313},{}],84:[function(_dereq_,module,exports){14314/**14315* Copyright 2013-2015, Facebook, Inc.14316* All rights reserved.14317*14318* This source code is licensed under the BSD-style license found in the14319* LICENSE file in the root directory of this source tree. An additional grant14320* of patent rights can be found in the PATENTS file in the same directory.14321*14322* @typechecks static-only14323* @providesModule ReactServerRendering14324*/14325'use strict';1432614327var ReactElement = _dereq_(57);14328var ReactInstanceHandles = _dereq_(66);14329var ReactMarkupChecksum = _dereq_(69);14330var ReactServerRenderingTransaction =14331_dereq_(85);1433214333var emptyObject = _dereq_(115);14334var instantiateReactComponent = _dereq_(134);14335var invariant = _dereq_(135);1433614337/**14338* @param {ReactElement} element14339* @return {string} the HTML markup14340*/14341function renderToString(element) {14342("production" !== "development" ? invariant(14343ReactElement.isValidElement(element),14344'renderToString(): You must pass a valid ReactElement.'14345) : invariant(ReactElement.isValidElement(element)));1434614347var transaction;14348try {14349var id = ReactInstanceHandles.createReactRootID();14350transaction = ReactServerRenderingTransaction.getPooled(false);1435114352return transaction.perform(function() {14353var componentInstance = instantiateReactComponent(element, null);14354var markup =14355componentInstance.mountComponent(id, transaction, emptyObject);14356return ReactMarkupChecksum.addChecksumToMarkup(markup);14357}, null);14358} finally {14359ReactServerRenderingTransaction.release(transaction);14360}14361}1436214363/**14364* @param {ReactElement} element14365* @return {string} the HTML markup, without the extra React ID and checksum14366* (for generating static pages)14367*/14368function renderToStaticMarkup(element) {14369("production" !== "development" ? invariant(14370ReactElement.isValidElement(element),14371'renderToStaticMarkup(): You must pass a valid ReactElement.'14372) : invariant(ReactElement.isValidElement(element)));1437314374var transaction;14375try {14376var id = ReactInstanceHandles.createReactRootID();14377transaction = ReactServerRenderingTransaction.getPooled(true);1437814379return transaction.perform(function() {14380var componentInstance = instantiateReactComponent(element, null);14381return componentInstance.mountComponent(id, transaction, emptyObject);14382}, null);14383} finally {14384ReactServerRenderingTransaction.release(transaction);14385}14386}1438714388module.exports = {14389renderToString: renderToString,14390renderToStaticMarkup: renderToStaticMarkup14391};1439214393},{"115":115,"134":134,"135":135,"57":57,"66":66,"69":69,"85":85}],85:[function(_dereq_,module,exports){14394/**14395* Copyright 2014-2015, Facebook, Inc.14396* All rights reserved.14397*14398* This source code is licensed under the BSD-style license found in the14399* LICENSE file in the root directory of this source tree. An additional grant14400* of patent rights can be found in the PATENTS file in the same directory.14401*14402* @providesModule ReactServerRenderingTransaction14403* @typechecks14404*/1440514406'use strict';1440714408var PooledClass = _dereq_(28);14409var CallbackQueue = _dereq_(6);14410var ReactPutListenerQueue = _dereq_(79);14411var Transaction = _dereq_(103);1441214413var assign = _dereq_(27);14414var emptyFunction = _dereq_(114);1441514416/**14417* Provides a `CallbackQueue` queue for collecting `onDOMReady` callbacks14418* during the performing of the transaction.14419*/14420var ON_DOM_READY_QUEUEING = {14421/**14422* Initializes the internal `onDOMReady` queue.14423*/14424initialize: function() {14425this.reactMountReady.reset();14426},1442714428close: emptyFunction14429};1443014431var PUT_LISTENER_QUEUEING = {14432initialize: function() {14433this.putListenerQueue.reset();14434},1443514436close: emptyFunction14437};1443814439/**14440* Executed within the scope of the `Transaction` instance. Consider these as14441* being member methods, but with an implied ordering while being isolated from14442* each other.14443*/14444var TRANSACTION_WRAPPERS = [14445PUT_LISTENER_QUEUEING,14446ON_DOM_READY_QUEUEING14447];1444814449/**14450* @class ReactServerRenderingTransaction14451* @param {boolean} renderToStaticMarkup14452*/14453function ReactServerRenderingTransaction(renderToStaticMarkup) {14454this.reinitializeTransaction();14455this.renderToStaticMarkup = renderToStaticMarkup;14456this.reactMountReady = CallbackQueue.getPooled(null);14457this.putListenerQueue = ReactPutListenerQueue.getPooled();14458}1445914460var Mixin = {14461/**14462* @see Transaction14463* @abstract14464* @final14465* @return {array} Empty list of operation wrap proceedures.14466*/14467getTransactionWrappers: function() {14468return TRANSACTION_WRAPPERS;14469},1447014471/**14472* @return {object} The queue to collect `onDOMReady` callbacks with.14473*/14474getReactMountReady: function() {14475return this.reactMountReady;14476},1447714478getPutListenerQueue: function() {14479return this.putListenerQueue;14480},1448114482/**14483* `PooledClass` looks for this, and will invoke this before allowing this14484* instance to be resused.14485*/14486destructor: function() {14487CallbackQueue.release(this.reactMountReady);14488this.reactMountReady = null;1448914490ReactPutListenerQueue.release(this.putListenerQueue);14491this.putListenerQueue = null;14492}14493};144941449514496assign(14497ReactServerRenderingTransaction.prototype,14498Transaction.Mixin,14499Mixin14500);1450114502PooledClass.addPoolingTo(ReactServerRenderingTransaction);1450314504module.exports = ReactServerRenderingTransaction;1450514506},{"103":103,"114":114,"27":27,"28":28,"6":6,"79":79}],86:[function(_dereq_,module,exports){14507/**14508* Copyright 2015, Facebook, Inc.14509* All rights reserved.14510*14511* This source code is licensed under the BSD-style license found in the14512* LICENSE file in the root directory of this source tree. An additional grant14513* of patent rights can be found in the PATENTS file in the same directory.14514*14515* @providesModule ReactUpdateQueue14516*/1451714518'use strict';1451914520var ReactLifeCycle = _dereq_(68);14521var ReactCurrentOwner = _dereq_(39);14522var ReactElement = _dereq_(57);14523var ReactInstanceMap = _dereq_(67);14524var ReactUpdates = _dereq_(87);1452514526var assign = _dereq_(27);14527var invariant = _dereq_(135);14528var warning = _dereq_(154);1452914530function enqueueUpdate(internalInstance) {14531if (internalInstance !== ReactLifeCycle.currentlyMountingInstance) {14532// If we're in a componentWillMount handler, don't enqueue a rerender14533// because ReactUpdates assumes we're in a browser context (which is14534// wrong for server rendering) and we're about to do a render anyway.14535// See bug in #1740.14536ReactUpdates.enqueueUpdate(internalInstance);14537}14538}1453914540function getInternalInstanceReadyForUpdate(publicInstance, callerName) {14541("production" !== "development" ? invariant(14542ReactCurrentOwner.current == null,14543'%s(...): Cannot update during an existing state transition ' +14544'(such as within `render`). Render methods should be a pure function ' +14545'of props and state.',14546callerName14547) : invariant(ReactCurrentOwner.current == null));1454814549var internalInstance = ReactInstanceMap.get(publicInstance);14550if (!internalInstance) {14551if ("production" !== "development") {14552// Only warn when we have a callerName. Otherwise we should be silent.14553// We're probably calling from enqueueCallback. We don't want to warn14554// there because we already warned for the corresponding lifecycle method.14555("production" !== "development" ? warning(14556!callerName,14557'%s(...): Can only update a mounted or mounting component. ' +14558'This usually means you called %s() on an unmounted ' +14559'component. This is a no-op.',14560callerName,14561callerName14562) : null);14563}14564return null;14565}1456614567if (internalInstance === ReactLifeCycle.currentlyUnmountingInstance) {14568return null;14569}1457014571return internalInstance;14572}1457314574/**14575* ReactUpdateQueue allows for state updates to be scheduled into a later14576* reconciliation step.14577*/14578var ReactUpdateQueue = {1457914580/**14581* Enqueue a callback that will be executed after all the pending updates14582* have processed.14583*14584* @param {ReactClass} publicInstance The instance to use as `this` context.14585* @param {?function} callback Called after state is updated.14586* @internal14587*/14588enqueueCallback: function(publicInstance, callback) {14589("production" !== "development" ? invariant(14590typeof callback === 'function',14591'enqueueCallback(...): You called `setProps`, `replaceProps`, ' +14592'`setState`, `replaceState`, or `forceUpdate` with a callback that ' +14593'isn\'t callable.'14594) : invariant(typeof callback === 'function'));14595var internalInstance = getInternalInstanceReadyForUpdate(publicInstance);1459614597// Previously we would throw an error if we didn't have an internal14598// instance. Since we want to make it a no-op instead, we mirror the same14599// behavior we have in other enqueue* methods.14600// We also need to ignore callbacks in componentWillMount. See14601// enqueueUpdates.14602if (!internalInstance ||14603internalInstance === ReactLifeCycle.currentlyMountingInstance) {14604return null;14605}1460614607if (internalInstance._pendingCallbacks) {14608internalInstance._pendingCallbacks.push(callback);14609} else {14610internalInstance._pendingCallbacks = [callback];14611}14612// TODO: The callback here is ignored when setState is called from14613// componentWillMount. Either fix it or disallow doing so completely in14614// favor of getInitialState. Alternatively, we can disallow14615// componentWillMount during server-side rendering.14616enqueueUpdate(internalInstance);14617},1461814619enqueueCallbackInternal: function(internalInstance, callback) {14620("production" !== "development" ? invariant(14621typeof callback === 'function',14622'enqueueCallback(...): You called `setProps`, `replaceProps`, ' +14623'`setState`, `replaceState`, or `forceUpdate` with a callback that ' +14624'isn\'t callable.'14625) : invariant(typeof callback === 'function'));14626if (internalInstance._pendingCallbacks) {14627internalInstance._pendingCallbacks.push(callback);14628} else {14629internalInstance._pendingCallbacks = [callback];14630}14631enqueueUpdate(internalInstance);14632},1463314634/**14635* Forces an update. This should only be invoked when it is known with14636* certainty that we are **not** in a DOM transaction.14637*14638* You may want to call this when you know that some deeper aspect of the14639* component's state has changed but `setState` was not called.14640*14641* This will not invoke `shouldUpdateComponent`, but it will invoke14642* `componentWillUpdate` and `componentDidUpdate`.14643*14644* @param {ReactClass} publicInstance The instance that should rerender.14645* @internal14646*/14647enqueueForceUpdate: function(publicInstance) {14648var internalInstance = getInternalInstanceReadyForUpdate(14649publicInstance,14650'forceUpdate'14651);1465214653if (!internalInstance) {14654return;14655}1465614657internalInstance._pendingForceUpdate = true;1465814659enqueueUpdate(internalInstance);14660},1466114662/**14663* Replaces all of the state. Always use this or `setState` to mutate state.14664* You should treat `this.state` as immutable.14665*14666* There is no guarantee that `this.state` will be immediately updated, so14667* accessing `this.state` after calling this method may return the old value.14668*14669* @param {ReactClass} publicInstance The instance that should rerender.14670* @param {object} completeState Next state.14671* @internal14672*/14673enqueueReplaceState: function(publicInstance, completeState) {14674var internalInstance = getInternalInstanceReadyForUpdate(14675publicInstance,14676'replaceState'14677);1467814679if (!internalInstance) {14680return;14681}1468214683internalInstance._pendingStateQueue = [completeState];14684internalInstance._pendingReplaceState = true;1468514686enqueueUpdate(internalInstance);14687},1468814689/**14690* Sets a subset of the state. This only exists because _pendingState is14691* internal. This provides a merging strategy that is not available to deep14692* properties which is confusing. TODO: Expose pendingState or don't use it14693* during the merge.14694*14695* @param {ReactClass} publicInstance The instance that should rerender.14696* @param {object} partialState Next partial state to be merged with state.14697* @internal14698*/14699enqueueSetState: function(publicInstance, partialState) {14700var internalInstance = getInternalInstanceReadyForUpdate(14701publicInstance,14702'setState'14703);1470414705if (!internalInstance) {14706return;14707}1470814709var queue =14710internalInstance._pendingStateQueue ||14711(internalInstance._pendingStateQueue = []);14712queue.push(partialState);1471314714enqueueUpdate(internalInstance);14715},1471614717/**14718* Sets a subset of the props.14719*14720* @param {ReactClass} publicInstance The instance that should rerender.14721* @param {object} partialProps Subset of the next props.14722* @internal14723*/14724enqueueSetProps: function(publicInstance, partialProps) {14725var internalInstance = getInternalInstanceReadyForUpdate(14726publicInstance,14727'setProps'14728);1472914730if (!internalInstance) {14731return;14732}1473314734("production" !== "development" ? invariant(14735internalInstance._isTopLevel,14736'setProps(...): You called `setProps` on a ' +14737'component with a parent. This is an anti-pattern since props will ' +14738'get reactively updated when rendered. Instead, change the owner\'s ' +14739'`render` method to pass the correct value as props to the component ' +14740'where it is created.'14741) : invariant(internalInstance._isTopLevel));1474214743// Merge with the pending element if it exists, otherwise with existing14744// element props.14745var element = internalInstance._pendingElement ||14746internalInstance._currentElement;14747var props = assign({}, element.props, partialProps);14748internalInstance._pendingElement = ReactElement.cloneAndReplaceProps(14749element,14750props14751);1475214753enqueueUpdate(internalInstance);14754},1475514756/**14757* Replaces all of the props.14758*14759* @param {ReactClass} publicInstance The instance that should rerender.14760* @param {object} props New props.14761* @internal14762*/14763enqueueReplaceProps: function(publicInstance, props) {14764var internalInstance = getInternalInstanceReadyForUpdate(14765publicInstance,14766'replaceProps'14767);1476814769if (!internalInstance) {14770return;14771}1477214773("production" !== "development" ? invariant(14774internalInstance._isTopLevel,14775'replaceProps(...): You called `replaceProps` on a ' +14776'component with a parent. This is an anti-pattern since props will ' +14777'get reactively updated when rendered. Instead, change the owner\'s ' +14778'`render` method to pass the correct value as props to the component ' +14779'where it is created.'14780) : invariant(internalInstance._isTopLevel));1478114782// Merge with the pending element if it exists, otherwise with existing14783// element props.14784var element = internalInstance._pendingElement ||14785internalInstance._currentElement;14786internalInstance._pendingElement = ReactElement.cloneAndReplaceProps(14787element,14788props14789);1479014791enqueueUpdate(internalInstance);14792},1479314794enqueueElementInternal: function(internalInstance, newElement) {14795internalInstance._pendingElement = newElement;14796enqueueUpdate(internalInstance);14797}1479814799};1480014801module.exports = ReactUpdateQueue;1480214803},{"135":135,"154":154,"27":27,"39":39,"57":57,"67":67,"68":68,"87":87}],87:[function(_dereq_,module,exports){14804/**14805* Copyright 2013-2015, Facebook, Inc.14806* All rights reserved.14807*14808* This source code is licensed under the BSD-style license found in the14809* LICENSE file in the root directory of this source tree. An additional grant14810* of patent rights can be found in the PATENTS file in the same directory.14811*14812* @providesModule ReactUpdates14813*/1481414815'use strict';1481614817var CallbackQueue = _dereq_(6);14818var PooledClass = _dereq_(28);14819var ReactCurrentOwner = _dereq_(39);14820var ReactPerf = _dereq_(75);14821var ReactReconciler = _dereq_(81);14822var Transaction = _dereq_(103);1482314824var assign = _dereq_(27);14825var invariant = _dereq_(135);14826var warning = _dereq_(154);1482714828var dirtyComponents = [];14829var asapCallbackQueue = CallbackQueue.getPooled();14830var asapEnqueued = false;1483114832var batchingStrategy = null;1483314834function ensureInjected() {14835("production" !== "development" ? invariant(14836ReactUpdates.ReactReconcileTransaction && batchingStrategy,14837'ReactUpdates: must inject a reconcile transaction class and batching ' +14838'strategy'14839) : invariant(ReactUpdates.ReactReconcileTransaction && batchingStrategy));14840}1484114842var NESTED_UPDATES = {14843initialize: function() {14844this.dirtyComponentsLength = dirtyComponents.length;14845},14846close: function() {14847if (this.dirtyComponentsLength !== dirtyComponents.length) {14848// Additional updates were enqueued by componentDidUpdate handlers or14849// similar; before our own UPDATE_QUEUEING wrapper closes, we want to run14850// these new updates so that if A's componentDidUpdate calls setState on14851// B, B will update before the callback A's updater provided when calling14852// setState.14853dirtyComponents.splice(0, this.dirtyComponentsLength);14854flushBatchedUpdates();14855} else {14856dirtyComponents.length = 0;14857}14858}14859};1486014861var UPDATE_QUEUEING = {14862initialize: function() {14863this.callbackQueue.reset();14864},14865close: function() {14866this.callbackQueue.notifyAll();14867}14868};1486914870var TRANSACTION_WRAPPERS = [NESTED_UPDATES, UPDATE_QUEUEING];1487114872function ReactUpdatesFlushTransaction() {14873this.reinitializeTransaction();14874this.dirtyComponentsLength = null;14875this.callbackQueue = CallbackQueue.getPooled();14876this.reconcileTransaction =14877ReactUpdates.ReactReconcileTransaction.getPooled();14878}1487914880assign(14881ReactUpdatesFlushTransaction.prototype,14882Transaction.Mixin, {14883getTransactionWrappers: function() {14884return TRANSACTION_WRAPPERS;14885},1488614887destructor: function() {14888this.dirtyComponentsLength = null;14889CallbackQueue.release(this.callbackQueue);14890this.callbackQueue = null;14891ReactUpdates.ReactReconcileTransaction.release(this.reconcileTransaction);14892this.reconcileTransaction = null;14893},1489414895perform: function(method, scope, a) {14896// Essentially calls `this.reconcileTransaction.perform(method, scope, a)`14897// with this transaction's wrappers around it.14898return Transaction.Mixin.perform.call(14899this,14900this.reconcileTransaction.perform,14901this.reconcileTransaction,14902method,14903scope,14904a14905);14906}14907});1490814909PooledClass.addPoolingTo(ReactUpdatesFlushTransaction);1491014911function batchedUpdates(callback, a, b, c, d) {14912ensureInjected();14913batchingStrategy.batchedUpdates(callback, a, b, c, d);14914}1491514916/**14917* Array comparator for ReactComponents by mount ordering.14918*14919* @param {ReactComponent} c1 first component you're comparing14920* @param {ReactComponent} c2 second component you're comparing14921* @return {number} Return value usable by Array.prototype.sort().14922*/14923function mountOrderComparator(c1, c2) {14924return c1._mountOrder - c2._mountOrder;14925}1492614927function runBatchedUpdates(transaction) {14928var len = transaction.dirtyComponentsLength;14929("production" !== "development" ? invariant(14930len === dirtyComponents.length,14931'Expected flush transaction\'s stored dirty-components length (%s) to ' +14932'match dirty-components array length (%s).',14933len,14934dirtyComponents.length14935) : invariant(len === dirtyComponents.length));1493614937// Since reconciling a component higher in the owner hierarchy usually (not14938// always -- see shouldComponentUpdate()) will reconcile children, reconcile14939// them before their children by sorting the array.14940dirtyComponents.sort(mountOrderComparator);1494114942for (var i = 0; i < len; i++) {14943// If a component is unmounted before pending changes apply, it will still14944// be here, but we assume that it has cleared its _pendingCallbacks and14945// that performUpdateIfNecessary is a noop.14946var component = dirtyComponents[i];1494714948// If performUpdateIfNecessary happens to enqueue any new updates, we14949// shouldn't execute the callbacks until the next render happens, so14950// stash the callbacks first14951var callbacks = component._pendingCallbacks;14952component._pendingCallbacks = null;1495314954ReactReconciler.performUpdateIfNecessary(14955component,14956transaction.reconcileTransaction14957);1495814959if (callbacks) {14960for (var j = 0; j < callbacks.length; j++) {14961transaction.callbackQueue.enqueue(14962callbacks[j],14963component.getPublicInstance()14964);14965}14966}14967}14968}1496914970var flushBatchedUpdates = function() {14971// ReactUpdatesFlushTransaction's wrappers will clear the dirtyComponents14972// array and perform any updates enqueued by mount-ready handlers (i.e.,14973// componentDidUpdate) but we need to check here too in order to catch14974// updates enqueued by setState callbacks and asap calls.14975while (dirtyComponents.length || asapEnqueued) {14976if (dirtyComponents.length) {14977var transaction = ReactUpdatesFlushTransaction.getPooled();14978transaction.perform(runBatchedUpdates, null, transaction);14979ReactUpdatesFlushTransaction.release(transaction);14980}1498114982if (asapEnqueued) {14983asapEnqueued = false;14984var queue = asapCallbackQueue;14985asapCallbackQueue = CallbackQueue.getPooled();14986queue.notifyAll();14987CallbackQueue.release(queue);14988}14989}14990};14991flushBatchedUpdates = ReactPerf.measure(14992'ReactUpdates',14993'flushBatchedUpdates',14994flushBatchedUpdates14995);1499614997/**14998* Mark a component as needing a rerender, adding an optional callback to a14999* list of functions which will be executed once the rerender occurs.15000*/15001function enqueueUpdate(component) {15002ensureInjected();1500315004// Various parts of our code (such as ReactCompositeComponent's15005// _renderValidatedComponent) assume that calls to render aren't nested;15006// verify that that's the case. (This is called by each top-level update15007// function, like setProps, setState, forceUpdate, etc.; creation and15008// destruction of top-level components is guarded in ReactMount.)15009("production" !== "development" ? warning(15010ReactCurrentOwner.current == null,15011'enqueueUpdate(): Render methods should be a pure function of props ' +15012'and state; triggering nested component updates from render is not ' +15013'allowed. If necessary, trigger nested updates in ' +15014'componentDidUpdate.'15015) : null);1501615017if (!batchingStrategy.isBatchingUpdates) {15018batchingStrategy.batchedUpdates(enqueueUpdate, component);15019return;15020}1502115022dirtyComponents.push(component);15023}1502415025/**15026* Enqueue a callback to be run at the end of the current batching cycle. Throws15027* if no updates are currently being performed.15028*/15029function asap(callback, context) {15030("production" !== "development" ? invariant(15031batchingStrategy.isBatchingUpdates,15032'ReactUpdates.asap: Can\'t enqueue an asap callback in a context where' +15033'updates are not being batched.'15034) : invariant(batchingStrategy.isBatchingUpdates));15035asapCallbackQueue.enqueue(callback, context);15036asapEnqueued = true;15037}1503815039var ReactUpdatesInjection = {15040injectReconcileTransaction: function(ReconcileTransaction) {15041("production" !== "development" ? invariant(15042ReconcileTransaction,15043'ReactUpdates: must provide a reconcile transaction class'15044) : invariant(ReconcileTransaction));15045ReactUpdates.ReactReconcileTransaction = ReconcileTransaction;15046},1504715048injectBatchingStrategy: function(_batchingStrategy) {15049("production" !== "development" ? invariant(15050_batchingStrategy,15051'ReactUpdates: must provide a batching strategy'15052) : invariant(_batchingStrategy));15053("production" !== "development" ? invariant(15054typeof _batchingStrategy.batchedUpdates === 'function',15055'ReactUpdates: must provide a batchedUpdates() function'15056) : invariant(typeof _batchingStrategy.batchedUpdates === 'function'));15057("production" !== "development" ? invariant(15058typeof _batchingStrategy.isBatchingUpdates === 'boolean',15059'ReactUpdates: must provide an isBatchingUpdates boolean attribute'15060) : invariant(typeof _batchingStrategy.isBatchingUpdates === 'boolean'));15061batchingStrategy = _batchingStrategy;15062}15063};1506415065var ReactUpdates = {15066/**15067* React references `ReactReconcileTransaction` using this property in order15068* to allow dependency injection.15069*15070* @internal15071*/15072ReactReconcileTransaction: null,1507315074batchedUpdates: batchedUpdates,15075enqueueUpdate: enqueueUpdate,15076flushBatchedUpdates: flushBatchedUpdates,15077injection: ReactUpdatesInjection,15078asap: asap15079};1508015081module.exports = ReactUpdates;1508215083},{"103":103,"135":135,"154":154,"27":27,"28":28,"39":39,"6":6,"75":75,"81":81}],88:[function(_dereq_,module,exports){15084/**15085* Copyright 2013-2015, Facebook, Inc.15086* All rights reserved.15087*15088* This source code is licensed under the BSD-style license found in the15089* LICENSE file in the root directory of this source tree. An additional grant15090* of patent rights can be found in the PATENTS file in the same directory.15091*15092* @providesModule SVGDOMPropertyConfig15093*/1509415095/*jslint bitwise: true*/1509615097'use strict';1509815099var DOMProperty = _dereq_(10);1510015101var MUST_USE_ATTRIBUTE = DOMProperty.injection.MUST_USE_ATTRIBUTE;1510215103var SVGDOMPropertyConfig = {15104Properties: {15105clipPath: MUST_USE_ATTRIBUTE,15106cx: MUST_USE_ATTRIBUTE,15107cy: MUST_USE_ATTRIBUTE,15108d: MUST_USE_ATTRIBUTE,15109dx: MUST_USE_ATTRIBUTE,15110dy: MUST_USE_ATTRIBUTE,15111fill: MUST_USE_ATTRIBUTE,15112fillOpacity: MUST_USE_ATTRIBUTE,15113fontFamily: MUST_USE_ATTRIBUTE,15114fontSize: MUST_USE_ATTRIBUTE,15115fx: MUST_USE_ATTRIBUTE,15116fy: MUST_USE_ATTRIBUTE,15117gradientTransform: MUST_USE_ATTRIBUTE,15118gradientUnits: MUST_USE_ATTRIBUTE,15119markerEnd: MUST_USE_ATTRIBUTE,15120markerMid: MUST_USE_ATTRIBUTE,15121markerStart: MUST_USE_ATTRIBUTE,15122offset: MUST_USE_ATTRIBUTE,15123opacity: MUST_USE_ATTRIBUTE,15124patternContentUnits: MUST_USE_ATTRIBUTE,15125patternUnits: MUST_USE_ATTRIBUTE,15126points: MUST_USE_ATTRIBUTE,15127preserveAspectRatio: MUST_USE_ATTRIBUTE,15128r: MUST_USE_ATTRIBUTE,15129rx: MUST_USE_ATTRIBUTE,15130ry: MUST_USE_ATTRIBUTE,15131spreadMethod: MUST_USE_ATTRIBUTE,15132stopColor: MUST_USE_ATTRIBUTE,15133stopOpacity: MUST_USE_ATTRIBUTE,15134stroke: MUST_USE_ATTRIBUTE,15135strokeDasharray: MUST_USE_ATTRIBUTE,15136strokeLinecap: MUST_USE_ATTRIBUTE,15137strokeOpacity: MUST_USE_ATTRIBUTE,15138strokeWidth: MUST_USE_ATTRIBUTE,15139textAnchor: MUST_USE_ATTRIBUTE,15140transform: MUST_USE_ATTRIBUTE,15141version: MUST_USE_ATTRIBUTE,15142viewBox: MUST_USE_ATTRIBUTE,15143x1: MUST_USE_ATTRIBUTE,15144x2: MUST_USE_ATTRIBUTE,15145x: MUST_USE_ATTRIBUTE,15146y1: MUST_USE_ATTRIBUTE,15147y2: MUST_USE_ATTRIBUTE,15148y: MUST_USE_ATTRIBUTE15149},15150DOMAttributeNames: {15151clipPath: 'clip-path',15152fillOpacity: 'fill-opacity',15153fontFamily: 'font-family',15154fontSize: 'font-size',15155gradientTransform: 'gradientTransform',15156gradientUnits: 'gradientUnits',15157markerEnd: 'marker-end',15158markerMid: 'marker-mid',15159markerStart: 'marker-start',15160patternContentUnits: 'patternContentUnits',15161patternUnits: 'patternUnits',15162preserveAspectRatio: 'preserveAspectRatio',15163spreadMethod: 'spreadMethod',15164stopColor: 'stop-color',15165stopOpacity: 'stop-opacity',15166strokeDasharray: 'stroke-dasharray',15167strokeLinecap: 'stroke-linecap',15168strokeOpacity: 'stroke-opacity',15169strokeWidth: 'stroke-width',15170textAnchor: 'text-anchor',15171viewBox: 'viewBox'15172}15173};1517415175module.exports = SVGDOMPropertyConfig;1517615177},{"10":10}],89:[function(_dereq_,module,exports){15178/**15179* Copyright 2013-2015, Facebook, Inc.15180* All rights reserved.15181*15182* This source code is licensed under the BSD-style license found in the15183* LICENSE file in the root directory of this source tree. An additional grant15184* of patent rights can be found in the PATENTS file in the same directory.15185*15186* @providesModule SelectEventPlugin15187*/1518815189'use strict';1519015191var EventConstants = _dereq_(15);15192var EventPropagators = _dereq_(20);15193var ReactInputSelection = _dereq_(65);15194var SyntheticEvent = _dereq_(95);1519515196var getActiveElement = _dereq_(121);15197var isTextInputElement = _dereq_(138);15198var keyOf = _dereq_(141);15199var shallowEqual = _dereq_(150);1520015201var topLevelTypes = EventConstants.topLevelTypes;1520215203var eventTypes = {15204select: {15205phasedRegistrationNames: {15206bubbled: keyOf({onSelect: null}),15207captured: keyOf({onSelectCapture: null})15208},15209dependencies: [15210topLevelTypes.topBlur,15211topLevelTypes.topContextMenu,15212topLevelTypes.topFocus,15213topLevelTypes.topKeyDown,15214topLevelTypes.topMouseDown,15215topLevelTypes.topMouseUp,15216topLevelTypes.topSelectionChange15217]15218}15219};1522015221var activeElement = null;15222var activeElementID = null;15223var lastSelection = null;15224var mouseDown = false;1522515226/**15227* Get an object which is a unique representation of the current selection.15228*15229* The return value will not be consistent across nodes or browsers, but15230* two identical selections on the same node will return identical objects.15231*15232* @param {DOMElement} node15233* @param {object}15234*/15235function getSelection(node) {15236if ('selectionStart' in node &&15237ReactInputSelection.hasSelectionCapabilities(node)) {15238return {15239start: node.selectionStart,15240end: node.selectionEnd15241};15242} else if (window.getSelection) {15243var selection = window.getSelection();15244return {15245anchorNode: selection.anchorNode,15246anchorOffset: selection.anchorOffset,15247focusNode: selection.focusNode,15248focusOffset: selection.focusOffset15249};15250} else if (document.selection) {15251var range = document.selection.createRange();15252return {15253parentElement: range.parentElement(),15254text: range.text,15255top: range.boundingTop,15256left: range.boundingLeft15257};15258}15259}1526015261/**15262* Poll selection to see whether it's changed.15263*15264* @param {object} nativeEvent15265* @return {?SyntheticEvent}15266*/15267function constructSelectEvent(nativeEvent) {15268// Ensure we have the right element, and that the user is not dragging a15269// selection (this matches native `select` event behavior). In HTML5, select15270// fires only on input and textarea thus if there's no focused element we15271// won't dispatch.15272if (mouseDown ||15273activeElement == null ||15274activeElement !== getActiveElement()) {15275return null;15276}1527715278// Only fire when selection has actually changed.15279var currentSelection = getSelection(activeElement);15280if (!lastSelection || !shallowEqual(lastSelection, currentSelection)) {15281lastSelection = currentSelection;1528215283var syntheticEvent = SyntheticEvent.getPooled(15284eventTypes.select,15285activeElementID,15286nativeEvent15287);1528815289syntheticEvent.type = 'select';15290syntheticEvent.target = activeElement;1529115292EventPropagators.accumulateTwoPhaseDispatches(syntheticEvent);1529315294return syntheticEvent;15295}15296}1529715298/**15299* This plugin creates an `onSelect` event that normalizes select events15300* across form elements.15301*15302* Supported elements are:15303* - input (see `isTextInputElement`)15304* - textarea15305* - contentEditable15306*15307* This differs from native browser implementations in the following ways:15308* - Fires on contentEditable fields as well as inputs.15309* - Fires for collapsed selection.15310* - Fires after user input.15311*/15312var SelectEventPlugin = {1531315314eventTypes: eventTypes,1531515316/**15317* @param {string} topLevelType Record from `EventConstants`.15318* @param {DOMEventTarget} topLevelTarget The listening component root node.15319* @param {string} topLevelTargetID ID of `topLevelTarget`.15320* @param {object} nativeEvent Native browser event.15321* @return {*} An accumulation of synthetic events.15322* @see {EventPluginHub.extractEvents}15323*/15324extractEvents: function(15325topLevelType,15326topLevelTarget,15327topLevelTargetID,15328nativeEvent) {1532915330switch (topLevelType) {15331// Track the input node that has focus.15332case topLevelTypes.topFocus:15333if (isTextInputElement(topLevelTarget) ||15334topLevelTarget.contentEditable === 'true') {15335activeElement = topLevelTarget;15336activeElementID = topLevelTargetID;15337lastSelection = null;15338}15339break;15340case topLevelTypes.topBlur:15341activeElement = null;15342activeElementID = null;15343lastSelection = null;15344break;1534515346// Don't fire the event while the user is dragging. This matches the15347// semantics of the native select event.15348case topLevelTypes.topMouseDown:15349mouseDown = true;15350break;15351case topLevelTypes.topContextMenu:15352case topLevelTypes.topMouseUp:15353mouseDown = false;15354return constructSelectEvent(nativeEvent);1535515356// Chrome and IE fire non-standard event when selection is changed (and15357// sometimes when it hasn't).15358// Firefox doesn't support selectionchange, so check selection status15359// after each key entry. The selection changes after keydown and before15360// keyup, but we check on keydown as well in the case of holding down a15361// key, when multiple keydown events are fired but only one keyup is.15362case topLevelTypes.topSelectionChange:15363case topLevelTypes.topKeyDown:15364case topLevelTypes.topKeyUp:15365return constructSelectEvent(nativeEvent);15366}15367}15368};1536915370module.exports = SelectEventPlugin;1537115372},{"121":121,"138":138,"141":141,"15":15,"150":150,"20":20,"65":65,"95":95}],90:[function(_dereq_,module,exports){15373/**15374* Copyright 2013-2015, Facebook, Inc.15375* All rights reserved.15376*15377* This source code is licensed under the BSD-style license found in the15378* LICENSE file in the root directory of this source tree. An additional grant15379* of patent rights can be found in the PATENTS file in the same directory.15380*15381* @providesModule ServerReactRootIndex15382* @typechecks15383*/1538415385'use strict';1538615387/**15388* Size of the reactRoot ID space. We generate random numbers for React root15389* IDs and if there's a collision the events and DOM update system will15390* get confused. In the future we need a way to generate GUIDs but for15391* now this will work on a smaller scale.15392*/15393var GLOBAL_MOUNT_POINT_MAX = Math.pow(2, 53);1539415395var ServerReactRootIndex = {15396createReactRootIndex: function() {15397return Math.ceil(Math.random() * GLOBAL_MOUNT_POINT_MAX);15398}15399};1540015401module.exports = ServerReactRootIndex;1540215403},{}],91:[function(_dereq_,module,exports){15404/**15405* Copyright 2013-2015, Facebook, Inc.15406* All rights reserved.15407*15408* This source code is licensed under the BSD-style license found in the15409* LICENSE file in the root directory of this source tree. An additional grant15410* of patent rights can be found in the PATENTS file in the same directory.15411*15412* @providesModule SimpleEventPlugin15413*/1541415415'use strict';1541615417var EventConstants = _dereq_(15);15418var EventPluginUtils = _dereq_(19);15419var EventPropagators = _dereq_(20);15420var SyntheticClipboardEvent = _dereq_(92);15421var SyntheticEvent = _dereq_(95);15422var SyntheticFocusEvent = _dereq_(96);15423var SyntheticKeyboardEvent = _dereq_(98);15424var SyntheticMouseEvent = _dereq_(99);15425var SyntheticDragEvent = _dereq_(94);15426var SyntheticTouchEvent = _dereq_(100);15427var SyntheticUIEvent = _dereq_(101);15428var SyntheticWheelEvent = _dereq_(102);1542915430var getEventCharCode = _dereq_(122);1543115432var invariant = _dereq_(135);15433var keyOf = _dereq_(141);15434var warning = _dereq_(154);1543515436var topLevelTypes = EventConstants.topLevelTypes;1543715438var eventTypes = {15439blur: {15440phasedRegistrationNames: {15441bubbled: keyOf({onBlur: true}),15442captured: keyOf({onBlurCapture: true})15443}15444},15445click: {15446phasedRegistrationNames: {15447bubbled: keyOf({onClick: true}),15448captured: keyOf({onClickCapture: true})15449}15450},15451contextMenu: {15452phasedRegistrationNames: {15453bubbled: keyOf({onContextMenu: true}),15454captured: keyOf({onContextMenuCapture: true})15455}15456},15457copy: {15458phasedRegistrationNames: {15459bubbled: keyOf({onCopy: true}),15460captured: keyOf({onCopyCapture: true})15461}15462},15463cut: {15464phasedRegistrationNames: {15465bubbled: keyOf({onCut: true}),15466captured: keyOf({onCutCapture: true})15467}15468},15469doubleClick: {15470phasedRegistrationNames: {15471bubbled: keyOf({onDoubleClick: true}),15472captured: keyOf({onDoubleClickCapture: true})15473}15474},15475drag: {15476phasedRegistrationNames: {15477bubbled: keyOf({onDrag: true}),15478captured: keyOf({onDragCapture: true})15479}15480},15481dragEnd: {15482phasedRegistrationNames: {15483bubbled: keyOf({onDragEnd: true}),15484captured: keyOf({onDragEndCapture: true})15485}15486},15487dragEnter: {15488phasedRegistrationNames: {15489bubbled: keyOf({onDragEnter: true}),15490captured: keyOf({onDragEnterCapture: true})15491}15492},15493dragExit: {15494phasedRegistrationNames: {15495bubbled: keyOf({onDragExit: true}),15496captured: keyOf({onDragExitCapture: true})15497}15498},15499dragLeave: {15500phasedRegistrationNames: {15501bubbled: keyOf({onDragLeave: true}),15502captured: keyOf({onDragLeaveCapture: true})15503}15504},15505dragOver: {15506phasedRegistrationNames: {15507bubbled: keyOf({onDragOver: true}),15508captured: keyOf({onDragOverCapture: true})15509}15510},15511dragStart: {15512phasedRegistrationNames: {15513bubbled: keyOf({onDragStart: true}),15514captured: keyOf({onDragStartCapture: true})15515}15516},15517drop: {15518phasedRegistrationNames: {15519bubbled: keyOf({onDrop: true}),15520captured: keyOf({onDropCapture: true})15521}15522},15523focus: {15524phasedRegistrationNames: {15525bubbled: keyOf({onFocus: true}),15526captured: keyOf({onFocusCapture: true})15527}15528},15529input: {15530phasedRegistrationNames: {15531bubbled: keyOf({onInput: true}),15532captured: keyOf({onInputCapture: true})15533}15534},15535keyDown: {15536phasedRegistrationNames: {15537bubbled: keyOf({onKeyDown: true}),15538captured: keyOf({onKeyDownCapture: true})15539}15540},15541keyPress: {15542phasedRegistrationNames: {15543bubbled: keyOf({onKeyPress: true}),15544captured: keyOf({onKeyPressCapture: true})15545}15546},15547keyUp: {15548phasedRegistrationNames: {15549bubbled: keyOf({onKeyUp: true}),15550captured: keyOf({onKeyUpCapture: true})15551}15552},15553load: {15554phasedRegistrationNames: {15555bubbled: keyOf({onLoad: true}),15556captured: keyOf({onLoadCapture: true})15557}15558},15559error: {15560phasedRegistrationNames: {15561bubbled: keyOf({onError: true}),15562captured: keyOf({onErrorCapture: true})15563}15564},15565// Note: We do not allow listening to mouseOver events. Instead, use the15566// onMouseEnter/onMouseLeave created by `EnterLeaveEventPlugin`.15567mouseDown: {15568phasedRegistrationNames: {15569bubbled: keyOf({onMouseDown: true}),15570captured: keyOf({onMouseDownCapture: true})15571}15572},15573mouseMove: {15574phasedRegistrationNames: {15575bubbled: keyOf({onMouseMove: true}),15576captured: keyOf({onMouseMoveCapture: true})15577}15578},15579mouseOut: {15580phasedRegistrationNames: {15581bubbled: keyOf({onMouseOut: true}),15582captured: keyOf({onMouseOutCapture: true})15583}15584},15585mouseOver: {15586phasedRegistrationNames: {15587bubbled: keyOf({onMouseOver: true}),15588captured: keyOf({onMouseOverCapture: true})15589}15590},15591mouseUp: {15592phasedRegistrationNames: {15593bubbled: keyOf({onMouseUp: true}),15594captured: keyOf({onMouseUpCapture: true})15595}15596},15597paste: {15598phasedRegistrationNames: {15599bubbled: keyOf({onPaste: true}),15600captured: keyOf({onPasteCapture: true})15601}15602},15603reset: {15604phasedRegistrationNames: {15605bubbled: keyOf({onReset: true}),15606captured: keyOf({onResetCapture: true})15607}15608},15609scroll: {15610phasedRegistrationNames: {15611bubbled: keyOf({onScroll: true}),15612captured: keyOf({onScrollCapture: true})15613}15614},15615submit: {15616phasedRegistrationNames: {15617bubbled: keyOf({onSubmit: true}),15618captured: keyOf({onSubmitCapture: true})15619}15620},15621touchCancel: {15622phasedRegistrationNames: {15623bubbled: keyOf({onTouchCancel: true}),15624captured: keyOf({onTouchCancelCapture: true})15625}15626},15627touchEnd: {15628phasedRegistrationNames: {15629bubbled: keyOf({onTouchEnd: true}),15630captured: keyOf({onTouchEndCapture: true})15631}15632},15633touchMove: {15634phasedRegistrationNames: {15635bubbled: keyOf({onTouchMove: true}),15636captured: keyOf({onTouchMoveCapture: true})15637}15638},15639touchStart: {15640phasedRegistrationNames: {15641bubbled: keyOf({onTouchStart: true}),15642captured: keyOf({onTouchStartCapture: true})15643}15644},15645wheel: {15646phasedRegistrationNames: {15647bubbled: keyOf({onWheel: true}),15648captured: keyOf({onWheelCapture: true})15649}15650}15651};1565215653var topLevelEventsToDispatchConfig = {15654topBlur: eventTypes.blur,15655topClick: eventTypes.click,15656topContextMenu: eventTypes.contextMenu,15657topCopy: eventTypes.copy,15658topCut: eventTypes.cut,15659topDoubleClick: eventTypes.doubleClick,15660topDrag: eventTypes.drag,15661topDragEnd: eventTypes.dragEnd,15662topDragEnter: eventTypes.dragEnter,15663topDragExit: eventTypes.dragExit,15664topDragLeave: eventTypes.dragLeave,15665topDragOver: eventTypes.dragOver,15666topDragStart: eventTypes.dragStart,15667topDrop: eventTypes.drop,15668topError: eventTypes.error,15669topFocus: eventTypes.focus,15670topInput: eventTypes.input,15671topKeyDown: eventTypes.keyDown,15672topKeyPress: eventTypes.keyPress,15673topKeyUp: eventTypes.keyUp,15674topLoad: eventTypes.load,15675topMouseDown: eventTypes.mouseDown,15676topMouseMove: eventTypes.mouseMove,15677topMouseOut: eventTypes.mouseOut,15678topMouseOver: eventTypes.mouseOver,15679topMouseUp: eventTypes.mouseUp,15680topPaste: eventTypes.paste,15681topReset: eventTypes.reset,15682topScroll: eventTypes.scroll,15683topSubmit: eventTypes.submit,15684topTouchCancel: eventTypes.touchCancel,15685topTouchEnd: eventTypes.touchEnd,15686topTouchMove: eventTypes.touchMove,15687topTouchStart: eventTypes.touchStart,15688topWheel: eventTypes.wheel15689};1569015691for (var type in topLevelEventsToDispatchConfig) {15692topLevelEventsToDispatchConfig[type].dependencies = [type];15693}1569415695var SimpleEventPlugin = {1569615697eventTypes: eventTypes,1569815699/**15700* Same as the default implementation, except cancels the event when return15701* value is false. This behavior will be disabled in a future release.15702*15703* @param {object} Event to be dispatched.15704* @param {function} Application-level callback.15705* @param {string} domID DOM ID to pass to the callback.15706*/15707executeDispatch: function(event, listener, domID) {15708var returnValue = EventPluginUtils.executeDispatch(event, listener, domID);1570915710("production" !== "development" ? warning(15711typeof returnValue !== 'boolean',15712'Returning `false` from an event handler is deprecated and will be ' +15713'ignored in a future release. Instead, manually call ' +15714'e.stopPropagation() or e.preventDefault(), as appropriate.'15715) : null);1571615717if (returnValue === false) {15718event.stopPropagation();15719event.preventDefault();15720}15721},1572215723/**15724* @param {string} topLevelType Record from `EventConstants`.15725* @param {DOMEventTarget} topLevelTarget The listening component root node.15726* @param {string} topLevelTargetID ID of `topLevelTarget`.15727* @param {object} nativeEvent Native browser event.15728* @return {*} An accumulation of synthetic events.15729* @see {EventPluginHub.extractEvents}15730*/15731extractEvents: function(15732topLevelType,15733topLevelTarget,15734topLevelTargetID,15735nativeEvent) {15736var dispatchConfig = topLevelEventsToDispatchConfig[topLevelType];15737if (!dispatchConfig) {15738return null;15739}15740var EventConstructor;15741switch (topLevelType) {15742case topLevelTypes.topInput:15743case topLevelTypes.topLoad:15744case topLevelTypes.topError:15745case topLevelTypes.topReset:15746case topLevelTypes.topSubmit:15747// HTML Events15748// @see http://www.w3.org/TR/html5/index.html#events-015749EventConstructor = SyntheticEvent;15750break;15751case topLevelTypes.topKeyPress:15752// FireFox creates a keypress event for function keys too. This removes15753// the unwanted keypress events. Enter is however both printable and15754// non-printable. One would expect Tab to be as well (but it isn't).15755if (getEventCharCode(nativeEvent) === 0) {15756return null;15757}15758/* falls through */15759case topLevelTypes.topKeyDown:15760case topLevelTypes.topKeyUp:15761EventConstructor = SyntheticKeyboardEvent;15762break;15763case topLevelTypes.topBlur:15764case topLevelTypes.topFocus:15765EventConstructor = SyntheticFocusEvent;15766break;15767case topLevelTypes.topClick:15768// Firefox creates a click event on right mouse clicks. This removes the15769// unwanted click events.15770if (nativeEvent.button === 2) {15771return null;15772}15773/* falls through */15774case topLevelTypes.topContextMenu:15775case topLevelTypes.topDoubleClick:15776case topLevelTypes.topMouseDown:15777case topLevelTypes.topMouseMove:15778case topLevelTypes.topMouseOut:15779case topLevelTypes.topMouseOver:15780case topLevelTypes.topMouseUp:15781EventConstructor = SyntheticMouseEvent;15782break;15783case topLevelTypes.topDrag:15784case topLevelTypes.topDragEnd:15785case topLevelTypes.topDragEnter:15786case topLevelTypes.topDragExit:15787case topLevelTypes.topDragLeave:15788case topLevelTypes.topDragOver:15789case topLevelTypes.topDragStart:15790case topLevelTypes.topDrop:15791EventConstructor = SyntheticDragEvent;15792break;15793case topLevelTypes.topTouchCancel:15794case topLevelTypes.topTouchEnd:15795case topLevelTypes.topTouchMove:15796case topLevelTypes.topTouchStart:15797EventConstructor = SyntheticTouchEvent;15798break;15799case topLevelTypes.topScroll:15800EventConstructor = SyntheticUIEvent;15801break;15802case topLevelTypes.topWheel:15803EventConstructor = SyntheticWheelEvent;15804break;15805case topLevelTypes.topCopy:15806case topLevelTypes.topCut:15807case topLevelTypes.topPaste:15808EventConstructor = SyntheticClipboardEvent;15809break;15810}15811("production" !== "development" ? invariant(15812EventConstructor,15813'SimpleEventPlugin: Unhandled event type, `%s`.',15814topLevelType15815) : invariant(EventConstructor));15816var event = EventConstructor.getPooled(15817dispatchConfig,15818topLevelTargetID,15819nativeEvent15820);15821EventPropagators.accumulateTwoPhaseDispatches(event);15822return event;15823}1582415825};1582615827module.exports = SimpleEventPlugin;1582815829},{"100":100,"101":101,"102":102,"122":122,"135":135,"141":141,"15":15,"154":154,"19":19,"20":20,"92":92,"94":94,"95":95,"96":96,"98":98,"99":99}],92:[function(_dereq_,module,exports){15830/**15831* Copyright 2013-2015, Facebook, Inc.15832* All rights reserved.15833*15834* This source code is licensed under the BSD-style license found in the15835* LICENSE file in the root directory of this source tree. An additional grant15836* of patent rights can be found in the PATENTS file in the same directory.15837*15838* @providesModule SyntheticClipboardEvent15839* @typechecks static-only15840*/1584115842'use strict';1584315844var SyntheticEvent = _dereq_(95);1584515846/**15847* @interface Event15848* @see http://www.w3.org/TR/clipboard-apis/15849*/15850var ClipboardEventInterface = {15851clipboardData: function(event) {15852return (15853'clipboardData' in event ?15854event.clipboardData :15855window.clipboardData15856);15857}15858};1585915860/**15861* @param {object} dispatchConfig Configuration used to dispatch this event.15862* @param {string} dispatchMarker Marker identifying the event target.15863* @param {object} nativeEvent Native browser event.15864* @extends {SyntheticUIEvent}15865*/15866function SyntheticClipboardEvent(dispatchConfig, dispatchMarker, nativeEvent) {15867SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent);15868}1586915870SyntheticEvent.augmentClass(SyntheticClipboardEvent, ClipboardEventInterface);1587115872module.exports = SyntheticClipboardEvent;1587315874},{"95":95}],93:[function(_dereq_,module,exports){15875/**15876* Copyright 2013-2015, Facebook, Inc.15877* All rights reserved.15878*15879* This source code is licensed under the BSD-style license found in the15880* LICENSE file in the root directory of this source tree. An additional grant15881* of patent rights can be found in the PATENTS file in the same directory.15882*15883* @providesModule SyntheticCompositionEvent15884* @typechecks static-only15885*/1588615887'use strict';1588815889var SyntheticEvent = _dereq_(95);1589015891/**15892* @interface Event15893* @see http://www.w3.org/TR/DOM-Level-3-Events/#events-compositionevents15894*/15895var CompositionEventInterface = {15896data: null15897};1589815899/**15900* @param {object} dispatchConfig Configuration used to dispatch this event.15901* @param {string} dispatchMarker Marker identifying the event target.15902* @param {object} nativeEvent Native browser event.15903* @extends {SyntheticUIEvent}15904*/15905function SyntheticCompositionEvent(15906dispatchConfig,15907dispatchMarker,15908nativeEvent) {15909SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent);15910}1591115912SyntheticEvent.augmentClass(15913SyntheticCompositionEvent,15914CompositionEventInterface15915);1591615917module.exports = SyntheticCompositionEvent;1591815919},{"95":95}],94:[function(_dereq_,module,exports){15920/**15921* Copyright 2013-2015, Facebook, Inc.15922* All rights reserved.15923*15924* This source code is licensed under the BSD-style license found in the15925* LICENSE file in the root directory of this source tree. An additional grant15926* of patent rights can be found in the PATENTS file in the same directory.15927*15928* @providesModule SyntheticDragEvent15929* @typechecks static-only15930*/1593115932'use strict';1593315934var SyntheticMouseEvent = _dereq_(99);1593515936/**15937* @interface DragEvent15938* @see http://www.w3.org/TR/DOM-Level-3-Events/15939*/15940var DragEventInterface = {15941dataTransfer: null15942};1594315944/**15945* @param {object} dispatchConfig Configuration used to dispatch this event.15946* @param {string} dispatchMarker Marker identifying the event target.15947* @param {object} nativeEvent Native browser event.15948* @extends {SyntheticUIEvent}15949*/15950function SyntheticDragEvent(dispatchConfig, dispatchMarker, nativeEvent) {15951SyntheticMouseEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent);15952}1595315954SyntheticMouseEvent.augmentClass(SyntheticDragEvent, DragEventInterface);1595515956module.exports = SyntheticDragEvent;1595715958},{"99":99}],95:[function(_dereq_,module,exports){15959/**15960* Copyright 2013-2015, Facebook, Inc.15961* All rights reserved.15962*15963* This source code is licensed under the BSD-style license found in the15964* LICENSE file in the root directory of this source tree. An additional grant15965* of patent rights can be found in the PATENTS file in the same directory.15966*15967* @providesModule SyntheticEvent15968* @typechecks static-only15969*/1597015971'use strict';1597215973var PooledClass = _dereq_(28);1597415975var assign = _dereq_(27);15976var emptyFunction = _dereq_(114);15977var getEventTarget = _dereq_(125);1597815979/**15980* @interface Event15981* @see http://www.w3.org/TR/DOM-Level-3-Events/15982*/15983var EventInterface = {15984type: null,15985target: getEventTarget,15986// currentTarget is set when dispatching; no use in copying it here15987currentTarget: emptyFunction.thatReturnsNull,15988eventPhase: null,15989bubbles: null,15990cancelable: null,15991timeStamp: function(event) {15992return event.timeStamp || Date.now();15993},15994defaultPrevented: null,15995isTrusted: null15996};1599715998/**15999* Synthetic events are dispatched by event plugins, typically in response to a16000* top-level event delegation handler.16001*16002* These systems should generally use pooling to reduce the frequency of garbage16003* collection. The system should check `isPersistent` to determine whether the16004* event should be released into the pool after being dispatched. Users that16005* need a persisted event should invoke `persist`.16006*16007* Synthetic events (and subclasses) implement the DOM Level 3 Events API by16008* normalizing browser quirks. Subclasses do not necessarily have to implement a16009* DOM interface; custom application-specific events can also subclass this.16010*16011* @param {object} dispatchConfig Configuration used to dispatch this event.16012* @param {string} dispatchMarker Marker identifying the event target.16013* @param {object} nativeEvent Native browser event.16014*/16015function SyntheticEvent(dispatchConfig, dispatchMarker, nativeEvent) {16016this.dispatchConfig = dispatchConfig;16017this.dispatchMarker = dispatchMarker;16018this.nativeEvent = nativeEvent;1601916020var Interface = this.constructor.Interface;16021for (var propName in Interface) {16022if (!Interface.hasOwnProperty(propName)) {16023continue;16024}16025var normalize = Interface[propName];16026if (normalize) {16027this[propName] = normalize(nativeEvent);16028} else {16029this[propName] = nativeEvent[propName];16030}16031}1603216033var defaultPrevented = nativeEvent.defaultPrevented != null ?16034nativeEvent.defaultPrevented :16035nativeEvent.returnValue === false;16036if (defaultPrevented) {16037this.isDefaultPrevented = emptyFunction.thatReturnsTrue;16038} else {16039this.isDefaultPrevented = emptyFunction.thatReturnsFalse;16040}16041this.isPropagationStopped = emptyFunction.thatReturnsFalse;16042}1604316044assign(SyntheticEvent.prototype, {1604516046preventDefault: function() {16047this.defaultPrevented = true;16048var event = this.nativeEvent;16049if (event.preventDefault) {16050event.preventDefault();16051} else {16052event.returnValue = false;16053}16054this.isDefaultPrevented = emptyFunction.thatReturnsTrue;16055},1605616057stopPropagation: function() {16058var event = this.nativeEvent;16059if (event.stopPropagation) {16060event.stopPropagation();16061} else {16062event.cancelBubble = true;16063}16064this.isPropagationStopped = emptyFunction.thatReturnsTrue;16065},1606616067/**16068* We release all dispatched `SyntheticEvent`s after each event loop, adding16069* them back into the pool. This allows a way to hold onto a reference that16070* won't be added back into the pool.16071*/16072persist: function() {16073this.isPersistent = emptyFunction.thatReturnsTrue;16074},1607516076/**16077* Checks if this event should be released back into the pool.16078*16079* @return {boolean} True if this should not be released, false otherwise.16080*/16081isPersistent: emptyFunction.thatReturnsFalse,1608216083/**16084* `PooledClass` looks for `destructor` on each instance it releases.16085*/16086destructor: function() {16087var Interface = this.constructor.Interface;16088for (var propName in Interface) {16089this[propName] = null;16090}16091this.dispatchConfig = null;16092this.dispatchMarker = null;16093this.nativeEvent = null;16094}1609516096});1609716098SyntheticEvent.Interface = EventInterface;1609916100/**16101* Helper to reduce boilerplate when creating subclasses.16102*16103* @param {function} Class16104* @param {?object} Interface16105*/16106SyntheticEvent.augmentClass = function(Class, Interface) {16107var Super = this;1610816109var prototype = Object.create(Super.prototype);16110assign(prototype, Class.prototype);16111Class.prototype = prototype;16112Class.prototype.constructor = Class;1611316114Class.Interface = assign({}, Super.Interface, Interface);16115Class.augmentClass = Super.augmentClass;1611616117PooledClass.addPoolingTo(Class, PooledClass.threeArgumentPooler);16118};1611916120PooledClass.addPoolingTo(SyntheticEvent, PooledClass.threeArgumentPooler);1612116122module.exports = SyntheticEvent;1612316124},{"114":114,"125":125,"27":27,"28":28}],96:[function(_dereq_,module,exports){16125/**16126* Copyright 2013-2015, Facebook, Inc.16127* All rights reserved.16128*16129* This source code is licensed under the BSD-style license found in the16130* LICENSE file in the root directory of this source tree. An additional grant16131* of patent rights can be found in the PATENTS file in the same directory.16132*16133* @providesModule SyntheticFocusEvent16134* @typechecks static-only16135*/1613616137'use strict';1613816139var SyntheticUIEvent = _dereq_(101);1614016141/**16142* @interface FocusEvent16143* @see http://www.w3.org/TR/DOM-Level-3-Events/16144*/16145var FocusEventInterface = {16146relatedTarget: null16147};1614816149/**16150* @param {object} dispatchConfig Configuration used to dispatch this event.16151* @param {string} dispatchMarker Marker identifying the event target.16152* @param {object} nativeEvent Native browser event.16153* @extends {SyntheticUIEvent}16154*/16155function SyntheticFocusEvent(dispatchConfig, dispatchMarker, nativeEvent) {16156SyntheticUIEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent);16157}1615816159SyntheticUIEvent.augmentClass(SyntheticFocusEvent, FocusEventInterface);1616016161module.exports = SyntheticFocusEvent;1616216163},{"101":101}],97:[function(_dereq_,module,exports){16164/**16165* Copyright 2013-2015, Facebook, Inc.16166* All rights reserved.16167*16168* This source code is licensed under the BSD-style license found in the16169* LICENSE file in the root directory of this source tree. An additional grant16170* of patent rights can be found in the PATENTS file in the same directory.16171*16172* @providesModule SyntheticInputEvent16173* @typechecks static-only16174*/1617516176'use strict';1617716178var SyntheticEvent = _dereq_(95);1617916180/**16181* @interface Event16182* @see http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-2013110516183* /#events-inputevents16184*/16185var InputEventInterface = {16186data: null16187};1618816189/**16190* @param {object} dispatchConfig Configuration used to dispatch this event.16191* @param {string} dispatchMarker Marker identifying the event target.16192* @param {object} nativeEvent Native browser event.16193* @extends {SyntheticUIEvent}16194*/16195function SyntheticInputEvent(16196dispatchConfig,16197dispatchMarker,16198nativeEvent) {16199SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent);16200}1620116202SyntheticEvent.augmentClass(16203SyntheticInputEvent,16204InputEventInterface16205);1620616207module.exports = SyntheticInputEvent;1620816209},{"95":95}],98:[function(_dereq_,module,exports){16210/**16211* Copyright 2013-2015, Facebook, Inc.16212* All rights reserved.16213*16214* This source code is licensed under the BSD-style license found in the16215* LICENSE file in the root directory of this source tree. An additional grant16216* of patent rights can be found in the PATENTS file in the same directory.16217*16218* @providesModule SyntheticKeyboardEvent16219* @typechecks static-only16220*/1622116222'use strict';1622316224var SyntheticUIEvent = _dereq_(101);1622516226var getEventCharCode = _dereq_(122);16227var getEventKey = _dereq_(123);16228var getEventModifierState = _dereq_(124);1622916230/**16231* @interface KeyboardEvent16232* @see http://www.w3.org/TR/DOM-Level-3-Events/16233*/16234var KeyboardEventInterface = {16235key: getEventKey,16236location: null,16237ctrlKey: null,16238shiftKey: null,16239altKey: null,16240metaKey: null,16241repeat: null,16242locale: null,16243getModifierState: getEventModifierState,16244// Legacy Interface16245charCode: function(event) {16246// `charCode` is the result of a KeyPress event and represents the value of16247// the actual printable character.1624816249// KeyPress is deprecated, but its replacement is not yet final and not16250// implemented in any major browser. Only KeyPress has charCode.16251if (event.type === 'keypress') {16252return getEventCharCode(event);16253}16254return 0;16255},16256keyCode: function(event) {16257// `keyCode` is the result of a KeyDown/Up event and represents the value of16258// physical keyboard key.1625916260// The actual meaning of the value depends on the users' keyboard layout16261// which cannot be detected. Assuming that it is a US keyboard layout16262// provides a surprisingly accurate mapping for US and European users.16263// Due to this, it is left to the user to implement at this time.16264if (event.type === 'keydown' || event.type === 'keyup') {16265return event.keyCode;16266}16267return 0;16268},16269which: function(event) {16270// `which` is an alias for either `keyCode` or `charCode` depending on the16271// type of the event.16272if (event.type === 'keypress') {16273return getEventCharCode(event);16274}16275if (event.type === 'keydown' || event.type === 'keyup') {16276return event.keyCode;16277}16278return 0;16279}16280};1628116282/**16283* @param {object} dispatchConfig Configuration used to dispatch this event.16284* @param {string} dispatchMarker Marker identifying the event target.16285* @param {object} nativeEvent Native browser event.16286* @extends {SyntheticUIEvent}16287*/16288function SyntheticKeyboardEvent(dispatchConfig, dispatchMarker, nativeEvent) {16289SyntheticUIEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent);16290}1629116292SyntheticUIEvent.augmentClass(SyntheticKeyboardEvent, KeyboardEventInterface);1629316294module.exports = SyntheticKeyboardEvent;1629516296},{"101":101,"122":122,"123":123,"124":124}],99:[function(_dereq_,module,exports){16297/**16298* Copyright 2013-2015, Facebook, Inc.16299* All rights reserved.16300*16301* This source code is licensed under the BSD-style license found in the16302* LICENSE file in the root directory of this source tree. An additional grant16303* of patent rights can be found in the PATENTS file in the same directory.16304*16305* @providesModule SyntheticMouseEvent16306* @typechecks static-only16307*/1630816309'use strict';1631016311var SyntheticUIEvent = _dereq_(101);16312var ViewportMetrics = _dereq_(104);1631316314var getEventModifierState = _dereq_(124);1631516316/**16317* @interface MouseEvent16318* @see http://www.w3.org/TR/DOM-Level-3-Events/16319*/16320var MouseEventInterface = {16321screenX: null,16322screenY: null,16323clientX: null,16324clientY: null,16325ctrlKey: null,16326shiftKey: null,16327altKey: null,16328metaKey: null,16329getModifierState: getEventModifierState,16330button: function(event) {16331// Webkit, Firefox, IE9+16332// which: 1 2 316333// button: 0 1 2 (standard)16334var button = event.button;16335if ('which' in event) {16336return button;16337}16338// IE<916339// which: undefined16340// button: 0 0 016341// button: 1 4 2 (onmouseup)16342return button === 2 ? 2 : button === 4 ? 1 : 0;16343},16344buttons: null,16345relatedTarget: function(event) {16346return event.relatedTarget || (16347((event.fromElement === event.srcElement ? event.toElement : event.fromElement))16348);16349},16350// "Proprietary" Interface.16351pageX: function(event) {16352return 'pageX' in event ?16353event.pageX :16354event.clientX + ViewportMetrics.currentScrollLeft;16355},16356pageY: function(event) {16357return 'pageY' in event ?16358event.pageY :16359event.clientY + ViewportMetrics.currentScrollTop;16360}16361};1636216363/**16364* @param {object} dispatchConfig Configuration used to dispatch this event.16365* @param {string} dispatchMarker Marker identifying the event target.16366* @param {object} nativeEvent Native browser event.16367* @extends {SyntheticUIEvent}16368*/16369function SyntheticMouseEvent(dispatchConfig, dispatchMarker, nativeEvent) {16370SyntheticUIEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent);16371}1637216373SyntheticUIEvent.augmentClass(SyntheticMouseEvent, MouseEventInterface);1637416375module.exports = SyntheticMouseEvent;1637616377},{"101":101,"104":104,"124":124}],100:[function(_dereq_,module,exports){16378/**16379* Copyright 2013-2015, Facebook, Inc.16380* All rights reserved.16381*16382* This source code is licensed under the BSD-style license found in the16383* LICENSE file in the root directory of this source tree. An additional grant16384* of patent rights can be found in the PATENTS file in the same directory.16385*16386* @providesModule SyntheticTouchEvent16387* @typechecks static-only16388*/1638916390'use strict';1639116392var SyntheticUIEvent = _dereq_(101);1639316394var getEventModifierState = _dereq_(124);1639516396/**16397* @interface TouchEvent16398* @see http://www.w3.org/TR/touch-events/16399*/16400var TouchEventInterface = {16401touches: null,16402targetTouches: null,16403changedTouches: null,16404altKey: null,16405metaKey: null,16406ctrlKey: null,16407shiftKey: null,16408getModifierState: getEventModifierState16409};1641016411/**16412* @param {object} dispatchConfig Configuration used to dispatch this event.16413* @param {string} dispatchMarker Marker identifying the event target.16414* @param {object} nativeEvent Native browser event.16415* @extends {SyntheticUIEvent}16416*/16417function SyntheticTouchEvent(dispatchConfig, dispatchMarker, nativeEvent) {16418SyntheticUIEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent);16419}1642016421SyntheticUIEvent.augmentClass(SyntheticTouchEvent, TouchEventInterface);1642216423module.exports = SyntheticTouchEvent;1642416425},{"101":101,"124":124}],101:[function(_dereq_,module,exports){16426/**16427* Copyright 2013-2015, Facebook, Inc.16428* All rights reserved.16429*16430* This source code is licensed under the BSD-style license found in the16431* LICENSE file in the root directory of this source tree. An additional grant16432* of patent rights can be found in the PATENTS file in the same directory.16433*16434* @providesModule SyntheticUIEvent16435* @typechecks static-only16436*/1643716438'use strict';1643916440var SyntheticEvent = _dereq_(95);1644116442var getEventTarget = _dereq_(125);1644316444/**16445* @interface UIEvent16446* @see http://www.w3.org/TR/DOM-Level-3-Events/16447*/16448var UIEventInterface = {16449view: function(event) {16450if (event.view) {16451return event.view;16452}1645316454var target = getEventTarget(event);16455if (target != null && target.window === target) {16456// target is a window object16457return target;16458}1645916460var doc = target.ownerDocument;16461// TODO: Figure out why `ownerDocument` is sometimes undefined in IE8.16462if (doc) {16463return doc.defaultView || doc.parentWindow;16464} else {16465return window;16466}16467},16468detail: function(event) {16469return event.detail || 0;16470}16471};1647216473/**16474* @param {object} dispatchConfig Configuration used to dispatch this event.16475* @param {string} dispatchMarker Marker identifying the event target.16476* @param {object} nativeEvent Native browser event.16477* @extends {SyntheticEvent}16478*/16479function SyntheticUIEvent(dispatchConfig, dispatchMarker, nativeEvent) {16480SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent);16481}1648216483SyntheticEvent.augmentClass(SyntheticUIEvent, UIEventInterface);1648416485module.exports = SyntheticUIEvent;1648616487},{"125":125,"95":95}],102:[function(_dereq_,module,exports){16488/**16489* Copyright 2013-2015, Facebook, Inc.16490* All rights reserved.16491*16492* This source code is licensed under the BSD-style license found in the16493* LICENSE file in the root directory of this source tree. An additional grant16494* of patent rights can be found in the PATENTS file in the same directory.16495*16496* @providesModule SyntheticWheelEvent16497* @typechecks static-only16498*/1649916500'use strict';1650116502var SyntheticMouseEvent = _dereq_(99);1650316504/**16505* @interface WheelEvent16506* @see http://www.w3.org/TR/DOM-Level-3-Events/16507*/16508var WheelEventInterface = {16509deltaX: function(event) {16510return (16511'deltaX' in event ? event.deltaX :16512// Fallback to `wheelDeltaX` for Webkit and normalize (right is positive).16513'wheelDeltaX' in event ? -event.wheelDeltaX : 016514);16515},16516deltaY: function(event) {16517return (16518'deltaY' in event ? event.deltaY :16519// Fallback to `wheelDeltaY` for Webkit and normalize (down is positive).16520'wheelDeltaY' in event ? -event.wheelDeltaY :16521// Fallback to `wheelDelta` for IE<9 and normalize (down is positive).16522'wheelDelta' in event ? -event.wheelDelta : 016523);16524},16525deltaZ: null,1652616527// Browsers without "deltaMode" is reporting in raw wheel delta where one16528// notch on the scroll is always +/- 120, roughly equivalent to pixels.16529// A good approximation of DOM_DELTA_LINE (1) is 5% of viewport size or16530// ~40 pixels, for DOM_DELTA_SCREEN (2) it is 87.5% of viewport size.16531deltaMode: null16532};1653316534/**16535* @param {object} dispatchConfig Configuration used to dispatch this event.16536* @param {string} dispatchMarker Marker identifying the event target.16537* @param {object} nativeEvent Native browser event.16538* @extends {SyntheticMouseEvent}16539*/16540function SyntheticWheelEvent(dispatchConfig, dispatchMarker, nativeEvent) {16541SyntheticMouseEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent);16542}1654316544SyntheticMouseEvent.augmentClass(SyntheticWheelEvent, WheelEventInterface);1654516546module.exports = SyntheticWheelEvent;1654716548},{"99":99}],103:[function(_dereq_,module,exports){16549/**16550* Copyright 2013-2015, Facebook, Inc.16551* All rights reserved.16552*16553* This source code is licensed under the BSD-style license found in the16554* LICENSE file in the root directory of this source tree. An additional grant16555* of patent rights can be found in the PATENTS file in the same directory.16556*16557* @providesModule Transaction16558*/1655916560'use strict';1656116562var invariant = _dereq_(135);1656316564/**16565* `Transaction` creates a black box that is able to wrap any method such that16566* certain invariants are maintained before and after the method is invoked16567* (Even if an exception is thrown while invoking the wrapped method). Whoever16568* instantiates a transaction can provide enforcers of the invariants at16569* creation time. The `Transaction` class itself will supply one additional16570* automatic invariant for you - the invariant that any transaction instance16571* should not be run while it is already being run. You would typically create a16572* single instance of a `Transaction` for reuse multiple times, that potentially16573* is used to wrap several different methods. Wrappers are extremely simple -16574* they only require implementing two methods.16575*16576* <pre>16577* wrappers (injected at creation time)16578* + +16579* | |16580* +-----------------|--------|--------------+16581* | v | |16582* | +---------------+ | |16583* | +--| wrapper1 |---|----+ |16584* | | +---------------+ v | |16585* | | +-------------+ | |16586* | | +----| wrapper2 |--------+ |16587* | | | +-------------+ | | |16588* | | | | | |16589* | v v v v | wrapper16590* | +---+ +---+ +---------+ +---+ +---+ | invariants16591* perform(anyMethod) | | | | | | | | | | | | maintained16592* +----------------->|-|---|-|---|-->|anyMethod|---|---|-|---|-|-------->16593* | | | | | | | | | | | |16594* | | | | | | | | | | | |16595* | | | | | | | | | | | |16596* | +---+ +---+ +---------+ +---+ +---+ |16597* | initialize close |16598* +-----------------------------------------+16599* </pre>16600*16601* Use cases:16602* - Preserving the input selection ranges before/after reconciliation.16603* Restoring selection even in the event of an unexpected error.16604* - Deactivating events while rearranging the DOM, preventing blurs/focuses,16605* while guaranteeing that afterwards, the event system is reactivated.16606* - Flushing a queue of collected DOM mutations to the main UI thread after a16607* reconciliation takes place in a worker thread.16608* - Invoking any collected `componentDidUpdate` callbacks after rendering new16609* content.16610* - (Future use case): Wrapping particular flushes of the `ReactWorker` queue16611* to preserve the `scrollTop` (an automatic scroll aware DOM).16612* - (Future use case): Layout calculations before and after DOM updates.16613*16614* Transactional plugin API:16615* - A module that has an `initialize` method that returns any precomputation.16616* - and a `close` method that accepts the precomputation. `close` is invoked16617* when the wrapped process is completed, or has failed.16618*16619* @param {Array<TransactionalWrapper>} transactionWrapper Wrapper modules16620* that implement `initialize` and `close`.16621* @return {Transaction} Single transaction for reuse in thread.16622*16623* @class Transaction16624*/16625var Mixin = {16626/**16627* Sets up this instance so that it is prepared for collecting metrics. Does16628* so such that this setup method may be used on an instance that is already16629* initialized, in a way that does not consume additional memory upon reuse.16630* That can be useful if you decide to make your subclass of this mixin a16631* "PooledClass".16632*/16633reinitializeTransaction: function() {16634this.transactionWrappers = this.getTransactionWrappers();16635if (!this.wrapperInitData) {16636this.wrapperInitData = [];16637} else {16638this.wrapperInitData.length = 0;16639}16640this._isInTransaction = false;16641},1664216643_isInTransaction: false,1664416645/**16646* @abstract16647* @return {Array<TransactionWrapper>} Array of transaction wrappers.16648*/16649getTransactionWrappers: null,1665016651isInTransaction: function() {16652return !!this._isInTransaction;16653},1665416655/**16656* Executes the function within a safety window. Use this for the top level16657* methods that result in large amounts of computation/mutations that would16658* need to be safety checked.16659*16660* @param {function} method Member of scope to call.16661* @param {Object} scope Scope to invoke from.16662* @param {Object?=} args... Arguments to pass to the method (optional).16663* Helps prevent need to bind in many cases.16664* @return Return value from `method`.16665*/16666perform: function(method, scope, a, b, c, d, e, f) {16667("production" !== "development" ? invariant(16668!this.isInTransaction(),16669'Transaction.perform(...): Cannot initialize a transaction when there ' +16670'is already an outstanding transaction.'16671) : invariant(!this.isInTransaction()));16672var errorThrown;16673var ret;16674try {16675this._isInTransaction = true;16676// Catching errors makes debugging more difficult, so we start with16677// errorThrown set to true before setting it to false after calling16678// close -- if it's still set to true in the finally block, it means16679// one of these calls threw.16680errorThrown = true;16681this.initializeAll(0);16682ret = method.call(scope, a, b, c, d, e, f);16683errorThrown = false;16684} finally {16685try {16686if (errorThrown) {16687// If `method` throws, prefer to show that stack trace over any thrown16688// by invoking `closeAll`.16689try {16690this.closeAll(0);16691} catch (err) {16692}16693} else {16694// Since `method` didn't throw, we don't want to silence the exception16695// here.16696this.closeAll(0);16697}16698} finally {16699this._isInTransaction = false;16700}16701}16702return ret;16703},1670416705initializeAll: function(startIndex) {16706var transactionWrappers = this.transactionWrappers;16707for (var i = startIndex; i < transactionWrappers.length; i++) {16708var wrapper = transactionWrappers[i];16709try {16710// Catching errors makes debugging more difficult, so we start with the16711// OBSERVED_ERROR state before overwriting it with the real return value16712// of initialize -- if it's still set to OBSERVED_ERROR in the finally16713// block, it means wrapper.initialize threw.16714this.wrapperInitData[i] = Transaction.OBSERVED_ERROR;16715this.wrapperInitData[i] = wrapper.initialize ?16716wrapper.initialize.call(this) :16717null;16718} finally {16719if (this.wrapperInitData[i] === Transaction.OBSERVED_ERROR) {16720// The initializer for wrapper i threw an error; initialize the16721// remaining wrappers but silence any exceptions from them to ensure16722// that the first error is the one to bubble up.16723try {16724this.initializeAll(i + 1);16725} catch (err) {16726}16727}16728}16729}16730},1673116732/**16733* Invokes each of `this.transactionWrappers.close[i]` functions, passing into16734* them the respective return values of `this.transactionWrappers.init[i]`16735* (`close`rs that correspond to initializers that failed will not be16736* invoked).16737*/16738closeAll: function(startIndex) {16739("production" !== "development" ? invariant(16740this.isInTransaction(),16741'Transaction.closeAll(): Cannot close transaction when none are open.'16742) : invariant(this.isInTransaction()));16743var transactionWrappers = this.transactionWrappers;16744for (var i = startIndex; i < transactionWrappers.length; i++) {16745var wrapper = transactionWrappers[i];16746var initData = this.wrapperInitData[i];16747var errorThrown;16748try {16749// Catching errors makes debugging more difficult, so we start with16750// errorThrown set to true before setting it to false after calling16751// close -- if it's still set to true in the finally block, it means16752// wrapper.close threw.16753errorThrown = true;16754if (initData !== Transaction.OBSERVED_ERROR && wrapper.close) {16755wrapper.close.call(this, initData);16756}16757errorThrown = false;16758} finally {16759if (errorThrown) {16760// The closer for wrapper i threw an error; close the remaining16761// wrappers but silence any exceptions from them to ensure that the16762// first error is the one to bubble up.16763try {16764this.closeAll(i + 1);16765} catch (e) {16766}16767}16768}16769}16770this.wrapperInitData.length = 0;16771}16772};1677316774var Transaction = {1677516776Mixin: Mixin,1677716778/**16779* Token to look for to determine if an error occured.16780*/16781OBSERVED_ERROR: {}1678216783};1678416785module.exports = Transaction;1678616787},{"135":135}],104:[function(_dereq_,module,exports){16788/**16789* Copyright 2013-2015, Facebook, Inc.16790* All rights reserved.16791*16792* This source code is licensed under the BSD-style license found in the16793* LICENSE file in the root directory of this source tree. An additional grant16794* of patent rights can be found in the PATENTS file in the same directory.16795*16796* @providesModule ViewportMetrics16797*/1679816799'use strict';1680016801var ViewportMetrics = {1680216803currentScrollLeft: 0,1680416805currentScrollTop: 0,1680616807refreshScrollValues: function(scrollPosition) {16808ViewportMetrics.currentScrollLeft = scrollPosition.x;16809ViewportMetrics.currentScrollTop = scrollPosition.y;16810}1681116812};1681316814module.exports = ViewportMetrics;1681516816},{}],105:[function(_dereq_,module,exports){16817/**16818* Copyright 2014-2015, Facebook, Inc.16819* All rights reserved.16820*16821* This source code is licensed under the BSD-style license found in the16822* LICENSE file in the root directory of this source tree. An additional grant16823* of patent rights can be found in the PATENTS file in the same directory.16824*16825* @providesModule accumulateInto16826*/1682716828'use strict';1682916830var invariant = _dereq_(135);1683116832/**16833*16834* Accumulates items that must not be null or undefined into the first one. This16835* is used to conserve memory by avoiding array allocations, and thus sacrifices16836* API cleanness. Since `current` can be null before being passed in and not16837* null after this function, make sure to assign it back to `current`:16838*16839* `a = accumulateInto(a, b);`16840*16841* This API should be sparingly used. Try `accumulate` for something cleaner.16842*16843* @return {*|array<*>} An accumulation of items.16844*/1684516846function accumulateInto(current, next) {16847("production" !== "development" ? invariant(16848next != null,16849'accumulateInto(...): Accumulated items must not be null or undefined.'16850) : invariant(next != null));16851if (current == null) {16852return next;16853}1685416855// Both are not empty. Warning: Never call x.concat(y) when you are not16856// certain that x is an Array (x could be a string with concat method).16857var currentIsArray = Array.isArray(current);16858var nextIsArray = Array.isArray(next);1685916860if (currentIsArray && nextIsArray) {16861current.push.apply(current, next);16862return current;16863}1686416865if (currentIsArray) {16866current.push(next);16867return current;16868}1686916870if (nextIsArray) {16871// A bit too dangerous to mutate `next`.16872return [current].concat(next);16873}1687416875return [current, next];16876}1687716878module.exports = accumulateInto;1687916880},{"135":135}],106:[function(_dereq_,module,exports){16881/**16882* Copyright 2013-2015, Facebook, Inc.16883* All rights reserved.16884*16885* This source code is licensed under the BSD-style license found in the16886* LICENSE file in the root directory of this source tree. An additional grant16887* of patent rights can be found in the PATENTS file in the same directory.16888*16889* @providesModule adler3216890*/1689116892/* jslint bitwise:true */1689316894'use strict';1689516896var MOD = 65521;1689716898// This is a clean-room implementation of adler32 designed for detecting16899// if markup is not what we expect it to be. It does not need to be16900// cryptographically strong, only reasonably good at detecting if markup16901// generated on the server is different than that on the client.16902function adler32(data) {16903var a = 1;16904var b = 0;16905for (var i = 0; i < data.length; i++) {16906a = (a + data.charCodeAt(i)) % MOD;16907b = (b + a) % MOD;16908}16909return a | (b << 16);16910}1691116912module.exports = adler32;1691316914},{}],107:[function(_dereq_,module,exports){16915/**16916* Copyright 2013-2015, Facebook, Inc.16917* All rights reserved.16918*16919* This source code is licensed under the BSD-style license found in the16920* LICENSE file in the root directory of this source tree. An additional grant16921* of patent rights can be found in the PATENTS file in the same directory.16922*16923* @providesModule camelize16924* @typechecks16925*/1692616927var _hyphenPattern = /-(.)/g;1692816929/**16930* Camelcases a hyphenated string, for example:16931*16932* > camelize('background-color')16933* < "backgroundColor"16934*16935* @param {string} string16936* @return {string}16937*/16938function camelize(string) {16939return string.replace(_hyphenPattern, function(_, character) {16940return character.toUpperCase();16941});16942}1694316944module.exports = camelize;1694516946},{}],108:[function(_dereq_,module,exports){16947/**16948* Copyright 2014-2015, Facebook, Inc.16949* All rights reserved.16950*16951* This source code is licensed under the BSD-style license found in the16952* LICENSE file in the root directory of this source tree. An additional grant16953* of patent rights can be found in the PATENTS file in the same directory.16954*16955* @providesModule camelizeStyleName16956* @typechecks16957*/1695816959"use strict";1696016961var camelize = _dereq_(107);1696216963var msPattern = /^-ms-/;1696416965/**16966* Camelcases a hyphenated CSS property name, for example:16967*16968* > camelizeStyleName('background-color')16969* < "backgroundColor"16970* > camelizeStyleName('-moz-transition')16971* < "MozTransition"16972* > camelizeStyleName('-ms-transition')16973* < "msTransition"16974*16975* As Andi Smith suggests16976* (http://www.andismith.com/blog/2012/02/modernizr-prefixed/), an `-ms` prefix16977* is converted to lowercase `ms`.16978*16979* @param {string} string16980* @return {string}16981*/16982function camelizeStyleName(string) {16983return camelize(string.replace(msPattern, 'ms-'));16984}1698516986module.exports = camelizeStyleName;1698716988},{"107":107}],109:[function(_dereq_,module,exports){16989/**16990* Copyright 2013-2015, Facebook, Inc.16991* All rights reserved.16992*16993* This source code is licensed under the BSD-style license found in the16994* LICENSE file in the root directory of this source tree. An additional grant16995* of patent rights can be found in the PATENTS file in the same directory.16996*16997* @providesModule containsNode16998* @typechecks16999*/1700017001var isTextNode = _dereq_(139);1700217003/*jslint bitwise:true */1700417005/**17006* Checks if a given DOM node contains or is another DOM node.17007*17008* @param {?DOMNode} outerNode Outer DOM node.17009* @param {?DOMNode} innerNode Inner DOM node.17010* @return {boolean} True if `outerNode` contains or is `innerNode`.17011*/17012function containsNode(outerNode, innerNode) {17013if (!outerNode || !innerNode) {17014return false;17015} else if (outerNode === innerNode) {17016return true;17017} else if (isTextNode(outerNode)) {17018return false;17019} else if (isTextNode(innerNode)) {17020return containsNode(outerNode, innerNode.parentNode);17021} else if (outerNode.contains) {17022return outerNode.contains(innerNode);17023} else if (outerNode.compareDocumentPosition) {17024return !!(outerNode.compareDocumentPosition(innerNode) & 16);17025} else {17026return false;17027}17028}1702917030module.exports = containsNode;1703117032},{"139":139}],110:[function(_dereq_,module,exports){17033/**17034* Copyright 2013-2015, Facebook, Inc.17035* All rights reserved.17036*17037* This source code is licensed under the BSD-style license found in the17038* LICENSE file in the root directory of this source tree. An additional grant17039* of patent rights can be found in the PATENTS file in the same directory.17040*17041* @providesModule createArrayFromMixed17042* @typechecks17043*/1704417045var toArray = _dereq_(152);1704617047/**17048* Perform a heuristic test to determine if an object is "array-like".17049*17050* A monk asked Joshu, a Zen master, "Has a dog Buddha nature?"17051* Joshu replied: "Mu."17052*17053* This function determines if its argument has "array nature": it returns17054* true if the argument is an actual array, an `arguments' object, or an17055* HTMLCollection (e.g. node.childNodes or node.getElementsByTagName()).17056*17057* It will return false for other array-like objects like Filelist.17058*17059* @param {*} obj17060* @return {boolean}17061*/17062function hasArrayNature(obj) {17063return (17064// not null/false17065!!obj &&17066// arrays are objects, NodeLists are functions in Safari17067(typeof obj == 'object' || typeof obj == 'function') &&17068// quacks like an array17069('length' in obj) &&17070// not window17071!('setInterval' in obj) &&17072// no DOM node should be considered an array-like17073// a 'select' element has 'length' and 'item' properties on IE817074(typeof obj.nodeType != 'number') &&17075(17076// a real array17077(// HTMLCollection/NodeList17078(Array.isArray(obj) ||17079// arguments17080('callee' in obj) || 'item' in obj))17081)17082);17083}1708417085/**17086* Ensure that the argument is an array by wrapping it in an array if it is not.17087* Creates a copy of the argument if it is already an array.17088*17089* This is mostly useful idiomatically:17090*17091* var createArrayFromMixed = require('createArrayFromMixed');17092*17093* function takesOneOrMoreThings(things) {17094* things = createArrayFromMixed(things);17095* ...17096* }17097*17098* This allows you to treat `things' as an array, but accept scalars in the API.17099*17100* If you need to convert an array-like object, like `arguments`, into an array17101* use toArray instead.17102*17103* @param {*} obj17104* @return {array}17105*/17106function createArrayFromMixed(obj) {17107if (!hasArrayNature(obj)) {17108return [obj];17109} else if (Array.isArray(obj)) {17110return obj.slice();17111} else {17112return toArray(obj);17113}17114}1711517116module.exports = createArrayFromMixed;1711717118},{"152":152}],111:[function(_dereq_,module,exports){17119/**17120* Copyright 2013-2015, Facebook, Inc.17121* All rights reserved.17122*17123* This source code is licensed under the BSD-style license found in the17124* LICENSE file in the root directory of this source tree. An additional grant17125* of patent rights can be found in the PATENTS file in the same directory.17126*17127* @providesModule createFullPageComponent17128* @typechecks17129*/1713017131'use strict';1713217133// Defeat circular references by requiring this directly.17134var ReactClass = _dereq_(33);17135var ReactElement = _dereq_(57);1713617137var invariant = _dereq_(135);1713817139/**17140* Create a component that will throw an exception when unmounted.17141*17142* Components like <html> <head> and <body> can't be removed or added17143* easily in a cross-browser way, however it's valuable to be able to17144* take advantage of React's reconciliation for styling and <title>17145* management. So we just document it and throw in dangerous cases.17146*17147* @param {string} tag The tag to wrap17148* @return {function} convenience constructor of new component17149*/17150function createFullPageComponent(tag) {17151var elementFactory = ReactElement.createFactory(tag);1715217153var FullPageComponent = ReactClass.createClass({17154tagName: tag.toUpperCase(),17155displayName: 'ReactFullPageComponent' + tag,1715617157componentWillUnmount: function() {17158("production" !== "development" ? invariant(17159false,17160'%s tried to unmount. Because of cross-browser quirks it is ' +17161'impossible to unmount some top-level components (eg <html>, <head>, ' +17162'and <body>) reliably and efficiently. To fix this, have a single ' +17163'top-level component that never unmounts render these elements.',17164this.constructor.displayName17165) : invariant(false));17166},1716717168render: function() {17169return elementFactory(this.props);17170}17171});1717217173return FullPageComponent;17174}1717517176module.exports = createFullPageComponent;1717717178},{"135":135,"33":33,"57":57}],112:[function(_dereq_,module,exports){17179/**17180* Copyright 2013-2015, Facebook, Inc.17181* All rights reserved.17182*17183* This source code is licensed under the BSD-style license found in the17184* LICENSE file in the root directory of this source tree. An additional grant17185* of patent rights can be found in the PATENTS file in the same directory.17186*17187* @providesModule createNodesFromMarkup17188* @typechecks17189*/1719017191/*jslint evil: true, sub: true */1719217193var ExecutionEnvironment = _dereq_(21);1719417195var createArrayFromMixed = _dereq_(110);17196var getMarkupWrap = _dereq_(127);17197var invariant = _dereq_(135);1719817199/**17200* Dummy container used to render all markup.17201*/17202var dummyNode =17203ExecutionEnvironment.canUseDOM ? document.createElement('div') : null;1720417205/**17206* Pattern used by `getNodeName`.17207*/17208var nodeNamePattern = /^\s*<(\w+)/;1720917210/**17211* Extracts the `nodeName` of the first element in a string of markup.17212*17213* @param {string} markup String of markup.17214* @return {?string} Node name of the supplied markup.17215*/17216function getNodeName(markup) {17217var nodeNameMatch = markup.match(nodeNamePattern);17218return nodeNameMatch && nodeNameMatch[1].toLowerCase();17219}1722017221/**17222* Creates an array containing the nodes rendered from the supplied markup. The17223* optionally supplied `handleScript` function will be invoked once for each17224* <script> element that is rendered. If no `handleScript` function is supplied,17225* an exception is thrown if any <script> elements are rendered.17226*17227* @param {string} markup A string of valid HTML markup.17228* @param {?function} handleScript Invoked once for each rendered <script>.17229* @return {array<DOMElement|DOMTextNode>} An array of rendered nodes.17230*/17231function createNodesFromMarkup(markup, handleScript) {17232var node = dummyNode;17233("production" !== "development" ? invariant(!!dummyNode, 'createNodesFromMarkup dummy not initialized') : invariant(!!dummyNode));17234var nodeName = getNodeName(markup);1723517236var wrap = nodeName && getMarkupWrap(nodeName);17237if (wrap) {17238node.innerHTML = wrap[1] + markup + wrap[2];1723917240var wrapDepth = wrap[0];17241while (wrapDepth--) {17242node = node.lastChild;17243}17244} else {17245node.innerHTML = markup;17246}1724717248var scripts = node.getElementsByTagName('script');17249if (scripts.length) {17250("production" !== "development" ? invariant(17251handleScript,17252'createNodesFromMarkup(...): Unexpected <script> element rendered.'17253) : invariant(handleScript));17254createArrayFromMixed(scripts).forEach(handleScript);17255}1725617257var nodes = createArrayFromMixed(node.childNodes);17258while (node.lastChild) {17259node.removeChild(node.lastChild);17260}17261return nodes;17262}1726317264module.exports = createNodesFromMarkup;1726517266},{"110":110,"127":127,"135":135,"21":21}],113:[function(_dereq_,module,exports){17267/**17268* Copyright 2013-2015, Facebook, Inc.17269* All rights reserved.17270*17271* This source code is licensed under the BSD-style license found in the17272* LICENSE file in the root directory of this source tree. An additional grant17273* of patent rights can be found in the PATENTS file in the same directory.17274*17275* @providesModule dangerousStyleValue17276* @typechecks static-only17277*/1727817279'use strict';1728017281var CSSProperty = _dereq_(4);1728217283var isUnitlessNumber = CSSProperty.isUnitlessNumber;1728417285/**17286* Convert a value into the proper css writable value. The style name `name`17287* should be logical (no hyphens), as specified17288* in `CSSProperty.isUnitlessNumber`.17289*17290* @param {string} name CSS property name such as `topMargin`.17291* @param {*} value CSS property value such as `10px`.17292* @return {string} Normalized style value with dimensions applied.17293*/17294function dangerousStyleValue(name, value) {17295// Note that we've removed escapeTextForBrowser() calls here since the17296// whole string will be escaped when the attribute is injected into17297// the markup. If you provide unsafe user data here they can inject17298// arbitrary CSS which may be problematic (I couldn't repro this):17299// https://www.owasp.org/index.php/XSS_Filter_Evasion_Cheat_Sheet17300// http://www.thespanner.co.uk/2007/11/26/ultimate-xss-css-injection/17301// This is not an XSS hole but instead a potential CSS injection issue17302// which has lead to a greater discussion about how we're going to17303// trust URLs moving forward. See #21159011730417305var isEmpty = value == null || typeof value === 'boolean' || value === '';17306if (isEmpty) {17307return '';17308}1730917310var isNonNumeric = isNaN(value);17311if (isNonNumeric || value === 0 ||17312isUnitlessNumber.hasOwnProperty(name) && isUnitlessNumber[name]) {17313return '' + value; // cast to string17314}1731517316if (typeof value === 'string') {17317value = value.trim();17318}17319return value + 'px';17320}1732117322module.exports = dangerousStyleValue;1732317324},{"4":4}],114:[function(_dereq_,module,exports){17325/**17326* Copyright 2013-2015, Facebook, Inc.17327* All rights reserved.17328*17329* This source code is licensed under the BSD-style license found in the17330* LICENSE file in the root directory of this source tree. An additional grant17331* of patent rights can be found in the PATENTS file in the same directory.17332*17333* @providesModule emptyFunction17334*/1733517336function makeEmptyFunction(arg) {17337return function() {17338return arg;17339};17340}1734117342/**17343* This function accepts and discards inputs; it has no side effects. This is17344* primarily useful idiomatically for overridable function endpoints which17345* always need to be callable, since JS lacks a null-call idiom ala Cocoa.17346*/17347function emptyFunction() {}1734817349emptyFunction.thatReturns = makeEmptyFunction;17350emptyFunction.thatReturnsFalse = makeEmptyFunction(false);17351emptyFunction.thatReturnsTrue = makeEmptyFunction(true);17352emptyFunction.thatReturnsNull = makeEmptyFunction(null);17353emptyFunction.thatReturnsThis = function() { return this; };17354emptyFunction.thatReturnsArgument = function(arg) { return arg; };1735517356module.exports = emptyFunction;1735717358},{}],115:[function(_dereq_,module,exports){17359/**17360* Copyright 2013-2015, Facebook, Inc.17361* All rights reserved.17362*17363* This source code is licensed under the BSD-style license found in the17364* LICENSE file in the root directory of this source tree. An additional grant17365* of patent rights can be found in the PATENTS file in the same directory.17366*17367* @providesModule emptyObject17368*/1736917370"use strict";1737117372var emptyObject = {};1737317374if ("production" !== "development") {17375Object.freeze(emptyObject);17376}1737717378module.exports = emptyObject;1737917380},{}],116:[function(_dereq_,module,exports){17381/**17382* Copyright 2013-2015, Facebook, Inc.17383* All rights reserved.17384*17385* This source code is licensed under the BSD-style license found in the17386* LICENSE file in the root directory of this source tree. An additional grant17387* of patent rights can be found in the PATENTS file in the same directory.17388*17389* @providesModule escapeTextContentForBrowser17390*/1739117392'use strict';1739317394var ESCAPE_LOOKUP = {17395'&': '&',17396'>': '>',17397'<': '<',17398'"': '"',17399'\'': '''17400};1740117402var ESCAPE_REGEX = /[&><"']/g;1740317404function escaper(match) {17405return ESCAPE_LOOKUP[match];17406}1740717408/**17409* Escapes text to prevent scripting attacks.17410*17411* @param {*} text Text value to escape.17412* @return {string} An escaped string.17413*/17414function escapeTextContentForBrowser(text) {17415return ('' + text).replace(ESCAPE_REGEX, escaper);17416}1741717418module.exports = escapeTextContentForBrowser;1741917420},{}],117:[function(_dereq_,module,exports){17421/**17422* Copyright 2013-2015, Facebook, Inc.17423* All rights reserved.17424*17425* This source code is licensed under the BSD-style license found in the17426* LICENSE file in the root directory of this source tree. An additional grant17427* of patent rights can be found in the PATENTS file in the same directory.17428*17429* @providesModule findDOMNode17430* @typechecks static-only17431*/1743217433'use strict';1743417435var ReactCurrentOwner = _dereq_(39);17436var ReactInstanceMap = _dereq_(67);17437var ReactMount = _dereq_(70);1743817439var invariant = _dereq_(135);17440var isNode = _dereq_(137);17441var warning = _dereq_(154);1744217443/**17444* Returns the DOM node rendered by this element.17445*17446* @param {ReactComponent|DOMElement} componentOrElement17447* @return {DOMElement} The root node of this element.17448*/17449function findDOMNode(componentOrElement) {17450if ("production" !== "development") {17451var owner = ReactCurrentOwner.current;17452if (owner !== null) {17453("production" !== "development" ? warning(17454owner._warnedAboutRefsInRender,17455'%s is accessing getDOMNode or findDOMNode inside its render(). ' +17456'render() should be a pure function of props and state. It should ' +17457'never access something that requires stale data from the previous ' +17458'render, such as refs. Move this logic to componentDidMount and ' +17459'componentDidUpdate instead.',17460owner.getName() || 'A component'17461) : null);17462owner._warnedAboutRefsInRender = true;17463}17464}17465if (componentOrElement == null) {17466return null;17467}17468if (isNode(componentOrElement)) {17469return componentOrElement;17470}17471if (ReactInstanceMap.has(componentOrElement)) {17472return ReactMount.getNodeFromInstance(componentOrElement);17473}17474("production" !== "development" ? invariant(17475componentOrElement.render == null ||17476typeof componentOrElement.render !== 'function',17477'Component (with keys: %s) contains `render` method ' +17478'but is not mounted in the DOM',17479Object.keys(componentOrElement)17480) : invariant(componentOrElement.render == null ||17481typeof componentOrElement.render !== 'function'));17482("production" !== "development" ? invariant(17483false,17484'Element appears to be neither ReactComponent nor DOMNode (keys: %s)',17485Object.keys(componentOrElement)17486) : invariant(false));17487}1748817489module.exports = findDOMNode;1749017491},{"135":135,"137":137,"154":154,"39":39,"67":67,"70":70}],118:[function(_dereq_,module,exports){17492/**17493* Copyright 2013-2015, Facebook, Inc.17494* All rights reserved.17495*17496* This source code is licensed under the BSD-style license found in the17497* LICENSE file in the root directory of this source tree. An additional grant17498* of patent rights can be found in the PATENTS file in the same directory.17499*17500* @providesModule flattenChildren17501*/1750217503'use strict';1750417505var traverseAllChildren = _dereq_(153);17506var warning = _dereq_(154);1750717508/**17509* @param {function} traverseContext Context passed through traversal.17510* @param {?ReactComponent} child React child component.17511* @param {!string} name String name of key path to child.17512*/17513function flattenSingleChildIntoContext(traverseContext, child, name) {17514// We found a component instance.17515var result = traverseContext;17516var keyUnique = !result.hasOwnProperty(name);17517if ("production" !== "development") {17518("production" !== "development" ? warning(17519keyUnique,17520'flattenChildren(...): Encountered two children with the same key, ' +17521'`%s`. Child keys must be unique; when two children share a key, only ' +17522'the first child will be used.',17523name17524) : null);17525}17526if (keyUnique && child != null) {17527result[name] = child;17528}17529}1753017531/**17532* Flattens children that are typically specified as `props.children`. Any null17533* children will not be included in the resulting object.17534* @return {!object} flattened children keyed by name.17535*/17536function flattenChildren(children) {17537if (children == null) {17538return children;17539}17540var result = {};17541traverseAllChildren(children, flattenSingleChildIntoContext, result);17542return result;17543}1754417545module.exports = flattenChildren;1754617547},{"153":153,"154":154}],119:[function(_dereq_,module,exports){17548/**17549* Copyright 2014-2015, Facebook, Inc.17550* All rights reserved.17551*17552* This source code is licensed under the BSD-style license found in the17553* LICENSE file in the root directory of this source tree. An additional grant17554* of patent rights can be found in the PATENTS file in the same directory.17555*17556* @providesModule focusNode17557*/1755817559"use strict";1756017561/**17562* @param {DOMElement} node input/textarea to focus17563*/17564function focusNode(node) {17565// IE8 can throw "Can't move focus to the control because it is invisible,17566// not enabled, or of a type that does not accept the focus." for all kinds of17567// reasons that are too expensive and fragile to test.17568try {17569node.focus();17570} catch(e) {17571}17572}1757317574module.exports = focusNode;1757517576},{}],120:[function(_dereq_,module,exports){17577/**17578* Copyright 2013-2015, Facebook, Inc.17579* All rights reserved.17580*17581* This source code is licensed under the BSD-style license found in the17582* LICENSE file in the root directory of this source tree. An additional grant17583* of patent rights can be found in the PATENTS file in the same directory.17584*17585* @providesModule forEachAccumulated17586*/1758717588'use strict';1758917590/**17591* @param {array} an "accumulation" of items which is either an Array or17592* a single item. Useful when paired with the `accumulate` module. This is a17593* simple utility that allows us to reason about a collection of items, but17594* handling the case when there is exactly one item (and we do not need to17595* allocate an array).17596*/17597var forEachAccumulated = function(arr, cb, scope) {17598if (Array.isArray(arr)) {17599arr.forEach(cb, scope);17600} else if (arr) {17601cb.call(scope, arr);17602}17603};1760417605module.exports = forEachAccumulated;1760617607},{}],121:[function(_dereq_,module,exports){17608/**17609* Copyright 2013-2015, Facebook, Inc.17610* All rights reserved.17611*17612* This source code is licensed under the BSD-style license found in the17613* LICENSE file in the root directory of this source tree. An additional grant17614* of patent rights can be found in the PATENTS file in the same directory.17615*17616* @providesModule getActiveElement17617* @typechecks17618*/1761917620/**17621* Same as document.activeElement but wraps in a try-catch block. In IE it is17622* not safe to call document.activeElement if there is nothing focused.17623*17624* The activeElement will be null only if the document body is not yet defined.17625*/17626function getActiveElement() /*?DOMElement*/ {17627try {17628return document.activeElement || document.body;17629} catch (e) {17630return document.body;17631}17632}1763317634module.exports = getActiveElement;1763517636},{}],122:[function(_dereq_,module,exports){17637/**17638* Copyright 2013-2015, Facebook, Inc.17639* All rights reserved.17640*17641* This source code is licensed under the BSD-style license found in the17642* LICENSE file in the root directory of this source tree. An additional grant17643* of patent rights can be found in the PATENTS file in the same directory.17644*17645* @providesModule getEventCharCode17646* @typechecks static-only17647*/1764817649'use strict';1765017651/**17652* `charCode` represents the actual "character code" and is safe to use with17653* `String.fromCharCode`. As such, only keys that correspond to printable17654* characters produce a valid `charCode`, the only exception to this is Enter.17655* The Tab-key is considered non-printable and does not have a `charCode`,17656* presumably because it does not produce a tab-character in browsers.17657*17658* @param {object} nativeEvent Native browser event.17659* @return {string} Normalized `charCode` property.17660*/17661function getEventCharCode(nativeEvent) {17662var charCode;17663var keyCode = nativeEvent.keyCode;1766417665if ('charCode' in nativeEvent) {17666charCode = nativeEvent.charCode;1766717668// FF does not set `charCode` for the Enter-key, check against `keyCode`.17669if (charCode === 0 && keyCode === 13) {17670charCode = 13;17671}17672} else {17673// IE8 does not implement `charCode`, but `keyCode` has the correct value.17674charCode = keyCode;17675}1767617677// Some non-printable keys are reported in `charCode`/`keyCode`, discard them.17678// Must not discard the (non-)printable Enter-key.17679if (charCode >= 32 || charCode === 13) {17680return charCode;17681}1768217683return 0;17684}1768517686module.exports = getEventCharCode;1768717688},{}],123:[function(_dereq_,module,exports){17689/**17690* Copyright 2013-2015, Facebook, Inc.17691* All rights reserved.17692*17693* This source code is licensed under the BSD-style license found in the17694* LICENSE file in the root directory of this source tree. An additional grant17695* of patent rights can be found in the PATENTS file in the same directory.17696*17697* @providesModule getEventKey17698* @typechecks static-only17699*/1770017701'use strict';1770217703var getEventCharCode = _dereq_(122);1770417705/**17706* Normalization of deprecated HTML5 `key` values17707* @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names17708*/17709var normalizeKey = {17710'Esc': 'Escape',17711'Spacebar': ' ',17712'Left': 'ArrowLeft',17713'Up': 'ArrowUp',17714'Right': 'ArrowRight',17715'Down': 'ArrowDown',17716'Del': 'Delete',17717'Win': 'OS',17718'Menu': 'ContextMenu',17719'Apps': 'ContextMenu',17720'Scroll': 'ScrollLock',17721'MozPrintableKey': 'Unidentified'17722};1772317724/**17725* Translation from legacy `keyCode` to HTML5 `key`17726* Only special keys supported, all others depend on keyboard layout or browser17727* @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names17728*/17729var translateToKey = {177308: 'Backspace',177319: 'Tab',1773212: 'Clear',1773313: 'Enter',1773416: 'Shift',1773517: 'Control',1773618: 'Alt',1773719: 'Pause',1773820: 'CapsLock',1773927: 'Escape',1774032: ' ',1774133: 'PageUp',1774234: 'PageDown',1774335: 'End',1774436: 'Home',1774537: 'ArrowLeft',1774638: 'ArrowUp',1774739: 'ArrowRight',1774840: 'ArrowDown',1774945: 'Insert',1775046: 'Delete',17751112: 'F1', 113: 'F2', 114: 'F3', 115: 'F4', 116: 'F5', 117: 'F6',17752118: 'F7', 119: 'F8', 120: 'F9', 121: 'F10', 122: 'F11', 123: 'F12',17753144: 'NumLock',17754145: 'ScrollLock',17755224: 'Meta'17756};1775717758/**17759* @param {object} nativeEvent Native browser event.17760* @return {string} Normalized `key` property.17761*/17762function getEventKey(nativeEvent) {17763if (nativeEvent.key) {17764// Normalize inconsistent values reported by browsers due to17765// implementations of a working draft specification.1776617767// FireFox implements `key` but returns `MozPrintableKey` for all17768// printable characters (normalized to `Unidentified`), ignore it.17769var key = normalizeKey[nativeEvent.key] || nativeEvent.key;17770if (key !== 'Unidentified') {17771return key;17772}17773}1777417775// Browser does not implement `key`, polyfill as much of it as we can.17776if (nativeEvent.type === 'keypress') {17777var charCode = getEventCharCode(nativeEvent);1777817779// The enter-key is technically both printable and non-printable and can17780// thus be captured by `keypress`, no other non-printable key should.17781return charCode === 13 ? 'Enter' : String.fromCharCode(charCode);17782}17783if (nativeEvent.type === 'keydown' || nativeEvent.type === 'keyup') {17784// While user keyboard layout determines the actual meaning of each17785// `keyCode` value, almost all function keys have a universal value.17786return translateToKey[nativeEvent.keyCode] || 'Unidentified';17787}17788return '';17789}1779017791module.exports = getEventKey;1779217793},{"122":122}],124:[function(_dereq_,module,exports){17794/**17795* Copyright 2013-2015, Facebook, Inc.17796* All rights reserved.17797*17798* This source code is licensed under the BSD-style license found in the17799* LICENSE file in the root directory of this source tree. An additional grant17800* of patent rights can be found in the PATENTS file in the same directory.17801*17802* @providesModule getEventModifierState17803* @typechecks static-only17804*/1780517806'use strict';1780717808/**17809* Translation from modifier key to the associated property in the event.17810* @see http://www.w3.org/TR/DOM-Level-3-Events/#keys-Modifiers17811*/1781217813var modifierKeyToProp = {17814'Alt': 'altKey',17815'Control': 'ctrlKey',17816'Meta': 'metaKey',17817'Shift': 'shiftKey'17818};1781917820// IE8 does not implement getModifierState so we simply map it to the only17821// modifier keys exposed by the event itself, does not support Lock-keys.17822// Currently, all major browsers except Chrome seems to support Lock-keys.17823function modifierStateGetter(keyArg) {17824/*jshint validthis:true */17825var syntheticEvent = this;17826var nativeEvent = syntheticEvent.nativeEvent;17827if (nativeEvent.getModifierState) {17828return nativeEvent.getModifierState(keyArg);17829}17830var keyProp = modifierKeyToProp[keyArg];17831return keyProp ? !!nativeEvent[keyProp] : false;17832}1783317834function getEventModifierState(nativeEvent) {17835return modifierStateGetter;17836}1783717838module.exports = getEventModifierState;1783917840},{}],125:[function(_dereq_,module,exports){17841/**17842* Copyright 2013-2015, Facebook, Inc.17843* All rights reserved.17844*17845* This source code is licensed under the BSD-style license found in the17846* LICENSE file in the root directory of this source tree. An additional grant17847* of patent rights can be found in the PATENTS file in the same directory.17848*17849* @providesModule getEventTarget17850* @typechecks static-only17851*/1785217853'use strict';1785417855/**17856* Gets the target node from a native browser event by accounting for17857* inconsistencies in browser DOM APIs.17858*17859* @param {object} nativeEvent Native browser event.17860* @return {DOMEventTarget} Target node.17861*/17862function getEventTarget(nativeEvent) {17863var target = nativeEvent.target || nativeEvent.srcElement || window;17864// Safari may fire events on text nodes (Node.TEXT_NODE is 3).17865// @see http://www.quirksmode.org/js/events_properties.html17866return target.nodeType === 3 ? target.parentNode : target;17867}1786817869module.exports = getEventTarget;1787017871},{}],126:[function(_dereq_,module,exports){17872/**17873* Copyright 2013-2015, Facebook, Inc.17874* All rights reserved.17875*17876* This source code is licensed under the BSD-style license found in the17877* LICENSE file in the root directory of this source tree. An additional grant17878* of patent rights can be found in the PATENTS file in the same directory.17879*17880* @providesModule getIteratorFn17881* @typechecks static-only17882*/1788317884'use strict';1788517886/* global Symbol */17887var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;17888var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.1788917890/**17891* Returns the iterator method function contained on the iterable object.17892*17893* Be sure to invoke the function with the iterable as context:17894*17895* var iteratorFn = getIteratorFn(myIterable);17896* if (iteratorFn) {17897* var iterator = iteratorFn.call(myIterable);17898* ...17899* }17900*17901* @param {?object} maybeIterable17902* @return {?function}17903*/17904function getIteratorFn(maybeIterable) {17905var iteratorFn = maybeIterable && (17906(ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL])17907);17908if (typeof iteratorFn === 'function') {17909return iteratorFn;17910}17911}1791217913module.exports = getIteratorFn;1791417915},{}],127:[function(_dereq_,module,exports){17916/**17917* Copyright 2013-2015, Facebook, Inc.17918* All rights reserved.17919*17920* This source code is licensed under the BSD-style license found in the17921* LICENSE file in the root directory of this source tree. An additional grant17922* of patent rights can be found in the PATENTS file in the same directory.17923*17924* @providesModule getMarkupWrap17925*/1792617927var ExecutionEnvironment = _dereq_(21);1792817929var invariant = _dereq_(135);1793017931/**17932* Dummy container used to detect which wraps are necessary.17933*/17934var dummyNode =17935ExecutionEnvironment.canUseDOM ? document.createElement('div') : null;1793617937/**17938* Some browsers cannot use `innerHTML` to render certain elements standalone,17939* so we wrap them, render the wrapped nodes, then extract the desired node.17940*17941* In IE8, certain elements cannot render alone, so wrap all elements ('*').17942*/17943var shouldWrap = {17944// Force wrapping for SVG elements because if they get created inside a <div>,17945// they will be initialized in the wrong namespace (and will not display).17946'circle': true,17947'clipPath': true,17948'defs': true,17949'ellipse': true,17950'g': true,17951'line': true,17952'linearGradient': true,17953'path': true,17954'polygon': true,17955'polyline': true,17956'radialGradient': true,17957'rect': true,17958'stop': true,17959'text': true17960};1796117962var selectWrap = [1, '<select multiple="true">', '</select>'];17963var tableWrap = [1, '<table>', '</table>'];17964var trWrap = [3, '<table><tbody><tr>', '</tr></tbody></table>'];1796517966var svgWrap = [1, '<svg>', '</svg>'];1796717968var markupWrap = {17969'*': [1, '?<div>', '</div>'],1797017971'area': [1, '<map>', '</map>'],17972'col': [2, '<table><tbody></tbody><colgroup>', '</colgroup></table>'],17973'legend': [1, '<fieldset>', '</fieldset>'],17974'param': [1, '<object>', '</object>'],17975'tr': [2, '<table><tbody>', '</tbody></table>'],1797617977'optgroup': selectWrap,17978'option': selectWrap,1797917980'caption': tableWrap,17981'colgroup': tableWrap,17982'tbody': tableWrap,17983'tfoot': tableWrap,17984'thead': tableWrap,1798517986'td': trWrap,17987'th': trWrap,1798817989'circle': svgWrap,17990'clipPath': svgWrap,17991'defs': svgWrap,17992'ellipse': svgWrap,17993'g': svgWrap,17994'line': svgWrap,17995'linearGradient': svgWrap,17996'path': svgWrap,17997'polygon': svgWrap,17998'polyline': svgWrap,17999'radialGradient': svgWrap,18000'rect': svgWrap,18001'stop': svgWrap,18002'text': svgWrap18003};1800418005/**18006* Gets the markup wrap configuration for the supplied `nodeName`.18007*18008* NOTE: This lazily detects which wraps are necessary for the current browser.18009*18010* @param {string} nodeName Lowercase `nodeName`.18011* @return {?array} Markup wrap configuration, if applicable.18012*/18013function getMarkupWrap(nodeName) {18014("production" !== "development" ? invariant(!!dummyNode, 'Markup wrapping node not initialized') : invariant(!!dummyNode));18015if (!markupWrap.hasOwnProperty(nodeName)) {18016nodeName = '*';18017}18018if (!shouldWrap.hasOwnProperty(nodeName)) {18019if (nodeName === '*') {18020dummyNode.innerHTML = '<link />';18021} else {18022dummyNode.innerHTML = '<' + nodeName + '></' + nodeName + '>';18023}18024shouldWrap[nodeName] = !dummyNode.firstChild;18025}18026return shouldWrap[nodeName] ? markupWrap[nodeName] : null;18027}180281802918030module.exports = getMarkupWrap;1803118032},{"135":135,"21":21}],128:[function(_dereq_,module,exports){18033/**18034* Copyright 2013-2015, Facebook, Inc.18035* All rights reserved.18036*18037* This source code is licensed under the BSD-style license found in the18038* LICENSE file in the root directory of this source tree. An additional grant18039* of patent rights can be found in the PATENTS file in the same directory.18040*18041* @providesModule getNodeForCharacterOffset18042*/1804318044'use strict';1804518046/**18047* Given any node return the first leaf node without children.18048*18049* @param {DOMElement|DOMTextNode} node18050* @return {DOMElement|DOMTextNode}18051*/18052function getLeafNode(node) {18053while (node && node.firstChild) {18054node = node.firstChild;18055}18056return node;18057}1805818059/**18060* Get the next sibling within a container. This will walk up the18061* DOM if a node's siblings have been exhausted.18062*18063* @param {DOMElement|DOMTextNode} node18064* @return {?DOMElement|DOMTextNode}18065*/18066function getSiblingNode(node) {18067while (node) {18068if (node.nextSibling) {18069return node.nextSibling;18070}18071node = node.parentNode;18072}18073}1807418075/**18076* Get object describing the nodes which contain characters at offset.18077*18078* @param {DOMElement|DOMTextNode} root18079* @param {number} offset18080* @return {?object}18081*/18082function getNodeForCharacterOffset(root, offset) {18083var node = getLeafNode(root);18084var nodeStart = 0;18085var nodeEnd = 0;1808618087while (node) {18088if (node.nodeType === 3) {18089nodeEnd = nodeStart + node.textContent.length;1809018091if (nodeStart <= offset && nodeEnd >= offset) {18092return {18093node: node,18094offset: offset - nodeStart18095};18096}1809718098nodeStart = nodeEnd;18099}1810018101node = getLeafNode(getSiblingNode(node));18102}18103}1810418105module.exports = getNodeForCharacterOffset;1810618107},{}],129:[function(_dereq_,module,exports){18108/**18109* Copyright 2013-2015, Facebook, Inc.18110* All rights reserved.18111*18112* This source code is licensed under the BSD-style license found in the18113* LICENSE file in the root directory of this source tree. An additional grant18114* of patent rights can be found in the PATENTS file in the same directory.18115*18116* @providesModule getReactRootElementInContainer18117*/1811818119'use strict';1812018121var DOC_NODE_TYPE = 9;1812218123/**18124* @param {DOMElement|DOMDocument} container DOM element that may contain18125* a React component18126* @return {?*} DOM element that may have the reactRoot ID, or null.18127*/18128function getReactRootElementInContainer(container) {18129if (!container) {18130return null;18131}1813218133if (container.nodeType === DOC_NODE_TYPE) {18134return container.documentElement;18135} else {18136return container.firstChild;18137}18138}1813918140module.exports = getReactRootElementInContainer;1814118142},{}],130:[function(_dereq_,module,exports){18143/**18144* Copyright 2013-2015, Facebook, Inc.18145* All rights reserved.18146*18147* This source code is licensed under the BSD-style license found in the18148* LICENSE file in the root directory of this source tree. An additional grant18149* of patent rights can be found in the PATENTS file in the same directory.18150*18151* @providesModule getTextContentAccessor18152*/1815318154'use strict';1815518156var ExecutionEnvironment = _dereq_(21);1815718158var contentKey = null;1815918160/**18161* Gets the key used to access text content on a DOM node.18162*18163* @return {?string} Key used to access text content.18164* @internal18165*/18166function getTextContentAccessor() {18167if (!contentKey && ExecutionEnvironment.canUseDOM) {18168// Prefer textContent to innerText because many browsers support both but18169// SVG <text> elements don't support innerText even when <div> does.18170contentKey = 'textContent' in document.documentElement ?18171'textContent' :18172'innerText';18173}18174return contentKey;18175}1817618177module.exports = getTextContentAccessor;1817818179},{"21":21}],131:[function(_dereq_,module,exports){18180/**18181* Copyright 2013-2015, Facebook, Inc.18182* All rights reserved.18183*18184* This source code is licensed under the BSD-style license found in the18185* LICENSE file in the root directory of this source tree. An additional grant18186* of patent rights can be found in the PATENTS file in the same directory.18187*18188* @providesModule getUnboundedScrollPosition18189* @typechecks18190*/1819118192"use strict";1819318194/**18195* Gets the scroll position of the supplied element or window.18196*18197* The return values are unbounded, unlike `getScrollPosition`. This means they18198* may be negative or exceed the element boundaries (which is possible using18199* inertial scrolling).18200*18201* @param {DOMWindow|DOMElement} scrollable18202* @return {object} Map with `x` and `y` keys.18203*/18204function getUnboundedScrollPosition(scrollable) {18205if (scrollable === window) {18206return {18207x: window.pageXOffset || document.documentElement.scrollLeft,18208y: window.pageYOffset || document.documentElement.scrollTop18209};18210}18211return {18212x: scrollable.scrollLeft,18213y: scrollable.scrollTop18214};18215}1821618217module.exports = getUnboundedScrollPosition;1821818219},{}],132:[function(_dereq_,module,exports){18220/**18221* Copyright 2013-2015, Facebook, Inc.18222* All rights reserved.18223*18224* This source code is licensed under the BSD-style license found in the18225* LICENSE file in the root directory of this source tree. An additional grant18226* of patent rights can be found in the PATENTS file in the same directory.18227*18228* @providesModule hyphenate18229* @typechecks18230*/1823118232var _uppercasePattern = /([A-Z])/g;1823318234/**18235* Hyphenates a camelcased string, for example:18236*18237* > hyphenate('backgroundColor')18238* < "background-color"18239*18240* For CSS style names, use `hyphenateStyleName` instead which works properly18241* with all vendor prefixes, including `ms`.18242*18243* @param {string} string18244* @return {string}18245*/18246function hyphenate(string) {18247return string.replace(_uppercasePattern, '-$1').toLowerCase();18248}1824918250module.exports = hyphenate;1825118252},{}],133:[function(_dereq_,module,exports){18253/**18254* Copyright 2013-2015, Facebook, Inc.18255* All rights reserved.18256*18257* This source code is licensed under the BSD-style license found in the18258* LICENSE file in the root directory of this source tree. An additional grant18259* of patent rights can be found in the PATENTS file in the same directory.18260*18261* @providesModule hyphenateStyleName18262* @typechecks18263*/1826418265"use strict";1826618267var hyphenate = _dereq_(132);1826818269var msPattern = /^ms-/;1827018271/**18272* Hyphenates a camelcased CSS property name, for example:18273*18274* > hyphenateStyleName('backgroundColor')18275* < "background-color"18276* > hyphenateStyleName('MozTransition')18277* < "-moz-transition"18278* > hyphenateStyleName('msTransition')18279* < "-ms-transition"18280*18281* As Modernizr suggests (http://modernizr.com/docs/#prefixed), an `ms` prefix18282* is converted to `-ms-`.18283*18284* @param {string} string18285* @return {string}18286*/18287function hyphenateStyleName(string) {18288return hyphenate(string).replace(msPattern, '-ms-');18289}1829018291module.exports = hyphenateStyleName;1829218293},{"132":132}],134:[function(_dereq_,module,exports){18294/**18295* Copyright 2013-2015, Facebook, Inc.18296* All rights reserved.18297*18298* This source code is licensed under the BSD-style license found in the18299* LICENSE file in the root directory of this source tree. An additional grant18300* of patent rights can be found in the PATENTS file in the same directory.18301*18302* @providesModule instantiateReactComponent18303* @typechecks static-only18304*/1830518306'use strict';1830718308var ReactCompositeComponent = _dereq_(37);18309var ReactEmptyComponent = _dereq_(59);18310var ReactNativeComponent = _dereq_(73);1831118312var assign = _dereq_(27);18313var invariant = _dereq_(135);18314var warning = _dereq_(154);1831518316// To avoid a cyclic dependency, we create the final class in this module18317var ReactCompositeComponentWrapper = function() { };18318assign(18319ReactCompositeComponentWrapper.prototype,18320ReactCompositeComponent.Mixin,18321{18322_instantiateReactComponent: instantiateReactComponent18323}18324);1832518326/**18327* Check if the type reference is a known internal type. I.e. not a user18328* provided composite type.18329*18330* @param {function} type18331* @return {boolean} Returns true if this is a valid internal type.18332*/18333function isInternalComponentType(type) {18334return (18335typeof type === 'function' &&18336typeof type.prototype !== 'undefined' &&18337typeof type.prototype.mountComponent === 'function' &&18338typeof type.prototype.receiveComponent === 'function'18339);18340}1834118342/**18343* Given a ReactNode, create an instance that will actually be mounted.18344*18345* @param {ReactNode} node18346* @param {*} parentCompositeType The composite type that resolved this.18347* @return {object} A new instance of the element's constructor.18348* @protected18349*/18350function instantiateReactComponent(node, parentCompositeType) {18351var instance;1835218353if (node === null || node === false) {18354node = ReactEmptyComponent.emptyElement;18355}1835618357if (typeof node === 'object') {18358var element = node;18359if ("production" !== "development") {18360("production" !== "development" ? warning(18361element && (typeof element.type === 'function' ||18362typeof element.type === 'string'),18363'Only functions or strings can be mounted as React components.'18364) : null);18365}1836618367// Special case string values18368if (parentCompositeType === element.type &&18369typeof element.type === 'string') {18370// Avoid recursion if the wrapper renders itself.18371instance = ReactNativeComponent.createInternalComponent(element);18372// All native components are currently wrapped in a composite so we're18373// safe to assume that this is what we should instantiate.18374} else if (isInternalComponentType(element.type)) {18375// This is temporarily available for custom components that are not string18376// represenations. I.e. ART. Once those are updated to use the string18377// representation, we can drop this code path.18378instance = new element.type(element);18379} else {18380instance = new ReactCompositeComponentWrapper();18381}18382} else if (typeof node === 'string' || typeof node === 'number') {18383instance = ReactNativeComponent.createInstanceForText(node);18384} else {18385("production" !== "development" ? invariant(18386false,18387'Encountered invalid React node of type %s',18388typeof node18389) : invariant(false));18390}1839118392if ("production" !== "development") {18393("production" !== "development" ? warning(18394typeof instance.construct === 'function' &&18395typeof instance.mountComponent === 'function' &&18396typeof instance.receiveComponent === 'function' &&18397typeof instance.unmountComponent === 'function',18398'Only React Components can be mounted.'18399) : null);18400}1840118402// Sets up the instance. This can probably just move into the constructor now.18403instance.construct(node);1840418405// These two fields are used by the DOM and ART diffing algorithms18406// respectively. Instead of using expandos on components, we should be18407// storing the state needed by the diffing algorithms elsewhere.18408instance._mountIndex = 0;18409instance._mountImage = null;1841018411if ("production" !== "development") {18412instance._isOwnerNecessary = false;18413instance._warnedAboutRefsInRender = false;18414}1841518416// Internal instances should fully constructed at this point, so they should18417// not get any new fields added to them at this point.18418if ("production" !== "development") {18419if (Object.preventExtensions) {18420Object.preventExtensions(instance);18421}18422}1842318424return instance;18425}1842618427module.exports = instantiateReactComponent;1842818429},{"135":135,"154":154,"27":27,"37":37,"59":59,"73":73}],135:[function(_dereq_,module,exports){18430/**18431* Copyright 2013-2015, Facebook, Inc.18432* All rights reserved.18433*18434* This source code is licensed under the BSD-style license found in the18435* LICENSE file in the root directory of this source tree. An additional grant18436* of patent rights can be found in the PATENTS file in the same directory.18437*18438* @providesModule invariant18439*/1844018441"use strict";1844218443/**18444* Use invariant() to assert state which your program assumes to be true.18445*18446* Provide sprintf-style format (only %s is supported) and arguments18447* to provide information about what broke and what you were18448* expecting.18449*18450* The invariant message will be stripped in production, but the invariant18451* will remain to ensure logic does not differ in production.18452*/1845318454var invariant = function(condition, format, a, b, c, d, e, f) {18455if ("production" !== "development") {18456if (format === undefined) {18457throw new Error('invariant requires an error message argument');18458}18459}1846018461if (!condition) {18462var error;18463if (format === undefined) {18464error = new Error(18465'Minified exception occurred; use the non-minified dev environment ' +18466'for the full error message and additional helpful warnings.'18467);18468} else {18469var args = [a, b, c, d, e, f];18470var argIndex = 0;18471error = new Error(18472'Invariant Violation: ' +18473format.replace(/%s/g, function() { return args[argIndex++]; })18474);18475}1847618477error.framesToPop = 1; // we don't care about invariant's own frame18478throw error;18479}18480};1848118482module.exports = invariant;1848318484},{}],136:[function(_dereq_,module,exports){18485/**18486* Copyright 2013-2015, Facebook, Inc.18487* All rights reserved.18488*18489* This source code is licensed under the BSD-style license found in the18490* LICENSE file in the root directory of this source tree. An additional grant18491* of patent rights can be found in the PATENTS file in the same directory.18492*18493* @providesModule isEventSupported18494*/1849518496'use strict';1849718498var ExecutionEnvironment = _dereq_(21);1849918500var useHasFeature;18501if (ExecutionEnvironment.canUseDOM) {18502useHasFeature =18503document.implementation &&18504document.implementation.hasFeature &&18505// always returns true in newer browsers as per the standard.18506// @see http://dom.spec.whatwg.org/#dom-domimplementation-hasfeature18507document.implementation.hasFeature('', '') !== true;18508}1850918510/**18511* Checks if an event is supported in the current execution environment.18512*18513* NOTE: This will not work correctly for non-generic events such as `change`,18514* `reset`, `load`, `error`, and `select`.18515*18516* Borrows from Modernizr.18517*18518* @param {string} eventNameSuffix Event name, e.g. "click".18519* @param {?boolean} capture Check if the capture phase is supported.18520* @return {boolean} True if the event is supported.18521* @internal18522* @license Modernizr 3.0.0pre (Custom Build) | MIT18523*/18524function isEventSupported(eventNameSuffix, capture) {18525if (!ExecutionEnvironment.canUseDOM ||18526capture && !('addEventListener' in document)) {18527return false;18528}1852918530var eventName = 'on' + eventNameSuffix;18531var isSupported = eventName in document;1853218533if (!isSupported) {18534var element = document.createElement('div');18535element.setAttribute(eventName, 'return;');18536isSupported = typeof element[eventName] === 'function';18537}1853818539if (!isSupported && useHasFeature && eventNameSuffix === 'wheel') {18540// This is the only way to test support for the `wheel` event in IE9+.18541isSupported = document.implementation.hasFeature('Events.wheel', '3.0');18542}1854318544return isSupported;18545}1854618547module.exports = isEventSupported;1854818549},{"21":21}],137:[function(_dereq_,module,exports){18550/**18551* Copyright 2013-2015, Facebook, Inc.18552* All rights reserved.18553*18554* This source code is licensed under the BSD-style license found in the18555* LICENSE file in the root directory of this source tree. An additional grant18556* of patent rights can be found in the PATENTS file in the same directory.18557*18558* @providesModule isNode18559* @typechecks18560*/1856118562/**18563* @param {*} object The object to check.18564* @return {boolean} Whether or not the object is a DOM node.18565*/18566function isNode(object) {18567return !!(object && (18568((typeof Node === 'function' ? object instanceof Node : typeof object === 'object' &&18569typeof object.nodeType === 'number' &&18570typeof object.nodeName === 'string'))18571));18572}1857318574module.exports = isNode;1857518576},{}],138:[function(_dereq_,module,exports){18577/**18578* Copyright 2013-2015, Facebook, Inc.18579* All rights reserved.18580*18581* This source code is licensed under the BSD-style license found in the18582* LICENSE file in the root directory of this source tree. An additional grant18583* of patent rights can be found in the PATENTS file in the same directory.18584*18585* @providesModule isTextInputElement18586*/1858718588'use strict';1858918590/**18591* @see http://www.whatwg.org/specs/web-apps/current-work/multipage/the-input-element.html#input-type-attr-summary18592*/18593var supportedInputTypes = {18594'color': true,18595'date': true,18596'datetime': true,18597'datetime-local': true,18598'email': true,18599'month': true,18600'number': true,18601'password': true,18602'range': true,18603'search': true,18604'tel': true,18605'text': true,18606'time': true,18607'url': true,18608'week': true18609};1861018611function isTextInputElement(elem) {18612return elem && (18613(elem.nodeName === 'INPUT' && supportedInputTypes[elem.type] || elem.nodeName === 'TEXTAREA')18614);18615}1861618617module.exports = isTextInputElement;1861818619},{}],139:[function(_dereq_,module,exports){18620/**18621* Copyright 2013-2015, Facebook, Inc.18622* All rights reserved.18623*18624* This source code is licensed under the BSD-style license found in the18625* LICENSE file in the root directory of this source tree. An additional grant18626* of patent rights can be found in the PATENTS file in the same directory.18627*18628* @providesModule isTextNode18629* @typechecks18630*/1863118632var isNode = _dereq_(137);1863318634/**18635* @param {*} object The object to check.18636* @return {boolean} Whether or not the object is a DOM text node.18637*/18638function isTextNode(object) {18639return isNode(object) && object.nodeType == 3;18640}1864118642module.exports = isTextNode;1864318644},{"137":137}],140:[function(_dereq_,module,exports){18645/**18646* Copyright 2013-2015, Facebook, Inc.18647* All rights reserved.18648*18649* This source code is licensed under the BSD-style license found in the18650* LICENSE file in the root directory of this source tree. An additional grant18651* of patent rights can be found in the PATENTS file in the same directory.18652*18653* @providesModule keyMirror18654* @typechecks static-only18655*/1865618657'use strict';1865818659var invariant = _dereq_(135);1866018661/**18662* Constructs an enumeration with keys equal to their value.18663*18664* For example:18665*18666* var COLORS = keyMirror({blue: null, red: null});18667* var myColor = COLORS.blue;18668* var isColorValid = !!COLORS[myColor];18669*18670* The last line could not be performed if the values of the generated enum were18671* not equal to their keys.18672*18673* Input: {key1: val1, key2: val2}18674* Output: {key1: key1, key2: key2}18675*18676* @param {object} obj18677* @return {object}18678*/18679var keyMirror = function(obj) {18680var ret = {};18681var key;18682("production" !== "development" ? invariant(18683obj instanceof Object && !Array.isArray(obj),18684'keyMirror(...): Argument must be an object.'18685) : invariant(obj instanceof Object && !Array.isArray(obj)));18686for (key in obj) {18687if (!obj.hasOwnProperty(key)) {18688continue;18689}18690ret[key] = key;18691}18692return ret;18693};1869418695module.exports = keyMirror;1869618697},{"135":135}],141:[function(_dereq_,module,exports){18698/**18699* Copyright 2013-2015, Facebook, Inc.18700* All rights reserved.18701*18702* This source code is licensed under the BSD-style license found in the18703* LICENSE file in the root directory of this source tree. An additional grant18704* of patent rights can be found in the PATENTS file in the same directory.18705*18706* @providesModule keyOf18707*/1870818709/**18710* Allows extraction of a minified key. Let's the build system minify keys18711* without loosing the ability to dynamically use key strings as values18712* themselves. Pass in an object with a single key/val pair and it will return18713* you the string key of that single record. Suppose you want to grab the18714* value for a key 'className' inside of an object. Key/val minification may18715* have aliased that key to be 'xa12'. keyOf({className: null}) will return18716* 'xa12' in that case. Resolve keys you want to use once at startup time, then18717* reuse those resolutions.18718*/18719var keyOf = function(oneKeyObj) {18720var key;18721for (key in oneKeyObj) {18722if (!oneKeyObj.hasOwnProperty(key)) {18723continue;18724}18725return key;18726}18727return null;18728};187291873018731module.exports = keyOf;1873218733},{}],142:[function(_dereq_,module,exports){18734/**18735* Copyright 2013-2015, Facebook, Inc.18736* All rights reserved.18737*18738* This source code is licensed under the BSD-style license found in the18739* LICENSE file in the root directory of this source tree. An additional grant18740* of patent rights can be found in the PATENTS file in the same directory.18741*18742* @providesModule mapObject18743*/1874418745'use strict';1874618747var hasOwnProperty = Object.prototype.hasOwnProperty;1874818749/**18750* Executes the provided `callback` once for each enumerable own property in the18751* object and constructs a new object from the results. The `callback` is18752* invoked with three arguments:18753*18754* - the property value18755* - the property name18756* - the object being traversed18757*18758* Properties that are added after the call to `mapObject` will not be visited18759* by `callback`. If the values of existing properties are changed, the value18760* passed to `callback` will be the value at the time `mapObject` visits them.18761* Properties that are deleted before being visited are not visited.18762*18763* @grep function objectMap()18764* @grep function objMap()18765*18766* @param {?object} object18767* @param {function} callback18768* @param {*} context18769* @return {?object}18770*/18771function mapObject(object, callback, context) {18772if (!object) {18773return null;18774}18775var result = {};18776for (var name in object) {18777if (hasOwnProperty.call(object, name)) {18778result[name] = callback.call(context, object[name], name, object);18779}18780}18781return result;18782}1878318784module.exports = mapObject;1878518786},{}],143:[function(_dereq_,module,exports){18787/**18788* Copyright 2013-2015, Facebook, Inc.18789* All rights reserved.18790*18791* This source code is licensed under the BSD-style license found in the18792* LICENSE file in the root directory of this source tree. An additional grant18793* of patent rights can be found in the PATENTS file in the same directory.18794*18795* @providesModule memoizeStringOnly18796* @typechecks static-only18797*/1879818799'use strict';1880018801/**18802* Memoizes the return value of a function that accepts one string argument.18803*18804* @param {function} callback18805* @return {function}18806*/18807function memoizeStringOnly(callback) {18808var cache = {};18809return function(string) {18810if (!cache.hasOwnProperty(string)) {18811cache[string] = callback.call(this, string);18812}18813return cache[string];18814};18815}1881618817module.exports = memoizeStringOnly;1881818819},{}],144:[function(_dereq_,module,exports){18820/**18821* Copyright 2013-2015, Facebook, Inc.18822* All rights reserved.18823*18824* This source code is licensed under the BSD-style license found in the18825* LICENSE file in the root directory of this source tree. An additional grant18826* of patent rights can be found in the PATENTS file in the same directory.18827*18828* @providesModule onlyChild18829*/18830'use strict';1883118832var ReactElement = _dereq_(57);1883318834var invariant = _dereq_(135);1883518836/**18837* Returns the first child in a collection of children and verifies that there18838* is only one child in the collection. The current implementation of this18839* function assumes that a single child gets passed without a wrapper, but the18840* purpose of this helper function is to abstract away the particular structure18841* of children.18842*18843* @param {?object} children Child collection structure.18844* @return {ReactComponent} The first and only `ReactComponent` contained in the18845* structure.18846*/18847function onlyChild(children) {18848("production" !== "development" ? invariant(18849ReactElement.isValidElement(children),18850'onlyChild must be passed a children with exactly one child.'18851) : invariant(ReactElement.isValidElement(children)));18852return children;18853}1885418855module.exports = onlyChild;1885618857},{"135":135,"57":57}],145:[function(_dereq_,module,exports){18858/**18859* Copyright 2013-2015, Facebook, Inc.18860* All rights reserved.18861*18862* This source code is licensed under the BSD-style license found in the18863* LICENSE file in the root directory of this source tree. An additional grant18864* of patent rights can be found in the PATENTS file in the same directory.18865*18866* @providesModule performance18867* @typechecks18868*/1886918870"use strict";1887118872var ExecutionEnvironment = _dereq_(21);1887318874var performance;1887518876if (ExecutionEnvironment.canUseDOM) {18877performance =18878window.performance ||18879window.msPerformance ||18880window.webkitPerformance;18881}1888218883module.exports = performance || {};1888418885},{"21":21}],146:[function(_dereq_,module,exports){18886/**18887* Copyright 2013-2015, Facebook, Inc.18888* All rights reserved.18889*18890* This source code is licensed under the BSD-style license found in the18891* LICENSE file in the root directory of this source tree. An additional grant18892* of patent rights can be found in the PATENTS file in the same directory.18893*18894* @providesModule performanceNow18895* @typechecks18896*/1889718898var performance = _dereq_(145);1889918900/**18901* Detect if we can use `window.performance.now()` and gracefully fallback to18902* `Date.now()` if it doesn't exist. We need to support Firefox < 15 for now18903* because of Facebook's testing infrastructure.18904*/18905if (!performance || !performance.now) {18906performance = Date;18907}1890818909var performanceNow = performance.now.bind(performance);1891018911module.exports = performanceNow;1891218913},{"145":145}],147:[function(_dereq_,module,exports){18914/**18915* Copyright 2013-2015, Facebook, Inc.18916* All rights reserved.18917*18918* This source code is licensed under the BSD-style license found in the18919* LICENSE file in the root directory of this source tree. An additional grant18920* of patent rights can be found in the PATENTS file in the same directory.18921*18922* @providesModule quoteAttributeValueForBrowser18923*/1892418925'use strict';1892618927var escapeTextContentForBrowser = _dereq_(116);1892818929/**18930* Escapes attribute value to prevent scripting attacks.18931*18932* @param {*} value Value to escape.18933* @return {string} An escaped string.18934*/18935function quoteAttributeValueForBrowser(value) {18936return '"' + escapeTextContentForBrowser(value) + '"';18937}1893818939module.exports = quoteAttributeValueForBrowser;1894018941},{"116":116}],148:[function(_dereq_,module,exports){18942/**18943* Copyright 2013-2015, Facebook, Inc.18944* All rights reserved.18945*18946* This source code is licensed under the BSD-style license found in the18947* LICENSE file in the root directory of this source tree. An additional grant18948* of patent rights can be found in the PATENTS file in the same directory.18949*18950* @providesModule setInnerHTML18951*/1895218953/* globals MSApp */1895418955'use strict';1895618957var ExecutionEnvironment = _dereq_(21);1895818959var WHITESPACE_TEST = /^[ \r\n\t\f]/;18960var NONVISIBLE_TEST = /<(!--|link|noscript|meta|script|style)[ \r\n\t\f\/>]/;1896118962/**18963* Set the innerHTML property of a node, ensuring that whitespace is preserved18964* even in IE8.18965*18966* @param {DOMElement} node18967* @param {string} html18968* @internal18969*/18970var setInnerHTML = function(node, html) {18971node.innerHTML = html;18972};1897318974// Win8 apps: Allow all html to be inserted18975if (typeof MSApp !== 'undefined' && MSApp.execUnsafeLocalFunction) {18976setInnerHTML = function(node, html) {18977MSApp.execUnsafeLocalFunction(function() {18978node.innerHTML = html;18979});18980};18981}1898218983if (ExecutionEnvironment.canUseDOM) {18984// IE8: When updating a just created node with innerHTML only leading18985// whitespace is removed. When updating an existing node with innerHTML18986// whitespace in root TextNodes is also collapsed.18987// @see quirksmode.org/bugreports/archives/2004/11/innerhtml_and_t.html1898818989// Feature detection; only IE8 is known to behave improperly like this.18990var testElement = document.createElement('div');18991testElement.innerHTML = ' ';18992if (testElement.innerHTML === '') {18993setInnerHTML = function(node, html) {18994// Magic theory: IE8 supposedly differentiates between added and updated18995// nodes when processing innerHTML, innerHTML on updated nodes suffers18996// from worse whitespace behavior. Re-adding a node like this triggers18997// the initial and more favorable whitespace behavior.18998// TODO: What to do on a detached node?18999if (node.parentNode) {19000node.parentNode.replaceChild(node, node);19001}1900219003// We also implement a workaround for non-visible tags disappearing into19004// thin air on IE8, this only happens if there is no visible text19005// in-front of the non-visible tags. Piggyback on the whitespace fix19006// and simply check if any non-visible tags appear in the source.19007if (WHITESPACE_TEST.test(html) ||19008html[0] === '<' && NONVISIBLE_TEST.test(html)) {19009// Recover leading whitespace by temporarily prepending any character.19010// \uFEFF has the potential advantage of being zero-width/invisible.19011node.innerHTML = '\uFEFF' + html;1901219013// deleteData leaves an empty `TextNode` which offsets the index of all19014// children. Definitely want to avoid this.19015var textNode = node.firstChild;19016if (textNode.data.length === 1) {19017node.removeChild(textNode);19018} else {19019textNode.deleteData(0, 1);19020}19021} else {19022node.innerHTML = html;19023}19024};19025}19026}1902719028module.exports = setInnerHTML;1902919030},{"21":21}],149:[function(_dereq_,module,exports){19031/**19032* Copyright 2013-2015, Facebook, Inc.19033* All rights reserved.19034*19035* This source code is licensed under the BSD-style license found in the19036* LICENSE file in the root directory of this source tree. An additional grant19037* of patent rights can be found in the PATENTS file in the same directory.19038*19039* @providesModule setTextContent19040*/1904119042'use strict';1904319044var ExecutionEnvironment = _dereq_(21);19045var escapeTextContentForBrowser = _dereq_(116);19046var setInnerHTML = _dereq_(148);1904719048/**19049* Set the textContent property of a node, ensuring that whitespace is preserved19050* even in IE8. innerText is a poor substitute for textContent and, among many19051* issues, inserts <br> instead of the literal newline chars. innerHTML behaves19052* as it should.19053*19054* @param {DOMElement} node19055* @param {string} text19056* @internal19057*/19058var setTextContent = function(node, text) {19059node.textContent = text;19060};1906119062if (ExecutionEnvironment.canUseDOM) {19063if (!('textContent' in document.documentElement)) {19064setTextContent = function(node, text) {19065setInnerHTML(node, escapeTextContentForBrowser(text));19066};19067}19068}1906919070module.exports = setTextContent;1907119072},{"116":116,"148":148,"21":21}],150:[function(_dereq_,module,exports){19073/**19074* Copyright 2013-2015, Facebook, Inc.19075* All rights reserved.19076*19077* This source code is licensed under the BSD-style license found in the19078* LICENSE file in the root directory of this source tree. An additional grant19079* of patent rights can be found in the PATENTS file in the same directory.19080*19081* @providesModule shallowEqual19082*/1908319084'use strict';1908519086/**19087* Performs equality by iterating through keys on an object and returning19088* false when any key has values which are not strictly equal between19089* objA and objB. Returns true when the values of all keys are strictly equal.19090*19091* @return {boolean}19092*/19093function shallowEqual(objA, objB) {19094if (objA === objB) {19095return true;19096}19097var key;19098// Test for A's keys different from B.19099for (key in objA) {19100if (objA.hasOwnProperty(key) &&19101(!objB.hasOwnProperty(key) || objA[key] !== objB[key])) {19102return false;19103}19104}19105// Test for B's keys missing from A.19106for (key in objB) {19107if (objB.hasOwnProperty(key) && !objA.hasOwnProperty(key)) {19108return false;19109}19110}19111return true;19112}1911319114module.exports = shallowEqual;1911519116},{}],151:[function(_dereq_,module,exports){19117/**19118* Copyright 2013-2015, Facebook, Inc.19119* All rights reserved.19120*19121* This source code is licensed under the BSD-style license found in the19122* LICENSE file in the root directory of this source tree. An additional grant19123* of patent rights can be found in the PATENTS file in the same directory.19124*19125* @providesModule shouldUpdateReactComponent19126* @typechecks static-only19127*/1912819129'use strict';1913019131var warning = _dereq_(154);1913219133/**19134* Given a `prevElement` and `nextElement`, determines if the existing19135* instance should be updated as opposed to being destroyed or replaced by a new19136* instance. Both arguments are elements. This ensures that this logic can19137* operate on stateless trees without any backing instance.19138*19139* @param {?object} prevElement19140* @param {?object} nextElement19141* @return {boolean} True if the existing instance should be updated.19142* @protected19143*/19144function shouldUpdateReactComponent(prevElement, nextElement) {19145if (prevElement != null && nextElement != null) {19146var prevType = typeof prevElement;19147var nextType = typeof nextElement;19148if (prevType === 'string' || prevType === 'number') {19149return (nextType === 'string' || nextType === 'number');19150} else {19151if (nextType === 'object' &&19152prevElement.type === nextElement.type &&19153prevElement.key === nextElement.key) {19154var ownersMatch = prevElement._owner === nextElement._owner;19155var prevName = null;19156var nextName = null;19157var nextDisplayName = null;19158if ("production" !== "development") {19159if (!ownersMatch) {19160if (prevElement._owner != null &&19161prevElement._owner.getPublicInstance() != null &&19162prevElement._owner.getPublicInstance().constructor != null) {19163prevName =19164prevElement._owner.getPublicInstance().constructor.displayName;19165}19166if (nextElement._owner != null &&19167nextElement._owner.getPublicInstance() != null &&19168nextElement._owner.getPublicInstance().constructor != null) {19169nextName =19170nextElement._owner.getPublicInstance().constructor.displayName;19171}19172if (nextElement.type != null &&19173nextElement.type.displayName != null) {19174nextDisplayName = nextElement.type.displayName;19175}19176if (nextElement.type != null && typeof nextElement.type === 'string') {19177nextDisplayName = nextElement.type;19178}19179if (typeof nextElement.type !== 'string' ||19180nextElement.type === 'input' ||19181nextElement.type === 'textarea') {19182if ((prevElement._owner != null &&19183prevElement._owner._isOwnerNecessary === false) ||19184(nextElement._owner != null &&19185nextElement._owner._isOwnerNecessary === false)) {19186if (prevElement._owner != null) {19187prevElement._owner._isOwnerNecessary = true;19188}19189if (nextElement._owner != null) {19190nextElement._owner._isOwnerNecessary = true;19191}19192("production" !== "development" ? warning(19193false,19194'<%s /> is being rendered by both %s and %s using the same ' +19195'key (%s) in the same place. Currently, this means that ' +19196'they don\'t preserve state. This behavior should be very ' +19197'rare so we\'re considering deprecating it. Please contact ' +19198'the React team and explain your use case so that we can ' +19199'take that into consideration.',19200nextDisplayName || 'Unknown Component',19201prevName || '[Unknown]',19202nextName || '[Unknown]',19203prevElement.key19204) : null);19205}19206}19207}19208}19209return ownersMatch;19210}19211}19212}19213return false;19214}1921519216module.exports = shouldUpdateReactComponent;1921719218},{"154":154}],152:[function(_dereq_,module,exports){19219/**19220* Copyright 2014-2015, Facebook, Inc.19221* All rights reserved.19222*19223* This source code is licensed under the BSD-style license found in the19224* LICENSE file in the root directory of this source tree. An additional grant19225* of patent rights can be found in the PATENTS file in the same directory.19226*19227* @providesModule toArray19228* @typechecks19229*/1923019231var invariant = _dereq_(135);1923219233/**19234* Convert array-like objects to arrays.19235*19236* This API assumes the caller knows the contents of the data type. For less19237* well defined inputs use createArrayFromMixed.19238*19239* @param {object|function|filelist} obj19240* @return {array}19241*/19242function toArray(obj) {19243var length = obj.length;1924419245// Some browse builtin objects can report typeof 'function' (e.g. NodeList in19246// old versions of Safari).19247("production" !== "development" ? invariant(19248!Array.isArray(obj) &&19249(typeof obj === 'object' || typeof obj === 'function'),19250'toArray: Array-like object expected'19251) : invariant(!Array.isArray(obj) &&19252(typeof obj === 'object' || typeof obj === 'function')));1925319254("production" !== "development" ? invariant(19255typeof length === 'number',19256'toArray: Object needs a length property'19257) : invariant(typeof length === 'number'));1925819259("production" !== "development" ? invariant(19260length === 0 ||19261(length - 1) in obj,19262'toArray: Object should have keys for indices'19263) : invariant(length === 0 ||19264(length - 1) in obj));1926519266// Old IE doesn't give collections access to hasOwnProperty. Assume inputs19267// without method will throw during the slice call and skip straight to the19268// fallback.19269if (obj.hasOwnProperty) {19270try {19271return Array.prototype.slice.call(obj);19272} catch (e) {19273// IE < 9 does not support Array#slice on collections objects19274}19275}1927619277// Fall back to copying key by key. This assumes all keys have a value,19278// so will not preserve sparsely populated inputs.19279var ret = Array(length);19280for (var ii = 0; ii < length; ii++) {19281ret[ii] = obj[ii];19282}19283return ret;19284}1928519286module.exports = toArray;1928719288},{"135":135}],153:[function(_dereq_,module,exports){19289/**19290* Copyright 2013-2015, Facebook, Inc.19291* All rights reserved.19292*19293* This source code is licensed under the BSD-style license found in the19294* LICENSE file in the root directory of this source tree. An additional grant19295* of patent rights can be found in the PATENTS file in the same directory.19296*19297* @providesModule traverseAllChildren19298*/1929919300'use strict';1930119302var ReactElement = _dereq_(57);19303var ReactFragment = _dereq_(63);19304var ReactInstanceHandles = _dereq_(66);1930519306var getIteratorFn = _dereq_(126);19307var invariant = _dereq_(135);19308var warning = _dereq_(154);1930919310var SEPARATOR = ReactInstanceHandles.SEPARATOR;19311var SUBSEPARATOR = ':';1931219313/**19314* TODO: Test that a single child and an array with one item have the same key19315* pattern.19316*/1931719318var userProvidedKeyEscaperLookup = {19319'=': '=0',19320'.': '=1',19321':': '=2'19322};1932319324var userProvidedKeyEscapeRegex = /[=.:]/g;1932519326var didWarnAboutMaps = false;1932719328function userProvidedKeyEscaper(match) {19329return userProvidedKeyEscaperLookup[match];19330}1933119332/**19333* Generate a key string that identifies a component within a set.19334*19335* @param {*} component A component that could contain a manual key.19336* @param {number} index Index that is used if a manual key is not provided.19337* @return {string}19338*/19339function getComponentKey(component, index) {19340if (component && component.key != null) {19341// Explicit key19342return wrapUserProvidedKey(component.key);19343}19344// Implicit key determined by the index in the set19345return index.toString(36);19346}1934719348/**19349* Escape a component key so that it is safe to use in a reactid.19350*19351* @param {*} key Component key to be escaped.19352* @return {string} An escaped string.19353*/19354function escapeUserProvidedKey(text) {19355return ('' + text).replace(19356userProvidedKeyEscapeRegex,19357userProvidedKeyEscaper19358);19359}1936019361/**19362* Wrap a `key` value explicitly provided by the user to distinguish it from19363* implicitly-generated keys generated by a component's index in its parent.19364*19365* @param {string} key Value of a user-provided `key` attribute19366* @return {string}19367*/19368function wrapUserProvidedKey(key) {19369return '$' + escapeUserProvidedKey(key);19370}1937119372/**19373* @param {?*} children Children tree container.19374* @param {!string} nameSoFar Name of the key path so far.19375* @param {!number} indexSoFar Number of children encountered until this point.19376* @param {!function} callback Callback to invoke with each child found.19377* @param {?*} traverseContext Used to pass information throughout the traversal19378* process.19379* @return {!number} The number of children in this subtree.19380*/19381function traverseAllChildrenImpl(19382children,19383nameSoFar,19384indexSoFar,19385callback,19386traverseContext19387) {19388var type = typeof children;1938919390if (type === 'undefined' || type === 'boolean') {19391// All of the above are perceived as null.19392children = null;19393}1939419395if (children === null ||19396type === 'string' ||19397type === 'number' ||19398ReactElement.isValidElement(children)) {19399callback(19400traverseContext,19401children,19402// If it's the only child, treat the name as if it was wrapped in an array19403// so that it's consistent if the number of children grows.19404nameSoFar === '' ? SEPARATOR + getComponentKey(children, 0) : nameSoFar,19405indexSoFar19406);19407return 1;19408}1940919410var child, nextName, nextIndex;19411var subtreeCount = 0; // Count of children found in the current subtree.1941219413if (Array.isArray(children)) {19414for (var i = 0; i < children.length; i++) {19415child = children[i];19416nextName = (19417(nameSoFar !== '' ? nameSoFar + SUBSEPARATOR : SEPARATOR) +19418getComponentKey(child, i)19419);19420nextIndex = indexSoFar + subtreeCount;19421subtreeCount += traverseAllChildrenImpl(19422child,19423nextName,19424nextIndex,19425callback,19426traverseContext19427);19428}19429} else {19430var iteratorFn = getIteratorFn(children);19431if (iteratorFn) {19432var iterator = iteratorFn.call(children);19433var step;19434if (iteratorFn !== children.entries) {19435var ii = 0;19436while (!(step = iterator.next()).done) {19437child = step.value;19438nextName = (19439(nameSoFar !== '' ? nameSoFar + SUBSEPARATOR : SEPARATOR) +19440getComponentKey(child, ii++)19441);19442nextIndex = indexSoFar + subtreeCount;19443subtreeCount += traverseAllChildrenImpl(19444child,19445nextName,19446nextIndex,19447callback,19448traverseContext19449);19450}19451} else {19452if ("production" !== "development") {19453("production" !== "development" ? warning(19454didWarnAboutMaps,19455'Using Maps as children is not yet fully supported. It is an ' +19456'experimental feature that might be removed. Convert it to a ' +19457'sequence / iterable of keyed ReactElements instead.'19458) : null);19459didWarnAboutMaps = true;19460}19461// Iterator will provide entry [k,v] tuples rather than values.19462while (!(step = iterator.next()).done) {19463var entry = step.value;19464if (entry) {19465child = entry[1];19466nextName = (19467(nameSoFar !== '' ? nameSoFar + SUBSEPARATOR : SEPARATOR) +19468wrapUserProvidedKey(entry[0]) + SUBSEPARATOR +19469getComponentKey(child, 0)19470);19471nextIndex = indexSoFar + subtreeCount;19472subtreeCount += traverseAllChildrenImpl(19473child,19474nextName,19475nextIndex,19476callback,19477traverseContext19478);19479}19480}19481}19482} else if (type === 'object') {19483("production" !== "development" ? invariant(19484children.nodeType !== 1,19485'traverseAllChildren(...): Encountered an invalid child; DOM ' +19486'elements are not valid children of React components.'19487) : invariant(children.nodeType !== 1));19488var fragment = ReactFragment.extract(children);19489for (var key in fragment) {19490if (fragment.hasOwnProperty(key)) {19491child = fragment[key];19492nextName = (19493(nameSoFar !== '' ? nameSoFar + SUBSEPARATOR : SEPARATOR) +19494wrapUserProvidedKey(key) + SUBSEPARATOR +19495getComponentKey(child, 0)19496);19497nextIndex = indexSoFar + subtreeCount;19498subtreeCount += traverseAllChildrenImpl(19499child,19500nextName,19501nextIndex,19502callback,19503traverseContext19504);19505}19506}19507}19508}1950919510return subtreeCount;19511}1951219513/**19514* Traverses children that are typically specified as `props.children`, but19515* might also be specified through attributes:19516*19517* - `traverseAllChildren(this.props.children, ...)`19518* - `traverseAllChildren(this.props.leftPanelChildren, ...)`19519*19520* The `traverseContext` is an optional argument that is passed through the19521* entire traversal. It can be used to store accumulations or anything else that19522* the callback might find relevant.19523*19524* @param {?*} children Children tree object.19525* @param {!function} callback To invoke upon traversing each child.19526* @param {?*} traverseContext Context for traversal.19527* @return {!number} The number of children in this subtree.19528*/19529function traverseAllChildren(children, callback, traverseContext) {19530if (children == null) {19531return 0;19532}1953319534return traverseAllChildrenImpl(children, '', 0, callback, traverseContext);19535}1953619537module.exports = traverseAllChildren;1953819539},{"126":126,"135":135,"154":154,"57":57,"63":63,"66":66}],154:[function(_dereq_,module,exports){19540/**19541* Copyright 2014-2015, Facebook, Inc.19542* All rights reserved.19543*19544* This source code is licensed under the BSD-style license found in the19545* LICENSE file in the root directory of this source tree. An additional grant19546* of patent rights can be found in the PATENTS file in the same directory.19547*19548* @providesModule warning19549*/1955019551"use strict";1955219553var emptyFunction = _dereq_(114);1955419555/**19556* Similar to invariant but only logs a warning if the condition is not met.19557* This can be used to log issues in development environments in critical19558* paths. Removing the logging code for production environments will keep the19559* same logic and follow the same code paths.19560*/1956119562var warning = emptyFunction;1956319564if ("production" !== "development") {19565warning = function(condition, format ) {for (var args=[],$__0=2,$__1=arguments.length;$__0<$__1;$__0++) args.push(arguments[$__0]);19566if (format === undefined) {19567throw new Error(19568'`warning(condition, format, ...args)` requires a warning ' +19569'message argument'19570);19571}1957219573if (format.length < 10 || /^[s\W]*$/.test(format)) {19574throw new Error(19575'The warning format should be able to uniquely identify this ' +19576'warning. Please, use a more descriptive format than: ' + format19577);19578}1957919580if (format.indexOf('Failed Composite propType: ') === 0) {19581return; // Ignore CompositeComponent proptype check.19582}1958319584if (!condition) {19585var argIndex = 0;19586var message = 'Warning: ' + format.replace(/%s/g, function() {return args[argIndex++];});19587console.warn(message);19588try {19589// --- Welcome to debugging React ---19590// This error was thrown as a convenience so that you can use this stack19591// to find the callsite that caused this warning to fire.19592throw new Error(message);19593} catch(x) {}19594}19595};19596}1959719598module.exports = warning;1959919600},{"114":114}]},{},[1])(1)19601});1960219603