} Array of transaction wrappers.\n */\n getTransactionWrappers: null,\n\n isInTransaction: function () {\n return !!this._isInTransaction;\n },\n\n /* eslint-disable space-before-function-paren */\n\n /**\n * Executes the function within a safety window. Use this for the top level\n * methods that result in large amounts of computation/mutations that would\n * need to be safety checked. The optional arguments helps prevent the need\n * to bind in many cases.\n *\n * @param {function} method Member of scope to call.\n * @param {Object} scope Scope to invoke from.\n * @param {Object?=} a Argument to pass to the method.\n * @param {Object?=} b Argument to pass to the method.\n * @param {Object?=} c Argument to pass to the method.\n * @param {Object?=} d Argument to pass to the method.\n * @param {Object?=} e Argument to pass to the method.\n * @param {Object?=} f Argument to pass to the method.\n *\n * @return {*} Return value from `method`.\n */\n perform: function (method, scope, a, b, c, d, e, f) {\n /* eslint-enable space-before-function-paren */\n !!this.isInTransaction() ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Transaction.perform(...): Cannot initialize a transaction when there is already an outstanding transaction.') : _prodInvariant('27') : void 0;\n var errorThrown;\n var ret;\n try {\n this._isInTransaction = true;\n // Catching errors makes debugging more difficult, so we start with\n // errorThrown set to true before setting it to false after calling\n // close -- if it's still set to true in the finally block, it means\n // one of these calls threw.\n errorThrown = true;\n this.initializeAll(0);\n ret = method.call(scope, a, b, c, d, e, f);\n errorThrown = false;\n } finally {\n try {\n if (errorThrown) {\n // If `method` throws, prefer to show that stack trace over any thrown\n // by invoking `closeAll`.\n try {\n this.closeAll(0);\n } catch (err) {}\n } else {\n // Since `method` didn't throw, we don't want to silence the exception\n // here.\n this.closeAll(0);\n }\n } finally {\n this._isInTransaction = false;\n }\n }\n return ret;\n },\n\n initializeAll: function (startIndex) {\n var transactionWrappers = this.transactionWrappers;\n for (var i = startIndex; i < transactionWrappers.length; i++) {\n var wrapper = transactionWrappers[i];\n try {\n // Catching errors makes debugging more difficult, so we start with the\n // OBSERVED_ERROR state before overwriting it with the real return value\n // of initialize -- if it's still set to OBSERVED_ERROR in the finally\n // block, it means wrapper.initialize threw.\n this.wrapperInitData[i] = OBSERVED_ERROR;\n this.wrapperInitData[i] = wrapper.initialize ? wrapper.initialize.call(this) : null;\n } finally {\n if (this.wrapperInitData[i] === OBSERVED_ERROR) {\n // The initializer for wrapper i threw an error; initialize the\n // remaining wrappers but silence any exceptions from them to ensure\n // that the first error is the one to bubble up.\n try {\n this.initializeAll(i + 1);\n } catch (err) {}\n }\n }\n }\n },\n\n /**\n * Invokes each of `this.transactionWrappers.close[i]` functions, passing into\n * them the respective return values of `this.transactionWrappers.init[i]`\n * (`close`rs that correspond to initializers that failed will not be\n * invoked).\n */\n closeAll: function (startIndex) {\n !this.isInTransaction() ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Transaction.closeAll(): Cannot close transaction when none are open.') : _prodInvariant('28') : void 0;\n var transactionWrappers = this.transactionWrappers;\n for (var i = startIndex; i < transactionWrappers.length; i++) {\n var wrapper = transactionWrappers[i];\n var initData = this.wrapperInitData[i];\n var errorThrown;\n try {\n // Catching errors makes debugging more difficult, so we start with\n // errorThrown set to true before setting it to false after calling\n // close -- if it's still set to true in the finally block, it means\n // wrapper.close threw.\n errorThrown = true;\n if (initData !== OBSERVED_ERROR && wrapper.close) {\n wrapper.close.call(this, initData);\n }\n errorThrown = false;\n } finally {\n if (errorThrown) {\n // The closer for wrapper i threw an error; close the remaining\n // wrappers but silence any exceptions from them to ensure that the\n // first error is the one to bubble up.\n try {\n this.closeAll(i + 1);\n } catch (e) {}\n }\n }\n }\n this.wrapperInitData.length = 0;\n }\n};\n\nmodule.exports = TransactionImpl;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\n/**\n * `charCode` represents the actual \"character code\" and is safe to use with\n * `String.fromCharCode`. As such, only keys that correspond to printable\n * characters produce a valid `charCode`, the only exception to this is Enter.\n * The Tab-key is considered non-printable and does not have a `charCode`,\n * presumably because it does not produce a tab-character in browsers.\n *\n * @param {object} nativeEvent Native browser event.\n * @return {number} Normalized `charCode` property.\n */\n\nfunction getEventCharCode(nativeEvent) {\n var charCode;\n var keyCode = nativeEvent.keyCode;\n\n if ('charCode' in nativeEvent) {\n charCode = nativeEvent.charCode;\n\n // FF does not set `charCode` for the Enter-key, check against `keyCode`.\n if (charCode === 0 && keyCode === 13) {\n charCode = 13;\n }\n } else {\n // IE8 does not implement `charCode`, but `keyCode` has the correct value.\n charCode = keyCode;\n }\n\n // Some non-printable keys are reported in `charCode`/`keyCode`, discard them.\n // Must not discard the (non-)printable Enter-key.\n if (charCode >= 32 || charCode === 13) {\n return charCode;\n }\n\n return 0;\n}\n\nmodule.exports = getEventCharCode;","/**\n * Copyright (c) 2015-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar _assign = require('object-assign');\n\nvar emptyFunction = require('fbjs/lib/emptyFunction');\nvar warning = require('fbjs/lib/warning');\n\nvar validateDOMNesting = emptyFunction;\n\nif (process.env.NODE_ENV !== 'production') {\n // This validation code was written based on the HTML5 parsing spec:\n // https://html.spec.whatwg.org/multipage/syntax.html#has-an-element-in-scope\n //\n // Note: this does not catch all invalid nesting, nor does it try to (as it's\n // not clear what practical benefit doing so provides); instead, we warn only\n // for cases where the parser will give a parse tree differing from what React\n // intended. For example, is invalid but we don't warn\n // because it still parses correctly; we do warn for other cases like nested\n // tags where the beginning of the second element implicitly closes the\n // first, causing a confusing mess.\n\n // https://html.spec.whatwg.org/multipage/syntax.html#special\n var specialTags = ['address', 'applet', 'area', 'article', 'aside', 'base', 'basefont', 'bgsound', 'blockquote', 'body', 'br', 'button', 'caption', 'center', 'col', 'colgroup', 'dd', 'details', 'dir', 'div', 'dl', 'dt', 'embed', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'frame', 'frameset', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'iframe', 'img', 'input', 'isindex', 'li', 'link', 'listing', 'main', 'marquee', 'menu', 'menuitem', 'meta', 'nav', 'noembed', 'noframes', 'noscript', 'object', 'ol', 'p', 'param', 'plaintext', 'pre', 'script', 'section', 'select', 'source', 'style', 'summary', 'table', 'tbody', 'td', 'template', 'textarea', 'tfoot', 'th', 'thead', 'title', 'tr', 'track', 'ul', 'wbr', 'xmp'];\n\n // https://html.spec.whatwg.org/multipage/syntax.html#has-an-element-in-scope\n var inScopeTags = ['applet', 'caption', 'html', 'table', 'td', 'th', 'marquee', 'object', 'template',\n\n // https://html.spec.whatwg.org/multipage/syntax.html#html-integration-point\n // TODO: Distinguish by namespace here -- for
, including it here\n // errs on the side of fewer warnings\n 'foreignObject', 'desc', 'title'];\n\n // https://html.spec.whatwg.org/multipage/syntax.html#has-an-element-in-button-scope\n var buttonScopeTags = inScopeTags.concat(['button']);\n\n // https://html.spec.whatwg.org/multipage/syntax.html#generate-implied-end-tags\n var impliedEndTags = ['dd', 'dt', 'li', 'option', 'optgroup', 'p', 'rp', 'rt'];\n\n var emptyAncestorInfo = {\n current: null,\n\n formTag: null,\n aTagInScope: null,\n buttonTagInScope: null,\n nobrTagInScope: null,\n pTagInButtonScope: null,\n\n listItemTagAutoclosing: null,\n dlItemTagAutoclosing: null\n };\n\n var updatedAncestorInfo = function (oldInfo, tag, instance) {\n var ancestorInfo = _assign({}, oldInfo || emptyAncestorInfo);\n var info = { tag: tag, instance: instance };\n\n if (inScopeTags.indexOf(tag) !== -1) {\n ancestorInfo.aTagInScope = null;\n ancestorInfo.buttonTagInScope = null;\n ancestorInfo.nobrTagInScope = null;\n }\n if (buttonScopeTags.indexOf(tag) !== -1) {\n ancestorInfo.pTagInButtonScope = null;\n }\n\n // See rules for 'li', 'dd', 'dt' start tags in\n // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inbody\n if (specialTags.indexOf(tag) !== -1 && tag !== 'address' && tag !== 'div' && tag !== 'p') {\n ancestorInfo.listItemTagAutoclosing = null;\n ancestorInfo.dlItemTagAutoclosing = null;\n }\n\n ancestorInfo.current = info;\n\n if (tag === 'form') {\n ancestorInfo.formTag = info;\n }\n if (tag === 'a') {\n ancestorInfo.aTagInScope = info;\n }\n if (tag === 'button') {\n ancestorInfo.buttonTagInScope = info;\n }\n if (tag === 'nobr') {\n ancestorInfo.nobrTagInScope = info;\n }\n if (tag === 'p') {\n ancestorInfo.pTagInButtonScope = info;\n }\n if (tag === 'li') {\n ancestorInfo.listItemTagAutoclosing = info;\n }\n if (tag === 'dd' || tag === 'dt') {\n ancestorInfo.dlItemTagAutoclosing = info;\n }\n\n return ancestorInfo;\n };\n\n /**\n * Returns whether\n */\n var isTagValidWithParent = function (tag, parentTag) {\n // First, let's check if we're in an unusual parsing mode...\n switch (parentTag) {\n // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inselect\n case 'select':\n return tag === 'option' || tag === 'optgroup' || tag === '#text';\n case 'optgroup':\n return tag === 'option' || tag === '#text';\n // Strictly speaking, seeing an <option> doesn't mean we're in a <select>\n // but\n case 'option':\n return tag === '#text';\n // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intd\n // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-incaption\n // No special behavior since these rules fall back to \"in body\" mode for\n // all except special table nodes which cause bad parsing behavior anyway.\n\n // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intr\n case 'tr':\n return tag === 'th' || tag === 'td' || tag === 'style' || tag === 'script' || tag === 'template';\n // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intbody\n case 'tbody':\n case 'thead':\n case 'tfoot':\n return tag === 'tr' || tag === 'style' || tag === 'script' || tag === 'template';\n // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-incolgroup\n case 'colgroup':\n return tag === 'col' || tag === 'template';\n // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intable\n case 'table':\n return tag === 'caption' || tag === 'colgroup' || tag === 'tbody' || tag === 'tfoot' || tag === 'thead' || tag === 'style' || tag === 'script' || tag === 'template';\n // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inhead\n case 'head':\n return tag === 'base' || tag === 'basefont' || tag === 'bgsound' || tag === 'link' || tag === 'meta' || tag === 'title' || tag === 'noscript' || tag === 'noframes' || tag === 'style' || tag === 'script' || tag === 'template';\n // https://html.spec.whatwg.org/multipage/semantics.html#the-html-element\n case 'html':\n return tag === 'head' || tag === 'body';\n case '#document':\n return tag === 'html';\n }\n\n // Probably in the \"in body\" parsing mode, so we outlaw only tag combos\n // where the parsing rules cause implicit opens or closes to be added.\n // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inbody\n switch (tag) {\n case 'h1':\n case 'h2':\n case 'h3':\n case 'h4':\n case 'h5':\n case 'h6':\n return parentTag !== 'h1' && parentTag !== 'h2' && parentTag !== 'h3' && parentTag !== 'h4' && parentTag !== 'h5' && parentTag !== 'h6';\n\n case 'rp':\n case 'rt':\n return impliedEndTags.indexOf(parentTag) === -1;\n\n case 'body':\n case 'caption':\n case 'col':\n case 'colgroup':\n case 'frame':\n case 'head':\n case 'html':\n case 'tbody':\n case 'td':\n case 'tfoot':\n case 'th':\n case 'thead':\n case 'tr':\n // These tags are only valid with a few parents that have special child\n // parsing rules -- if we're down here, then none of those matched and\n // so we allow it only if we don't know what the parent is, as all other\n // cases are invalid.\n return parentTag == null;\n }\n\n return true;\n };\n\n /**\n * Returns whether\n */\n var findInvalidAncestorForTag = function (tag, ancestorInfo) {\n switch (tag) {\n case 'address':\n case 'article':\n case 'aside':\n case 'blockquote':\n case 'center':\n case 'details':\n case 'dialog':\n case 'dir':\n case 'div':\n case 'dl':\n case 'fieldset':\n case 'figcaption':\n case 'figure':\n case 'footer':\n case 'header':\n case 'hgroup':\n case 'main':\n case 'menu':\n case 'nav':\n case 'ol':\n case 'p':\n case 'section':\n case 'summary':\n case 'ul':\n case 'pre':\n case 'listing':\n case 'table':\n case 'hr':\n case 'xmp':\n case 'h1':\n case 'h2':\n case 'h3':\n case 'h4':\n case 'h5':\n case 'h6':\n return ancestorInfo.pTagInButtonScope;\n\n case 'form':\n return ancestorInfo.formTag || ancestorInfo.pTagInButtonScope;\n\n case 'li':\n return ancestorInfo.listItemTagAutoclosing;\n\n case 'dd':\n case 'dt':\n return ancestorInfo.dlItemTagAutoclosing;\n\n case 'button':\n return ancestorInfo.buttonTagInScope;\n\n case 'a':\n // Spec says something about storing a list of markers, but it sounds\n // equivalent to this check.\n return ancestorInfo.aTagInScope;\n\n case 'nobr':\n return ancestorInfo.nobrTagInScope;\n }\n\n return null;\n };\n\n /**\n * Given a ReactCompositeComponent instance, return a list of its recursive\n * owners, starting at the root and ending with the instance itself.\n */\n var findOwnerStack = function (instance) {\n if (!instance) {\n return [];\n }\n\n var stack = [];\n do {\n stack.push(instance);\n } while (instance = instance._currentElement._owner);\n stack.reverse();\n return stack;\n };\n\n var didWarn = {};\n\n validateDOMNesting = function (childTag, childText, childInstance, ancestorInfo) {\n ancestorInfo = ancestorInfo || emptyAncestorInfo;\n var parentInfo = ancestorInfo.current;\n var parentTag = parentInfo && parentInfo.tag;\n\n if (childText != null) {\n process.env.NODE_ENV !== 'production' ? warning(childTag == null, 'validateDOMNesting: when childText is passed, childTag should be null') : void 0;\n childTag = '#text';\n }\n\n var invalidParent = isTagValidWithParent(childTag, parentTag) ? null : parentInfo;\n var invalidAncestor = invalidParent ? null : findInvalidAncestorForTag(childTag, ancestorInfo);\n var problematic = invalidParent || invalidAncestor;\n\n if (problematic) {\n var ancestorTag = problematic.tag;\n var ancestorInstance = problematic.instance;\n\n var childOwner = childInstance && childInstance._currentElement._owner;\n var ancestorOwner = ancestorInstance && ancestorInstance._currentElement._owner;\n\n var childOwners = findOwnerStack(childOwner);\n var ancestorOwners = findOwnerStack(ancestorOwner);\n\n var minStackLen = Math.min(childOwners.length, ancestorOwners.length);\n var i;\n\n var deepestCommon = -1;\n for (i = 0; i < minStackLen; i++) {\n if (childOwners[i] === ancestorOwners[i]) {\n deepestCommon = i;\n } else {\n break;\n }\n }\n\n var UNKNOWN = '(unknown)';\n var childOwnerNames = childOwners.slice(deepestCommon + 1).map(function (inst) {\n return inst.getName() || UNKNOWN;\n });\n var ancestorOwnerNames = ancestorOwners.slice(deepestCommon + 1).map(function (inst) {\n return inst.getName() || UNKNOWN;\n });\n var ownerInfo = [].concat(\n // If the parent and child instances have a common owner ancestor, start\n // with that -- otherwise we just start with the parent's owners.\n deepestCommon !== -1 ? childOwners[deepestCommon].getName() || UNKNOWN : [], ancestorOwnerNames, ancestorTag,\n // If we're warning about an invalid (non-parent) ancestry, add '...'\n invalidAncestor ? ['...'] : [], childOwnerNames, childTag).join(' > ');\n\n var warnKey = !!invalidParent + '|' + childTag + '|' + ancestorTag + '|' + ownerInfo;\n if (didWarn[warnKey]) {\n return;\n }\n didWarn[warnKey] = true;\n\n var tagDisplayName = childTag;\n var whitespaceInfo = '';\n if (childTag === '#text') {\n if (/\\S/.test(childText)) {\n tagDisplayName = 'Text nodes';\n } else {\n tagDisplayName = 'Whitespace text nodes';\n whitespaceInfo = \" Make sure you don't have any extra whitespace between tags on \" + 'each line of your source code.';\n }\n } else {\n tagDisplayName = '<' + childTag + '>';\n }\n\n if (invalidParent) {\n var info = '';\n if (ancestorTag === 'table' && childTag === 'tr') {\n info += ' Add a <tbody> to your code to match the DOM tree generated by ' + 'the browser.';\n }\n process.env.NODE_ENV !== 'production' ? warning(false, 'validateDOMNesting(...): %s cannot appear as a child of <%s>.%s ' + 'See %s.%s', tagDisplayName, ancestorTag, whitespaceInfo, ownerInfo, info) : void 0;\n } else {\n process.env.NODE_ENV !== 'production' ? warning(false, 'validateDOMNesting(...): %s cannot appear as a descendant of ' + '<%s>. See %s.', tagDisplayName, ancestorTag, ownerInfo) : void 0;\n }\n }\n };\n\n validateDOMNesting.updatedAncestorInfo = updatedAncestorInfo;\n\n // For testing\n validateDOMNesting.isTagValidInContext = function (tag, ancestorInfo) {\n ancestorInfo = ancestorInfo || emptyAncestorInfo;\n var parentInfo = ancestorInfo.current;\n var parentTag = parentInfo && parentInfo.tag;\n return isTagValidWithParent(tag, parentTag) && !findInvalidAncestorForTag(tag, ancestorInfo);\n };\n}\n\nmodule.exports = validateDOMNesting;","/**\n * Copyright (c) 2015-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar _prodInvariant = require('./reactProdInvariant');\n\nvar ReactCurrentOwner = require('react/lib/ReactCurrentOwner');\nvar ReactInstanceMap = require('./ReactInstanceMap');\nvar ReactInstrumentation = require('./ReactInstrumentation');\nvar ReactUpdates = require('./ReactUpdates');\n\nvar invariant = require('fbjs/lib/invariant');\nvar warning = require('fbjs/lib/warning');\n\nfunction enqueueUpdate(internalInstance) {\n ReactUpdates.enqueueUpdate(internalInstance);\n}\n\nfunction formatUnexpectedArgument(arg) {\n var type = typeof arg;\n if (type !== 'object') {\n return type;\n }\n var displayName = arg.constructor && arg.constructor.name || type;\n var keys = Object.keys(arg);\n if (keys.length > 0 && keys.length < 20) {\n return displayName + ' (keys: ' + keys.join(', ') + ')';\n }\n return displayName;\n}\n\nfunction getInternalInstanceReadyForUpdate(publicInstance, callerName) {\n var internalInstance = ReactInstanceMap.get(publicInstance);\n if (!internalInstance) {\n if (process.env.NODE_ENV !== 'production') {\n var ctor = publicInstance.constructor;\n // Only warn when we have a callerName. Otherwise we should be silent.\n // We're probably calling from enqueueCallback. We don't want to warn\n // there because we already warned for the corresponding lifecycle method.\n process.env.NODE_ENV !== 'production' ? warning(!callerName, '%s(...): Can only update a mounted or mounting component. ' + 'This usually means you called %s() on an unmounted component. ' + 'This is a no-op. Please check the code for the %s component.', callerName, callerName, ctor && (ctor.displayName || ctor.name) || 'ReactClass') : void 0;\n }\n return null;\n }\n\n if (process.env.NODE_ENV !== 'production') {\n process.env.NODE_ENV !== 'production' ? warning(ReactCurrentOwner.current == null, '%s(...): Cannot update during an existing state transition (such as ' + \"within `render` or another component's constructor). Render methods \" + 'should be a pure function of props and state; constructor ' + 'side-effects are an anti-pattern, but can be moved to ' + '`componentWillMount`.', callerName) : void 0;\n }\n\n return internalInstance;\n}\n\n/**\n * ReactUpdateQueue allows for state updates to be scheduled into a later\n * reconciliation step.\n */\nvar ReactUpdateQueue = {\n /**\n * Checks whether or not this composite component is mounted.\n * @param {ReactClass} publicInstance The instance we want to test.\n * @return {boolean} True if mounted, false otherwise.\n * @protected\n * @final\n */\n isMounted: function (publicInstance) {\n if (process.env.NODE_ENV !== 'production') {\n var owner = ReactCurrentOwner.current;\n if (owner !== null) {\n process.env.NODE_ENV !== 'production' ? warning(owner._warnedAboutRefsInRender, '%s is accessing isMounted inside its render() function. ' + 'render() should be a pure function of props and state. It should ' + 'never access something that requires stale data from the previous ' + 'render, such as refs. Move this logic to componentDidMount and ' + 'componentDidUpdate instead.', owner.getName() || 'A component') : void 0;\n owner._warnedAboutRefsInRender = true;\n }\n }\n var internalInstance = ReactInstanceMap.get(publicInstance);\n if (internalInstance) {\n // During componentWillMount and render this will still be null but after\n // that will always render to something. At least for now. So we can use\n // this hack.\n return !!internalInstance._renderedComponent;\n } else {\n return false;\n }\n },\n\n /**\n * Enqueue a callback that will be executed after all the pending updates\n * have processed.\n *\n * @param {ReactClass} publicInstance The instance to use as `this` context.\n * @param {?function} callback Called after state is updated.\n * @param {string} callerName Name of the calling function in the public API.\n * @internal\n */\n enqueueCallback: function (publicInstance, callback, callerName) {\n ReactUpdateQueue.validateCallback(callback, callerName);\n var internalInstance = getInternalInstanceReadyForUpdate(publicInstance);\n\n // Previously we would throw an error if we didn't have an internal\n // instance. Since we want to make it a no-op instead, we mirror the same\n // behavior we have in other enqueue* methods.\n // We also need to ignore callbacks in componentWillMount. See\n // enqueueUpdates.\n if (!internalInstance) {\n return null;\n }\n\n if (internalInstance._pendingCallbacks) {\n internalInstance._pendingCallbacks.push(callback);\n } else {\n internalInstance._pendingCallbacks = [callback];\n }\n // TODO: The callback here is ignored when setState is called from\n // componentWillMount. Either fix it or disallow doing so completely in\n // favor of getInitialState. Alternatively, we can disallow\n // componentWillMount during server-side rendering.\n enqueueUpdate(internalInstance);\n },\n\n enqueueCallbackInternal: function (internalInstance, callback) {\n if (internalInstance._pendingCallbacks) {\n internalInstance._pendingCallbacks.push(callback);\n } else {\n internalInstance._pendingCallbacks = [callback];\n }\n enqueueUpdate(internalInstance);\n },\n\n /**\n * Forces an update. This should only be invoked when it is known with\n * certainty that we are **not** in a DOM transaction.\n *\n * You may want to call this when you know that some deeper aspect of the\n * component's state has changed but `setState` was not called.\n *\n * This will not invoke `shouldComponentUpdate`, but it will invoke\n * `componentWillUpdate` and `componentDidUpdate`.\n *\n * @param {ReactClass} publicInstance The instance that should rerender.\n * @internal\n */\n enqueueForceUpdate: function (publicInstance) {\n var internalInstance = getInternalInstanceReadyForUpdate(publicInstance, 'forceUpdate');\n\n if (!internalInstance) {\n return;\n }\n\n internalInstance._pendingForceUpdate = true;\n\n enqueueUpdate(internalInstance);\n },\n\n /**\n * Replaces all of the state. Always use this or `setState` to mutate state.\n * You should treat `this.state` as immutable.\n *\n * There is no guarantee that `this.state` will be immediately updated, so\n * accessing `this.state` after calling this method may return the old value.\n *\n * @param {ReactClass} publicInstance The instance that should rerender.\n * @param {object} completeState Next state.\n * @internal\n */\n enqueueReplaceState: function (publicInstance, completeState, callback) {\n var internalInstance = getInternalInstanceReadyForUpdate(publicInstance, 'replaceState');\n\n if (!internalInstance) {\n return;\n }\n\n internalInstance._pendingStateQueue = [completeState];\n internalInstance._pendingReplaceState = true;\n\n // Future-proof 15.5\n if (callback !== undefined && callback !== null) {\n ReactUpdateQueue.validateCallback(callback, 'replaceState');\n if (internalInstance._pendingCallbacks) {\n internalInstance._pendingCallbacks.push(callback);\n } else {\n internalInstance._pendingCallbacks = [callback];\n }\n }\n\n enqueueUpdate(internalInstance);\n },\n\n /**\n * Sets a subset of the state. This only exists because _pendingState is\n * internal. This provides a merging strategy that is not available to deep\n * properties which is confusing. TODO: Expose pendingState or don't use it\n * during the merge.\n *\n * @param {ReactClass} publicInstance The instance that should rerender.\n * @param {object} partialState Next partial state to be merged with state.\n * @internal\n */\n enqueueSetState: function (publicInstance, partialState) {\n if (process.env.NODE_ENV !== 'production') {\n ReactInstrumentation.debugTool.onSetState();\n process.env.NODE_ENV !== 'production' ? warning(partialState != null, 'setState(...): You passed an undefined or null state object; ' + 'instead, use forceUpdate().') : void 0;\n }\n\n var internalInstance = getInternalInstanceReadyForUpdate(publicInstance, 'setState');\n\n if (!internalInstance) {\n return;\n }\n\n var queue = internalInstance._pendingStateQueue || (internalInstance._pendingStateQueue = []);\n queue.push(partialState);\n\n enqueueUpdate(internalInstance);\n },\n\n enqueueElementInternal: function (internalInstance, nextElement, nextContext) {\n internalInstance._pendingElement = nextElement;\n // TODO: introduce _pendingContext instead of setting it directly.\n internalInstance._context = nextContext;\n enqueueUpdate(internalInstance);\n },\n\n validateCallback: function (callback, callerName) {\n !(!callback || typeof callback === 'function') ? process.env.NODE_ENV !== 'production' ? invariant(false, '%s(...): Expected the last optional `callback` argument to be a function. Instead received: %s.', callerName, formatUnexpectedArgument(callback)) : _prodInvariant('122', callerName, formatUnexpectedArgument(callback)) : void 0;\n }\n};\n\nmodule.exports = ReactUpdateQueue;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n */\n\n'use strict';\n\n/**\n * Escape and wrap key so it is safe to use as a reactid\n *\n * @param {string} key to be escaped.\n * @return {string} the escaped key.\n */\n\nfunction escape(key) {\n var escapeRegex = /[=:]/g;\n var escaperLookup = {\n '=': '=0',\n ':': '=2'\n };\n var escapedString = ('' + key).replace(escapeRegex, function (match) {\n return escaperLookup[match];\n });\n\n return '$' + escapedString;\n}\n\n/**\n * Unescape and unwrap key for human-readable display\n *\n * @param {string} key to unescape.\n * @return {string} the unescaped key.\n */\nfunction unescape(key) {\n var unescapeRegex = /(=0|=2)/g;\n var unescaperLookup = {\n '=0': '=',\n '=2': ':'\n };\n var keySubstring = key[0] === '.' && key[1] === '$' ? key.substring(2) : key.substring(1);\n\n return ('' + keySubstring).replace(unescapeRegex, function (match) {\n return unescaperLookup[match];\n });\n}\n\nvar KeyEscapeUtils = {\n escape: escape,\n unescape: unescape\n};\n\nmodule.exports = KeyEscapeUtils;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\n/**\n * Given a `prevElement` and `nextElement`, determines if the existing\n * instance should be updated as opposed to being destroyed or replaced by a new\n * instance. Both arguments are elements. This ensures that this logic can\n * operate on stateless trees without any backing instance.\n *\n * @param {?object} prevElement\n * @param {?object} nextElement\n * @return {boolean} True if the existing instance should be updated.\n * @protected\n */\n\nfunction shouldUpdateReactComponent(prevElement, nextElement) {\n var prevEmpty = prevElement === null || prevElement === false;\n var nextEmpty = nextElement === null || nextElement === false;\n if (prevEmpty || nextEmpty) {\n return prevEmpty === nextEmpty;\n }\n\n var prevType = typeof prevElement;\n var nextType = typeof nextElement;\n if (prevType === 'string' || prevType === 'number') {\n return nextType === 'string' || nextType === 'number';\n } else {\n return nextType === 'object' && prevElement.type === nextElement.type && prevElement.key === nextElement.key;\n }\n}\n\nmodule.exports = shouldUpdateReactComponent;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n * \n */\n\n/*eslint-disable no-self-compare */\n\n'use strict';\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\n/**\n * inlined Object.is polyfill to avoid requiring consumers ship their own\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is\n */\nfunction is(x, y) {\n // SameValue algorithm\n if (x === y) {\n // Steps 1-5, 7-10\n // Steps 6.b-6.e: +0 != -0\n // Added the nonzero y check to make Flow happy, but it is redundant\n return x !== 0 || y !== 0 || 1 / x === 1 / y;\n } else {\n // Step 6.a: NaN == NaN\n return x !== x && y !== y;\n }\n}\n\n/**\n * Performs equality by iterating through keys on an object and returning false\n * when any key has values which are not strictly equal between the arguments.\n * Returns true when the values of all keys are strictly equal.\n */\nfunction shallowEqual(objA, objB) {\n if (is(objA, objB)) {\n return true;\n }\n\n if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {\n return false;\n }\n\n var keysA = Object.keys(objA);\n var keysB = Object.keys(objB);\n\n if (keysA.length !== keysB.length) {\n return false;\n }\n\n // Test for A's keys different from B.\n for (var i = 0; i < keysA.length; i++) {\n if (!hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) {\n return false;\n }\n }\n\n return true;\n}\n\nmodule.exports = shallowEqual;","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n */\n\n'use strict';\n\nvar _prodInvariant = require('./reactProdInvariant');\n\nvar invariant = require('fbjs/lib/invariant');\n\nvar injected = false;\n\nvar ReactComponentEnvironment = {\n /**\n * Optionally injectable hook for swapping out mount images in the middle of\n * the tree.\n */\n replaceNodeWithMarkup: null,\n\n /**\n * Optionally injectable hook for processing a queue of child updates. Will\n * later move into MultiChildComponents.\n */\n processChildrenUpdates: null,\n\n injection: {\n injectEnvironment: function (environment) {\n !!injected ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactCompositeComponent: injectEnvironment() can only be called once.') : _prodInvariant('104') : void 0;\n ReactComponentEnvironment.replaceNodeWithMarkup = environment.replaceNodeWithMarkup;\n ReactComponentEnvironment.processChildrenUpdates = environment.processChildrenUpdates;\n injected = true;\n }\n }\n};\n\nmodule.exports = ReactComponentEnvironment;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar _prodInvariant = require('./reactProdInvariant');\n\nvar ReactPropTypesSecret = require('./ReactPropTypesSecret');\nvar propTypesFactory = require('prop-types/factory');\n\nvar React = require('react/lib/React');\nvar PropTypes = propTypesFactory(React.isValidElement);\n\nvar invariant = require('fbjs/lib/invariant');\nvar warning = require('fbjs/lib/warning');\n\nvar hasReadOnlyValue = {\n button: true,\n checkbox: true,\n image: true,\n hidden: true,\n radio: true,\n reset: true,\n submit: true\n};\n\nfunction _assertSingleLink(inputProps) {\n !(inputProps.checkedLink == null || inputProps.valueLink == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Cannot provide a checkedLink and a valueLink. If you want to use checkedLink, you probably don\\'t want to use valueLink and vice versa.') : _prodInvariant('87') : void 0;\n}\nfunction _assertValueLink(inputProps) {\n _assertSingleLink(inputProps);\n !(inputProps.value == null && inputProps.onChange == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Cannot provide a valueLink and a value or onChange event. If you want to use value or onChange, you probably don\\'t want to use valueLink.') : _prodInvariant('88') : void 0;\n}\n\nfunction _assertCheckedLink(inputProps) {\n _assertSingleLink(inputProps);\n !(inputProps.checked == null && inputProps.onChange == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Cannot provide a checkedLink and a checked property or onChange event. If you want to use checked or onChange, you probably don\\'t want to use checkedLink') : _prodInvariant('89') : void 0;\n}\n\nvar propTypes = {\n value: function (props, propName, componentName) {\n if (!props[propName] || hasReadOnlyValue[props.type] || props.onChange || props.readOnly || props.disabled) {\n return null;\n }\n return new Error('You provided a `value` prop to a form field without an ' + '`onChange` handler. This will render a read-only field. If ' + 'the field should be mutable use `defaultValue`. Otherwise, ' + 'set either `onChange` or `readOnly`.');\n },\n checked: function (props, propName, componentName) {\n if (!props[propName] || props.onChange || props.readOnly || props.disabled) {\n return null;\n }\n return new Error('You provided a `checked` prop to a form field without an ' + '`onChange` handler. This will render a read-only field. If ' + 'the field should be mutable use `defaultChecked`. Otherwise, ' + 'set either `onChange` or `readOnly`.');\n },\n onChange: PropTypes.func\n};\n\nvar loggedTypeFailures = {};\nfunction getDeclarationErrorAddendum(owner) {\n if (owner) {\n var name = owner.getName();\n if (name) {\n return ' Check the render method of `' + name + '`.';\n }\n }\n return '';\n}\n\n/**\n * Provide a linked `value` attribute for controlled forms. You should not use\n * this outside of the ReactDOM controlled form components.\n */\nvar LinkedValueUtils = {\n checkPropTypes: function (tagName, props, owner) {\n for (var propName in propTypes) {\n if (propTypes.hasOwnProperty(propName)) {\n var error = propTypes[propName](props, propName, tagName, 'prop', null, ReactPropTypesSecret);\n }\n if (error instanceof Error && !(error.message in loggedTypeFailures)) {\n // Only monitor this failure once because there tends to be a lot of the\n // same error.\n loggedTypeFailures[error.message] = true;\n\n var addendum = getDeclarationErrorAddendum(owner);\n process.env.NODE_ENV !== 'production' ? warning(false, 'Failed form propType: %s%s', error.message, addendum) : void 0;\n }\n }\n },\n\n /**\n * @param {object} inputProps Props for form component\n * @return {*} current value of the input either from value prop or link.\n */\n getValue: function (inputProps) {\n if (inputProps.valueLink) {\n _assertValueLink(inputProps);\n return inputProps.valueLink.value;\n }\n return inputProps.value;\n },\n\n /**\n * @param {object} inputProps Props for form component\n * @return {*} current checked status of the input either from checked prop\n * or link.\n */\n getChecked: function (inputProps) {\n if (inputProps.checkedLink) {\n _assertCheckedLink(inputProps);\n return inputProps.checkedLink.value;\n }\n return inputProps.checked;\n },\n\n /**\n * @param {object} inputProps Props for form component\n * @param {SyntheticEvent} event change event to handle\n */\n executeOnChange: function (inputProps, event) {\n if (inputProps.valueLink) {\n _assertValueLink(inputProps);\n return inputProps.valueLink.requestChange(event.target.value);\n } else if (inputProps.checkedLink) {\n _assertCheckedLink(inputProps);\n return inputProps.checkedLink.requestChange(event.target.checked);\n } else if (inputProps.onChange) {\n return inputProps.onChange.call(undefined, event);\n }\n }\n};\n\nmodule.exports = LinkedValueUtils;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n/* globals MSApp */\n\n'use strict';\n\n/**\n * Create a function which has 'unsafe' privileges (required by windows8 apps)\n */\n\nvar createMicrosoftUnsafeLocalFunction = function (func) {\n if (typeof MSApp !== 'undefined' && MSApp.execUnsafeLocalFunction) {\n return function (arg0, arg1, arg2, arg3) {\n MSApp.execUnsafeLocalFunction(function () {\n return func(arg0, arg1, arg2, arg3);\n });\n };\n } else {\n return func;\n }\n};\n\nmodule.exports = createMicrosoftUnsafeLocalFunction;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar DOMNamespaces = {\n html: 'http://www.w3.org/1999/xhtml',\n mathml: 'http://www.w3.org/1998/Math/MathML',\n svg: 'http://www.w3.org/2000/svg'\n};\n\nmodule.exports = DOMNamespaces;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar DOMLazyTree = require('./DOMLazyTree');\nvar Danger = require('./Danger');\nvar ReactDOMComponentTree = require('./ReactDOMComponentTree');\nvar ReactInstrumentation = require('./ReactInstrumentation');\n\nvar createMicrosoftUnsafeLocalFunction = require('./createMicrosoftUnsafeLocalFunction');\nvar setInnerHTML = require('./setInnerHTML');\nvar setTextContent = require('./setTextContent');\n\nfunction getNodeAfter(parentNode, node) {\n // Special case for text components, which return [open, close] comments\n // from getHostNode.\n if (Array.isArray(node)) {\n node = node[1];\n }\n return node ? node.nextSibling : parentNode.firstChild;\n}\n\n/**\n * Inserts `childNode` as a child of `parentNode` at the `index`.\n *\n * @param {DOMElement} parentNode Parent node in which to insert.\n * @param {DOMElement} childNode Child node to insert.\n * @param {number} index Index at which to insert the child.\n * @internal\n */\nvar insertChildAt = createMicrosoftUnsafeLocalFunction(function (parentNode, childNode, referenceNode) {\n // We rely exclusively on `insertBefore(node, null)` instead of also using\n // `appendChild(node)`. (Using `undefined` is not allowed by all browsers so\n // we are careful to use `null`.)\n parentNode.insertBefore(childNode, referenceNode);\n});\n\nfunction insertLazyTreeChildAt(parentNode, childTree, referenceNode) {\n DOMLazyTree.insertTreeBefore(parentNode, childTree, referenceNode);\n}\n\nfunction moveChild(parentNode, childNode, referenceNode) {\n if (Array.isArray(childNode)) {\n moveDelimitedText(parentNode, childNode[0], childNode[1], referenceNode);\n } else {\n insertChildAt(parentNode, childNode, referenceNode);\n }\n}\n\nfunction removeChild(parentNode, childNode) {\n if (Array.isArray(childNode)) {\n var closingComment = childNode[1];\n childNode = childNode[0];\n removeDelimitedText(parentNode, childNode, closingComment);\n parentNode.removeChild(closingComment);\n }\n parentNode.removeChild(childNode);\n}\n\nfunction moveDelimitedText(parentNode, openingComment, closingComment, referenceNode) {\n var node = openingComment;\n while (true) {\n var nextNode = node.nextSibling;\n insertChildAt(parentNode, node, referenceNode);\n if (node === closingComment) {\n break;\n }\n node = nextNode;\n }\n}\n\nfunction removeDelimitedText(parentNode, startNode, closingComment) {\n while (true) {\n var node = startNode.nextSibling;\n if (node === closingComment) {\n // The closing comment is removed by ReactMultiChild.\n break;\n } else {\n parentNode.removeChild(node);\n }\n }\n}\n\nfunction replaceDelimitedText(openingComment, closingComment, stringText) {\n var parentNode = openingComment.parentNode;\n var nodeAfterComment = openingComment.nextSibling;\n if (nodeAfterComment === closingComment) {\n // There are no text nodes between the opening and closing comments; insert\n // a new one if stringText isn't empty.\n if (stringText) {\n insertChildAt(parentNode, document.createTextNode(stringText), nodeAfterComment);\n }\n } else {\n if (stringText) {\n // Set the text content of the first node after the opening comment, and\n // remove all following nodes up until the closing comment.\n setTextContent(nodeAfterComment, stringText);\n removeDelimitedText(parentNode, nodeAfterComment, closingComment);\n } else {\n removeDelimitedText(parentNode, openingComment, closingComment);\n }\n }\n\n if (process.env.NODE_ENV !== 'production') {\n ReactInstrumentation.debugTool.onHostOperation({\n instanceID: ReactDOMComponentTree.getInstanceFromNode(openingComment)._debugID,\n type: 'replace text',\n payload: stringText\n });\n }\n}\n\nvar dangerouslyReplaceNodeWithMarkup = Danger.dangerouslyReplaceNodeWithMarkup;\nif (process.env.NODE_ENV !== 'production') {\n dangerouslyReplaceNodeWithMarkup = function (oldChild, markup, prevInstance) {\n Danger.dangerouslyReplaceNodeWithMarkup(oldChild, markup);\n if (prevInstance._debugID !== 0) {\n ReactInstrumentation.debugTool.onHostOperation({\n instanceID: prevInstance._debugID,\n type: 'replace with',\n payload: markup.toString()\n });\n } else {\n var nextInstance = ReactDOMComponentTree.getInstanceFromNode(markup.node);\n if (nextInstance._debugID !== 0) {\n ReactInstrumentation.debugTool.onHostOperation({\n instanceID: nextInstance._debugID,\n type: 'mount',\n payload: markup.toString()\n });\n }\n }\n };\n}\n\n/**\n * Operations for updating with DOM children.\n */\nvar DOMChildrenOperations = {\n dangerouslyReplaceNodeWithMarkup: dangerouslyReplaceNodeWithMarkup,\n\n replaceDelimitedText: replaceDelimitedText,\n\n /**\n * Updates a component's children by processing a series of updates. The\n * update configurations are each expected to have a `parentNode` property.\n *\n * @param {array<object>} updates List of update configurations.\n * @internal\n */\n processUpdates: function (parentNode, updates) {\n if (process.env.NODE_ENV !== 'production') {\n var parentNodeDebugID = ReactDOMComponentTree.getInstanceFromNode(parentNode)._debugID;\n }\n\n for (var k = 0; k < updates.length; k++) {\n var update = updates[k];\n switch (update.type) {\n case 'INSERT_MARKUP':\n insertLazyTreeChildAt(parentNode, update.content, getNodeAfter(parentNode, update.afterNode));\n if (process.env.NODE_ENV !== 'production') {\n ReactInstrumentation.debugTool.onHostOperation({\n instanceID: parentNodeDebugID,\n type: 'insert child',\n payload: {\n toIndex: update.toIndex,\n content: update.content.toString()\n }\n });\n }\n break;\n case 'MOVE_EXISTING':\n moveChild(parentNode, update.fromNode, getNodeAfter(parentNode, update.afterNode));\n if (process.env.NODE_ENV !== 'production') {\n ReactInstrumentation.debugTool.onHostOperation({\n instanceID: parentNodeDebugID,\n type: 'move child',\n payload: { fromIndex: update.fromIndex, toIndex: update.toIndex }\n });\n }\n break;\n case 'SET_MARKUP':\n setInnerHTML(parentNode, update.content);\n if (process.env.NODE_ENV !== 'production') {\n ReactInstrumentation.debugTool.onHostOperation({\n instanceID: parentNodeDebugID,\n type: 'replace children',\n payload: update.content.toString()\n });\n }\n break;\n case 'TEXT_CONTENT':\n setTextContent(parentNode, update.content);\n if (process.env.NODE_ENV !== 'production') {\n ReactInstrumentation.debugTool.onHostOperation({\n instanceID: parentNodeDebugID,\n type: 'replace text',\n payload: update.content.toString()\n });\n }\n break;\n case 'REMOVE_NODE':\n removeChild(parentNode, update.fromNode);\n if (process.env.NODE_ENV !== 'production') {\n ReactInstrumentation.debugTool.onHostOperation({\n instanceID: parentNodeDebugID,\n type: 'remove child',\n payload: { fromIndex: update.fromIndex }\n });\n }\n break;\n }\n }\n }\n};\n\nmodule.exports = DOMChildrenOperations;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\n/**\n * Translation from modifier key to the associated property in the event.\n * @see http://www.w3.org/TR/DOM-Level-3-Events/#keys-Modifiers\n */\n\nvar modifierKeyToProp = {\n Alt: 'altKey',\n Control: 'ctrlKey',\n Meta: 'metaKey',\n Shift: 'shiftKey'\n};\n\n// IE8 does not implement getModifierState so we simply map it to the only\n// modifier keys exposed by the event itself, does not support Lock-keys.\n// Currently, all major browsers except Chrome seems to support Lock-keys.\nfunction modifierStateGetter(keyArg) {\n var syntheticEvent = this;\n var nativeEvent = syntheticEvent.nativeEvent;\n if (nativeEvent.getModifierState) {\n return nativeEvent.getModifierState(keyArg);\n }\n var keyProp = modifierKeyToProp[keyArg];\n return keyProp ? !!nativeEvent[keyProp] : false;\n}\n\nfunction getEventModifierState(nativeEvent) {\n return modifierStateGetter;\n}\n\nmodule.exports = getEventModifierState;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar ExecutionEnvironment = require('fbjs/lib/ExecutionEnvironment');\n\nvar useHasFeature;\nif (ExecutionEnvironment.canUseDOM) {\n useHasFeature = document.implementation && document.implementation.hasFeature &&\n // always returns true in newer browsers as per the standard.\n // @see http://dom.spec.whatwg.org/#dom-domimplementation-hasfeature\n document.implementation.hasFeature('', '') !== true;\n}\n\n/**\n * Checks if an event is supported in the current execution environment.\n *\n * NOTE: This will not work correctly for non-generic events such as `change`,\n * `reset`, `load`, `error`, and `select`.\n *\n * Borrows from Modernizr.\n *\n * @param {string} eventNameSuffix Event name, e.g. \"click\".\n * @param {?boolean} capture Check if the capture phase is supported.\n * @return {boolean} True if the event is supported.\n * @internal\n * @license Modernizr 3.0.0pre (Custom Build) | MIT\n */\nfunction isEventSupported(eventNameSuffix, capture) {\n if (!ExecutionEnvironment.canUseDOM || capture && !('addEventListener' in document)) {\n return false;\n }\n\n var eventName = 'on' + eventNameSuffix;\n var isSupported = eventName in document;\n\n if (!isSupported) {\n var element = document.createElement('div');\n element.setAttribute(eventName, 'return;');\n isSupported = typeof element[eventName] === 'function';\n }\n\n if (!isSupported && useHasFeature && eventNameSuffix === 'wheel') {\n // This is the only way to test support for the `wheel` event in IE9+.\n isSupported = document.implementation.hasFeature('Events.wheel', '3.0');\n }\n\n return isSupported;\n}\n\nmodule.exports = isEventSupported;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\n/**\n * Gets the target node from a native browser event by accounting for\n * inconsistencies in browser DOM APIs.\n *\n * @param {object} nativeEvent Native browser event.\n * @return {DOMEventTarget} Target node.\n */\n\nfunction getEventTarget(nativeEvent) {\n var target = nativeEvent.target || nativeEvent.srcElement || window;\n\n // Normalize SVG <use> element events #4963\n if (target.correspondingUseElement) {\n target = target.correspondingUseElement;\n }\n\n // Safari may fire events on text nodes (Node.TEXT_NODE is 3).\n // @see http://www.quirksmode.org/js/events_properties.html\n return target.nodeType === 3 ? target.parentNode : target;\n}\n\nmodule.exports = getEventTarget;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n */\n\n'use strict';\n\nvar caughtError = null;\n\n/**\n * Call a function while guarding against errors that happens within it.\n *\n * @param {String} name of the guard to use for logging or debugging\n * @param {Function} func The function to invoke\n * @param {*} a First argument\n * @param {*} b Second argument\n */\nfunction invokeGuardedCallback(name, func, a) {\n try {\n func(a);\n } catch (x) {\n if (caughtError === null) {\n caughtError = x;\n }\n }\n}\n\nvar ReactErrorUtils = {\n invokeGuardedCallback: invokeGuardedCallback,\n\n /**\n * Invoked by ReactTestUtils.Simulate so that any errors thrown by the event\n * handler are sure to be rethrown by rethrowCaughtError.\n */\n invokeGuardedCallbackWithCatch: invokeGuardedCallback,\n\n /**\n * During execution of guarded functions we will capture the first error which\n * we will rethrow to be handled by the top level error handler.\n */\n rethrowCaughtError: function () {\n if (caughtError) {\n var error = caughtError;\n caughtError = null;\n throw error;\n }\n }\n};\n\nif (process.env.NODE_ENV !== 'production') {\n /**\n * To help development we can get better devtools integration by simulating a\n * real browser event.\n */\n if (typeof window !== 'undefined' && typeof window.dispatchEvent === 'function' && typeof document !== 'undefined' && typeof document.createEvent === 'function') {\n var fakeNode = document.createElement('react');\n ReactErrorUtils.invokeGuardedCallback = function (name, func, a) {\n var boundFunc = function () {\n func(a);\n };\n var evtType = 'react-' + name;\n fakeNode.addEventListener(evtType, boundFunc, false);\n var evt = document.createEvent('Event');\n evt.initEvent(evtType, false, false);\n fakeNode.dispatchEvent(evt);\n fakeNode.removeEventListener(evtType, boundFunc, false);\n };\n }\n}\n\nmodule.exports = ReactErrorUtils;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar _prodInvariant = require('./reactProdInvariant');\n\nvar ReactErrorUtils = require('./ReactErrorUtils');\n\nvar invariant = require('fbjs/lib/invariant');\nvar warning = require('fbjs/lib/warning');\n\n/**\n * Injected dependencies:\n */\n\n/**\n * - `ComponentTree`: [required] Module that can convert between React instances\n * and actual node references.\n */\nvar ComponentTree;\nvar TreeTraversal;\nvar injection = {\n injectComponentTree: function (Injected) {\n ComponentTree = Injected;\n if (process.env.NODE_ENV !== 'production') {\n process.env.NODE_ENV !== 'production' ? warning(Injected && Injected.getNodeFromInstance && Injected.getInstanceFromNode, 'EventPluginUtils.injection.injectComponentTree(...): Injected ' + 'module is missing getNodeFromInstance or getInstanceFromNode.') : void 0;\n }\n },\n injectTreeTraversal: function (Injected) {\n TreeTraversal = Injected;\n if (process.env.NODE_ENV !== 'production') {\n process.env.NODE_ENV !== 'production' ? warning(Injected && Injected.isAncestor && Injected.getLowestCommonAncestor, 'EventPluginUtils.injection.injectTreeTraversal(...): Injected ' + 'module is missing isAncestor or getLowestCommonAncestor.') : void 0;\n }\n }\n};\n\nfunction isEndish(topLevelType) {\n return topLevelType === 'topMouseUp' || topLevelType === 'topTouchEnd' || topLevelType === 'topTouchCancel';\n}\n\nfunction isMoveish(topLevelType) {\n return topLevelType === 'topMouseMove' || topLevelType === 'topTouchMove';\n}\nfunction isStartish(topLevelType) {\n return topLevelType === 'topMouseDown' || topLevelType === 'topTouchStart';\n}\n\nvar validateEventDispatches;\nif (process.env.NODE_ENV !== 'production') {\n validateEventDispatches = function (event) {\n var dispatchListeners = event._dispatchListeners;\n var dispatchInstances = event._dispatchInstances;\n\n var listenersIsArr = Array.isArray(dispatchListeners);\n var listenersLen = listenersIsArr ? dispatchListeners.length : dispatchListeners ? 1 : 0;\n\n var instancesIsArr = Array.isArray(dispatchInstances);\n var instancesLen = instancesIsArr ? dispatchInstances.length : dispatchInstances ? 1 : 0;\n\n process.env.NODE_ENV !== 'production' ? warning(instancesIsArr === listenersIsArr && instancesLen === listenersLen, 'EventPluginUtils: Invalid `event`.') : void 0;\n };\n}\n\n/**\n * Dispatch the event to the listener.\n * @param {SyntheticEvent} event SyntheticEvent to handle\n * @param {boolean} simulated If the event is simulated (changes exn behavior)\n * @param {function} listener Application-level callback\n * @param {*} inst Internal component instance\n */\nfunction executeDispatch(event, simulated, listener, inst) {\n var type = event.type || 'unknown-event';\n event.currentTarget = EventPluginUtils.getNodeFromInstance(inst);\n if (simulated) {\n ReactErrorUtils.invokeGuardedCallbackWithCatch(type, listener, event);\n } else {\n ReactErrorUtils.invokeGuardedCallback(type, listener, event);\n }\n event.currentTarget = null;\n}\n\n/**\n * Standard/simple iteration through an event's collected dispatches.\n */\nfunction executeDispatchesInOrder(event, simulated) {\n var dispatchListeners = event._dispatchListeners;\n var dispatchInstances = event._dispatchInstances;\n if (process.env.NODE_ENV !== 'production') {\n validateEventDispatches(event);\n }\n if (Array.isArray(dispatchListeners)) {\n for (var i = 0; i < dispatchListeners.length; i++) {\n if (event.isPropagationStopped()) {\n break;\n }\n // Listeners and Instances are two parallel arrays that are always in sync.\n executeDispatch(event, simulated, dispatchListeners[i], dispatchInstances[i]);\n }\n } else if (dispatchListeners) {\n executeDispatch(event, simulated, dispatchListeners, dispatchInstances);\n }\n event._dispatchListeners = null;\n event._dispatchInstances = null;\n}\n\n/**\n * Standard/simple iteration through an event's collected dispatches, but stops\n * at the first dispatch execution returning true, and returns that id.\n *\n * @return {?string} id of the first dispatch execution who's listener returns\n * true, or null if no listener returned true.\n */\nfunction executeDispatchesInOrderStopAtTrueImpl(event) {\n var dispatchListeners = event._dispatchListeners;\n var dispatchInstances = event._dispatchInstances;\n if (process.env.NODE_ENV !== 'production') {\n validateEventDispatches(event);\n }\n if (Array.isArray(dispatchListeners)) {\n for (var i = 0; i < dispatchListeners.length; i++) {\n if (event.isPropagationStopped()) {\n break;\n }\n // Listeners and Instances are two parallel arrays that are always in sync.\n if (dispatchListeners[i](event, dispatchInstances[i])) {\n return dispatchInstances[i];\n }\n }\n } else if (dispatchListeners) {\n if (dispatchListeners(event, dispatchInstances)) {\n return dispatchInstances;\n }\n }\n return null;\n}\n\n/**\n * @see executeDispatchesInOrderStopAtTrueImpl\n */\nfunction executeDispatchesInOrderStopAtTrue(event) {\n var ret = executeDispatchesInOrderStopAtTrueImpl(event);\n event._dispatchInstances = null;\n event._dispatchListeners = null;\n return ret;\n}\n\n/**\n * Execution of a \"direct\" dispatch - there must be at most one dispatch\n * accumulated on the event or it is considered an error. It doesn't really make\n * sense for an event with multiple dispatches (bubbled) to keep track of the\n * return values at each dispatch execution, but it does tend to make sense when\n * dealing with \"direct\" dispatches.\n *\n * @return {*} The return value of executing the single dispatch.\n */\nfunction executeDirectDispatch(event) {\n if (process.env.NODE_ENV !== 'production') {\n validateEventDispatches(event);\n }\n var dispatchListener = event._dispatchListeners;\n var dispatchInstance = event._dispatchInstances;\n !!Array.isArray(dispatchListener) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'executeDirectDispatch(...): Invalid `event`.') : _prodInvariant('103') : void 0;\n event.currentTarget = dispatchListener ? EventPluginUtils.getNodeFromInstance(dispatchInstance) : null;\n var res = dispatchListener ? dispatchListener(event) : null;\n event.currentTarget = null;\n event._dispatchListeners = null;\n event._dispatchInstances = null;\n return res;\n}\n\n/**\n * @param {SyntheticEvent} event\n * @return {boolean} True iff number of dispatches accumulated is greater than 0.\n */\nfunction hasDispatches(event) {\n return !!event._dispatchListeners;\n}\n\n/**\n * General utilities that are useful in creating custom Event Plugins.\n */\nvar EventPluginUtils = {\n isEndish: isEndish,\n isMoveish: isMoveish,\n isStartish: isStartish,\n\n executeDirectDispatch: executeDirectDispatch,\n executeDispatchesInOrder: executeDispatchesInOrder,\n executeDispatchesInOrderStopAtTrue: executeDispatchesInOrderStopAtTrue,\n hasDispatches: hasDispatches,\n\n getInstanceFromNode: function (node) {\n return ComponentTree.getInstanceFromNode(node);\n },\n getNodeFromInstance: function (node) {\n return ComponentTree.getNodeFromInstance(node);\n },\n isAncestor: function (a, b) {\n return TreeTraversal.isAncestor(a, b);\n },\n getLowestCommonAncestor: function (a, b) {\n return TreeTraversal.getLowestCommonAncestor(a, b);\n },\n getParentInstance: function (inst) {\n return TreeTraversal.getParentInstance(inst);\n },\n traverseTwoPhase: function (target, fn, arg) {\n return TreeTraversal.traverseTwoPhase(target, fn, arg);\n },\n traverseEnterLeave: function (from, to, fn, argFrom, argTo) {\n return TreeTraversal.traverseEnterLeave(from, to, fn, argFrom, argTo);\n },\n\n injection: injection\n};\n\nmodule.exports = EventPluginUtils;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n */\n\n'use strict';\n\nvar _prodInvariant = require('./reactProdInvariant');\n\nvar invariant = require('fbjs/lib/invariant');\n\n/**\n * Injectable ordering of event plugins.\n */\nvar eventPluginOrder = null;\n\n/**\n * Injectable mapping from names to event plugin modules.\n */\nvar namesToPlugins = {};\n\n/**\n * Recomputes the plugin list using the injected plugins and plugin ordering.\n *\n * @private\n */\nfunction recomputePluginOrdering() {\n if (!eventPluginOrder) {\n // Wait until an `eventPluginOrder` is injected.\n return;\n }\n for (var pluginName in namesToPlugins) {\n var pluginModule = namesToPlugins[pluginName];\n var pluginIndex = eventPluginOrder.indexOf(pluginName);\n !(pluginIndex > -1) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginRegistry: Cannot inject event plugins that do not exist in the plugin ordering, `%s`.', pluginName) : _prodInvariant('96', pluginName) : void 0;\n if (EventPluginRegistry.plugins[pluginIndex]) {\n continue;\n }\n !pluginModule.extractEvents ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginRegistry: Event plugins must implement an `extractEvents` method, but `%s` does not.', pluginName) : _prodInvariant('97', pluginName) : void 0;\n EventPluginRegistry.plugins[pluginIndex] = pluginModule;\n var publishedEvents = pluginModule.eventTypes;\n for (var eventName in publishedEvents) {\n !publishEventForPlugin(publishedEvents[eventName], pluginModule, eventName) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginRegistry: Failed to publish event `%s` for plugin `%s`.', eventName, pluginName) : _prodInvariant('98', eventName, pluginName) : void 0;\n }\n }\n}\n\n/**\n * Publishes an event so that it can be dispatched by the supplied plugin.\n *\n * @param {object} dispatchConfig Dispatch configuration for the event.\n * @param {object} PluginModule Plugin publishing the event.\n * @return {boolean} True if the event was successfully published.\n * @private\n */\nfunction publishEventForPlugin(dispatchConfig, pluginModule, eventName) {\n !!EventPluginRegistry.eventNameDispatchConfigs.hasOwnProperty(eventName) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginHub: More than one plugin attempted to publish the same event name, `%s`.', eventName) : _prodInvariant('99', eventName) : void 0;\n EventPluginRegistry.eventNameDispatchConfigs[eventName] = dispatchConfig;\n\n var phasedRegistrationNames = dispatchConfig.phasedRegistrationNames;\n if (phasedRegistrationNames) {\n for (var phaseName in phasedRegistrationNames) {\n if (phasedRegistrationNames.hasOwnProperty(phaseName)) {\n var phasedRegistrationName = phasedRegistrationNames[phaseName];\n publishRegistrationName(phasedRegistrationName, pluginModule, eventName);\n }\n }\n return true;\n } else if (dispatchConfig.registrationName) {\n publishRegistrationName(dispatchConfig.registrationName, pluginModule, eventName);\n return true;\n }\n return false;\n}\n\n/**\n * Publishes a registration name that is used to identify dispatched events and\n * can be used with `EventPluginHub.putListener` to register listeners.\n *\n * @param {string} registrationName Registration name to add.\n * @param {object} PluginModule Plugin publishing the event.\n * @private\n */\nfunction publishRegistrationName(registrationName, pluginModule, eventName) {\n !!EventPluginRegistry.registrationNameModules[registrationName] ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginHub: More than one plugin attempted to publish the same registration name, `%s`.', registrationName) : _prodInvariant('100', registrationName) : void 0;\n EventPluginRegistry.registrationNameModules[registrationName] = pluginModule;\n EventPluginRegistry.registrationNameDependencies[registrationName] = pluginModule.eventTypes[eventName].dependencies;\n\n if (process.env.NODE_ENV !== 'production') {\n var lowerCasedName = registrationName.toLowerCase();\n EventPluginRegistry.possibleRegistrationNames[lowerCasedName] = registrationName;\n\n if (registrationName === 'onDoubleClick') {\n EventPluginRegistry.possibleRegistrationNames.ondblclick = registrationName;\n }\n }\n}\n\n/**\n * Registers plugins so that they can extract and dispatch events.\n *\n * @see {EventPluginHub}\n */\nvar EventPluginRegistry = {\n /**\n * Ordered list of injected plugins.\n */\n plugins: [],\n\n /**\n * Mapping from event name to dispatch config\n */\n eventNameDispatchConfigs: {},\n\n /**\n * Mapping from registration name to plugin module\n */\n registrationNameModules: {},\n\n /**\n * Mapping from registration name to event name\n */\n registrationNameDependencies: {},\n\n /**\n * Mapping from lowercase registration names to the properly cased version,\n * used to warn in the case of missing event handlers. Available\n * only in __DEV__.\n * @type {Object}\n */\n possibleRegistrationNames: process.env.NODE_ENV !== 'production' ? {} : null,\n // Trust the developer to only use possibleRegistrationNames in __DEV__\n\n /**\n * Injects an ordering of plugins (by plugin name). This allows the ordering\n * to be decoupled from injection of the actual plugins so that ordering is\n * always deterministic regardless of packaging, on-the-fly injection, etc.\n *\n * @param {array} InjectedEventPluginOrder\n * @internal\n * @see {EventPluginHub.injection.injectEventPluginOrder}\n */\n injectEventPluginOrder: function (injectedEventPluginOrder) {\n !!eventPluginOrder ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginRegistry: Cannot inject event plugin ordering more than once. You are likely trying to load more than one copy of React.') : _prodInvariant('101') : void 0;\n // Clone the ordering so it cannot be dynamically mutated.\n eventPluginOrder = Array.prototype.slice.call(injectedEventPluginOrder);\n recomputePluginOrdering();\n },\n\n /**\n * Injects plugins to be used by `EventPluginHub`. The plugin names must be\n * in the ordering injected by `injectEventPluginOrder`.\n *\n * Plugins can be injected as part of page initialization or on-the-fly.\n *\n * @param {object} injectedNamesToPlugins Map from names to plugin modules.\n * @internal\n * @see {EventPluginHub.injection.injectEventPluginsByName}\n */\n injectEventPluginsByName: function (injectedNamesToPlugins) {\n var isOrderingDirty = false;\n for (var pluginName in injectedNamesToPlugins) {\n if (!injectedNamesToPlugins.hasOwnProperty(pluginName)) {\n continue;\n }\n var pluginModule = injectedNamesToPlugins[pluginName];\n if (!namesToPlugins.hasOwnProperty(pluginName) || namesToPlugins[pluginName] !== pluginModule) {\n !!namesToPlugins[pluginName] ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginRegistry: Cannot inject two different event plugins using the same name, `%s`.', pluginName) : _prodInvariant('102', pluginName) : void 0;\n namesToPlugins[pluginName] = pluginModule;\n isOrderingDirty = true;\n }\n }\n if (isOrderingDirty) {\n recomputePluginOrdering();\n }\n },\n\n /**\n * Looks up the plugin for the supplied event.\n *\n * @param {object} event A synthetic event.\n * @return {?object} The plugin that created the supplied event.\n * @internal\n */\n getPluginModuleForEvent: function (event) {\n var dispatchConfig = event.dispatchConfig;\n if (dispatchConfig.registrationName) {\n return EventPluginRegistry.registrationNameModules[dispatchConfig.registrationName] || null;\n }\n if (dispatchConfig.phasedRegistrationNames !== undefined) {\n // pulling phasedRegistrationNames out of dispatchConfig helps Flow see\n // that it is not undefined.\n var phasedRegistrationNames = dispatchConfig.phasedRegistrationNames;\n\n for (var phase in phasedRegistrationNames) {\n if (!phasedRegistrationNames.hasOwnProperty(phase)) {\n continue;\n }\n var pluginModule = EventPluginRegistry.registrationNameModules[phasedRegistrationNames[phase]];\n if (pluginModule) {\n return pluginModule;\n }\n }\n }\n return null;\n },\n\n /**\n * Exposed for unit testing.\n * @private\n */\n _resetEventPlugins: function () {\n eventPluginOrder = null;\n for (var pluginName in namesToPlugins) {\n if (namesToPlugins.hasOwnProperty(pluginName)) {\n delete namesToPlugins[pluginName];\n }\n }\n EventPluginRegistry.plugins.length = 0;\n\n var eventNameDispatchConfigs = EventPluginRegistry.eventNameDispatchConfigs;\n for (var eventName in eventNameDispatchConfigs) {\n if (eventNameDispatchConfigs.hasOwnProperty(eventName)) {\n delete eventNameDispatchConfigs[eventName];\n }\n }\n\n var registrationNameModules = EventPluginRegistry.registrationNameModules;\n for (var registrationName in registrationNameModules) {\n if (registrationNameModules.hasOwnProperty(registrationName)) {\n delete registrationNameModules[registrationName];\n }\n }\n\n if (process.env.NODE_ENV !== 'production') {\n var possibleRegistrationNames = EventPluginRegistry.possibleRegistrationNames;\n for (var lowerCasedName in possibleRegistrationNames) {\n if (possibleRegistrationNames.hasOwnProperty(lowerCasedName)) {\n delete possibleRegistrationNames[lowerCasedName];\n }\n }\n }\n }\n};\n\nmodule.exports = EventPluginRegistry;","\"use strict\";\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n */\n\nfunction makeEmptyFunction(arg) {\n return function () {\n return arg;\n };\n}\n\n/**\n * This function accepts and discards inputs; it has no side effects. This is\n * primarily useful idiomatically for overridable function endpoints which\n * always need to be callable, since JS lacks a null-call idiom ala Cocoa.\n */\nvar emptyFunction = function emptyFunction() {};\n\nemptyFunction.thatReturns = makeEmptyFunction;\nemptyFunction.thatReturnsFalse = makeEmptyFunction(false);\nemptyFunction.thatReturnsTrue = makeEmptyFunction(true);\nemptyFunction.thatReturnsNull = makeEmptyFunction(null);\nemptyFunction.thatReturnsThis = function () {\n return this;\n};\nemptyFunction.thatReturnsArgument = function (arg) {\n return arg;\n};\n\nmodule.exports = emptyFunction;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar ReactNodeTypes = require('./ReactNodeTypes');\n\nfunction getHostComponentFromComposite(inst) {\n var type;\n\n while ((type = inst._renderedNodeType) === ReactNodeTypes.COMPOSITE) {\n inst = inst._renderedComponent;\n }\n\n if (type === ReactNodeTypes.HOST) {\n return inst._renderedComponent;\n } else if (type === ReactNodeTypes.EMPTY) {\n return null;\n }\n}\n\nmodule.exports = getHostComponentFromComposite;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar _prodInvariant = require('./reactProdInvariant');\n\nvar DOMLazyTree = require('./DOMLazyTree');\nvar DOMProperty = require('./DOMProperty');\nvar React = require('react/lib/React');\nvar ReactBrowserEventEmitter = require('./ReactBrowserEventEmitter');\nvar ReactCurrentOwner = require('react/lib/ReactCurrentOwner');\nvar ReactDOMComponentTree = require('./ReactDOMComponentTree');\nvar ReactDOMContainerInfo = require('./ReactDOMContainerInfo');\nvar ReactDOMFeatureFlags = require('./ReactDOMFeatureFlags');\nvar ReactFeatureFlags = require('./ReactFeatureFlags');\nvar ReactInstanceMap = require('./ReactInstanceMap');\nvar ReactInstrumentation = require('./ReactInstrumentation');\nvar ReactMarkupChecksum = require('./ReactMarkupChecksum');\nvar ReactReconciler = require('./ReactReconciler');\nvar ReactUpdateQueue = require('./ReactUpdateQueue');\nvar ReactUpdates = require('./ReactUpdates');\n\nvar emptyObject = require('fbjs/lib/emptyObject');\nvar instantiateReactComponent = require('./instantiateReactComponent');\nvar invariant = require('fbjs/lib/invariant');\nvar setInnerHTML = require('./setInnerHTML');\nvar shouldUpdateReactComponent = require('./shouldUpdateReactComponent');\nvar warning = require('fbjs/lib/warning');\n\nvar ATTR_NAME = DOMProperty.ID_ATTRIBUTE_NAME;\nvar ROOT_ATTR_NAME = DOMProperty.ROOT_ATTRIBUTE_NAME;\n\nvar ELEMENT_NODE_TYPE = 1;\nvar DOC_NODE_TYPE = 9;\nvar DOCUMENT_FRAGMENT_NODE_TYPE = 11;\n\nvar instancesByReactRootID = {};\n\n/**\n * Finds the index of the first character\n * that's not common between the two given strings.\n *\n * @return {number} the index of the character where the strings diverge\n */\nfunction firstDifferenceIndex(string1, string2) {\n var minLen = Math.min(string1.length, string2.length);\n for (var i = 0; i < minLen; i++) {\n if (string1.charAt(i) !== string2.charAt(i)) {\n return i;\n }\n }\n return string1.length === string2.length ? -1 : minLen;\n}\n\n/**\n * @param {DOMElement|DOMDocument} container DOM element that may contain\n * a React component\n * @return {?*} DOM element that may have the reactRoot ID, or null.\n */\nfunction getReactRootElementInContainer(container) {\n if (!container) {\n return null;\n }\n\n if (container.nodeType === DOC_NODE_TYPE) {\n return container.documentElement;\n } else {\n return container.firstChild;\n }\n}\n\nfunction internalGetID(node) {\n // If node is something like a window, document, or text node, none of\n // which support attributes or a .getAttribute method, gracefully return\n // the empty string, as if the attribute were missing.\n return node.getAttribute && node.getAttribute(ATTR_NAME) || '';\n}\n\n/**\n * Mounts this component and inserts it into the DOM.\n *\n * @param {ReactComponent} componentInstance The instance to mount.\n * @param {DOMElement} container DOM element to mount into.\n * @param {ReactReconcileTransaction} transaction\n * @param {boolean} shouldReuseMarkup If true, do not insert markup\n */\nfunction mountComponentIntoNode(wrapperInstance, container, transaction, shouldReuseMarkup, context) {\n var markerName;\n if (ReactFeatureFlags.logTopLevelRenders) {\n var wrappedElement = wrapperInstance._currentElement.props.child;\n var type = wrappedElement.type;\n markerName = 'React mount: ' + (typeof type === 'string' ? type : type.displayName || type.name);\n console.time(markerName);\n }\n\n var markup = ReactReconciler.mountComponent(wrapperInstance, transaction, null, ReactDOMContainerInfo(wrapperInstance, container), context, 0 /* parentDebugID */\n );\n\n if (markerName) {\n console.timeEnd(markerName);\n }\n\n wrapperInstance._renderedComponent._topLevelWrapper = wrapperInstance;\n ReactMount._mountImageIntoNode(markup, container, wrapperInstance, shouldReuseMarkup, transaction);\n}\n\n/**\n * Batched mount.\n *\n * @param {ReactComponent} componentInstance The instance to mount.\n * @param {DOMElement} container DOM element to mount into.\n * @param {boolean} shouldReuseMarkup If true, do not insert markup\n */\nfunction batchedMountComponentIntoNode(componentInstance, container, shouldReuseMarkup, context) {\n var transaction = ReactUpdates.ReactReconcileTransaction.getPooled(\n /* useCreateElement */\n !shouldReuseMarkup && ReactDOMFeatureFlags.useCreateElement);\n transaction.perform(mountComponentIntoNode, null, componentInstance, container, transaction, shouldReuseMarkup, context);\n ReactUpdates.ReactReconcileTransaction.release(transaction);\n}\n\n/**\n * Unmounts a component and removes it from the DOM.\n *\n * @param {ReactComponent} instance React component instance.\n * @param {DOMElement} container DOM element to unmount from.\n * @final\n * @internal\n * @see {ReactMount.unmountComponentAtNode}\n */\nfunction unmountComponentFromNode(instance, container, safely) {\n if (process.env.NODE_ENV !== 'production') {\n ReactInstrumentation.debugTool.onBeginFlush();\n }\n ReactReconciler.unmountComponent(instance, safely);\n if (process.env.NODE_ENV !== 'production') {\n ReactInstrumentation.debugTool.onEndFlush();\n }\n\n if (container.nodeType === DOC_NODE_TYPE) {\n container = container.documentElement;\n }\n\n // http://jsperf.com/emptying-a-node\n while (container.lastChild) {\n container.removeChild(container.lastChild);\n }\n}\n\n/**\n * True if the supplied DOM node has a direct React-rendered child that is\n * not a React root element. Useful for warning in `render`,\n * `unmountComponentAtNode`, etc.\n *\n * @param {?DOMElement} node The candidate DOM node.\n * @return {boolean} True if the DOM element contains a direct child that was\n * rendered by React but is not a root element.\n * @internal\n */\nfunction hasNonRootReactChild(container) {\n var rootEl = getReactRootElementInContainer(container);\n if (rootEl) {\n var inst = ReactDOMComponentTree.getInstanceFromNode(rootEl);\n return !!(inst && inst._hostParent);\n }\n}\n\n/**\n * True if the supplied DOM node is a React DOM element and\n * it has been rendered by another copy of React.\n *\n * @param {?DOMElement} node The candidate DOM node.\n * @return {boolean} True if the DOM has been rendered by another copy of React\n * @internal\n */\nfunction nodeIsRenderedByOtherInstance(container) {\n var rootEl = getReactRootElementInContainer(container);\n return !!(rootEl && isReactNode(rootEl) && !ReactDOMComponentTree.getInstanceFromNode(rootEl));\n}\n\n/**\n * True if the supplied DOM node is a valid node element.\n *\n * @param {?DOMElement} node The candidate DOM node.\n * @return {boolean} True if the DOM is a valid DOM node.\n * @internal\n */\nfunction isValidContainer(node) {\n return !!(node && (node.nodeType === ELEMENT_NODE_TYPE || node.nodeType === DOC_NODE_TYPE || node.nodeType === DOCUMENT_FRAGMENT_NODE_TYPE));\n}\n\n/**\n * True if the supplied DOM node is a valid React node element.\n *\n * @param {?DOMElement} node The candidate DOM node.\n * @return {boolean} True if the DOM is a valid React DOM node.\n * @internal\n */\nfunction isReactNode(node) {\n return isValidContainer(node) && (node.hasAttribute(ROOT_ATTR_NAME) || node.hasAttribute(ATTR_NAME));\n}\n\nfunction getHostRootInstanceInContainer(container) {\n var rootEl = getReactRootElementInContainer(container);\n var prevHostInstance = rootEl && ReactDOMComponentTree.getInstanceFromNode(rootEl);\n return prevHostInstance && !prevHostInstance._hostParent ? prevHostInstance : null;\n}\n\nfunction getTopLevelWrapperInContainer(container) {\n var root = getHostRootInstanceInContainer(container);\n return root ? root._hostContainerInfo._topLevelWrapper : null;\n}\n\n/**\n * Temporary (?) hack so that we can store all top-level pending updates on\n * composites instead of having to worry about different types of components\n * here.\n */\nvar topLevelRootCounter = 1;\nvar TopLevelWrapper = function () {\n this.rootID = topLevelRootCounter++;\n};\nTopLevelWrapper.prototype.isReactComponent = {};\nif (process.env.NODE_ENV !== 'production') {\n TopLevelWrapper.displayName = 'TopLevelWrapper';\n}\nTopLevelWrapper.prototype.render = function () {\n return this.props.child;\n};\nTopLevelWrapper.isReactTopLevelWrapper = true;\n\n/**\n * Mounting is the process of initializing a React component by creating its\n * representative DOM elements and inserting them into a supplied `container`.\n * Any prior content inside `container` is destroyed in the process.\n *\n * ReactMount.render(\n * component,\n * document.getElementById('container')\n * );\n *\n * <div id=\"container\"> <-- Supplied `container`.\n * <div data-reactid=\".3\"> <-- Rendered reactRoot of React\n * // ... component.\n * </div>\n * </div>\n *\n * Inside of `container`, the first element rendered is the \"reactRoot\".\n */\nvar ReactMount = {\n TopLevelWrapper: TopLevelWrapper,\n\n /**\n * Used by devtools. The keys are not important.\n */\n _instancesByReactRootID: instancesByReactRootID,\n\n /**\n * This is a hook provided to support rendering React components while\n * ensuring that the apparent scroll position of its `container` does not\n * change.\n *\n * @param {DOMElement} container The `container` being rendered into.\n * @param {function} renderCallback This must be called once to do the render.\n */\n scrollMonitor: function (container, renderCallback) {\n renderCallback();\n },\n\n /**\n * Take a component that's already mounted into the DOM and replace its props\n * @param {ReactComponent} prevComponent component instance already in the DOM\n * @param {ReactElement} nextElement component instance to render\n * @param {DOMElement} container container to render into\n * @param {?function} callback function triggered on completion\n */\n _updateRootComponent: function (prevComponent, nextElement, nextContext, container, callback) {\n ReactMount.scrollMonitor(container, function () {\n ReactUpdateQueue.enqueueElementInternal(prevComponent, nextElement, nextContext);\n if (callback) {\n ReactUpdateQueue.enqueueCallbackInternal(prevComponent, callback);\n }\n });\n\n return prevComponent;\n },\n\n /**\n * Render a new component into the DOM. Hooked by hooks!\n *\n * @param {ReactElement} nextElement element to render\n * @param {DOMElement} container container to render into\n * @param {boolean} shouldReuseMarkup if we should skip the markup insertion\n * @return {ReactComponent} nextComponent\n */\n _renderNewRootComponent: function (nextElement, container, shouldReuseMarkup, context) {\n // Various parts of our code (such as ReactCompositeComponent's\n // _renderValidatedComponent) assume that calls to render aren't nested;\n // verify that that's the case.\n process.env.NODE_ENV !== 'production' ? warning(ReactCurrentOwner.current == null, '_renderNewRootComponent(): Render methods should be a pure function ' + 'of props and state; triggering nested component updates from ' + 'render is not allowed. If necessary, trigger nested updates in ' + 'componentDidUpdate. Check the render method of %s.', ReactCurrentOwner.current && ReactCurrentOwner.current.getName() || 'ReactCompositeComponent') : void 0;\n\n !isValidContainer(container) ? process.env.NODE_ENV !== 'production' ? invariant(false, '_registerComponent(...): Target container is not a DOM element.') : _prodInvariant('37') : void 0;\n\n ReactBrowserEventEmitter.ensureScrollValueMonitoring();\n var componentInstance = instantiateReactComponent(nextElement, false);\n\n // The initial render is synchronous but any updates that happen during\n // rendering, in componentWillMount or componentDidMount, will be batched\n // according to the current batching strategy.\n\n ReactUpdates.batchedUpdates(batchedMountComponentIntoNode, componentInstance, container, shouldReuseMarkup, context);\n\n var wrapperID = componentInstance._instance.rootID;\n instancesByReactRootID[wrapperID] = componentInstance;\n\n return componentInstance;\n },\n\n /**\n * Renders a React component into the DOM in the supplied `container`.\n *\n * If the React component was previously rendered into `container`, this will\n * perform an update on it and only mutate the DOM as necessary to reflect the\n * latest React component.\n *\n * @param {ReactComponent} parentComponent The conceptual parent of this render tree.\n * @param {ReactElement} nextElement Component element to render.\n * @param {DOMElement} container DOM element to render into.\n * @param {?function} callback function triggered on completion\n * @return {ReactComponent} Component instance rendered in `container`.\n */\n renderSubtreeIntoContainer: function (parentComponent, nextElement, container, callback) {\n !(parentComponent != null && ReactInstanceMap.has(parentComponent)) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'parentComponent must be a valid React Component') : _prodInvariant('38') : void 0;\n return ReactMount._renderSubtreeIntoContainer(parentComponent, nextElement, container, callback);\n },\n\n _renderSubtreeIntoContainer: function (parentComponent, nextElement, container, callback) {\n ReactUpdateQueue.validateCallback(callback, 'ReactDOM.render');\n !React.isValidElement(nextElement) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactDOM.render(): Invalid component element.%s', typeof nextElement === 'string' ? \" Instead of passing a string like 'div', pass \" + \"React.createElement('div') or <div />.\" : typeof nextElement === 'function' ? ' Instead of passing a class like Foo, pass ' + 'React.createElement(Foo) or <Foo />.' : // Check if it quacks like an element\n nextElement != null && nextElement.props !== undefined ? ' This may be caused by unintentionally loading two independent ' + 'copies of React.' : '') : _prodInvariant('39', typeof nextElement === 'string' ? \" Instead of passing a string like 'div', pass \" + \"React.createElement('div') or <div />.\" : typeof nextElement === 'function' ? ' Instead of passing a class like Foo, pass ' + 'React.createElement(Foo) or <Foo />.' : nextElement != null && nextElement.props !== undefined ? ' This may be caused by unintentionally loading two independent ' + 'copies of React.' : '') : void 0;\n\n process.env.NODE_ENV !== 'production' ? warning(!container || !container.tagName || container.tagName.toUpperCase() !== 'BODY', 'render(): Rendering components directly into document.body is ' + 'discouraged, since its children are often manipulated by third-party ' + 'scripts and browser extensions. This may lead to subtle ' + 'reconciliation issues. Try rendering into a container element created ' + 'for your app.') : void 0;\n\n var nextWrappedElement = React.createElement(TopLevelWrapper, {\n child: nextElement\n });\n\n var nextContext;\n if (parentComponent) {\n var parentInst = ReactInstanceMap.get(parentComponent);\n nextContext = parentInst._processChildContext(parentInst._context);\n } else {\n nextContext = emptyObject;\n }\n\n var prevComponent = getTopLevelWrapperInContainer(container);\n\n if (prevComponent) {\n var prevWrappedElement = prevComponent._currentElement;\n var prevElement = prevWrappedElement.props.child;\n if (shouldUpdateReactComponent(prevElement, nextElement)) {\n var publicInst = prevComponent._renderedComponent.getPublicInstance();\n var updatedCallback = callback && function () {\n callback.call(publicInst);\n };\n ReactMount._updateRootComponent(prevComponent, nextWrappedElement, nextContext, container, updatedCallback);\n return publicInst;\n } else {\n ReactMount.unmountComponentAtNode(container);\n }\n }\n\n var reactRootElement = getReactRootElementInContainer(container);\n var containerHasReactMarkup = reactRootElement && !!internalGetID(reactRootElement);\n var containerHasNonRootReactChild = hasNonRootReactChild(container);\n\n if (process.env.NODE_ENV !== 'production') {\n process.env.NODE_ENV !== 'production' ? warning(!containerHasNonRootReactChild, 'render(...): Replacing React-rendered children with a new root ' + 'component. If you intended to update the children of this node, ' + 'you should instead have the existing children update their state ' + 'and render the new components instead of calling ReactDOM.render.') : void 0;\n\n if (!containerHasReactMarkup || reactRootElement.nextSibling) {\n var rootElementSibling = reactRootElement;\n while (rootElementSibling) {\n if (internalGetID(rootElementSibling)) {\n process.env.NODE_ENV !== 'production' ? warning(false, 'render(): Target node has markup rendered by React, but there ' + 'are unrelated nodes as well. This is most commonly caused by ' + 'white-space inserted around server-rendered markup.') : void 0;\n break;\n }\n rootElementSibling = rootElementSibling.nextSibling;\n }\n }\n }\n\n var shouldReuseMarkup = containerHasReactMarkup && !prevComponent && !containerHasNonRootReactChild;\n var component = ReactMount._renderNewRootComponent(nextWrappedElement, container, shouldReuseMarkup, nextContext)._renderedComponent.getPublicInstance();\n if (callback) {\n callback.call(component);\n }\n return component;\n },\n\n /**\n * Renders a React component into the DOM in the supplied `container`.\n * See https://facebook.github.io/react/docs/top-level-api.html#reactdom.render\n *\n * If the React component was previously rendered into `container`, this will\n * perform an update on it and only mutate the DOM as necessary to reflect the\n * latest React component.\n *\n * @param {ReactElement} nextElement Component element to render.\n * @param {DOMElement} container DOM element to render into.\n * @param {?function} callback function triggered on completion\n * @return {ReactComponent} Component instance rendered in `container`.\n */\n render: function (nextElement, container, callback) {\n return ReactMount._renderSubtreeIntoContainer(null, nextElement, container, callback);\n },\n\n /**\n * Unmounts and destroys the React component rendered in the `container`.\n * See https://facebook.github.io/react/docs/top-level-api.html#reactdom.unmountcomponentatnode\n *\n * @param {DOMElement} container DOM element containing a React component.\n * @return {boolean} True if a component was found in and unmounted from\n * `container`\n */\n unmountComponentAtNode: function (container) {\n // Various parts of our code (such as ReactCompositeComponent's\n // _renderValidatedComponent) assume that calls to render aren't nested;\n // verify that that's the case. (Strictly speaking, unmounting won't cause a\n // render but we still don't expect to be in a render call here.)\n process.env.NODE_ENV !== 'production' ? warning(ReactCurrentOwner.current == null, 'unmountComponentAtNode(): Render methods should be a pure function ' + 'of props and state; triggering nested component updates from render ' + 'is not allowed. If necessary, trigger nested updates in ' + 'componentDidUpdate. Check the render method of %s.', ReactCurrentOwner.current && ReactCurrentOwner.current.getName() || 'ReactCompositeComponent') : void 0;\n\n !isValidContainer(container) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'unmountComponentAtNode(...): Target container is not a DOM element.') : _prodInvariant('40') : void 0;\n\n if (process.env.NODE_ENV !== 'production') {\n process.env.NODE_ENV !== 'production' ? warning(!nodeIsRenderedByOtherInstance(container), \"unmountComponentAtNode(): The node you're attempting to unmount \" + 'was rendered by another copy of React.') : void 0;\n }\n\n var prevComponent = getTopLevelWrapperInContainer(container);\n if (!prevComponent) {\n // Check if the node being unmounted was rendered by React, but isn't a\n // root node.\n var containerHasNonRootReactChild = hasNonRootReactChild(container);\n\n // Check if the container itself is a React root node.\n var isContainerReactRoot = container.nodeType === 1 && container.hasAttribute(ROOT_ATTR_NAME);\n\n if (process.env.NODE_ENV !== 'production') {\n process.env.NODE_ENV !== 'production' ? warning(!containerHasNonRootReactChild, \"unmountComponentAtNode(): The node you're attempting to unmount \" + 'was rendered by React and is not a top-level container. %s', isContainerReactRoot ? 'You may have accidentally passed in a React root node instead ' + 'of its container.' : 'Instead, have the parent component update its state and ' + 'rerender in order to remove this component.') : void 0;\n }\n\n return false;\n }\n delete instancesByReactRootID[prevComponent._instance.rootID];\n ReactUpdates.batchedUpdates(unmountComponentFromNode, prevComponent, container, false);\n return true;\n },\n\n _mountImageIntoNode: function (markup, container, instance, shouldReuseMarkup, transaction) {\n !isValidContainer(container) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'mountComponentIntoNode(...): Target container is not valid.') : _prodInvariant('41') : void 0;\n\n if (shouldReuseMarkup) {\n var rootElement = getReactRootElementInContainer(container);\n if (ReactMarkupChecksum.canReuseMarkup(markup, rootElement)) {\n ReactDOMComponentTree.precacheNode(instance, rootElement);\n return;\n } else {\n var checksum = rootElement.getAttribute(ReactMarkupChecksum.CHECKSUM_ATTR_NAME);\n rootElement.removeAttribute(ReactMarkupChecksum.CHECKSUM_ATTR_NAME);\n\n var rootMarkup = rootElement.outerHTML;\n rootElement.setAttribute(ReactMarkupChecksum.CHECKSUM_ATTR_NAME, checksum);\n\n var normalizedMarkup = markup;\n if (process.env.NODE_ENV !== 'production') {\n // because rootMarkup is retrieved from the DOM, various normalizations\n // will have occurred which will not be present in `markup`. Here,\n // insert markup into a <div> or <iframe> depending on the container\n // type to perform the same normalizations before comparing.\n var normalizer;\n if (container.nodeType === ELEMENT_NODE_TYPE) {\n normalizer = document.createElement('div');\n normalizer.innerHTML = markup;\n normalizedMarkup = normalizer.innerHTML;\n } else {\n normalizer = document.createElement('iframe');\n document.body.appendChild(normalizer);\n normalizer.contentDocument.write(markup);\n normalizedMarkup = normalizer.contentDocument.documentElement.outerHTML;\n document.body.removeChild(normalizer);\n }\n }\n\n var diffIndex = firstDifferenceIndex(normalizedMarkup, rootMarkup);\n var difference = ' (client) ' + normalizedMarkup.substring(diffIndex - 20, diffIndex + 20) + '\\n (server) ' + rootMarkup.substring(diffIndex - 20, diffIndex + 20);\n\n !(container.nodeType !== DOC_NODE_TYPE) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'You\\'re trying to render a component to the document using server rendering but the checksum was invalid. This usually means you rendered a different component type or props on the client from the one on the server, or your render() methods are impure. React cannot handle this case due to cross-browser quirks by rendering at the document root. You should look for environment dependent code in your components and ensure the props are the same client and server side:\\n%s', difference) : _prodInvariant('42', difference) : void 0;\n\n if (process.env.NODE_ENV !== 'production') {\n process.env.NODE_ENV !== 'production' ? warning(false, 'React attempted to reuse markup in a container but the ' + 'checksum was invalid. This generally means that you are ' + 'using server rendering and the markup generated on the ' + 'server was not what the client was expecting. React injected ' + 'new markup to compensate which works but you have lost many ' + 'of the benefits of server rendering. Instead, figure out ' + 'why the markup being generated is different on the client ' + 'or server:\\n%s', difference) : void 0;\n }\n }\n }\n\n !(container.nodeType !== DOC_NODE_TYPE) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'You\\'re trying to render a component to the document but you didn\\'t use server rendering. We can\\'t do this without using server rendering due to cross-browser quirks. See ReactDOMServer.renderToString() for server rendering.') : _prodInvariant('43') : void 0;\n\n if (transaction.useCreateElement) {\n while (container.lastChild) {\n container.removeChild(container.lastChild);\n }\n DOMLazyTree.insertTreeBefore(container, markup, null);\n } else {\n setInnerHTML(container, markup);\n ReactDOMComponentTree.precacheNode(instance, container.firstChild);\n }\n\n if (process.env.NODE_ENV !== 'production') {\n var hostNode = ReactDOMComponentTree.getInstanceFromNode(container.firstChild);\n if (hostNode._debugID !== 0) {\n ReactInstrumentation.debugTool.onHostOperation({\n instanceID: hostNode._debugID,\n type: 'mount',\n payload: markup.toString()\n });\n }\n }\n }\n};\n\nmodule.exports = ReactMount;","'use strict';\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\n/* eslint-disable fb-www/typeof-undefined */\n\n/**\n * Same as document.activeElement but wraps in a try-catch block. In IE it is\n * not safe to call document.activeElement if there is nothing focused.\n *\n * The activeElement will be null only if the document or document body is not\n * yet defined.\n *\n * @param {?DOMDocument} doc Defaults to current document.\n * @return {?DOMElement}\n */\nfunction getActiveElement(doc) /*?DOMElement*/{\n doc = doc || (typeof document !== 'undefined' ? document : undefined);\n if (typeof doc === 'undefined') {\n return null;\n }\n try {\n return doc.activeElement || doc.body;\n } catch (e) {\n return doc.body;\n }\n}\n\nmodule.exports = getActiveElement;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar ReactDOMSelection = require('./ReactDOMSelection');\n\nvar containsNode = require('fbjs/lib/containsNode');\nvar focusNode = require('fbjs/lib/focusNode');\nvar getActiveElement = require('fbjs/lib/getActiveElement');\n\nfunction isInDocument(node) {\n return containsNode(document.documentElement, node);\n}\n\n/**\n * @ReactInputSelection: React input selection module. Based on Selection.js,\n * but modified to be suitable for react and has a couple of bug fixes (doesn't\n * assume buttons have range selections allowed).\n * Input selection module for React.\n */\nvar ReactInputSelection = {\n hasSelectionCapabilities: function (elem) {\n var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();\n return nodeName && (nodeName === 'input' && elem.type === 'text' || nodeName === 'textarea' || elem.contentEditable === 'true');\n },\n\n getSelectionInformation: function () {\n var focusedElem = getActiveElement();\n return {\n focusedElem: focusedElem,\n selectionRange: ReactInputSelection.hasSelectionCapabilities(focusedElem) ? ReactInputSelection.getSelection(focusedElem) : null\n };\n },\n\n /**\n * @restoreSelection: If any selection information was potentially lost,\n * restore it. This is useful when performing operations that could remove dom\n * nodes and place them back in, resulting in focus being lost.\n */\n restoreSelection: function (priorSelectionInformation) {\n var curFocusedElem = getActiveElement();\n var priorFocusedElem = priorSelectionInformation.focusedElem;\n var priorSelectionRange = priorSelectionInformation.selectionRange;\n if (curFocusedElem !== priorFocusedElem && isInDocument(priorFocusedElem)) {\n if (ReactInputSelection.hasSelectionCapabilities(priorFocusedElem)) {\n ReactInputSelection.setSelection(priorFocusedElem, priorSelectionRange);\n }\n focusNode(priorFocusedElem);\n }\n },\n\n /**\n * @getSelection: Gets the selection bounds of a focused textarea, input or\n * contentEditable node.\n * -@input: Look up selection bounds of this input\n * -@return {start: selectionStart, end: selectionEnd}\n */\n getSelection: function (input) {\n var selection;\n\n if ('selectionStart' in input) {\n // Modern browser with input or textarea.\n selection = {\n start: input.selectionStart,\n end: input.selectionEnd\n };\n } else if (document.selection && input.nodeName && input.nodeName.toLowerCase() === 'input') {\n // IE8 input.\n var range = document.selection.createRange();\n // There can only be one selection per document in IE, so it must\n // be in our element.\n if (range.parentElement() === input) {\n selection = {\n start: -range.moveStart('character', -input.value.length),\n end: -range.moveEnd('character', -input.value.length)\n };\n }\n } else {\n // Content editable or old IE textarea.\n selection = ReactDOMSelection.getOffsets(input);\n }\n\n return selection || { start: 0, end: 0 };\n },\n\n /**\n * @setSelection: Sets the selection bounds of a textarea or input and focuses\n * the input.\n * -@input Set selection bounds of this input or textarea\n * -@offsets Object of same form that is returned from get*\n */\n setSelection: function (input, offsets) {\n var start = offsets.start;\n var end = offsets.end;\n if (end === undefined) {\n end = start;\n }\n\n if ('selectionStart' in input) {\n input.selectionStart = start;\n input.selectionEnd = Math.min(end, input.value.length);\n } else if (document.selection && input.nodeName && input.nodeName.toLowerCase() === 'input') {\n var range = input.createTextRange();\n range.collapse(true);\n range.moveStart('character', start);\n range.moveEnd('character', end - start);\n range.select();\n } else {\n ReactDOMSelection.setOffsets(input, offsets);\n }\n }\n};\n\nmodule.exports = ReactInputSelection;","'use strict';\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\nvar emptyFunction = require('./emptyFunction');\n\n/**\n * Upstream version of event listener. Does not take into account specific\n * nature of platform.\n */\nvar EventListener = {\n /**\n * Listen to DOM events during the bubble phase.\n *\n * @param {DOMEventTarget} target DOM element to register listener on.\n * @param {string} eventType Event type, e.g. 'click' or 'mouseover'.\n * @param {function} callback Callback function.\n * @return {object} Object with a `remove` method.\n */\n listen: function listen(target, eventType, callback) {\n if (target.addEventListener) {\n target.addEventListener(eventType, callback, false);\n return {\n remove: function remove() {\n target.removeEventListener(eventType, callback, false);\n }\n };\n } else if (target.attachEvent) {\n target.attachEvent('on' + eventType, callback);\n return {\n remove: function remove() {\n target.detachEvent('on' + eventType, callback);\n }\n };\n }\n },\n\n /**\n * Listen to DOM events during the capture phase.\n *\n * @param {DOMEventTarget} target DOM element to register listener on.\n * @param {string} eventType Event type, e.g. 'click' or 'mouseover'.\n * @param {function} callback Callback function.\n * @return {object} Object with a `remove` method.\n */\n capture: function capture(target, eventType, callback) {\n if (target.addEventListener) {\n target.addEventListener(eventType, callback, true);\n return {\n remove: function remove() {\n target.removeEventListener(eventType, callback, true);\n }\n };\n } else {\n if (process.env.NODE_ENV !== 'production') {\n console.error('Attempted to listen to events during the capture phase on a ' + 'browser that does not support the capture phase. Your application ' + 'will not receive some events.');\n }\n return {\n remove: emptyFunction\n };\n }\n },\n\n registerDefault: function registerDefault() {}\n};\n\nmodule.exports = EventListener;","/**\n * Copyright (c) 2016-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n */\n\n'use strict';\n\nvar _prodInvariant = require('./reactProdInvariant');\n\nvar ReactCurrentOwner = require('./ReactCurrentOwner');\n\nvar invariant = require('fbjs/lib/invariant');\nvar warning = require('fbjs/lib/warning');\n\nfunction isNative(fn) {\n // Based on isNative() from Lodash\n var funcToString = Function.prototype.toString;\n var hasOwnProperty = Object.prototype.hasOwnProperty;\n var reIsNative = RegExp('^' + funcToString\n // Take an example native function source for comparison\n .call(hasOwnProperty\n // Strip regex characters so we can use it for regex\n ).replace(/[\\\\^$.*+?()[\\]{}|]/g, '\\\\$&'\n // Remove hasOwnProperty from the template to make it generic\n ).replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$');\n try {\n var source = funcToString.call(fn);\n return reIsNative.test(source);\n } catch (err) {\n return false;\n }\n}\n\nvar canUseCollections =\n// Array.from\ntypeof Array.from === 'function' &&\n// Map\ntypeof Map === 'function' && isNative(Map) &&\n// Map.prototype.keys\nMap.prototype != null && typeof Map.prototype.keys === 'function' && isNative(Map.prototype.keys) &&\n// Set\ntypeof Set === 'function' && isNative(Set) &&\n// Set.prototype.keys\nSet.prototype != null && typeof Set.prototype.keys === 'function' && isNative(Set.prototype.keys);\n\nvar setItem;\nvar getItem;\nvar removeItem;\nvar getItemIDs;\nvar addRoot;\nvar removeRoot;\nvar getRootIDs;\n\nif (canUseCollections) {\n var itemMap = new Map();\n var rootIDSet = new Set();\n\n setItem = function (id, item) {\n itemMap.set(id, item);\n };\n getItem = function (id) {\n return itemMap.get(id);\n };\n removeItem = function (id) {\n itemMap['delete'](id);\n };\n getItemIDs = function () {\n return Array.from(itemMap.keys());\n };\n\n addRoot = function (id) {\n rootIDSet.add(id);\n };\n removeRoot = function (id) {\n rootIDSet['delete'](id);\n };\n getRootIDs = function () {\n return Array.from(rootIDSet.keys());\n };\n} else {\n var itemByKey = {};\n var rootByKey = {};\n\n // Use non-numeric keys to prevent V8 performance issues:\n // https://github.com/facebook/react/pull/7232\n var getKeyFromID = function (id) {\n return '.' + id;\n };\n var getIDFromKey = function (key) {\n return parseInt(key.substr(1), 10);\n };\n\n setItem = function (id, item) {\n var key = getKeyFromID(id);\n itemByKey[key] = item;\n };\n getItem = function (id) {\n var key = getKeyFromID(id);\n return itemByKey[key];\n };\n removeItem = function (id) {\n var key = getKeyFromID(id);\n delete itemByKey[key];\n };\n getItemIDs = function () {\n return Object.keys(itemByKey).map(getIDFromKey);\n };\n\n addRoot = function (id) {\n var key = getKeyFromID(id);\n rootByKey[key] = true;\n };\n removeRoot = function (id) {\n var key = getKeyFromID(id);\n delete rootByKey[key];\n };\n getRootIDs = function () {\n return Object.keys(rootByKey).map(getIDFromKey);\n };\n}\n\nvar unmountedIDs = [];\n\nfunction purgeDeep(id) {\n var item = getItem(id);\n if (item) {\n var childIDs = item.childIDs;\n\n removeItem(id);\n childIDs.forEach(purgeDeep);\n }\n}\n\nfunction describeComponentFrame(name, source, ownerName) {\n return '\\n in ' + (name || 'Unknown') + (source ? ' (at ' + source.fileName.replace(/^.*[\\\\\\/]/, '') + ':' + source.lineNumber + ')' : ownerName ? ' (created by ' + ownerName + ')' : '');\n}\n\nfunction getDisplayName(element) {\n if (element == null) {\n return '#empty';\n } else if (typeof element === 'string' || typeof element === 'number') {\n return '#text';\n } else if (typeof element.type === 'string') {\n return element.type;\n } else {\n return element.type.displayName || element.type.name || 'Unknown';\n }\n}\n\nfunction describeID(id) {\n var name = ReactComponentTreeHook.getDisplayName(id);\n var element = ReactComponentTreeHook.getElement(id);\n var ownerID = ReactComponentTreeHook.getOwnerID(id);\n var ownerName;\n if (ownerID) {\n ownerName = ReactComponentTreeHook.getDisplayName(ownerID);\n }\n process.env.NODE_ENV !== 'production' ? warning(element, 'ReactComponentTreeHook: Missing React element for debugID %s when ' + 'building stack', id) : void 0;\n return describeComponentFrame(name, element && element._source, ownerName);\n}\n\nvar ReactComponentTreeHook = {\n onSetChildren: function (id, nextChildIDs) {\n var item = getItem(id);\n !item ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Item must have been set') : _prodInvariant('144') : void 0;\n item.childIDs = nextChildIDs;\n\n for (var i = 0; i < nextChildIDs.length; i++) {\n var nextChildID = nextChildIDs[i];\n var nextChild = getItem(nextChildID);\n !nextChild ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Expected hook events to fire for the child before its parent includes it in onSetChildren().') : _prodInvariant('140') : void 0;\n !(nextChild.childIDs != null || typeof nextChild.element !== 'object' || nextChild.element == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Expected onSetChildren() to fire for a container child before its parent includes it in onSetChildren().') : _prodInvariant('141') : void 0;\n !nextChild.isMounted ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Expected onMountComponent() to fire for the child before its parent includes it in onSetChildren().') : _prodInvariant('71') : void 0;\n if (nextChild.parentID == null) {\n nextChild.parentID = id;\n // TODO: This shouldn't be necessary but mounting a new root during in\n // componentWillMount currently causes not-yet-mounted components to\n // be purged from our tree data so their parent id is missing.\n }\n !(nextChild.parentID === id) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Expected onBeforeMountComponent() parent and onSetChildren() to be consistent (%s has parents %s and %s).', nextChildID, nextChild.parentID, id) : _prodInvariant('142', nextChildID, nextChild.parentID, id) : void 0;\n }\n },\n onBeforeMountComponent: function (id, element, parentID) {\n var item = {\n element: element,\n parentID: parentID,\n text: null,\n childIDs: [],\n isMounted: false,\n updateCount: 0\n };\n setItem(id, item);\n },\n onBeforeUpdateComponent: function (id, element) {\n var item = getItem(id);\n if (!item || !item.isMounted) {\n // We may end up here as a result of setState() in componentWillUnmount().\n // In this case, ignore the element.\n return;\n }\n item.element = element;\n },\n onMountComponent: function (id) {\n var item = getItem(id);\n !item ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Item must have been set') : _prodInvariant('144') : void 0;\n item.isMounted = true;\n var isRoot = item.parentID === 0;\n if (isRoot) {\n addRoot(id);\n }\n },\n onUpdateComponent: function (id) {\n var item = getItem(id);\n if (!item || !item.isMounted) {\n // We may end up here as a result of setState() in componentWillUnmount().\n // In this case, ignore the element.\n return;\n }\n item.updateCount++;\n },\n onUnmountComponent: function (id) {\n var item = getItem(id);\n if (item) {\n // We need to check if it exists.\n // `item` might not exist if it is inside an error boundary, and a sibling\n // error boundary child threw while mounting. Then this instance never\n // got a chance to mount, but it still gets an unmounting event during\n // the error boundary cleanup.\n item.isMounted = false;\n var isRoot = item.parentID === 0;\n if (isRoot) {\n removeRoot(id);\n }\n }\n unmountedIDs.push(id);\n },\n purgeUnmountedComponents: function () {\n if (ReactComponentTreeHook._preventPurging) {\n // Should only be used for testing.\n return;\n }\n\n for (var i = 0; i < unmountedIDs.length; i++) {\n var id = unmountedIDs[i];\n purgeDeep(id);\n }\n unmountedIDs.length = 0;\n },\n isMounted: function (id) {\n var item = getItem(id);\n return item ? item.isMounted : false;\n },\n getCurrentStackAddendum: function (topElement) {\n var info = '';\n if (topElement) {\n var name = getDisplayName(topElement);\n var owner = topElement._owner;\n info += describeComponentFrame(name, topElement._source, owner && owner.getName());\n }\n\n var currentOwner = ReactCurrentOwner.current;\n var id = currentOwner && currentOwner._debugID;\n\n info += ReactComponentTreeHook.getStackAddendumByID(id);\n return info;\n },\n getStackAddendumByID: function (id) {\n var info = '';\n while (id) {\n info += describeID(id);\n id = ReactComponentTreeHook.getParentID(id);\n }\n return info;\n },\n getChildIDs: function (id) {\n var item = getItem(id);\n return item ? item.childIDs : [];\n },\n getDisplayName: function (id) {\n var element = ReactComponentTreeHook.getElement(id);\n if (!element) {\n return null;\n }\n return getDisplayName(element);\n },\n getElement: function (id) {\n var item = getItem(id);\n return item ? item.element : null;\n },\n getOwnerID: function (id) {\n var element = ReactComponentTreeHook.getElement(id);\n if (!element || !element._owner) {\n return null;\n }\n return element._owner._debugID;\n },\n getParentID: function (id) {\n var item = getItem(id);\n return item ? item.parentID : null;\n },\n getSource: function (id) {\n var item = getItem(id);\n var element = item ? item.element : null;\n var source = element != null ? element._source : null;\n return source;\n },\n getText: function (id) {\n var element = ReactComponentTreeHook.getElement(id);\n if (typeof element === 'string') {\n return element;\n } else if (typeof element === 'number') {\n return '' + element;\n } else {\n return null;\n }\n },\n getUpdateCount: function (id) {\n var item = getItem(id);\n return item ? item.updateCount : 0;\n },\n\n\n getRootIDs: getRootIDs,\n getRegisteredIDs: getItemIDs,\n\n pushNonStandardWarningStack: function (isCreatingElement, currentSource) {\n if (typeof console.reactStack !== 'function') {\n return;\n }\n\n var stack = [];\n var currentOwner = ReactCurrentOwner.current;\n var id = currentOwner && currentOwner._debugID;\n\n try {\n if (isCreatingElement) {\n stack.push({\n name: id ? ReactComponentTreeHook.getDisplayName(id) : null,\n fileName: currentSource ? currentSource.fileName : null,\n lineNumber: currentSource ? currentSource.lineNumber : null\n });\n }\n\n while (id) {\n var element = ReactComponentTreeHook.getElement(id);\n var parentID = ReactComponentTreeHook.getParentID(id);\n var ownerID = ReactComponentTreeHook.getOwnerID(id);\n var ownerName = ownerID ? ReactComponentTreeHook.getDisplayName(ownerID) : null;\n var source = element && element._source;\n stack.push({\n name: ownerName,\n fileName: source ? source.fileName : null,\n lineNumber: source ? source.lineNumber : null\n });\n id = parentID;\n }\n } catch (err) {\n // Internal state is messed up.\n // Stop building the stack (it's just a nice to have).\n }\n\n console.reactStack(stack);\n },\n popNonStandardWarningStack: function () {\n if (typeof console.reactStackEnd !== 'function') {\n return;\n }\n console.reactStackEnd();\n }\n};\n\nmodule.exports = ReactComponentTreeHook;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar _prodInvariant = require('./reactProdInvariant');\n\nvar ReactCurrentOwner = require('react/lib/ReactCurrentOwner');\nvar REACT_ELEMENT_TYPE = require('./ReactElementSymbol');\n\nvar getIteratorFn = require('./getIteratorFn');\nvar invariant = require('fbjs/lib/invariant');\nvar KeyEscapeUtils = require('./KeyEscapeUtils');\nvar warning = require('fbjs/lib/warning');\n\nvar SEPARATOR = '.';\nvar SUBSEPARATOR = ':';\n\n/**\n * This is inlined from ReactElement since this file is shared between\n * isomorphic and renderers. We could extract this to a\n *\n */\n\n/**\n * TODO: Test that a single child and an array with one item have the same key\n * pattern.\n */\n\nvar didWarnAboutMaps = false;\n\n/**\n * Generate a key string that identifies a component within a set.\n *\n * @param {*} component A component that could contain a manual key.\n * @param {number} index Index that is used if a manual key is not provided.\n * @return {string}\n */\nfunction getComponentKey(component, index) {\n // Do some typechecking here since we call this blindly. We want to ensure\n // that we don't block potential future ES APIs.\n if (component && typeof component === 'object' && component.key != null) {\n // Explicit key\n return KeyEscapeUtils.escape(component.key);\n }\n // Implicit key determined by the index in the set\n return index.toString(36);\n}\n\n/**\n * @param {?*} children Children tree container.\n * @param {!string} nameSoFar Name of the key path so far.\n * @param {!function} callback Callback to invoke with each child found.\n * @param {?*} traverseContext Used to pass information throughout the traversal\n * process.\n * @return {!number} The number of children in this subtree.\n */\nfunction traverseAllChildrenImpl(children, nameSoFar, callback, traverseContext) {\n var type = typeof children;\n\n if (type === 'undefined' || type === 'boolean') {\n // All of the above are perceived as null.\n children = null;\n }\n\n if (children === null || type === 'string' || type === 'number' ||\n // The following is inlined from ReactElement. This means we can optimize\n // some checks. React Fiber also inlines this logic for similar purposes.\n type === 'object' && children.$$typeof === REACT_ELEMENT_TYPE) {\n callback(traverseContext, children,\n // If it's the only child, treat the name as if it was wrapped in an array\n // so that it's consistent if the number of children grows.\n nameSoFar === '' ? SEPARATOR + getComponentKey(children, 0) : nameSoFar);\n return 1;\n }\n\n var child;\n var nextName;\n var subtreeCount = 0; // Count of children found in the current subtree.\n var nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR;\n\n if (Array.isArray(children)) {\n for (var i = 0; i < children.length; i++) {\n child = children[i];\n nextName = nextNamePrefix + getComponentKey(child, i);\n subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);\n }\n } else {\n var iteratorFn = getIteratorFn(children);\n if (iteratorFn) {\n var iterator = iteratorFn.call(children);\n var step;\n if (iteratorFn !== children.entries) {\n var ii = 0;\n while (!(step = iterator.next()).done) {\n child = step.value;\n nextName = nextNamePrefix + getComponentKey(child, ii++);\n subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);\n }\n } else {\n if (process.env.NODE_ENV !== 'production') {\n var mapsAsChildrenAddendum = '';\n if (ReactCurrentOwner.current) {\n var mapsAsChildrenOwnerName = ReactCurrentOwner.current.getName();\n if (mapsAsChildrenOwnerName) {\n mapsAsChildrenAddendum = ' Check the render method of `' + mapsAsChildrenOwnerName + '`.';\n }\n }\n process.env.NODE_ENV !== 'production' ? warning(didWarnAboutMaps, 'Using Maps as children is not yet fully supported. It is an ' + 'experimental feature that might be removed. Convert it to a ' + 'sequence / iterable of keyed ReactElements instead.%s', mapsAsChildrenAddendum) : void 0;\n didWarnAboutMaps = true;\n }\n // Iterator will provide entry [k,v] tuples rather than values.\n while (!(step = iterator.next()).done) {\n var entry = step.value;\n if (entry) {\n child = entry[1];\n nextName = nextNamePrefix + KeyEscapeUtils.escape(entry[0]) + SUBSEPARATOR + getComponentKey(child, 0);\n subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);\n }\n }\n }\n } else if (type === 'object') {\n var addendum = '';\n if (process.env.NODE_ENV !== 'production') {\n addendum = ' If you meant to render a collection of children, use an array ' + 'instead or wrap the object using createFragment(object) from the ' + 'React add-ons.';\n if (children._isReactElement) {\n addendum = \" It looks like you're using an element created by a different \" + 'version of React. Make sure to use only one copy of React.';\n }\n if (ReactCurrentOwner.current) {\n var name = ReactCurrentOwner.current.getName();\n if (name) {\n addendum += ' Check the render method of `' + name + '`.';\n }\n }\n }\n var childrenString = String(children);\n !false ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Objects are not valid as a React child (found: %s).%s', childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString, addendum) : _prodInvariant('31', childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString, addendum) : void 0;\n }\n }\n\n return subtreeCount;\n}\n\n/**\n * Traverses children that are typically specified as `props.children`, but\n * might also be specified through attributes:\n *\n * - `traverseAllChildren(this.props.children, ...)`\n * - `traverseAllChildren(this.props.leftPanelChildren, ...)`\n *\n * The `traverseContext` is an optional argument that is passed through the\n * entire traversal. It can be used to store accumulations or anything else that\n * the callback might find relevant.\n *\n * @param {?*} children Children tree object.\n * @param {!function} callback To invoke upon traversing each child.\n * @param {?*} traverseContext Context for traversal.\n * @return {!number} The number of children in this subtree.\n */\nfunction traverseAllChildren(children, callback, traverseContext) {\n if (children == null) {\n return 0;\n }\n\n return traverseAllChildrenImpl(children, '', callback, traverseContext);\n}\n\nmodule.exports = traverseAllChildren;","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar _prodInvariant = require('./reactProdInvariant');\n\nvar invariant = require('fbjs/lib/invariant');\n\nvar genericComponentClass = null;\nvar textComponentClass = null;\n\nvar ReactHostComponentInjection = {\n // This accepts a class that receives the tag string. This is a catch all\n // that can render any kind of tag.\n injectGenericComponentClass: function (componentClass) {\n genericComponentClass = componentClass;\n },\n // This accepts a text component class that takes the text string to be\n // rendered as props.\n injectTextComponentClass: function (componentClass) {\n textComponentClass = componentClass;\n }\n};\n\n/**\n * Get a host internal component class for a specific tag.\n *\n * @param {ReactElement} element The element to create.\n * @return {function} The internal class constructor function.\n */\nfunction createInternalComponent(element) {\n !genericComponentClass ? process.env.NODE_ENV !== 'production' ? invariant(false, 'There is no registered component for the tag %s', element.type) : _prodInvariant('111', element.type) : void 0;\n return new genericComponentClass(element);\n}\n\n/**\n * @param {ReactText} text\n * @return {ReactComponent}\n */\nfunction createInstanceForText(text) {\n return new textComponentClass(text);\n}\n\n/**\n * @param {ReactComponent} component\n * @return {boolean}\n */\nfunction isTextComponent(component) {\n return component instanceof textComponentClass;\n}\n\nvar ReactHostComponent = {\n createInternalComponent: createInternalComponent,\n createInstanceForText: createInstanceForText,\n isTextComponent: isTextComponent,\n injection: ReactHostComponentInjection\n};\n\nmodule.exports = ReactHostComponent;","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar emptyComponentFactory;\n\nvar ReactEmptyComponentInjection = {\n injectEmptyComponentFactory: function (factory) {\n emptyComponentFactory = factory;\n }\n};\n\nvar ReactEmptyComponent = {\n create: function (instantiate) {\n return emptyComponentFactory(instantiate);\n }\n};\n\nReactEmptyComponent.injection = ReactEmptyComponentInjection;\n\nmodule.exports = ReactEmptyComponent;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar emptyObject = {};\n\nif (process.env.NODE_ENV !== 'production') {\n Object.freeze(emptyObject);\n}\n\nmodule.exports = emptyObject;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n */\n\n'use strict';\n\nvar _prodInvariant = require('./reactProdInvariant');\n\nvar React = require('react/lib/React');\n\nvar invariant = require('fbjs/lib/invariant');\n\nvar ReactNodeTypes = {\n HOST: 0,\n COMPOSITE: 1,\n EMPTY: 2,\n\n getType: function (node) {\n if (node === null || node === false) {\n return ReactNodeTypes.EMPTY;\n } else if (React.isValidElement(node)) {\n if (typeof node.type === 'function') {\n return ReactNodeTypes.COMPOSITE;\n } else {\n return ReactNodeTypes.HOST;\n }\n }\n !false ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Unexpected node: %s', node) : _prodInvariant('26', node) : void 0;\n }\n};\n\nmodule.exports = ReactNodeTypes;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar _prodInvariant = require('./reactProdInvariant'),\n _assign = require('object-assign');\n\nvar ReactCompositeComponent = require('./ReactCompositeComponent');\nvar ReactEmptyComponent = require('./ReactEmptyComponent');\nvar ReactHostComponent = require('./ReactHostComponent');\n\nvar getNextDebugID = require('react/lib/getNextDebugID');\nvar invariant = require('fbjs/lib/invariant');\nvar warning = require('fbjs/lib/warning');\n\n// To avoid a cyclic dependency, we create the final class in this module\nvar ReactCompositeComponentWrapper = function (element) {\n this.construct(element);\n};\n\nfunction getDeclarationErrorAddendum(owner) {\n if (owner) {\n var name = owner.getName();\n if (name) {\n return ' Check the render method of `' + name + '`.';\n }\n }\n return '';\n}\n\n/**\n * Check if the type reference is a known internal type. I.e. not a user\n * provided composite type.\n *\n * @param {function} type\n * @return {boolean} Returns true if this is a valid internal type.\n */\nfunction isInternalComponentType(type) {\n return typeof type === 'function' && typeof type.prototype !== 'undefined' && typeof type.prototype.mountComponent === 'function' && typeof type.prototype.receiveComponent === 'function';\n}\n\n/**\n * Given a ReactNode, create an instance that will actually be mounted.\n *\n * @param {ReactNode} node\n * @param {boolean} shouldHaveDebugID\n * @return {object} A new instance of the element's constructor.\n * @protected\n */\nfunction instantiateReactComponent(node, shouldHaveDebugID) {\n var instance;\n\n if (node === null || node === false) {\n instance = ReactEmptyComponent.create(instantiateReactComponent);\n } else if (typeof node === 'object') {\n var element = node;\n var type = element.type;\n if (typeof type !== 'function' && typeof type !== 'string') {\n var info = '';\n if (process.env.NODE_ENV !== 'production') {\n if (type === undefined || typeof type === 'object' && type !== null && Object.keys(type).length === 0) {\n info += ' You likely forgot to export your component from the file ' + \"it's defined in.\";\n }\n }\n info += getDeclarationErrorAddendum(element._owner);\n !false ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s', type == null ? type : typeof type, info) : _prodInvariant('130', type == null ? type : typeof type, info) : void 0;\n }\n\n // Special case string values\n if (typeof element.type === 'string') {\n instance = ReactHostComponent.createInternalComponent(element);\n } else if (isInternalComponentType(element.type)) {\n // This is temporarily available for custom components that are not string\n // representations. I.e. ART. Once those are updated to use the string\n // representation, we can drop this code path.\n instance = new element.type(element);\n\n // We renamed this. Allow the old name for compat. :(\n if (!instance.getHostNode) {\n instance.getHostNode = instance.getNativeNode;\n }\n } else {\n instance = new ReactCompositeComponentWrapper(element);\n }\n } else if (typeof node === 'string' || typeof node === 'number') {\n instance = ReactHostComponent.createInstanceForText(node);\n } else {\n !false ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Encountered invalid React node of type %s', typeof node) : _prodInvariant('131', typeof node) : void 0;\n }\n\n if (process.env.NODE_ENV !== 'production') {\n process.env.NODE_ENV !== 'production' ? warning(typeof instance.mountComponent === 'function' && typeof instance.receiveComponent === 'function' && typeof instance.getHostNode === 'function' && typeof instance.unmountComponent === 'function', 'Only React Components can be mounted.') : void 0;\n }\n\n // These two fields are used by the DOM and ART diffing algorithms\n // respectively. Instead of using expandos on components, we should be\n // storing the state needed by the diffing algorithms elsewhere.\n instance._mountIndex = 0;\n instance._mountImage = null;\n\n if (process.env.NODE_ENV !== 'production') {\n instance._debugID = shouldHaveDebugID ? getNextDebugID() : 0;\n }\n\n // Internal instances should fully constructed at this point, so they should\n // not get any new fields added to them at this point.\n if (process.env.NODE_ENV !== 'production') {\n if (Object.preventExtensions) {\n Object.preventExtensions(instance);\n }\n }\n\n return instance;\n}\n\n_assign(ReactCompositeComponentWrapper.prototype, ReactCompositeComponent, {\n _instantiateReactComponent: instantiateReactComponent\n});\n\nmodule.exports = instantiateReactComponent;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar _assign = require('object-assign');\n\nvar LinkedValueUtils = require('./LinkedValueUtils');\nvar ReactDOMComponentTree = require('./ReactDOMComponentTree');\nvar ReactUpdates = require('./ReactUpdates');\n\nvar warning = require('fbjs/lib/warning');\n\nvar didWarnValueLink = false;\nvar didWarnValueDefaultValue = false;\n\nfunction updateOptionsIfPendingUpdateAndMounted() {\n if (this._rootNodeID && this._wrapperState.pendingUpdate) {\n this._wrapperState.pendingUpdate = false;\n\n var props = this._currentElement.props;\n var value = LinkedValueUtils.getValue(props);\n\n if (value != null) {\n updateOptions(this, Boolean(props.multiple), value);\n }\n }\n}\n\nfunction getDeclarationErrorAddendum(owner) {\n if (owner) {\n var name = owner.getName();\n if (name) {\n return ' Check the render method of `' + name + '`.';\n }\n }\n return '';\n}\n\nvar valuePropNames = ['value', 'defaultValue'];\n\n/**\n * Validation function for `value` and `defaultValue`.\n * @private\n */\nfunction checkSelectPropTypes(inst, props) {\n var owner = inst._currentElement._owner;\n LinkedValueUtils.checkPropTypes('select', props, owner);\n\n if (props.valueLink !== undefined && !didWarnValueLink) {\n process.env.NODE_ENV !== 'production' ? warning(false, '`valueLink` prop on `select` is deprecated; set `value` and `onChange` instead.') : void 0;\n didWarnValueLink = true;\n }\n\n for (var i = 0; i < valuePropNames.length; i++) {\n var propName = valuePropNames[i];\n if (props[propName] == null) {\n continue;\n }\n var isArray = Array.isArray(props[propName]);\n if (props.multiple && !isArray) {\n process.env.NODE_ENV !== 'production' ? warning(false, 'The `%s` prop supplied to <select> must be an array if ' + '`multiple` is true.%s', propName, getDeclarationErrorAddendum(owner)) : void 0;\n } else if (!props.multiple && isArray) {\n process.env.NODE_ENV !== 'production' ? warning(false, 'The `%s` prop supplied to <select> must be a scalar ' + 'value if `multiple` is false.%s', propName, getDeclarationErrorAddendum(owner)) : void 0;\n }\n }\n}\n\n/**\n * @param {ReactDOMComponent} inst\n * @param {boolean} multiple\n * @param {*} propValue A stringable (with `multiple`, a list of stringables).\n * @private\n */\nfunction updateOptions(inst, multiple, propValue) {\n var selectedValue, i;\n var options = ReactDOMComponentTree.getNodeFromInstance(inst).options;\n\n if (multiple) {\n selectedValue = {};\n for (i = 0; i < propValue.length; i++) {\n selectedValue['' + propValue[i]] = true;\n }\n for (i = 0; i < options.length; i++) {\n var selected = selectedValue.hasOwnProperty(options[i].value);\n if (options[i].selected !== selected) {\n options[i].selected = selected;\n }\n }\n } else {\n // Do not set `select.value` as exact behavior isn't consistent across all\n // browsers for all cases.\n selectedValue = '' + propValue;\n for (i = 0; i < options.length; i++) {\n if (options[i].value === selectedValue) {\n options[i].selected = true;\n return;\n }\n }\n if (options.length) {\n options[0].selected = true;\n }\n }\n}\n\n/**\n * Implements a <select> host component that allows optionally setting the\n * props `value` and `defaultValue`. If `multiple` is false, the prop must be a\n * stringable. If `multiple` is true, the prop must be an array of stringables.\n *\n * If `value` is not supplied (or null/undefined), user actions that change the\n * selected option will trigger updates to the rendered options.\n *\n * If it is supplied (and not null/undefined), the rendered options will not\n * update in response to user actions. Instead, the `value` prop must change in\n * order for the rendered options to update.\n *\n * If `defaultValue` is provided, any options with the supplied values will be\n * selected.\n */\nvar ReactDOMSelect = {\n getHostProps: function (inst, props) {\n return _assign({}, props, {\n onChange: inst._wrapperState.onChange,\n value: undefined\n });\n },\n\n mountWrapper: function (inst, props) {\n if (process.env.NODE_ENV !== 'production') {\n checkSelectPropTypes(inst, props);\n }\n\n var value = LinkedValueUtils.getValue(props);\n inst._wrapperState = {\n pendingUpdate: false,\n initialValue: value != null ? value : props.defaultValue,\n listeners: null,\n onChange: _handleChange.bind(inst),\n wasMultiple: Boolean(props.multiple)\n };\n\n if (props.value !== undefined && props.defaultValue !== undefined && !didWarnValueDefaultValue) {\n process.env.NODE_ENV !== 'production' ? warning(false, 'Select elements must be either controlled or uncontrolled ' + '(specify either the value prop, or the defaultValue prop, but not ' + 'both). Decide between using a controlled or uncontrolled select ' + 'element and remove one of these props. More info: ' + 'https://fb.me/react-controlled-components') : void 0;\n didWarnValueDefaultValue = true;\n }\n },\n\n getSelectValueContext: function (inst) {\n // ReactDOMOption looks at this initial value so the initial generated\n // markup has correct `selected` attributes\n return inst._wrapperState.initialValue;\n },\n\n postUpdateWrapper: function (inst) {\n var props = inst._currentElement.props;\n\n // After the initial mount, we control selected-ness manually so don't pass\n // this value down\n inst._wrapperState.initialValue = undefined;\n\n var wasMultiple = inst._wrapperState.wasMultiple;\n inst._wrapperState.wasMultiple = Boolean(props.multiple);\n\n var value = LinkedValueUtils.getValue(props);\n if (value != null) {\n inst._wrapperState.pendingUpdate = false;\n updateOptions(inst, Boolean(props.multiple), value);\n } else if (wasMultiple !== Boolean(props.multiple)) {\n // For simplicity, reapply `defaultValue` if `multiple` is toggled.\n if (props.defaultValue != null) {\n updateOptions(inst, Boolean(props.multiple), props.defaultValue);\n } else {\n // Revert the select back to its default unselected state.\n updateOptions(inst, Boolean(props.multiple), props.multiple ? [] : '');\n }\n }\n }\n};\n\nfunction _handleChange(event) {\n var props = this._currentElement.props;\n var returnValue = LinkedValueUtils.executeOnChange(props, event);\n\n if (this._rootNodeID) {\n this._wrapperState.pendingUpdate = true;\n }\n ReactUpdates.asap(updateOptionsIfPendingUpdateAndMounted, this);\n return returnValue;\n}\n\nmodule.exports = ReactDOMSelect;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar DOMProperty = require('./DOMProperty');\nvar ReactDOMComponentTree = require('./ReactDOMComponentTree');\nvar ReactInstrumentation = require('./ReactInstrumentation');\n\nvar quoteAttributeValueForBrowser = require('./quoteAttributeValueForBrowser');\nvar warning = require('fbjs/lib/warning');\n\nvar VALID_ATTRIBUTE_NAME_REGEX = new RegExp('^[' + DOMProperty.ATTRIBUTE_NAME_START_CHAR + '][' + DOMProperty.ATTRIBUTE_NAME_CHAR + ']*$');\nvar illegalAttributeNameCache = {};\nvar validatedAttributeNameCache = {};\n\nfunction isAttributeNameSafe(attributeName) {\n if (validatedAttributeNameCache.hasOwnProperty(attributeName)) {\n return true;\n }\n if (illegalAttributeNameCache.hasOwnProperty(attributeName)) {\n return false;\n }\n if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) {\n validatedAttributeNameCache[attributeName] = true;\n return true;\n }\n illegalAttributeNameCache[attributeName] = true;\n process.env.NODE_ENV !== 'production' ? warning(false, 'Invalid attribute name: `%s`', attributeName) : void 0;\n return false;\n}\n\nfunction shouldIgnoreValue(propertyInfo, value) {\n return value == null || propertyInfo.hasBooleanValue && !value || propertyInfo.hasNumericValue && isNaN(value) || propertyInfo.hasPositiveNumericValue && value < 1 || propertyInfo.hasOverloadedBooleanValue && value === false;\n}\n\n/**\n * Operations for dealing with DOM properties.\n */\nvar DOMPropertyOperations = {\n /**\n * Creates markup for the ID property.\n *\n * @param {string} id Unescaped ID.\n * @return {string} Markup string.\n */\n createMarkupForID: function (id) {\n return DOMProperty.ID_ATTRIBUTE_NAME + '=' + quoteAttributeValueForBrowser(id);\n },\n\n setAttributeForID: function (node, id) {\n node.setAttribute(DOMProperty.ID_ATTRIBUTE_NAME, id);\n },\n\n createMarkupForRoot: function () {\n return DOMProperty.ROOT_ATTRIBUTE_NAME + '=\"\"';\n },\n\n setAttributeForRoot: function (node) {\n node.setAttribute(DOMProperty.ROOT_ATTRIBUTE_NAME, '');\n },\n\n /**\n * Creates markup for a property.\n *\n * @param {string} name\n * @param {*} value\n * @return {?string} Markup string, or null if the property was invalid.\n */\n createMarkupForProperty: function (name, value) {\n var propertyInfo = DOMProperty.properties.hasOwnProperty(name) ? DOMProperty.properties[name] : null;\n if (propertyInfo) {\n if (shouldIgnoreValue(propertyInfo, value)) {\n return '';\n }\n var attributeName = propertyInfo.attributeName;\n if (propertyInfo.hasBooleanValue || propertyInfo.hasOverloadedBooleanValue && value === true) {\n return attributeName + '=\"\"';\n }\n return attributeName + '=' + quoteAttributeValueForBrowser(value);\n } else if (DOMProperty.isCustomAttribute(name)) {\n if (value == null) {\n return '';\n }\n return name + '=' + quoteAttributeValueForBrowser(value);\n }\n return null;\n },\n\n /**\n * Creates markup for a custom property.\n *\n * @param {string} name\n * @param {*} value\n * @return {string} Markup string, or empty string if the property was invalid.\n */\n createMarkupForCustomAttribute: function (name, value) {\n if (!isAttributeNameSafe(name) || value == null) {\n return '';\n }\n return name + '=' + quoteAttributeValueForBrowser(value);\n },\n\n /**\n * Sets the value for a property on a node.\n *\n * @param {DOMElement} node\n * @param {string} name\n * @param {*} value\n */\n setValueForProperty: function (node, name, value) {\n var propertyInfo = DOMProperty.properties.hasOwnProperty(name) ? DOMProperty.properties[name] : null;\n if (propertyInfo) {\n var mutationMethod = propertyInfo.mutationMethod;\n if (mutationMethod) {\n mutationMethod(node, value);\n } else if (shouldIgnoreValue(propertyInfo, value)) {\n this.deleteValueForProperty(node, name);\n return;\n } else if (propertyInfo.mustUseProperty) {\n // Contrary to `setAttribute`, object properties are properly\n // `toString`ed by IE8/9.\n node[propertyInfo.propertyName] = value;\n } else {\n var attributeName = propertyInfo.attributeName;\n var namespace = propertyInfo.attributeNamespace;\n // `setAttribute` with objects becomes only `[object]` in IE8/9,\n // ('' + value) makes it output the correct toString()-value.\n if (namespace) {\n node.setAttributeNS(namespace, attributeName, '' + value);\n } else if (propertyInfo.hasBooleanValue || propertyInfo.hasOverloadedBooleanValue && value === true) {\n node.setAttribute(attributeName, '');\n } else {\n node.setAttribute(attributeName, '' + value);\n }\n }\n } else if (DOMProperty.isCustomAttribute(name)) {\n DOMPropertyOperations.setValueForAttribute(node, name, value);\n return;\n }\n\n if (process.env.NODE_ENV !== 'production') {\n var payload = {};\n payload[name] = value;\n ReactInstrumentation.debugTool.onHostOperation({\n instanceID: ReactDOMComponentTree.getInstanceFromNode(node)._debugID,\n type: 'update attribute',\n payload: payload\n });\n }\n },\n\n setValueForAttribute: function (node, name, value) {\n if (!isAttributeNameSafe(name)) {\n return;\n }\n if (value == null) {\n node.removeAttribute(name);\n } else {\n node.setAttribute(name, '' + value);\n }\n\n if (process.env.NODE_ENV !== 'production') {\n var payload = {};\n payload[name] = value;\n ReactInstrumentation.debugTool.onHostOperation({\n instanceID: ReactDOMComponentTree.getInstanceFromNode(node)._debugID,\n type: 'update attribute',\n payload: payload\n });\n }\n },\n\n /**\n * Deletes an attributes from a node.\n *\n * @param {DOMElement} node\n * @param {string} name\n */\n deleteValueForAttribute: function (node, name) {\n node.removeAttribute(name);\n if (process.env.NODE_ENV !== 'production') {\n ReactInstrumentation.debugTool.onHostOperation({\n instanceID: ReactDOMComponentTree.getInstanceFromNode(node)._debugID,\n type: 'remove attribute',\n payload: name\n });\n }\n },\n\n /**\n * Deletes the value for a property on a node.\n *\n * @param {DOMElement} node\n * @param {string} name\n */\n deleteValueForProperty: function (node, name) {\n var propertyInfo = DOMProperty.properties.hasOwnProperty(name) ? DOMProperty.properties[name] : null;\n if (propertyInfo) {\n var mutationMethod = propertyInfo.mutationMethod;\n if (mutationMethod) {\n mutationMethod(node, undefined);\n } else if (propertyInfo.mustUseProperty) {\n var propName = propertyInfo.propertyName;\n if (propertyInfo.hasBooleanValue) {\n node[propName] = false;\n } else {\n node[propName] = '';\n }\n } else {\n node.removeAttribute(propertyInfo.attributeName);\n }\n } else if (DOMProperty.isCustomAttribute(name)) {\n node.removeAttribute(name);\n }\n\n if (process.env.NODE_ENV !== 'production') {\n ReactInstrumentation.debugTool.onHostOperation({\n instanceID: ReactDOMComponentTree.getInstanceFromNode(node)._debugID,\n type: 'remove attribute',\n payload: name\n });\n }\n }\n};\n\nmodule.exports = DOMPropertyOperations;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\n/**\n * CSS properties which accept numbers but are not in units of \"px\".\n */\n\nvar isUnitlessNumber = {\n animationIterationCount: true,\n borderImageOutset: true,\n borderImageSlice: true,\n borderImageWidth: true,\n boxFlex: true,\n boxFlexGroup: true,\n boxOrdinalGroup: true,\n columnCount: true,\n columns: true,\n flex: true,\n flexGrow: true,\n flexPositive: true,\n flexShrink: true,\n flexNegative: true,\n flexOrder: true,\n gridRow: true,\n gridRowEnd: true,\n gridRowSpan: true,\n gridRowStart: true,\n gridColumn: true,\n gridColumnEnd: true,\n gridColumnSpan: true,\n gridColumnStart: true,\n fontWeight: true,\n lineClamp: true,\n lineHeight: true,\n opacity: true,\n order: true,\n orphans: true,\n tabSize: true,\n widows: true,\n zIndex: true,\n zoom: true,\n\n // SVG-related properties\n fillOpacity: true,\n floodOpacity: true,\n stopOpacity: true,\n strokeDasharray: true,\n strokeDashoffset: true,\n strokeMiterlimit: true,\n strokeOpacity: true,\n strokeWidth: true\n};\n\n/**\n * @param {string} prefix vendor-specific prefix, eg: Webkit\n * @param {string} key style name, eg: transitionDuration\n * @return {string} style name prefixed with `prefix`, properly camelCased, eg:\n * WebkitTransitionDuration\n */\nfunction prefixKey(prefix, key) {\n return prefix + key.charAt(0).toUpperCase() + key.substring(1);\n}\n\n/**\n * Support style names that may come passed in prefixed by adding permutations\n * of vendor prefixes.\n */\nvar prefixes = ['Webkit', 'ms', 'Moz', 'O'];\n\n// Using Object.keys here, or else the vanilla for-in loop makes IE8 go into an\n// infinite loop, because it iterates over the newly added props too.\nObject.keys(isUnitlessNumber).forEach(function (prop) {\n prefixes.forEach(function (prefix) {\n isUnitlessNumber[prefixKey(prefix, prop)] = isUnitlessNumber[prop];\n });\n});\n\n/**\n * Most style properties can be unset by doing .style[prop] = '' but IE8\n * doesn't like doing that with shorthand properties so for the properties that\n * IE8 breaks on, which are listed here, we instead unset each of the\n * individual properties. See http://bugs.jquery.com/ticket/12385.\n * The 4-value 'clock' properties like margin, padding, border-width seem to\n * behave without any problems. Curiously, list-style works too without any\n * special prodding.\n */\nvar shorthandPropertyExpansions = {\n background: {\n backgroundAttachment: true,\n backgroundColor: true,\n backgroundImage: true,\n backgroundPositionX: true,\n backgroundPositionY: true,\n backgroundRepeat: true\n },\n backgroundPosition: {\n backgroundPositionX: true,\n backgroundPositionY: true\n },\n border: {\n borderWidth: true,\n borderStyle: true,\n borderColor: true\n },\n borderBottom: {\n borderBottomWidth: true,\n borderBottomStyle: true,\n borderBottomColor: true\n },\n borderLeft: {\n borderLeftWidth: true,\n borderLeftStyle: true,\n borderLeftColor: true\n },\n borderRight: {\n borderRightWidth: true,\n borderRightStyle: true,\n borderRightColor: true\n },\n borderTop: {\n borderTopWidth: true,\n borderTopStyle: true,\n borderTopColor: true\n },\n font: {\n fontStyle: true,\n fontVariant: true,\n fontWeight: true,\n fontSize: true,\n lineHeight: true,\n fontFamily: true\n },\n outline: {\n outlineWidth: true,\n outlineStyle: true,\n outlineColor: true\n }\n};\n\nvar CSSProperty = {\n isUnitlessNumber: isUnitlessNumber,\n shorthandPropertyExpansions: shorthandPropertyExpansions\n};\n\nmodule.exports = CSSProperty;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\n/**\n * @param {DOMElement} node input/textarea to focus\n */\n\nfunction focusNode(node) {\n // IE8 can throw \"Can't move focus to the control because it is invisible,\n // not enabled, or of a type that does not accept the focus.\" for all kinds of\n // reasons that are too expensive and fragile to test.\n try {\n node.focus();\n } catch (e) {}\n}\n\nmodule.exports = focusNode;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar ExecutionEnvironment = require('fbjs/lib/ExecutionEnvironment');\nvar escapeTextContentForBrowser = require('./escapeTextContentForBrowser');\nvar setInnerHTML = require('./setInnerHTML');\n\n/**\n * Set the textContent property of a node, ensuring that whitespace is preserved\n * even in IE8. innerText is a poor substitute for textContent and, among many\n * issues, inserts <br> instead of the literal newline chars. innerHTML behaves\n * as it should.\n *\n * @param {DOMElement} node\n * @param {string} text\n * @internal\n */\nvar setTextContent = function (node, text) {\n if (text) {\n var firstChild = node.firstChild;\n\n if (firstChild && firstChild === node.lastChild && firstChild.nodeType === 3) {\n firstChild.nodeValue = text;\n return;\n }\n }\n node.textContent = text;\n};\n\nif (ExecutionEnvironment.canUseDOM) {\n if (!('textContent' in document.documentElement)) {\n setTextContent = function (node, text) {\n if (node.nodeType === 3) {\n node.nodeValue = text;\n return;\n }\n setInnerHTML(node, escapeTextContentForBrowser(text));\n };\n }\n}\n\nmodule.exports = setTextContent;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar ViewportMetrics = {\n currentScrollLeft: 0,\n\n currentScrollTop: 0,\n\n refreshScrollValues: function (scrollPosition) {\n ViewportMetrics.currentScrollLeft = scrollPosition.x;\n ViewportMetrics.currentScrollTop = scrollPosition.y;\n }\n};\n\nmodule.exports = ViewportMetrics;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n */\n\n'use strict';\n\n/**\n * @see http://www.whatwg.org/specs/web-apps/current-work/multipage/the-input-element.html#input-type-attr-summary\n */\n\nvar supportedInputTypes = {\n color: true,\n date: true,\n datetime: true,\n 'datetime-local': true,\n email: true,\n month: true,\n number: true,\n password: true,\n range: true,\n search: true,\n tel: true,\n text: true,\n time: true,\n url: true,\n week: true\n};\n\nfunction isTextInputElement(elem) {\n var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();\n\n if (nodeName === 'input') {\n return !!supportedInputTypes[elem.type];\n }\n\n if (nodeName === 'textarea') {\n return true;\n }\n\n return false;\n}\n\nmodule.exports = isTextInputElement;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar ReactDOMComponentTree = require('./ReactDOMComponentTree');\n\nfunction isCheckable(elem) {\n var type = elem.type;\n var nodeName = elem.nodeName;\n return nodeName && nodeName.toLowerCase() === 'input' && (type === 'checkbox' || type === 'radio');\n}\n\nfunction getTracker(inst) {\n return inst._wrapperState.valueTracker;\n}\n\nfunction attachTracker(inst, tracker) {\n inst._wrapperState.valueTracker = tracker;\n}\n\nfunction detachTracker(inst) {\n inst._wrapperState.valueTracker = null;\n}\n\nfunction getValueFromNode(node) {\n var value;\n if (node) {\n value = isCheckable(node) ? '' + node.checked : node.value;\n }\n return value;\n}\n\nvar inputValueTracking = {\n // exposed for testing\n _getTrackerFromNode: function (node) {\n return getTracker(ReactDOMComponentTree.getInstanceFromNode(node));\n },\n\n\n track: function (inst) {\n if (getTracker(inst)) {\n return;\n }\n\n var node = ReactDOMComponentTree.getNodeFromInstance(inst);\n var valueField = isCheckable(node) ? 'checked' : 'value';\n var descriptor = Object.getOwnPropertyDescriptor(node.constructor.prototype, valueField);\n\n var currentValue = '' + node[valueField];\n\n // if someone has already defined a value or Safari, then bail\n // and don't track value will cause over reporting of changes,\n // but it's better then a hard failure\n // (needed for certain tests that spyOn input values and Safari)\n if (node.hasOwnProperty(valueField) || typeof descriptor.get !== 'function' || typeof descriptor.set !== 'function') {\n return;\n }\n\n Object.defineProperty(node, valueField, {\n enumerable: descriptor.enumerable,\n configurable: true,\n get: function () {\n return descriptor.get.call(this);\n },\n set: function (value) {\n currentValue = '' + value;\n descriptor.set.call(this, value);\n }\n });\n\n attachTracker(inst, {\n getValue: function () {\n return currentValue;\n },\n setValue: function (value) {\n currentValue = '' + value;\n },\n stopTracking: function () {\n detachTracker(inst);\n delete node[valueField];\n }\n });\n },\n\n updateValueIfChanged: function (inst) {\n if (!inst) {\n return false;\n }\n var tracker = getTracker(inst);\n\n if (!tracker) {\n inputValueTracking.track(inst);\n return true;\n }\n\n var lastValue = tracker.getValue();\n var nextValue = getValueFromNode(ReactDOMComponentTree.getNodeFromInstance(inst));\n\n if (nextValue !== lastValue) {\n tracker.setValue(nextValue);\n return true;\n }\n\n return false;\n },\n stopTracking: function (inst) {\n var tracker = getTracker(inst);\n if (tracker) {\n tracker.stopTracking();\n }\n }\n};\n\nmodule.exports = inputValueTracking;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n */\n\n'use strict';\n\nvar ReactFeatureFlags = {\n // When true, call console.time() before and .timeEnd() after each top-level\n // render (both initial renders and updates). Useful when looking at prod-mode\n // timeline profiles in Chrome, for example.\n logTopLevelRenders: false\n};\n\nmodule.exports = ReactFeatureFlags;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n */\n\n'use strict';\n\nvar _prodInvariant = require('./reactProdInvariant');\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar PooledClass = require('./PooledClass');\n\nvar invariant = require('fbjs/lib/invariant');\n\n/**\n * A specialized pseudo-event module to help keep track of components waiting to\n * be notified when their DOM representations are available for use.\n *\n * This implements `PooledClass`, so you should never need to instantiate this.\n * Instead, use `CallbackQueue.getPooled()`.\n *\n * @class ReactMountReady\n * @implements PooledClass\n * @internal\n */\n\nvar CallbackQueue = function () {\n function CallbackQueue(arg) {\n _classCallCheck(this, CallbackQueue);\n\n this._callbacks = null;\n this._contexts = null;\n this._arg = arg;\n }\n\n /**\n * Enqueues a callback to be invoked when `notifyAll` is invoked.\n *\n * @param {function} callback Invoked when `notifyAll` is invoked.\n * @param {?object} context Context to call `callback` with.\n * @internal\n */\n\n\n CallbackQueue.prototype.enqueue = function enqueue(callback, context) {\n this._callbacks = this._callbacks || [];\n this._callbacks.push(callback);\n this._contexts = this._contexts || [];\n this._contexts.push(context);\n };\n\n /**\n * Invokes all enqueued callbacks and clears the queue. This is invoked after\n * the DOM representation of a component has been created or updated.\n *\n * @internal\n */\n\n\n CallbackQueue.prototype.notifyAll = function notifyAll() {\n var callbacks = this._callbacks;\n var contexts = this._contexts;\n var arg = this._arg;\n if (callbacks && contexts) {\n !(callbacks.length === contexts.length) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Mismatched list of contexts in callback queue') : _prodInvariant('24') : void 0;\n this._callbacks = null;\n this._contexts = null;\n for (var i = 0; i < callbacks.length; i++) {\n callbacks[i].call(contexts[i], arg);\n }\n callbacks.length = 0;\n contexts.length = 0;\n }\n };\n\n CallbackQueue.prototype.checkpoint = function checkpoint() {\n return this._callbacks ? this._callbacks.length : 0;\n };\n\n CallbackQueue.prototype.rollback = function rollback(len) {\n if (this._callbacks && this._contexts) {\n this._callbacks.length = len;\n this._contexts.length = len;\n }\n };\n\n /**\n * Resets the internal queue.\n *\n * @internal\n */\n\n\n CallbackQueue.prototype.reset = function reset() {\n this._callbacks = null;\n this._contexts = null;\n };\n\n /**\n * `PooledClass` looks for this.\n */\n\n\n CallbackQueue.prototype.destructor = function destructor() {\n this.reset();\n };\n\n return CallbackQueue;\n}();\n\nmodule.exports = PooledClass.addPoolingTo(CallbackQueue);","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar ExecutionEnvironment = require('fbjs/lib/ExecutionEnvironment');\n\nvar contentKey = null;\n\n/**\n * Gets the key used to access text content on a DOM node.\n *\n * @return {?string} Key used to access text content.\n * @internal\n */\nfunction getTextContentAccessor() {\n if (!contentKey && ExecutionEnvironment.canUseDOM) {\n // Prefer textContent to innerText because many browsers support both but\n // SVG <text> elements don't support innerText even when <div> does.\n contentKey = 'textContent' in document.documentElement ? 'textContent' : 'innerText';\n }\n return contentKey;\n}\n\nmodule.exports = getTextContentAccessor;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n */\n\n'use strict';\n\n/**\n * @param {array} arr an \"accumulation\" of items which is either an Array or\n * a single item. Useful when paired with the `accumulate` module. This is a\n * simple utility that allows us to reason about a collection of items, but\n * handling the case when there is exactly one item (and we do not need to\n * allocate an array).\n */\n\nfunction forEachAccumulated(arr, cb, scope) {\n if (Array.isArray(arr)) {\n arr.forEach(cb, scope);\n } else if (arr) {\n cb.call(scope, arr);\n }\n}\n\nmodule.exports = forEachAccumulated;","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n */\n\n'use strict';\n\nvar _prodInvariant = require('./reactProdInvariant');\n\nvar invariant = require('fbjs/lib/invariant');\n\n/**\n * Accumulates items that must not be null or undefined into the first one. This\n * is used to conserve memory by avoiding array allocations, and thus sacrifices\n * API cleanness. Since `current` can be null before being passed in and not\n * null after this function, make sure to assign it back to `current`:\n *\n * `a = accumulateInto(a, b);`\n *\n * This API should be sparingly used. Try `accumulate` for something cleaner.\n *\n * @return {*|array<*>} An accumulation of items.\n */\n\nfunction accumulateInto(current, next) {\n !(next != null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'accumulateInto(...): Accumulated items must not be null or undefined.') : _prodInvariant('30') : void 0;\n\n if (current == null) {\n return next;\n }\n\n // Both are not empty. Warning: Never call x.concat(y) when you are not\n // certain that x is an Array (x could be a string with concat method).\n if (Array.isArray(current)) {\n if (Array.isArray(next)) {\n current.push.apply(current, next);\n return current;\n }\n current.push(next);\n return current;\n }\n\n if (Array.isArray(next)) {\n // A bit too dangerous to mutate `next`.\n return [current].concat(next);\n }\n\n return [current, next];\n}\n\nmodule.exports = accumulateInto;","/**\n * Copyright (c) 2015-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar ReactDOMComponentFlags = {\n hasCachedChildNodes: 1 << 0\n};\n\nmodule.exports = ReactDOMComponentFlags;","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n */\n\n'use strict';\n\n// The Symbol used to tag the ReactElement type. If there is no native Symbol\n// nor polyfill, then a plain number is used for performance.\n\nvar REACT_ELEMENT_TYPE = typeof Symbol === 'function' && Symbol['for'] && Symbol['for']('react.element') || 0xeac7;\n\nmodule.exports = REACT_ELEMENT_TYPE;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar emptyObject = {};\n\nif (process.env.NODE_ENV !== 'production') {\n Object.freeze(emptyObject);\n}\n\nmodule.exports = emptyObject;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n */\n\n'use strict';\n\nvar canDefineProperty = false;\nif (process.env.NODE_ENV !== 'production') {\n try {\n // $FlowFixMe https://github.com/facebook/flow/issues/285\n Object.defineProperty({}, 'x', { get: function () {} });\n canDefineProperty = true;\n } catch (x) {\n // IE will fail on defineProperty\n }\n}\n\nmodule.exports = canDefineProperty;","/**\n * Copyright (c) 2015-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar warning = require('fbjs/lib/warning');\n\nfunction warnNoop(publicInstance, callerName) {\n if (process.env.NODE_ENV !== 'production') {\n var constructor = publicInstance.constructor;\n process.env.NODE_ENV !== 'production' ? warning(false, '%s(...): Can only update a mounted or mounting component. ' + 'This usually means you called %s() on an unmounted component. ' + 'This is a no-op. Please check the code for the %s component.', callerName, callerName, constructor && (constructor.displayName || constructor.name) || 'ReactClass') : void 0;\n }\n}\n\n/**\n * This is the abstract API for an update queue.\n */\nvar ReactNoopUpdateQueue = {\n /**\n * Checks whether or not this composite component is mounted.\n * @param {ReactClass} publicInstance The instance we want to test.\n * @return {boolean} True if mounted, false otherwise.\n * @protected\n * @final\n */\n isMounted: function (publicInstance) {\n return false;\n },\n\n /**\n * Enqueue a callback that will be executed after all the pending updates\n * have processed.\n *\n * @param {ReactClass} publicInstance The instance to use as `this` context.\n * @param {?function} callback Called after state is updated.\n * @internal\n */\n enqueueCallback: function (publicInstance, callback) {},\n\n /**\n * Forces an update. This should only be invoked when it is known with\n * certainty that we are **not** in a DOM transaction.\n *\n * You may want to call this when you know that some deeper aspect of the\n * component's state has changed but `setState` was not called.\n *\n * This will not invoke `shouldComponentUpdate`, but it will invoke\n * `componentWillUpdate` and `componentDidUpdate`.\n *\n * @param {ReactClass} publicInstance The instance that should rerender.\n * @internal\n */\n enqueueForceUpdate: function (publicInstance) {\n warnNoop(publicInstance, 'forceUpdate');\n },\n\n /**\n * Replaces all of the state. Always use this or `setState` to mutate state.\n * You should treat `this.state` as immutable.\n *\n * There is no guarantee that `this.state` will be immediately updated, so\n * accessing `this.state` after calling this method may return the old value.\n *\n * @param {ReactClass} publicInstance The instance that should rerender.\n * @param {object} completeState Next state.\n * @internal\n */\n enqueueReplaceState: function (publicInstance, completeState) {\n warnNoop(publicInstance, 'replaceState');\n },\n\n /**\n * Sets a subset of the state. This only exists because _pendingState is\n * internal. This provides a merging strategy that is not available to deep\n * properties which is confusing. TODO: Expose pendingState or don't use it\n * during the merge.\n *\n * @param {ReactClass} publicInstance The instance that should rerender.\n * @param {object} partialState Next partial state to be merged with state.\n * @internal\n */\n enqueueSetState: function (publicInstance, partialState) {\n warnNoop(publicInstance, 'setState');\n }\n};\n\nmodule.exports = ReactNoopUpdateQueue;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar _prodInvariant = require('./reactProdInvariant'),\n _assign = require('object-assign');\n\nvar ReactNoopUpdateQueue = require('./ReactNoopUpdateQueue');\n\nvar canDefineProperty = require('./canDefineProperty');\nvar emptyObject = require('fbjs/lib/emptyObject');\nvar invariant = require('fbjs/lib/invariant');\nvar lowPriorityWarning = require('./lowPriorityWarning');\n\n/**\n * Base class helpers for the updating state of a component.\n */\nfunction ReactComponent(props, context, updater) {\n this.props = props;\n this.context = context;\n this.refs = emptyObject;\n // We initialize the default updater but the real one gets injected by the\n // renderer.\n this.updater = updater || ReactNoopUpdateQueue;\n}\n\nReactComponent.prototype.isReactComponent = {};\n\n/**\n * Sets a subset of the state. Always use this to mutate\n * state. You should treat `this.state` as immutable.\n *\n * There is no guarantee that `this.state` will be immediately updated, so\n * accessing `this.state` after calling this method may return the old value.\n *\n * There is no guarantee that calls to `setState` will run synchronously,\n * as they may eventually be batched together. You can provide an optional\n * callback that will be executed when the call to setState is actually\n * completed.\n *\n * When a function is provided to setState, it will be called at some point in\n * the future (not synchronously). It will be called with the up to date\n * component arguments (state, props, context). These values can be different\n * from this.* because your function may be called after receiveProps but before\n * shouldComponentUpdate, and this new state, props, and context will not yet be\n * assigned to this.\n *\n * @param {object|function} partialState Next partial state or function to\n * produce next partial state to be merged with current state.\n * @param {?function} callback Called after state is updated.\n * @final\n * @protected\n */\nReactComponent.prototype.setState = function (partialState, callback) {\n !(typeof partialState === 'object' || typeof partialState === 'function' || partialState == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'setState(...): takes an object of state variables to update or a function which returns an object of state variables.') : _prodInvariant('85') : void 0;\n this.updater.enqueueSetState(this, partialState);\n if (callback) {\n this.updater.enqueueCallback(this, callback, 'setState');\n }\n};\n\n/**\n * Forces an update. This should only be invoked when it is known with\n * certainty that we are **not** in a DOM transaction.\n *\n * You may want to call this when you know that some deeper aspect of the\n * component's state has changed but `setState` was not called.\n *\n * This will not invoke `shouldComponentUpdate`, but it will invoke\n * `componentWillUpdate` and `componentDidUpdate`.\n *\n * @param {?function} callback Called after update is complete.\n * @final\n * @protected\n */\nReactComponent.prototype.forceUpdate = function (callback) {\n this.updater.enqueueForceUpdate(this);\n if (callback) {\n this.updater.enqueueCallback(this, callback, 'forceUpdate');\n }\n};\n\n/**\n * Deprecated APIs. These APIs used to exist on classic React classes but since\n * we would like to deprecate them, we're not going to move them over to this\n * modern base class. Instead, we define a getter that warns if it's accessed.\n */\nif (process.env.NODE_ENV !== 'production') {\n var deprecatedAPIs = {\n isMounted: ['isMounted', 'Instead, make sure to clean up subscriptions and pending requests in ' + 'componentWillUnmount to prevent memory leaks.'],\n replaceState: ['replaceState', 'Refactor your code to use setState instead (see ' + 'https://github.com/facebook/react/issues/3236).']\n };\n var defineDeprecationWarning = function (methodName, info) {\n if (canDefineProperty) {\n Object.defineProperty(ReactComponent.prototype, methodName, {\n get: function () {\n lowPriorityWarning(false, '%s(...) is deprecated in plain JavaScript React classes. %s', info[0], info[1]);\n return undefined;\n }\n });\n }\n };\n for (var fnName in deprecatedAPIs) {\n if (deprecatedAPIs.hasOwnProperty(fnName)) {\n defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);\n }\n }\n}\n\n/**\n * Base class helpers for the updating state of a component.\n */\nfunction ReactPureComponent(props, context, updater) {\n // Duplicated from ReactComponent.\n this.props = props;\n this.context = context;\n this.refs = emptyObject;\n // We initialize the default updater but the real one gets injected by the\n // renderer.\n this.updater = updater || ReactNoopUpdateQueue;\n}\n\nfunction ComponentDummy() {}\nComponentDummy.prototype = ReactComponent.prototype;\nReactPureComponent.prototype = new ComponentDummy();\nReactPureComponent.prototype.constructor = ReactPureComponent;\n// Avoid an extra prototype jump for these methods.\n_assign(ReactPureComponent.prototype, ReactComponent.prototype);\nReactPureComponent.prototype.isPureReactComponent = true;\n\nmodule.exports = {\n Component: ReactComponent,\n PureComponent: ReactPureComponent\n};","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar ReactMount = require('./ReactMount');\n\nmodule.exports = ReactMount.renderSubtreeIntoContainer;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar _prodInvariant = require('./reactProdInvariant');\n\nvar ReactCurrentOwner = require('react/lib/ReactCurrentOwner');\nvar ReactDOMComponentTree = require('./ReactDOMComponentTree');\nvar ReactInstanceMap = require('./ReactInstanceMap');\n\nvar getHostComponentFromComposite = require('./getHostComponentFromComposite');\nvar invariant = require('fbjs/lib/invariant');\nvar warning = require('fbjs/lib/warning');\n\n/**\n * Returns the DOM node rendered by this element.\n *\n * See https://facebook.github.io/react/docs/top-level-api.html#reactdom.finddomnode\n *\n * @param {ReactComponent|DOMElement} componentOrElement\n * @return {?DOMElement} The root node of this element.\n */\nfunction findDOMNode(componentOrElement) {\n if (process.env.NODE_ENV !== 'production') {\n var owner = ReactCurrentOwner.current;\n if (owner !== null) {\n process.env.NODE_ENV !== 'production' ? warning(owner._warnedAboutRefsInRender, '%s is accessing findDOMNode inside its render(). ' + 'render() should be a pure function of props and state. It should ' + 'never access something that requires stale data from the previous ' + 'render, such as refs. Move this logic to componentDidMount and ' + 'componentDidUpdate instead.', owner.getName() || 'A component') : void 0;\n owner._warnedAboutRefsInRender = true;\n }\n }\n if (componentOrElement == null) {\n return null;\n }\n if (componentOrElement.nodeType === 1) {\n return componentOrElement;\n }\n\n var inst = ReactInstanceMap.get(componentOrElement);\n if (inst) {\n inst = getHostComponentFromComposite(inst);\n return inst ? ReactDOMComponentTree.getNodeFromInstance(inst) : null;\n }\n\n if (typeof componentOrElement.render === 'function') {\n !false ? process.env.NODE_ENV !== 'production' ? invariant(false, 'findDOMNode was called on an unmounted component.') : _prodInvariant('44') : void 0;\n } else {\n !false ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Element appears to be neither ReactComponent nor DOMNode (keys: %s)', Object.keys(componentOrElement)) : _prodInvariant('45', Object.keys(componentOrElement)) : void 0;\n }\n}\n\nmodule.exports = findDOMNode;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nmodule.exports = '15.6.2';","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n */\n\n'use strict';\n\nvar MOD = 65521;\n\n// adler32 is not cryptographically strong, and is only used to sanity check that\n// markup generated on the server matches the markup generated on the client.\n// This implementation (a modified version of the SheetJS version) has been optimized\n// for our use case, at the expense of conforming to the adler32 specification\n// for non-ascii inputs.\nfunction adler32(data) {\n var a = 1;\n var b = 0;\n var i = 0;\n var l = data.length;\n var m = l & ~0x3;\n while (i < m) {\n var n = Math.min(i + 4096, m);\n for (; i < n; i += 4) {\n b += (a += data.charCodeAt(i)) + (a += data.charCodeAt(i + 1)) + (a += data.charCodeAt(i + 2)) + (a += data.charCodeAt(i + 3));\n }\n a %= MOD;\n b %= MOD;\n }\n for (; i < l; i++) {\n b += a += data.charCodeAt(i);\n }\n a %= MOD;\n b %= MOD;\n return a | b << 16;\n}\n\nmodule.exports = adler32;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar adler32 = require('./adler32');\n\nvar TAG_END = /\\/?>/;\nvar COMMENT_START = /^<\\!\\-\\-/;\n\nvar ReactMarkupChecksum = {\n CHECKSUM_ATTR_NAME: 'data-react-checksum',\n\n /**\n * @param {string} markup Markup string\n * @return {string} Markup string with checksum attribute attached\n */\n addChecksumToMarkup: function (markup) {\n var checksum = adler32(markup);\n\n // Add checksum (handle both parent tags, comments and self-closing tags)\n if (COMMENT_START.test(markup)) {\n return markup;\n } else {\n return markup.replace(TAG_END, ' ' + ReactMarkupChecksum.CHECKSUM_ATTR_NAME + '=\"' + checksum + '\"$&');\n }\n },\n\n /**\n * @param {string} markup to use\n * @param {DOMElement} element root React element\n * @returns {boolean} whether or not the markup is the same\n */\n canReuseMarkup: function (markup, element) {\n var existingChecksum = element.getAttribute(ReactMarkupChecksum.CHECKSUM_ATTR_NAME);\n existingChecksum = existingChecksum && parseInt(existingChecksum, 10);\n var markupChecksum = adler32(markup);\n return markupChecksum === existingChecksum;\n }\n};\n\nmodule.exports = ReactMarkupChecksum;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar ReactDOMFeatureFlags = {\n useCreateElement: true,\n useFiber: false\n};\n\nmodule.exports = ReactDOMFeatureFlags;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar validateDOMNesting = require('./validateDOMNesting');\n\nvar DOC_NODE_TYPE = 9;\n\nfunction ReactDOMContainerInfo(topLevelWrapper, node) {\n var info = {\n _topLevelWrapper: topLevelWrapper,\n _idCounter: 1,\n _ownerDocument: node ? node.nodeType === DOC_NODE_TYPE ? node : node.ownerDocument : null,\n _node: node,\n _tag: node ? node.nodeName.toLowerCase() : null,\n _namespaceURI: node ? node.namespaceURI : null\n };\n if (process.env.NODE_ENV !== 'production') {\n info._ancestorInfo = node ? validateDOMNesting.updatedAncestorInfo(null, info._tag, null) : null;\n }\n return info;\n}\n\nmodule.exports = ReactDOMContainerInfo;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar SyntheticMouseEvent = require('./SyntheticMouseEvent');\n\n/**\n * @interface WheelEvent\n * @see http://www.w3.org/TR/DOM-Level-3-Events/\n */\nvar WheelEventInterface = {\n deltaX: function (event) {\n return 'deltaX' in event ? event.deltaX : // Fallback to `wheelDeltaX` for Webkit and normalize (right is positive).\n 'wheelDeltaX' in event ? -event.wheelDeltaX : 0;\n },\n deltaY: function (event) {\n return 'deltaY' in event ? event.deltaY : // Fallback to `wheelDeltaY` for Webkit and normalize (down is positive).\n 'wheelDeltaY' in event ? -event.wheelDeltaY : // Fallback to `wheelDelta` for IE<9 and normalize (down is positive).\n 'wheelDelta' in event ? -event.wheelDelta : 0;\n },\n deltaZ: null,\n\n // Browsers without \"deltaMode\" is reporting in raw wheel delta where one\n // notch on the scroll is always +/- 120, roughly equivalent to pixels.\n // A good approximation of DOM_DELTA_LINE (1) is 5% of viewport size or\n // ~40 pixels, for DOM_DELTA_SCREEN (2) it is 87.5% of viewport size.\n deltaMode: null\n};\n\n/**\n * @param {object} dispatchConfig Configuration used to dispatch this event.\n * @param {string} dispatchMarker Marker identifying the event target.\n * @param {object} nativeEvent Native browser event.\n * @extends {SyntheticMouseEvent}\n */\nfunction SyntheticWheelEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {\n return SyntheticMouseEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);\n}\n\nSyntheticMouseEvent.augmentClass(SyntheticWheelEvent, WheelEventInterface);\n\nmodule.exports = SyntheticWheelEvent;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar SyntheticEvent = require('./SyntheticEvent');\n\n/**\n * @interface Event\n * @see http://www.w3.org/TR/2009/WD-css3-transitions-20090320/#transition-events-\n * @see https://developer.mozilla.org/en-US/docs/Web/API/TransitionEvent\n */\nvar TransitionEventInterface = {\n propertyName: null,\n elapsedTime: null,\n pseudoElement: null\n};\n\n/**\n * @param {object} dispatchConfig Configuration used to dispatch this event.\n * @param {string} dispatchMarker Marker identifying the event target.\n * @param {object} nativeEvent Native browser event.\n * @extends {SyntheticEvent}\n */\nfunction SyntheticTransitionEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {\n return SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);\n}\n\nSyntheticEvent.augmentClass(SyntheticTransitionEvent, TransitionEventInterface);\n\nmodule.exports = SyntheticTransitionEvent;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar SyntheticUIEvent = require('./SyntheticUIEvent');\n\nvar getEventModifierState = require('./getEventModifierState');\n\n/**\n * @interface TouchEvent\n * @see http://www.w3.org/TR/touch-events/\n */\nvar TouchEventInterface = {\n touches: null,\n targetTouches: null,\n changedTouches: null,\n altKey: null,\n metaKey: null,\n ctrlKey: null,\n shiftKey: null,\n getModifierState: getEventModifierState\n};\n\n/**\n * @param {object} dispatchConfig Configuration used to dispatch this event.\n * @param {string} dispatchMarker Marker identifying the event target.\n * @param {object} nativeEvent Native browser event.\n * @extends {SyntheticUIEvent}\n */\nfunction SyntheticTouchEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {\n return SyntheticUIEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);\n}\n\nSyntheticUIEvent.augmentClass(SyntheticTouchEvent, TouchEventInterface);\n\nmodule.exports = SyntheticTouchEvent;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar SyntheticMouseEvent = require('./SyntheticMouseEvent');\n\n/**\n * @interface DragEvent\n * @see http://www.w3.org/TR/DOM-Level-3-Events/\n */\nvar DragEventInterface = {\n dataTransfer: null\n};\n\n/**\n * @param {object} dispatchConfig Configuration used to dispatch this event.\n * @param {string} dispatchMarker Marker identifying the event target.\n * @param {object} nativeEvent Native browser event.\n * @extends {SyntheticUIEvent}\n */\nfunction SyntheticDragEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {\n return SyntheticMouseEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);\n}\n\nSyntheticMouseEvent.augmentClass(SyntheticDragEvent, DragEventInterface);\n\nmodule.exports = SyntheticDragEvent;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar getEventCharCode = require('./getEventCharCode');\n\n/**\n * Normalization of deprecated HTML5 `key` values\n * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names\n */\nvar normalizeKey = {\n Esc: 'Escape',\n Spacebar: ' ',\n Left: 'ArrowLeft',\n Up: 'ArrowUp',\n Right: 'ArrowRight',\n Down: 'ArrowDown',\n Del: 'Delete',\n Win: 'OS',\n Menu: 'ContextMenu',\n Apps: 'ContextMenu',\n Scroll: 'ScrollLock',\n MozPrintableKey: 'Unidentified'\n};\n\n/**\n * Translation from legacy `keyCode` to HTML5 `key`\n * Only special keys supported, all others depend on keyboard layout or browser\n * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names\n */\nvar translateToKey = {\n 8: 'Backspace',\n 9: 'Tab',\n 12: 'Clear',\n 13: 'Enter',\n 16: 'Shift',\n 17: 'Control',\n 18: 'Alt',\n 19: 'Pause',\n 20: 'CapsLock',\n 27: 'Escape',\n 32: ' ',\n 33: 'PageUp',\n 34: 'PageDown',\n 35: 'End',\n 36: 'Home',\n 37: 'ArrowLeft',\n 38: 'ArrowUp',\n 39: 'ArrowRight',\n 40: 'ArrowDown',\n 45: 'Insert',\n 46: 'Delete',\n 112: 'F1',\n 113: 'F2',\n 114: 'F3',\n 115: 'F4',\n 116: 'F5',\n 117: 'F6',\n 118: 'F7',\n 119: 'F8',\n 120: 'F9',\n 121: 'F10',\n 122: 'F11',\n 123: 'F12',\n 144: 'NumLock',\n 145: 'ScrollLock',\n 224: 'Meta'\n};\n\n/**\n * @param {object} nativeEvent Native browser event.\n * @return {string} Normalized `key` property.\n */\nfunction getEventKey(nativeEvent) {\n if (nativeEvent.key) {\n // Normalize inconsistent values reported by browsers due to\n // implementations of a working draft specification.\n\n // FireFox implements `key` but returns `MozPrintableKey` for all\n // printable characters (normalized to `Unidentified`), ignore it.\n var key = normalizeKey[nativeEvent.key] || nativeEvent.key;\n if (key !== 'Unidentified') {\n return key;\n }\n }\n\n // Browser does not implement `key`, polyfill as much of it as we can.\n if (nativeEvent.type === 'keypress') {\n var charCode = getEventCharCode(nativeEvent);\n\n // The enter-key is technically both printable and non-printable and can\n // thus be captured by `keypress`, no other non-printable key should.\n return charCode === 13 ? 'Enter' : String.fromCharCode(charCode);\n }\n if (nativeEvent.type === 'keydown' || nativeEvent.type === 'keyup') {\n // While user keyboard layout determines the actual meaning of each\n // `keyCode` value, almost all function keys have a universal value.\n return translateToKey[nativeEvent.keyCode] || 'Unidentified';\n }\n return '';\n}\n\nmodule.exports = getEventKey;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar SyntheticUIEvent = require('./SyntheticUIEvent');\n\nvar getEventCharCode = require('./getEventCharCode');\nvar getEventKey = require('./getEventKey');\nvar getEventModifierState = require('./getEventModifierState');\n\n/**\n * @interface KeyboardEvent\n * @see http://www.w3.org/TR/DOM-Level-3-Events/\n */\nvar KeyboardEventInterface = {\n key: getEventKey,\n location: null,\n ctrlKey: null,\n shiftKey: null,\n altKey: null,\n metaKey: null,\n repeat: null,\n locale: null,\n getModifierState: getEventModifierState,\n // Legacy Interface\n charCode: function (event) {\n // `charCode` is the result of a KeyPress event and represents the value of\n // the actual printable character.\n\n // KeyPress is deprecated, but its replacement is not yet final and not\n // implemented in any major browser. Only KeyPress has charCode.\n if (event.type === 'keypress') {\n return getEventCharCode(event);\n }\n return 0;\n },\n keyCode: function (event) {\n // `keyCode` is the result of a KeyDown/Up event and represents the value of\n // physical keyboard key.\n\n // The actual meaning of the value depends on the users' keyboard layout\n // which cannot be detected. Assuming that it is a US keyboard layout\n // provides a surprisingly accurate mapping for US and European users.\n // Due to this, it is left to the user to implement at this time.\n if (event.type === 'keydown' || event.type === 'keyup') {\n return event.keyCode;\n }\n return 0;\n },\n which: function (event) {\n // `which` is an alias for either `keyCode` or `charCode` depending on the\n // type of the event.\n if (event.type === 'keypress') {\n return getEventCharCode(event);\n }\n if (event.type === 'keydown' || event.type === 'keyup') {\n return event.keyCode;\n }\n return 0;\n }\n};\n\n/**\n * @param {object} dispatchConfig Configuration used to dispatch this event.\n * @param {string} dispatchMarker Marker identifying the event target.\n * @param {object} nativeEvent Native browser event.\n * @extends {SyntheticUIEvent}\n */\nfunction SyntheticKeyboardEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {\n return SyntheticUIEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);\n}\n\nSyntheticUIEvent.augmentClass(SyntheticKeyboardEvent, KeyboardEventInterface);\n\nmodule.exports = SyntheticKeyboardEvent;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar SyntheticUIEvent = require('./SyntheticUIEvent');\n\n/**\n * @interface FocusEvent\n * @see http://www.w3.org/TR/DOM-Level-3-Events/\n */\nvar FocusEventInterface = {\n relatedTarget: null\n};\n\n/**\n * @param {object} dispatchConfig Configuration used to dispatch this event.\n * @param {string} dispatchMarker Marker identifying the event target.\n * @param {object} nativeEvent Native browser event.\n * @extends {SyntheticUIEvent}\n */\nfunction SyntheticFocusEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {\n return SyntheticUIEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);\n}\n\nSyntheticUIEvent.augmentClass(SyntheticFocusEvent, FocusEventInterface);\n\nmodule.exports = SyntheticFocusEvent;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar SyntheticEvent = require('./SyntheticEvent');\n\n/**\n * @interface Event\n * @see http://www.w3.org/TR/clipboard-apis/\n */\nvar ClipboardEventInterface = {\n clipboardData: function (event) {\n return 'clipboardData' in event ? event.clipboardData : window.clipboardData;\n }\n};\n\n/**\n * @param {object} dispatchConfig Configuration used to dispatch this event.\n * @param {string} dispatchMarker Marker identifying the event target.\n * @param {object} nativeEvent Native browser event.\n * @extends {SyntheticUIEvent}\n */\nfunction SyntheticClipboardEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {\n return SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);\n}\n\nSyntheticEvent.augmentClass(SyntheticClipboardEvent, ClipboardEventInterface);\n\nmodule.exports = SyntheticClipboardEvent;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar SyntheticEvent = require('./SyntheticEvent');\n\n/**\n * @interface Event\n * @see http://www.w3.org/TR/css3-animations/#AnimationEvent-interface\n * @see https://developer.mozilla.org/en-US/docs/Web/API/AnimationEvent\n */\nvar AnimationEventInterface = {\n animationName: null,\n elapsedTime: null,\n pseudoElement: null\n};\n\n/**\n * @param {object} dispatchConfig Configuration used to dispatch this event.\n * @param {string} dispatchMarker Marker identifying the event target.\n * @param {object} nativeEvent Native browser event.\n * @extends {SyntheticEvent}\n */\nfunction SyntheticAnimationEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {\n return SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);\n}\n\nSyntheticEvent.augmentClass(SyntheticAnimationEvent, AnimationEventInterface);\n\nmodule.exports = SyntheticAnimationEvent;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n */\n\n'use strict';\n\nvar _prodInvariant = require('./reactProdInvariant');\n\nvar EventListener = require('fbjs/lib/EventListener');\nvar EventPropagators = require('./EventPropagators');\nvar ReactDOMComponentTree = require('./ReactDOMComponentTree');\nvar SyntheticAnimationEvent = require('./SyntheticAnimationEvent');\nvar SyntheticClipboardEvent = require('./SyntheticClipboardEvent');\nvar SyntheticEvent = require('./SyntheticEvent');\nvar SyntheticFocusEvent = require('./SyntheticFocusEvent');\nvar SyntheticKeyboardEvent = require('./SyntheticKeyboardEvent');\nvar SyntheticMouseEvent = require('./SyntheticMouseEvent');\nvar SyntheticDragEvent = require('./SyntheticDragEvent');\nvar SyntheticTouchEvent = require('./SyntheticTouchEvent');\nvar SyntheticTransitionEvent = require('./SyntheticTransitionEvent');\nvar SyntheticUIEvent = require('./SyntheticUIEvent');\nvar SyntheticWheelEvent = require('./SyntheticWheelEvent');\n\nvar emptyFunction = require('fbjs/lib/emptyFunction');\nvar getEventCharCode = require('./getEventCharCode');\nvar invariant = require('fbjs/lib/invariant');\n\n/**\n * Turns\n * ['abort', ...]\n * into\n * eventTypes = {\n * 'abort': {\n * phasedRegistrationNames: {\n * bubbled: 'onAbort',\n * captured: 'onAbortCapture',\n * },\n * dependencies: ['topAbort'],\n * },\n * ...\n * };\n * topLevelEventsToDispatchConfig = {\n * 'topAbort': { sameConfig }\n * };\n */\nvar eventTypes = {};\nvar topLevelEventsToDispatchConfig = {};\n['abort', 'animationEnd', 'animationIteration', 'animationStart', 'blur', 'canPlay', 'canPlayThrough', 'click', 'contextMenu', 'copy', 'cut', 'doubleClick', 'drag', 'dragEnd', 'dragEnter', 'dragExit', 'dragLeave', 'dragOver', 'dragStart', 'drop', 'durationChange', 'emptied', 'encrypted', 'ended', 'error', 'focus', 'input', 'invalid', 'keyDown', 'keyPress', 'keyUp', 'load', 'loadedData', 'loadedMetadata', 'loadStart', 'mouseDown', 'mouseMove', 'mouseOut', 'mouseOver', 'mouseUp', 'paste', 'pause', 'play', 'playing', 'progress', 'rateChange', 'reset', 'scroll', 'seeked', 'seeking', 'stalled', 'submit', 'suspend', 'timeUpdate', 'touchCancel', 'touchEnd', 'touchMove', 'touchStart', 'transitionEnd', 'volumeChange', 'waiting', 'wheel'].forEach(function (event) {\n var capitalizedEvent = event[0].toUpperCase() + event.slice(1);\n var onEvent = 'on' + capitalizedEvent;\n var topEvent = 'top' + capitalizedEvent;\n\n var type = {\n phasedRegistrationNames: {\n bubbled: onEvent,\n captured: onEvent + 'Capture'\n },\n dependencies: [topEvent]\n };\n eventTypes[event] = type;\n topLevelEventsToDispatchConfig[topEvent] = type;\n});\n\nvar onClickListeners = {};\n\nfunction getDictionaryKey(inst) {\n // Prevents V8 performance issue:\n // https://github.com/facebook/react/pull/7232\n return '.' + inst._rootNodeID;\n}\n\nfunction isInteractive(tag) {\n return tag === 'button' || tag === 'input' || tag === 'select' || tag === 'textarea';\n}\n\nvar SimpleEventPlugin = {\n eventTypes: eventTypes,\n\n extractEvents: function (topLevelType, targetInst, nativeEvent, nativeEventTarget) {\n var dispatchConfig = topLevelEventsToDispatchConfig[topLevelType];\n if (!dispatchConfig) {\n return null;\n }\n var EventConstructor;\n switch (topLevelType) {\n case 'topAbort':\n case 'topCanPlay':\n case 'topCanPlayThrough':\n case 'topDurationChange':\n case 'topEmptied':\n case 'topEncrypted':\n case 'topEnded':\n case 'topError':\n case 'topInput':\n case 'topInvalid':\n case 'topLoad':\n case 'topLoadedData':\n case 'topLoadedMetadata':\n case 'topLoadStart':\n case 'topPause':\n case 'topPlay':\n case 'topPlaying':\n case 'topProgress':\n case 'topRateChange':\n case 'topReset':\n case 'topSeeked':\n case 'topSeeking':\n case 'topStalled':\n case 'topSubmit':\n case 'topSuspend':\n case 'topTimeUpdate':\n case 'topVolumeChange':\n case 'topWaiting':\n // HTML Events\n // @see http://www.w3.org/TR/html5/index.html#events-0\n EventConstructor = SyntheticEvent;\n break;\n case 'topKeyPress':\n // Firefox creates a keypress event for function keys too. This removes\n // the unwanted keypress events. Enter is however both printable and\n // non-printable. One would expect Tab to be as well (but it isn't).\n if (getEventCharCode(nativeEvent) === 0) {\n return null;\n }\n /* falls through */\n case 'topKeyDown':\n case 'topKeyUp':\n EventConstructor = SyntheticKeyboardEvent;\n break;\n case 'topBlur':\n case 'topFocus':\n EventConstructor = SyntheticFocusEvent;\n break;\n case 'topClick':\n // Firefox creates a click event on right mouse clicks. This removes the\n // unwanted click events.\n if (nativeEvent.button === 2) {\n return null;\n }\n /* falls through */\n case 'topDoubleClick':\n case 'topMouseDown':\n case 'topMouseMove':\n case 'topMouseUp':\n // TODO: Disabled elements should not respond to mouse events\n /* falls through */\n case 'topMouseOut':\n case 'topMouseOver':\n case 'topContextMenu':\n EventConstructor = SyntheticMouseEvent;\n break;\n case 'topDrag':\n case 'topDragEnd':\n case 'topDragEnter':\n case 'topDragExit':\n case 'topDragLeave':\n case 'topDragOver':\n case 'topDragStart':\n case 'topDrop':\n EventConstructor = SyntheticDragEvent;\n break;\n case 'topTouchCancel':\n case 'topTouchEnd':\n case 'topTouchMove':\n case 'topTouchStart':\n EventConstructor = SyntheticTouchEvent;\n break;\n case 'topAnimationEnd':\n case 'topAnimationIteration':\n case 'topAnimationStart':\n EventConstructor = SyntheticAnimationEvent;\n break;\n case 'topTransitionEnd':\n EventConstructor = SyntheticTransitionEvent;\n break;\n case 'topScroll':\n EventConstructor = SyntheticUIEvent;\n break;\n case 'topWheel':\n EventConstructor = SyntheticWheelEvent;\n break;\n case 'topCopy':\n case 'topCut':\n case 'topPaste':\n EventConstructor = SyntheticClipboardEvent;\n break;\n }\n !EventConstructor ? process.env.NODE_ENV !== 'production' ? invariant(false, 'SimpleEventPlugin: Unhandled event type, `%s`.', topLevelType) : _prodInvariant('86', topLevelType) : void 0;\n var event = EventConstructor.getPooled(dispatchConfig, targetInst, nativeEvent, nativeEventTarget);\n EventPropagators.accumulateTwoPhaseDispatches(event);\n return event;\n },\n\n didPutListener: function (inst, registrationName, listener) {\n // Mobile Safari does not fire properly bubble click events on\n // non-interactive elements, which means delegated click listeners do not\n // fire. The workaround for this bug involves attaching an empty click\n // listener on the target node.\n // http://www.quirksmode.org/blog/archives/2010/09/click_event_del.html\n if (registrationName === 'onClick' && !isInteractive(inst._tag)) {\n var key = getDictionaryKey(inst);\n var node = ReactDOMComponentTree.getNodeFromInstance(inst);\n if (!onClickListeners[key]) {\n onClickListeners[key] = EventListener.listen(node, 'click', emptyFunction);\n }\n }\n },\n\n willDeleteListener: function (inst, registrationName) {\n if (registrationName === 'onClick' && !isInteractive(inst._tag)) {\n var key = getDictionaryKey(inst);\n onClickListeners[key].remove();\n delete onClickListeners[key];\n }\n }\n};\n\nmodule.exports = SimpleEventPlugin;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar EventPropagators = require('./EventPropagators');\nvar ExecutionEnvironment = require('fbjs/lib/ExecutionEnvironment');\nvar ReactDOMComponentTree = require('./ReactDOMComponentTree');\nvar ReactInputSelection = require('./ReactInputSelection');\nvar SyntheticEvent = require('./SyntheticEvent');\n\nvar getActiveElement = require('fbjs/lib/getActiveElement');\nvar isTextInputElement = require('./isTextInputElement');\nvar shallowEqual = require('fbjs/lib/shallowEqual');\n\nvar skipSelectionChangeEvent = ExecutionEnvironment.canUseDOM && 'documentMode' in document && document.documentMode <= 11;\n\nvar eventTypes = {\n select: {\n phasedRegistrationNames: {\n bubbled: 'onSelect',\n captured: 'onSelectCapture'\n },\n dependencies: ['topBlur', 'topContextMenu', 'topFocus', 'topKeyDown', 'topKeyUp', 'topMouseDown', 'topMouseUp', 'topSelectionChange']\n }\n};\n\nvar activeElement = null;\nvar activeElementInst = null;\nvar lastSelection = null;\nvar mouseDown = false;\n\n// Track whether a listener exists for this plugin. If none exist, we do\n// not extract events. See #3639.\nvar hasListener = false;\n\n/**\n * Get an object which is a unique representation of the current selection.\n *\n * The return value will not be consistent across nodes or browsers, but\n * two identical selections on the same node will return identical objects.\n *\n * @param {DOMElement} node\n * @return {object}\n */\nfunction getSelection(node) {\n if ('selectionStart' in node && ReactInputSelection.hasSelectionCapabilities(node)) {\n return {\n start: node.selectionStart,\n end: node.selectionEnd\n };\n } else if (window.getSelection) {\n var selection = window.getSelection();\n return {\n anchorNode: selection.anchorNode,\n anchorOffset: selection.anchorOffset,\n focusNode: selection.focusNode,\n focusOffset: selection.focusOffset\n };\n } else if (document.selection) {\n var range = document.selection.createRange();\n return {\n parentElement: range.parentElement(),\n text: range.text,\n top: range.boundingTop,\n left: range.boundingLeft\n };\n }\n}\n\n/**\n * Poll selection to see whether it's changed.\n *\n * @param {object} nativeEvent\n * @return {?SyntheticEvent}\n */\nfunction constructSelectEvent(nativeEvent, nativeEventTarget) {\n // Ensure we have the right element, and that the user is not dragging a\n // selection (this matches native `select` event behavior). In HTML5, select\n // fires only on input and textarea thus if there's no focused element we\n // won't dispatch.\n if (mouseDown || activeElement == null || activeElement !== getActiveElement()) {\n return null;\n }\n\n // Only fire when selection has actually changed.\n var currentSelection = getSelection(activeElement);\n if (!lastSelection || !shallowEqual(lastSelection, currentSelection)) {\n lastSelection = currentSelection;\n\n var syntheticEvent = SyntheticEvent.getPooled(eventTypes.select, activeElementInst, nativeEvent, nativeEventTarget);\n\n syntheticEvent.type = 'select';\n syntheticEvent.target = activeElement;\n\n EventPropagators.accumulateTwoPhaseDispatches(syntheticEvent);\n\n return syntheticEvent;\n }\n\n return null;\n}\n\n/**\n * This plugin creates an `onSelect` event that normalizes select events\n * across form elements.\n *\n * Supported elements are:\n * - input (see `isTextInputElement`)\n * - textarea\n * - contentEditable\n *\n * This differs from native browser implementations in the following ways:\n * - Fires on contentEditable fields as well as inputs.\n * - Fires for collapsed selection.\n * - Fires after user input.\n */\nvar SelectEventPlugin = {\n eventTypes: eventTypes,\n\n extractEvents: function (topLevelType, targetInst, nativeEvent, nativeEventTarget) {\n if (!hasListener) {\n return null;\n }\n\n var targetNode = targetInst ? ReactDOMComponentTree.getNodeFromInstance(targetInst) : window;\n\n switch (topLevelType) {\n // Track the input node that has focus.\n case 'topFocus':\n if (isTextInputElement(targetNode) || targetNode.contentEditable === 'true') {\n activeElement = targetNode;\n activeElementInst = targetInst;\n lastSelection = null;\n }\n break;\n case 'topBlur':\n activeElement = null;\n activeElementInst = null;\n lastSelection = null;\n break;\n // Don't fire the event while the user is dragging. This matches the\n // semantics of the native select event.\n case 'topMouseDown':\n mouseDown = true;\n break;\n case 'topContextMenu':\n case 'topMouseUp':\n mouseDown = false;\n return constructSelectEvent(nativeEvent, nativeEventTarget);\n // Chrome and IE fire non-standard event when selection is changed (and\n // sometimes when it hasn't). IE's event fires out of order with respect\n // to key and input events on deletion, so we discard it.\n //\n // Firefox doesn't support selectionchange, so check selection status\n // after each key entry. The selection changes after keydown and before\n // keyup, but we check on keydown as well in the case of holding down a\n // key, when multiple keydown events are fired but only one keyup is.\n // This is also our approach for IE handling, for the reason above.\n case 'topSelectionChange':\n if (skipSelectionChangeEvent) {\n break;\n }\n // falls through\n case 'topKeyDown':\n case 'topKeyUp':\n return constructSelectEvent(nativeEvent, nativeEventTarget);\n }\n\n return null;\n },\n\n didPutListener: function (inst, registrationName, listener) {\n if (registrationName === 'onSelect') {\n hasListener = true;\n }\n }\n};\n\nmodule.exports = SelectEventPlugin;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar NS = {\n xlink: 'http://www.w3.org/1999/xlink',\n xml: 'http://www.w3.org/XML/1998/namespace'\n};\n\n// We use attributes for everything SVG so let's avoid some duplication and run\n// code instead.\n// The following are all specified in the HTML config already so we exclude here.\n// - class (as className)\n// - color\n// - height\n// - id\n// - lang\n// - max\n// - media\n// - method\n// - min\n// - name\n// - style\n// - target\n// - type\n// - width\nvar ATTRS = {\n accentHeight: 'accent-height',\n accumulate: 0,\n additive: 0,\n alignmentBaseline: 'alignment-baseline',\n allowReorder: 'allowReorder',\n alphabetic: 0,\n amplitude: 0,\n arabicForm: 'arabic-form',\n ascent: 0,\n attributeName: 'attributeName',\n attributeType: 'attributeType',\n autoReverse: 'autoReverse',\n azimuth: 0,\n baseFrequency: 'baseFrequency',\n baseProfile: 'baseProfile',\n baselineShift: 'baseline-shift',\n bbox: 0,\n begin: 0,\n bias: 0,\n by: 0,\n calcMode: 'calcMode',\n capHeight: 'cap-height',\n clip: 0,\n clipPath: 'clip-path',\n clipRule: 'clip-rule',\n clipPathUnits: 'clipPathUnits',\n colorInterpolation: 'color-interpolation',\n colorInterpolationFilters: 'color-interpolation-filters',\n colorProfile: 'color-profile',\n colorRendering: 'color-rendering',\n contentScriptType: 'contentScriptType',\n contentStyleType: 'contentStyleType',\n cursor: 0,\n cx: 0,\n cy: 0,\n d: 0,\n decelerate: 0,\n descent: 0,\n diffuseConstant: 'diffuseConstant',\n direction: 0,\n display: 0,\n divisor: 0,\n dominantBaseline: 'dominant-baseline',\n dur: 0,\n dx: 0,\n dy: 0,\n edgeMode: 'edgeMode',\n elevation: 0,\n enableBackground: 'enable-background',\n end: 0,\n exponent: 0,\n externalResourcesRequired: 'externalResourcesRequired',\n fill: 0,\n fillOpacity: 'fill-opacity',\n fillRule: 'fill-rule',\n filter: 0,\n filterRes: 'filterRes',\n filterUnits: 'filterUnits',\n floodColor: 'flood-color',\n floodOpacity: 'flood-opacity',\n focusable: 0,\n fontFamily: 'font-family',\n fontSize: 'font-size',\n fontSizeAdjust: 'font-size-adjust',\n fontStretch: 'font-stretch',\n fontStyle: 'font-style',\n fontVariant: 'font-variant',\n fontWeight: 'font-weight',\n format: 0,\n from: 0,\n fx: 0,\n fy: 0,\n g1: 0,\n g2: 0,\n glyphName: 'glyph-name',\n glyphOrientationHorizontal: 'glyph-orientation-horizontal',\n glyphOrientationVertical: 'glyph-orientation-vertical',\n glyphRef: 'glyphRef',\n gradientTransform: 'gradientTransform',\n gradientUnits: 'gradientUnits',\n hanging: 0,\n horizAdvX: 'horiz-adv-x',\n horizOriginX: 'horiz-origin-x',\n ideographic: 0,\n imageRendering: 'image-rendering',\n 'in': 0,\n in2: 0,\n intercept: 0,\n k: 0,\n k1: 0,\n k2: 0,\n k3: 0,\n k4: 0,\n kernelMatrix: 'kernelMatrix',\n kernelUnitLength: 'kernelUnitLength',\n kerning: 0,\n keyPoints: 'keyPoints',\n keySplines: 'keySplines',\n keyTimes: 'keyTimes',\n lengthAdjust: 'lengthAdjust',\n letterSpacing: 'letter-spacing',\n lightingColor: 'lighting-color',\n limitingConeAngle: 'limitingConeAngle',\n local: 0,\n markerEnd: 'marker-end',\n markerMid: 'marker-mid',\n markerStart: 'marker-start',\n markerHeight: 'markerHeight',\n markerUnits: 'markerUnits',\n markerWidth: 'markerWidth',\n mask: 0,\n maskContentUnits: 'maskContentUnits',\n maskUnits: 'maskUnits',\n mathematical: 0,\n mode: 0,\n numOctaves: 'numOctaves',\n offset: 0,\n opacity: 0,\n operator: 0,\n order: 0,\n orient: 0,\n orientation: 0,\n origin: 0,\n overflow: 0,\n overlinePosition: 'overline-position',\n overlineThickness: 'overline-thickness',\n paintOrder: 'paint-order',\n panose1: 'panose-1',\n pathLength: 'pathLength',\n patternContentUnits: 'patternContentUnits',\n patternTransform: 'patternTransform',\n patternUnits: 'patternUnits',\n pointerEvents: 'pointer-events',\n points: 0,\n pointsAtX: 'pointsAtX',\n pointsAtY: 'pointsAtY',\n pointsAtZ: 'pointsAtZ',\n preserveAlpha: 'preserveAlpha',\n preserveAspectRatio: 'preserveAspectRatio',\n primitiveUnits: 'primitiveUnits',\n r: 0,\n radius: 0,\n refX: 'refX',\n refY: 'refY',\n renderingIntent: 'rendering-intent',\n repeatCount: 'repeatCount',\n repeatDur: 'repeatDur',\n requiredExtensions: 'requiredExtensions',\n requiredFeatures: 'requiredFeatures',\n restart: 0,\n result: 0,\n rotate: 0,\n rx: 0,\n ry: 0,\n scale: 0,\n seed: 0,\n shapeRendering: 'shape-rendering',\n slope: 0,\n spacing: 0,\n specularConstant: 'specularConstant',\n specularExponent: 'specularExponent',\n speed: 0,\n spreadMethod: 'spreadMethod',\n startOffset: 'startOffset',\n stdDeviation: 'stdDeviation',\n stemh: 0,\n stemv: 0,\n stitchTiles: 'stitchTiles',\n stopColor: 'stop-color',\n stopOpacity: 'stop-opacity',\n strikethroughPosition: 'strikethrough-position',\n strikethroughThickness: 'strikethrough-thickness',\n string: 0,\n stroke: 0,\n strokeDasharray: 'stroke-dasharray',\n strokeDashoffset: 'stroke-dashoffset',\n strokeLinecap: 'stroke-linecap',\n strokeLinejoin: 'stroke-linejoin',\n strokeMiterlimit: 'stroke-miterlimit',\n strokeOpacity: 'stroke-opacity',\n strokeWidth: 'stroke-width',\n surfaceScale: 'surfaceScale',\n systemLanguage: 'systemLanguage',\n tableValues: 'tableValues',\n targetX: 'targetX',\n targetY: 'targetY',\n textAnchor: 'text-anchor',\n textDecoration: 'text-decoration',\n textRendering: 'text-rendering',\n textLength: 'textLength',\n to: 0,\n transform: 0,\n u1: 0,\n u2: 0,\n underlinePosition: 'underline-position',\n underlineThickness: 'underline-thickness',\n unicode: 0,\n unicodeBidi: 'unicode-bidi',\n unicodeRange: 'unicode-range',\n unitsPerEm: 'units-per-em',\n vAlphabetic: 'v-alphabetic',\n vHanging: 'v-hanging',\n vIdeographic: 'v-ideographic',\n vMathematical: 'v-mathematical',\n values: 0,\n vectorEffect: 'vector-effect',\n version: 0,\n vertAdvY: 'vert-adv-y',\n vertOriginX: 'vert-origin-x',\n vertOriginY: 'vert-origin-y',\n viewBox: 'viewBox',\n viewTarget: 'viewTarget',\n visibility: 0,\n widths: 0,\n wordSpacing: 'word-spacing',\n writingMode: 'writing-mode',\n x: 0,\n xHeight: 'x-height',\n x1: 0,\n x2: 0,\n xChannelSelector: 'xChannelSelector',\n xlinkActuate: 'xlink:actuate',\n xlinkArcrole: 'xlink:arcrole',\n xlinkHref: 'xlink:href',\n xlinkRole: 'xlink:role',\n xlinkShow: 'xlink:show',\n xlinkTitle: 'xlink:title',\n xlinkType: 'xlink:type',\n xmlBase: 'xml:base',\n xmlns: 0,\n xmlnsXlink: 'xmlns:xlink',\n xmlLang: 'xml:lang',\n xmlSpace: 'xml:space',\n y: 0,\n y1: 0,\n y2: 0,\n yChannelSelector: 'yChannelSelector',\n z: 0,\n zoomAndPan: 'zoomAndPan'\n};\n\nvar SVGDOMPropertyConfig = {\n Properties: {},\n DOMAttributeNamespaces: {\n xlinkActuate: NS.xlink,\n xlinkArcrole: NS.xlink,\n xlinkHref: NS.xlink,\n xlinkRole: NS.xlink,\n xlinkShow: NS.xlink,\n xlinkTitle: NS.xlink,\n xlinkType: NS.xlink,\n xmlBase: NS.xml,\n xmlLang: NS.xml,\n xmlSpace: NS.xml\n },\n DOMAttributeNames: {}\n};\n\nObject.keys(ATTRS).forEach(function (key) {\n SVGDOMPropertyConfig.Properties[key] = 0;\n if (ATTRS[key]) {\n SVGDOMPropertyConfig.DOMAttributeNames[key] = ATTRS[key];\n }\n});\n\nmodule.exports = SVGDOMPropertyConfig;","'use strict';\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\n/**\n * @param {*} object The object to check.\n * @return {boolean} Whether or not the object is a DOM node.\n */\nfunction isNode(object) {\n var doc = object ? object.ownerDocument || object : document;\n var defaultView = doc.defaultView || window;\n return !!(object && (typeof defaultView.Node === 'function' ? object instanceof defaultView.Node : typeof object === 'object' && typeof object.nodeType === 'number' && typeof object.nodeName === 'string'));\n}\n\nmodule.exports = isNode;","'use strict';\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\nvar isNode = require('./isNode');\n\n/**\n * @param {*} object The object to check.\n * @return {boolean} Whether or not the object is a DOM text node.\n */\nfunction isTextNode(object) {\n return isNode(object) && object.nodeType == 3;\n}\n\nmodule.exports = isTextNode;","'use strict';\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n */\n\nvar isTextNode = require('./isTextNode');\n\n/*eslint-disable no-bitwise */\n\n/**\n * Checks if a given DOM node contains or is another DOM node.\n */\nfunction containsNode(outerNode, innerNode) {\n if (!outerNode || !innerNode) {\n return false;\n } else if (outerNode === innerNode) {\n return true;\n } else if (isTextNode(outerNode)) {\n return false;\n } else if (isTextNode(innerNode)) {\n return containsNode(outerNode, innerNode.parentNode);\n } else if ('contains' in outerNode) {\n return outerNode.contains(innerNode);\n } else if (outerNode.compareDocumentPosition) {\n return !!(outerNode.compareDocumentPosition(innerNode) & 16);\n } else {\n return false;\n }\n}\n\nmodule.exports = containsNode;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\n/**\n * Given any node return the first leaf node without children.\n *\n * @param {DOMElement|DOMTextNode} node\n * @return {DOMElement|DOMTextNode}\n */\n\nfunction getLeafNode(node) {\n while (node && node.firstChild) {\n node = node.firstChild;\n }\n return node;\n}\n\n/**\n * Get the next sibling within a container. This will walk up the\n * DOM if a node's siblings have been exhausted.\n *\n * @param {DOMElement|DOMTextNode} node\n * @return {?DOMElement|DOMTextNode}\n */\nfunction getSiblingNode(node) {\n while (node) {\n if (node.nextSibling) {\n return node.nextSibling;\n }\n node = node.parentNode;\n }\n}\n\n/**\n * Get object describing the nodes which contain characters at offset.\n *\n * @param {DOMElement|DOMTextNode} root\n * @param {number} offset\n * @return {?object}\n */\nfunction getNodeForCharacterOffset(root, offset) {\n var node = getLeafNode(root);\n var nodeStart = 0;\n var nodeEnd = 0;\n\n while (node) {\n if (node.nodeType === 3) {\n nodeEnd = nodeStart + node.textContent.length;\n\n if (nodeStart <= offset && nodeEnd >= offset) {\n return {\n node: node,\n offset: offset - nodeStart\n };\n }\n\n nodeStart = nodeEnd;\n }\n\n node = getLeafNode(getSiblingNode(node));\n }\n}\n\nmodule.exports = getNodeForCharacterOffset;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar ExecutionEnvironment = require('fbjs/lib/ExecutionEnvironment');\n\nvar getNodeForCharacterOffset = require('./getNodeForCharacterOffset');\nvar getTextContentAccessor = require('./getTextContentAccessor');\n\n/**\n * While `isCollapsed` is available on the Selection object and `collapsed`\n * is available on the Range object, IE11 sometimes gets them wrong.\n * If the anchor/focus nodes and offsets are the same, the range is collapsed.\n */\nfunction isCollapsed(anchorNode, anchorOffset, focusNode, focusOffset) {\n return anchorNode === focusNode && anchorOffset === focusOffset;\n}\n\n/**\n * Get the appropriate anchor and focus node/offset pairs for IE.\n *\n * The catch here is that IE's selection API doesn't provide information\n * about whether the selection is forward or backward, so we have to\n * behave as though it's always forward.\n *\n * IE text differs from modern selection in that it behaves as though\n * block elements end with a new line. This means character offsets will\n * differ between the two APIs.\n *\n * @param {DOMElement} node\n * @return {object}\n */\nfunction getIEOffsets(node) {\n var selection = document.selection;\n var selectedRange = selection.createRange();\n var selectedLength = selectedRange.text.length;\n\n // Duplicate selection so we can move range without breaking user selection.\n var fromStart = selectedRange.duplicate();\n fromStart.moveToElementText(node);\n fromStart.setEndPoint('EndToStart', selectedRange);\n\n var startOffset = fromStart.text.length;\n var endOffset = startOffset + selectedLength;\n\n return {\n start: startOffset,\n end: endOffset\n };\n}\n\n/**\n * @param {DOMElement} node\n * @return {?object}\n */\nfunction getModernOffsets(node) {\n var selection = window.getSelection && window.getSelection();\n\n if (!selection || selection.rangeCount === 0) {\n return null;\n }\n\n var anchorNode = selection.anchorNode;\n var anchorOffset = selection.anchorOffset;\n var focusNode = selection.focusNode;\n var focusOffset = selection.focusOffset;\n\n var currentRange = selection.getRangeAt(0);\n\n // In Firefox, range.startContainer and range.endContainer can be \"anonymous\n // divs\", e.g. the up/down buttons on an <input type=\"number\">. Anonymous\n // divs do not seem to expose properties, triggering a \"Permission denied\n // error\" if any of its properties are accessed. The only seemingly possible\n // way to avoid erroring is to access a property that typically works for\n // non-anonymous divs and catch any error that may otherwise arise. See\n // https://bugzilla.mozilla.org/show_bug.cgi?id=208427\n try {\n /* eslint-disable no-unused-expressions */\n currentRange.startContainer.nodeType;\n currentRange.endContainer.nodeType;\n /* eslint-enable no-unused-expressions */\n } catch (e) {\n return null;\n }\n\n // If the node and offset values are the same, the selection is collapsed.\n // `Selection.isCollapsed` is available natively, but IE sometimes gets\n // this value wrong.\n var isSelectionCollapsed = isCollapsed(selection.anchorNode, selection.anchorOffset, selection.focusNode, selection.focusOffset);\n\n var rangeLength = isSelectionCollapsed ? 0 : currentRange.toString().length;\n\n var tempRange = currentRange.cloneRange();\n tempRange.selectNodeContents(node);\n tempRange.setEnd(currentRange.startContainer, currentRange.startOffset);\n\n var isTempRangeCollapsed = isCollapsed(tempRange.startContainer, tempRange.startOffset, tempRange.endContainer, tempRange.endOffset);\n\n var start = isTempRangeCollapsed ? 0 : tempRange.toString().length;\n var end = start + rangeLength;\n\n // Detect whether the selection is backward.\n var detectionRange = document.createRange();\n detectionRange.setStart(anchorNode, anchorOffset);\n detectionRange.setEnd(focusNode, focusOffset);\n var isBackward = detectionRange.collapsed;\n\n return {\n start: isBackward ? end : start,\n end: isBackward ? start : end\n };\n}\n\n/**\n * @param {DOMElement|DOMTextNode} node\n * @param {object} offsets\n */\nfunction setIEOffsets(node, offsets) {\n var range = document.selection.createRange().duplicate();\n var start, end;\n\n if (offsets.end === undefined) {\n start = offsets.start;\n end = start;\n } else if (offsets.start > offsets.end) {\n start = offsets.end;\n end = offsets.start;\n } else {\n start = offsets.start;\n end = offsets.end;\n }\n\n range.moveToElementText(node);\n range.moveStart('character', start);\n range.setEndPoint('EndToStart', range);\n range.moveEnd('character', end - start);\n range.select();\n}\n\n/**\n * In modern non-IE browsers, we can support both forward and backward\n * selections.\n *\n * Note: IE10+ supports the Selection object, but it does not support\n * the `extend` method, which means that even in modern IE, it's not possible\n * to programmatically create a backward selection. Thus, for all IE\n * versions, we use the old IE API to create our selections.\n *\n * @param {DOMElement|DOMTextNode} node\n * @param {object} offsets\n */\nfunction setModernOffsets(node, offsets) {\n if (!window.getSelection) {\n return;\n }\n\n var selection = window.getSelection();\n var length = node[getTextContentAccessor()].length;\n var start = Math.min(offsets.start, length);\n var end = offsets.end === undefined ? start : Math.min(offsets.end, length);\n\n // IE 11 uses modern selection, but doesn't support the extend method.\n // Flip backward selections, so we can set with a single range.\n if (!selection.extend && start > end) {\n var temp = end;\n end = start;\n start = temp;\n }\n\n var startMarker = getNodeForCharacterOffset(node, start);\n var endMarker = getNodeForCharacterOffset(node, end);\n\n if (startMarker && endMarker) {\n var range = document.createRange();\n range.setStart(startMarker.node, startMarker.offset);\n selection.removeAllRanges();\n\n if (start > end) {\n selection.addRange(range);\n selection.extend(endMarker.node, endMarker.offset);\n } else {\n range.setEnd(endMarker.node, endMarker.offset);\n selection.addRange(range);\n }\n }\n}\n\nvar useIEOffsets = ExecutionEnvironment.canUseDOM && 'selection' in document && !('getSelection' in window);\n\nvar ReactDOMSelection = {\n /**\n * @param {DOMElement} node\n */\n getOffsets: useIEOffsets ? getIEOffsets : getModernOffsets,\n\n /**\n * @param {DOMElement|DOMTextNode} node\n * @param {object} offsets\n */\n setOffsets: useIEOffsets ? setIEOffsets : setModernOffsets\n};\n\nmodule.exports = ReactDOMSelection;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar _assign = require('object-assign');\n\nvar CallbackQueue = require('./CallbackQueue');\nvar PooledClass = require('./PooledClass');\nvar ReactBrowserEventEmitter = require('./ReactBrowserEventEmitter');\nvar ReactInputSelection = require('./ReactInputSelection');\nvar ReactInstrumentation = require('./ReactInstrumentation');\nvar Transaction = require('./Transaction');\nvar ReactUpdateQueue = require('./ReactUpdateQueue');\n\n/**\n * Ensures that, when possible, the selection range (currently selected text\n * input) is not disturbed by performing the transaction.\n */\nvar SELECTION_RESTORATION = {\n /**\n * @return {Selection} Selection information.\n */\n initialize: ReactInputSelection.getSelectionInformation,\n /**\n * @param {Selection} sel Selection information returned from `initialize`.\n */\n close: ReactInputSelection.restoreSelection\n};\n\n/**\n * Suppresses events (blur/focus) that could be inadvertently dispatched due to\n * high level DOM manipulations (like temporarily removing a text input from the\n * DOM).\n */\nvar EVENT_SUPPRESSION = {\n /**\n * @return {boolean} The enabled status of `ReactBrowserEventEmitter` before\n * the reconciliation.\n */\n initialize: function () {\n var currentlyEnabled = ReactBrowserEventEmitter.isEnabled();\n ReactBrowserEventEmitter.setEnabled(false);\n return currentlyEnabled;\n },\n\n /**\n * @param {boolean} previouslyEnabled Enabled status of\n * `ReactBrowserEventEmitter` before the reconciliation occurred. `close`\n * restores the previous value.\n */\n close: function (previouslyEnabled) {\n ReactBrowserEventEmitter.setEnabled(previouslyEnabled);\n }\n};\n\n/**\n * Provides a queue for collecting `componentDidMount` and\n * `componentDidUpdate` callbacks during the transaction.\n */\nvar ON_DOM_READY_QUEUEING = {\n /**\n * Initializes the internal `onDOMReady` queue.\n */\n initialize: function () {\n this.reactMountReady.reset();\n },\n\n /**\n * After DOM is flushed, invoke all registered `onDOMReady` callbacks.\n */\n close: function () {\n this.reactMountReady.notifyAll();\n }\n};\n\n/**\n * Executed within the scope of the `Transaction` instance. Consider these as\n * being member methods, but with an implied ordering while being isolated from\n * each other.\n */\nvar TRANSACTION_WRAPPERS = [SELECTION_RESTORATION, EVENT_SUPPRESSION, ON_DOM_READY_QUEUEING];\n\nif (process.env.NODE_ENV !== 'production') {\n TRANSACTION_WRAPPERS.push({\n initialize: ReactInstrumentation.debugTool.onBeginFlush,\n close: ReactInstrumentation.debugTool.onEndFlush\n });\n}\n\n/**\n * Currently:\n * - The order that these are listed in the transaction is critical:\n * - Suppresses events.\n * - Restores selection range.\n *\n * Future:\n * - Restore document/overflow scroll positions that were unintentionally\n * modified via DOM insertions above the top viewport boundary.\n * - Implement/integrate with customized constraint based layout system and keep\n * track of which dimensions must be remeasured.\n *\n * @class ReactReconcileTransaction\n */\nfunction ReactReconcileTransaction(useCreateElement) {\n this.reinitializeTransaction();\n // Only server-side rendering really needs this option (see\n // `ReactServerRendering`), but server-side uses\n // `ReactServerRenderingTransaction` instead. This option is here so that it's\n // accessible and defaults to false when `ReactDOMComponent` and\n // `ReactDOMTextComponent` checks it in `mountComponent`.`\n this.renderToStaticMarkup = false;\n this.reactMountReady = CallbackQueue.getPooled(null);\n this.useCreateElement = useCreateElement;\n}\n\nvar Mixin = {\n /**\n * @see Transaction\n * @abstract\n * @final\n * @return {array<object>} List of operation wrap procedures.\n * TODO: convert to array<TransactionWrapper>\n */\n getTransactionWrappers: function () {\n return TRANSACTION_WRAPPERS;\n },\n\n /**\n * @return {object} The queue to collect `onDOMReady` callbacks with.\n */\n getReactMountReady: function () {\n return this.reactMountReady;\n },\n\n /**\n * @return {object} The queue to collect React async events.\n */\n getUpdateQueue: function () {\n return ReactUpdateQueue;\n },\n\n /**\n * Save current transaction state -- if the return value from this method is\n * passed to `rollback`, the transaction will be reset to that state.\n */\n checkpoint: function () {\n // reactMountReady is the our only stateful wrapper\n return this.reactMountReady.checkpoint();\n },\n\n rollback: function (checkpoint) {\n this.reactMountReady.rollback(checkpoint);\n },\n\n /**\n * `PooledClass` looks for this, and will invoke this before allowing this\n * instance to be reused.\n */\n destructor: function () {\n CallbackQueue.release(this.reactMountReady);\n this.reactMountReady = null;\n }\n};\n\n_assign(ReactReconcileTransaction.prototype, Transaction, Mixin);\n\nPooledClass.addPoolingTo(ReactReconcileTransaction);\n\nmodule.exports = ReactReconcileTransaction;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar DOMProperty = require('./DOMProperty');\nvar EventPluginHub = require('./EventPluginHub');\nvar EventPluginUtils = require('./EventPluginUtils');\nvar ReactComponentEnvironment = require('./ReactComponentEnvironment');\nvar ReactEmptyComponent = require('./ReactEmptyComponent');\nvar ReactBrowserEventEmitter = require('./ReactBrowserEventEmitter');\nvar ReactHostComponent = require('./ReactHostComponent');\nvar ReactUpdates = require('./ReactUpdates');\n\nvar ReactInjection = {\n Component: ReactComponentEnvironment.injection,\n DOMProperty: DOMProperty.injection,\n EmptyComponent: ReactEmptyComponent.injection,\n EventPluginHub: EventPluginHub.injection,\n EventPluginUtils: EventPluginUtils.injection,\n EventEmitter: ReactBrowserEventEmitter.injection,\n HostComponent: ReactHostComponent.injection,\n Updates: ReactUpdates.injection\n};\n\nmodule.exports = ReactInjection;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\n'use strict';\n\n/**\n * Gets the scroll position of the supplied element or window.\n *\n * The return values are unbounded, unlike `getScrollPosition`. This means they\n * may be negative or exceed the element boundaries (which is possible using\n * inertial scrolling).\n *\n * @param {DOMWindow|DOMElement} scrollable\n * @return {object} Map with `x` and `y` keys.\n */\n\nfunction getUnboundedScrollPosition(scrollable) {\n if (scrollable.Window && scrollable instanceof scrollable.Window) {\n return {\n x: scrollable.pageXOffset || scrollable.document.documentElement.scrollLeft,\n y: scrollable.pageYOffset || scrollable.document.documentElement.scrollTop\n };\n }\n return {\n x: scrollable.scrollLeft,\n y: scrollable.scrollTop\n };\n}\n\nmodule.exports = getUnboundedScrollPosition;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar _assign = require('object-assign');\n\nvar EventListener = require('fbjs/lib/EventListener');\nvar ExecutionEnvironment = require('fbjs/lib/ExecutionEnvironment');\nvar PooledClass = require('./PooledClass');\nvar ReactDOMComponentTree = require('./ReactDOMComponentTree');\nvar ReactUpdates = require('./ReactUpdates');\n\nvar getEventTarget = require('./getEventTarget');\nvar getUnboundedScrollPosition = require('fbjs/lib/getUnboundedScrollPosition');\n\n/**\n * Find the deepest React component completely containing the root of the\n * passed-in instance (for use when entire React trees are nested within each\n * other). If React trees are not nested, returns null.\n */\nfunction findParent(inst) {\n // TODO: It may be a good idea to cache this to prevent unnecessary DOM\n // traversal, but caching is difficult to do correctly without using a\n // mutation observer to listen for all DOM changes.\n while (inst._hostParent) {\n inst = inst._hostParent;\n }\n var rootNode = ReactDOMComponentTree.getNodeFromInstance(inst);\n var container = rootNode.parentNode;\n return ReactDOMComponentTree.getClosestInstanceFromNode(container);\n}\n\n// Used to store ancestor hierarchy in top level callback\nfunction TopLevelCallbackBookKeeping(topLevelType, nativeEvent) {\n this.topLevelType = topLevelType;\n this.nativeEvent = nativeEvent;\n this.ancestors = [];\n}\n_assign(TopLevelCallbackBookKeeping.prototype, {\n destructor: function () {\n this.topLevelType = null;\n this.nativeEvent = null;\n this.ancestors.length = 0;\n }\n});\nPooledClass.addPoolingTo(TopLevelCallbackBookKeeping, PooledClass.twoArgumentPooler);\n\nfunction handleTopLevelImpl(bookKeeping) {\n var nativeEventTarget = getEventTarget(bookKeeping.nativeEvent);\n var targetInst = ReactDOMComponentTree.getClosestInstanceFromNode(nativeEventTarget);\n\n // Loop through the hierarchy, in case there's any nested components.\n // It's important that we build the array of ancestors before calling any\n // event handlers, because event handlers can modify the DOM, leading to\n // inconsistencies with ReactMount's node cache. See #1105.\n var ancestor = targetInst;\n do {\n bookKeeping.ancestors.push(ancestor);\n ancestor = ancestor && findParent(ancestor);\n } while (ancestor);\n\n for (var i = 0; i < bookKeeping.ancestors.length; i++) {\n targetInst = bookKeeping.ancestors[i];\n ReactEventListener._handleTopLevel(bookKeeping.topLevelType, targetInst, bookKeeping.nativeEvent, getEventTarget(bookKeeping.nativeEvent));\n }\n}\n\nfunction scrollValueMonitor(cb) {\n var scrollPosition = getUnboundedScrollPosition(window);\n cb(scrollPosition);\n}\n\nvar ReactEventListener = {\n _enabled: true,\n _handleTopLevel: null,\n\n WINDOW_HANDLE: ExecutionEnvironment.canUseDOM ? window : null,\n\n setHandleTopLevel: function (handleTopLevel) {\n ReactEventListener._handleTopLevel = handleTopLevel;\n },\n\n setEnabled: function (enabled) {\n ReactEventListener._enabled = !!enabled;\n },\n\n isEnabled: function () {\n return ReactEventListener._enabled;\n },\n\n /**\n * Traps top-level events by using event bubbling.\n *\n * @param {string} topLevelType Record from `EventConstants`.\n * @param {string} handlerBaseName Event name (e.g. \"click\").\n * @param {object} element Element on which to attach listener.\n * @return {?object} An object with a remove function which will forcefully\n * remove the listener.\n * @internal\n */\n trapBubbledEvent: function (topLevelType, handlerBaseName, element) {\n if (!element) {\n return null;\n }\n return EventListener.listen(element, handlerBaseName, ReactEventListener.dispatchEvent.bind(null, topLevelType));\n },\n\n /**\n * Traps a top-level event by using event capturing.\n *\n * @param {string} topLevelType Record from `EventConstants`.\n * @param {string} handlerBaseName Event name (e.g. \"click\").\n * @param {object} element Element on which to attach listener.\n * @return {?object} An object with a remove function which will forcefully\n * remove the listener.\n * @internal\n */\n trapCapturedEvent: function (topLevelType, handlerBaseName, element) {\n if (!element) {\n return null;\n }\n return EventListener.capture(element, handlerBaseName, ReactEventListener.dispatchEvent.bind(null, topLevelType));\n },\n\n monitorScrollValue: function (refresh) {\n var callback = scrollValueMonitor.bind(null, refresh);\n EventListener.listen(window, 'scroll', callback);\n },\n\n dispatchEvent: function (topLevelType, nativeEvent) {\n if (!ReactEventListener._enabled) {\n return;\n }\n\n var bookKeeping = TopLevelCallbackBookKeeping.getPooled(topLevelType, nativeEvent);\n try {\n // Event queue being processed in the same cycle allows\n // `preventDefault`.\n ReactUpdates.batchedUpdates(handleTopLevelImpl, bookKeeping);\n } finally {\n TopLevelCallbackBookKeeping.release(bookKeeping);\n }\n }\n};\n\nmodule.exports = ReactEventListener;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar _assign = require('object-assign');\n\nvar ReactUpdates = require('./ReactUpdates');\nvar Transaction = require('./Transaction');\n\nvar emptyFunction = require('fbjs/lib/emptyFunction');\n\nvar RESET_BATCHED_UPDATES = {\n initialize: emptyFunction,\n close: function () {\n ReactDefaultBatchingStrategy.isBatchingUpdates = false;\n }\n};\n\nvar FLUSH_BATCHED_UPDATES = {\n initialize: emptyFunction,\n close: ReactUpdates.flushBatchedUpdates.bind(ReactUpdates)\n};\n\nvar TRANSACTION_WRAPPERS = [FLUSH_BATCHED_UPDATES, RESET_BATCHED_UPDATES];\n\nfunction ReactDefaultBatchingStrategyTransaction() {\n this.reinitializeTransaction();\n}\n\n_assign(ReactDefaultBatchingStrategyTransaction.prototype, Transaction, {\n getTransactionWrappers: function () {\n return TRANSACTION_WRAPPERS;\n }\n});\n\nvar transaction = new ReactDefaultBatchingStrategyTransaction();\n\nvar ReactDefaultBatchingStrategy = {\n isBatchingUpdates: false,\n\n /**\n * Call the provided function in a context within which calls to `setState`\n * and friends are batched such that components aren't updated unnecessarily.\n */\n batchedUpdates: function (callback, a, b, c, d, e) {\n var alreadyBatchingUpdates = ReactDefaultBatchingStrategy.isBatchingUpdates;\n\n ReactDefaultBatchingStrategy.isBatchingUpdates = true;\n\n // The code is written this way to avoid extra allocations\n if (alreadyBatchingUpdates) {\n return callback(a, b, c, d, e);\n } else {\n return transaction.perform(callback, null, a, b, c, d, e);\n }\n }\n};\n\nmodule.exports = ReactDefaultBatchingStrategy;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar _prodInvariant = require('./reactProdInvariant'),\n _assign = require('object-assign');\n\nvar DOMChildrenOperations = require('./DOMChildrenOperations');\nvar DOMLazyTree = require('./DOMLazyTree');\nvar ReactDOMComponentTree = require('./ReactDOMComponentTree');\n\nvar escapeTextContentForBrowser = require('./escapeTextContentForBrowser');\nvar invariant = require('fbjs/lib/invariant');\nvar validateDOMNesting = require('./validateDOMNesting');\n\n/**\n * Text nodes violate a couple assumptions that React makes about components:\n *\n * - When mounting text into the DOM, adjacent text nodes are merged.\n * - Text nodes cannot be assigned a React root ID.\n *\n * This component is used to wrap strings between comment nodes so that they\n * can undergo the same reconciliation that is applied to elements.\n *\n * TODO: Investigate representing React components in the DOM with text nodes.\n *\n * @class ReactDOMTextComponent\n * @extends ReactComponent\n * @internal\n */\nvar ReactDOMTextComponent = function (text) {\n // TODO: This is really a ReactText (ReactNode), not a ReactElement\n this._currentElement = text;\n this._stringText = '' + text;\n // ReactDOMComponentTree uses these:\n this._hostNode = null;\n this._hostParent = null;\n\n // Properties\n this._domID = 0;\n this._mountIndex = 0;\n this._closingComment = null;\n this._commentNodes = null;\n};\n\n_assign(ReactDOMTextComponent.prototype, {\n /**\n * Creates the markup for this text node. This node is not intended to have\n * any features besides containing text content.\n *\n * @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction\n * @return {string} Markup for this text node.\n * @internal\n */\n mountComponent: function (transaction, hostParent, hostContainerInfo, context) {\n if (process.env.NODE_ENV !== 'production') {\n var parentInfo;\n if (hostParent != null) {\n parentInfo = hostParent._ancestorInfo;\n } else if (hostContainerInfo != null) {\n parentInfo = hostContainerInfo._ancestorInfo;\n }\n if (parentInfo) {\n // parentInfo should always be present except for the top-level\n // component when server rendering\n validateDOMNesting(null, this._stringText, this, parentInfo);\n }\n }\n\n var domID = hostContainerInfo._idCounter++;\n var openingValue = ' react-text: ' + domID + ' ';\n var closingValue = ' /react-text ';\n this._domID = domID;\n this._hostParent = hostParent;\n if (transaction.useCreateElement) {\n var ownerDocument = hostContainerInfo._ownerDocument;\n var openingComment = ownerDocument.createComment(openingValue);\n var closingComment = ownerDocument.createComment(closingValue);\n var lazyTree = DOMLazyTree(ownerDocument.createDocumentFragment());\n DOMLazyTree.queueChild(lazyTree, DOMLazyTree(openingComment));\n if (this._stringText) {\n DOMLazyTree.queueChild(lazyTree, DOMLazyTree(ownerDocument.createTextNode(this._stringText)));\n }\n DOMLazyTree.queueChild(lazyTree, DOMLazyTree(closingComment));\n ReactDOMComponentTree.precacheNode(this, openingComment);\n this._closingComment = closingComment;\n return lazyTree;\n } else {\n var escapedText = escapeTextContentForBrowser(this._stringText);\n\n if (transaction.renderToStaticMarkup) {\n // Normally we'd wrap this between comment nodes for the reasons stated\n // above, but since this is a situation where React won't take over\n // (static pages), we can simply return the text as it is.\n return escapedText;\n }\n\n return '<!--' + openingValue + '-->' + escapedText + '<!--' + closingValue + '-->';\n }\n },\n\n /**\n * Updates this component by updating the text content.\n *\n * @param {ReactText} nextText The next text content\n * @param {ReactReconcileTransaction} transaction\n * @internal\n */\n receiveComponent: function (nextText, transaction) {\n if (nextText !== this._currentElement) {\n this._currentElement = nextText;\n var nextStringText = '' + nextText;\n if (nextStringText !== this._stringText) {\n // TODO: Save this as pending props and use performUpdateIfNecessary\n // and/or updateComponent to do the actual update for consistency with\n // other component types?\n this._stringText = nextStringText;\n var commentNodes = this.getHostNode();\n DOMChildrenOperations.replaceDelimitedText(commentNodes[0], commentNodes[1], nextStringText);\n }\n }\n },\n\n getHostNode: function () {\n var hostNode = this._commentNodes;\n if (hostNode) {\n return hostNode;\n }\n if (!this._closingComment) {\n var openingComment = ReactDOMComponentTree.getNodeFromInstance(this);\n var node = openingComment.nextSibling;\n while (true) {\n !(node != null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Missing closing comment for text component %s', this._domID) : _prodInvariant('67', this._domID) : void 0;\n if (node.nodeType === 8 && node.nodeValue === ' /react-text ') {\n this._closingComment = node;\n break;\n }\n node = node.nextSibling;\n }\n }\n hostNode = [this._hostNode, this._closingComment];\n this._commentNodes = hostNode;\n return hostNode;\n },\n\n unmountComponent: function () {\n this._closingComment = null;\n this._commentNodes = null;\n ReactDOMComponentTree.uncacheNode(this);\n }\n});\n\nmodule.exports = ReactDOMTextComponent;","/**\n * Copyright (c) 2015-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar _prodInvariant = require('./reactProdInvariant');\n\nvar invariant = require('fbjs/lib/invariant');\n\n/**\n * Return the lowest common ancestor of A and B, or null if they are in\n * different trees.\n */\nfunction getLowestCommonAncestor(instA, instB) {\n !('_hostNode' in instA) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'getNodeFromInstance: Invalid argument.') : _prodInvariant('33') : void 0;\n !('_hostNode' in instB) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'getNodeFromInstance: Invalid argument.') : _prodInvariant('33') : void 0;\n\n var depthA = 0;\n for (var tempA = instA; tempA; tempA = tempA._hostParent) {\n depthA++;\n }\n var depthB = 0;\n for (var tempB = instB; tempB; tempB = tempB._hostParent) {\n depthB++;\n }\n\n // If A is deeper, crawl up.\n while (depthA - depthB > 0) {\n instA = instA._hostParent;\n depthA--;\n }\n\n // If B is deeper, crawl up.\n while (depthB - depthA > 0) {\n instB = instB._hostParent;\n depthB--;\n }\n\n // Walk in lockstep until we find a match.\n var depth = depthA;\n while (depth--) {\n if (instA === instB) {\n return instA;\n }\n instA = instA._hostParent;\n instB = instB._hostParent;\n }\n return null;\n}\n\n/**\n * Return if A is an ancestor of B.\n */\nfunction isAncestor(instA, instB) {\n !('_hostNode' in instA) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'isAncestor: Invalid argument.') : _prodInvariant('35') : void 0;\n !('_hostNode' in instB) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'isAncestor: Invalid argument.') : _prodInvariant('35') : void 0;\n\n while (instB) {\n if (instB === instA) {\n return true;\n }\n instB = instB._hostParent;\n }\n return false;\n}\n\n/**\n * Return the parent instance of the passed-in instance.\n */\nfunction getParentInstance(inst) {\n !('_hostNode' in inst) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'getParentInstance: Invalid argument.') : _prodInvariant('36') : void 0;\n\n return inst._hostParent;\n}\n\n/**\n * Simulates the traversal of a two-phase, capture/bubble event dispatch.\n */\nfunction traverseTwoPhase(inst, fn, arg) {\n var path = [];\n while (inst) {\n path.push(inst);\n inst = inst._hostParent;\n }\n var i;\n for (i = path.length; i-- > 0;) {\n fn(path[i], 'captured', arg);\n }\n for (i = 0; i < path.length; i++) {\n fn(path[i], 'bubbled', arg);\n }\n}\n\n/**\n * Traverses the ID hierarchy and invokes the supplied `cb` on any IDs that\n * should would receive a `mouseEnter` or `mouseLeave` event.\n *\n * Does not invoke the callback on the nearest common ancestor because nothing\n * \"entered\" or \"left\" that element.\n */\nfunction traverseEnterLeave(from, to, fn, argFrom, argTo) {\n var common = from && to ? getLowestCommonAncestor(from, to) : null;\n var pathFrom = [];\n while (from && from !== common) {\n pathFrom.push(from);\n from = from._hostParent;\n }\n var pathTo = [];\n while (to && to !== common) {\n pathTo.push(to);\n to = to._hostParent;\n }\n var i;\n for (i = 0; i < pathFrom.length; i++) {\n fn(pathFrom[i], 'bubbled', argFrom);\n }\n for (i = pathTo.length; i-- > 0;) {\n fn(pathTo[i], 'captured', argTo);\n }\n}\n\nmodule.exports = {\n isAncestor: isAncestor,\n getLowestCommonAncestor: getLowestCommonAncestor,\n getParentInstance: getParentInstance,\n traverseTwoPhase: traverseTwoPhase,\n traverseEnterLeave: traverseEnterLeave\n};","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar _assign = require('object-assign');\n\nvar DOMLazyTree = require('./DOMLazyTree');\nvar ReactDOMComponentTree = require('./ReactDOMComponentTree');\n\nvar ReactDOMEmptyComponent = function (instantiate) {\n // ReactCompositeComponent uses this:\n this._currentElement = null;\n // ReactDOMComponentTree uses these:\n this._hostNode = null;\n this._hostParent = null;\n this._hostContainerInfo = null;\n this._domID = 0;\n};\n_assign(ReactDOMEmptyComponent.prototype, {\n mountComponent: function (transaction, hostParent, hostContainerInfo, context) {\n var domID = hostContainerInfo._idCounter++;\n this._domID = domID;\n this._hostParent = hostParent;\n this._hostContainerInfo = hostContainerInfo;\n\n var nodeValue = ' react-empty: ' + this._domID + ' ';\n if (transaction.useCreateElement) {\n var ownerDocument = hostContainerInfo._ownerDocument;\n var node = ownerDocument.createComment(nodeValue);\n ReactDOMComponentTree.precacheNode(this, node);\n return DOMLazyTree(node);\n } else {\n if (transaction.renderToStaticMarkup) {\n // Normally we'd insert a comment node, but since this is a situation\n // where React won't take over (static pages), we can simply return\n // nothing.\n return '';\n }\n return '<!--' + nodeValue + '-->';\n }\n },\n receiveComponent: function () {},\n getHostNode: function () {\n return ReactDOMComponentTree.getNodeFromInstance(this);\n },\n unmountComponent: function () {\n ReactDOMComponentTree.uncacheNode(this);\n }\n});\n\nmodule.exports = ReactDOMEmptyComponent;","/**\n * Copyright (c) 2015-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n */\n\n'use strict';\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar ReactUpdateQueue = require('./ReactUpdateQueue');\n\nvar warning = require('fbjs/lib/warning');\n\nfunction warnNoop(publicInstance, callerName) {\n if (process.env.NODE_ENV !== 'production') {\n var constructor = publicInstance.constructor;\n process.env.NODE_ENV !== 'production' ? warning(false, '%s(...): Can only update a mounting component. ' + 'This usually means you called %s() outside componentWillMount() on the server. ' + 'This is a no-op. Please check the code for the %s component.', callerName, callerName, constructor && (constructor.displayName || constructor.name) || 'ReactClass') : void 0;\n }\n}\n\n/**\n * This is the update queue used for server rendering.\n * It delegates to ReactUpdateQueue while server rendering is in progress and\n * switches to ReactNoopUpdateQueue after the transaction has completed.\n * @class ReactServerUpdateQueue\n * @param {Transaction} transaction\n */\n\nvar ReactServerUpdateQueue = function () {\n function ReactServerUpdateQueue(transaction) {\n _classCallCheck(this, ReactServerUpdateQueue);\n\n this.transaction = transaction;\n }\n\n /**\n * Checks whether or not this composite component is mounted.\n * @param {ReactClass} publicInstance The instance we want to test.\n * @return {boolean} True if mounted, false otherwise.\n * @protected\n * @final\n */\n\n\n ReactServerUpdateQueue.prototype.isMounted = function isMounted(publicInstance) {\n return false;\n };\n\n /**\n * Enqueue a callback that will be executed after all the pending updates\n * have processed.\n *\n * @param {ReactClass} publicInstance The instance to use as `this` context.\n * @param {?function} callback Called after state is updated.\n * @internal\n */\n\n\n ReactServerUpdateQueue.prototype.enqueueCallback = function enqueueCallback(publicInstance, callback, callerName) {\n if (this.transaction.isInTransaction()) {\n ReactUpdateQueue.enqueueCallback(publicInstance, callback, callerName);\n }\n };\n\n /**\n * Forces an update. This should only be invoked when it is known with\n * certainty that we are **not** in a DOM transaction.\n *\n * You may want to call this when you know that some deeper aspect of the\n * component's state has changed but `setState` was not called.\n *\n * This will not invoke `shouldComponentUpdate`, but it will invoke\n * `componentWillUpdate` and `componentDidUpdate`.\n *\n * @param {ReactClass} publicInstance The instance that should rerender.\n * @internal\n */\n\n\n ReactServerUpdateQueue.prototype.enqueueForceUpdate = function enqueueForceUpdate(publicInstance) {\n if (this.transaction.isInTransaction()) {\n ReactUpdateQueue.enqueueForceUpdate(publicInstance);\n } else {\n warnNoop(publicInstance, 'forceUpdate');\n }\n };\n\n /**\n * Replaces all of the state. Always use this or `setState` to mutate state.\n * You should treat `this.state` as immutable.\n *\n * There is no guarantee that `this.state` will be immediately updated, so\n * accessing `this.state` after calling this method may return the old value.\n *\n * @param {ReactClass} publicInstance The instance that should rerender.\n * @param {object|function} completeState Next state.\n * @internal\n */\n\n\n ReactServerUpdateQueue.prototype.enqueueReplaceState = function enqueueReplaceState(publicInstance, completeState) {\n if (this.transaction.isInTransaction()) {\n ReactUpdateQueue.enqueueReplaceState(publicInstance, completeState);\n } else {\n warnNoop(publicInstance, 'replaceState');\n }\n };\n\n /**\n * Sets a subset of the state. This only exists because _pendingState is\n * internal. This provides a merging strategy that is not available to deep\n * properties which is confusing. TODO: Expose pendingState or don't use it\n * during the merge.\n *\n * @param {ReactClass} publicInstance The instance that should rerender.\n * @param {object|function} partialState Next partial state to be merged with state.\n * @internal\n */\n\n\n ReactServerUpdateQueue.prototype.enqueueSetState = function enqueueSetState(publicInstance, partialState) {\n if (this.transaction.isInTransaction()) {\n ReactUpdateQueue.enqueueSetState(publicInstance, partialState);\n } else {\n warnNoop(publicInstance, 'setState');\n }\n };\n\n return ReactServerUpdateQueue;\n}();\n\nmodule.exports = ReactServerUpdateQueue;","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar _assign = require('object-assign');\n\nvar PooledClass = require('./PooledClass');\nvar Transaction = require('./Transaction');\nvar ReactInstrumentation = require('./ReactInstrumentation');\nvar ReactServerUpdateQueue = require('./ReactServerUpdateQueue');\n\n/**\n * Executed within the scope of the `Transaction` instance. Consider these as\n * being member methods, but with an implied ordering while being isolated from\n * each other.\n */\nvar TRANSACTION_WRAPPERS = [];\n\nif (process.env.NODE_ENV !== 'production') {\n TRANSACTION_WRAPPERS.push({\n initialize: ReactInstrumentation.debugTool.onBeginFlush,\n close: ReactInstrumentation.debugTool.onEndFlush\n });\n}\n\nvar noopCallbackQueue = {\n enqueue: function () {}\n};\n\n/**\n * @class ReactServerRenderingTransaction\n * @param {boolean} renderToStaticMarkup\n */\nfunction ReactServerRenderingTransaction(renderToStaticMarkup) {\n this.reinitializeTransaction();\n this.renderToStaticMarkup = renderToStaticMarkup;\n this.useCreateElement = false;\n this.updateQueue = new ReactServerUpdateQueue(this);\n}\n\nvar Mixin = {\n /**\n * @see Transaction\n * @abstract\n * @final\n * @return {array} Empty list of operation wrap procedures.\n */\n getTransactionWrappers: function () {\n return TRANSACTION_WRAPPERS;\n },\n\n /**\n * @return {object} The queue to collect `onDOMReady` callbacks with.\n */\n getReactMountReady: function () {\n return noopCallbackQueue;\n },\n\n /**\n * @return {object} The queue to collect React async events.\n */\n getUpdateQueue: function () {\n return this.updateQueue;\n },\n\n /**\n * `PooledClass` looks for this, and will invoke this before allowing this\n * instance to be reused.\n */\n destructor: function () {},\n\n checkpoint: function () {},\n\n rollback: function () {}\n};\n\n_assign(ReactServerRenderingTransaction.prototype, Transaction, Mixin);\n\nPooledClass.addPoolingTo(ReactServerRenderingTransaction);\n\nmodule.exports = ReactServerRenderingTransaction;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n */\n\n'use strict';\n\nvar KeyEscapeUtils = require('./KeyEscapeUtils');\nvar traverseAllChildren = require('./traverseAllChildren');\nvar warning = require('fbjs/lib/warning');\n\nvar ReactComponentTreeHook;\n\nif (typeof process !== 'undefined' && process.env && process.env.NODE_ENV === 'test') {\n // Temporary hack.\n // Inline requires don't work well with Jest:\n // https://github.com/facebook/react/issues/7240\n // Remove the inline requires when we don't need them anymore:\n // https://github.com/facebook/react/pull/7178\n ReactComponentTreeHook = require('react/lib/ReactComponentTreeHook');\n}\n\n/**\n * @param {function} traverseContext Context passed through traversal.\n * @param {?ReactComponent} child React child component.\n * @param {!string} name String name of key path to child.\n * @param {number=} selfDebugID Optional debugID of the current internal instance.\n */\nfunction flattenSingleChildIntoContext(traverseContext, child, name, selfDebugID) {\n // We found a component instance.\n if (traverseContext && typeof traverseContext === 'object') {\n var result = traverseContext;\n var keyUnique = result[name] === undefined;\n if (process.env.NODE_ENV !== 'production') {\n if (!ReactComponentTreeHook) {\n ReactComponentTreeHook = require('react/lib/ReactComponentTreeHook');\n }\n if (!keyUnique) {\n process.env.NODE_ENV !== 'production' ? warning(false, 'flattenChildren(...): Encountered two children with the same key, ' + '`%s`. Child keys must be unique; when two children share a key, only ' + 'the first child will be used.%s', KeyEscapeUtils.unescape(name), ReactComponentTreeHook.getStackAddendumByID(selfDebugID)) : void 0;\n }\n }\n if (keyUnique && child != null) {\n result[name] = child;\n }\n }\n}\n\n/**\n * Flattens children that are typically specified as `props.children`. Any null\n * children will not be included in the resulting object.\n * @return {!object} flattened children keyed by name.\n */\nfunction flattenChildren(children, selfDebugID) {\n if (children == null) {\n return children;\n }\n var result = {};\n\n if (process.env.NODE_ENV !== 'production') {\n traverseAllChildren(children, function (traverseContext, child, name) {\n return flattenSingleChildIntoContext(traverseContext, child, name, selfDebugID);\n }, result);\n } else {\n traverseAllChildren(children, flattenSingleChildIntoContext, result);\n }\n return result;\n}\n\nmodule.exports = flattenChildren;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n */\n\n'use strict';\n\n/* global Symbol */\n\nvar ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;\nvar FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.\n\n/**\n * Returns the iterator method function contained on the iterable object.\n *\n * Be sure to invoke the function with the iterable as context:\n *\n * var iteratorFn = getIteratorFn(myIterable);\n * if (iteratorFn) {\n * var iterator = iteratorFn.call(myIterable);\n * ...\n * }\n *\n * @param {?object} maybeIterable\n * @return {?function}\n */\nfunction getIteratorFn(maybeIterable) {\n var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);\n if (typeof iteratorFn === 'function') {\n return iteratorFn;\n }\n}\n\nmodule.exports = getIteratorFn;","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n */\n\n'use strict';\n\n// The Symbol used to tag the ReactElement type. If there is no native Symbol\n// nor polyfill, then a plain number is used for performance.\n\nvar REACT_ELEMENT_TYPE = typeof Symbol === 'function' && Symbol['for'] && Symbol['for']('react.element') || 0xeac7;\n\nmodule.exports = REACT_ELEMENT_TYPE;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n */\n\n'use strict';\n\nvar nextDebugID = 1;\n\nfunction getNextDebugID() {\n return nextDebugID++;\n}\n\nmodule.exports = getNextDebugID;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar _prodInvariant = require('./reactProdInvariant'),\n _assign = require('object-assign');\n\nvar React = require('react/lib/React');\nvar ReactComponentEnvironment = require('./ReactComponentEnvironment');\nvar ReactCurrentOwner = require('react/lib/ReactCurrentOwner');\nvar ReactErrorUtils = require('./ReactErrorUtils');\nvar ReactInstanceMap = require('./ReactInstanceMap');\nvar ReactInstrumentation = require('./ReactInstrumentation');\nvar ReactNodeTypes = require('./ReactNodeTypes');\nvar ReactReconciler = require('./ReactReconciler');\n\nif (process.env.NODE_ENV !== 'production') {\n var checkReactTypeSpec = require('./checkReactTypeSpec');\n}\n\nvar emptyObject = require('fbjs/lib/emptyObject');\nvar invariant = require('fbjs/lib/invariant');\nvar shallowEqual = require('fbjs/lib/shallowEqual');\nvar shouldUpdateReactComponent = require('./shouldUpdateReactComponent');\nvar warning = require('fbjs/lib/warning');\n\nvar CompositeTypes = {\n ImpureClass: 0,\n PureClass: 1,\n StatelessFunctional: 2\n};\n\nfunction StatelessComponent(Component) {}\nStatelessComponent.prototype.render = function () {\n var Component = ReactInstanceMap.get(this)._currentElement.type;\n var element = Component(this.props, this.context, this.updater);\n warnIfInvalidElement(Component, element);\n return element;\n};\n\nfunction warnIfInvalidElement(Component, element) {\n if (process.env.NODE_ENV !== 'production') {\n process.env.NODE_ENV !== 'production' ? warning(element === null || element === false || React.isValidElement(element), '%s(...): A valid React element (or null) must be returned. You may have ' + 'returned undefined, an array or some other invalid object.', Component.displayName || Component.name || 'Component') : void 0;\n process.env.NODE_ENV !== 'production' ? warning(!Component.childContextTypes, '%s(...): childContextTypes cannot be defined on a functional component.', Component.displayName || Component.name || 'Component') : void 0;\n }\n}\n\nfunction shouldConstruct(Component) {\n return !!(Component.prototype && Component.prototype.isReactComponent);\n}\n\nfunction isPureComponent(Component) {\n return !!(Component.prototype && Component.prototype.isPureReactComponent);\n}\n\n// Separated into a function to contain deoptimizations caused by try/finally.\nfunction measureLifeCyclePerf(fn, debugID, timerType) {\n if (debugID === 0) {\n // Top-level wrappers (see ReactMount) and empty components (see\n // ReactDOMEmptyComponent) are invisible to hooks and devtools.\n // Both are implementation details that should go away in the future.\n return fn();\n }\n\n ReactInstrumentation.debugTool.onBeginLifeCycleTimer(debugID, timerType);\n try {\n return fn();\n } finally {\n ReactInstrumentation.debugTool.onEndLifeCycleTimer(debugID, timerType);\n }\n}\n\n/**\n * ------------------ The Life-Cycle of a Composite Component ------------------\n *\n * - constructor: Initialization of state. The instance is now retained.\n * - componentWillMount\n * - render\n * - [children's constructors]\n * - [children's componentWillMount and render]\n * - [children's componentDidMount]\n * - componentDidMount\n *\n * Update Phases:\n * - componentWillReceiveProps (only called if parent updated)\n * - shouldComponentUpdate\n * - componentWillUpdate\n * - render\n * - [children's constructors or receive props phases]\n * - componentDidUpdate\n *\n * - componentWillUnmount\n * - [children's componentWillUnmount]\n * - [children destroyed]\n * - (destroyed): The instance is now blank, released by React and ready for GC.\n *\n * -----------------------------------------------------------------------------\n */\n\n/**\n * An incrementing ID assigned to each component when it is mounted. This is\n * used to enforce the order in which `ReactUpdates` updates dirty components.\n *\n * @private\n */\nvar nextMountID = 1;\n\n/**\n * @lends {ReactCompositeComponent.prototype}\n */\nvar ReactCompositeComponent = {\n /**\n * Base constructor for all composite component.\n *\n * @param {ReactElement} element\n * @final\n * @internal\n */\n construct: function (element) {\n this._currentElement = element;\n this._rootNodeID = 0;\n this._compositeType = null;\n this._instance = null;\n this._hostParent = null;\n this._hostContainerInfo = null;\n\n // See ReactUpdateQueue\n this._updateBatchNumber = null;\n this._pendingElement = null;\n this._pendingStateQueue = null;\n this._pendingReplaceState = false;\n this._pendingForceUpdate = false;\n\n this._renderedNodeType = null;\n this._renderedComponent = null;\n this._context = null;\n this._mountOrder = 0;\n this._topLevelWrapper = null;\n\n // See ReactUpdates and ReactUpdateQueue.\n this._pendingCallbacks = null;\n\n // ComponentWillUnmount shall only be called once\n this._calledComponentWillUnmount = false;\n\n if (process.env.NODE_ENV !== 'production') {\n this._warnedAboutRefsInRender = false;\n }\n },\n\n /**\n * Initializes the component, renders markup, and registers event listeners.\n *\n * @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction\n * @param {?object} hostParent\n * @param {?object} hostContainerInfo\n * @param {?object} context\n * @return {?string} Rendered markup to be inserted into the DOM.\n * @final\n * @internal\n */\n mountComponent: function (transaction, hostParent, hostContainerInfo, context) {\n var _this = this;\n\n this._context = context;\n this._mountOrder = nextMountID++;\n this._hostParent = hostParent;\n this._hostContainerInfo = hostContainerInfo;\n\n var publicProps = this._currentElement.props;\n var publicContext = this._processContext(context);\n\n var Component = this._currentElement.type;\n\n var updateQueue = transaction.getUpdateQueue();\n\n // Initialize the public class\n var doConstruct = shouldConstruct(Component);\n var inst = this._constructComponent(doConstruct, publicProps, publicContext, updateQueue);\n var renderedElement;\n\n // Support functional components\n if (!doConstruct && (inst == null || inst.render == null)) {\n renderedElement = inst;\n warnIfInvalidElement(Component, renderedElement);\n !(inst === null || inst === false || React.isValidElement(inst)) ? process.env.NODE_ENV !== 'production' ? invariant(false, '%s(...): A valid React element (or null) must be returned. You may have returned undefined, an array or some other invalid object.', Component.displayName || Component.name || 'Component') : _prodInvariant('105', Component.displayName || Component.name || 'Component') : void 0;\n inst = new StatelessComponent(Component);\n this._compositeType = CompositeTypes.StatelessFunctional;\n } else {\n if (isPureComponent(Component)) {\n this._compositeType = CompositeTypes.PureClass;\n } else {\n this._compositeType = CompositeTypes.ImpureClass;\n }\n }\n\n if (process.env.NODE_ENV !== 'production') {\n // This will throw later in _renderValidatedComponent, but add an early\n // warning now to help debugging\n if (inst.render == null) {\n process.env.NODE_ENV !== 'production' ? warning(false, '%s(...): No `render` method found on the returned component ' + 'instance: you may have forgotten to define `render`.', Component.displayName || Component.name || 'Component') : void 0;\n }\n\n var propsMutated = inst.props !== publicProps;\n var componentName = Component.displayName || Component.name || 'Component';\n\n process.env.NODE_ENV !== 'production' ? warning(inst.props === undefined || !propsMutated, '%s(...): When calling super() in `%s`, make sure to pass ' + \"up the same props that your component's constructor was passed.\", componentName, componentName) : void 0;\n }\n\n // These should be set up in the constructor, but as a convenience for\n // simpler class abstractions, we set them up after the fact.\n inst.props = publicProps;\n inst.context = publicContext;\n inst.refs = emptyObject;\n inst.updater = updateQueue;\n\n this._instance = inst;\n\n // Store a reference from the instance back to the internal representation\n ReactInstanceMap.set(inst, this);\n\n if (process.env.NODE_ENV !== 'production') {\n // Since plain JS classes are defined without any special initialization\n // logic, we can not catch common errors early. Therefore, we have to\n // catch them here, at initialization time, instead.\n process.env.NODE_ENV !== 'production' ? warning(!inst.getInitialState || inst.getInitialState.isReactClassApproved || inst.state, 'getInitialState was defined on %s, a plain JavaScript class. ' + 'This is only supported for classes created using React.createClass. ' + 'Did you mean to define a state property instead?', this.getName() || 'a component') : void 0;\n process.env.NODE_ENV !== 'production' ? warning(!inst.getDefaultProps || inst.getDefaultProps.isReactClassApproved, 'getDefaultProps was defined on %s, a plain JavaScript class. ' + 'This is only supported for classes created using React.createClass. ' + 'Use a static property to define defaultProps instead.', this.getName() || 'a component') : void 0;\n process.env.NODE_ENV !== 'production' ? warning(!inst.propTypes, 'propTypes was defined as an instance property on %s. Use a static ' + 'property to define propTypes instead.', this.getName() || 'a component') : void 0;\n process.env.NODE_ENV !== 'production' ? warning(!inst.contextTypes, 'contextTypes was defined as an instance property on %s. Use a ' + 'static property to define contextTypes instead.', this.getName() || 'a component') : void 0;\n process.env.NODE_ENV !== 'production' ? warning(typeof inst.componentShouldUpdate !== 'function', '%s has a method called ' + 'componentShouldUpdate(). Did you mean shouldComponentUpdate()? ' + 'The name is phrased as a question because the function is ' + 'expected to return a value.', this.getName() || 'A component') : void 0;\n process.env.NODE_ENV !== 'production' ? warning(typeof inst.componentDidUnmount !== 'function', '%s has a method called ' + 'componentDidUnmount(). But there is no such lifecycle method. ' + 'Did you mean componentWillUnmount()?', this.getName() || 'A component') : void 0;\n process.env.NODE_ENV !== 'production' ? warning(typeof inst.componentWillRecieveProps !== 'function', '%s has a method called ' + 'componentWillRecieveProps(). Did you mean componentWillReceiveProps()?', this.getName() || 'A component') : void 0;\n }\n\n var initialState = inst.state;\n if (initialState === undefined) {\n inst.state = initialState = null;\n }\n !(typeof initialState === 'object' && !Array.isArray(initialState)) ? process.env.NODE_ENV !== 'production' ? invariant(false, '%s.state: must be set to an object or null', this.getName() || 'ReactCompositeComponent') : _prodInvariant('106', this.getName() || 'ReactCompositeComponent') : void 0;\n\n this._pendingStateQueue = null;\n this._pendingReplaceState = false;\n this._pendingForceUpdate = false;\n\n var markup;\n if (inst.unstable_handleError) {\n markup = this.performInitialMountWithErrorHandling(renderedElement, hostParent, hostContainerInfo, transaction, context);\n } else {\n markup = this.performInitialMount(renderedElement, hostParent, hostContainerInfo, transaction, context);\n }\n\n if (inst.componentDidMount) {\n if (process.env.NODE_ENV !== 'production') {\n transaction.getReactMountReady().enqueue(function () {\n measureLifeCyclePerf(function () {\n return inst.componentDidMount();\n }, _this._debugID, 'componentDidMount');\n });\n } else {\n transaction.getReactMountReady().enqueue(inst.componentDidMount, inst);\n }\n }\n\n return markup;\n },\n\n _constructComponent: function (doConstruct, publicProps, publicContext, updateQueue) {\n if (process.env.NODE_ENV !== 'production' && !doConstruct) {\n ReactCurrentOwner.current = this;\n try {\n return this._constructComponentWithoutOwner(doConstruct, publicProps, publicContext, updateQueue);\n } finally {\n ReactCurrentOwner.current = null;\n }\n } else {\n return this._constructComponentWithoutOwner(doConstruct, publicProps, publicContext, updateQueue);\n }\n },\n\n _constructComponentWithoutOwner: function (doConstruct, publicProps, publicContext, updateQueue) {\n var Component = this._currentElement.type;\n\n if (doConstruct) {\n if (process.env.NODE_ENV !== 'production') {\n return measureLifeCyclePerf(function () {\n return new Component(publicProps, publicContext, updateQueue);\n }, this._debugID, 'ctor');\n } else {\n return new Component(publicProps, publicContext, updateQueue);\n }\n }\n\n // This can still be an instance in case of factory components\n // but we'll count this as time spent rendering as the more common case.\n if (process.env.NODE_ENV !== 'production') {\n return measureLifeCyclePerf(function () {\n return Component(publicProps, publicContext, updateQueue);\n }, this._debugID, 'render');\n } else {\n return Component(publicProps, publicContext, updateQueue);\n }\n },\n\n performInitialMountWithErrorHandling: function (renderedElement, hostParent, hostContainerInfo, transaction, context) {\n var markup;\n var checkpoint = transaction.checkpoint();\n try {\n markup = this.performInitialMount(renderedElement, hostParent, hostContainerInfo, transaction, context);\n } catch (e) {\n // Roll back to checkpoint, handle error (which may add items to the transaction), and take a new checkpoint\n transaction.rollback(checkpoint);\n this._instance.unstable_handleError(e);\n if (this._pendingStateQueue) {\n this._instance.state = this._processPendingState(this._instance.props, this._instance.context);\n }\n checkpoint = transaction.checkpoint();\n\n this._renderedComponent.unmountComponent(true);\n transaction.rollback(checkpoint);\n\n // Try again - we've informed the component about the error, so they can render an error message this time.\n // If this throws again, the error will bubble up (and can be caught by a higher error boundary).\n markup = this.performInitialMount(renderedElement, hostParent, hostContainerInfo, transaction, context);\n }\n return markup;\n },\n\n performInitialMount: function (renderedElement, hostParent, hostContainerInfo, transaction, context) {\n var inst = this._instance;\n\n var debugID = 0;\n if (process.env.NODE_ENV !== 'production') {\n debugID = this._debugID;\n }\n\n if (inst.componentWillMount) {\n if (process.env.NODE_ENV !== 'production') {\n measureLifeCyclePerf(function () {\n return inst.componentWillMount();\n }, debugID, 'componentWillMount');\n } else {\n inst.componentWillMount();\n }\n // When mounting, calls to `setState` by `componentWillMount` will set\n // `this._pendingStateQueue` without triggering a re-render.\n if (this._pendingStateQueue) {\n inst.state = this._processPendingState(inst.props, inst.context);\n }\n }\n\n // If not a stateless component, we now render\n if (renderedElement === undefined) {\n renderedElement = this._renderValidatedComponent();\n }\n\n var nodeType = ReactNodeTypes.getType(renderedElement);\n this._renderedNodeType = nodeType;\n var child = this._instantiateReactComponent(renderedElement, nodeType !== ReactNodeTypes.EMPTY /* shouldHaveDebugID */\n );\n this._renderedComponent = child;\n\n var markup = ReactReconciler.mountComponent(child, transaction, hostParent, hostContainerInfo, this._processChildContext(context), debugID);\n\n if (process.env.NODE_ENV !== 'production') {\n if (debugID !== 0) {\n var childDebugIDs = child._debugID !== 0 ? [child._debugID] : [];\n ReactInstrumentation.debugTool.onSetChildren(debugID, childDebugIDs);\n }\n }\n\n return markup;\n },\n\n getHostNode: function () {\n return ReactReconciler.getHostNode(this._renderedComponent);\n },\n\n /**\n * Releases any resources allocated by `mountComponent`.\n *\n * @final\n * @internal\n */\n unmountComponent: function (safely) {\n if (!this._renderedComponent) {\n return;\n }\n\n var inst = this._instance;\n\n if (inst.componentWillUnmount && !inst._calledComponentWillUnmount) {\n inst._calledComponentWillUnmount = true;\n\n if (safely) {\n var name = this.getName() + '.componentWillUnmount()';\n ReactErrorUtils.invokeGuardedCallback(name, inst.componentWillUnmount.bind(inst));\n } else {\n if (process.env.NODE_ENV !== 'production') {\n measureLifeCyclePerf(function () {\n return inst.componentWillUnmount();\n }, this._debugID, 'componentWillUnmount');\n } else {\n inst.componentWillUnmount();\n }\n }\n }\n\n if (this._renderedComponent) {\n ReactReconciler.unmountComponent(this._renderedComponent, safely);\n this._renderedNodeType = null;\n this._renderedComponent = null;\n this._instance = null;\n }\n\n // Reset pending fields\n // Even if this component is scheduled for another update in ReactUpdates,\n // it would still be ignored because these fields are reset.\n this._pendingStateQueue = null;\n this._pendingReplaceState = false;\n this._pendingForceUpdate = false;\n this._pendingCallbacks = null;\n this._pendingElement = null;\n\n // These fields do not really need to be reset since this object is no\n // longer accessible.\n this._context = null;\n this._rootNodeID = 0;\n this._topLevelWrapper = null;\n\n // Delete the reference from the instance to this internal representation\n // which allow the internals to be properly cleaned up even if the user\n // leaks a reference to the public instance.\n ReactInstanceMap.remove(inst);\n\n // Some existing components rely on inst.props even after they've been\n // destroyed (in event handlers).\n // TODO: inst.props = null;\n // TODO: inst.state = null;\n // TODO: inst.context = null;\n },\n\n /**\n * Filters the context object to only contain keys specified in\n * `contextTypes`\n *\n * @param {object} context\n * @return {?object}\n * @private\n */\n _maskContext: function (context) {\n var Component = this._currentElement.type;\n var contextTypes = Component.contextTypes;\n if (!contextTypes) {\n return emptyObject;\n }\n var maskedContext = {};\n for (var contextName in contextTypes) {\n maskedContext[contextName] = context[contextName];\n }\n return maskedContext;\n },\n\n /**\n * Filters the context object to only contain keys specified in\n * `contextTypes`, and asserts that they are valid.\n *\n * @param {object} context\n * @return {?object}\n * @private\n */\n _processContext: function (context) {\n var maskedContext = this._maskContext(context);\n if (process.env.NODE_ENV !== 'production') {\n var Component = this._currentElement.type;\n if (Component.contextTypes) {\n this._checkContextTypes(Component.contextTypes, maskedContext, 'context');\n }\n }\n return maskedContext;\n },\n\n /**\n * @param {object} currentContext\n * @return {object}\n * @private\n */\n _processChildContext: function (currentContext) {\n var Component = this._currentElement.type;\n var inst = this._instance;\n var childContext;\n\n if (inst.getChildContext) {\n if (process.env.NODE_ENV !== 'production') {\n ReactInstrumentation.debugTool.onBeginProcessingChildContext();\n try {\n childContext = inst.getChildContext();\n } finally {\n ReactInstrumentation.debugTool.onEndProcessingChildContext();\n }\n } else {\n childContext = inst.getChildContext();\n }\n }\n\n if (childContext) {\n !(typeof Component.childContextTypes === 'object') ? process.env.NODE_ENV !== 'production' ? invariant(false, '%s.getChildContext(): childContextTypes must be defined in order to use getChildContext().', this.getName() || 'ReactCompositeComponent') : _prodInvariant('107', this.getName() || 'ReactCompositeComponent') : void 0;\n if (process.env.NODE_ENV !== 'production') {\n this._checkContextTypes(Component.childContextTypes, childContext, 'child context');\n }\n for (var name in childContext) {\n !(name in Component.childContextTypes) ? process.env.NODE_ENV !== 'production' ? invariant(false, '%s.getChildContext(): key \"%s\" is not defined in childContextTypes.', this.getName() || 'ReactCompositeComponent', name) : _prodInvariant('108', this.getName() || 'ReactCompositeComponent', name) : void 0;\n }\n return _assign({}, currentContext, childContext);\n }\n return currentContext;\n },\n\n /**\n * Assert that the context types are valid\n *\n * @param {object} typeSpecs Map of context field to a ReactPropType\n * @param {object} values Runtime values that need to be type-checked\n * @param {string} location e.g. \"prop\", \"context\", \"child context\"\n * @private\n */\n _checkContextTypes: function (typeSpecs, values, location) {\n if (process.env.NODE_ENV !== 'production') {\n checkReactTypeSpec(typeSpecs, values, location, this.getName(), null, this._debugID);\n }\n },\n\n receiveComponent: function (nextElement, transaction, nextContext) {\n var prevElement = this._currentElement;\n var prevContext = this._context;\n\n this._pendingElement = null;\n\n this.updateComponent(transaction, prevElement, nextElement, prevContext, nextContext);\n },\n\n /**\n * If any of `_pendingElement`, `_pendingStateQueue`, or `_pendingForceUpdate`\n * is set, update the component.\n *\n * @param {ReactReconcileTransaction} transaction\n * @internal\n */\n performUpdateIfNecessary: function (transaction) {\n if (this._pendingElement != null) {\n ReactReconciler.receiveComponent(this, this._pendingElement, transaction, this._context);\n } else if (this._pendingStateQueue !== null || this._pendingForceUpdate) {\n this.updateComponent(transaction, this._currentElement, this._currentElement, this._context, this._context);\n } else {\n this._updateBatchNumber = null;\n }\n },\n\n /**\n * Perform an update to a mounted component. The componentWillReceiveProps and\n * shouldComponentUpdate methods are called, then (assuming the update isn't\n * skipped) the remaining update lifecycle methods are called and the DOM\n * representation is updated.\n *\n * By default, this implements React's rendering and reconciliation algorithm.\n * Sophisticated clients may wish to override this.\n *\n * @param {ReactReconcileTransaction} transaction\n * @param {ReactElement} prevParentElement\n * @param {ReactElement} nextParentElement\n * @internal\n * @overridable\n */\n updateComponent: function (transaction, prevParentElement, nextParentElement, prevUnmaskedContext, nextUnmaskedContext) {\n var inst = this._instance;\n !(inst != null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Attempted to update component `%s` that has already been unmounted (or failed to mount).', this.getName() || 'ReactCompositeComponent') : _prodInvariant('136', this.getName() || 'ReactCompositeComponent') : void 0;\n\n var willReceive = false;\n var nextContext;\n\n // Determine if the context has changed or not\n if (this._context === nextUnmaskedContext) {\n nextContext = inst.context;\n } else {\n nextContext = this._processContext(nextUnmaskedContext);\n willReceive = true;\n }\n\n var prevProps = prevParentElement.props;\n var nextProps = nextParentElement.props;\n\n // Not a simple state update but a props update\n if (prevParentElement !== nextParentElement) {\n willReceive = true;\n }\n\n // An update here will schedule an update but immediately set\n // _pendingStateQueue which will ensure that any state updates gets\n // immediately reconciled instead of waiting for the next batch.\n if (willReceive && inst.componentWillReceiveProps) {\n if (process.env.NODE_ENV !== 'production') {\n measureLifeCyclePerf(function () {\n return inst.componentWillReceiveProps(nextProps, nextContext);\n }, this._debugID, 'componentWillReceiveProps');\n } else {\n inst.componentWillReceiveProps(nextProps, nextContext);\n }\n }\n\n var nextState = this._processPendingState(nextProps, nextContext);\n var shouldUpdate = true;\n\n if (!this._pendingForceUpdate) {\n if (inst.shouldComponentUpdate) {\n if (process.env.NODE_ENV !== 'production') {\n shouldUpdate = measureLifeCyclePerf(function () {\n return inst.shouldComponentUpdate(nextProps, nextState, nextContext);\n }, this._debugID, 'shouldComponentUpdate');\n } else {\n shouldUpdate = inst.shouldComponentUpdate(nextProps, nextState, nextContext);\n }\n } else {\n if (this._compositeType === CompositeTypes.PureClass) {\n shouldUpdate = !shallowEqual(prevProps, nextProps) || !shallowEqual(inst.state, nextState);\n }\n }\n }\n\n if (process.env.NODE_ENV !== 'production') {\n process.env.NODE_ENV !== 'production' ? warning(shouldUpdate !== undefined, '%s.shouldComponentUpdate(): Returned undefined instead of a ' + 'boolean value. Make sure to return true or false.', this.getName() || 'ReactCompositeComponent') : void 0;\n }\n\n this._updateBatchNumber = null;\n if (shouldUpdate) {\n this._pendingForceUpdate = false;\n // Will set `this.props`, `this.state` and `this.context`.\n this._performComponentUpdate(nextParentElement, nextProps, nextState, nextContext, transaction, nextUnmaskedContext);\n } else {\n // If it's determined that a component should not update, we still want\n // to set props and state but we shortcut the rest of the update.\n this._currentElement = nextParentElement;\n this._context = nextUnmaskedContext;\n inst.props = nextProps;\n inst.state = nextState;\n inst.context = nextContext;\n }\n },\n\n _processPendingState: function (props, context) {\n var inst = this._instance;\n var queue = this._pendingStateQueue;\n var replace = this._pendingReplaceState;\n this._pendingReplaceState = false;\n this._pendingStateQueue = null;\n\n if (!queue) {\n return inst.state;\n }\n\n if (replace && queue.length === 1) {\n return queue[0];\n }\n\n var nextState = _assign({}, replace ? queue[0] : inst.state);\n for (var i = replace ? 1 : 0; i < queue.length; i++) {\n var partial = queue[i];\n _assign(nextState, typeof partial === 'function' ? partial.call(inst, nextState, props, context) : partial);\n }\n\n return nextState;\n },\n\n /**\n * Merges new props and state, notifies delegate methods of update and\n * performs update.\n *\n * @param {ReactElement} nextElement Next element\n * @param {object} nextProps Next public object to set as properties.\n * @param {?object} nextState Next object to set as state.\n * @param {?object} nextContext Next public object to set as context.\n * @param {ReactReconcileTransaction} transaction\n * @param {?object} unmaskedContext\n * @private\n */\n _performComponentUpdate: function (nextElement, nextProps, nextState, nextContext, transaction, unmaskedContext) {\n var _this2 = this;\n\n var inst = this._instance;\n\n var hasComponentDidUpdate = Boolean(inst.componentDidUpdate);\n var prevProps;\n var prevState;\n var prevContext;\n if (hasComponentDidUpdate) {\n prevProps = inst.props;\n prevState = inst.state;\n prevContext = inst.context;\n }\n\n if (inst.componentWillUpdate) {\n if (process.env.NODE_ENV !== 'production') {\n measureLifeCyclePerf(function () {\n return inst.componentWillUpdate(nextProps, nextState, nextContext);\n }, this._debugID, 'componentWillUpdate');\n } else {\n inst.componentWillUpdate(nextProps, nextState, nextContext);\n }\n }\n\n this._currentElement = nextElement;\n this._context = unmaskedContext;\n inst.props = nextProps;\n inst.state = nextState;\n inst.context = nextContext;\n\n this._updateRenderedComponent(transaction, unmaskedContext);\n\n if (hasComponentDidUpdate) {\n if (process.env.NODE_ENV !== 'production') {\n transaction.getReactMountReady().enqueue(function () {\n measureLifeCyclePerf(inst.componentDidUpdate.bind(inst, prevProps, prevState, prevContext), _this2._debugID, 'componentDidUpdate');\n });\n } else {\n transaction.getReactMountReady().enqueue(inst.componentDidUpdate.bind(inst, prevProps, prevState, prevContext), inst);\n }\n }\n },\n\n /**\n * Call the component's `render` method and update the DOM accordingly.\n *\n * @param {ReactReconcileTransaction} transaction\n * @internal\n */\n _updateRenderedComponent: function (transaction, context) {\n var prevComponentInstance = this._renderedComponent;\n var prevRenderedElement = prevComponentInstance._currentElement;\n var nextRenderedElement = this._renderValidatedComponent();\n\n var debugID = 0;\n if (process.env.NODE_ENV !== 'production') {\n debugID = this._debugID;\n }\n\n if (shouldUpdateReactComponent(prevRenderedElement, nextRenderedElement)) {\n ReactReconciler.receiveComponent(prevComponentInstance, nextRenderedElement, transaction, this._processChildContext(context));\n } else {\n var oldHostNode = ReactReconciler.getHostNode(prevComponentInstance);\n ReactReconciler.unmountComponent(prevComponentInstance, false);\n\n var nodeType = ReactNodeTypes.getType(nextRenderedElement);\n this._renderedNodeType = nodeType;\n var child = this._instantiateReactComponent(nextRenderedElement, nodeType !== ReactNodeTypes.EMPTY /* shouldHaveDebugID */\n );\n this._renderedComponent = child;\n\n var nextMarkup = ReactReconciler.mountComponent(child, transaction, this._hostParent, this._hostContainerInfo, this._processChildContext(context), debugID);\n\n if (process.env.NODE_ENV !== 'production') {\n if (debugID !== 0) {\n var childDebugIDs = child._debugID !== 0 ? [child._debugID] : [];\n ReactInstrumentation.debugTool.onSetChildren(debugID, childDebugIDs);\n }\n }\n\n this._replaceNodeWithMarkup(oldHostNode, nextMarkup, prevComponentInstance);\n }\n },\n\n /**\n * Overridden in shallow rendering.\n *\n * @protected\n */\n _replaceNodeWithMarkup: function (oldHostNode, nextMarkup, prevInstance) {\n ReactComponentEnvironment.replaceNodeWithMarkup(oldHostNode, nextMarkup, prevInstance);\n },\n\n /**\n * @protected\n */\n _renderValidatedComponentWithoutOwnerOrContext: function () {\n var inst = this._instance;\n var renderedElement;\n\n if (process.env.NODE_ENV !== 'production') {\n renderedElement = measureLifeCyclePerf(function () {\n return inst.render();\n }, this._debugID, 'render');\n } else {\n renderedElement = inst.render();\n }\n\n if (process.env.NODE_ENV !== 'production') {\n // We allow auto-mocks to proceed as if they're returning null.\n if (renderedElement === undefined && inst.render._isMockFunction) {\n // This is probably bad practice. Consider warning here and\n // deprecating this convenience.\n renderedElement = null;\n }\n }\n\n return renderedElement;\n },\n\n /**\n * @private\n */\n _renderValidatedComponent: function () {\n var renderedElement;\n if (process.env.NODE_ENV !== 'production' || this._compositeType !== CompositeTypes.StatelessFunctional) {\n ReactCurrentOwner.current = this;\n try {\n renderedElement = this._renderValidatedComponentWithoutOwnerOrContext();\n } finally {\n ReactCurrentOwner.current = null;\n }\n } else {\n renderedElement = this._renderValidatedComponentWithoutOwnerOrContext();\n }\n !(\n // TODO: An `isValidNode` function would probably be more appropriate\n renderedElement === null || renderedElement === false || React.isValidElement(renderedElement)) ? process.env.NODE_ENV !== 'production' ? invariant(false, '%s.render(): A valid React element (or null) must be returned. You may have returned undefined, an array or some other invalid object.', this.getName() || 'ReactCompositeComponent') : _prodInvariant('109', this.getName() || 'ReactCompositeComponent') : void 0;\n\n return renderedElement;\n },\n\n /**\n * Lazily allocates the refs object and stores `component` as `ref`.\n *\n * @param {string} ref Reference name.\n * @param {component} component Component to store as `ref`.\n * @final\n * @private\n */\n attachRef: function (ref, component) {\n var inst = this.getPublicInstance();\n !(inst != null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Stateless function components cannot have refs.') : _prodInvariant('110') : void 0;\n var publicComponentInstance = component.getPublicInstance();\n if (process.env.NODE_ENV !== 'production') {\n var componentName = component && component.getName ? component.getName() : 'a component';\n process.env.NODE_ENV !== 'production' ? warning(publicComponentInstance != null || component._compositeType !== CompositeTypes.StatelessFunctional, 'Stateless function components cannot be given refs ' + '(See ref \"%s\" in %s created by %s). ' + 'Attempts to access this ref will fail.', ref, componentName, this.getName()) : void 0;\n }\n var refs = inst.refs === emptyObject ? inst.refs = {} : inst.refs;\n refs[ref] = publicComponentInstance;\n },\n\n /**\n * Detaches a reference name.\n *\n * @param {string} ref Name to dereference.\n * @final\n * @private\n */\n detachRef: function (ref) {\n var refs = this.getPublicInstance().refs;\n delete refs[ref];\n },\n\n /**\n * Get a text description of the component that can be used to identify it\n * in error messages.\n * @return {string} The name or null.\n * @internal\n */\n getName: function () {\n var type = this._currentElement.type;\n var constructor = this._instance && this._instance.constructor;\n return type.displayName || constructor && constructor.displayName || type.name || constructor && constructor.name || null;\n },\n\n /**\n * Get the publicly accessible representation of this component - i.e. what\n * is exposed by refs and returned by render. Can be null for stateless\n * components.\n *\n * @return {ReactComponent} the public component instance.\n * @internal\n */\n getPublicInstance: function () {\n var inst = this._instance;\n if (this._compositeType === CompositeTypes.StatelessFunctional) {\n return null;\n }\n return inst;\n },\n\n // Stub\n _instantiateReactComponent: null\n};\n\nmodule.exports = ReactCompositeComponent;","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar ReactReconciler = require('./ReactReconciler');\n\nvar instantiateReactComponent = require('./instantiateReactComponent');\nvar KeyEscapeUtils = require('./KeyEscapeUtils');\nvar shouldUpdateReactComponent = require('./shouldUpdateReactComponent');\nvar traverseAllChildren = require('./traverseAllChildren');\nvar warning = require('fbjs/lib/warning');\n\nvar ReactComponentTreeHook;\n\nif (typeof process !== 'undefined' && process.env && process.env.NODE_ENV === 'test') {\n // Temporary hack.\n // Inline requires don't work well with Jest:\n // https://github.com/facebook/react/issues/7240\n // Remove the inline requires when we don't need them anymore:\n // https://github.com/facebook/react/pull/7178\n ReactComponentTreeHook = require('react/lib/ReactComponentTreeHook');\n}\n\nfunction instantiateChild(childInstances, child, name, selfDebugID) {\n // We found a component instance.\n var keyUnique = childInstances[name] === undefined;\n if (process.env.NODE_ENV !== 'production') {\n if (!ReactComponentTreeHook) {\n ReactComponentTreeHook = require('react/lib/ReactComponentTreeHook');\n }\n if (!keyUnique) {\n process.env.NODE_ENV !== 'production' ? warning(false, 'flattenChildren(...): Encountered two children with the same key, ' + '`%s`. Child keys must be unique; when two children share a key, only ' + 'the first child will be used.%s', KeyEscapeUtils.unescape(name), ReactComponentTreeHook.getStackAddendumByID(selfDebugID)) : void 0;\n }\n }\n if (child != null && keyUnique) {\n childInstances[name] = instantiateReactComponent(child, true);\n }\n}\n\n/**\n * ReactChildReconciler provides helpers for initializing or updating a set of\n * children. Its output is suitable for passing it onto ReactMultiChild which\n * does diffed reordering and insertion.\n */\nvar ReactChildReconciler = {\n /**\n * Generates a \"mount image\" for each of the supplied children. In the case\n * of `ReactDOMComponent`, a mount image is a string of markup.\n *\n * @param {?object} nestedChildNodes Nested child maps.\n * @return {?object} A set of child instances.\n * @internal\n */\n instantiateChildren: function (nestedChildNodes, transaction, context, selfDebugID) // 0 in production and for roots\n {\n if (nestedChildNodes == null) {\n return null;\n }\n var childInstances = {};\n\n if (process.env.NODE_ENV !== 'production') {\n traverseAllChildren(nestedChildNodes, function (childInsts, child, name) {\n return instantiateChild(childInsts, child, name, selfDebugID);\n }, childInstances);\n } else {\n traverseAllChildren(nestedChildNodes, instantiateChild, childInstances);\n }\n return childInstances;\n },\n\n /**\n * Updates the rendered children and returns a new set of children.\n *\n * @param {?object} prevChildren Previously initialized set of children.\n * @param {?object} nextChildren Flat child element maps.\n * @param {ReactReconcileTransaction} transaction\n * @param {object} context\n * @return {?object} A new set of child instances.\n * @internal\n */\n updateChildren: function (prevChildren, nextChildren, mountImages, removedNodes, transaction, hostParent, hostContainerInfo, context, selfDebugID) // 0 in production and for roots\n {\n // We currently don't have a way to track moves here but if we use iterators\n // instead of for..in we can zip the iterators and check if an item has\n // moved.\n // TODO: If nothing has changed, return the prevChildren object so that we\n // can quickly bailout if nothing has changed.\n if (!nextChildren && !prevChildren) {\n return;\n }\n var name;\n var prevChild;\n for (name in nextChildren) {\n if (!nextChildren.hasOwnProperty(name)) {\n continue;\n }\n prevChild = prevChildren && prevChildren[name];\n var prevElement = prevChild && prevChild._currentElement;\n var nextElement = nextChildren[name];\n if (prevChild != null && shouldUpdateReactComponent(prevElement, nextElement)) {\n ReactReconciler.receiveComponent(prevChild, nextElement, transaction, context);\n nextChildren[name] = prevChild;\n } else {\n if (prevChild) {\n removedNodes[name] = ReactReconciler.getHostNode(prevChild);\n ReactReconciler.unmountComponent(prevChild, false);\n }\n // The child must be instantiated before it's mounted.\n var nextChildInstance = instantiateReactComponent(nextElement, true);\n nextChildren[name] = nextChildInstance;\n // Creating mount image now ensures refs are resolved in right order\n // (see https://github.com/facebook/react/pull/7101 for explanation).\n var nextChildMountImage = ReactReconciler.mountComponent(nextChildInstance, transaction, hostParent, hostContainerInfo, context, selfDebugID);\n mountImages.push(nextChildMountImage);\n }\n }\n // Unmount children that are no longer present.\n for (name in prevChildren) {\n if (prevChildren.hasOwnProperty(name) && !(nextChildren && nextChildren.hasOwnProperty(name))) {\n prevChild = prevChildren[name];\n removedNodes[name] = ReactReconciler.getHostNode(prevChild);\n ReactReconciler.unmountComponent(prevChild, false);\n }\n }\n },\n\n /**\n * Unmounts all rendered children. This should be used to clean up children\n * when this component is unmounted.\n *\n * @param {?object} renderedChildren Previously initialized set of children.\n * @internal\n */\n unmountChildren: function (renderedChildren, safely) {\n for (var name in renderedChildren) {\n if (renderedChildren.hasOwnProperty(name)) {\n var renderedChild = renderedChildren[name];\n ReactReconciler.unmountComponent(renderedChild, safely);\n }\n }\n }\n};\n\nmodule.exports = ReactChildReconciler;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar _prodInvariant = require('./reactProdInvariant');\n\nvar ReactComponentEnvironment = require('./ReactComponentEnvironment');\nvar ReactInstanceMap = require('./ReactInstanceMap');\nvar ReactInstrumentation = require('./ReactInstrumentation');\n\nvar ReactCurrentOwner = require('react/lib/ReactCurrentOwner');\nvar ReactReconciler = require('./ReactReconciler');\nvar ReactChildReconciler = require('./ReactChildReconciler');\n\nvar emptyFunction = require('fbjs/lib/emptyFunction');\nvar flattenChildren = require('./flattenChildren');\nvar invariant = require('fbjs/lib/invariant');\n\n/**\n * Make an update for markup to be rendered and inserted at a supplied index.\n *\n * @param {string} markup Markup that renders into an element.\n * @param {number} toIndex Destination index.\n * @private\n */\nfunction makeInsertMarkup(markup, afterNode, toIndex) {\n // NOTE: Null values reduce hidden classes.\n return {\n type: 'INSERT_MARKUP',\n content: markup,\n fromIndex: null,\n fromNode: null,\n toIndex: toIndex,\n afterNode: afterNode\n };\n}\n\n/**\n * Make an update for moving an existing element to another index.\n *\n * @param {number} fromIndex Source index of the existing element.\n * @param {number} toIndex Destination index of the element.\n * @private\n */\nfunction makeMove(child, afterNode, toIndex) {\n // NOTE: Null values reduce hidden classes.\n return {\n type: 'MOVE_EXISTING',\n content: null,\n fromIndex: child._mountIndex,\n fromNode: ReactReconciler.getHostNode(child),\n toIndex: toIndex,\n afterNode: afterNode\n };\n}\n\n/**\n * Make an update for removing an element at an index.\n *\n * @param {number} fromIndex Index of the element to remove.\n * @private\n */\nfunction makeRemove(child, node) {\n // NOTE: Null values reduce hidden classes.\n return {\n type: 'REMOVE_NODE',\n content: null,\n fromIndex: child._mountIndex,\n fromNode: node,\n toIndex: null,\n afterNode: null\n };\n}\n\n/**\n * Make an update for setting the markup of a node.\n *\n * @param {string} markup Markup that renders into an element.\n * @private\n */\nfunction makeSetMarkup(markup) {\n // NOTE: Null values reduce hidden classes.\n return {\n type: 'SET_MARKUP',\n content: markup,\n fromIndex: null,\n fromNode: null,\n toIndex: null,\n afterNode: null\n };\n}\n\n/**\n * Make an update for setting the text content.\n *\n * @param {string} textContent Text content to set.\n * @private\n */\nfunction makeTextContent(textContent) {\n // NOTE: Null values reduce hidden classes.\n return {\n type: 'TEXT_CONTENT',\n content: textContent,\n fromIndex: null,\n fromNode: null,\n toIndex: null,\n afterNode: null\n };\n}\n\n/**\n * Push an update, if any, onto the queue. Creates a new queue if none is\n * passed and always returns the queue. Mutative.\n */\nfunction enqueue(queue, update) {\n if (update) {\n queue = queue || [];\n queue.push(update);\n }\n return queue;\n}\n\n/**\n * Processes any enqueued updates.\n *\n * @private\n */\nfunction processQueue(inst, updateQueue) {\n ReactComponentEnvironment.processChildrenUpdates(inst, updateQueue);\n}\n\nvar setChildrenForInstrumentation = emptyFunction;\nif (process.env.NODE_ENV !== 'production') {\n var getDebugID = function (inst) {\n if (!inst._debugID) {\n // Check for ART-like instances. TODO: This is silly/gross.\n var internal;\n if (internal = ReactInstanceMap.get(inst)) {\n inst = internal;\n }\n }\n return inst._debugID;\n };\n setChildrenForInstrumentation = function (children) {\n var debugID = getDebugID(this);\n // TODO: React Native empty components are also multichild.\n // This means they still get into this method but don't have _debugID.\n if (debugID !== 0) {\n ReactInstrumentation.debugTool.onSetChildren(debugID, children ? Object.keys(children).map(function (key) {\n return children[key]._debugID;\n }) : []);\n }\n };\n}\n\n/**\n * ReactMultiChild are capable of reconciling multiple children.\n *\n * @class ReactMultiChild\n * @internal\n */\nvar ReactMultiChild = {\n /**\n * Provides common functionality for components that must reconcile multiple\n * children. This is used by `ReactDOMComponent` to mount, update, and\n * unmount child components.\n *\n * @lends {ReactMultiChild.prototype}\n */\n Mixin: {\n _reconcilerInstantiateChildren: function (nestedChildren, transaction, context) {\n if (process.env.NODE_ENV !== 'production') {\n var selfDebugID = getDebugID(this);\n if (this._currentElement) {\n try {\n ReactCurrentOwner.current = this._currentElement._owner;\n return ReactChildReconciler.instantiateChildren(nestedChildren, transaction, context, selfDebugID);\n } finally {\n ReactCurrentOwner.current = null;\n }\n }\n }\n return ReactChildReconciler.instantiateChildren(nestedChildren, transaction, context);\n },\n\n _reconcilerUpdateChildren: function (prevChildren, nextNestedChildrenElements, mountImages, removedNodes, transaction, context) {\n var nextChildren;\n var selfDebugID = 0;\n if (process.env.NODE_ENV !== 'production') {\n selfDebugID = getDebugID(this);\n if (this._currentElement) {\n try {\n ReactCurrentOwner.current = this._currentElement._owner;\n nextChildren = flattenChildren(nextNestedChildrenElements, selfDebugID);\n } finally {\n ReactCurrentOwner.current = null;\n }\n ReactChildReconciler.updateChildren(prevChildren, nextChildren, mountImages, removedNodes, transaction, this, this._hostContainerInfo, context, selfDebugID);\n return nextChildren;\n }\n }\n nextChildren = flattenChildren(nextNestedChildrenElements, selfDebugID);\n ReactChildReconciler.updateChildren(prevChildren, nextChildren, mountImages, removedNodes, transaction, this, this._hostContainerInfo, context, selfDebugID);\n return nextChildren;\n },\n\n /**\n * Generates a \"mount image\" for each of the supplied children. In the case\n * of `ReactDOMComponent`, a mount image is a string of markup.\n *\n * @param {?object} nestedChildren Nested child maps.\n * @return {array} An array of mounted representations.\n * @internal\n */\n mountChildren: function (nestedChildren, transaction, context) {\n var children = this._reconcilerInstantiateChildren(nestedChildren, transaction, context);\n this._renderedChildren = children;\n\n var mountImages = [];\n var index = 0;\n for (var name in children) {\n if (children.hasOwnProperty(name)) {\n var child = children[name];\n var selfDebugID = 0;\n if (process.env.NODE_ENV !== 'production') {\n selfDebugID = getDebugID(this);\n }\n var mountImage = ReactReconciler.mountComponent(child, transaction, this, this._hostContainerInfo, context, selfDebugID);\n child._mountIndex = index++;\n mountImages.push(mountImage);\n }\n }\n\n if (process.env.NODE_ENV !== 'production') {\n setChildrenForInstrumentation.call(this, children);\n }\n\n return mountImages;\n },\n\n /**\n * Replaces any rendered children with a text content string.\n *\n * @param {string} nextContent String of content.\n * @internal\n */\n updateTextContent: function (nextContent) {\n var prevChildren = this._renderedChildren;\n // Remove any rendered children.\n ReactChildReconciler.unmountChildren(prevChildren, false);\n for (var name in prevChildren) {\n if (prevChildren.hasOwnProperty(name)) {\n !false ? process.env.NODE_ENV !== 'production' ? invariant(false, 'updateTextContent called on non-empty component.') : _prodInvariant('118') : void 0;\n }\n }\n // Set new text content.\n var updates = [makeTextContent(nextContent)];\n processQueue(this, updates);\n },\n\n /**\n * Replaces any rendered children with a markup string.\n *\n * @param {string} nextMarkup String of markup.\n * @internal\n */\n updateMarkup: function (nextMarkup) {\n var prevChildren = this._renderedChildren;\n // Remove any rendered children.\n ReactChildReconciler.unmountChildren(prevChildren, false);\n for (var name in prevChildren) {\n if (prevChildren.hasOwnProperty(name)) {\n !false ? process.env.NODE_ENV !== 'production' ? invariant(false, 'updateTextContent called on non-empty component.') : _prodInvariant('118') : void 0;\n }\n }\n var updates = [makeSetMarkup(nextMarkup)];\n processQueue(this, updates);\n },\n\n /**\n * Updates the rendered children with new children.\n *\n * @param {?object} nextNestedChildrenElements Nested child element maps.\n * @param {ReactReconcileTransaction} transaction\n * @internal\n */\n updateChildren: function (nextNestedChildrenElements, transaction, context) {\n // Hook used by React ART\n this._updateChildren(nextNestedChildrenElements, transaction, context);\n },\n\n /**\n * @param {?object} nextNestedChildrenElements Nested child element maps.\n * @param {ReactReconcileTransaction} transaction\n * @final\n * @protected\n */\n _updateChildren: function (nextNestedChildrenElements, transaction, context) {\n var prevChildren = this._renderedChildren;\n var removedNodes = {};\n var mountImages = [];\n var nextChildren = this._reconcilerUpdateChildren(prevChildren, nextNestedChildrenElements, mountImages, removedNodes, transaction, context);\n if (!nextChildren && !prevChildren) {\n return;\n }\n var updates = null;\n var name;\n // `nextIndex` will increment for each child in `nextChildren`, but\n // `lastIndex` will be the last index visited in `prevChildren`.\n var nextIndex = 0;\n var lastIndex = 0;\n // `nextMountIndex` will increment for each newly mounted child.\n var nextMountIndex = 0;\n var lastPlacedNode = null;\n for (name in nextChildren) {\n if (!nextChildren.hasOwnProperty(name)) {\n continue;\n }\n var prevChild = prevChildren && prevChildren[name];\n var nextChild = nextChildren[name];\n if (prevChild === nextChild) {\n updates = enqueue(updates, this.moveChild(prevChild, lastPlacedNode, nextIndex, lastIndex));\n lastIndex = Math.max(prevChild._mountIndex, lastIndex);\n prevChild._mountIndex = nextIndex;\n } else {\n if (prevChild) {\n // Update `lastIndex` before `_mountIndex` gets unset by unmounting.\n lastIndex = Math.max(prevChild._mountIndex, lastIndex);\n // The `removedNodes` loop below will actually remove the child.\n }\n // The child must be instantiated before it's mounted.\n updates = enqueue(updates, this._mountChildAtIndex(nextChild, mountImages[nextMountIndex], lastPlacedNode, nextIndex, transaction, context));\n nextMountIndex++;\n }\n nextIndex++;\n lastPlacedNode = ReactReconciler.getHostNode(nextChild);\n }\n // Remove children that are no longer present.\n for (name in removedNodes) {\n if (removedNodes.hasOwnProperty(name)) {\n updates = enqueue(updates, this._unmountChild(prevChildren[name], removedNodes[name]));\n }\n }\n if (updates) {\n processQueue(this, updates);\n }\n this._renderedChildren = nextChildren;\n\n if (process.env.NODE_ENV !== 'production') {\n setChildrenForInstrumentation.call(this, nextChildren);\n }\n },\n\n /**\n * Unmounts all rendered children. This should be used to clean up children\n * when this component is unmounted. It does not actually perform any\n * backend operations.\n *\n * @internal\n */\n unmountChildren: function (safely) {\n var renderedChildren = this._renderedChildren;\n ReactChildReconciler.unmountChildren(renderedChildren, safely);\n this._renderedChildren = null;\n },\n\n /**\n * Moves a child component to the supplied index.\n *\n * @param {ReactComponent} child Component to move.\n * @param {number} toIndex Destination index of the element.\n * @param {number} lastIndex Last index visited of the siblings of `child`.\n * @protected\n */\n moveChild: function (child, afterNode, toIndex, lastIndex) {\n // If the index of `child` is less than `lastIndex`, then it needs to\n // be moved. Otherwise, we do not need to move it because a child will be\n // inserted or moved before `child`.\n if (child._mountIndex < lastIndex) {\n return makeMove(child, afterNode, toIndex);\n }\n },\n\n /**\n * Creates a child component.\n *\n * @param {ReactComponent} child Component to create.\n * @param {string} mountImage Markup to insert.\n * @protected\n */\n createChild: function (child, afterNode, mountImage) {\n return makeInsertMarkup(mountImage, afterNode, child._mountIndex);\n },\n\n /**\n * Removes a child component.\n *\n * @param {ReactComponent} child Child to remove.\n * @protected\n */\n removeChild: function (child, node) {\n return makeRemove(child, node);\n },\n\n /**\n * Mounts a child with the supplied name.\n *\n * NOTE: This is part of `updateChildren` and is here for readability.\n *\n * @param {ReactComponent} child Component to mount.\n * @param {string} name Name of the child.\n * @param {number} index Index at which to insert the child.\n * @param {ReactReconcileTransaction} transaction\n * @private\n */\n _mountChildAtIndex: function (child, mountImage, afterNode, index, transaction, context) {\n child._mountIndex = index;\n return this.createChild(child, afterNode, mountImage);\n },\n\n /**\n * Unmounts a rendered child.\n *\n * NOTE: This is part of `updateChildren` and is here for readability.\n *\n * @param {ReactComponent} child Component to unmount.\n * @private\n */\n _unmountChild: function (child, node) {\n var update = this.removeChild(child, node);\n child._mountIndex = null;\n return update;\n }\n }\n};\n\nmodule.exports = ReactMultiChild;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar _prodInvariant = require('./reactProdInvariant'),\n _assign = require('object-assign');\n\nvar LinkedValueUtils = require('./LinkedValueUtils');\nvar ReactDOMComponentTree = require('./ReactDOMComponentTree');\nvar ReactUpdates = require('./ReactUpdates');\n\nvar invariant = require('fbjs/lib/invariant');\nvar warning = require('fbjs/lib/warning');\n\nvar didWarnValueLink = false;\nvar didWarnValDefaultVal = false;\n\nfunction forceUpdateIfMounted() {\n if (this._rootNodeID) {\n // DOM component is still mounted; update\n ReactDOMTextarea.updateWrapper(this);\n }\n}\n\n/**\n * Implements a <textarea> host component that allows setting `value`, and\n * `defaultValue`. This differs from the traditional DOM API because value is\n * usually set as PCDATA children.\n *\n * If `value` is not supplied (or null/undefined), user actions that affect the\n * value will trigger updates to the element.\n *\n * If `value` is supplied (and not null/undefined), the rendered element will\n * not trigger updates to the element. Instead, the `value` prop must change in\n * order for the rendered element to be updated.\n *\n * The rendered element will be initialized with an empty value, the prop\n * `defaultValue` if specified, or the children content (deprecated).\n */\nvar ReactDOMTextarea = {\n getHostProps: function (inst, props) {\n !(props.dangerouslySetInnerHTML == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, '`dangerouslySetInnerHTML` does not make sense on <textarea>.') : _prodInvariant('91') : void 0;\n\n // Always set children to the same thing. In IE9, the selection range will\n // get reset if `textContent` is mutated. We could add a check in setTextContent\n // to only set the value if/when the value differs from the node value (which would\n // completely solve this IE9 bug), but Sebastian+Ben seemed to like this solution.\n // The value can be a boolean or object so that's why it's forced to be a string.\n var hostProps = _assign({}, props, {\n value: undefined,\n defaultValue: undefined,\n children: '' + inst._wrapperState.initialValue,\n onChange: inst._wrapperState.onChange\n });\n\n return hostProps;\n },\n\n mountWrapper: function (inst, props) {\n if (process.env.NODE_ENV !== 'production') {\n LinkedValueUtils.checkPropTypes('textarea', props, inst._currentElement._owner);\n if (props.valueLink !== undefined && !didWarnValueLink) {\n process.env.NODE_ENV !== 'production' ? warning(false, '`valueLink` prop on `textarea` is deprecated; set `value` and `onChange` instead.') : void 0;\n didWarnValueLink = true;\n }\n if (props.value !== undefined && props.defaultValue !== undefined && !didWarnValDefaultVal) {\n process.env.NODE_ENV !== 'production' ? warning(false, 'Textarea elements must be either controlled or uncontrolled ' + '(specify either the value prop, or the defaultValue prop, but not ' + 'both). Decide between using a controlled or uncontrolled textarea ' + 'and remove one of these props. More info: ' + 'https://fb.me/react-controlled-components') : void 0;\n didWarnValDefaultVal = true;\n }\n }\n\n var value = LinkedValueUtils.getValue(props);\n var initialValue = value;\n\n // Only bother fetching default value if we're going to use it\n if (value == null) {\n var defaultValue = props.defaultValue;\n // TODO (yungsters): Remove support for children content in <textarea>.\n var children = props.children;\n if (children != null) {\n if (process.env.NODE_ENV !== 'production') {\n process.env.NODE_ENV !== 'production' ? warning(false, 'Use the `defaultValue` or `value` props instead of setting ' + 'children on <textarea>.') : void 0;\n }\n !(defaultValue == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'If you supply `defaultValue` on a <textarea>, do not pass children.') : _prodInvariant('92') : void 0;\n if (Array.isArray(children)) {\n !(children.length <= 1) ? process.env.NODE_ENV !== 'production' ? invariant(false, '<textarea> can only have at most one child.') : _prodInvariant('93') : void 0;\n children = children[0];\n }\n\n defaultValue = '' + children;\n }\n if (defaultValue == null) {\n defaultValue = '';\n }\n initialValue = defaultValue;\n }\n\n inst._wrapperState = {\n initialValue: '' + initialValue,\n listeners: null,\n onChange: _handleChange.bind(inst)\n };\n },\n\n updateWrapper: function (inst) {\n var props = inst._currentElement.props;\n\n var node = ReactDOMComponentTree.getNodeFromInstance(inst);\n var value = LinkedValueUtils.getValue(props);\n if (value != null) {\n // Cast `value` to a string to ensure the value is set correctly. While\n // browsers typically do this as necessary, jsdom doesn't.\n var newValue = '' + value;\n\n // To avoid side effects (such as losing text selection), only set value if changed\n if (newValue !== node.value) {\n node.value = newValue;\n }\n if (props.defaultValue == null) {\n node.defaultValue = newValue;\n }\n }\n if (props.defaultValue != null) {\n node.defaultValue = props.defaultValue;\n }\n },\n\n postMountWrapper: function (inst) {\n // This is in postMount because we need access to the DOM node, which is not\n // available until after the component has mounted.\n var node = ReactDOMComponentTree.getNodeFromInstance(inst);\n var textContent = node.textContent;\n\n // Only set node.value if textContent is equal to the expected\n // initial value. In IE10/IE11 there is a bug where the placeholder attribute\n // will populate textContent as well.\n // https://developer.microsoft.com/microsoft-edge/platform/issues/101525/\n if (textContent === inst._wrapperState.initialValue) {\n node.value = textContent;\n }\n }\n};\n\nfunction _handleChange(event) {\n var props = this._currentElement.props;\n var returnValue = LinkedValueUtils.executeOnChange(props, event);\n ReactUpdates.asap(forceUpdateIfMounted, this);\n return returnValue;\n}\n\nmodule.exports = ReactDOMTextarea;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar _assign = require('object-assign');\n\nvar React = require('react/lib/React');\nvar ReactDOMComponentTree = require('./ReactDOMComponentTree');\nvar ReactDOMSelect = require('./ReactDOMSelect');\n\nvar warning = require('fbjs/lib/warning');\nvar didWarnInvalidOptionChildren = false;\n\nfunction flattenChildren(children) {\n var content = '';\n\n // Flatten children and warn if they aren't strings or numbers;\n // invalid types are ignored.\n React.Children.forEach(children, function (child) {\n if (child == null) {\n return;\n }\n if (typeof child === 'string' || typeof child === 'number') {\n content += child;\n } else if (!didWarnInvalidOptionChildren) {\n didWarnInvalidOptionChildren = true;\n process.env.NODE_ENV !== 'production' ? warning(false, 'Only strings and numbers are supported as <option> children.') : void 0;\n }\n });\n\n return content;\n}\n\n/**\n * Implements an <option> host component that warns when `selected` is set.\n */\nvar ReactDOMOption = {\n mountWrapper: function (inst, props, hostParent) {\n // TODO (yungsters): Remove support for `selected` in <option>.\n if (process.env.NODE_ENV !== 'production') {\n process.env.NODE_ENV !== 'production' ? warning(props.selected == null, 'Use the `defaultValue` or `value` props on <select> instead of ' + 'setting `selected` on <option>.') : void 0;\n }\n\n // Look up whether this option is 'selected'\n var selectValue = null;\n if (hostParent != null) {\n var selectParent = hostParent;\n\n if (selectParent._tag === 'optgroup') {\n selectParent = selectParent._hostParent;\n }\n\n if (selectParent != null && selectParent._tag === 'select') {\n selectValue = ReactDOMSelect.getSelectValueContext(selectParent);\n }\n }\n\n // If the value is null (e.g., no specified value or after initial mount)\n // or missing (e.g., for <datalist>), we don't change props.selected\n var selected = null;\n if (selectValue != null) {\n var value;\n if (props.value != null) {\n value = props.value + '';\n } else {\n value = flattenChildren(props.children);\n }\n selected = false;\n if (Array.isArray(selectValue)) {\n // multiple\n for (var i = 0; i < selectValue.length; i++) {\n if ('' + selectValue[i] === value) {\n selected = true;\n break;\n }\n }\n } else {\n selected = '' + selectValue === value;\n }\n }\n\n inst._wrapperState = { selected: selected };\n },\n\n postMountWrapper: function (inst) {\n // value=\"\" should make a value attribute (#6219)\n var props = inst._currentElement.props;\n if (props.value != null) {\n var node = ReactDOMComponentTree.getNodeFromInstance(inst);\n node.setAttribute('value', props.value);\n }\n },\n\n getHostProps: function (inst, props) {\n var hostProps = _assign({ selected: undefined, children: undefined }, props);\n\n // Read state only from initial mount because <select> updates value\n // manually; we need the initial state only for server rendering\n if (inst._wrapperState.selected != null) {\n hostProps.selected = inst._wrapperState.selected;\n }\n\n var content = flattenChildren(props.children);\n\n if (content) {\n hostProps.children = content;\n }\n\n return hostProps;\n }\n};\n\nmodule.exports = ReactDOMOption;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nif (process.env.NODE_ENV !== 'production') {\n var invariant = require('fbjs/lib/invariant');\n var warning = require('fbjs/lib/warning');\n var ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');\n var loggedTypeFailures = {};\n}\n\n/**\n * Assert that the values match with the type specs.\n * Error messages are memorized and will only be shown once.\n *\n * @param {object} typeSpecs Map of name to a ReactPropType\n * @param {object} values Runtime values that need to be type-checked\n * @param {string} location e.g. \"prop\", \"context\", \"child context\"\n * @param {string} componentName Name of the component for error messages.\n * @param {?Function} getStack Returns the component stack.\n * @private\n */\nfunction checkPropTypes(typeSpecs, values, location, componentName, getStack) {\n if (process.env.NODE_ENV !== 'production') {\n for (var typeSpecName in typeSpecs) {\n if (typeSpecs.hasOwnProperty(typeSpecName)) {\n var error;\n // Prop type validation may throw. In case they do, we don't want to\n // fail the render phase where it didn't fail before. So we log it.\n // After these have been cleaned up, we'll let them throw.\n try {\n // This is intentionally an invariant that gets caught. It's the same\n // behavior as without this statement except with a better message.\n invariant(typeof typeSpecs[typeSpecName] === 'function', '%s: %s type `%s` is invalid; it must be a function, usually from ' + 'the `prop-types` package, but received `%s`.', componentName || 'React class', location, typeSpecName, typeof typeSpecs[typeSpecName]);\n error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);\n } catch (ex) {\n error = ex;\n }\n warning(!error || error instanceof Error, '%s: type specification of %s `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', location, typeSpecName, typeof error);\n if (error instanceof Error && !(error.message in loggedTypeFailures)) {\n // Only monitor this failure once because there tends to be a lot of the\n // same error.\n loggedTypeFailures[error.message] = true;\n\n var stack = getStack ? getStack() : '';\n\n warning(false, 'Failed %s type: %s%s', location, error.message, stack != null ? stack : '');\n }\n }\n }\n }\n}\n\nmodule.exports = checkPropTypes;\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';\n\nmodule.exports = ReactPropTypesSecret;\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar emptyFunction = require('fbjs/lib/emptyFunction');\nvar invariant = require('fbjs/lib/invariant');\nvar warning = require('fbjs/lib/warning');\nvar assign = require('object-assign');\n\nvar ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');\nvar checkPropTypes = require('./checkPropTypes');\n\nmodule.exports = function(isValidElement, throwOnDirectAccess) {\n /* global Symbol */\n var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;\n var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.\n\n /**\n * Returns the iterator method function contained on the iterable object.\n *\n * Be sure to invoke the function with the iterable as context:\n *\n * var iteratorFn = getIteratorFn(myIterable);\n * if (iteratorFn) {\n * var iterator = iteratorFn.call(myIterable);\n * ...\n * }\n *\n * @param {?object} maybeIterable\n * @return {?function}\n */\n function getIteratorFn(maybeIterable) {\n var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);\n if (typeof iteratorFn === 'function') {\n return iteratorFn;\n }\n }\n\n /**\n * Collection of methods that allow declaration and validation of props that are\n * supplied to React components. Example usage:\n *\n * var Props = require('ReactPropTypes');\n * var MyArticle = React.createClass({\n * propTypes: {\n * // An optional string prop named \"description\".\n * description: Props.string,\n *\n * // A required enum prop named \"category\".\n * category: Props.oneOf(['News','Photos']).isRequired,\n *\n * // A prop named \"dialog\" that requires an instance of Dialog.\n * dialog: Props.instanceOf(Dialog).isRequired\n * },\n * render: function() { ... }\n * });\n *\n * A more formal specification of how these methods are used:\n *\n * type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...)\n * decl := ReactPropTypes.{type}(.isRequired)?\n *\n * Each and every declaration produces a function with the same signature. This\n * allows the creation of custom validation functions. For example:\n *\n * var MyLink = React.createClass({\n * propTypes: {\n * // An optional string or URI prop named \"href\".\n * href: function(props, propName, componentName) {\n * var propValue = props[propName];\n * if (propValue != null && typeof propValue !== 'string' &&\n * !(propValue instanceof URI)) {\n * return new Error(\n * 'Expected a string or an URI for ' + propName + ' in ' +\n * componentName\n * );\n * }\n * }\n * },\n * render: function() {...}\n * });\n *\n * @internal\n */\n\n var ANONYMOUS = '<<anonymous>>';\n\n // Important!\n // Keep this list in sync with production version in `./factoryWithThrowingShims.js`.\n var ReactPropTypes = {\n array: createPrimitiveTypeChecker('array'),\n bool: createPrimitiveTypeChecker('boolean'),\n func: createPrimitiveTypeChecker('function'),\n number: createPrimitiveTypeChecker('number'),\n object: createPrimitiveTypeChecker('object'),\n string: createPrimitiveTypeChecker('string'),\n symbol: createPrimitiveTypeChecker('symbol'),\n\n any: createAnyTypeChecker(),\n arrayOf: createArrayOfTypeChecker,\n element: createElementTypeChecker(),\n instanceOf: createInstanceTypeChecker,\n node: createNodeChecker(),\n objectOf: createObjectOfTypeChecker,\n oneOf: createEnumTypeChecker,\n oneOfType: createUnionTypeChecker,\n shape: createShapeTypeChecker,\n exact: createStrictShapeTypeChecker,\n };\n\n /**\n * inlined Object.is polyfill to avoid requiring consumers ship their own\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is\n */\n /*eslint-disable no-self-compare*/\n function is(x, y) {\n // SameValue algorithm\n if (x === y) {\n // Steps 1-5, 7-10\n // Steps 6.b-6.e: +0 != -0\n return x !== 0 || 1 / x === 1 / y;\n } else {\n // Step 6.a: NaN == NaN\n return x !== x && y !== y;\n }\n }\n /*eslint-enable no-self-compare*/\n\n /**\n * We use an Error-like object for backward compatibility as people may call\n * PropTypes directly and inspect their output. However, we don't use real\n * Errors anymore. We don't inspect their stack anyway, and creating them\n * is prohibitively expensive if they are created too often, such as what\n * happens in oneOfType() for any type before the one that matched.\n */\n function PropTypeError(message) {\n this.message = message;\n this.stack = '';\n }\n // Make `instanceof Error` still work for returned errors.\n PropTypeError.prototype = Error.prototype;\n\n function createChainableTypeChecker(validate) {\n if (process.env.NODE_ENV !== 'production') {\n var manualPropTypeCallCache = {};\n var manualPropTypeWarningCount = 0;\n }\n function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {\n componentName = componentName || ANONYMOUS;\n propFullName = propFullName || propName;\n\n if (secret !== ReactPropTypesSecret) {\n if (throwOnDirectAccess) {\n // New behavior only for users of `prop-types` package\n invariant(\n false,\n 'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +\n 'Use `PropTypes.checkPropTypes()` to call them. ' +\n 'Read more at http://fb.me/use-check-prop-types'\n );\n } else if (process.env.NODE_ENV !== 'production' && typeof console !== 'undefined') {\n // Old behavior for people using React.PropTypes\n var cacheKey = componentName + ':' + propName;\n if (\n !manualPropTypeCallCache[cacheKey] &&\n // Avoid spamming the console because they are often not actionable except for lib authors\n manualPropTypeWarningCount < 3\n ) {\n warning(\n false,\n 'You are manually calling a React.PropTypes validation ' +\n 'function for the `%s` prop on `%s`. This is deprecated ' +\n 'and will throw in the standalone `prop-types` package. ' +\n 'You may be seeing this warning due to a third-party PropTypes ' +\n 'library. See https://fb.me/react-warning-dont-call-proptypes ' + 'for details.',\n propFullName,\n componentName\n );\n manualPropTypeCallCache[cacheKey] = true;\n manualPropTypeWarningCount++;\n }\n }\n }\n if (props[propName] == null) {\n if (isRequired) {\n if (props[propName] === null) {\n return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));\n }\n return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.'));\n }\n return null;\n } else {\n return validate(props, propName, componentName, location, propFullName);\n }\n }\n\n var chainedCheckType = checkType.bind(null, false);\n chainedCheckType.isRequired = checkType.bind(null, true);\n\n return chainedCheckType;\n }\n\n function createPrimitiveTypeChecker(expectedType) {\n function validate(props, propName, componentName, location, propFullName, secret) {\n var propValue = props[propName];\n var propType = getPropType(propValue);\n if (propType !== expectedType) {\n // `propValue` being instance of, say, date/regexp, pass the 'object'\n // check, but we can offer a more precise error message here rather than\n // 'of type `object`'.\n var preciseType = getPreciseType(propValue);\n\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'));\n }\n return null;\n }\n return createChainableTypeChecker(validate);\n }\n\n function createAnyTypeChecker() {\n return createChainableTypeChecker(emptyFunction.thatReturnsNull);\n }\n\n function createArrayOfTypeChecker(typeChecker) {\n function validate(props, propName, componentName, location, propFullName) {\n if (typeof typeChecker !== 'function') {\n return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside arrayOf.');\n }\n var propValue = props[propName];\n if (!Array.isArray(propValue)) {\n var propType = getPropType(propValue);\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an array.'));\n }\n for (var i = 0; i < propValue.length; i++) {\n var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']', ReactPropTypesSecret);\n if (error instanceof Error) {\n return error;\n }\n }\n return null;\n }\n return createChainableTypeChecker(validate);\n }\n\n function createElementTypeChecker() {\n function validate(props, propName, componentName, location, propFullName) {\n var propValue = props[propName];\n if (!isValidElement(propValue)) {\n var propType = getPropType(propValue);\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement.'));\n }\n return null;\n }\n return createChainableTypeChecker(validate);\n }\n\n function createInstanceTypeChecker(expectedClass) {\n function validate(props, propName, componentName, location, propFullName) {\n if (!(props[propName] instanceof expectedClass)) {\n var expectedClassName = expectedClass.name || ANONYMOUS;\n var actualClassName = getClassName(props[propName]);\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.'));\n }\n return null;\n }\n return createChainableTypeChecker(validate);\n }\n\n function createEnumTypeChecker(expectedValues) {\n if (!Array.isArray(expectedValues)) {\n process.env.NODE_ENV !== 'production' ? warning(false, 'Invalid argument supplied to oneOf, expected an instance of array.') : void 0;\n return emptyFunction.thatReturnsNull;\n }\n\n function validate(props, propName, componentName, location, propFullName) {\n var propValue = props[propName];\n for (var i = 0; i < expectedValues.length; i++) {\n if (is(propValue, expectedValues[i])) {\n return null;\n }\n }\n\n var valuesString = JSON.stringify(expectedValues);\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + propValue + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));\n }\n return createChainableTypeChecker(validate);\n }\n\n function createObjectOfTypeChecker(typeChecker) {\n function validate(props, propName, componentName, location, propFullName) {\n if (typeof typeChecker !== 'function') {\n return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.');\n }\n var propValue = props[propName];\n var propType = getPropType(propValue);\n if (propType !== 'object') {\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.'));\n }\n for (var key in propValue) {\n if (propValue.hasOwnProperty(key)) {\n var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);\n if (error instanceof Error) {\n return error;\n }\n }\n }\n return null;\n }\n return createChainableTypeChecker(validate);\n }\n\n function createUnionTypeChecker(arrayOfTypeCheckers) {\n if (!Array.isArray(arrayOfTypeCheckers)) {\n process.env.NODE_ENV !== 'production' ? warning(false, 'Invalid argument supplied to oneOfType, expected an instance of array.') : void 0;\n return emptyFunction.thatReturnsNull;\n }\n\n for (var i = 0; i < arrayOfTypeCheckers.length; i++) {\n var checker = arrayOfTypeCheckers[i];\n if (typeof checker !== 'function') {\n warning(\n false,\n 'Invalid argument supplied to oneOfType. Expected an array of check functions, but ' +\n 'received %s at index %s.',\n getPostfixForTypeWarning(checker),\n i\n );\n return emptyFunction.thatReturnsNull;\n }\n }\n\n function validate(props, propName, componentName, location, propFullName) {\n for (var i = 0; i < arrayOfTypeCheckers.length; i++) {\n var checker = arrayOfTypeCheckers[i];\n if (checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret) == null) {\n return null;\n }\n }\n\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`.'));\n }\n return createChainableTypeChecker(validate);\n }\n\n function createNodeChecker() {\n function validate(props, propName, componentName, location, propFullName) {\n if (!isNode(props[propName])) {\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.'));\n }\n return null;\n }\n return createChainableTypeChecker(validate);\n }\n\n function createShapeTypeChecker(shapeTypes) {\n function validate(props, propName, componentName, location, propFullName) {\n var propValue = props[propName];\n var propType = getPropType(propValue);\n if (propType !== 'object') {\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));\n }\n for (var key in shapeTypes) {\n var checker = shapeTypes[key];\n if (!checker) {\n continue;\n }\n var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);\n if (error) {\n return error;\n }\n }\n return null;\n }\n return createChainableTypeChecker(validate);\n }\n\n function createStrictShapeTypeChecker(shapeTypes) {\n function validate(props, propName, componentName, location, propFullName) {\n var propValue = props[propName];\n var propType = getPropType(propValue);\n if (propType !== 'object') {\n return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));\n }\n // We need to check all keys in case some are required but missing from\n // props.\n var allKeys = assign({}, props[propName], shapeTypes);\n for (var key in allKeys) {\n var checker = shapeTypes[key];\n if (!checker) {\n return new PropTypeError(\n 'Invalid ' + location + ' `' + propFullName + '` key `' + key + '` supplied to `' + componentName + '`.' +\n '\\nBad object: ' + JSON.stringify(props[propName], null, ' ') +\n '\\nValid keys: ' + JSON.stringify(Object.keys(shapeTypes), null, ' ')\n );\n }\n var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);\n if (error) {\n return error;\n }\n }\n return null;\n }\n\n return createChainableTypeChecker(validate);\n }\n\n function isNode(propValue) {\n switch (typeof propValue) {\n case 'number':\n case 'string':\n case 'undefined':\n return true;\n case 'boolean':\n return !propValue;\n case 'object':\n if (Array.isArray(propValue)) {\n return propValue.every(isNode);\n }\n if (propValue === null || isValidElement(propValue)) {\n return true;\n }\n\n var iteratorFn = getIteratorFn(propValue);\n if (iteratorFn) {\n var iterator = iteratorFn.call(propValue);\n var step;\n if (iteratorFn !== propValue.entries) {\n while (!(step = iterator.next()).done) {\n if (!isNode(step.value)) {\n return false;\n }\n }\n } else {\n // Iterator will provide entry [k,v] tuples rather than values.\n while (!(step = iterator.next()).done) {\n var entry = step.value;\n if (entry) {\n if (!isNode(entry[1])) {\n return false;\n }\n }\n }\n }\n } else {\n return false;\n }\n\n return true;\n default:\n return false;\n }\n }\n\n function isSymbol(propType, propValue) {\n // Native Symbol.\n if (propType === 'symbol') {\n return true;\n }\n\n // 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'\n if (propValue['@@toStringTag'] === 'Symbol') {\n return true;\n }\n\n // Fallback for non-spec compliant Symbols which are polyfilled.\n if (typeof Symbol === 'function' && propValue instanceof Symbol) {\n return true;\n }\n\n return false;\n }\n\n // Equivalent of `typeof` but with special handling for array and regexp.\n function getPropType(propValue) {\n var propType = typeof propValue;\n if (Array.isArray(propValue)) {\n return 'array';\n }\n if (propValue instanceof RegExp) {\n // Old webkits (at least until Android 4.0) return 'function' rather than\n // 'object' for typeof a RegExp. We'll normalize this here so that /bla/\n // passes PropTypes.object.\n return 'object';\n }\n if (isSymbol(propType, propValue)) {\n return 'symbol';\n }\n return propType;\n }\n\n // This handles more types than `getPropType`. Only used for error messages.\n // See `createPrimitiveTypeChecker`.\n function getPreciseType(propValue) {\n if (typeof propValue === 'undefined' || propValue === null) {\n return '' + propValue;\n }\n var propType = getPropType(propValue);\n if (propType === 'object') {\n if (propValue instanceof Date) {\n return 'date';\n } else if (propValue instanceof RegExp) {\n return 'regexp';\n }\n }\n return propType;\n }\n\n // Returns a string that is postfixed to a warning about an invalid type.\n // For example, \"undefined\" or \"of type array\"\n function getPostfixForTypeWarning(value) {\n var type = getPreciseType(value);\n switch (type) {\n case 'array':\n case 'object':\n return 'an ' + type;\n case 'boolean':\n case 'date':\n case 'regexp':\n return 'a ' + type;\n default:\n return type;\n }\n }\n\n // Returns class name of the object, if any.\n function getClassName(propValue) {\n if (!propValue.constructor || !propValue.constructor.name) {\n return ANONYMOUS;\n }\n return propValue.constructor.name;\n }\n\n ReactPropTypes.checkPropTypes = checkPropTypes;\n ReactPropTypes.PropTypes = ReactPropTypes;\n\n return ReactPropTypes;\n};\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\n// React 15.5 references this module, and assumes PropTypes are still callable in production.\n// Therefore we re-export development-only version with all the PropTypes checks here.\n// However if one is migrating to the `prop-types` npm library, they will go through the\n// `index.js` entry point, and it will branch depending on the environment.\nvar factory = require('./factoryWithTypeCheckers');\nmodule.exports = function(isValidElement) {\n // It is still allowed in 15.5.\n var throwOnDirectAccess = false;\n return factory(isValidElement, throwOnDirectAccess);\n};\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n */\n\n'use strict';\n\nvar ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';\n\nmodule.exports = ReactPropTypesSecret;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar _prodInvariant = require('./reactProdInvariant'),\n _assign = require('object-assign');\n\nvar DOMPropertyOperations = require('./DOMPropertyOperations');\nvar LinkedValueUtils = require('./LinkedValueUtils');\nvar ReactDOMComponentTree = require('./ReactDOMComponentTree');\nvar ReactUpdates = require('./ReactUpdates');\n\nvar invariant = require('fbjs/lib/invariant');\nvar warning = require('fbjs/lib/warning');\n\nvar didWarnValueLink = false;\nvar didWarnCheckedLink = false;\nvar didWarnValueDefaultValue = false;\nvar didWarnCheckedDefaultChecked = false;\nvar didWarnControlledToUncontrolled = false;\nvar didWarnUncontrolledToControlled = false;\n\nfunction forceUpdateIfMounted() {\n if (this._rootNodeID) {\n // DOM component is still mounted; update\n ReactDOMInput.updateWrapper(this);\n }\n}\n\nfunction isControlled(props) {\n var usesChecked = props.type === 'checkbox' || props.type === 'radio';\n return usesChecked ? props.checked != null : props.value != null;\n}\n\n/**\n * Implements an <input> host component that allows setting these optional\n * props: `checked`, `value`, `defaultChecked`, and `defaultValue`.\n *\n * If `checked` or `value` are not supplied (or null/undefined), user actions\n * that affect the checked state or value will trigger updates to the element.\n *\n * If they are supplied (and not null/undefined), the rendered element will not\n * trigger updates to the element. Instead, the props must change in order for\n * the rendered element to be updated.\n *\n * The rendered element will be initialized as unchecked (or `defaultChecked`)\n * with an empty value (or `defaultValue`).\n *\n * @see http://www.w3.org/TR/2012/WD-html5-20121025/the-input-element.html\n */\nvar ReactDOMInput = {\n getHostProps: function (inst, props) {\n var value = LinkedValueUtils.getValue(props);\n var checked = LinkedValueUtils.getChecked(props);\n\n var hostProps = _assign({\n // Make sure we set .type before any other properties (setting .value\n // before .type means .value is lost in IE11 and below)\n type: undefined,\n // Make sure we set .step before .value (setting .value before .step\n // means .value is rounded on mount, based upon step precision)\n step: undefined,\n // Make sure we set .min & .max before .value (to ensure proper order\n // in corner cases such as min or max deriving from value, e.g. Issue #7170)\n min: undefined,\n max: undefined\n }, props, {\n defaultChecked: undefined,\n defaultValue: undefined,\n value: value != null ? value : inst._wrapperState.initialValue,\n checked: checked != null ? checked : inst._wrapperState.initialChecked,\n onChange: inst._wrapperState.onChange\n });\n\n return hostProps;\n },\n\n mountWrapper: function (inst, props) {\n if (process.env.NODE_ENV !== 'production') {\n LinkedValueUtils.checkPropTypes('input', props, inst._currentElement._owner);\n\n var owner = inst._currentElement._owner;\n\n if (props.valueLink !== undefined && !didWarnValueLink) {\n process.env.NODE_ENV !== 'production' ? warning(false, '`valueLink` prop on `input` is deprecated; set `value` and `onChange` instead.') : void 0;\n didWarnValueLink = true;\n }\n if (props.checkedLink !== undefined && !didWarnCheckedLink) {\n process.env.NODE_ENV !== 'production' ? warning(false, '`checkedLink` prop on `input` is deprecated; set `value` and `onChange` instead.') : void 0;\n didWarnCheckedLink = true;\n }\n if (props.checked !== undefined && props.defaultChecked !== undefined && !didWarnCheckedDefaultChecked) {\n process.env.NODE_ENV !== 'production' ? warning(false, '%s contains an input of type %s with both checked and defaultChecked props. ' + 'Input elements must be either controlled or uncontrolled ' + '(specify either the checked prop, or the defaultChecked prop, but not ' + 'both). Decide between using a controlled or uncontrolled input ' + 'element and remove one of these props. More info: ' + 'https://fb.me/react-controlled-components', owner && owner.getName() || 'A component', props.type) : void 0;\n didWarnCheckedDefaultChecked = true;\n }\n if (props.value !== undefined && props.defaultValue !== undefined && !didWarnValueDefaultValue) {\n process.env.NODE_ENV !== 'production' ? warning(false, '%s contains an input of type %s with both value and defaultValue props. ' + 'Input elements must be either controlled or uncontrolled ' + '(specify either the value prop, or the defaultValue prop, but not ' + 'both). Decide between using a controlled or uncontrolled input ' + 'element and remove one of these props. More info: ' + 'https://fb.me/react-controlled-components', owner && owner.getName() || 'A component', props.type) : void 0;\n didWarnValueDefaultValue = true;\n }\n }\n\n var defaultValue = props.defaultValue;\n inst._wrapperState = {\n initialChecked: props.checked != null ? props.checked : props.defaultChecked,\n initialValue: props.value != null ? props.value : defaultValue,\n listeners: null,\n onChange: _handleChange.bind(inst),\n controlled: isControlled(props)\n };\n },\n\n updateWrapper: function (inst) {\n var props = inst._currentElement.props;\n\n if (process.env.NODE_ENV !== 'production') {\n var controlled = isControlled(props);\n var owner = inst._currentElement._owner;\n\n if (!inst._wrapperState.controlled && controlled && !didWarnUncontrolledToControlled) {\n process.env.NODE_ENV !== 'production' ? warning(false, '%s is changing an uncontrolled input of type %s to be controlled. ' + 'Input elements should not switch from uncontrolled to controlled (or vice versa). ' + 'Decide between using a controlled or uncontrolled input ' + 'element for the lifetime of the component. More info: https://fb.me/react-controlled-components', owner && owner.getName() || 'A component', props.type) : void 0;\n didWarnUncontrolledToControlled = true;\n }\n if (inst._wrapperState.controlled && !controlled && !didWarnControlledToUncontrolled) {\n process.env.NODE_ENV !== 'production' ? warning(false, '%s is changing a controlled input of type %s to be uncontrolled. ' + 'Input elements should not switch from controlled to uncontrolled (or vice versa). ' + 'Decide between using a controlled or uncontrolled input ' + 'element for the lifetime of the component. More info: https://fb.me/react-controlled-components', owner && owner.getName() || 'A component', props.type) : void 0;\n didWarnControlledToUncontrolled = true;\n }\n }\n\n // TODO: Shouldn't this be getChecked(props)?\n var checked = props.checked;\n if (checked != null) {\n DOMPropertyOperations.setValueForProperty(ReactDOMComponentTree.getNodeFromInstance(inst), 'checked', checked || false);\n }\n\n var node = ReactDOMComponentTree.getNodeFromInstance(inst);\n var value = LinkedValueUtils.getValue(props);\n if (value != null) {\n if (value === 0 && node.value === '') {\n node.value = '0';\n // Note: IE9 reports a number inputs as 'text', so check props instead.\n } else if (props.type === 'number') {\n // Simulate `input.valueAsNumber`. IE9 does not support it\n var valueAsNumber = parseFloat(node.value, 10) || 0;\n\n if (\n // eslint-disable-next-line\n value != valueAsNumber ||\n // eslint-disable-next-line\n value == valueAsNumber && node.value != value) {\n // Cast `value` to a string to ensure the value is set correctly. While\n // browsers typically do this as necessary, jsdom doesn't.\n node.value = '' + value;\n }\n } else if (node.value !== '' + value) {\n // Cast `value` to a string to ensure the value is set correctly. While\n // browsers typically do this as necessary, jsdom doesn't.\n node.value = '' + value;\n }\n } else {\n if (props.value == null && props.defaultValue != null) {\n // In Chrome, assigning defaultValue to certain input types triggers input validation.\n // For number inputs, the display value loses trailing decimal points. For email inputs,\n // Chrome raises \"The specified value <x> is not a valid email address\".\n //\n // Here we check to see if the defaultValue has actually changed, avoiding these problems\n // when the user is inputting text\n //\n // https://github.com/facebook/react/issues/7253\n if (node.defaultValue !== '' + props.defaultValue) {\n node.defaultValue = '' + props.defaultValue;\n }\n }\n if (props.checked == null && props.defaultChecked != null) {\n node.defaultChecked = !!props.defaultChecked;\n }\n }\n },\n\n postMountWrapper: function (inst) {\n var props = inst._currentElement.props;\n\n // This is in postMount because we need access to the DOM node, which is not\n // available until after the component has mounted.\n var node = ReactDOMComponentTree.getNodeFromInstance(inst);\n\n // Detach value from defaultValue. We won't do anything if we're working on\n // submit or reset inputs as those values & defaultValues are linked. They\n // are not resetable nodes so this operation doesn't matter and actually\n // removes browser-default values (eg \"Submit Query\") when no value is\n // provided.\n\n switch (props.type) {\n case 'submit':\n case 'reset':\n break;\n case 'color':\n case 'date':\n case 'datetime':\n case 'datetime-local':\n case 'month':\n case 'time':\n case 'week':\n // This fixes the no-show issue on iOS Safari and Android Chrome:\n // https://github.com/facebook/react/issues/7233\n node.value = '';\n node.value = node.defaultValue;\n break;\n default:\n node.value = node.value;\n break;\n }\n\n // Normally, we'd just do `node.checked = node.checked` upon initial mount, less this bug\n // this is needed to work around a chrome bug where setting defaultChecked\n // will sometimes influence the value of checked (even after detachment).\n // Reference: https://bugs.chromium.org/p/chromium/issues/detail?id=608416\n // We need to temporarily unset name to avoid disrupting radio button groups.\n var name = node.name;\n if (name !== '') {\n node.name = '';\n }\n node.defaultChecked = !node.defaultChecked;\n node.defaultChecked = !node.defaultChecked;\n if (name !== '') {\n node.name = name;\n }\n }\n};\n\nfunction _handleChange(event) {\n var props = this._currentElement.props;\n\n var returnValue = LinkedValueUtils.executeOnChange(props, event);\n\n // Here we use asap to wait until all updates have propagated, which\n // is important when using controlled components within layers:\n // https://github.com/facebook/react/issues/1698\n ReactUpdates.asap(forceUpdateIfMounted, this);\n\n var name = props.name;\n if (props.type === 'radio' && name != null) {\n var rootNode = ReactDOMComponentTree.getNodeFromInstance(this);\n var queryRoot = rootNode;\n\n while (queryRoot.parentNode) {\n queryRoot = queryRoot.parentNode;\n }\n\n // If `rootNode.form` was non-null, then we could try `form.elements`,\n // but that sometimes behaves strangely in IE8. We could also try using\n // `form.getElementsByName`, but that will only return direct children\n // and won't include inputs that use the HTML5 `form=` attribute. Since\n // the input might not even be in a form, let's just use the global\n // `querySelectorAll` to ensure we don't miss anything.\n var group = queryRoot.querySelectorAll('input[name=' + JSON.stringify('' + name) + '][type=\"radio\"]');\n\n for (var i = 0; i < group.length; i++) {\n var otherNode = group[i];\n if (otherNode === rootNode || otherNode.form !== rootNode.form) {\n continue;\n }\n // This will throw if radio buttons rendered by different copies of React\n // and the same name are rendered into the same form (same as #1939).\n // That's probably okay; we don't support it just as we don't support\n // mixing React radio buttons with non-React ones.\n var otherInstance = ReactDOMComponentTree.getInstanceFromNode(otherNode);\n !otherInstance ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactDOMInput: Mixing React and non-React radio inputs with the same `name` is not supported.') : _prodInvariant('90') : void 0;\n // If this is a controlled radio button group, forcing the input that\n // was previously checked to update will cause it to be come re-checked\n // as appropriate.\n ReactUpdates.asap(forceUpdateIfMounted, otherInstance);\n }\n }\n\n return returnValue;\n}\n\nmodule.exports = ReactDOMInput;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar ExecutionEnvironment = require('fbjs/lib/ExecutionEnvironment');\n\n/**\n * Generate a mapping of standard vendor prefixes using the defined style property and event name.\n *\n * @param {string} styleProp\n * @param {string} eventName\n * @returns {object}\n */\nfunction makePrefixMap(styleProp, eventName) {\n var prefixes = {};\n\n prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();\n prefixes['Webkit' + styleProp] = 'webkit' + eventName;\n prefixes['Moz' + styleProp] = 'moz' + eventName;\n prefixes['ms' + styleProp] = 'MS' + eventName;\n prefixes['O' + styleProp] = 'o' + eventName.toLowerCase();\n\n return prefixes;\n}\n\n/**\n * A list of event names to a configurable list of vendor prefixes.\n */\nvar vendorPrefixes = {\n animationend: makePrefixMap('Animation', 'AnimationEnd'),\n animationiteration: makePrefixMap('Animation', 'AnimationIteration'),\n animationstart: makePrefixMap('Animation', 'AnimationStart'),\n transitionend: makePrefixMap('Transition', 'TransitionEnd')\n};\n\n/**\n * Event names that have already been detected and prefixed (if applicable).\n */\nvar prefixedEventNames = {};\n\n/**\n * Element to check for prefixes on.\n */\nvar style = {};\n\n/**\n * Bootstrap if a DOM exists.\n */\nif (ExecutionEnvironment.canUseDOM) {\n style = document.createElement('div').style;\n\n // On some platforms, in particular some releases of Android 4.x,\n // the un-prefixed \"animation\" and \"transition\" properties are defined on the\n // style object but the events that fire will still be prefixed, so we need\n // to check if the un-prefixed events are usable, and if not remove them from the map.\n if (!('AnimationEvent' in window)) {\n delete vendorPrefixes.animationend.animation;\n delete vendorPrefixes.animationiteration.animation;\n delete vendorPrefixes.animationstart.animation;\n }\n\n // Same as above\n if (!('TransitionEvent' in window)) {\n delete vendorPrefixes.transitionend.transition;\n }\n}\n\n/**\n * Attempts to determine the correct vendor prefixed event name.\n *\n * @param {string} eventName\n * @returns {string}\n */\nfunction getVendorPrefixedEventName(eventName) {\n if (prefixedEventNames[eventName]) {\n return prefixedEventNames[eventName];\n } else if (!vendorPrefixes[eventName]) {\n return eventName;\n }\n\n var prefixMap = vendorPrefixes[eventName];\n\n for (var styleProp in prefixMap) {\n if (prefixMap.hasOwnProperty(styleProp) && styleProp in style) {\n return prefixedEventNames[eventName] = prefixMap[styleProp];\n }\n }\n\n return '';\n}\n\nmodule.exports = getVendorPrefixedEventName;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar EventPluginHub = require('./EventPluginHub');\n\nfunction runEventQueueInBatch(events) {\n EventPluginHub.enqueueEvents(events);\n EventPluginHub.processEventQueue(false);\n}\n\nvar ReactEventEmitterMixin = {\n /**\n * Streams a fired top-level event to `EventPluginHub` where plugins have the\n * opportunity to create `ReactEvent`s to be dispatched.\n */\n handleTopLevel: function (topLevelType, targetInst, nativeEvent, nativeEventTarget) {\n var events = EventPluginHub.extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget);\n runEventQueueInBatch(events);\n }\n};\n\nmodule.exports = ReactEventEmitterMixin;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar escapeTextContentForBrowser = require('./escapeTextContentForBrowser');\n\n/**\n * Escapes attribute value to prevent scripting attacks.\n *\n * @param {*} value Value to escape.\n * @return {string} An escaped string.\n */\nfunction quoteAttributeValueForBrowser(value) {\n return '\"' + escapeTextContentForBrowser(value) + '\"';\n}\n\nmodule.exports = quoteAttributeValueForBrowser;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n * @typechecks static-only\n */\n\n'use strict';\n\n/**\n * Memoizes the return value of a function that accepts one string argument.\n */\n\nfunction memoizeStringOnly(callback) {\n var cache = {};\n return function (string) {\n if (!cache.hasOwnProperty(string)) {\n cache[string] = callback.call(this, string);\n }\n return cache[string];\n };\n}\n\nmodule.exports = memoizeStringOnly;","'use strict';\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\nvar _uppercasePattern = /([A-Z])/g;\n\n/**\n * Hyphenates a camelcased string, for example:\n *\n * > hyphenate('backgroundColor')\n * < \"background-color\"\n *\n * For CSS style names, use `hyphenateStyleName` instead which works properly\n * with all vendor prefixes, including `ms`.\n *\n * @param {string} string\n * @return {string}\n */\nfunction hyphenate(string) {\n return string.replace(_uppercasePattern, '-$1').toLowerCase();\n}\n\nmodule.exports = hyphenate;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\n'use strict';\n\nvar hyphenate = require('./hyphenate');\n\nvar msPattern = /^ms-/;\n\n/**\n * Hyphenates a camelcased CSS property name, for example:\n *\n * > hyphenateStyleName('backgroundColor')\n * < \"background-color\"\n * > hyphenateStyleName('MozTransition')\n * < \"-moz-transition\"\n * > hyphenateStyleName('msTransition')\n * < \"-ms-transition\"\n *\n * As Modernizr suggests (http://modernizr.com/docs/#prefixed), an `ms` prefix\n * is converted to `-ms-`.\n *\n * @param {string} string\n * @return {string}\n */\nfunction hyphenateStyleName(string) {\n return hyphenate(string).replace(msPattern, '-ms-');\n}\n\nmodule.exports = hyphenateStyleName;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar CSSProperty = require('./CSSProperty');\nvar warning = require('fbjs/lib/warning');\n\nvar isUnitlessNumber = CSSProperty.isUnitlessNumber;\nvar styleWarnings = {};\n\n/**\n * Convert a value into the proper css writable value. The style name `name`\n * should be logical (no hyphens), as specified\n * in `CSSProperty.isUnitlessNumber`.\n *\n * @param {string} name CSS property name such as `topMargin`.\n * @param {*} value CSS property value such as `10px`.\n * @param {ReactDOMComponent} component\n * @return {string} Normalized style value with dimensions applied.\n */\nfunction dangerousStyleValue(name, value, component, isCustomProperty) {\n // Note that we've removed escapeTextForBrowser() calls here since the\n // whole string will be escaped when the attribute is injected into\n // the markup. If you provide unsafe user data here they can inject\n // arbitrary CSS which may be problematic (I couldn't repro this):\n // https://www.owasp.org/index.php/XSS_Filter_Evasion_Cheat_Sheet\n // http://www.thespanner.co.uk/2007/11/26/ultimate-xss-css-injection/\n // This is not an XSS hole but instead a potential CSS injection issue\n // which has lead to a greater discussion about how we're going to\n // trust URLs moving forward. See #2115901\n\n var isEmpty = value == null || typeof value === 'boolean' || value === '';\n if (isEmpty) {\n return '';\n }\n\n var isNonNumeric = isNaN(value);\n if (isCustomProperty || isNonNumeric || value === 0 || isUnitlessNumber.hasOwnProperty(name) && isUnitlessNumber[name]) {\n return '' + value; // cast to string\n }\n\n if (typeof value === 'string') {\n if (process.env.NODE_ENV !== 'production') {\n // Allow '0' to pass through without warning. 0 is already special and\n // doesn't require units, so we don't need to warn about it.\n if (component && value !== '0') {\n var owner = component._currentElement._owner;\n var ownerName = owner ? owner.getName() : null;\n if (ownerName && !styleWarnings[ownerName]) {\n styleWarnings[ownerName] = {};\n }\n var warned = false;\n if (ownerName) {\n var warnings = styleWarnings[ownerName];\n warned = warnings[name];\n if (!warned) {\n warnings[name] = true;\n }\n }\n if (!warned) {\n process.env.NODE_ENV !== 'production' ? warning(false, 'a `%s` tag (owner: `%s`) was passed a numeric string value ' + 'for CSS property `%s` (value: `%s`) which will be treated ' + 'as a unitless number in a future version of React.', component._currentElement.type, ownerName || 'unknown', name, value) : void 0;\n }\n }\n }\n value = value.trim();\n }\n return value + 'px';\n}\n\nmodule.exports = dangerousStyleValue;","\"use strict\";\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\nvar _hyphenPattern = /-(.)/g;\n\n/**\n * Camelcases a hyphenated string, for example:\n *\n * > camelize('background-color')\n * < \"backgroundColor\"\n *\n * @param {string} string\n * @return {string}\n */\nfunction camelize(string) {\n return string.replace(_hyphenPattern, function (_, character) {\n return character.toUpperCase();\n });\n}\n\nmodule.exports = camelize;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\n'use strict';\n\nvar camelize = require('./camelize');\n\nvar msPattern = /^-ms-/;\n\n/**\n * Camelcases a hyphenated CSS property name, for example:\n *\n * > camelizeStyleName('background-color')\n * < \"backgroundColor\"\n * > camelizeStyleName('-moz-transition')\n * < \"MozTransition\"\n * > camelizeStyleName('-ms-transition')\n * < \"msTransition\"\n *\n * As Andi Smith suggests\n * (http://www.andismith.com/blog/2012/02/modernizr-prefixed/), an `-ms` prefix\n * is converted to lowercase `ms`.\n *\n * @param {string} string\n * @return {string}\n */\nfunction camelizeStyleName(string) {\n return camelize(string.replace(msPattern, 'ms-'));\n}\n\nmodule.exports = camelizeStyleName;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar CSSProperty = require('./CSSProperty');\nvar ExecutionEnvironment = require('fbjs/lib/ExecutionEnvironment');\nvar ReactInstrumentation = require('./ReactInstrumentation');\n\nvar camelizeStyleName = require('fbjs/lib/camelizeStyleName');\nvar dangerousStyleValue = require('./dangerousStyleValue');\nvar hyphenateStyleName = require('fbjs/lib/hyphenateStyleName');\nvar memoizeStringOnly = require('fbjs/lib/memoizeStringOnly');\nvar warning = require('fbjs/lib/warning');\n\nvar processStyleName = memoizeStringOnly(function (styleName) {\n return hyphenateStyleName(styleName);\n});\n\nvar hasShorthandPropertyBug = false;\nvar styleFloatAccessor = 'cssFloat';\nif (ExecutionEnvironment.canUseDOM) {\n var tempStyle = document.createElement('div').style;\n try {\n // IE8 throws \"Invalid argument.\" if resetting shorthand style properties.\n tempStyle.font = '';\n } catch (e) {\n hasShorthandPropertyBug = true;\n }\n // IE8 only supports accessing cssFloat (standard) as styleFloat\n if (document.documentElement.style.cssFloat === undefined) {\n styleFloatAccessor = 'styleFloat';\n }\n}\n\nif (process.env.NODE_ENV !== 'production') {\n // 'msTransform' is correct, but the other prefixes should be capitalized\n var badVendoredStyleNamePattern = /^(?:webkit|moz|o)[A-Z]/;\n\n // style values shouldn't contain a semicolon\n var badStyleValueWithSemicolonPattern = /;\\s*$/;\n\n var warnedStyleNames = {};\n var warnedStyleValues = {};\n var warnedForNaNValue = false;\n\n var warnHyphenatedStyleName = function (name, owner) {\n if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {\n return;\n }\n\n warnedStyleNames[name] = true;\n process.env.NODE_ENV !== 'production' ? warning(false, 'Unsupported style property %s. Did you mean %s?%s', name, camelizeStyleName(name), checkRenderMessage(owner)) : void 0;\n };\n\n var warnBadVendoredStyleName = function (name, owner) {\n if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {\n return;\n }\n\n warnedStyleNames[name] = true;\n process.env.NODE_ENV !== '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;\n };\n\n var warnStyleValueWithSemicolon = function (name, value, owner) {\n if (warnedStyleValues.hasOwnProperty(value) && warnedStyleValues[value]) {\n return;\n }\n\n warnedStyleValues[value] = true;\n process.env.NODE_ENV !== 'production' ? warning(false, \"Style property values shouldn't contain a semicolon.%s \" + 'Try \"%s: %s\" instead.', checkRenderMessage(owner), name, value.replace(badStyleValueWithSemicolonPattern, '')) : void 0;\n };\n\n var warnStyleValueIsNaN = function (name, value, owner) {\n if (warnedForNaNValue) {\n return;\n }\n\n warnedForNaNValue = true;\n process.env.NODE_ENV !== 'production' ? warning(false, '`NaN` is an invalid value for the `%s` css style property.%s', name, checkRenderMessage(owner)) : void 0;\n };\n\n var checkRenderMessage = function (owner) {\n if (owner) {\n var name = owner.getName();\n if (name) {\n return ' Check the render method of `' + name + '`.';\n }\n }\n return '';\n };\n\n /**\n * @param {string} name\n * @param {*} value\n * @param {ReactDOMComponent} component\n */\n var warnValidStyle = function (name, value, component) {\n var owner;\n if (component) {\n owner = component._currentElement._owner;\n }\n if (name.indexOf('-') > -1) {\n warnHyphenatedStyleName(name, owner);\n } else if (badVendoredStyleNamePattern.test(name)) {\n warnBadVendoredStyleName(name, owner);\n } else if (badStyleValueWithSemicolonPattern.test(value)) {\n warnStyleValueWithSemicolon(name, value, owner);\n }\n\n if (typeof value === 'number' && isNaN(value)) {\n warnStyleValueIsNaN(name, value, owner);\n }\n };\n}\n\n/**\n * Operations for dealing with CSS properties.\n */\nvar CSSPropertyOperations = {\n /**\n * Serializes a mapping of style properties for use as inline styles:\n *\n * > createMarkupForStyles({width: '200px', height: 0})\n * \"width:200px;height:0;\"\n *\n * Undefined values are ignored so that declarative programming is easier.\n * The result should be HTML-escaped before insertion into the DOM.\n *\n * @param {object} styles\n * @param {ReactDOMComponent} component\n * @return {?string}\n */\n createMarkupForStyles: function (styles, component) {\n var serialized = '';\n for (var styleName in styles) {\n if (!styles.hasOwnProperty(styleName)) {\n continue;\n }\n var isCustomProperty = styleName.indexOf('--') === 0;\n var styleValue = styles[styleName];\n if (process.env.NODE_ENV !== 'production') {\n if (!isCustomProperty) {\n warnValidStyle(styleName, styleValue, component);\n }\n }\n if (styleValue != null) {\n serialized += processStyleName(styleName) + ':';\n serialized += dangerousStyleValue(styleName, styleValue, component, isCustomProperty) + ';';\n }\n }\n return serialized || null;\n },\n\n /**\n * Sets the value for multiple styles on a node. If a value is specified as\n * '' (empty string), the corresponding style property will be unset.\n *\n * @param {DOMElement} node\n * @param {object} styles\n * @param {ReactDOMComponent} component\n */\n setValueForStyles: function (node, styles, component) {\n if (process.env.NODE_ENV !== 'production') {\n ReactInstrumentation.debugTool.onHostOperation({\n instanceID: component._debugID,\n type: 'update styles',\n payload: styles\n });\n }\n\n var style = node.style;\n for (var styleName in styles) {\n if (!styles.hasOwnProperty(styleName)) {\n continue;\n }\n var isCustomProperty = styleName.indexOf('--') === 0;\n if (process.env.NODE_ENV !== 'production') {\n if (!isCustomProperty) {\n warnValidStyle(styleName, styles[styleName], component);\n }\n }\n var styleValue = dangerousStyleValue(styleName, styles[styleName], component, isCustomProperty);\n if (styleName === 'float' || styleName === 'cssFloat') {\n styleName = styleFloatAccessor;\n }\n if (isCustomProperty) {\n style.setProperty(styleName, styleValue);\n } else if (styleValue) {\n style[styleName] = styleValue;\n } else {\n var expansion = hasShorthandPropertyBug && CSSProperty.shorthandPropertyExpansions[styleName];\n if (expansion) {\n // Shorthand property that IE8 won't like unsetting, so unset each\n // component to placate it\n for (var individualStyleName in expansion) {\n style[individualStyleName] = '';\n }\n } else {\n style[styleName] = '';\n }\n }\n }\n }\n};\n\nmodule.exports = CSSPropertyOperations;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar ReactDOMComponentTree = require('./ReactDOMComponentTree');\n\nvar focusNode = require('fbjs/lib/focusNode');\n\nvar AutoFocusUtils = {\n focusDOMComponent: function () {\n focusNode(ReactDOMComponentTree.getNodeFromInstance(this));\n }\n};\n\nmodule.exports = AutoFocusUtils;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n/* global hasOwnProperty:true */\n\n'use strict';\n\nvar _prodInvariant = require('./reactProdInvariant'),\n _assign = require('object-assign');\n\nvar AutoFocusUtils = require('./AutoFocusUtils');\nvar CSSPropertyOperations = require('./CSSPropertyOperations');\nvar DOMLazyTree = require('./DOMLazyTree');\nvar DOMNamespaces = require('./DOMNamespaces');\nvar DOMProperty = require('./DOMProperty');\nvar DOMPropertyOperations = require('./DOMPropertyOperations');\nvar EventPluginHub = require('./EventPluginHub');\nvar EventPluginRegistry = require('./EventPluginRegistry');\nvar ReactBrowserEventEmitter = require('./ReactBrowserEventEmitter');\nvar ReactDOMComponentFlags = require('./ReactDOMComponentFlags');\nvar ReactDOMComponentTree = require('./ReactDOMComponentTree');\nvar ReactDOMInput = require('./ReactDOMInput');\nvar ReactDOMOption = require('./ReactDOMOption');\nvar ReactDOMSelect = require('./ReactDOMSelect');\nvar ReactDOMTextarea = require('./ReactDOMTextarea');\nvar ReactInstrumentation = require('./ReactInstrumentation');\nvar ReactMultiChild = require('./ReactMultiChild');\nvar ReactServerRenderingTransaction = require('./ReactServerRenderingTransaction');\n\nvar emptyFunction = require('fbjs/lib/emptyFunction');\nvar escapeTextContentForBrowser = require('./escapeTextContentForBrowser');\nvar invariant = require('fbjs/lib/invariant');\nvar isEventSupported = require('./isEventSupported');\nvar shallowEqual = require('fbjs/lib/shallowEqual');\nvar inputValueTracking = require('./inputValueTracking');\nvar validateDOMNesting = require('./validateDOMNesting');\nvar warning = require('fbjs/lib/warning');\n\nvar Flags = ReactDOMComponentFlags;\nvar deleteListener = EventPluginHub.deleteListener;\nvar getNode = ReactDOMComponentTree.getNodeFromInstance;\nvar listenTo = ReactBrowserEventEmitter.listenTo;\nvar registrationNameModules = EventPluginRegistry.registrationNameModules;\n\n// For quickly matching children type, to test if can be treated as content.\nvar CONTENT_TYPES = { string: true, number: true };\n\nvar STYLE = 'style';\nvar HTML = '__html';\nvar RESERVED_PROPS = {\n children: null,\n dangerouslySetInnerHTML: null,\n suppressContentEditableWarning: null\n};\n\n// Node type for document fragments (Node.DOCUMENT_FRAGMENT_NODE).\nvar DOC_FRAGMENT_TYPE = 11;\n\nfunction getDeclarationErrorAddendum(internalInstance) {\n if (internalInstance) {\n var owner = internalInstance._currentElement._owner || null;\n if (owner) {\n var name = owner.getName();\n if (name) {\n return ' This DOM node was rendered by `' + name + '`.';\n }\n }\n }\n return '';\n}\n\nfunction friendlyStringify(obj) {\n if (typeof obj === 'object') {\n if (Array.isArray(obj)) {\n return '[' + obj.map(friendlyStringify).join(', ') + ']';\n } else {\n var pairs = [];\n for (var key in obj) {\n if (Object.prototype.hasOwnProperty.call(obj, key)) {\n var keyEscaped = /^[a-z$_][\\w$_]*$/i.test(key) ? key : JSON.stringify(key);\n pairs.push(keyEscaped + ': ' + friendlyStringify(obj[key]));\n }\n }\n return '{' + pairs.join(', ') + '}';\n }\n } else if (typeof obj === 'string') {\n return JSON.stringify(obj);\n } else if (typeof obj === 'function') {\n return '[function object]';\n }\n // Differs from JSON.stringify in that undefined because undefined and that\n // inf and nan don't become null\n return String(obj);\n}\n\nvar styleMutationWarning = {};\n\nfunction checkAndWarnForMutatedStyle(style1, style2, component) {\n if (style1 == null || style2 == null) {\n return;\n }\n if (shallowEqual(style1, style2)) {\n return;\n }\n\n var componentName = component._tag;\n var owner = component._currentElement._owner;\n var ownerName;\n if (owner) {\n ownerName = owner.getName();\n }\n\n var hash = ownerName + '|' + componentName;\n\n if (styleMutationWarning.hasOwnProperty(hash)) {\n return;\n }\n\n styleMutationWarning[hash] = true;\n\n process.env.NODE_ENV !== 'production' ? warning(false, '`%s` was passed a style object that has previously been mutated. ' + 'Mutating `style` is deprecated. Consider cloning it beforehand. Check ' + 'the `render` %s. Previous style: %s. Mutated style: %s.', componentName, owner ? 'of `' + ownerName + '`' : 'using <' + componentName + '>', friendlyStringify(style1), friendlyStringify(style2)) : void 0;\n}\n\n/**\n * @param {object} component\n * @param {?object} props\n */\nfunction assertValidProps(component, props) {\n if (!props) {\n return;\n }\n // Note the use of `==` which checks for null or undefined.\n if (voidElementTags[component._tag]) {\n !(props.children == null && props.dangerouslySetInnerHTML == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, '%s is a void element tag and must neither have `children` nor use `dangerouslySetInnerHTML`.%s', component._tag, component._currentElement._owner ? ' Check the render method of ' + component._currentElement._owner.getName() + '.' : '') : _prodInvariant('137', component._tag, component._currentElement._owner ? ' Check the render method of ' + component._currentElement._owner.getName() + '.' : '') : void 0;\n }\n if (props.dangerouslySetInnerHTML != null) {\n !(props.children == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Can only set one of `children` or `props.dangerouslySetInnerHTML`.') : _prodInvariant('60') : void 0;\n !(typeof props.dangerouslySetInnerHTML === 'object' && HTML in props.dangerouslySetInnerHTML) ? process.env.NODE_ENV !== 'production' ? invariant(false, '`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. Please visit https://fb.me/react-invariant-dangerously-set-inner-html for more information.') : _prodInvariant('61') : void 0;\n }\n if (process.env.NODE_ENV !== 'production') {\n process.env.NODE_ENV !== 'production' ? warning(props.innerHTML == null, 'Directly setting property `innerHTML` is not permitted. ' + 'For more information, lookup documentation on `dangerouslySetInnerHTML`.') : void 0;\n process.env.NODE_ENV !== 'production' ? warning(props.suppressContentEditableWarning || !props.contentEditable || props.children == null, 'A component is `contentEditable` and contains `children` managed by ' + 'React. It is now your responsibility to guarantee that none of ' + 'those nodes are unexpectedly modified or duplicated. This is ' + 'probably not intentional.') : void 0;\n process.env.NODE_ENV !== 'production' ? warning(props.onFocusIn == null && props.onFocusOut == null, 'React uses onFocus and onBlur instead of onFocusIn and onFocusOut. ' + 'All React events are normalized to bubble, so onFocusIn and onFocusOut ' + 'are not needed/supported by React.') : void 0;\n }\n !(props.style == null || typeof props.style === 'object') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'The `style` prop expects a mapping from style properties to values, not a string. For example, style={{marginRight: spacing + \\'em\\'}} when using JSX.%s', getDeclarationErrorAddendum(component)) : _prodInvariant('62', getDeclarationErrorAddendum(component)) : void 0;\n}\n\nfunction enqueuePutListener(inst, registrationName, listener, transaction) {\n if (transaction instanceof ReactServerRenderingTransaction) {\n return;\n }\n if (process.env.NODE_ENV !== 'production') {\n // IE8 has no API for event capturing and the `onScroll` event doesn't\n // bubble.\n process.env.NODE_ENV !== 'production' ? warning(registrationName !== 'onScroll' || isEventSupported('scroll', true), \"This browser doesn't support the `onScroll` event\") : void 0;\n }\n var containerInfo = inst._hostContainerInfo;\n var isDocumentFragment = containerInfo._node && containerInfo._node.nodeType === DOC_FRAGMENT_TYPE;\n var doc = isDocumentFragment ? containerInfo._node : containerInfo._ownerDocument;\n listenTo(registrationName, doc);\n transaction.getReactMountReady().enqueue(putListener, {\n inst: inst,\n registrationName: registrationName,\n listener: listener\n });\n}\n\nfunction putListener() {\n var listenerToPut = this;\n EventPluginHub.putListener(listenerToPut.inst, listenerToPut.registrationName, listenerToPut.listener);\n}\n\nfunction inputPostMount() {\n var inst = this;\n ReactDOMInput.postMountWrapper(inst);\n}\n\nfunction textareaPostMount() {\n var inst = this;\n ReactDOMTextarea.postMountWrapper(inst);\n}\n\nfunction optionPostMount() {\n var inst = this;\n ReactDOMOption.postMountWrapper(inst);\n}\n\nvar setAndValidateContentChildDev = emptyFunction;\nif (process.env.NODE_ENV !== 'production') {\n setAndValidateContentChildDev = function (content) {\n var hasExistingContent = this._contentDebugID != null;\n var debugID = this._debugID;\n // This ID represents the inlined child that has no backing instance:\n var contentDebugID = -debugID;\n\n if (content == null) {\n if (hasExistingContent) {\n ReactInstrumentation.debugTool.onUnmountComponent(this._contentDebugID);\n }\n this._contentDebugID = null;\n return;\n }\n\n validateDOMNesting(null, String(content), this, this._ancestorInfo);\n this._contentDebugID = contentDebugID;\n if (hasExistingContent) {\n ReactInstrumentation.debugTool.onBeforeUpdateComponent(contentDebugID, content);\n ReactInstrumentation.debugTool.onUpdateComponent(contentDebugID);\n } else {\n ReactInstrumentation.debugTool.onBeforeMountComponent(contentDebugID, content, debugID);\n ReactInstrumentation.debugTool.onMountComponent(contentDebugID);\n ReactInstrumentation.debugTool.onSetChildren(debugID, [contentDebugID]);\n }\n };\n}\n\n// There are so many media events, it makes sense to just\n// maintain a list rather than create a `trapBubbledEvent` for each\nvar mediaEvents = {\n topAbort: 'abort',\n topCanPlay: 'canplay',\n topCanPlayThrough: 'canplaythrough',\n topDurationChange: 'durationchange',\n topEmptied: 'emptied',\n topEncrypted: 'encrypted',\n topEnded: 'ended',\n topError: 'error',\n topLoadedData: 'loadeddata',\n topLoadedMetadata: 'loadedmetadata',\n topLoadStart: 'loadstart',\n topPause: 'pause',\n topPlay: 'play',\n topPlaying: 'playing',\n topProgress: 'progress',\n topRateChange: 'ratechange',\n topSeeked: 'seeked',\n topSeeking: 'seeking',\n topStalled: 'stalled',\n topSuspend: 'suspend',\n topTimeUpdate: 'timeupdate',\n topVolumeChange: 'volumechange',\n topWaiting: 'waiting'\n};\n\nfunction trackInputValue() {\n inputValueTracking.track(this);\n}\n\nfunction trapBubbledEventsLocal() {\n var inst = this;\n // If a component renders to null or if another component fatals and causes\n // the state of the tree to be corrupted, `node` here can be null.\n !inst._rootNodeID ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Must be mounted to trap events') : _prodInvariant('63') : void 0;\n var node = getNode(inst);\n !node ? process.env.NODE_ENV !== 'production' ? invariant(false, 'trapBubbledEvent(...): Requires node to be rendered.') : _prodInvariant('64') : void 0;\n\n switch (inst._tag) {\n case 'iframe':\n case 'object':\n inst._wrapperState.listeners = [ReactBrowserEventEmitter.trapBubbledEvent('topLoad', 'load', node)];\n break;\n case 'video':\n case 'audio':\n inst._wrapperState.listeners = [];\n // Create listener for each media event\n for (var event in mediaEvents) {\n if (mediaEvents.hasOwnProperty(event)) {\n inst._wrapperState.listeners.push(ReactBrowserEventEmitter.trapBubbledEvent(event, mediaEvents[event], node));\n }\n }\n break;\n case 'source':\n inst._wrapperState.listeners = [ReactBrowserEventEmitter.trapBubbledEvent('topError', 'error', node)];\n break;\n case 'img':\n inst._wrapperState.listeners = [ReactBrowserEventEmitter.trapBubbledEvent('topError', 'error', node), ReactBrowserEventEmitter.trapBubbledEvent('topLoad', 'load', node)];\n break;\n case 'form':\n inst._wrapperState.listeners = [ReactBrowserEventEmitter.trapBubbledEvent('topReset', 'reset', node), ReactBrowserEventEmitter.trapBubbledEvent('topSubmit', 'submit', node)];\n break;\n case 'input':\n case 'select':\n case 'textarea':\n inst._wrapperState.listeners = [ReactBrowserEventEmitter.trapBubbledEvent('topInvalid', 'invalid', node)];\n break;\n }\n}\n\nfunction postUpdateSelectWrapper() {\n ReactDOMSelect.postUpdateWrapper(this);\n}\n\n// For HTML, certain tags should omit their close tag. We keep a whitelist for\n// those special-case tags.\n\nvar omittedCloseTags = {\n area: true,\n base: true,\n br: true,\n col: true,\n embed: true,\n hr: true,\n img: true,\n input: true,\n keygen: true,\n link: true,\n meta: true,\n param: true,\n source: true,\n track: true,\n wbr: true\n // NOTE: menuitem's close tag should be omitted, but that causes problems.\n};\n\nvar newlineEatingTags = {\n listing: true,\n pre: true,\n textarea: true\n};\n\n// For HTML, certain tags cannot have children. This has the same purpose as\n// `omittedCloseTags` except that `menuitem` should still have its closing tag.\n\nvar voidElementTags = _assign({\n menuitem: true\n}, omittedCloseTags);\n\n// We accept any tag to be rendered but since this gets injected into arbitrary\n// HTML, we want to make sure that it's a safe tag.\n// http://www.w3.org/TR/REC-xml/#NT-Name\n\nvar VALID_TAG_REGEX = /^[a-zA-Z][a-zA-Z:_\\.\\-\\d]*$/; // Simplified subset\nvar validatedTagCache = {};\nvar hasOwnProperty = {}.hasOwnProperty;\n\nfunction validateDangerousTag(tag) {\n if (!hasOwnProperty.call(validatedTagCache, tag)) {\n !VALID_TAG_REGEX.test(tag) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Invalid tag: %s', tag) : _prodInvariant('65', tag) : void 0;\n validatedTagCache[tag] = true;\n }\n}\n\nfunction isCustomComponent(tagName, props) {\n return tagName.indexOf('-') >= 0 || props.is != null;\n}\n\nvar globalIdCounter = 1;\n\n/**\n * Creates a new React class that is idempotent and capable of containing other\n * React components. It accepts event listeners and DOM properties that are\n * valid according to `DOMProperty`.\n *\n * - Event listeners: `onClick`, `onMouseDown`, etc.\n * - DOM properties: `className`, `name`, `title`, etc.\n *\n * The `style` property functions differently from the DOM API. It accepts an\n * object mapping of style properties to values.\n *\n * @constructor ReactDOMComponent\n * @extends ReactMultiChild\n */\nfunction ReactDOMComponent(element) {\n var tag = element.type;\n validateDangerousTag(tag);\n this._currentElement = element;\n this._tag = tag.toLowerCase();\n this._namespaceURI = null;\n this._renderedChildren = null;\n this._previousStyle = null;\n this._previousStyleCopy = null;\n this._hostNode = null;\n this._hostParent = null;\n this._rootNodeID = 0;\n this._domID = 0;\n this._hostContainerInfo = null;\n this._wrapperState = null;\n this._topLevelWrapper = null;\n this._flags = 0;\n if (process.env.NODE_ENV !== 'production') {\n this._ancestorInfo = null;\n setAndValidateContentChildDev.call(this, null);\n }\n}\n\nReactDOMComponent.displayName = 'ReactDOMComponent';\n\nReactDOMComponent.Mixin = {\n /**\n * Generates root tag markup then recurses. This method has side effects and\n * is not idempotent.\n *\n * @internal\n * @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction\n * @param {?ReactDOMComponent} the parent component instance\n * @param {?object} info about the host container\n * @param {object} context\n * @return {string} The computed markup.\n */\n mountComponent: function (transaction, hostParent, hostContainerInfo, context) {\n this._rootNodeID = globalIdCounter++;\n this._domID = hostContainerInfo._idCounter++;\n this._hostParent = hostParent;\n this._hostContainerInfo = hostContainerInfo;\n\n var props = this._currentElement.props;\n\n switch (this._tag) {\n case 'audio':\n case 'form':\n case 'iframe':\n case 'img':\n case 'link':\n case 'object':\n case 'source':\n case 'video':\n this._wrapperState = {\n listeners: null\n };\n transaction.getReactMountReady().enqueue(trapBubbledEventsLocal, this);\n break;\n case 'input':\n ReactDOMInput.mountWrapper(this, props, hostParent);\n props = ReactDOMInput.getHostProps(this, props);\n transaction.getReactMountReady().enqueue(trackInputValue, this);\n transaction.getReactMountReady().enqueue(trapBubbledEventsLocal, this);\n break;\n case 'option':\n ReactDOMOption.mountWrapper(this, props, hostParent);\n props = ReactDOMOption.getHostProps(this, props);\n break;\n case 'select':\n ReactDOMSelect.mountWrapper(this, props, hostParent);\n props = ReactDOMSelect.getHostProps(this, props);\n transaction.getReactMountReady().enqueue(trapBubbledEventsLocal, this);\n break;\n case 'textarea':\n ReactDOMTextarea.mountWrapper(this, props, hostParent);\n props = ReactDOMTextarea.getHostProps(this, props);\n transaction.getReactMountReady().enqueue(trackInputValue, this);\n transaction.getReactMountReady().enqueue(trapBubbledEventsLocal, this);\n break;\n }\n\n assertValidProps(this, props);\n\n // We create tags in the namespace of their parent container, except HTML\n // tags get no namespace.\n var namespaceURI;\n var parentTag;\n if (hostParent != null) {\n namespaceURI = hostParent._namespaceURI;\n parentTag = hostParent._tag;\n } else if (hostContainerInfo._tag) {\n namespaceURI = hostContainerInfo._namespaceURI;\n parentTag = hostContainerInfo._tag;\n }\n if (namespaceURI == null || namespaceURI === DOMNamespaces.svg && parentTag === 'foreignobject') {\n namespaceURI = DOMNamespaces.html;\n }\n if (namespaceURI === DOMNamespaces.html) {\n if (this._tag === 'svg') {\n namespaceURI = DOMNamespaces.svg;\n } else if (this._tag === 'math') {\n namespaceURI = DOMNamespaces.mathml;\n }\n }\n this._namespaceURI = namespaceURI;\n\n if (process.env.NODE_ENV !== 'production') {\n var parentInfo;\n if (hostParent != null) {\n parentInfo = hostParent._ancestorInfo;\n } else if (hostContainerInfo._tag) {\n parentInfo = hostContainerInfo._ancestorInfo;\n }\n if (parentInfo) {\n // parentInfo should always be present except for the top-level\n // component when server rendering\n validateDOMNesting(this._tag, null, this, parentInfo);\n }\n this._ancestorInfo = validateDOMNesting.updatedAncestorInfo(parentInfo, this._tag, this);\n }\n\n var mountImage;\n if (transaction.useCreateElement) {\n var ownerDocument = hostContainerInfo._ownerDocument;\n var el;\n if (namespaceURI === DOMNamespaces.html) {\n if (this._tag === 'script') {\n // Create the script via .innerHTML so its \"parser-inserted\" flag is\n // set to true and it does not execute\n var div = ownerDocument.createElement('div');\n var type = this._currentElement.type;\n div.innerHTML = '<' + type + '></' + type + '>';\n el = div.removeChild(div.firstChild);\n } else if (props.is) {\n el = ownerDocument.createElement(this._currentElement.type, props.is);\n } else {\n // Separate else branch instead of using `props.is || undefined` above becuase of a Firefox bug.\n // See discussion in https://github.com/facebook/react/pull/6896\n // and discussion in https://bugzilla.mozilla.org/show_bug.cgi?id=1276240\n el = ownerDocument.createElement(this._currentElement.type);\n }\n } else {\n el = ownerDocument.createElementNS(namespaceURI, this._currentElement.type);\n }\n ReactDOMComponentTree.precacheNode(this, el);\n this._flags |= Flags.hasCachedChildNodes;\n if (!this._hostParent) {\n DOMPropertyOperations.setAttributeForRoot(el);\n }\n this._updateDOMProperties(null, props, transaction);\n var lazyTree = DOMLazyTree(el);\n this._createInitialChildren(transaction, props, context, lazyTree);\n mountImage = lazyTree;\n } else {\n var tagOpen = this._createOpenTagMarkupAndPutListeners(transaction, props);\n var tagContent = this._createContentMarkup(transaction, props, context);\n if (!tagContent && omittedCloseTags[this._tag]) {\n mountImage = tagOpen + '/>';\n } else {\n mountImage = tagOpen + '>' + tagContent + '</' + this._currentElement.type + '>';\n }\n }\n\n switch (this._tag) {\n case 'input':\n transaction.getReactMountReady().enqueue(inputPostMount, this);\n if (props.autoFocus) {\n transaction.getReactMountReady().enqueue(AutoFocusUtils.focusDOMComponent, this);\n }\n break;\n case 'textarea':\n transaction.getReactMountReady().enqueue(textareaPostMount, this);\n if (props.autoFocus) {\n transaction.getReactMountReady().enqueue(AutoFocusUtils.focusDOMComponent, this);\n }\n break;\n case 'select':\n if (props.autoFocus) {\n transaction.getReactMountReady().enqueue(AutoFocusUtils.focusDOMComponent, this);\n }\n break;\n case 'button':\n if (props.autoFocus) {\n transaction.getReactMountReady().enqueue(AutoFocusUtils.focusDOMComponent, this);\n }\n break;\n case 'option':\n transaction.getReactMountReady().enqueue(optionPostMount, this);\n break;\n }\n\n return mountImage;\n },\n\n /**\n * Creates markup for the open tag and all attributes.\n *\n * This method has side effects because events get registered.\n *\n * Iterating over object properties is faster than iterating over arrays.\n * @see http://jsperf.com/obj-vs-arr-iteration\n *\n * @private\n * @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction\n * @param {object} props\n * @return {string} Markup of opening tag.\n */\n _createOpenTagMarkupAndPutListeners: function (transaction, props) {\n var ret = '<' + this._currentElement.type;\n\n for (var propKey in props) {\n if (!props.hasOwnProperty(propKey)) {\n continue;\n }\n var propValue = props[propKey];\n if (propValue == null) {\n continue;\n }\n if (registrationNameModules.hasOwnProperty(propKey)) {\n if (propValue) {\n enqueuePutListener(this, propKey, propValue, transaction);\n }\n } else {\n if (propKey === STYLE) {\n if (propValue) {\n if (process.env.NODE_ENV !== 'production') {\n // See `_updateDOMProperties`. style block\n this._previousStyle = propValue;\n }\n propValue = this._previousStyleCopy = _assign({}, props.style);\n }\n propValue = CSSPropertyOperations.createMarkupForStyles(propValue, this);\n }\n var markup = null;\n if (this._tag != null && isCustomComponent(this._tag, props)) {\n if (!RESERVED_PROPS.hasOwnProperty(propKey)) {\n markup = DOMPropertyOperations.createMarkupForCustomAttribute(propKey, propValue);\n }\n } else {\n markup = DOMPropertyOperations.createMarkupForProperty(propKey, propValue);\n }\n if (markup) {\n ret += ' ' + markup;\n }\n }\n }\n\n // For static pages, no need to put React ID and checksum. Saves lots of\n // bytes.\n if (transaction.renderToStaticMarkup) {\n return ret;\n }\n\n if (!this._hostParent) {\n ret += ' ' + DOMPropertyOperations.createMarkupForRoot();\n }\n ret += ' ' + DOMPropertyOperations.createMarkupForID(this._domID);\n return ret;\n },\n\n /**\n * Creates markup for the content between the tags.\n *\n * @private\n * @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction\n * @param {object} props\n * @param {object} context\n * @return {string} Content markup.\n */\n _createContentMarkup: function (transaction, props, context) {\n var ret = '';\n\n // Intentional use of != to avoid catching zero/false.\n var innerHTML = props.dangerouslySetInnerHTML;\n if (innerHTML != null) {\n if (innerHTML.__html != null) {\n ret = innerHTML.__html;\n }\n } else {\n var contentToUse = CONTENT_TYPES[typeof props.children] ? props.children : null;\n var childrenToUse = contentToUse != null ? null : props.children;\n if (contentToUse != null) {\n // TODO: Validate that text is allowed as a child of this node\n ret = escapeTextContentForBrowser(contentToUse);\n if (process.env.NODE_ENV !== 'production') {\n setAndValidateContentChildDev.call(this, contentToUse);\n }\n } else if (childrenToUse != null) {\n var mountImages = this.mountChildren(childrenToUse, transaction, context);\n ret = mountImages.join('');\n }\n }\n if (newlineEatingTags[this._tag] && ret.charAt(0) === '\\n') {\n // text/html ignores the first character in these tags if it's a newline\n // Prefer to break application/xml over text/html (for now) by adding\n // a newline specifically to get eaten by the parser. (Alternately for\n // textareas, replacing \"^\\n\" with \"\\r\\n\" doesn't get eaten, and the first\n // \\r is normalized out by HTMLTextAreaElement#value.)\n // See: <http://www.w3.org/TR/html-polyglot/#newlines-in-textarea-and-pre>\n // See: <http://www.w3.org/TR/html5/syntax.html#element-restrictions>\n // See: <http://www.w3.org/TR/html5/syntax.html#newlines>\n // See: Parsing of \"textarea\" \"listing\" and \"pre\" elements\n // from <http://www.w3.org/TR/html5/syntax.html#parsing-main-inbody>\n return '\\n' + ret;\n } else {\n return ret;\n }\n },\n\n _createInitialChildren: function (transaction, props, context, lazyTree) {\n // Intentional use of != to avoid catching zero/false.\n var innerHTML = props.dangerouslySetInnerHTML;\n if (innerHTML != null) {\n if (innerHTML.__html != null) {\n DOMLazyTree.queueHTML(lazyTree, innerHTML.__html);\n }\n } else {\n var contentToUse = CONTENT_TYPES[typeof props.children] ? props.children : null;\n var childrenToUse = contentToUse != null ? null : props.children;\n // TODO: Validate that text is allowed as a child of this node\n if (contentToUse != null) {\n // Avoid setting textContent when the text is empty. In IE11 setting\n // textContent on a text area will cause the placeholder to not\n // show within the textarea until it has been focused and blurred again.\n // https://github.com/facebook/react/issues/6731#issuecomment-254874553\n if (contentToUse !== '') {\n if (process.env.NODE_ENV !== 'production') {\n setAndValidateContentChildDev.call(this, contentToUse);\n }\n DOMLazyTree.queueText(lazyTree, contentToUse);\n }\n } else if (childrenToUse != null) {\n var mountImages = this.mountChildren(childrenToUse, transaction, context);\n for (var i = 0; i < mountImages.length; i++) {\n DOMLazyTree.queueChild(lazyTree, mountImages[i]);\n }\n }\n }\n },\n\n /**\n * Receives a next element and updates the component.\n *\n * @internal\n * @param {ReactElement} nextElement\n * @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction\n * @param {object} context\n */\n receiveComponent: function (nextElement, transaction, context) {\n var prevElement = this._currentElement;\n this._currentElement = nextElement;\n this.updateComponent(transaction, prevElement, nextElement, context);\n },\n\n /**\n * Updates a DOM component after it has already been allocated and\n * attached to the DOM. Reconciles the root DOM node, then recurses.\n *\n * @param {ReactReconcileTransaction} transaction\n * @param {ReactElement} prevElement\n * @param {ReactElement} nextElement\n * @internal\n * @overridable\n */\n updateComponent: function (transaction, prevElement, nextElement, context) {\n var lastProps = prevElement.props;\n var nextProps = this._currentElement.props;\n\n switch (this._tag) {\n case 'input':\n lastProps = ReactDOMInput.getHostProps(this, lastProps);\n nextProps = ReactDOMInput.getHostProps(this, nextProps);\n break;\n case 'option':\n lastProps = ReactDOMOption.getHostProps(this, lastProps);\n nextProps = ReactDOMOption.getHostProps(this, nextProps);\n break;\n case 'select':\n lastProps = ReactDOMSelect.getHostProps(this, lastProps);\n nextProps = ReactDOMSelect.getHostProps(this, nextProps);\n break;\n case 'textarea':\n lastProps = ReactDOMTextarea.getHostProps(this, lastProps);\n nextProps = ReactDOMTextarea.getHostProps(this, nextProps);\n break;\n }\n\n assertValidProps(this, nextProps);\n this._updateDOMProperties(lastProps, nextProps, transaction);\n this._updateDOMChildren(lastProps, nextProps, transaction, context);\n\n switch (this._tag) {\n case 'input':\n // Update the wrapper around inputs *after* updating props. This has to\n // happen after `_updateDOMProperties`. Otherwise HTML5 input validations\n // raise warnings and prevent the new value from being assigned.\n ReactDOMInput.updateWrapper(this);\n\n // We also check that we haven't missed a value update, such as a\n // Radio group shifting the checked value to another named radio input.\n inputValueTracking.updateValueIfChanged(this);\n break;\n case 'textarea':\n ReactDOMTextarea.updateWrapper(this);\n break;\n case 'select':\n // <select> value update needs to occur after <option> children\n // reconciliation\n transaction.getReactMountReady().enqueue(postUpdateSelectWrapper, this);\n break;\n }\n },\n\n /**\n * Reconciles the properties by detecting differences in property values and\n * updating the DOM as necessary. This function is probably the single most\n * critical path for performance optimization.\n *\n * TODO: Benchmark whether checking for changed values in memory actually\n * improves performance (especially statically positioned elements).\n * TODO: Benchmark the effects of putting this at the top since 99% of props\n * do not change for a given reconciliation.\n * TODO: Benchmark areas that can be improved with caching.\n *\n * @private\n * @param {object} lastProps\n * @param {object} nextProps\n * @param {?DOMElement} node\n */\n _updateDOMProperties: function (lastProps, nextProps, transaction) {\n var propKey;\n var styleName;\n var styleUpdates;\n for (propKey in lastProps) {\n if (nextProps.hasOwnProperty(propKey) || !lastProps.hasOwnProperty(propKey) || lastProps[propKey] == null) {\n continue;\n }\n if (propKey === STYLE) {\n var lastStyle = this._previousStyleCopy;\n for (styleName in lastStyle) {\n if (lastStyle.hasOwnProperty(styleName)) {\n styleUpdates = styleUpdates || {};\n styleUpdates[styleName] = '';\n }\n }\n this._previousStyleCopy = null;\n } else if (registrationNameModules.hasOwnProperty(propKey)) {\n if (lastProps[propKey]) {\n // Only call deleteListener if there was a listener previously or\n // else willDeleteListener gets called when there wasn't actually a\n // listener (e.g., onClick={null})\n deleteListener(this, propKey);\n }\n } else if (isCustomComponent(this._tag, lastProps)) {\n if (!RESERVED_PROPS.hasOwnProperty(propKey)) {\n DOMPropertyOperations.deleteValueForAttribute(getNode(this), propKey);\n }\n } else if (DOMProperty.properties[propKey] || DOMProperty.isCustomAttribute(propKey)) {\n DOMPropertyOperations.deleteValueForProperty(getNode(this), propKey);\n }\n }\n for (propKey in nextProps) {\n var nextProp = nextProps[propKey];\n var lastProp = propKey === STYLE ? this._previousStyleCopy : lastProps != null ? lastProps[propKey] : undefined;\n if (!nextProps.hasOwnProperty(propKey) || nextProp === lastProp || nextProp == null && lastProp == null) {\n continue;\n }\n if (propKey === STYLE) {\n if (nextProp) {\n if (process.env.NODE_ENV !== 'production') {\n checkAndWarnForMutatedStyle(this._previousStyleCopy, this._previousStyle, this);\n this._previousStyle = nextProp;\n }\n nextProp = this._previousStyleCopy = _assign({}, nextProp);\n } else {\n this._previousStyleCopy = null;\n }\n if (lastProp) {\n // Unset styles on `lastProp` but not on `nextProp`.\n for (styleName in lastProp) {\n if (lastProp.hasOwnProperty(styleName) && (!nextProp || !nextProp.hasOwnProperty(styleName))) {\n styleUpdates = styleUpdates || {};\n styleUpdates[styleName] = '';\n }\n }\n // Update styles that changed since `lastProp`.\n for (styleName in nextProp) {\n if (nextProp.hasOwnProperty(styleName) && lastProp[styleName] !== nextProp[styleName]) {\n styleUpdates = styleUpdates || {};\n styleUpdates[styleName] = nextProp[styleName];\n }\n }\n } else {\n // Relies on `updateStylesByID` not mutating `styleUpdates`.\n styleUpdates = nextProp;\n }\n } else if (registrationNameModules.hasOwnProperty(propKey)) {\n if (nextProp) {\n enqueuePutListener(this, propKey, nextProp, transaction);\n } else if (lastProp) {\n deleteListener(this, propKey);\n }\n } else if (isCustomComponent(this._tag, nextProps)) {\n if (!RESERVED_PROPS.hasOwnProperty(propKey)) {\n DOMPropertyOperations.setValueForAttribute(getNode(this), propKey, nextProp);\n }\n } else if (DOMProperty.properties[propKey] || DOMProperty.isCustomAttribute(propKey)) {\n var node = getNode(this);\n // If we're updating to null or undefined, we should remove the property\n // from the DOM node instead of inadvertently setting to a string. This\n // brings us in line with the same behavior we have on initial render.\n if (nextProp != null) {\n DOMPropertyOperations.setValueForProperty(node, propKey, nextProp);\n } else {\n DOMPropertyOperations.deleteValueForProperty(node, propKey);\n }\n }\n }\n if (styleUpdates) {\n CSSPropertyOperations.setValueForStyles(getNode(this), styleUpdates, this);\n }\n },\n\n /**\n * Reconciles the children with the various properties that affect the\n * children content.\n *\n * @param {object} lastProps\n * @param {object} nextProps\n * @param {ReactReconcileTransaction} transaction\n * @param {object} context\n */\n _updateDOMChildren: function (lastProps, nextProps, transaction, context) {\n var lastContent = CONTENT_TYPES[typeof lastProps.children] ? lastProps.children : null;\n var nextContent = CONTENT_TYPES[typeof nextProps.children] ? nextProps.children : null;\n\n var lastHtml = lastProps.dangerouslySetInnerHTML && lastProps.dangerouslySetInnerHTML.__html;\n var nextHtml = nextProps.dangerouslySetInnerHTML && nextProps.dangerouslySetInnerHTML.__html;\n\n // Note the use of `!=` which checks for null or undefined.\n var lastChildren = lastContent != null ? null : lastProps.children;\n var nextChildren = nextContent != null ? null : nextProps.children;\n\n // If we're switching from children to content/html or vice versa, remove\n // the old content\n var lastHasContentOrHtml = lastContent != null || lastHtml != null;\n var nextHasContentOrHtml = nextContent != null || nextHtml != null;\n if (lastChildren != null && nextChildren == null) {\n this.updateChildren(null, transaction, context);\n } else if (lastHasContentOrHtml && !nextHasContentOrHtml) {\n this.updateTextContent('');\n if (process.env.NODE_ENV !== 'production') {\n ReactInstrumentation.debugTool.onSetChildren(this._debugID, []);\n }\n }\n\n if (nextContent != null) {\n if (lastContent !== nextContent) {\n this.updateTextContent('' + nextContent);\n if (process.env.NODE_ENV !== 'production') {\n setAndValidateContentChildDev.call(this, nextContent);\n }\n }\n } else if (nextHtml != null) {\n if (lastHtml !== nextHtml) {\n this.updateMarkup('' + nextHtml);\n }\n if (process.env.NODE_ENV !== 'production') {\n ReactInstrumentation.debugTool.onSetChildren(this._debugID, []);\n }\n } else if (nextChildren != null) {\n if (process.env.NODE_ENV !== 'production') {\n setAndValidateContentChildDev.call(this, null);\n }\n\n this.updateChildren(nextChildren, transaction, context);\n }\n },\n\n getHostNode: function () {\n return getNode(this);\n },\n\n /**\n * Destroys all event registrations for this instance. Does not remove from\n * the DOM. That must be done by the parent.\n *\n * @internal\n */\n unmountComponent: function (safely) {\n switch (this._tag) {\n case 'audio':\n case 'form':\n case 'iframe':\n case 'img':\n case 'link':\n case 'object':\n case 'source':\n case 'video':\n var listeners = this._wrapperState.listeners;\n if (listeners) {\n for (var i = 0; i < listeners.length; i++) {\n listeners[i].remove();\n }\n }\n break;\n case 'input':\n case 'textarea':\n inputValueTracking.stopTracking(this);\n break;\n case 'html':\n case 'head':\n case 'body':\n /**\n * Components like <html> <head> and <body> can't be removed or added\n * easily in a cross-browser way, however it's valuable to be able to\n * take advantage of React's reconciliation for styling and <title>\n * management. So we just document it and throw in dangerous cases.\n */\n !false ? process.env.NODE_ENV !== 'production' ? invariant(false, '<%s> tried to unmount. Because of cross-browser quirks it is impossible to unmount some top-level components (eg <html>, <head>, and <body>) reliably and efficiently. To fix this, have a single top-level component that never unmounts render these elements.', this._tag) : _prodInvariant('66', this._tag) : void 0;\n break;\n }\n\n this.unmountChildren(safely);\n ReactDOMComponentTree.uncacheNode(this);\n EventPluginHub.deleteAllListeners(this);\n this._rootNodeID = 0;\n this._domID = 0;\n this._wrapperState = null;\n\n if (process.env.NODE_ENV !== 'production') {\n setAndValidateContentChildDev.call(this, null);\n }\n },\n\n getPublicInstance: function () {\n return getNode(this);\n }\n};\n\n_assign(ReactDOMComponent.prototype, ReactDOMComponent.Mixin, ReactMultiChild.Mixin);\n\nmodule.exports = ReactDOMComponent;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar DOMChildrenOperations = require('./DOMChildrenOperations');\nvar ReactDOMComponentTree = require('./ReactDOMComponentTree');\n\n/**\n * Operations used to process updates to DOM nodes.\n */\nvar ReactDOMIDOperations = {\n /**\n * Updates a component's children by processing a series of updates.\n *\n * @param {array<object>} updates List of update configurations.\n * @internal\n */\n dangerouslyProcessChildrenUpdates: function (parentInst, updates) {\n var node = ReactDOMComponentTree.getNodeFromInstance(parentInst);\n DOMChildrenOperations.processUpdates(node, updates);\n }\n};\n\nmodule.exports = ReactDOMIDOperations;","'use strict';\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n/*eslint-disable fb-www/unsafe-html */\n\nvar ExecutionEnvironment = require('./ExecutionEnvironment');\n\nvar invariant = require('./invariant');\n\n/**\n * Dummy container used to detect which wraps are necessary.\n */\nvar dummyNode = ExecutionEnvironment.canUseDOM ? document.createElement('div') : null;\n\n/**\n * Some browsers cannot use `innerHTML` to render certain elements standalone,\n * so we wrap them, render the wrapped nodes, then extract the desired node.\n *\n * In IE8, certain elements cannot render alone, so wrap all elements ('*').\n */\n\nvar shouldWrap = {};\n\nvar selectWrap = [1, '<select multiple=\"true\">', '</select>'];\nvar tableWrap = [1, '<table>', '</table>'];\nvar trWrap = [3, '<table><tbody><tr>', '</tr></tbody></table>'];\n\nvar svgWrap = [1, '<svg xmlns=\"http://www.w3.org/2000/svg\">', '</svg>'];\n\nvar markupWrap = {\n '*': [1, '?<div>', '</div>'],\n\n 'area': [1, '<map>', '</map>'],\n 'col': [2, '<table><tbody></tbody><colgroup>', '</colgroup></table>'],\n 'legend': [1, '<fieldset>', '</fieldset>'],\n 'param': [1, '<object>', '</object>'],\n 'tr': [2, '<table><tbody>', '</tbody></table>'],\n\n 'optgroup': selectWrap,\n 'option': selectWrap,\n\n 'caption': tableWrap,\n 'colgroup': tableWrap,\n 'tbody': tableWrap,\n 'tfoot': tableWrap,\n 'thead': tableWrap,\n\n 'td': trWrap,\n 'th': trWrap\n};\n\n// Initialize the SVG elements since we know they'll always need to be wrapped\n// consistently. If they are created inside a <div> they will be initialized in\n// the wrong namespace (and will not display).\nvar svgElements = ['circle', 'clipPath', 'defs', 'ellipse', 'g', 'image', 'line', 'linearGradient', 'mask', 'path', 'pattern', 'polygon', 'polyline', 'radialGradient', 'rect', 'stop', 'text', 'tspan'];\nsvgElements.forEach(function (nodeName) {\n markupWrap[nodeName] = svgWrap;\n shouldWrap[nodeName] = true;\n});\n\n/**\n * Gets the markup wrap configuration for the supplied `nodeName`.\n *\n * NOTE: This lazily detects which wraps are necessary for the current browser.\n *\n * @param {string} nodeName Lowercase `nodeName`.\n * @return {?array} Markup wrap configuration, if applicable.\n */\nfunction getMarkupWrap(nodeName) {\n !!!dummyNode ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Markup wrapping node not initialized') : invariant(false) : void 0;\n if (!markupWrap.hasOwnProperty(nodeName)) {\n nodeName = '*';\n }\n if (!shouldWrap.hasOwnProperty(nodeName)) {\n if (nodeName === '*') {\n dummyNode.innerHTML = '<link />';\n } else {\n dummyNode.innerHTML = '<' + nodeName + '></' + nodeName + '>';\n }\n shouldWrap[nodeName] = !dummyNode.firstChild;\n }\n return shouldWrap[nodeName] ? markupWrap[nodeName] : null;\n}\n\nmodule.exports = getMarkupWrap;","'use strict';\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\nvar invariant = require('./invariant');\n\n/**\n * Convert array-like objects to arrays.\n *\n * This API assumes the caller knows the contents of the data type. For less\n * well defined inputs use createArrayFromMixed.\n *\n * @param {object|function|filelist} obj\n * @return {array}\n */\nfunction toArray(obj) {\n var length = obj.length;\n\n // Some browsers builtin objects can report typeof 'function' (e.g. NodeList\n // in old versions of Safari).\n !(!Array.isArray(obj) && (typeof obj === 'object' || typeof obj === 'function')) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'toArray: Array-like object expected') : invariant(false) : void 0;\n\n !(typeof length === 'number') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'toArray: Object needs a length property') : invariant(false) : void 0;\n\n !(length === 0 || length - 1 in obj) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'toArray: Object should have keys for indices') : invariant(false) : void 0;\n\n !(typeof obj.callee !== 'function') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'toArray: Object can\\'t be `arguments`. Use rest params ' + '(function(...args) {}) or Array.from() instead.') : invariant(false) : void 0;\n\n // Old IE doesn't give collections access to hasOwnProperty. Assume inputs\n // without method will throw during the slice call and skip straight to the\n // fallback.\n if (obj.hasOwnProperty) {\n try {\n return Array.prototype.slice.call(obj);\n } catch (e) {\n // IE < 9 does not support Array#slice on collections objects\n }\n }\n\n // Fall back to copying key by key. This assumes all keys have a value,\n // so will not preserve sparsely populated inputs.\n var ret = Array(length);\n for (var ii = 0; ii < length; ii++) {\n ret[ii] = obj[ii];\n }\n return ret;\n}\n\n/**\n * Perform a heuristic test to determine if an object is \"array-like\".\n *\n * A monk asked Joshu, a Zen master, \"Has a dog Buddha nature?\"\n * Joshu replied: \"Mu.\"\n *\n * This function determines if its argument has \"array nature\": it returns\n * true if the argument is an actual array, an `arguments' object, or an\n * HTMLCollection (e.g. node.childNodes or node.getElementsByTagName()).\n *\n * It will return false for other array-like objects like Filelist.\n *\n * @param {*} obj\n * @return {boolean}\n */\nfunction hasArrayNature(obj) {\n return (\n // not null/false\n !!obj && (\n // arrays are objects, NodeLists are functions in Safari\n typeof obj == 'object' || typeof obj == 'function') &&\n // quacks like an array\n 'length' in obj &&\n // not window\n !('setInterval' in obj) &&\n // no DOM node should be considered an array-like\n // a 'select' element has 'length' and 'item' properties on IE8\n typeof obj.nodeType != 'number' && (\n // a real array\n Array.isArray(obj) ||\n // arguments\n 'callee' in obj ||\n // HTMLCollection/NodeList\n 'item' in obj)\n );\n}\n\n/**\n * Ensure that the argument is an array by wrapping it in an array if it is not.\n * Creates a copy of the argument if it is already an array.\n *\n * This is mostly useful idiomatically:\n *\n * var createArrayFromMixed = require('createArrayFromMixed');\n *\n * function takesOneOrMoreThings(things) {\n * things = createArrayFromMixed(things);\n * ...\n * }\n *\n * This allows you to treat `things' as an array, but accept scalars in the API.\n *\n * If you need to convert an array-like object, like `arguments`, into an array\n * use toArray instead.\n *\n * @param {*} obj\n * @return {array}\n */\nfunction createArrayFromMixed(obj) {\n if (!hasArrayNature(obj)) {\n return [obj];\n } else if (Array.isArray(obj)) {\n return obj.slice();\n } else {\n return toArray(obj);\n }\n}\n\nmodule.exports = createArrayFromMixed;","'use strict';\n\n/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * @typechecks\n */\n\n/*eslint-disable fb-www/unsafe-html*/\n\nvar ExecutionEnvironment = require('./ExecutionEnvironment');\n\nvar createArrayFromMixed = require('./createArrayFromMixed');\nvar getMarkupWrap = require('./getMarkupWrap');\nvar invariant = require('./invariant');\n\n/**\n * Dummy container used to render all markup.\n */\nvar dummyNode = ExecutionEnvironment.canUseDOM ? document.createElement('div') : null;\n\n/**\n * Pattern used by `getNodeName`.\n */\nvar nodeNamePattern = /^\\s*<(\\w+)/;\n\n/**\n * Extracts the `nodeName` of the first element in a string of markup.\n *\n * @param {string} markup String of markup.\n * @return {?string} Node name of the supplied markup.\n */\nfunction getNodeName(markup) {\n var nodeNameMatch = markup.match(nodeNamePattern);\n return nodeNameMatch && nodeNameMatch[1].toLowerCase();\n}\n\n/**\n * Creates an array containing the nodes rendered from the supplied markup. The\n * optionally supplied `handleScript` function will be invoked once for each\n * <script> element that is rendered. If no `handleScript` function is supplied,\n * an exception is thrown if any <script> elements are rendered.\n *\n * @param {string} markup A string of valid HTML markup.\n * @param {?function} handleScript Invoked once for each rendered <script>.\n * @return {array<DOMElement|DOMTextNode>} An array of rendered nodes.\n */\nfunction createNodesFromMarkup(markup, handleScript) {\n var node = dummyNode;\n !!!dummyNode ? process.env.NODE_ENV !== 'production' ? invariant(false, 'createNodesFromMarkup dummy not initialized') : invariant(false) : void 0;\n var nodeName = getNodeName(markup);\n\n var wrap = nodeName && getMarkupWrap(nodeName);\n if (wrap) {\n node.innerHTML = wrap[1] + markup + wrap[2];\n\n var wrapDepth = wrap[0];\n while (wrapDepth--) {\n node = node.lastChild;\n }\n } else {\n node.innerHTML = markup;\n }\n\n var scripts = node.getElementsByTagName('script');\n if (scripts.length) {\n !handleScript ? process.env.NODE_ENV !== 'production' ? invariant(false, 'createNodesFromMarkup(...): Unexpected <script> element rendered.') : invariant(false) : void 0;\n createArrayFromMixed(scripts).forEach(handleScript);\n }\n\n var nodes = Array.from(node.childNodes);\n while (node.lastChild) {\n node.removeChild(node.lastChild);\n }\n return nodes;\n}\n\nmodule.exports = createNodesFromMarkup;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar _prodInvariant = require('./reactProdInvariant');\n\nvar DOMLazyTree = require('./DOMLazyTree');\nvar ExecutionEnvironment = require('fbjs/lib/ExecutionEnvironment');\n\nvar createNodesFromMarkup = require('fbjs/lib/createNodesFromMarkup');\nvar emptyFunction = require('fbjs/lib/emptyFunction');\nvar invariant = require('fbjs/lib/invariant');\n\nvar Danger = {\n /**\n * Replaces a node with a string of markup at its current position within its\n * parent. The markup must render into a single root node.\n *\n * @param {DOMElement} oldChild Child node to replace.\n * @param {string} markup Markup to render in place of the child node.\n * @internal\n */\n dangerouslyReplaceNodeWithMarkup: function (oldChild, markup) {\n !ExecutionEnvironment.canUseDOM ? process.env.NODE_ENV !== 'production' ? invariant(false, 'dangerouslyReplaceNodeWithMarkup(...): Cannot render markup in a worker thread. Make sure `window` and `document` are available globally before requiring React when unit testing or use ReactDOMServer.renderToString() for server rendering.') : _prodInvariant('56') : void 0;\n !markup ? process.env.NODE_ENV !== 'production' ? invariant(false, 'dangerouslyReplaceNodeWithMarkup(...): Missing markup.') : _prodInvariant('57') : void 0;\n !(oldChild.nodeName !== 'HTML') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'dangerouslyReplaceNodeWithMarkup(...): Cannot replace markup of the <html> node. This is because browser quirks make this unreliable and/or slow. If you want to render to the root you must use server rendering. See ReactDOMServer.renderToString().') : _prodInvariant('58') : void 0;\n\n if (typeof markup === 'string') {\n var newChild = createNodesFromMarkup(markup, emptyFunction)[0];\n oldChild.parentNode.replaceChild(newChild, oldChild);\n } else {\n DOMLazyTree.replaceChildWithTree(oldChild, markup);\n }\n }\n};\n\nmodule.exports = Danger;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar DOMChildrenOperations = require('./DOMChildrenOperations');\nvar ReactDOMIDOperations = require('./ReactDOMIDOperations');\n\n/**\n * Abstracts away all functionality of the reconciler that requires knowledge of\n * the browser context. TODO: These callers should be refactored to avoid the\n * need for this injection.\n */\nvar ReactComponentBrowserEnvironment = {\n processChildrenUpdates: ReactDOMIDOperations.dangerouslyProcessChildrenUpdates,\n\n replaceNodeWithMarkup: DOMChildrenOperations.dangerouslyReplaceNodeWithMarkup\n};\n\nmodule.exports = ReactComponentBrowserEnvironment;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar DOMProperty = require('./DOMProperty');\n\nvar MUST_USE_PROPERTY = DOMProperty.injection.MUST_USE_PROPERTY;\nvar HAS_BOOLEAN_VALUE = DOMProperty.injection.HAS_BOOLEAN_VALUE;\nvar HAS_NUMERIC_VALUE = DOMProperty.injection.HAS_NUMERIC_VALUE;\nvar HAS_POSITIVE_NUMERIC_VALUE = DOMProperty.injection.HAS_POSITIVE_NUMERIC_VALUE;\nvar HAS_OVERLOADED_BOOLEAN_VALUE = DOMProperty.injection.HAS_OVERLOADED_BOOLEAN_VALUE;\n\nvar HTMLDOMPropertyConfig = {\n isCustomAttribute: RegExp.prototype.test.bind(new RegExp('^(data|aria)-[' + DOMProperty.ATTRIBUTE_NAME_CHAR + ']*$')),\n Properties: {\n /**\n * Standard Properties\n */\n accept: 0,\n acceptCharset: 0,\n accessKey: 0,\n action: 0,\n allowFullScreen: HAS_BOOLEAN_VALUE,\n allowTransparency: 0,\n alt: 0,\n // specifies target context for links with `preload` type\n as: 0,\n async: HAS_BOOLEAN_VALUE,\n autoComplete: 0,\n // autoFocus is polyfilled/normalized by AutoFocusUtils\n // autoFocus: HAS_BOOLEAN_VALUE,\n autoPlay: HAS_BOOLEAN_VALUE,\n capture: HAS_BOOLEAN_VALUE,\n cellPadding: 0,\n cellSpacing: 0,\n charSet: 0,\n challenge: 0,\n checked: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,\n cite: 0,\n classID: 0,\n className: 0,\n cols: HAS_POSITIVE_NUMERIC_VALUE,\n colSpan: 0,\n content: 0,\n contentEditable: 0,\n contextMenu: 0,\n controls: HAS_BOOLEAN_VALUE,\n controlsList: 0,\n coords: 0,\n crossOrigin: 0,\n data: 0, // For `<object />` acts as `src`.\n dateTime: 0,\n 'default': HAS_BOOLEAN_VALUE,\n defer: HAS_BOOLEAN_VALUE,\n dir: 0,\n disabled: HAS_BOOLEAN_VALUE,\n download: HAS_OVERLOADED_BOOLEAN_VALUE,\n draggable: 0,\n encType: 0,\n form: 0,\n formAction: 0,\n formEncType: 0,\n formMethod: 0,\n formNoValidate: HAS_BOOLEAN_VALUE,\n formTarget: 0,\n frameBorder: 0,\n headers: 0,\n height: 0,\n hidden: HAS_BOOLEAN_VALUE,\n high: 0,\n href: 0,\n hrefLang: 0,\n htmlFor: 0,\n httpEquiv: 0,\n icon: 0,\n id: 0,\n inputMode: 0,\n integrity: 0,\n is: 0,\n keyParams: 0,\n keyType: 0,\n kind: 0,\n label: 0,\n lang: 0,\n list: 0,\n loop: HAS_BOOLEAN_VALUE,\n low: 0,\n manifest: 0,\n marginHeight: 0,\n marginWidth: 0,\n max: 0,\n maxLength: 0,\n media: 0,\n mediaGroup: 0,\n method: 0,\n min: 0,\n minLength: 0,\n // Caution; `option.selected` is not updated if `select.multiple` is\n // disabled with `removeAttribute`.\n multiple: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,\n muted: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,\n name: 0,\n nonce: 0,\n noValidate: HAS_BOOLEAN_VALUE,\n open: HAS_BOOLEAN_VALUE,\n optimum: 0,\n pattern: 0,\n placeholder: 0,\n playsInline: HAS_BOOLEAN_VALUE,\n poster: 0,\n preload: 0,\n profile: 0,\n radioGroup: 0,\n readOnly: HAS_BOOLEAN_VALUE,\n referrerPolicy: 0,\n rel: 0,\n required: HAS_BOOLEAN_VALUE,\n reversed: HAS_BOOLEAN_VALUE,\n role: 0,\n rows: HAS_POSITIVE_NUMERIC_VALUE,\n rowSpan: HAS_NUMERIC_VALUE,\n sandbox: 0,\n scope: 0,\n scoped: HAS_BOOLEAN_VALUE,\n scrolling: 0,\n seamless: HAS_BOOLEAN_VALUE,\n selected: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,\n shape: 0,\n size: HAS_POSITIVE_NUMERIC_VALUE,\n sizes: 0,\n span: HAS_POSITIVE_NUMERIC_VALUE,\n spellCheck: 0,\n src: 0,\n srcDoc: 0,\n srcLang: 0,\n srcSet: 0,\n start: HAS_NUMERIC_VALUE,\n step: 0,\n style: 0,\n summary: 0,\n tabIndex: 0,\n target: 0,\n title: 0,\n // Setting .type throws on non-<input> tags\n type: 0,\n useMap: 0,\n value: 0,\n width: 0,\n wmode: 0,\n wrap: 0,\n\n /**\n * RDFa Properties\n */\n about: 0,\n datatype: 0,\n inlist: 0,\n prefix: 0,\n // property is also supported for OpenGraph in meta tags.\n property: 0,\n resource: 0,\n 'typeof': 0,\n vocab: 0,\n\n /**\n * Non-standard Properties\n */\n // autoCapitalize and autoCorrect are supported in Mobile Safari for\n // keyboard hints.\n autoCapitalize: 0,\n autoCorrect: 0,\n // autoSave allows WebKit/Blink to persist values of input fields on page reloads\n autoSave: 0,\n // color is for Safari mask-icon link\n color: 0,\n // itemProp, itemScope, itemType are for\n // Microdata support. See http://schema.org/docs/gs.html\n itemProp: 0,\n itemScope: HAS_BOOLEAN_VALUE,\n itemType: 0,\n // itemID and itemRef are for Microdata support as well but\n // only specified in the WHATWG spec document. See\n // https://html.spec.whatwg.org/multipage/microdata.html#microdata-dom-api\n itemID: 0,\n itemRef: 0,\n // results show looking glass icon and recent searches on input\n // search fields in WebKit/Blink\n results: 0,\n // IE-only attribute that specifies security restrictions on an iframe\n // as an alternative to the sandbox attribute on IE<10\n security: 0,\n // IE-only attribute that controls focus behavior\n unselectable: 0\n },\n DOMAttributeNames: {\n acceptCharset: 'accept-charset',\n className: 'class',\n htmlFor: 'for',\n httpEquiv: 'http-equiv'\n },\n DOMPropertyNames: {},\n DOMMutationMethods: {\n value: function (node, value) {\n if (value == null) {\n return node.removeAttribute('value');\n }\n\n // Number inputs get special treatment due to some edge cases in\n // Chrome. Let everything else assign the value attribute as normal.\n // https://github.com/facebook/react/issues/7253#issuecomment-236074326\n if (node.type !== 'number' || node.hasAttribute('value') === false) {\n node.setAttribute('value', '' + value);\n } else if (node.validity && !node.validity.badInput && node.ownerDocument.activeElement !== node) {\n // Don't assign an attribute if validation reports bad\n // input. Chrome will clear the value. Additionally, don't\n // operate on inputs that have focus, otherwise Chrome might\n // strip off trailing decimal places and cause the user's\n // cursor position to jump to the beginning of the input.\n //\n // In ReactDOMInput, we have an onBlur event that will trigger\n // this function again when focus is lost.\n node.setAttribute('value', '' + value);\n }\n }\n }\n};\n\nmodule.exports = HTMLDOMPropertyConfig;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar EventPropagators = require('./EventPropagators');\nvar ReactDOMComponentTree = require('./ReactDOMComponentTree');\nvar SyntheticMouseEvent = require('./SyntheticMouseEvent');\n\nvar eventTypes = {\n mouseEnter: {\n registrationName: 'onMouseEnter',\n dependencies: ['topMouseOut', 'topMouseOver']\n },\n mouseLeave: {\n registrationName: 'onMouseLeave',\n dependencies: ['topMouseOut', 'topMouseOver']\n }\n};\n\nvar EnterLeaveEventPlugin = {\n eventTypes: eventTypes,\n\n /**\n * For almost every interaction we care about, there will be both a top-level\n * `mouseover` and `mouseout` event that occurs. Only use `mouseout` so that\n * we do not extract duplicate events. However, moving the mouse into the\n * browser from outside will not fire a `mouseout` event. In this case, we use\n * the `mouseover` top-level event.\n */\n extractEvents: function (topLevelType, targetInst, nativeEvent, nativeEventTarget) {\n if (topLevelType === 'topMouseOver' && (nativeEvent.relatedTarget || nativeEvent.fromElement)) {\n return null;\n }\n if (topLevelType !== 'topMouseOut' && topLevelType !== 'topMouseOver') {\n // Must not be a mouse in or mouse out - ignoring.\n return null;\n }\n\n var win;\n if (nativeEventTarget.window === nativeEventTarget) {\n // `nativeEventTarget` is probably a window object.\n win = nativeEventTarget;\n } else {\n // TODO: Figure out why `ownerDocument` is sometimes undefined in IE8.\n var doc = nativeEventTarget.ownerDocument;\n if (doc) {\n win = doc.defaultView || doc.parentWindow;\n } else {\n win = window;\n }\n }\n\n var from;\n var to;\n if (topLevelType === 'topMouseOut') {\n from = targetInst;\n var related = nativeEvent.relatedTarget || nativeEvent.toElement;\n to = related ? ReactDOMComponentTree.getClosestInstanceFromNode(related) : null;\n } else {\n // Moving to a node from outside the window.\n from = null;\n to = targetInst;\n }\n\n if (from === to) {\n // Nothing pertains to our managed components.\n return null;\n }\n\n var fromNode = from == null ? win : ReactDOMComponentTree.getNodeFromInstance(from);\n var toNode = to == null ? win : ReactDOMComponentTree.getNodeFromInstance(to);\n\n var leave = SyntheticMouseEvent.getPooled(eventTypes.mouseLeave, from, nativeEvent, nativeEventTarget);\n leave.type = 'mouseleave';\n leave.target = fromNode;\n leave.relatedTarget = toNode;\n\n var enter = SyntheticMouseEvent.getPooled(eventTypes.mouseEnter, to, nativeEvent, nativeEventTarget);\n enter.type = 'mouseenter';\n enter.target = toNode;\n enter.relatedTarget = fromNode;\n\n EventPropagators.accumulateEnterLeaveDispatches(leave, enter, from, to);\n\n return [leave, enter];\n }\n};\n\nmodule.exports = EnterLeaveEventPlugin;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\n/**\n * Module that is injectable into `EventPluginHub`, that specifies a\n * deterministic ordering of `EventPlugin`s. A convenient way to reason about\n * plugins, without having to package every one of them. This is better than\n * having plugins be ordered in the same order that they are injected because\n * that ordering would be influenced by the packaging order.\n * `ResponderEventPlugin` must occur before `SimpleEventPlugin` so that\n * preventing default on events is convenient in `SimpleEventPlugin` handlers.\n */\n\nvar DefaultEventPluginOrder = ['ResponderEventPlugin', 'SimpleEventPlugin', 'TapEventPlugin', 'EnterLeaveEventPlugin', 'ChangeEventPlugin', 'SelectEventPlugin', 'BeforeInputEventPlugin'];\n\nmodule.exports = DefaultEventPluginOrder;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n */\n\n'use strict';\n\nvar _prodInvariant = require('./reactProdInvariant');\n\nvar invariant = require('fbjs/lib/invariant');\n\n/**\n * @param {?object} object\n * @return {boolean} True if `object` is a valid owner.\n * @final\n */\nfunction isValidOwner(object) {\n return !!(object && typeof object.attachRef === 'function' && typeof object.detachRef === 'function');\n}\n\n/**\n * ReactOwners are capable of storing references to owned components.\n *\n * All components are capable of //being// referenced by owner components, but\n * only ReactOwner components are capable of //referencing// owned components.\n * The named reference is known as a \"ref\".\n *\n * Refs are available when mounted and updated during reconciliation.\n *\n * var MyComponent = React.createClass({\n * render: function() {\n * return (\n * <div onClick={this.handleClick}>\n * <CustomComponent ref=\"custom\" />\n * </div>\n * );\n * },\n * handleClick: function() {\n * this.refs.custom.handleClick();\n * },\n * componentDidMount: function() {\n * this.refs.custom.initialize();\n * }\n * });\n *\n * Refs should rarely be used. When refs are used, they should only be done to\n * control data that is not handled by React's data flow.\n *\n * @class ReactOwner\n */\nvar ReactOwner = {\n /**\n * Adds a component by ref to an owner component.\n *\n * @param {ReactComponent} component Component to reference.\n * @param {string} ref Name by which to refer to the component.\n * @param {ReactOwner} owner Component on which to record the ref.\n * @final\n * @internal\n */\n addComponentAsRefTo: function (component, ref, owner) {\n !isValidOwner(owner) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'addComponentAsRefTo(...): Only a ReactOwner can have refs. You might be adding a ref to a component that was not created inside a component\\'s `render` method, or you have multiple copies of React loaded (details: https://fb.me/react-refs-must-have-owner).') : _prodInvariant('119') : void 0;\n owner.attachRef(ref, component);\n },\n\n /**\n * Removes a component by ref from an owner component.\n *\n * @param {ReactComponent} component Component to dereference.\n * @param {string} ref Name of the ref to remove.\n * @param {ReactOwner} owner Component on which the ref is recorded.\n * @final\n * @internal\n */\n removeComponentAsRefFrom: function (component, ref, owner) {\n !isValidOwner(owner) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'removeComponentAsRefFrom(...): Only a ReactOwner can have refs. You might be removing a ref to a component that was not created inside a component\\'s `render` method, or you have multiple copies of React loaded (details: https://fb.me/react-refs-must-have-owner).') : _prodInvariant('120') : void 0;\n var ownerPublicInstance = owner.getPublicInstance();\n // Check that `component`'s owner is still alive and that `component` is still the current ref\n // because we do not want to detach the ref if another component stole it.\n if (ownerPublicInstance && ownerPublicInstance.refs[ref] === component.getPublicInstance()) {\n owner.detachRef(ref);\n }\n }\n};\n\nmodule.exports = ReactOwner;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n * \n */\n\n'use strict';\n\nvar ReactOwner = require('./ReactOwner');\n\nvar ReactRef = {};\n\nfunction attachRef(ref, component, owner) {\n if (typeof ref === 'function') {\n ref(component.getPublicInstance());\n } else {\n // Legacy ref\n ReactOwner.addComponentAsRefTo(component, ref, owner);\n }\n}\n\nfunction detachRef(ref, component, owner) {\n if (typeof ref === 'function') {\n ref(null);\n } else {\n // Legacy ref\n ReactOwner.removeComponentAsRefFrom(component, ref, owner);\n }\n}\n\nReactRef.attachRefs = function (instance, element) {\n if (element === null || typeof element !== 'object') {\n return;\n }\n var ref = element.ref;\n if (ref != null) {\n attachRef(ref, instance, element._owner);\n }\n};\n\nReactRef.shouldUpdateRefs = function (prevElement, nextElement) {\n // If either the owner or a `ref` has changed, make sure the newest owner\n // has stored a reference to `this`, and the previous owner (if different)\n // has forgotten the reference to `this`. We use the element instead\n // of the public this.props because the post processing cannot determine\n // a ref. The ref conceptually lives on the element.\n\n // TODO: Should this even be possible? The owner cannot change because\n // it's forbidden by shouldUpdateReactComponent. The ref can change\n // if you swap the keys of but not the refs. Reconsider where this check\n // is made. It probably belongs where the key checking and\n // instantiateReactComponent is done.\n\n var prevRef = null;\n var prevOwner = null;\n if (prevElement !== null && typeof prevElement === 'object') {\n prevRef = prevElement.ref;\n prevOwner = prevElement._owner;\n }\n\n var nextRef = null;\n var nextOwner = null;\n if (nextElement !== null && typeof nextElement === 'object') {\n nextRef = nextElement.ref;\n nextOwner = nextElement._owner;\n }\n\n return prevRef !== nextRef ||\n // If owner changes but we have an unchanged function ref, don't update refs\n typeof nextRef === 'string' && nextOwner !== prevOwner;\n};\n\nReactRef.detachRefs = function (instance, element) {\n if (element === null || typeof element !== 'object') {\n return;\n }\n var ref = element.ref;\n if (ref != null) {\n detachRef(ref, instance, element._owner);\n }\n};\n\nmodule.exports = ReactRef;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar EventPluginHub = require('./EventPluginHub');\nvar EventPropagators = require('./EventPropagators');\nvar ExecutionEnvironment = require('fbjs/lib/ExecutionEnvironment');\nvar ReactDOMComponentTree = require('./ReactDOMComponentTree');\nvar ReactUpdates = require('./ReactUpdates');\nvar SyntheticEvent = require('./SyntheticEvent');\n\nvar inputValueTracking = require('./inputValueTracking');\nvar getEventTarget = require('./getEventTarget');\nvar isEventSupported = require('./isEventSupported');\nvar isTextInputElement = require('./isTextInputElement');\n\nvar eventTypes = {\n change: {\n phasedRegistrationNames: {\n bubbled: 'onChange',\n captured: 'onChangeCapture'\n },\n dependencies: ['topBlur', 'topChange', 'topClick', 'topFocus', 'topInput', 'topKeyDown', 'topKeyUp', 'topSelectionChange']\n }\n};\n\nfunction createAndAccumulateChangeEvent(inst, nativeEvent, target) {\n var event = SyntheticEvent.getPooled(eventTypes.change, inst, nativeEvent, target);\n event.type = 'change';\n EventPropagators.accumulateTwoPhaseDispatches(event);\n return event;\n}\n/**\n * For IE shims\n */\nvar activeElement = null;\nvar activeElementInst = null;\n\n/**\n * SECTION: handle `change` event\n */\nfunction shouldUseChangeEvent(elem) {\n var nodeName = elem.nodeName && elem.nodeName.toLowerCase();\n return nodeName === 'select' || nodeName === 'input' && elem.type === 'file';\n}\n\nvar doesChangeEventBubble = false;\nif (ExecutionEnvironment.canUseDOM) {\n // See `handleChange` comment below\n doesChangeEventBubble = isEventSupported('change') && (!document.documentMode || document.documentMode > 8);\n}\n\nfunction manualDispatchChangeEvent(nativeEvent) {\n var event = createAndAccumulateChangeEvent(activeElementInst, nativeEvent, getEventTarget(nativeEvent));\n\n // If change and propertychange bubbled, we'd just bind to it like all the\n // other events and have it go through ReactBrowserEventEmitter. Since it\n // doesn't, we manually listen for the events and so we have to enqueue and\n // process the abstract event manually.\n //\n // Batching is necessary here in order to ensure that all event handlers run\n // before the next rerender (including event handlers attached to ancestor\n // elements instead of directly on the input). Without this, controlled\n // components don't work properly in conjunction with event bubbling because\n // the component is rerendered and the value reverted before all the event\n // handlers can run. See https://github.com/facebook/react/issues/708.\n ReactUpdates.batchedUpdates(runEventInBatch, event);\n}\n\nfunction runEventInBatch(event) {\n EventPluginHub.enqueueEvents(event);\n EventPluginHub.processEventQueue(false);\n}\n\nfunction startWatchingForChangeEventIE8(target, targetInst) {\n activeElement = target;\n activeElementInst = targetInst;\n activeElement.attachEvent('onchange', manualDispatchChangeEvent);\n}\n\nfunction stopWatchingForChangeEventIE8() {\n if (!activeElement) {\n return;\n }\n activeElement.detachEvent('onchange', manualDispatchChangeEvent);\n activeElement = null;\n activeElementInst = null;\n}\n\nfunction getInstIfValueChanged(targetInst, nativeEvent) {\n var updated = inputValueTracking.updateValueIfChanged(targetInst);\n var simulated = nativeEvent.simulated === true && ChangeEventPlugin._allowSimulatedPassThrough;\n\n if (updated || simulated) {\n return targetInst;\n }\n}\n\nfunction getTargetInstForChangeEvent(topLevelType, targetInst) {\n if (topLevelType === 'topChange') {\n return targetInst;\n }\n}\n\nfunction handleEventsForChangeEventIE8(topLevelType, target, targetInst) {\n if (topLevelType === 'topFocus') {\n // stopWatching() should be a noop here but we call it just in case we\n // missed a blur event somehow.\n stopWatchingForChangeEventIE8();\n startWatchingForChangeEventIE8(target, targetInst);\n } else if (topLevelType === 'topBlur') {\n stopWatchingForChangeEventIE8();\n }\n}\n\n/**\n * SECTION: handle `input` event\n */\nvar isInputEventSupported = false;\nif (ExecutionEnvironment.canUseDOM) {\n // IE9 claims to support the input event but fails to trigger it when\n // deleting text, so we ignore its input events.\n\n isInputEventSupported = isEventSupported('input') && (!document.documentMode || document.documentMode > 9);\n}\n\n/**\n * (For IE <=9) Starts tracking propertychange events on the passed-in element\n * and override the value property so that we can distinguish user events from\n * value changes in JS.\n */\nfunction startWatchingForValueChange(target, targetInst) {\n activeElement = target;\n activeElementInst = targetInst;\n activeElement.attachEvent('onpropertychange', handlePropertyChange);\n}\n\n/**\n * (For IE <=9) Removes the event listeners from the currently-tracked element,\n * if any exists.\n */\nfunction stopWatchingForValueChange() {\n if (!activeElement) {\n return;\n }\n activeElement.detachEvent('onpropertychange', handlePropertyChange);\n\n activeElement = null;\n activeElementInst = null;\n}\n\n/**\n * (For IE <=9) Handles a propertychange event, sending a `change` event if\n * the value of the active element has changed.\n */\nfunction handlePropertyChange(nativeEvent) {\n if (nativeEvent.propertyName !== 'value') {\n return;\n }\n if (getInstIfValueChanged(activeElementInst, nativeEvent)) {\n manualDispatchChangeEvent(nativeEvent);\n }\n}\n\nfunction handleEventsForInputEventPolyfill(topLevelType, target, targetInst) {\n if (topLevelType === 'topFocus') {\n // In IE8, we can capture almost all .value changes by adding a\n // propertychange handler and looking for events with propertyName\n // equal to 'value'\n // In IE9, propertychange fires for most input events but is buggy and\n // doesn't fire when text is deleted, but conveniently, selectionchange\n // appears to fire in all of the remaining cases so we catch those and\n // forward the event if the value has changed\n // In either case, we don't want to call the event handler if the value\n // is changed from JS so we redefine a setter for `.value` that updates\n // our activeElementValue variable, allowing us to ignore those changes\n //\n // stopWatching() should be a noop here but we call it just in case we\n // missed a blur event somehow.\n stopWatchingForValueChange();\n startWatchingForValueChange(target, targetInst);\n } else if (topLevelType === 'topBlur') {\n stopWatchingForValueChange();\n }\n}\n\n// For IE8 and IE9.\nfunction getTargetInstForInputEventPolyfill(topLevelType, targetInst, nativeEvent) {\n if (topLevelType === 'topSelectionChange' || topLevelType === 'topKeyUp' || topLevelType === 'topKeyDown') {\n // On the selectionchange event, the target is just document which isn't\n // helpful for us so just check activeElement instead.\n //\n // 99% of the time, keydown and keyup aren't necessary. IE8 fails to fire\n // propertychange on the first input event after setting `value` from a\n // script and fires only keydown, keypress, keyup. Catching keyup usually\n // gets it and catching keydown lets us fire an event for the first\n // keystroke if user does a key repeat (it'll be a little delayed: right\n // before the second keystroke). Other input methods (e.g., paste) seem to\n // fire selectionchange normally.\n return getInstIfValueChanged(activeElementInst, nativeEvent);\n }\n}\n\n/**\n * SECTION: handle `click` event\n */\nfunction shouldUseClickEvent(elem) {\n // Use the `click` event to detect changes to checkbox and radio inputs.\n // This approach works across all browsers, whereas `change` does not fire\n // until `blur` in IE8.\n var nodeName = elem.nodeName;\n return nodeName && nodeName.toLowerCase() === 'input' && (elem.type === 'checkbox' || elem.type === 'radio');\n}\n\nfunction getTargetInstForClickEvent(topLevelType, targetInst, nativeEvent) {\n if (topLevelType === 'topClick') {\n return getInstIfValueChanged(targetInst, nativeEvent);\n }\n}\n\nfunction getTargetInstForInputOrChangeEvent(topLevelType, targetInst, nativeEvent) {\n if (topLevelType === 'topInput' || topLevelType === 'topChange') {\n return getInstIfValueChanged(targetInst, nativeEvent);\n }\n}\n\nfunction handleControlledInputBlur(inst, node) {\n // TODO: In IE, inst is occasionally null. Why?\n if (inst == null) {\n return;\n }\n\n // Fiber and ReactDOM keep wrapper state in separate places\n var state = inst._wrapperState || node._wrapperState;\n\n if (!state || !state.controlled || node.type !== 'number') {\n return;\n }\n\n // If controlled, assign the value attribute to the current value on blur\n var value = '' + node.value;\n if (node.getAttribute('value') !== value) {\n node.setAttribute('value', value);\n }\n}\n\n/**\n * This plugin creates an `onChange` event that normalizes change events\n * across form elements. This event fires at a time when it's possible to\n * change the element's value without seeing a flicker.\n *\n * Supported elements are:\n * - input (see `isTextInputElement`)\n * - textarea\n * - select\n */\nvar ChangeEventPlugin = {\n eventTypes: eventTypes,\n\n _allowSimulatedPassThrough: true,\n _isInputEventSupported: isInputEventSupported,\n\n extractEvents: function (topLevelType, targetInst, nativeEvent, nativeEventTarget) {\n var targetNode = targetInst ? ReactDOMComponentTree.getNodeFromInstance(targetInst) : window;\n\n var getTargetInstFunc, handleEventFunc;\n if (shouldUseChangeEvent(targetNode)) {\n if (doesChangeEventBubble) {\n getTargetInstFunc = getTargetInstForChangeEvent;\n } else {\n handleEventFunc = handleEventsForChangeEventIE8;\n }\n } else if (isTextInputElement(targetNode)) {\n if (isInputEventSupported) {\n getTargetInstFunc = getTargetInstForInputOrChangeEvent;\n } else {\n getTargetInstFunc = getTargetInstForInputEventPolyfill;\n handleEventFunc = handleEventsForInputEventPolyfill;\n }\n } else if (shouldUseClickEvent(targetNode)) {\n getTargetInstFunc = getTargetInstForClickEvent;\n }\n\n if (getTargetInstFunc) {\n var inst = getTargetInstFunc(topLevelType, targetInst, nativeEvent);\n if (inst) {\n var event = createAndAccumulateChangeEvent(inst, nativeEvent, nativeEventTarget);\n return event;\n }\n }\n\n if (handleEventFunc) {\n handleEventFunc(topLevelType, targetNode, targetInst);\n }\n\n // When blurring, set the value attribute for number inputs\n if (topLevelType === 'topBlur') {\n handleControlledInputBlur(targetInst, targetNode);\n }\n }\n};\n\nmodule.exports = ChangeEventPlugin;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar SyntheticEvent = require('./SyntheticEvent');\n\n/**\n * @interface Event\n * @see http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105\n * /#events-inputevents\n */\nvar InputEventInterface = {\n data: null\n};\n\n/**\n * @param {object} dispatchConfig Configuration used to dispatch this event.\n * @param {string} dispatchMarker Marker identifying the event target.\n * @param {object} nativeEvent Native browser event.\n * @extends {SyntheticUIEvent}\n */\nfunction SyntheticInputEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {\n return SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);\n}\n\nSyntheticEvent.augmentClass(SyntheticInputEvent, InputEventInterface);\n\nmodule.exports = SyntheticInputEvent;","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n'use strict';\n\nvar SyntheticEvent = require('./SyntheticEvent');\n\n/**\n * @interface Event\n * @see http://www.w3.org/TR/DOM-Level-3-Events/#events-compositionevents\n */\nvar CompositionEventInterface = {\n data: null\n};\n\n/**\n * @param {object} dispatchConfig Configuration used to dispatch this event.\n * @param {string} dispatchMarker Marker identifying the event target.\n * @param {object} nativeEvent Native browser event.\n * @extends {SyntheticUIEvent}\n */\nfunction SyntheticCompositionEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {\n return SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);\n}\n\nSyntheticEvent.augmentClass(SyntheticCompositionEvent, CompositionEventInterface);\n\nmodule.exports = SyntheticCompositionEvent;"],"sourceRoot":""}