/**

* React (with addons) v15.1.0

*/

(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.React = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){

/**

* Copyright 2013-present, Facebook, Inc.

* All rights reserved.

*

* This source code is licensed under the BSD-style license found in the

* LICENSE file in the root directory of this source tree. An additional grant

* of patent rights can be found in the PATENTS file in the same directory.

*

* @providesModule AutoFocusUtils

*/

'use strict';

var ReactDOMComponentTree = _dereq_(45);

var focusNode = _dereq_(167);

var AutoFocusUtils = {

focusDOMComponent: function () {

focusNode(ReactDOMComponentTree.getNodeFromInstance(this));

}

};

module.exports = AutoFocusUtils;

},{"167":167,"45":45}],2:[function(_dereq_,module,exports){

/**

* Copyright 2013-present Facebook, Inc.

* All rights reserved.

*

* This source code is licensed under the BSD-style license found in the

* LICENSE file in the root directory of this source tree. An additional grant

* of patent rights can be found in the PATENTS file in the same directory.

*

* @providesModule BeforeInputEventPlugin

*/

'use strict';

var EventConstants = _dereq_(16);

var EventPropagators = _dereq_(20);

var ExecutionEnvironment = _dereq_(159);

var FallbackCompositionState = _dereq_(21);

var SyntheticCompositionEvent = _dereq_(113);

var SyntheticInputEvent = _dereq_(117);

var keyOf = _dereq_(177);

var END_KEYCODES = [9, 13, 27, 32]; // Tab, Return, Esc, Space

var START_KEYCODE = 229;

var canUseCompositionEvent = ExecutionEnvironment.canUseDOM && 'CompositionEvent' in window;

var documentMode = null;

if (ExecutionEnvironment.canUseDOM && 'documentMode' in document) {

documentMode = document.documentMode;

}

// Webkit offers a very useful `textInput` event that can be used to

// directly represent `beforeInput`. The IE `textinput` event is not as

// useful, so we don't use it.

var canUseTextInputEvent = ExecutionEnvironment.canUseDOM && 'TextEvent' in window && !documentMode && !isPresto();

// In IE9+, we have access to composition events, but the data supplied

// by the native compositionend event may be incorrect. Japanese ideographic

// spaces, for instance (\u3000) are not recorded correctly.

var useFallbackCompositionData = ExecutionEnvironment.canUseDOM && (!canUseCompositionEvent || documentMode && documentMode > 8 && documentMode <= 11);

/**

* Opera <= 12 includes TextEvent in window, but does not fire

* text input events. Rely on keypress instead.

*/

function isPresto() {

var opera = window.opera;

return typeof opera === 'object' && typeof opera.version === 'function' && parseInt(opera.version(), 10) <= 12;

}

var SPACEBAR_CODE = 32;

var SPACEBAR_CHAR = String.fromCharCode(SPACEBAR_CODE);

var topLevelTypes = EventConstants.topLevelTypes;

// Events and their corresponding property names.

var eventTypes = {

beforeInput: {

phasedRegistrationNames: {

bubbled: keyOf({ onBeforeInput: null }),

captured: keyOf({ onBeforeInputCapture: null })

},

dependencies: [topLevelTypes.topCompositionEnd, topLevelTypes.topKeyPress, topLevelTypes.topTextInput, topLevelTypes.topPaste]

},

compositionEnd: {

phasedRegistrationNames: {

bubbled: keyOf({ onCompositionEnd: null }),

captured: keyOf({ onCompositionEndCapture: null })

},

dependencies: [topLevelTypes.topBlur, topLevelTypes.topCompositionEnd, topLevelTypes.topKeyDown, topLevelTypes.topKeyPress, topLevelTypes.topKeyUp, topLevelTypes.topMouseDown]

},

compositionStart: {

phasedRegistrationNames: {

bubbled: keyOf({ onCompositionStart: null }),

captured: keyOf({ onCompositionStartCapture: null })

},

dependencies: [topLevelTypes.topBlur, topLevelTypes.topCompositionStart, topLevelTypes.topKeyDown, topLevelTypes.topKeyPress, topLevelTypes.topKeyUp, topLevelTypes.topMouseDown]

},

compositionUpdate: {

phasedRegistrationNames: {

bubbled: keyOf({ onCompositionUpdate: null }),

captured: keyOf({ onCompositionUpdateCapture: null })

},

dependencies: [topLevelTypes.topBlur, topLevelTypes.topCompositionUpdate, topLevelTypes.topKeyDown, topLevelTypes.topKeyPress, topLevelTypes.topKeyUp, topLevelTypes.topMouseDown]

}

};

// Track whether we've ever handled a keypress on the space key.

var hasSpaceKeypress = false;

/**

* Return whether a native keypress event is assumed to be a command.

* This is required because Firefox fires `keypress` events for key commands

* (cut, copy, select-all, etc.) even though no character is inserted.

*/

function isKeypressCommand(nativeEvent) {

return (nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) &&

// ctrlKey && altKey is equivalent to AltGr, and is not a command.

!(nativeEvent.ctrlKey && nativeEvent.altKey);

}

/**

* Translate native top level events into event types.

*

* @param {string} topLevelType

* @return {object}

*/

function getCompositionEventType(topLevelType) {

switch (topLevelType) {

case topLevelTypes.topCompositionStart:

return eventTypes.compositionStart;

case topLevelTypes.topCompositionEnd:

return eventTypes.compositionEnd;

case topLevelTypes.topCompositionUpdate:

return eventTypes.compositionUpdate;

}

}

/**

* Does our fallback best-guess model think this event signifies that

* composition has begun?

*

* @param {string} topLevelType

* @param {object} nativeEvent

* @return {boolean}

*/

function isFallbackCompositionStart(topLevelType, nativeEvent) {

return topLevelType === topLevelTypes.topKeyDown && nativeEvent.keyCode === START_KEYCODE;

}

/**

* Does our fallback mode think that this event is the end of composition?

*

* @param {string} topLevelType

* @param {object} nativeEvent

* @return {boolean}

*/

function isFallbackCompositionEnd(topLevelType, nativeEvent) {

switch (topLevelType) {

case topLevelTypes.topKeyUp:

// Command keys insert or clear IME input.

return END_KEYCODES.indexOf(nativeEvent.keyCode) !== -1;

case topLevelTypes.topKeyDown:

// Expect IME keyCode on each keydown. If we get any other

// code we must have exited earlier.

return nativeEvent.keyCode !== START_KEYCODE;

case topLevelTypes.topKeyPress:

case topLevelTypes.topMouseDown:

case topLevelTypes.topBlur:

// Events are not possible without cancelling IME.

return true;

default:

return false;

}

}

/**

* Google Input Tools provides composition data via a CustomEvent,

* with the `data` property populated in the `detail` object. If this

* is available on the event object, use it. If not, this is a plain

* composition event and we have nothing special to extract.

*

* @param {object} nativeEvent

* @return {?string}

*/

function getDataFromCustomEvent(nativeEvent) {

var detail = nativeEvent.detail;

if (typeof detail === 'object' && 'data' in detail) {

return detail.data;

}

return null;

}

// Track the current IME composition fallback object, if any.

var currentComposition = null;

/**

* @return {?object} A SyntheticCompositionEvent.

*/

function extractCompositionEvent(topLevelType, targetInst, nativeEvent, nativeEventTarget) {

var eventType;

var fallbackData;

if (canUseCompositionEvent) {

eventType = getCompositionEventType(topLevelType);

} else if (!currentComposition) {

if (isFallbackCompositionStart(topLevelType, nativeEvent)) {

eventType = eventTypes.compositionStart;

}

} else if (isFallbackCompositionEnd(topLevelType, nativeEvent)) {

eventType = eventTypes.compositionEnd;

}

if (!eventType) {

return null;

}

if (useFallbackCompositionData) {

// The current composition is stored statically and must not be

// overwritten while composition continues.

if (!currentComposition && eventType === eventTypes.compositionStart) {

currentComposition = FallbackCompositionState.getPooled(nativeEventTarget);

} else if (eventType === eventTypes.compositionEnd) {

if (currentComposition) {

fallbackData = currentComposition.getData();

}

}

}

var event = SyntheticCompositionEvent.getPooled(eventType, targetInst, nativeEvent, nativeEventTarget);

if (fallbackData) {

// Inject data generated from fallback path into the synthetic event.

// This matches the property of native CompositionEventInterface.

event.data = fallbackData;

} else {

var customData = getDataFromCustomEvent(nativeEvent);

if (customData !== null) {

event.data = customData;

}

}

EventPropagators.accumulateTwoPhaseDispatches(event);

return event;

}

/**

* @param {string} topLevelType Record from `EventConstants`.

* @param {object} nativeEvent Native browser event.

* @return {?string} The string corresponding to this `beforeInput` event.

*/

function getNativeBeforeInputChars(topLevelType, nativeEvent) {

switch (topLevelType) {

case topLevelTypes.topCompositionEnd:

return getDataFromCustomEvent(nativeEvent);

case topLevelTypes.topKeyPress:

/**

* If native `textInput` events are available, our goal is to make

* use of them. However, there is a special case: the spacebar key.

* In Webkit, preventing default on a spacebar `textInput` event

* cancels character insertion, but it *also* causes the browser

* to fall back to its default spacebar behavior of scrolling the

* page.

*

* Tracking at:

* https://code.google.com/p/chromium/issues/detail?id=355103

*

* To avoid this issue, use the keypress event as if no `textInput`

* event is available.

*/

var which = nativeEvent.which;

if (which !== SPACEBAR_CODE) {

return null;

}

hasSpaceKeypress = true;

return SPACEBAR_CHAR;

case topLevelTypes.topTextInput:

// Record the characters to be added to the DOM.

var chars = nativeEvent.data;

// If it's a spacebar character, assume that we have already handled

// it at the keypress level and bail immediately. Android Chrome

// doesn't give us keycodes, so we need to blacklist it.

if (chars === SPACEBAR_CHAR && hasSpaceKeypress) {

return null;

}

return chars;

default:

// For other native event types, do nothing.

return null;

}

}

/**

* For browsers that do not provide the `textInput` event, extract the

* appropriate string to use for SyntheticInputEvent.

*

* @param {string} topLevelType Record from `EventConstants`.

* @param {object} nativeEvent Native browser event.

* @return {?string} The fallback string for this `beforeInput` event.

*/

function getFallbackBeforeInputChars(topLevelType, nativeEvent) {

// If we are currently composing (IME) and using a fallback to do so,

// try to extract the composed characters from the fallback object.

if (currentComposition) {

if (topLevelType === topLevelTypes.topCompositionEnd || isFallbackCompositionEnd(topLevelType, nativeEvent)) {

var chars = currentComposition.getData();

FallbackCompositionState.release(currentComposition);

currentComposition = null;

return chars;

}

return null;

}

switch (topLevelType) {

case topLevelTypes.topPaste:

// If a paste event occurs after a keypress, throw out the input

// chars. Paste events should not lead to BeforeInput events.

return null;

case topLevelTypes.topKeyPress:

/**

* As of v27, Firefox may fire keypress events even when no character

* will be inserted. A few possibilities:

*

* - `which` is `0`. Arrow keys, Esc key, etc.

*

* - `which` is the pressed key code, but no char is available.

* Ex: 'AltGr + d` in Polish. There is no modified character for

* this key combination and no character is inserted into the

* document, but FF fires the keypress for char code `100` anyway.

* No `input` event will occur.

*

* - `which` is the pressed key code, but a command combination is

* being used. Ex: `Cmd+C`. No character is inserted, and no

* `input` event will occur.

*/

if (nativeEvent.which && !isKeypressCommand(nativeEvent)) {

return String.fromCharCode(nativeEvent.which);

}

return null;

case topLevelTypes.topCompositionEnd:

return useFallbackCompositionData ? null : nativeEvent.data;

default:

return null;

}

}

/**

* Extract a SyntheticInputEvent for `beforeInput`, based on either native

* `textInput` or fallback behavior.

*

* @return {?object} A SyntheticInputEvent.

*/

function extractBeforeInputEvent(topLevelType, targetInst, nativeEvent, nativeEventTarget) {

var chars;

if (canUseTextInputEvent) {

chars = getNativeBeforeInputChars(topLevelType, nativeEvent);

} else {

chars = getFallbackBeforeInputChars(topLevelType, nativeEvent);

}

// If no characters are being inserted, no BeforeInput event should

// be fired.

if (!chars) {

return null;

}

var event = SyntheticInputEvent.getPooled(eventTypes.beforeInput, targetInst, nativeEvent, nativeEventTarget);

event.data = chars;

EventPropagators.accumulateTwoPhaseDispatches(event);

return event;

}

/**

* Create an `onBeforeInput` event to match

* http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105/#events-inputevents.

*

* This event plugin is based on the native `textInput` event

* available in Chrome, Safari, Opera, and IE. This event fires after

* `onKeyPress` and `onCompositionEnd`, but before `onInput`.

*

* `beforeInput` is spec'd but not implemented in any browsers, and

* the `input` event does not provide any useful information about what has

* actually been added, contrary to the spec. Thus, `textInput` is the best

* available event to identify the characters that have actually been inserted

* into the target node.

*

* This plugin is also responsible for emitting `composition` events, thus

* allowing us to share composition fallback code for both `beforeInput` and

* `composition` event types.

*/

var BeforeInputEventPlugin = {

eventTypes: eventTypes,

extractEvents: function (topLevelType, targetInst, nativeEvent, nativeEventTarget) {

return [extractCompositionEvent(topLevelType, targetInst, nativeEvent, nativeEventTarget), extractBeforeInputEvent(topLevelType, targetInst, nativeEvent, nativeEventTarget)];

}

};

module.exports = BeforeInputEventPlugin;

},{"113":113,"117":117,"159":159,"16":16,"177":177,"20":20,"21":21}],3:[function(_dereq_,module,exports){

/**

* Copyright 2013-present, Facebook, Inc.

* All rights reserved.

*

* This source code is licensed under the BSD-style license found in the

* LICENSE file in the root directory of this source tree. An additional grant

* of patent rights can be found in the PATENTS file in the same directory.

*

* @providesModule CSSProperty

*/

'use strict';

/**

* CSS properties which accept numbers but are not in units of "px".

*/

var isUnitlessNumber = {

animationIterationCount: true,

borderImageOutset: true,

borderImageSlice: true,

borderImageWidth: true,

boxFlex: true,

boxFlexGroup: true,

boxOrdinalGroup: true,

columnCount: true,

flex: true,

flexGrow: true,

flexPositive: true,

flexShrink: true,

flexNegative: true,

flexOrder: true,

gridRow: true,

gridColumn: true,

fontWeight: true,

lineClamp: true,

lineHeight: true,

opacity: true,

order: true,

orphans: true,

tabSize: true,

widows: true,

zIndex: true,

zoom: true,

// SVG-related properties

fillOpacity: true,

floodOpacity: true,

stopOpacity: true,

strokeDasharray: true,

strokeDashoffset: true,

strokeMiterlimit: true,

strokeOpacity: true,

strokeWidth: true

};

/**

* @param {string} prefix vendor-specific prefix, eg: Webkit

* @param {string} key style name, eg: transitionDuration

* @return {string} style name prefixed with `prefix`, properly camelCased, eg:

* WebkitTransitionDuration

*/

function prefixKey(prefix, key) {

return prefix + key.charAt(0).toUpperCase() + key.substring(1);

}

/**

* Support style names that may come passed in prefixed by adding permutations

* of vendor prefixes.

*/

var prefixes = ['Webkit', 'ms', 'Moz', 'O'];

// Using Object.keys here, or else the vanilla for-in loop makes IE8 go into an

// infinite loop, because it iterates over the newly added props too.

Object.keys(isUnitlessNumber).forEach(function (prop) {

prefixes.forEach(function (prefix) {

isUnitlessNumber[prefixKey(prefix, prop)] = isUnitlessNumber[prop];

});

});

/**

* Most style properties can be unset by doing .style[prop] = '' but IE8

* doesn't like doing that with shorthand properties so for the properties that

* IE8 breaks on, which are listed here, we instead unset each of the

* individual properties. See http://bugs.jquery.com/ticket/12385.

* The 4-value 'clock' properties like margin, padding, border-width seem to

* behave without any problems. Curiously, list-style works too without any

* special prodding.

*/

var shorthandPropertyExpansions = {

background: {

backgroundAttachment: true,

backgroundColor: true,

backgroundImage: true,

backgroundPositionX: true,

backgroundPositionY: true,

backgroundRepeat: true

},

backgroundPosition: {

backgroundPositionX: true,

backgroundPositionY: true

},

border: {

borderWidth: true,

borderStyle: true,

borderColor: true

},

borderBottom: {

borderBottomWidth: true,

borderBottomStyle: true,

borderBottomColor: true

},

borderLeft: {

borderLeftWidth: true,

borderLeftStyle: true,

borderLeftColor: true

},

borderRight: {

borderRightWidth: true,

borderRightStyle: true,

borderRightColor: true

},

borderTop: {

borderTopWidth: true,

borderTopStyle: true,

borderTopColor: true

},

font: {

fontStyle: true,

fontVariant: true,

fontWeight: true,

fontSize: true,

lineHeight: true,

fontFamily: true

},

outline: {

outlineWidth: true,

outlineStyle: true,

outlineColor: true

}

};

var CSSProperty = {

isUnitlessNumber: isUnitlessNumber,

shorthandPropertyExpansions: shorthandPropertyExpansions

};

module.exports = CSSProperty;

},{}],4:[function(_dereq_,module,exports){

/**

* Copyright 2013-present, Facebook, Inc.

* All rights reserved.

*

* This source code is licensed under the BSD-style license found in the

* LICENSE file in the root directory of this source tree. An additional grant

* of patent rights can be found in the PATENTS file in the same directory.

*

* @providesModule CSSPropertyOperations

*/

'use strict';

var CSSProperty = _dereq_(3);

var ExecutionEnvironment = _dereq_(159);

var ReactInstrumentation = _dereq_(76);

var camelizeStyleName = _dereq_(161);

var dangerousStyleValue = _dereq_(130);

var hyphenateStyleName = _dereq_(172);

var memoizeStringOnly = _dereq_(179);

var warning = _dereq_(183);

var processStyleName = memoizeStringOnly(function (styleName) {

return hyphenateStyleName(styleName);

});

var hasShorthandPropertyBug = false;

var styleFloatAccessor = 'cssFloat';

if (ExecutionEnvironment.canUseDOM) {

var tempStyle = document.createElement('div').style;

try {

// IE8 throws "Invalid argument." if resetting shorthand style properties.

tempStyle.font = '';

} catch (e) {

hasShorthandPropertyBug = true;

}

// IE8 only supports accessing cssFloat (standard) as styleFloat

if (document.documentElement.style.cssFloat === undefined) {

styleFloatAccessor = 'styleFloat';

}

}

if ("development" !== 'production') {

// 'msTransform' is correct, but the other prefixes should be capitalized

var badVendoredStyleNamePattern = /^(?:webkit|moz|o)[A-Z]/;

// style values shouldn't contain a semicolon

var badStyleValueWithSemicolonPattern = /;\s*$/;

var warnedStyleNames = {};

var warnedStyleValues = {};

var warnedForNaNValue = false;

var warnHyphenatedStyleName = function (name, owner) {

if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {

return;

}

warnedStyleNames[name] = true;

"development" !== 'production' ? warning(false, 'Unsupported style property %s. Did you mean %s?%s', name, camelizeStyleName(name), checkRenderMessage(owner)) : void 0;

};

var warnBadVendoredStyleName = function (name, owner) {

if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {

return;

}

warnedStyleNames[name] = true;

"development" !== 'production' ? warning(false, 'Unsupported vendor-prefixed style property %s. Did you mean %s?%s', name, name.charAt(0).toUpperCase() + name.slice(1), checkRenderMessage(owner)) : void 0;

};

var warnStyleValueWithSemicolon = function (name, value, owner) {

if (warnedStyleValues.hasOwnProperty(value) && warnedStyleValues[value]) {

return;

}

warnedStyleValues[value] = true;

"development" !== 'production' ? warning(false, 'Style property values shouldn\'t contain a semicolon.%s ' + 'Try "%s: %s" instead.', checkRenderMessage(owner), name, value.replace(badStyleValueWithSemicolonPattern, '')) : void 0;

};

var warnStyleValueIsNaN = function (name, value, owner) {

if (warnedForNaNValue) {

return;

}

warnedForNaNValue = true;

"development" !== 'production' ? warning(false, '`NaN` is an invalid value for the `%s` css style property.%s', name, checkRenderMessage(owner)) : void 0;

};

var checkRenderMessage = function (owner) {

if (owner) {

var name = owner.getName();

if (name) {

return ' Check the render method of `' + name + '`.';

}

}

return '';

};

/**

* @param {string} name

* @param {*} value

* @param {ReactDOMComponent} component

*/

var warnValidStyle = function (name, value, component) {

var owner;

if (component) {

owner = component._currentElement._owner;

}

if (name.indexOf('-') > -1) {

warnHyphenatedStyleName(name, owner);

} else if (badVendoredStyleNamePattern.test(name)) {

warnBadVendoredStyleName(name, owner);

} else if (badStyleValueWithSemicolonPattern.test(value)) {

warnStyleValueWithSemicolon(name, value, owner);

}

if (typeof value === 'number' && isNaN(value)) {

warnStyleValueIsNaN(name, value, owner);

}

};

}

/**

* Operations for dealing with CSS properties.

*/

var CSSPropertyOperations = {

/**

* Serializes a mapping of style properties for use as inline styles:

*

* > createMarkupForStyles({width: '200px', height: 0})

* "width:200px;height:0;"

*

* Undefined values are ignored so that declarative programming is easier.

* The result should be HTML-escaped before insertion into the DOM.

*

* @param {object} styles

* @param {ReactDOMComponent} component

* @return {?string}

*/

createMarkupForStyles: function (styles, component) {

var serialized = '';

for (var styleName in styles) {

if (!styles.hasOwnProperty(styleName)) {

continue;

}

var styleValue = styles[styleName];

if ("development" !== 'production') {

warnValidStyle(styleName, styleValue, component);

}

if (styleValue != null) {

serialized += processStyleName(styleName) + ':';

serialized += dangerousStyleValue(styleName, styleValue, component) + ';';

}

}

return serialized || null;

},

/**

* Sets the value for multiple styles on a node. If a value is specified as

* '' (empty string), the corresponding style property will be unset.

*

* @param {DOMElement} node

* @param {object} styles

* @param {ReactDOMComponent} component

*/

setValueForStyles: function (node, styles, component) {

if ("development" !== 'production') {

ReactInstrumentation.debugTool.onNativeOperation(component._debugID, 'update styles', styles);

}

var style = node.style;

for (var styleName in styles) {

if (!styles.hasOwnProperty(styleName)) {

continue;

}

if ("development" !== 'production') {

warnValidStyle(styleName, styles[styleName], component);

}

var styleValue = dangerousStyleValue(styleName, styles[styleName], component);

if (styleName === 'float' || styleName === 'cssFloat') {

styleName = styleFloatAccessor;

}

if (styleValue) {

style[styleName] = styleValue;

} else {

var expansion = hasShorthandPropertyBug && CSSProperty.shorthandPropertyExpansions[styleName];

if (expansion) {

// Shorthand property that IE8 won't like unsetting, so unset each

// component to placate it

for (var individualStyleName in expansion) {

style[individualStyleName] = '';

}

} else {

style[styleName] = '';

}

}

}

}

};

module.exports = CSSPropertyOperations;

},{"130":130,"159":159,"161":161,"172":172,"179":179,"183":183,"3":3,"76":76}],5:[function(_dereq_,module,exports){

/**

* Copyright 2013-present, Facebook, Inc.

* All rights reserved.

*

* This source code is licensed under the BSD-style license found in the

* LICENSE file in the root directory of this source tree. An additional grant

* of patent rights can be found in the PATENTS file in the same directory.

*

* @providesModule CallbackQueue

*/

'use strict';

var _assign = _dereq_(184);

var PooledClass = _dereq_(26);

var invariant = _dereq_(173);

/**

* A specialized pseudo-event module to help keep track of components waiting to

* be notified when their DOM representations are available for use.

*

* This implements `PooledClass`, so you should never need to instantiate this.

* Instead, use `CallbackQueue.getPooled()`.

*

* @class ReactMountReady

* @implements PooledClass

* @internal

*/

function CallbackQueue() {

this._callbacks = null;

this._contexts = null;

}

_assign(CallbackQueue.prototype, {

/**

* Enqueues a callback to be invoked when `notifyAll` is invoked.

*

* @param {function} callback Invoked when `notifyAll` is invoked.

* @param {?object} context Context to call `callback` with.

* @internal

*/

enqueue: function (callback, context) {

this._callbacks = this._callbacks || [];

this._contexts = this._contexts || [];

this._callbacks.push(callback);

this._contexts.push(context);

},

/**

* Invokes all enqueued callbacks and clears the queue. This is invoked after

* the DOM representation of a component has been created or updated.

*

* @internal

*/

notifyAll: function () {

var callbacks = this._callbacks;

var contexts = this._contexts;

if (callbacks) {

!(callbacks.length === contexts.length) ? "development" !== 'production' ? invariant(false, 'Mismatched list of contexts in callback queue') : invariant(false) : void 0;

this._callbacks = null;

this._contexts = null;

for (var i = 0; i < callbacks.length; i++) {

callbacks[i].call(contexts[i]);

}

callbacks.length = 0;

contexts.length = 0;

}

},

checkpoint: function () {

return this._callbacks ? this._callbacks.length : 0;

},

rollback: function (len) {

if (this._callbacks) {

this._callbacks.length = len;

this._contexts.length = len;

}

},

/**

* Resets the internal queue.

*

* @internal

*/

reset: function () {

this._callbacks = null;

this._contexts = null;

},

/**

* `PooledClass` looks for this.

*/

destructor: function () {

this.reset();

}

});

PooledClass.addPoolingTo(CallbackQueue);

module.exports = CallbackQueue;

},{"173":173,"184":184,"26":26}],6:[function(_dereq_,module,exports){

/**

* Copyright 2013-present, Facebook, Inc.

* All rights reserved.

*

* This source code is licensed under the BSD-style license found in the

* LICENSE file in the root directory of this source tree. An additional grant

* of patent rights can be found in the PATENTS file in the same directory.

*

* @providesModule ChangeEventPlugin

*/

'use strict';

var EventConstants = _dereq_(16);

var EventPluginHub = _dereq_(17);

var EventPropagators = _dereq_(20);

var ExecutionEnvironment = _dereq_(159);

var ReactDOMComponentTree = _dereq_(45);

var ReactUpdates = _dereq_(104);

var SyntheticEvent = _dereq_(115);

var getEventTarget = _dereq_(138);

var isEventSupported = _dereq_(145);

var isTextInputElement = _dereq_(146);

var keyOf = _dereq_(177);

var topLevelTypes = EventConstants.topLevelTypes;

var eventTypes = {

change: {

phasedRegistrationNames: {

bubbled: keyOf({ onChange: null }),

captured: keyOf({ onChangeCapture: null })

},

dependencies: [topLevelTypes.topBlur, topLevelTypes.topChange, topLevelTypes.topClick, topLevelTypes.topFocus, topLevelTypes.topInput, topLevelTypes.topKeyDown, topLevelTypes.topKeyUp, topLevelTypes.topSelectionChange]

}

};

/**

* For IE shims

*/

var activeElement = null;

var activeElementInst = null;

var activeElementValue = null;

var activeElementValueProp = null;

/**

* SECTION: handle `change` event

*/

function shouldUseChangeEvent(elem) {

var nodeName = elem.nodeName && elem.nodeName.toLowerCase();

return nodeName === 'select' || nodeName === 'input' && elem.type === 'file';

}

var doesChangeEventBubble = false;

if (ExecutionEnvironment.canUseDOM) {

// See `handleChange` comment below

doesChangeEventBubble = isEventSupported('change') && (!('documentMode' in document) || document.documentMode > 8);

}

function manualDispatchChangeEvent(nativeEvent) {

var event = SyntheticEvent.getPooled(eventTypes.change, activeElementInst, nativeEvent, getEventTarget(nativeEvent));

EventPropagators.accumulateTwoPhaseDispatches(event);

// If change and propertychange bubbled, we'd just bind to it like all the

// other events and have it go through ReactBrowserEventEmitter. Since it

// doesn't, we manually listen for the events and so we have to enqueue and

// process the abstract event manually.

//

// Batching is necessary here in order to ensure that all event handlers run

// before the next rerender (including event handlers attached to ancestor

// elements instead of directly on the input). Without this, controlled

// components don't work properly in conjunction with event bubbling because

// the component is rerendered and the value reverted before all the event

// handlers can run. See https://github.com/facebook/react/issues/708.

ReactUpdates.batchedUpdates(runEventInBatch, event);

}

function runEventInBatch(event) {

EventPluginHub.enqueueEvents(event);

EventPluginHub.processEventQueue(false);

}

function startWatchingForChangeEventIE8(target, targetInst) {

activeElement = target;

activeElementInst = targetInst;

activeElement.attachEvent('onchange', manualDispatchChangeEvent);

}

function stopWatchingForChangeEventIE8() {

if (!activeElement) {

return;

}

activeElement.detachEvent('onchange', manualDispatchChangeEvent);

activeElement = null;

activeElementInst = null;

}

function getTargetInstForChangeEvent(topLevelType, targetInst) {

if (topLevelType === topLevelTypes.topChange) {

return targetInst;

}

}

function handleEventsForChangeEventIE8(topLevelType, target, targetInst) {

if (topLevelType === topLevelTypes.topFocus) {

// stopWatching() should be a noop here but we call it just in case we

// missed a blur event somehow.

stopWatchingForChangeEventIE8();

startWatchingForChangeEventIE8(target, targetInst);

} else if (topLevelType === topLevelTypes.topBlur) {

stopWatchingForChangeEventIE8();

}

}

/**

* SECTION: handle `input` event

*/

var isInputEventSupported = false;

if (ExecutionEnvironment.canUseDOM) {

// IE9 claims to support the input event but fails to trigger it when

// deleting text, so we ignore its input events.