DoYouEvenBench: Add Facebook's React TodoMVC test case
[WebKit-https.git] / PerformanceTests / DoYouEvenBench / todomvc / labs / architecture-examples / react / bower_components / react / react.js
1 /**
2  * React v0.4.0
3  */
4 (function(e){if("function"==typeof bootstrap)bootstrap("react",e);else if("object"==typeof exports)module.exports=e();else if("function"==typeof define&&define.amd)define(e);else if("undefined"!=typeof ses){if(!ses.ok())return;ses.makeReact=e}else"undefined"!=typeof window?window.React=e():global.React=e()})(function(){var define,ses,bootstrap,module,exports;
5 return (function(e,t,n){function i(n,s){if(!t[n]){if(!e[n]){var o=typeof require=="function"&&require;if(!s&&o)return o(n,!0);if(r)return r(n,!0);throw new Error("Cannot find module '"+n+"'")}var u=t[n]={exports:{}};e[n][0].call(u.exports,function(t){var r=e[n][1][t];return i(r?r:t)},u,u.exports)}return t[n].exports}var r=typeof require=="function"&&require;for(var s=0;s<n.length;s++)i(n[s]);return i})({1:[function(require,module,exports){
6 /**
7  * Copyright 2013 Facebook, Inc.
8  *
9  * Licensed under the Apache License, Version 2.0 (the "License");
10  * you may not use this file except in compliance with the License.
11  * You may obtain a copy of the License at
12  *
13  * http://www.apache.org/licenses/LICENSE-2.0
14  *
15  * Unless required by applicable law or agreed to in writing, software
16  * distributed under the License is distributed on an "AS IS" BASIS,
17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18  * See the License for the specific language governing permissions and
19  * limitations under the License.
20  *
21  * @providesModule $
22  * @typechecks
23  */
24
25 var ge = require("./ge");
26 var ex = require("./ex");
27
28 /**
29  * @param {string|DOMDocument|DOMElement|DOMTextNode} id
30  * @return {DOMDocument|DOMElement|DOMTextNode}
31  *
32  * Find a node by ID.
33  *
34  * If your application code depends on the existence of the element, use $,
35  * which will throw if the element doesn't exist.
36  *
37  * If you're not sure whether or not the element exists, use ge instead, and
38  * manually check for the element's existence in your application code.
39  */
40 function $(id) {
41   var element = ge(id);
42   if (!element) {
43     throw new Error(ex(
44       'Tried to get element with id of "%s" but it is not present on the page.',
45       id
46     ));
47   }
48   return element;
49 }
50
51 module.exports = $;
52
53 },{"./ex":66,"./ge":69}],2:[function(require,module,exports){
54 /**
55  * Copyright 2013 Facebook, Inc.
56  *
57  * Licensed under the Apache License, Version 2.0 (the "License");
58  * you may not use this file except in compliance with the License.
59  * You may obtain a copy of the License at
60  *
61  * http://www.apache.org/licenses/LICENSE-2.0
62  *
63  * Unless required by applicable law or agreed to in writing, software
64  * distributed under the License is distributed on an "AS IS" BASIS,
65  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
66  * See the License for the specific language governing permissions and
67  * limitations under the License.
68  *
69  * @providesModule CSSProperty
70  */
71
72 "use strict";
73
74 /**
75  * CSS properties which accept numbers but are not in units of "px".
76  */
77 var isUnitlessNumber = {
78   fillOpacity: true,
79   fontWeight: true,
80   opacity: true,
81   orphans: true,
82   zIndex: true,
83   zoom: true
84 };
85
86 /**
87  * Most style properties can be unset by doing .style[prop] = '' but IE8
88  * doesn't like doing that with shorthand properties so for the properties that
89  * IE8 breaks on, which are listed here, we instead unset each of the
90  * individual properties. See http://bugs.jquery.com/ticket/12385.
91  * The 4-value 'clock' properties like margin, padding, border-width seem to
92  * behave without any problems. Curiously, list-style works too without any
93  * special prodding.
94  */
95 var shorthandPropertyExpansions = {
96   background: {
97     backgroundImage: true,
98     backgroundPosition: true,
99     backgroundRepeat: true,
100     backgroundColor: true
101   },
102   border: {
103     borderWidth: true,
104     borderStyle: true,
105     borderColor: true
106   },
107   borderBottom: {
108     borderBottomWidth: true,
109     borderBottomStyle: true,
110     borderBottomColor: true
111   },
112   borderLeft: {
113     borderLeftWidth: true,
114     borderLeftStyle: true,
115     borderLeftColor: true
116   },
117   borderRight: {
118     borderRightWidth: true,
119     borderRightStyle: true,
120     borderRightColor: true
121   },
122   borderTop: {
123     borderTopWidth: true,
124     borderTopStyle: true,
125     borderTopColor: true
126   },
127   font: {
128     fontStyle: true,
129     fontVariant: true,
130     fontWeight: true,
131     fontSize: true,
132     lineHeight: true,
133     fontFamily: true
134   }
135 };
136
137 var CSSProperty = {
138   isUnitlessNumber: isUnitlessNumber,
139   shorthandPropertyExpansions: shorthandPropertyExpansions
140 };
141
142 module.exports = CSSProperty;
143
144 },{}],3:[function(require,module,exports){
145 /**
146  * Copyright 2013 Facebook, Inc.
147  *
148  * Licensed under the Apache License, Version 2.0 (the "License");
149  * you may not use this file except in compliance with the License.
150  * You may obtain a copy of the License at
151  *
152  * http://www.apache.org/licenses/LICENSE-2.0
153  *
154  * Unless required by applicable law or agreed to in writing, software
155  * distributed under the License is distributed on an "AS IS" BASIS,
156  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
157  * See the License for the specific language governing permissions and
158  * limitations under the License.
159  *
160  * @providesModule CSSPropertyOperations
161  * @typechecks static-only
162  */
163
164 "use strict";
165
166 var CSSProperty = require("./CSSProperty");
167
168 var dangerousStyleValue = require("./dangerousStyleValue");
169 var escapeTextForBrowser = require("./escapeTextForBrowser");
170 var hyphenate = require("./hyphenate");
171 var memoizeStringOnly = require("./memoizeStringOnly");
172
173 var processStyleName = memoizeStringOnly(function(styleName) {
174   return escapeTextForBrowser(hyphenate(styleName));
175 });
176
177 /**
178  * Operations for dealing with CSS properties.
179  */
180 var CSSPropertyOperations = {
181
182   /**
183    * Serializes a mapping of style properties for use as inline styles:
184    *
185    *   > createMarkupForStyles({width: '200px', height: 0})
186    *   "width:200px;height:0;"
187    *
188    * Undefined values are ignored so that declarative programming is easier.
189    *
190    * @param {object} styles
191    * @return {?string}
192    */
193   createMarkupForStyles: function(styles) {
194     var serialized = '';
195     for (var styleName in styles) {
196       if (!styles.hasOwnProperty(styleName)) {
197         continue;
198       }
199       var styleValue = styles[styleName];
200       if (styleValue != null) {
201         serialized += processStyleName(styleName) + ':';
202         serialized += dangerousStyleValue(styleName, styleValue) + ';';
203       }
204     }
205     return serialized || null;
206   },
207
208   /**
209    * Sets the value for multiple styles on a node.  If a value is specified as
210    * '' (empty string), the corresponding style property will be unset.
211    *
212    * @param {DOMElement} node
213    * @param {object} styles
214    */
215   setValueForStyles: function(node, styles) {
216     var style = node.style;
217     for (var styleName in styles) {
218       if (!styles.hasOwnProperty(styleName)) {
219         continue;
220       }
221       var styleValue = dangerousStyleValue(styleName, styles[styleName]);
222       if (styleValue) {
223         style[styleName] = styleValue;
224       } else {
225         var expansion = CSSProperty.shorthandPropertyExpansions[styleName];
226         if (expansion) {
227           // Shorthand property that IE8 won't like unsetting, so unset each
228           // component to placate it
229           for (var individualStyleName in expansion) {
230             style[individualStyleName] = '';
231           }
232         } else {
233           style[styleName] = '';
234         }
235       }
236     }
237   }
238
239 };
240
241 module.exports = CSSPropertyOperations;
242
243 },{"./CSSProperty":2,"./dangerousStyleValue":63,"./escapeTextForBrowser":65,"./hyphenate":73,"./memoizeStringOnly":80}],4:[function(require,module,exports){
244 /**
245  * Copyright 2013 Facebook, Inc.
246  *
247  * Licensed under the Apache License, Version 2.0 (the "License");
248  * you may not use this file except in compliance with the License.
249  * You may obtain a copy of the License at
250  *
251  * http://www.apache.org/licenses/LICENSE-2.0
252  *
253  * Unless required by applicable law or agreed to in writing, software
254  * distributed under the License is distributed on an "AS IS" BASIS,
255  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
256  * See the License for the specific language governing permissions and
257  * limitations under the License.
258  *
259  * @providesModule CallbackRegistry
260  * @typechecks static-only
261  */
262
263 "use strict";
264
265 var listenerBank = {};
266
267 /**
268  * Stores "listeners" by `registrationName`/`id`. There should be at most one
269  * "listener" per `registrationName`/`id` in the `listenerBank`.
270  *
271  * Access listeners via `listenerBank[registrationName][id]`.
272  *
273  * @class CallbackRegistry
274  * @internal
275  */
276 var CallbackRegistry = {
277
278   /**
279    * Stores `listener` at `listenerBank[registrationName][id]`. Is idempotent.
280    *
281    * @param {string} id ID of the DOM element.
282    * @param {string} registrationName Name of listener (e.g. `onClick`).
283    * @param {?function} listener The callback to store.
284    */
285   putListener: function(id, registrationName, listener) {
286     var bankForRegistrationName =
287       listenerBank[registrationName] || (listenerBank[registrationName] = {});
288     bankForRegistrationName[id] = listener;
289   },
290
291   /**
292    * @param {string} id ID of the DOM element.
293    * @param {string} registrationName Name of listener (e.g. `onClick`).
294    * @return {?function} The stored callback.
295    */
296   getListener: function(id, registrationName) {
297     var bankForRegistrationName = listenerBank[registrationName];
298     return bankForRegistrationName && bankForRegistrationName[id];
299   },
300
301   /**
302    * Deletes a listener from the registration bank.
303    *
304    * @param {string} id ID of the DOM element.
305    * @param {string} registrationName Name of listener (e.g. `onClick`).
306    */
307   deleteListener: function(id, registrationName) {
308     var bankForRegistrationName = listenerBank[registrationName];
309     if (bankForRegistrationName) {
310       delete bankForRegistrationName[id];
311     }
312   },
313
314   /**
315    * Deletes all listeners for the DOM element with the supplied ID.
316    *
317    * @param {string} id ID of the DOM element.
318    */
319   deleteAllListeners: function(id) {
320     for (var registrationName in listenerBank) {
321       delete listenerBank[registrationName][id];
322     }
323   },
324
325   /**
326    * This is needed for tests only. Do not use!
327    */
328   __purge: function() {
329     listenerBank = {};
330   }
331
332 };
333
334 module.exports = CallbackRegistry;
335
336 },{}],5:[function(require,module,exports){
337 (function(){/**
338  * Copyright 2013 Facebook, Inc.
339  *
340  * Licensed under the Apache License, Version 2.0 (the "License");
341  * you may not use this file except in compliance with the License.
342  * You may obtain a copy of the License at
343  *
344  * http://www.apache.org/licenses/LICENSE-2.0
345  *
346  * Unless required by applicable law or agreed to in writing, software
347  * distributed under the License is distributed on an "AS IS" BASIS,
348  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
349  * See the License for the specific language governing permissions and
350  * limitations under the License.
351  *
352  * @providesModule ChangeEventPlugin
353  */
354
355 "use strict";
356
357 var EventConstants = require("./EventConstants");
358 var EventPluginHub = require("./EventPluginHub");
359 var EventPropagators = require("./EventPropagators");
360 var ExecutionEnvironment = require("./ExecutionEnvironment");
361 var SyntheticEvent = require("./SyntheticEvent");
362
363 var isEventSupported = require("./isEventSupported");
364 var keyOf = require("./keyOf");
365
366 var topLevelTypes = EventConstants.topLevelTypes;
367
368 var eventTypes = {
369   change: {
370     phasedRegistrationNames: {
371       bubbled: keyOf({onChange: null}),
372       captured: keyOf({onChangeCapture: null})
373     }
374   }
375 };
376
377 /**
378  * For IE shims
379  */
380 var activeElement = null;
381 var activeElementID = null;
382 var activeElementValue = null;
383 var activeElementValueProp = null;
384
385
386 /**
387  * SECTION: handle `change` event
388  */
389 function shouldUseChangeEvent(elem) {
390   return (
391     elem.nodeName === 'SELECT' ||
392     (elem.nodeName === 'INPUT' && elem.type === 'file')
393   );
394 }
395
396 var doesChangeEventBubble = false;
397 if (ExecutionEnvironment.canUseDOM) {
398   // See `handleChange` comment below
399   doesChangeEventBubble = isEventSupported('change') && (
400     !('documentMode' in document) || document.documentMode > 8
401   );
402 }
403
404 function manualDispatchChangeEvent(nativeEvent) {
405   var event = SyntheticEvent.getPooled(
406     eventTypes.change,
407     activeElementID,
408     nativeEvent
409   );
410   EventPropagators.accumulateTwoPhaseDispatches(event);
411
412   // If change bubbled, we'd just bind to it like all the other events
413   // and have it go through ReactEventTopLevelCallback. Since it doesn't, we
414   // manually listen for the change event and so we have to enqueue and
415   // process the abstract event manually.
416   EventPluginHub.enqueueEvents(event);
417   EventPluginHub.processEventQueue();
418 }
419
420 function startWatchingForChangeEventIE8(target, targetID) {
421   activeElement = target;
422   activeElementID = targetID;
423   activeElement.attachEvent('onchange', manualDispatchChangeEvent);
424 }
425
426 function stopWatchingForChangeEventIE8() {
427   if (!activeElement) {
428     return;
429   }
430   activeElement.detachEvent('onchange', manualDispatchChangeEvent);
431   activeElement = null;
432   activeElementID = null;
433 }
434
435 function getTargetIDForChangeEvent(
436     topLevelType,
437     topLevelTarget,
438     topLevelTargetID) {
439   if (topLevelType === topLevelTypes.topChange) {
440     return topLevelTargetID;
441   }
442 }
443 function handleEventsForChangeEventIE8(
444     topLevelType,
445     topLevelTarget,
446     topLevelTargetID) {
447   if (topLevelType === topLevelTypes.topFocus) {
448     // stopWatching() should be a noop here but we call it just in case we
449     // missed a blur event somehow.
450     stopWatchingForChangeEventIE8();
451     startWatchingForChangeEventIE8(topLevelTarget, topLevelTargetID);
452   } else if (topLevelType === topLevelTypes.topBlur) {
453     stopWatchingForChangeEventIE8();
454   }
455 }
456
457
458 /**
459  * SECTION: handle `input` event
460  */
461 var isInputEventSupported = false;
462 if (ExecutionEnvironment.canUseDOM) {
463   // IE9 claims to support the input event but fails to trigger it when
464   // deleting text, so we ignore its input events
465   isInputEventSupported = isEventSupported('input') && (
466     !('documentMode' in document) || document.documentMode > 9
467   );
468 }
469
470
471 /**
472  * @see http://www.whatwg.org/specs/web-apps/current-work/multipage/the-input-element.html#input-type-attr-summary
473  */
474 var supportedInputTypes = {
475   'color': true,
476   'date': true,
477   'datetime': true,
478   'datetime-local': true,
479   'email': true,
480   'month': true,
481   'number': true,
482   'password': true,
483   'range': true,
484   'search': true,
485   'tel': true,
486   'text': true,
487   'time': true,
488   'url': true,
489   'week': true
490 };
491
492 function shouldUseInputEvent(elem) {
493   return (
494     (elem.nodeName === 'INPUT' && supportedInputTypes[elem.type]) ||
495     elem.nodeName === 'TEXTAREA'
496   );
497 }
498
499 /**
500  * (For old IE.) Replacement getter/setter for the `value` property that gets
501  * set on the active element.
502  */
503 var newValueProp =  {
504   get: function() {
505     return activeElementValueProp.get.call(this);
506   },
507   set: function(val) {
508     // Cast to a string so we can do equality checks.
509     activeElementValue = '' + val;
510     activeElementValueProp.set.call(this, val);
511   }
512 };
513
514 /**
515  * (For old IE.) Starts tracking propertychange events on the passed-in element
516  * and override the value property so that we can distinguish user events from
517  * value changes in JS.
518  */
519 function startWatchingForValueChange(target, targetID) {
520   activeElement = target;
521   activeElementID = targetID;
522   activeElementValue = target.value;
523   activeElementValueProp = Object.getOwnPropertyDescriptor(
524     target.constructor.prototype,
525     'value'
526   );
527
528   Object.defineProperty(activeElement, 'value', newValueProp);
529   activeElement.attachEvent('onpropertychange', handlePropertyChange);
530 }
531
532 /**
533  * (For old IE.) Removes the event listeners from the currently-tracked element,
534  * if any exists.
535  */
536 function stopWatchingForValueChange() {
537   if (!activeElement) {
538     return;
539   }
540
541   // delete restores the original property definition
542   delete activeElement.value;
543   activeElement.detachEvent('onpropertychange', handlePropertyChange);
544
545   activeElement = null;
546   activeElementID = null;
547   activeElementValue = null;
548   activeElementValueProp = null;
549 }
550
551 /**
552  * (For old IE.) Handles a propertychange event, sending a `change` event if
553  * the value of the active element has changed.
554  */
555 function handlePropertyChange(nativeEvent) {
556   if (nativeEvent.propertyName !== 'value') {
557     return;
558   }
559   var value = nativeEvent.srcElement.value;
560   if (value === activeElementValue) {
561     return;
562   }
563   activeElementValue = value;
564
565   manualDispatchChangeEvent(nativeEvent);
566 }
567
568 /**
569  * If a `change` event should be fired, returns the target's ID.
570  */
571 function getTargetIDForInputEvent(
572     topLevelType,
573     topLevelTarget,
574     topLevelTargetID) {
575   if (topLevelType === topLevelTypes.topInput) {
576     // In modern browsers (i.e., not IE8 or IE9), the input event is exactly
577     // what we want so fall through here and trigger an abstract event
578     return topLevelTargetID;
579   }
580 }
581
582 // For IE8 and IE9.
583 function handleEventsForInputEventIE(
584     topLevelType,
585     topLevelTarget,
586     topLevelTargetID) {
587   if (topLevelType === topLevelTypes.topFocus) {
588     // In IE8, we can capture almost all .value changes by adding a
589     // propertychange handler and looking for events with propertyName
590     // equal to 'value'
591     // In IE9, propertychange fires for most input events but is buggy and
592     // doesn't fire when text is deleted, but conveniently, selectionchange
593     // appears to fire in all of the remaining cases so we catch those and
594     // forward the event if the value has changed
595     // In either case, we don't want to call the event handler if the value
596     // is changed from JS so we redefine a setter for `.value` that updates
597     // our activeElementValue variable, allowing us to ignore those changes
598     //
599     // stopWatching() should be a noop here but we call it just in case we
600     // missed a blur event somehow.
601     stopWatchingForValueChange();
602     startWatchingForValueChange(topLevelTarget, topLevelTargetID);
603   } else if (topLevelType === topLevelTypes.topBlur) {
604     stopWatchingForValueChange();
605   }
606 }
607
608 // For IE8 and IE9.
609 function getTargetIDForInputEventIE(
610     topLevelType,
611     topLevelTarget,
612     topLevelTargetID) {
613   if (topLevelType === topLevelTypes.topSelectionChange ||
614       topLevelType === topLevelTypes.topKeyUp ||
615       topLevelType === topLevelTypes.topKeyDown) {
616     // On the selectionchange event, the target is just document which isn't
617     // helpful for us so just check activeElement instead.
618     //
619     // 99% of the time, keydown and keyup aren't necessary. IE8 fails to fire
620     // propertychange on the first input event after setting `value` from a
621     // script and fires only keydown, keypress, keyup. Catching keyup usually
622     // gets it and catching keydown lets us fire an event for the first
623     // keystroke if user does a key repeat (it'll be a little delayed: right
624     // before the second keystroke). Other input methods (e.g., paste) seem to
625     // fire selectionchange normally.
626     if (activeElement && activeElement.value !== activeElementValue) {
627       activeElementValue = activeElement.value;
628       return activeElementID;
629     }
630   }
631 }
632
633
634 /**
635  * SECTION: handle `click` event
636  */
637 function shouldUseClickEvent(elem) {
638   // Use the `click` event to detect changes to checkbox and radio inputs.
639   // This approach works across all browsers, whereas `change` does not fire
640   // until `blur` in IE8.
641   return (
642     elem.nodeName === 'INPUT' &&
643     (elem.type === 'checkbox' || elem.type === 'radio')
644   );
645 }
646
647 function getTargetIDForClickEvent(
648     topLevelType,
649     topLevelTarget,
650     topLevelTargetID) {
651   if (topLevelType === topLevelTypes.topClick) {
652     return topLevelTargetID;
653   }
654 }
655
656 /**
657  * This plugin creates an `onChange` event that normalizes change events
658  * across form elements. This event fires at a time when it's possible to
659  * change the element's value without seeing a flicker.
660  *
661  * Supported elements are:
662  * - input (see `supportedInputTypes`)
663  * - textarea
664  * - select
665  */
666 var ChangeEventPlugin = {
667
668   eventTypes: eventTypes,
669
670   /**
671    * @param {string} topLevelType Record from `EventConstants`.
672    * @param {DOMEventTarget} topLevelTarget The listening component root node.
673    * @param {string} topLevelTargetID ID of `topLevelTarget`.
674    * @param {object} nativeEvent Native browser event.
675    * @return {*} An accumulation of synthetic events.
676    * @see {EventPluginHub.extractEvents}
677    */
678   extractEvents: function(
679       topLevelType,
680       topLevelTarget,
681       topLevelTargetID,
682       nativeEvent) {
683
684     var getTargetIDFunc, handleEventFunc;
685     if (shouldUseChangeEvent(topLevelTarget)) {
686       if (doesChangeEventBubble) {
687         getTargetIDFunc = getTargetIDForChangeEvent;
688       } else {
689         handleEventFunc = handleEventsForChangeEventIE8;
690       }
691     } else if (shouldUseInputEvent(topLevelTarget)) {
692       if (isInputEventSupported) {
693         getTargetIDFunc = getTargetIDForInputEvent;
694       } else {
695         getTargetIDFunc = getTargetIDForInputEventIE;
696         handleEventFunc = handleEventsForInputEventIE;
697       }
698     } else if (shouldUseClickEvent(topLevelTarget)) {
699       getTargetIDFunc = getTargetIDForClickEvent;
700     }
701
702     if (getTargetIDFunc) {
703       var targetID = getTargetIDFunc(
704         topLevelType,
705         topLevelTarget,
706         topLevelTargetID
707       );
708       if (targetID) {
709         var event = SyntheticEvent.getPooled(
710           eventTypes.change,
711           targetID,
712           nativeEvent
713         );
714         EventPropagators.accumulateTwoPhaseDispatches(event);
715         return event;
716       }
717     }
718
719     if (handleEventFunc) {
720       handleEventFunc(
721         topLevelType,
722         topLevelTarget,
723         topLevelTargetID
724       );
725     }
726   }
727
728 };
729
730 module.exports = ChangeEventPlugin;
731
732 })()
733 },{"./EventConstants":13,"./EventPluginHub":15,"./EventPropagators":18,"./ExecutionEnvironment":19,"./SyntheticEvent":50,"./isEventSupported":76,"./keyOf":79}],6:[function(require,module,exports){
734 (function(){/**
735  * Copyright 2013 Facebook, Inc.
736  *
737  * Licensed under the Apache License, Version 2.0 (the "License");
738  * you may not use this file except in compliance with the License.
739  * You may obtain a copy of the License at
740  *
741  * http://www.apache.org/licenses/LICENSE-2.0
742  *
743  * Unless required by applicable law or agreed to in writing, software
744  * distributed under the License is distributed on an "AS IS" BASIS,
745  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
746  * See the License for the specific language governing permissions and
747  * limitations under the License.
748  *
749  * @providesModule DOMChildrenOperations
750  */
751
752 // Empty blocks improve readability so disable that warning
753 // jshint -W035
754
755 "use strict";
756
757 var Danger = require("./Danger");
758
759 var insertNodeAt = require("./insertNodeAt");
760 var keyOf = require("./keyOf");
761 var throwIf = require("./throwIf");
762
763 var NON_INCREASING_OPERATIONS;
764 if (true) {
765   NON_INCREASING_OPERATIONS =
766     'DOM child management operations must be provided in order ' +
767     'of increasing destination index. This is likely an issue with ' +
768     'the core framework.';
769 }
770
771 var MOVE_NODE_AT_ORIG_INDEX = keyOf({moveFrom: null});
772 var INSERT_MARKUP = keyOf({insertMarkup: null});
773 var REMOVE_AT = keyOf({removeAt: null});
774
775 /**
776  * In order to carry out movement of DOM nodes without knowing their IDs, we
777  * have to first store knowledge about nodes' original indices before beginning
778  * to carry out the sequence of operations. Once we begin the sequence, the DOM
779  * indices in future instructions are no longer valid.
780  *
781  * @param {Element} parent Parent DOM node.
782  * @param {Object} childOperations Description of child operations.
783  * @return {Array?} Sparse array containing elements by their current index in
784  * the DOM.
785  */
786 var _getNodesByOriginalIndex = function(parent, childOperations) {
787   var nodesByOriginalIndex; // Sparse array.
788   var childOperation;
789   var origIndex;
790   for (var i = 0; i < childOperations.length; i++) {
791     childOperation = childOperations[i];
792     if (MOVE_NODE_AT_ORIG_INDEX in childOperation) {
793       nodesByOriginalIndex = nodesByOriginalIndex || [];
794       origIndex = childOperation.moveFrom;
795       nodesByOriginalIndex[origIndex] = parent.childNodes[origIndex];
796     } else if (REMOVE_AT in childOperation) {
797       nodesByOriginalIndex = nodesByOriginalIndex || [];
798       origIndex = childOperation.removeAt;
799       nodesByOriginalIndex[origIndex] = parent.childNodes[origIndex];
800     }
801   }
802   return nodesByOriginalIndex;
803 };
804
805 /**
806  * Removes DOM elements from their parent, or moved.
807  * @param {Element} parent Parent DOM node.
808  * @param {Array} nodesByOriginalIndex Child nodes by their original index
809  * (potentially sparse.)
810  */
811 var _removeChildrenByOriginalIndex = function(parent, nodesByOriginalIndex) {
812   for (var j = 0; j < nodesByOriginalIndex.length; j++) {
813     var nodeToRemove = nodesByOriginalIndex[j];
814     if (nodeToRemove) {     // We used a sparse array.
815       parent.removeChild(nodesByOriginalIndex[j]);
816     }
817   }
818 };
819
820 /**
821  * Once all nodes that will be removed or moved - are removed from the parent
822  * node, we can begin the process of placing nodes into their final locations.
823  * We must perform all operations in the order of the final DOM index -
824  * otherwise, we couldn't count on the fact that an insertion at index X, will
825  * remain at index X. This will iterate through the child operations, adding
826  * content where needed, skip over removals (they've already been removed) and
827  * insert "moved" Elements that were previously removed. The "moved" elements
828  * are only temporarily removed from the parent, so that index calculations can
829  * be manageable and perform well in the cases that matter.
830  */
831 var _placeNodesAtDestination =
832   function(parent, childOperations, nodesByOriginalIndex) {
833     var origNode;
834     var finalIndex;
835     var lastFinalIndex = -1;
836     var childOperation;
837     for (var k = 0; k < childOperations.length; k++) {
838       childOperation = childOperations[k];
839       if (MOVE_NODE_AT_ORIG_INDEX in childOperation) {
840         origNode = nodesByOriginalIndex[childOperation.moveFrom];
841         finalIndex = childOperation.finalIndex;
842         insertNodeAt(parent, origNode, finalIndex);
843         if (true) {
844           throwIf(finalIndex <= lastFinalIndex, NON_INCREASING_OPERATIONS);
845           lastFinalIndex = finalIndex;
846         }
847       } else if (REMOVE_AT in childOperation) {
848       } else if (INSERT_MARKUP in childOperation) {
849         finalIndex = childOperation.finalIndex;
850         var markup = childOperation.insertMarkup;
851         Danger.dangerouslyInsertMarkupAt(parent, markup, finalIndex);
852         if (true) {
853           throwIf(finalIndex <= lastFinalIndex, NON_INCREASING_OPERATIONS);
854           lastFinalIndex = finalIndex;
855         }
856       }
857     }
858   };
859
860 var manageChildren = function(parent, childOperations) {
861   var nodesByOriginalIndex = _getNodesByOriginalIndex(parent, childOperations);
862   if (nodesByOriginalIndex) {
863     _removeChildrenByOriginalIndex(parent, nodesByOriginalIndex);
864   }
865   _placeNodesAtDestination(parent, childOperations, nodesByOriginalIndex);
866 };
867
868 /**
869  * Also reexport all of the dangerous functions. It helps to have all dangerous
870  * functions located in a single module `Danger`.
871  */
872 var DOMChildrenOperations = {
873   dangerouslyReplaceNodeWithMarkup: Danger.dangerouslyReplaceNodeWithMarkup,
874   manageChildren: manageChildren
875 };
876
877 module.exports = DOMChildrenOperations;
878
879 })()
880 },{"./Danger":9,"./insertNodeAt":74,"./keyOf":79,"./throwIf":86}],7:[function(require,module,exports){
881 /**
882  * Copyright 2013 Facebook, Inc.
883  *
884  * Licensed under the Apache License, Version 2.0 (the "License");
885  * you may not use this file except in compliance with the License.
886  * You may obtain a copy of the License at
887  *
888  * http://www.apache.org/licenses/LICENSE-2.0
889  *
890  * Unless required by applicable law or agreed to in writing, software
891  * distributed under the License is distributed on an "AS IS" BASIS,
892  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
893  * See the License for the specific language governing permissions and
894  * limitations under the License.
895  *
896  * @providesModule DOMProperty
897  * @typechecks static-only
898  */
899
900 /*jslint bitwise: true */
901
902 "use strict";
903
904 var invariant = require("./invariant");
905
906 var DOMPropertyInjection = {
907   /**
908    * Mapping from normalized, camelcased property names to a configuration that
909    * specifies how the associated DOM property should be accessed or rendered.
910    */
911   MUST_USE_ATTRIBUTE: 0x1,
912   MUST_USE_PROPERTY:  0x2,
913   HAS_BOOLEAN_VALUE:  0x4,
914   HAS_SIDE_EFFECTS:   0x8,
915
916   /**
917    * Inject some specialized knowledge about the DOM. This takes a config object
918    * with the following properties:
919    *
920    * isCustomAttribute: function that given an attribute name will return true
921    * if it can be inserted into the DOM verbatim. Useful for data-* or aria-*
922    * attributes where it's impossible to enumerate all of the possible
923    * attribute names,
924    *
925    * Properties: object mapping DOM property name to one of the
926    * DOMPropertyInjection constants or null. If your attribute isn't in here,
927    * it won't get written to the DOM.
928    *
929    * DOMAttributeNames: object mapping React attribute name to the DOM
930    * attribute name. Attribute names not specified use the **lowercase**
931    * normalized name.
932    *
933    * DOMPropertyNames: similar to DOMAttributeNames but for DOM properties.
934    * Property names not specified use the normalized name.
935    *
936    * DOMMutationMethods: Properties that require special mutation methods. If
937    * `value` is undefined, the mutation method should unset the property.
938    *
939    * @param {object} domPropertyConfig the config as described above.
940    */
941   injectDOMPropertyConfig: function(domPropertyConfig) {
942     var Properties = domPropertyConfig.Properties || {};
943     var DOMAttributeNames = domPropertyConfig.DOMAttributeNames || {};
944     var DOMPropertyNames = domPropertyConfig.DOMPropertyNames || {};
945     var DOMMutationMethods = domPropertyConfig.DOMMutationMethods || {};
946
947     if (domPropertyConfig.isCustomAttribute) {
948       DOMProperty._isCustomAttributeFunctions.push(
949         domPropertyConfig.isCustomAttribute
950       );
951     }
952
953     for (var propName in Properties) {
954       invariant(
955         !DOMProperty.isStandardName[propName],
956         'injectDOMPropertyConfig(...): You\'re trying to inject DOM property ' +
957         '\'%s\' which has already been injected. You may be accidentally ' +
958         'injecting the same DOM property config twice, or you may be ' +
959         'injecting two configs that have conflicting property names.',
960         propName
961       );
962
963       DOMProperty.isStandardName[propName] = true;
964
965       DOMProperty.getAttributeName[propName] =
966         DOMAttributeNames[propName] || propName.toLowerCase();
967
968       DOMProperty.getPropertyName[propName] =
969         DOMPropertyNames[propName] || propName;
970
971       var mutationMethod = DOMMutationMethods[propName];
972       if (mutationMethod) {
973         DOMProperty.getMutationMethod[propName] = mutationMethod;
974       }
975
976       var propConfig = Properties[propName];
977       DOMProperty.mustUseAttribute[propName] =
978         propConfig & DOMPropertyInjection.MUST_USE_ATTRIBUTE;
979       DOMProperty.mustUseProperty[propName] =
980         propConfig & DOMPropertyInjection.MUST_USE_PROPERTY;
981       DOMProperty.hasBooleanValue[propName] =
982         propConfig & DOMPropertyInjection.HAS_BOOLEAN_VALUE;
983       DOMProperty.hasSideEffects[propName] =
984         propConfig & DOMPropertyInjection.HAS_SIDE_EFFECTS;
985
986       invariant(
987         !DOMProperty.mustUseAttribute[propName] ||
988           !DOMProperty.mustUseProperty[propName],
989         'DOMProperty: Cannot use require using both attribute and property: %s',
990         propName
991       );
992       invariant(
993         DOMProperty.mustUseProperty[propName] ||
994           !DOMProperty.hasSideEffects[propName],
995         'DOMProperty: Properties that have side effects must use property: %s',
996         propName
997       );
998     }
999   }
1000 };
1001 var defaultValueCache = {};
1002
1003 /**
1004  * DOMProperty exports lookup objects that can be used like functions:
1005  *
1006  *   > DOMProperty.isValid['id']
1007  *   true
1008  *   > DOMProperty.isValid['foobar']
1009  *   undefined
1010  *
1011  * Although this may be confusing, it performs better in general.
1012  *
1013  * @see http://jsperf.com/key-exists
1014  * @see http://jsperf.com/key-missing
1015  */
1016 var DOMProperty = {
1017
1018   /**
1019    * Checks whether a property name is a standard property.
1020    * @type {Object}
1021    */
1022   isStandardName: {},
1023
1024   /**
1025    * Mapping from normalized names to attribute names that differ. Attribute
1026    * names are used when rendering markup or with `*Attribute()`.
1027    * @type {Object}
1028    */
1029   getAttributeName: {},
1030
1031   /**
1032    * Mapping from normalized names to properties on DOM node instances.
1033    * (This includes properties that mutate due to external factors.)
1034    * @type {Object}
1035    */
1036   getPropertyName: {},
1037
1038   /**
1039    * Mapping from normalized names to mutation methods. This will only exist if
1040    * mutation cannot be set simply by the property or `setAttribute()`.
1041    * @type {Object}
1042    */
1043   getMutationMethod: {},
1044
1045   /**
1046    * Whether the property must be accessed and mutated as an object property.
1047    * @type {Object}
1048    */
1049   mustUseAttribute: {},
1050
1051   /**
1052    * Whether the property must be accessed and mutated using `*Attribute()`.
1053    * (This includes anything that fails `<propName> in <element>`.)
1054    * @type {Object}
1055    */
1056   mustUseProperty: {},
1057
1058   /**
1059    * Whether the property should be removed when set to a falsey value.
1060    * @type {Object}
1061    */
1062   hasBooleanValue: {},
1063
1064   /**
1065    * Whether or not setting a value causes side effects such as triggering
1066    * resources to be loaded or text selection changes. We must ensure that
1067    * the value is only set if it has changed.
1068    * @type {Object}
1069    */
1070   hasSideEffects: {},
1071
1072   /**
1073    * All of the isCustomAttribute() functions that have been injected.
1074    */
1075   _isCustomAttributeFunctions: [],
1076
1077   /**
1078    * Checks whether a property name is a custom attribute.
1079    * @method
1080    */
1081   isCustomAttribute: function(attributeName) {
1082     return DOMProperty._isCustomAttributeFunctions.some(
1083       function(isCustomAttributeFn) {
1084         return isCustomAttributeFn.call(null, attributeName);
1085       }
1086     );
1087   },
1088
1089   /**
1090    * Returns the default property value for a DOM property (i.e., not an
1091    * attribute). Most default values are '' or false, but not all. Worse yet,
1092    * some (in particular, `type`) vary depending on the type of element.
1093    *
1094    * TODO: Is it better to grab all the possible properties when creating an
1095    * element to avoid having to create the same element twice?
1096    */
1097   getDefaultValueForProperty: function(nodeName, prop) {
1098     var nodeDefaults = defaultValueCache[nodeName];
1099     var testElement;
1100     if (!nodeDefaults) {
1101       defaultValueCache[nodeName] = nodeDefaults = {};
1102     }
1103     if (!(prop in nodeDefaults)) {
1104       testElement = document.createElement(nodeName);
1105       nodeDefaults[prop] = testElement[prop];
1106     }
1107     return nodeDefaults[prop];
1108   },
1109
1110   injection: DOMPropertyInjection
1111 };
1112
1113 module.exports = DOMProperty;
1114
1115 },{"./invariant":75}],8:[function(require,module,exports){
1116 /**
1117  * Copyright 2013 Facebook, Inc.
1118  *
1119  * Licensed under the Apache License, Version 2.0 (the "License");
1120  * you may not use this file except in compliance with the License.
1121  * You may obtain a copy of the License at
1122  *
1123  * http://www.apache.org/licenses/LICENSE-2.0
1124  *
1125  * Unless required by applicable law or agreed to in writing, software
1126  * distributed under the License is distributed on an "AS IS" BASIS,
1127  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1128  * See the License for the specific language governing permissions and
1129  * limitations under the License.
1130  *
1131  * @providesModule DOMPropertyOperations
1132  * @typechecks static-only
1133  */
1134
1135 "use strict";
1136
1137 var DOMProperty = require("./DOMProperty");
1138
1139 var escapeTextForBrowser = require("./escapeTextForBrowser");
1140 var memoizeStringOnly = require("./memoizeStringOnly");
1141
1142 var processAttributeNameAndPrefix = memoizeStringOnly(function(name) {
1143   return escapeTextForBrowser(name) + '="';
1144 });
1145
1146 /**
1147  * Operations for dealing with DOM properties.
1148  */
1149 var DOMPropertyOperations = {
1150
1151   /**
1152    * Creates markup for a property.
1153    *
1154    * @param {string} name
1155    * @param {*} value
1156    * @return {?string} Markup string, or null if the property was invalid.
1157    */
1158   createMarkupForProperty: function(name, value) {
1159     if (DOMProperty.isStandardName[name]) {
1160       if (value == null || DOMProperty.hasBooleanValue[name] && !value) {
1161         return '';
1162       }
1163       var attributeName = DOMProperty.getAttributeName[name];
1164       return processAttributeNameAndPrefix(attributeName) +
1165         escapeTextForBrowser(value) + '"';
1166     } else if (DOMProperty.isCustomAttribute(name)) {
1167       if (value == null) {
1168         return '';
1169       }
1170       return processAttributeNameAndPrefix(name) +
1171         escapeTextForBrowser(value) + '"';
1172     } else {
1173       return null;
1174     }
1175   },
1176
1177   /**
1178    * Sets the value for a property on a node.
1179    *
1180    * @param {DOMElement} node
1181    * @param {string} name
1182    * @param {*} value
1183    */
1184   setValueForProperty: function(node, name, value) {
1185     if (DOMProperty.isStandardName[name]) {
1186       var mutationMethod = DOMProperty.getMutationMethod[name];
1187       if (mutationMethod) {
1188         mutationMethod(node, value);
1189       } else if (DOMProperty.mustUseAttribute[name]) {
1190         if (DOMProperty.hasBooleanValue[name] && !value) {
1191           node.removeAttribute(DOMProperty.getAttributeName[name]);
1192         } else {
1193           node.setAttribute(DOMProperty.getAttributeName[name], value);
1194         }
1195       } else {
1196         var propName = DOMProperty.getPropertyName[name];
1197         if (!DOMProperty.hasSideEffects[name] || node[propName] !== value) {
1198           node[propName] = value;
1199         }
1200       }
1201     } else if (DOMProperty.isCustomAttribute(name)) {
1202       node.setAttribute(name, value);
1203     }
1204   },
1205
1206   /**
1207    * Deletes the value for a property on a node.
1208    *
1209    * @param {DOMElement} node
1210    * @param {string} name
1211    */
1212   deleteValueForProperty: function(node, name) {
1213     if (DOMProperty.isStandardName[name]) {
1214       var mutationMethod = DOMProperty.getMutationMethod[name];
1215       if (mutationMethod) {
1216         mutationMethod(node, undefined);
1217       } else if (DOMProperty.mustUseAttribute[name]) {
1218         node.removeAttribute(DOMProperty.getAttributeName[name]);
1219       } else {
1220         var propName = DOMProperty.getPropertyName[name];
1221         node[propName] = DOMProperty.getDefaultValueForProperty(
1222           node.nodeName,
1223           name
1224         );
1225       }
1226     } else if (DOMProperty.isCustomAttribute(name)) {
1227       node.removeAttribute(name);
1228     }
1229   }
1230
1231 };
1232
1233 module.exports = DOMPropertyOperations;
1234
1235 },{"./DOMProperty":7,"./escapeTextForBrowser":65,"./memoizeStringOnly":80}],9:[function(require,module,exports){
1236 /**
1237  * Copyright 2013 Facebook, Inc.
1238  *
1239  * Licensed under the Apache License, Version 2.0 (the "License");
1240  * you may not use this file except in compliance with the License.
1241  * You may obtain a copy of the License at
1242  *
1243  * http://www.apache.org/licenses/LICENSE-2.0
1244  *
1245  * Unless required by applicable law or agreed to in writing, software
1246  * distributed under the License is distributed on an "AS IS" BASIS,
1247  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1248  * See the License for the specific language governing permissions and
1249  * limitations under the License.
1250  *
1251  * @providesModule Danger
1252  */
1253
1254 /*jslint evil: true, sub: true */
1255
1256 "use strict";
1257
1258 var ExecutionEnvironment = require("./ExecutionEnvironment");
1259
1260 var throwIf = require("./throwIf");
1261
1262 var DOM_UNSUPPORTED;
1263 var NO_MARKUP_PARENT;
1264 var NO_MULTI_MARKUP;
1265 if (true) {
1266   DOM_UNSUPPORTED =
1267     'You may not insert markup into the document while you are in a worker ' +
1268     'thread. It\'s not you, it\'s me. This is likely the fault of the ' +
1269     'framework. Please report this immediately.';
1270   NO_MARKUP_PARENT =
1271     'You have attempted to inject markup without a suitable parent. This is ' +
1272     'likely the fault of the framework - please report immediately.';
1273   NO_MULTI_MARKUP =
1274     'The framework has attempted to either insert zero or multiple markup ' +
1275     'roots into a single location when it should not. This is a serious ' +
1276     'error - a fault of the framework - please report immediately.';
1277 }
1278
1279 var validateMarkupParams;
1280 if (true) {
1281   validateMarkupParams = function(parentNode, markup) {
1282     throwIf(!ExecutionEnvironment.canUseDOM, DOM_UNSUPPORTED);
1283     throwIf(!parentNode || !parentNode.tagName, NO_MARKUP_PARENT);
1284     throwIf(!markup, NO_MULTI_MARKUP);
1285   };
1286 }
1287
1288 /**
1289  * Dummy container used to render all markup.
1290  */
1291 var dummyNode = ExecutionEnvironment.canUseDOM ?
1292   document.createElement('div') :
1293   null;
1294
1295 /**
1296  * Some browsers cannot use `innerHTML` to render certain elements standalone,
1297  * so we wrap them, render the wrapped nodes, then extract the desired node.
1298  */
1299 var markupWrap = {
1300   'option': [1, '<select multiple="true">', '</select>'],
1301   'legend': [1, '<fieldset>', '</fieldset>'],
1302   'area': [1, '<map>', '</map>'],
1303   'param': [1, '<object>', '</object>'],
1304   'thead': [1, '<table>', '</table>'],
1305   'tr': [2, '<table><tbody>', '</tbody></table>'],
1306   'col': [2, '<table><tbody></tbody><colgroup>', '</colgroup></table>'],
1307   'td': [3, '<table><tbody><tr>', '</tr></tbody></table>']
1308 };
1309 markupWrap['optgroup'] = markupWrap['option'];
1310 markupWrap['tbody'] = markupWrap['thead'];
1311 markupWrap['tfoot'] = markupWrap['thead'];
1312 markupWrap['colgroup'] = markupWrap['thead'];
1313 markupWrap['caption'] = markupWrap['thead'];
1314 markupWrap['th'] = markupWrap['td'];
1315
1316 /**
1317  * In IE8, certain elements cannot render alone, so wrap all elements.
1318  */
1319 var defaultWrap = [1, '?<div>', '</div>'];
1320
1321 /**
1322  * Feature detection, remove wraps that are unnecessary for the current browser.
1323  */
1324 if (dummyNode) {
1325   for (var nodeName in markupWrap) {
1326     if (!markupWrap.hasOwnProperty(nodeName)) {
1327       continue;
1328     }
1329     dummyNode.innerHTML = '<' + nodeName + '></' + nodeName + '>';
1330     if (dummyNode.firstChild) {
1331       markupWrap[nodeName] = null;
1332     }
1333   }
1334   dummyNode.innerHTML = '<link />';
1335   if (dummyNode.firstChild) {
1336     defaultWrap = null;
1337   }
1338 }
1339
1340 /**
1341  * Renders markup into nodes. The returned HTMLCollection is live and should be
1342  * used immediately (or at least before the next invocation to `renderMarkup`).
1343  *
1344  * NOTE: Extracting the `nodeName` does not require a regular expression match
1345  * because we make assumptions about React-generated markup (i.e. there are no
1346  * spaces surrounding the opening tag and there is at least one attribute).
1347  * @see http://jsperf.com/extract-nodename
1348  *
1349  * @param {string} markup
1350  * @return {*} An HTMLCollection.
1351  */
1352 function renderMarkup(markup) {
1353   var node = dummyNode;
1354   var nodeName = markup.substring(1, markup.indexOf(' '));
1355
1356   var wrap = markupWrap[nodeName.toLowerCase()] || defaultWrap;
1357   if (wrap) {
1358     node.innerHTML = wrap[1] + markup + wrap[2];
1359
1360     var wrapDepth = wrap[0];
1361     while (wrapDepth--) {
1362       node = node.lastChild;
1363     }
1364   } else {
1365     node.innerHTML = markup;
1366   }
1367   return node.childNodes;
1368 }
1369
1370 /**
1371  * Inserts node after 'after'. If 'after' is null, inserts it after nothing,
1372  * which is inserting it at the beginning.
1373  *
1374  * @param {Element} elem Parent element.
1375  * @param {Element} insert Element to insert.
1376  * @param {Element} after Element to insert after.
1377  * @return {Element} Element that was inserted.
1378  */
1379 function insertNodeAfterNode(elem, insert, after) {
1380   if (true) {
1381     throwIf(!ExecutionEnvironment.canUseDOM, DOM_UNSUPPORTED);
1382   }
1383   if (after) {
1384     if (after.nextSibling) {
1385       return elem.insertBefore(insert, after.nextSibling);
1386     } else {
1387       return elem.appendChild(insert);
1388     }
1389   } else {
1390     return elem.insertBefore(insert, elem.firstChild);
1391   }
1392 }
1393
1394 /**
1395  * Slow: Should only be used when it is known there are a few (or one) element
1396  * in the node list.
1397  * @param {Element} parentRootDomNode Parent element.
1398  * @param {HTMLCollection} htmlCollection HTMLCollection to insert.
1399  * @param {Element} after Element to insert the node list after.
1400  */
1401 function inefficientlyInsertHTMLCollectionAfter(
1402     parentRootDomNode,
1403     htmlCollection,
1404     after) {
1405
1406   if (true) {
1407     throwIf(!ExecutionEnvironment.canUseDOM, DOM_UNSUPPORTED);
1408   }
1409   var ret;
1410   var originalLength = htmlCollection.length;
1411   // Access htmlCollection[0] because htmlCollection shrinks as we remove items.
1412   // `insertNodeAfterNode` will remove items from the htmlCollection.
1413   for (var i = 0; i < originalLength; i++) {
1414     ret =
1415       insertNodeAfterNode(parentRootDomNode, htmlCollection[0], ret || after);
1416   }
1417 }
1418
1419 /**
1420  * Super-dangerously inserts markup into existing DOM structure. Seriously, you
1421  * don't want to use this module unless you are building a framework. This
1422  * requires that the markup that you are inserting represents the root of a
1423  * tree. We do not support the case where there `markup` represents several
1424  * roots.
1425  *
1426  * @param {Element} parentNode Parent DOM element.
1427  * @param {string} markup Markup to dangerously insert.
1428  * @param {number} index Position to insert markup at.
1429  */
1430 function dangerouslyInsertMarkupAt(parentNode, markup, index) {
1431   if (true) {
1432     validateMarkupParams(parentNode, markup);
1433   }
1434   var htmlCollection = renderMarkup(markup);
1435   var afterNode = index ? parentNode.childNodes[index - 1] : null;
1436   inefficientlyInsertHTMLCollectionAfter(parentNode, htmlCollection, afterNode);
1437 }
1438
1439 /**
1440  * Replaces a node with a string of markup at its current position within its
1441  * parent. `childNode` must be in the document (or at least within a parent
1442  * node). The string of markup must represent a tree of markup with a single
1443  * root.
1444  *
1445  * @param {Element} childNode Child node to replace.
1446  * @param {string} markup Markup to dangerously replace child with.
1447  */
1448 function dangerouslyReplaceNodeWithMarkup(childNode, markup) {
1449   var parentNode = childNode.parentNode;
1450   if (true) {
1451     validateMarkupParams(parentNode, markup);
1452   }
1453   var htmlCollection = renderMarkup(markup);
1454   if (true) {
1455     throwIf(htmlCollection.length !== 1, NO_MULTI_MARKUP);
1456   }
1457   parentNode.replaceChild(htmlCollection[0], childNode);
1458 }
1459
1460 var Danger = {
1461   dangerouslyInsertMarkupAt: dangerouslyInsertMarkupAt,
1462   dangerouslyReplaceNodeWithMarkup: dangerouslyReplaceNodeWithMarkup
1463 };
1464
1465 module.exports = Danger;
1466
1467 },{"./ExecutionEnvironment":19,"./throwIf":86}],10:[function(require,module,exports){
1468 /**
1469  * Copyright 2013 Facebook, Inc.
1470  *
1471  * Licensed under the Apache License, Version 2.0 (the "License");
1472  * you may not use this file except in compliance with the License.
1473  * You may obtain a copy of the License at
1474  *
1475  * http://www.apache.org/licenses/LICENSE-2.0
1476  *
1477  * Unless required by applicable law or agreed to in writing, software
1478  * distributed under the License is distributed on an "AS IS" BASIS,
1479  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1480  * See the License for the specific language governing permissions and
1481  * limitations under the License.
1482  *
1483  * @providesModule DefaultDOMPropertyConfig
1484  */
1485
1486 "use strict";
1487
1488 var DOMProperty = require("./DOMProperty");
1489
1490 var MUST_USE_ATTRIBUTE = DOMProperty.injection.MUST_USE_ATTRIBUTE;
1491 var MUST_USE_PROPERTY = DOMProperty.injection.MUST_USE_PROPERTY;
1492 var HAS_BOOLEAN_VALUE = DOMProperty.injection.HAS_BOOLEAN_VALUE;
1493 var HAS_SIDE_EFFECTS = DOMProperty.injection.HAS_SIDE_EFFECTS;
1494
1495 var DefaultDOMPropertyConfig = {
1496   isCustomAttribute: RegExp.prototype.test.bind(
1497     /^(data|aria)-[a-z_][a-z\d_.\-]*$/
1498   ),
1499   Properties: {
1500     /**
1501      * Standard Properties
1502      */
1503     accessKey: null,
1504     accept: null,
1505     action: null,
1506     ajaxify: MUST_USE_ATTRIBUTE,
1507     allowFullScreen: MUST_USE_ATTRIBUTE | HAS_BOOLEAN_VALUE,
1508     alt: null,
1509     autoComplete: null,
1510     autoFocus: HAS_BOOLEAN_VALUE,
1511     autoPlay: HAS_BOOLEAN_VALUE,
1512     cellPadding: null,
1513     cellSpacing: null,
1514     checked: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,
1515     className: MUST_USE_PROPERTY,
1516     colSpan: null,
1517     contentEditable: null,
1518     contextMenu: MUST_USE_ATTRIBUTE,
1519     controls: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,
1520     data: null, // For `<object />` acts as `src`.
1521     dateTime: MUST_USE_ATTRIBUTE,
1522     dir: null,
1523     disabled: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,
1524     draggable: null,
1525     encType: null,
1526     height: MUST_USE_ATTRIBUTE,
1527     hidden: MUST_USE_ATTRIBUTE | HAS_BOOLEAN_VALUE,
1528     href: null,
1529     htmlFor: null,
1530     icon: null,
1531     id: MUST_USE_PROPERTY,
1532     label: null,
1533     lang: null,
1534     list: null,
1535     max: null,
1536     maxLength: MUST_USE_ATTRIBUTE,
1537     method: null,
1538     min: null,
1539     multiple: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,
1540     name: null,
1541     pattern: null,
1542     poster: null,
1543     preload: null,
1544     placeholder: null,
1545     radioGroup: null,
1546     rel: null,
1547     readOnly: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,
1548     required: HAS_BOOLEAN_VALUE,
1549     role: MUST_USE_ATTRIBUTE,
1550     scrollLeft: MUST_USE_PROPERTY,
1551     scrollTop: MUST_USE_PROPERTY,
1552     selected: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,
1553     size: null,
1554     spellCheck: null,
1555     src: null,
1556     step: null,
1557     style: null,
1558     tabIndex: null,
1559     target: null,
1560     title: null,
1561     type: null,
1562     value: MUST_USE_PROPERTY | HAS_SIDE_EFFECTS,
1563     width: MUST_USE_ATTRIBUTE,
1564     wmode: MUST_USE_ATTRIBUTE,
1565     /**
1566      * SVG Properties
1567      */
1568     cx: MUST_USE_PROPERTY,
1569     cy: MUST_USE_PROPERTY,
1570     d: MUST_USE_PROPERTY,
1571     fill: MUST_USE_PROPERTY,
1572     fx: MUST_USE_PROPERTY,
1573     fy: MUST_USE_PROPERTY,
1574     points: MUST_USE_PROPERTY,
1575     r: MUST_USE_PROPERTY,
1576     stroke: MUST_USE_PROPERTY,
1577     strokeLinecap: MUST_USE_PROPERTY,
1578     strokeWidth: MUST_USE_PROPERTY,
1579     transform: MUST_USE_PROPERTY,
1580     x: MUST_USE_PROPERTY,
1581     x1: MUST_USE_PROPERTY,
1582     x2: MUST_USE_PROPERTY,
1583     version: MUST_USE_PROPERTY,
1584     viewBox: MUST_USE_PROPERTY,
1585     y: MUST_USE_PROPERTY,
1586     y1: MUST_USE_PROPERTY,
1587     y2: MUST_USE_PROPERTY,
1588     spreadMethod: MUST_USE_PROPERTY,
1589     offset: MUST_USE_PROPERTY,
1590     stopColor: MUST_USE_PROPERTY,
1591     stopOpacity: MUST_USE_PROPERTY,
1592     gradientUnits: MUST_USE_PROPERTY,
1593     gradientTransform: MUST_USE_PROPERTY
1594   },
1595   DOMAttributeNames: {
1596     className: 'class',
1597     htmlFor: 'for',
1598     strokeLinecap: 'stroke-linecap',
1599     strokeWidth: 'stroke-width',
1600     stopColor: 'stop-color',
1601     stopOpacity: 'stop-opacity'
1602   },
1603   DOMPropertyNames: {
1604     autoComplete: 'autocomplete',
1605     autoFocus: 'autofocus',
1606     autoPlay: 'autoplay',
1607     encType: 'enctype',
1608     radioGroup: 'radiogroup',
1609     spellCheck: 'spellcheck'
1610   },
1611   DOMMutationMethods: {
1612     /**
1613      * Setting `className` to null may cause it to be set to the string "null".
1614      *
1615      * @param {DOMElement} node
1616      * @param {*} value
1617      */
1618     className: function(node, value) {
1619       node.className = value || '';
1620     }
1621   }
1622 };
1623
1624 module.exports = DefaultDOMPropertyConfig;
1625
1626 },{"./DOMProperty":7}],11:[function(require,module,exports){
1627 /**
1628  * Copyright 2013 Facebook, Inc.
1629  *
1630  * Licensed under the Apache License, Version 2.0 (the "License");
1631  * you may not use this file except in compliance with the License.
1632  * You may obtain a copy of the License at
1633  *
1634  * http://www.apache.org/licenses/LICENSE-2.0
1635  *
1636  * Unless required by applicable law or agreed to in writing, software
1637  * distributed under the License is distributed on an "AS IS" BASIS,
1638  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1639  * See the License for the specific language governing permissions and
1640  * limitations under the License.
1641  *
1642  * @providesModule DefaultEventPluginOrder
1643  */
1644
1645 "use strict";
1646
1647  var keyOf = require("./keyOf");
1648
1649 /**
1650  * Module that is injectable into `EventPluginHub`, that specifies a
1651  * deterministic ordering of `EventPlugin`s. A convenient way to reason about
1652  * plugins, without having to package every one of them. This is better than
1653  * having plugins be ordered in the same order that they are injected because
1654  * that ordering would be influenced by the packaging order.
1655  * `ResponderEventPlugin` must occur before `SimpleEventPlugin` so that
1656  * preventing default on events is convenient in `SimpleEventPlugin` handlers.
1657  */
1658 var DefaultEventPluginOrder = [
1659   keyOf({ResponderEventPlugin: null}),
1660   keyOf({SimpleEventPlugin: null}),
1661   keyOf({TapEventPlugin: null}),
1662   keyOf({EnterLeaveEventPlugin: null}),
1663   keyOf({ChangeEventPlugin: null}),
1664   keyOf({AnalyticsEventPlugin: null})
1665 ];
1666
1667 module.exports = DefaultEventPluginOrder;
1668
1669 },{"./keyOf":79}],12:[function(require,module,exports){
1670 (function(){/**
1671  * Copyright 2013 Facebook, Inc.
1672  *
1673  * Licensed under the Apache License, Version 2.0 (the "License");
1674  * you may not use this file except in compliance with the License.
1675  * You may obtain a copy of the License at
1676  *
1677  * http://www.apache.org/licenses/LICENSE-2.0
1678  *
1679  * Unless required by applicable law or agreed to in writing, software
1680  * distributed under the License is distributed on an "AS IS" BASIS,
1681  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1682  * See the License for the specific language governing permissions and
1683  * limitations under the License.
1684  *
1685  * @providesModule EnterLeaveEventPlugin
1686  * @typechecks static-only
1687  */
1688
1689 "use strict";
1690
1691 var EventConstants = require("./EventConstants");
1692 var EventPropagators = require("./EventPropagators");
1693 var ExecutionEnvironment = require("./ExecutionEnvironment");
1694 var ReactInstanceHandles = require("./ReactInstanceHandles");
1695 var SyntheticMouseEvent = require("./SyntheticMouseEvent");
1696
1697 var ReactID = require("./ReactID");
1698 var keyOf = require("./keyOf");
1699
1700 var topLevelTypes = EventConstants.topLevelTypes;
1701 var getFirstReactDOM = ReactInstanceHandles.getFirstReactDOM;
1702
1703 var eventTypes = {
1704   mouseEnter: {registrationName: keyOf({onMouseEnter: null})},
1705   mouseLeave: {registrationName: keyOf({onMouseLeave: null})}
1706 };
1707
1708 var EnterLeaveEventPlugin = {
1709
1710   eventTypes: eventTypes,
1711
1712   /**
1713    * For almost every interaction we care about, there will be both a top-level
1714    * `mouseover` and `mouseout` event that occurs. Only use `mouseout` so that
1715    * we do not extract duplicate events. However, moving the mouse into the
1716    * browser from outside will not fire a `mouseout` event. In this case, we use
1717    * the `mouseover` top-level event.
1718    *
1719    * @param {string} topLevelType Record from `EventConstants`.
1720    * @param {DOMEventTarget} topLevelTarget The listening component root node.
1721    * @param {string} topLevelTargetID ID of `topLevelTarget`.
1722    * @param {object} nativeEvent Native browser event.
1723    * @return {*} An accumulation of synthetic events.
1724    * @see {EventPluginHub.extractEvents}
1725    */
1726   extractEvents: function(
1727       topLevelType,
1728       topLevelTarget,
1729       topLevelTargetID,
1730       nativeEvent) {
1731     if (topLevelType === topLevelTypes.topMouseOver &&
1732         (nativeEvent.relatedTarget || nativeEvent.fromElement)) {
1733       return null;
1734     }
1735     if (topLevelType !== topLevelTypes.topMouseOut &&
1736         topLevelType !== topLevelTypes.topMouseOver) {
1737       // Must not be a mouse in or mouse out - ignoring.
1738       return null;
1739     }
1740
1741     var from, to;
1742     if (topLevelType === topLevelTypes.topMouseOut) {
1743       from = topLevelTarget;
1744       to =
1745         getFirstReactDOM(nativeEvent.relatedTarget || nativeEvent.toElement) ||
1746         ExecutionEnvironment.global;
1747     } else {
1748       from = ExecutionEnvironment.global;
1749       to = topLevelTarget;
1750     }
1751
1752     if (from === to) {
1753       // Nothing pertains to our managed components.
1754       return null;
1755     }
1756
1757     var fromID = from ? ReactID.getID(from) : '';
1758     var toID = to ? ReactID.getID(to) : '';
1759
1760     var leave = SyntheticMouseEvent.getPooled(
1761       eventTypes.mouseLeave,
1762       fromID,
1763       nativeEvent
1764     );
1765     var enter = SyntheticMouseEvent.getPooled(
1766       eventTypes.mouseEnter,
1767       toID,
1768       nativeEvent
1769     );
1770
1771     EventPropagators.accumulateEnterLeaveDispatches(leave, enter, fromID, toID);
1772     return [leave, enter];
1773   }
1774
1775 };
1776
1777 module.exports = EnterLeaveEventPlugin;
1778
1779 })()
1780 },{"./EventConstants":13,"./EventPropagators":18,"./ExecutionEnvironment":19,"./ReactID":35,"./ReactInstanceHandles":37,"./SyntheticMouseEvent":53,"./keyOf":79}],13:[function(require,module,exports){
1781 /**
1782  * Copyright 2013 Facebook, Inc.
1783  *
1784  * Licensed under the Apache License, Version 2.0 (the "License");
1785  * you may not use this file except in compliance with the License.
1786  * You may obtain a copy of the License at
1787  *
1788  * http://www.apache.org/licenses/LICENSE-2.0
1789  *
1790  * Unless required by applicable law or agreed to in writing, software
1791  * distributed under the License is distributed on an "AS IS" BASIS,
1792  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1793  * See the License for the specific language governing permissions and
1794  * limitations under the License.
1795  *
1796  * @providesModule EventConstants
1797  */
1798
1799 "use strict";
1800
1801 var keyMirror = require("./keyMirror");
1802
1803 var PropagationPhases = keyMirror({bubbled: null, captured: null});
1804
1805 /**
1806  * Types of raw signals from the browser caught at the top level.
1807  */
1808 var topLevelTypes = keyMirror({
1809   topBlur: null,
1810   topChange: null,
1811   topClick: null,
1812   topDOMCharacterDataModified: null,
1813   topDoubleClick: null,
1814   topDrag: null,
1815   topDragEnd: null,
1816   topDragEnter: null,
1817   topDragExit: null,
1818   topDragLeave: null,
1819   topDragOver: null,
1820   topDragStart: null,
1821   topDrop: null,
1822   topFocus: null,
1823   topInput: null,
1824   topKeyDown: null,
1825   topKeyPress: null,
1826   topKeyUp: null,
1827   topMouseDown: null,
1828   topMouseMove: null,
1829   topMouseOut: null,
1830   topMouseOver: null,
1831   topMouseUp: null,
1832   topScroll: null,
1833   topSelectionChange: null,
1834   topSubmit: null,
1835   topTouchCancel: null,
1836   topTouchEnd: null,
1837   topTouchMove: null,
1838   topTouchStart: null,
1839   topWheel: null
1840 });
1841
1842 var EventConstants = {
1843   topLevelTypes: topLevelTypes,
1844   PropagationPhases: PropagationPhases
1845 };
1846
1847 module.exports = EventConstants;
1848
1849 },{"./keyMirror":78}],14:[function(require,module,exports){
1850 /**
1851  * Copyright 2013 Facebook, Inc.
1852  *
1853  * Licensed under the Apache License, Version 2.0 (the "License");
1854  * you may not use this file except in compliance with the License.
1855  * You may obtain a copy of the License at
1856  *
1857  * http://www.apache.org/licenses/LICENSE-2.0
1858  *
1859  * Unless required by applicable law or agreed to in writing, software
1860  * distributed under the License is distributed on an "AS IS" BASIS,
1861  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1862  * See the License for the specific language governing permissions and
1863  * limitations under the License.
1864  *
1865  * @providesModule EventListener
1866  */
1867
1868 /**
1869  * Upstream version of event listener. Does not take into account specific
1870  * nature of platform.
1871  */
1872 var EventListener = {
1873   /**
1874    * Listens to bubbled events on a DOM node.
1875    *
1876    * @param {Element} el DOM element to register listener on.
1877    * @param {string} handlerBaseName 'click'/'mouseover'
1878    * @param {Function!} cb Callback function
1879    */
1880   listen: function(el, handlerBaseName, cb) {
1881     if (el.addEventListener) {
1882       el.addEventListener(handlerBaseName, cb, false);
1883     } else if (el.attachEvent) {
1884       el.attachEvent('on' + handlerBaseName, cb);
1885     }
1886   },
1887
1888   /**
1889    * Listens to captured events on a DOM node.
1890    *
1891    * @see `EventListener.listen` for params.
1892    * @throws Exception if addEventListener is not supported.
1893    */
1894   capture: function(el, handlerBaseName, cb) {
1895     if (!el.addEventListener) {
1896       if (true) {
1897         console.error(
1898           'You are attempting to use addEventlistener ' +
1899           'in a browser that does not support it support it.' +
1900           'This likely means that you will not receive events that ' +
1901           'your application relies on (such as scroll).');
1902       }
1903       return;
1904     } else {
1905       el.addEventListener(handlerBaseName, cb, true);
1906     }
1907   }
1908 };
1909
1910 module.exports = EventListener;
1911
1912 },{}],15:[function(require,module,exports){
1913 /**
1914  * Copyright 2013 Facebook, Inc.
1915  *
1916  * Licensed under the Apache License, Version 2.0 (the "License");
1917  * you may not use this file except in compliance with the License.
1918  * You may obtain a copy of the License at
1919  *
1920  * http://www.apache.org/licenses/LICENSE-2.0
1921  *
1922  * Unless required by applicable law or agreed to in writing, software
1923  * distributed under the License is distributed on an "AS IS" BASIS,
1924  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1925  * See the License for the specific language governing permissions and
1926  * limitations under the License.
1927  *
1928  * @providesModule EventPluginHub
1929  */
1930
1931 "use strict";
1932
1933 var CallbackRegistry = require("./CallbackRegistry");
1934 var EventPluginRegistry = require("./EventPluginRegistry");
1935 var EventPluginUtils = require("./EventPluginUtils");
1936 var EventPropagators = require("./EventPropagators");
1937 var ExecutionEnvironment = require("./ExecutionEnvironment");
1938
1939 var accumulate = require("./accumulate");
1940 var forEachAccumulated = require("./forEachAccumulated");
1941 var invariant = require("./invariant");
1942
1943 /**
1944  * Internal queue of events that have accumulated their dispatches and are
1945  * waiting to have their dispatches executed.
1946  */
1947 var eventQueue = null;
1948
1949 /**
1950  * Dispatches an event and releases it back into the pool, unless persistent.
1951  *
1952  * @param {?object} event Synthetic event to be dispatched.
1953  * @private
1954  */
1955 var executeDispatchesAndRelease = function(event) {
1956   if (event) {
1957     var executeDispatch = EventPluginUtils.executeDispatch;
1958     // Plugins can provide custom behavior when dispatching events.
1959     var PluginModule = EventPluginRegistry.getPluginModuleForEvent(event);
1960     if (PluginModule && PluginModule.executeDispatch) {
1961       executeDispatch = PluginModule.executeDispatch;
1962     }
1963     EventPluginUtils.executeDispatchesInOrder(event, executeDispatch);
1964
1965     if (!event.isPersistent()) {
1966       event.constructor.release(event);
1967     }
1968   }
1969 };
1970
1971 /**
1972  * This is a unified interface for event plugins to be installed and configured.
1973  *
1974  * Event plugins can implement the following properties:
1975  *
1976  *   `extractEvents` {function(string, DOMEventTarget, string, object): *}
1977  *     Required. When a top-level event is fired, this method is expected to
1978  *     extract synthetic events that will in turn be queued and dispatched.
1979  *
1980  *   `eventTypes` {object}
1981  *     Optional, plugins that fire events must publish a mapping of registration
1982  *     names that are used to register listeners. Values of this mapping must
1983  *     be objects that contain `registrationName` or `phasedRegistrationNames`.
1984  *
1985  *   `executeDispatch` {function(object, function, string)}
1986  *     Optional, allows plugins to override how an event gets dispatched. By
1987  *     default, the listener is simply invoked.
1988  *
1989  * Each plugin that is injected into `EventsPluginHub` is immediately operable.
1990  *
1991  * @public
1992  */
1993 var EventPluginHub = {
1994
1995   /**
1996    * Methods for injecting dependencies.
1997    */
1998   injection: {
1999
2000     /**
2001      * @param {object} InjectedInstanceHandle
2002      * @public
2003      */
2004     injectInstanceHandle: EventPropagators.injection.injectInstanceHandle,
2005
2006     /**
2007      * @param {array} InjectedEventPluginOrder
2008      * @public
2009      */
2010     injectEventPluginOrder: EventPluginRegistry.injectEventPluginOrder,
2011
2012     /**
2013      * @param {object} injectedNamesToPlugins Map from names to plugin modules.
2014      */
2015     injectEventPluginsByName: EventPluginRegistry.injectEventPluginsByName
2016
2017   },
2018
2019   registrationNames: EventPluginRegistry.registrationNames,
2020
2021   putListener: CallbackRegistry.putListener,
2022
2023   getListener: CallbackRegistry.getListener,
2024
2025   deleteListener: CallbackRegistry.deleteListener,
2026
2027   deleteAllListeners: CallbackRegistry.deleteAllListeners,
2028
2029   /**
2030    * Allows registered plugins an opportunity to extract events from top-level
2031    * native browser events.
2032    *
2033    * @param {string} topLevelType Record from `EventConstants`.
2034    * @param {DOMEventTarget} topLevelTarget The listening component root node.
2035    * @param {string} topLevelTargetID ID of `topLevelTarget`.
2036    * @param {object} nativeEvent Native browser event.
2037    * @return {*} An accumulation of synthetic events.
2038    * @internal
2039    */
2040   extractEvents: function(
2041       topLevelType,
2042       topLevelTarget,
2043       topLevelTargetID,
2044       nativeEvent) {
2045     var events;
2046     var plugins = EventPluginRegistry.plugins;
2047     for (var i = 0, l = plugins.length; i < l; i++) {
2048       // Not every plugin in the ordering may be loaded at runtime.
2049       var possiblePlugin = plugins[i];
2050       if (possiblePlugin) {
2051         var extractedEvents = possiblePlugin.extractEvents(
2052           topLevelType,
2053           topLevelTarget,
2054           topLevelTargetID,
2055           nativeEvent
2056         );
2057         if (extractedEvents) {
2058           events = accumulate(events, extractedEvents);
2059         }
2060       }
2061     }
2062     return events;
2063   },
2064
2065   /**
2066    * Enqueues a synthetic event that should be dispatched when
2067    * `processEventQueue` is invoked.
2068    *
2069    * @param {*} events An accumulation of synthetic events.
2070    * @internal
2071    */
2072   enqueueEvents: function(events) {
2073     if (events) {
2074       eventQueue = accumulate(eventQueue, events);
2075     }
2076   },
2077
2078   /**
2079    * Dispatches all synthetic events on the event queue.
2080    *
2081    * @internal
2082    */
2083   processEventQueue: function() {
2084     // Set `eventQueue` to null before processing it so that we can tell if more
2085     // events get enqueued while processing.
2086     var processingEventQueue = eventQueue;
2087     eventQueue = null;
2088     forEachAccumulated(processingEventQueue, executeDispatchesAndRelease);
2089     invariant(
2090       !eventQueue,
2091       'processEventQueue(): Additional events were enqueued while processing ' +
2092       'an event queue. Support for this has not yet been implemented.'
2093     );
2094   }
2095
2096 };
2097
2098 if (ExecutionEnvironment.canUseDOM) {
2099   window.EventPluginHub = EventPluginHub;
2100 }
2101
2102 module.exports = EventPluginHub;
2103
2104 },{"./CallbackRegistry":4,"./EventPluginRegistry":16,"./EventPluginUtils":17,"./EventPropagators":18,"./ExecutionEnvironment":19,"./accumulate":60,"./forEachAccumulated":68,"./invariant":75}],16:[function(require,module,exports){
2105 /**
2106  * Copyright 2013 Facebook, Inc.
2107  *
2108  * Licensed under the Apache License, Version 2.0 (the "License");
2109  * you may not use this file except in compliance with the License.
2110  * You may obtain a copy of the License at
2111  *
2112  * http://www.apache.org/licenses/LICENSE-2.0
2113  *
2114  * Unless required by applicable law or agreed to in writing, software
2115  * distributed under the License is distributed on an "AS IS" BASIS,
2116  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
2117  * See the License for the specific language governing permissions and
2118  * limitations under the License.
2119  *
2120  * @providesModule EventPluginRegistry
2121  * @typechecks static-only
2122  */
2123
2124 "use strict";
2125
2126 var invariant = require("./invariant");
2127
2128 /**
2129  * Injectable ordering of event plugins.
2130  */
2131 var EventPluginOrder = null;
2132
2133 /**
2134  * Injectable mapping from names to event plugin modules.
2135  */
2136 var namesToPlugins = {};
2137
2138 /**
2139  * Recomputes the plugin list using the injected plugins and plugin ordering.
2140  *
2141  * @private
2142  */
2143 function recomputePluginOrdering() {
2144   if (!EventPluginOrder) {
2145     // Wait until an `EventPluginOrder` is injected.
2146     return;
2147   }
2148   for (var pluginName in namesToPlugins) {
2149     var PluginModule = namesToPlugins[pluginName];
2150     var pluginIndex = EventPluginOrder.indexOf(pluginName);
2151     invariant(
2152       pluginIndex > -1,
2153       'EventPluginRegistry: Cannot inject event plugins that do not exist in ' +
2154       'the plugin ordering, `%s`.',
2155       pluginName
2156     );
2157     if (EventPluginRegistry.plugins[pluginIndex]) {
2158       continue;
2159     }
2160     invariant(
2161       PluginModule.extractEvents,
2162       'EventPluginRegistry: Event plugins must implement an `extractEvents` ' +
2163       'method, but `%s` does not.',
2164       pluginName
2165     );
2166     EventPluginRegistry.plugins[pluginIndex] = PluginModule;
2167     var publishedEvents = PluginModule.eventTypes;
2168     for (var eventName in publishedEvents) {
2169       invariant(
2170         publishEventForPlugin(publishedEvents[eventName], PluginModule),
2171         'EventPluginRegistry: Failed to publish event `%s` for plugin `%s`.',
2172         eventName,
2173         pluginName
2174       );
2175     }
2176   }
2177 }
2178
2179 /**
2180  * Publishes an event so that it can be dispatched by the supplied plugin.
2181  *
2182  * @param {object} dispatchConfig Dispatch configuration for the event.
2183  * @param {object} PluginModule Plugin publishing the event.
2184  * @return {boolean} True if the event was successfully published.
2185  * @private
2186  */
2187 function publishEventForPlugin(dispatchConfig, PluginModule) {
2188   var phasedRegistrationNames = dispatchConfig.phasedRegistrationNames;
2189   if (phasedRegistrationNames) {
2190     for (var phaseName in phasedRegistrationNames) {
2191       if (phasedRegistrationNames.hasOwnProperty(phaseName)) {
2192         var phasedRegistrationName = phasedRegistrationNames[phaseName];
2193         publishRegistrationName(phasedRegistrationName, PluginModule);
2194       }
2195     }
2196     return true;
2197   } else if (dispatchConfig.registrationName) {
2198     publishRegistrationName(dispatchConfig.registrationName, PluginModule);
2199     return true;
2200   }
2201   return false;
2202 }
2203
2204 /**
2205  * Publishes a registration name that is used to identify dispatched events and
2206  * can be used with `EventPluginHub.putListener` to register listeners.
2207  *
2208  * @param {string} registrationName Registration name to add.
2209  * @param {object} PluginModule Plugin publishing the event.
2210  * @private
2211  */
2212 function publishRegistrationName(registrationName, PluginModule) {
2213   invariant(
2214     !EventPluginRegistry.registrationNames[registrationName],
2215     'EventPluginHub: More than one plugin attempted to publish the same ' +
2216     'registration name, `%s`.',
2217     registrationName
2218   );
2219   EventPluginRegistry.registrationNames[registrationName] = PluginModule;
2220   EventPluginRegistry.registrationNamesKeys.push(registrationName);
2221 }
2222
2223 /**
2224  * Registers plugins so that they can extract and dispatch events.
2225  *
2226  * @see {EventPluginHub}
2227  */
2228 var EventPluginRegistry = {
2229
2230   /**
2231    * Ordered list of injected plugins.
2232    */
2233   plugins: [],
2234
2235   /**
2236    * Mapping from registration names to plugin modules.
2237    */
2238   registrationNames: {},
2239
2240   /**
2241    * The keys of `registrationNames`.
2242    */
2243   registrationNamesKeys: [],
2244
2245   /**
2246    * Injects an ordering of plugins (by plugin name). This allows the ordering
2247    * to be decoupled from injection of the actual plugins so that ordering is
2248    * always deterministic regardless of packaging, on-the-fly injection, etc.
2249    *
2250    * @param {array} InjectedEventPluginOrder
2251    * @internal
2252    * @see {EventPluginHub.injection.injectEventPluginOrder}
2253    */
2254   injectEventPluginOrder: function(InjectedEventPluginOrder) {
2255     invariant(
2256       !EventPluginOrder,
2257       'EventPluginRegistry: Cannot inject event plugin ordering more than once.'
2258     );
2259     // Clone the ordering so it cannot be dynamically mutated.
2260     EventPluginOrder = Array.prototype.slice.call(InjectedEventPluginOrder);
2261     recomputePluginOrdering();
2262   },
2263
2264   /**
2265    * Injects plugins to be used by `EventPluginHub`. The plugin names must be
2266    * in the ordering injected by `injectEventPluginOrder`.
2267    *
2268    * Plugins can be injected as part of page initialization or on-the-fly.
2269    *
2270    * @param {object} injectedNamesToPlugins Map from names to plugin modules.
2271    * @internal
2272    * @see {EventPluginHub.injection.injectEventPluginsByName}
2273    */
2274   injectEventPluginsByName: function(injectedNamesToPlugins) {
2275     var isOrderingDirty = false;
2276     for (var pluginName in injectedNamesToPlugins) {
2277       if (!injectedNamesToPlugins.hasOwnProperty(pluginName)) {
2278         continue;
2279       }
2280       var PluginModule = injectedNamesToPlugins[pluginName];
2281       if (namesToPlugins[pluginName] !== PluginModule) {
2282         invariant(
2283           !namesToPlugins[pluginName],
2284           'EventPluginRegistry: Cannot inject two different event plugins ' +
2285           'using the same name, `%s`.',
2286           pluginName
2287         );
2288         namesToPlugins[pluginName] = PluginModule;
2289         isOrderingDirty = true;
2290       }
2291     }
2292     if (isOrderingDirty) {
2293       recomputePluginOrdering();
2294     }
2295   },
2296
2297   /**
2298    * Looks up the plugin for the supplied event.
2299    *
2300    * @param {object} event A synthetic event.
2301    * @return {?object} The plugin that created the supplied event.
2302    * @internal
2303    */
2304   getPluginModuleForEvent: function(event) {
2305     var dispatchConfig = event.dispatchConfig;
2306     if (dispatchConfig.registrationName) {
2307       return EventPluginRegistry.registrationNames[
2308         dispatchConfig.registrationName
2309       ] || null;
2310     }
2311     for (var phase in dispatchConfig.phasedRegistrationNames) {
2312       if (!dispatchConfig.phasedRegistrationNames.hasOwnProperty(phase)) {
2313         continue;
2314       }
2315       var PluginModule = EventPluginRegistry.registrationNames[
2316         dispatchConfig.phasedRegistrationNames[phase]
2317       ];
2318       if (PluginModule) {
2319         return PluginModule;
2320       }
2321     }
2322     return null;
2323   },
2324
2325   /**
2326    * Exposed for unit testing.
2327    * @private
2328    */
2329   _resetEventPlugins: function() {
2330     EventPluginOrder = null;
2331     for (var pluginName in namesToPlugins) {
2332       if (namesToPlugins.hasOwnProperty(pluginName)) {
2333         delete namesToPlugins[pluginName];
2334       }
2335     }
2336     EventPluginRegistry.plugins.length = 0;
2337     var registrationNames = EventPluginRegistry.registrationNames;
2338     for (var registrationName in registrationNames) {
2339       if (registrationNames.hasOwnProperty(registrationName)) {
2340         delete registrationNames[registrationName];
2341       }
2342     }
2343     EventPluginRegistry.registrationNamesKeys.length = 0;
2344   }
2345
2346 };
2347
2348 module.exports = EventPluginRegistry;
2349
2350 },{"./invariant":75}],17:[function(require,module,exports){
2351 /**
2352  * Copyright 2013 Facebook, Inc.
2353  *
2354  * Licensed under the Apache License, Version 2.0 (the "License");
2355  * you may not use this file except in compliance with the License.
2356  * You may obtain a copy of the License at
2357  *
2358  * http://www.apache.org/licenses/LICENSE-2.0
2359  *
2360  * Unless required by applicable law or agreed to in writing, software
2361  * distributed under the License is distributed on an "AS IS" BASIS,
2362  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
2363  * See the License for the specific language governing permissions and
2364  * limitations under the License.
2365  *
2366  * @providesModule EventPluginUtils
2367  */
2368
2369 "use strict";
2370
2371 var EventConstants = require("./EventConstants");
2372
2373 var invariant = require("./invariant");
2374
2375 var topLevelTypes = EventConstants.topLevelTypes;
2376
2377 function isEndish(topLevelType) {
2378   return topLevelType === topLevelTypes.topMouseUp ||
2379          topLevelType === topLevelTypes.topTouchEnd ||
2380          topLevelType === topLevelTypes.topTouchCancel;
2381 }
2382
2383 function isMoveish(topLevelType) {
2384   return topLevelType === topLevelTypes.topMouseMove ||
2385          topLevelType === topLevelTypes.topTouchMove;
2386 }
2387 function isStartish(topLevelType) {
2388   return topLevelType === topLevelTypes.topMouseDown ||
2389          topLevelType === topLevelTypes.topTouchStart;
2390 }
2391
2392 var validateEventDispatches;
2393 if (true) {
2394   validateEventDispatches = function(event) {
2395     var dispatchListeners = event._dispatchListeners;
2396     var dispatchIDs = event._dispatchIDs;
2397
2398     var listenersIsArr = Array.isArray(dispatchListeners);
2399     var idsIsArr = Array.isArray(dispatchIDs);
2400     var IDsLen = idsIsArr ? dispatchIDs.length : dispatchIDs ? 1 : 0;
2401     var listenersLen = listenersIsArr ?
2402       dispatchListeners.length :
2403       dispatchListeners ? 1 : 0;
2404
2405     invariant(
2406       idsIsArr === listenersIsArr && IDsLen === listenersLen,
2407       'EventPluginUtils: Invalid `event`.'
2408     );
2409   };
2410 }
2411
2412 /**
2413  * Invokes `cb(event, listener, id)`. Avoids using call if no scope is
2414  * provided. The `(listener,id)` pair effectively forms the "dispatch" but are
2415  * kept separate to conserve memory.
2416  */
2417 function forEachEventDispatch(event, cb) {
2418   var dispatchListeners = event._dispatchListeners;
2419   var dispatchIDs = event._dispatchIDs;
2420   if (true) {
2421     validateEventDispatches(event);
2422   }
2423   if (Array.isArray(dispatchListeners)) {
2424     for (var i = 0; i < dispatchListeners.length; i++) {
2425       if (event.isPropagationStopped()) {
2426         break;
2427       }
2428       // Listeners and IDs are two parallel arrays that are always in sync.
2429       cb(event, dispatchListeners[i], dispatchIDs[i]);
2430     }
2431   } else if (dispatchListeners) {
2432     cb(event, dispatchListeners, dispatchIDs);
2433   }
2434 }
2435
2436 /**
2437  * Default implementation of PluginModule.executeDispatch().
2438  * @param {SyntheticEvent} SyntheticEvent to handle
2439  * @param {function} Application-level callback
2440  * @param {string} domID DOM id to pass to the callback.
2441  */
2442 function executeDispatch(event, listener, domID) {
2443   listener(event, domID);
2444 }
2445
2446 /**
2447  * Standard/simple iteration through an event's collected dispatches.
2448  */
2449 function executeDispatchesInOrder(event, executeDispatch) {
2450   forEachEventDispatch(event, executeDispatch);
2451   event._dispatchListeners = null;
2452   event._dispatchIDs = null;
2453 }
2454
2455 /**
2456  * Standard/simple iteration through an event's collected dispatches, but stops
2457  * at the first dispatch execution returning true, and returns that id.
2458  *
2459  * @return id of the first dispatch execution who's listener returns true, or
2460  * null if no listener returned true.
2461  */
2462 function executeDispatchesInOrderStopAtTrue(event) {
2463   var dispatchListeners = event._dispatchListeners;
2464   var dispatchIDs = event._dispatchIDs;
2465   if (true) {
2466     validateEventDispatches(event);
2467   }
2468   if (Array.isArray(dispatchListeners)) {
2469     for (var i = 0; i < dispatchListeners.length; i++) {
2470       if (event.isPropagationStopped()) {
2471         break;
2472       }
2473       // Listeners and IDs are two parallel arrays that are always in sync.
2474       if (dispatchListeners[i](event, dispatchIDs[i])) {
2475         return dispatchIDs[i];
2476       }
2477     }
2478   } else if (dispatchListeners) {
2479     if (dispatchListeners(event, dispatchIDs)) {
2480       return dispatchIDs;
2481     }
2482   }
2483   return null;
2484 }
2485
2486 /**
2487  * Execution of a "direct" dispatch - there must be at most one dispatch
2488  * accumulated on the event or it is considered an error. It doesn't really make
2489  * sense for an event with multiple dispatches (bubbled) to keep track of the
2490  * return values at each dispatch execution, but it does tend to make sense when
2491  * dealing with "direct" dispatches.
2492  *
2493  * @return The return value of executing the single dispatch.
2494  */
2495 function executeDirectDispatch(event) {
2496   if (true) {
2497     validateEventDispatches(event);
2498   }
2499   var dispatchListener = event._dispatchListeners;
2500   var dispatchID = event._dispatchIDs;
2501   invariant(
2502     !Array.isArray(dispatchListener),
2503     'executeDirectDispatch(...): Invalid `event`.'
2504   );
2505   var res = dispatchListener ?
2506     dispatchListener(event, dispatchID) :
2507     null;
2508   event._dispatchListeners = null;
2509   event._dispatchIDs = null;
2510   return res;
2511 }
2512
2513 /**
2514  * @param {SyntheticEvent} event
2515  * @return {bool} True iff number of dispatches accumulated is greater than 0.
2516  */
2517 function hasDispatches(event) {
2518   return !!event._dispatchListeners;
2519 }
2520
2521 /**
2522  * General utilities that are useful in creating custom Event Plugins.
2523  */
2524 var EventPluginUtils = {
2525   isEndish: isEndish,
2526   isMoveish: isMoveish,
2527   isStartish: isStartish,
2528   executeDispatchesInOrder: executeDispatchesInOrder,
2529   executeDispatchesInOrderStopAtTrue: executeDispatchesInOrderStopAtTrue,
2530   executeDirectDispatch: executeDirectDispatch,
2531   hasDispatches: hasDispatches,
2532   executeDispatch: executeDispatch
2533 };
2534
2535 module.exports = EventPluginUtils;
2536
2537 },{"./EventConstants":13,"./invariant":75}],18:[function(require,module,exports){
2538 /**
2539  * Copyright 2013 Facebook, Inc.
2540  *
2541  * Licensed under the Apache License, Version 2.0 (the "License");
2542  * you may not use this file except in compliance with the License.
2543  * You may obtain a copy of the License at
2544  *
2545  * http://www.apache.org/licenses/LICENSE-2.0
2546  *
2547  * Unless required by applicable law or agreed to in writing, software
2548  * distributed under the License is distributed on an "AS IS" BASIS,
2549  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
2550  * See the License for the specific language governing permissions and
2551  * limitations under the License.
2552  *
2553  * @providesModule EventPropagators
2554  */
2555
2556 "use strict";
2557
2558 var CallbackRegistry = require("./CallbackRegistry");
2559 var EventConstants = require("./EventConstants");
2560
2561 var accumulate = require("./accumulate");
2562 var forEachAccumulated = require("./forEachAccumulated");
2563 var getListener = CallbackRegistry.getListener;
2564 var PropagationPhases = EventConstants.PropagationPhases;
2565
2566 /**
2567  * Injected dependencies:
2568  */
2569
2570 /**
2571  * - `InstanceHandle`: [required] Module that performs logical traversals of DOM
2572  *   hierarchy given ids of the logical DOM elements involved.
2573  */
2574 var injection = {
2575   InstanceHandle: null,
2576   injectInstanceHandle: function(InjectedInstanceHandle) {
2577     injection.InstanceHandle = InjectedInstanceHandle;
2578     if (true) {
2579       injection.validate();
2580     }
2581   },
2582   validate: function() {
2583     var invalid = !injection.InstanceHandle||
2584       !injection.InstanceHandle.traverseTwoPhase ||
2585       !injection.InstanceHandle.traverseEnterLeave;
2586     if (invalid) {
2587       throw new Error('InstanceHandle not injected before use!');
2588     }
2589   }
2590 };
2591
2592 /**
2593  * Some event types have a notion of different registration names for different
2594  * "phases" of propagation. This finds listeners by a given phase.
2595  */
2596 function listenerAtPhase(id, event, propagationPhase) {
2597   var registrationName =
2598     event.dispatchConfig.phasedRegistrationNames[propagationPhase];
2599   return getListener(id, registrationName);
2600 }
2601
2602 /**
2603  * Tags a `SyntheticEvent` with dispatched listeners. Creating this function
2604  * here, allows us to not have to bind or create functions for each event.
2605  * Mutating the event's members allows us to not have to create a wrapping
2606  * "dispatch" object that pairs the event with the listener.
2607  */
2608 function accumulateDirectionalDispatches(domID, upwards, event) {
2609   if (true) {
2610     if (!domID) {
2611       throw new Error('Dispatching id must not be null');
2612     }
2613     injection.validate();
2614   }
2615   var phase = upwards ? PropagationPhases.bubbled : PropagationPhases.captured;
2616   var listener = listenerAtPhase(domID, event, phase);
2617   if (listener) {
2618     event._dispatchListeners = accumulate(event._dispatchListeners, listener);
2619     event._dispatchIDs = accumulate(event._dispatchIDs, domID);
2620   }
2621 }
2622
2623 /**
2624  * Collect dispatches (must be entirely collected before dispatching - see unit
2625  * tests). Lazily allocate the array to conserve memory.  We must loop through
2626  * each event and perform the traversal for each one. We can not perform a
2627  * single traversal for the entire collection of events because each event may
2628  * have a different target.
2629  */
2630 function accumulateTwoPhaseDispatchesSingle(event) {
2631   if (event && event.dispatchConfig.phasedRegistrationNames) {
2632     injection.InstanceHandle.traverseTwoPhase(
2633       event.dispatchMarker,
2634       accumulateDirectionalDispatches,
2635       event
2636     );
2637   }
2638 }
2639
2640
2641 /**
2642  * Accumulates without regard to direction, does not look for phased
2643  * registration names. Same as `accumulateDirectDispatchesSingle` but without
2644  * requiring that the `dispatchMarker` be the same as the dispatched ID.
2645  */
2646 function accumulateDispatches(id, ignoredDirection, event) {
2647   if (event && event.dispatchConfig.registrationName) {
2648     var registrationName = event.dispatchConfig.registrationName;
2649     var listener = getListener(id, registrationName);
2650     if (listener) {
2651       event._dispatchListeners = accumulate(event._dispatchListeners, listener);
2652       event._dispatchIDs = accumulate(event._dispatchIDs, id);
2653     }
2654   }
2655 }
2656
2657 /**
2658  * Accumulates dispatches on an `SyntheticEvent`, but only for the
2659  * `dispatchMarker`.
2660  * @param {SyntheticEvent} event
2661  */
2662 function accumulateDirectDispatchesSingle(event) {
2663   if (event && event.dispatchConfig.registrationName) {
2664     accumulateDispatches(event.dispatchMarker, null, event);
2665   }
2666 }
2667
2668 function accumulateTwoPhaseDispatches(events) {
2669   if (true) {
2670     injection.validate();
2671   }
2672   forEachAccumulated(events, accumulateTwoPhaseDispatchesSingle);
2673 }
2674
2675 function accumulateEnterLeaveDispatches(leave, enter, fromID, toID) {
2676   if (true) {
2677     injection.validate();
2678   }
2679   injection.InstanceHandle.traverseEnterLeave(
2680     fromID,
2681     toID,
2682     accumulateDispatches,
2683     leave,
2684     enter
2685   );
2686 }
2687
2688
2689 function accumulateDirectDispatches(events) {
2690   if (true) {
2691     injection.validate();
2692   }
2693   forEachAccumulated(events, accumulateDirectDispatchesSingle);
2694 }
2695
2696
2697
2698 /**
2699  * A small set of propagation patterns, each of which will accept a small amount
2700  * of information, and generate a set of "dispatch ready event objects" - which
2701  * are sets of events that have already been annotated with a set of dispatched
2702  * listener functions/ids. The API is designed this way to discourage these
2703  * propagation strategies from actually executing the dispatches, since we
2704  * always want to collect the entire set of dispatches before executing event a
2705  * single one.
2706  *
2707  * @constructor EventPropagators
2708  */
2709 var EventPropagators = {
2710   accumulateTwoPhaseDispatches: accumulateTwoPhaseDispatches,
2711   accumulateDirectDispatches: accumulateDirectDispatches,
2712   accumulateEnterLeaveDispatches: accumulateEnterLeaveDispatches,
2713   injection: injection
2714 };
2715
2716 module.exports = EventPropagators;
2717
2718 },{"./CallbackRegistry":4,"./EventConstants":13,"./accumulate":60,"./forEachAccumulated":68}],19:[function(require,module,exports){
2719 (function(){/**
2720  * Copyright 2013 Facebook, Inc.
2721  *
2722  * Licensed under the Apache License, Version 2.0 (the "License");
2723  * you may not use this file except in compliance with the License.
2724  * You may obtain a copy of the License at
2725  *
2726  * http://www.apache.org/licenses/LICENSE-2.0
2727  *
2728  * Unless required by applicable law or agreed to in writing, software
2729  * distributed under the License is distributed on an "AS IS" BASIS,
2730  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
2731  * See the License for the specific language governing permissions and
2732  * limitations under the License.
2733  *
2734  * @providesModule ExecutionEnvironment
2735  */
2736
2737 /*jslint evil: true */
2738
2739 "use strict";
2740
2741 var canUseDOM = typeof window !== 'undefined';
2742
2743 /**
2744  * Simple, lightweight module assisting with the detection and context of
2745  * Worker. Helps avoid circular dependencies and allows code to reason about
2746  * whether or not they are in a Worker, even if they never include the main
2747  * `ReactWorker` dependency.
2748  */
2749 var ExecutionEnvironment = {
2750
2751   canUseDOM: canUseDOM,
2752
2753   canUseWorkers: typeof Worker !== 'undefined',
2754
2755   isInWorker: !canUseDOM, // For now, this is true - might change in the future.
2756
2757   global: new Function('return this;')()
2758
2759 };
2760
2761 module.exports = ExecutionEnvironment;
2762
2763 })()
2764 },{}],20:[function(require,module,exports){
2765 /**
2766  * Copyright 2013 Facebook, Inc.
2767  *
2768  * Licensed under the Apache License, Version 2.0 (the "License");
2769  * you may not use this file except in compliance with the License.
2770  * You may obtain a copy of the License at
2771  *
2772  * http://www.apache.org/licenses/LICENSE-2.0
2773  *
2774  * Unless required by applicable law or agreed to in writing, software
2775  * distributed under the License is distributed on an "AS IS" BASIS,
2776  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
2777  * See the License for the specific language governing permissions and
2778  * limitations under the License.
2779  *
2780  * @providesModule PooledClass
2781  */
2782
2783 "use strict";
2784
2785 /**
2786  * Static poolers. Several custom versions for each potential number of
2787  * arguments. A completely generic pooler is easy to implement, but would
2788  * require accessing the `arguments` object. In each of these, `this` refers to
2789  * the Class itself, not an instance. If any others are needed, simply add them
2790  * here, or in their own files.
2791  */
2792 var oneArgumentPooler = function(copyFieldsFrom) {
2793   var Klass = this;
2794   if (Klass.instancePool.length) {
2795     var instance = Klass.instancePool.pop();
2796     Klass.call(instance, copyFieldsFrom);
2797     return instance;
2798   } else {
2799     return new Klass(copyFieldsFrom);
2800   }
2801 };
2802
2803 var twoArgumentPooler = function(a1, a2) {
2804   var Klass = this;
2805   if (Klass.instancePool.length) {
2806     var instance = Klass.instancePool.pop();
2807     Klass.call(instance, a1, a2);
2808     return instance;
2809   } else {
2810     return new Klass(a1, a2);
2811   }
2812 };
2813
2814 var threeArgumentPooler = function(a1, a2, a3) {
2815   var Klass = this;
2816   if (Klass.instancePool.length) {
2817     var instance = Klass.instancePool.pop();
2818     Klass.call(instance, a1, a2, a3);
2819     return instance;
2820   } else {
2821     return new Klass(a1, a2, a3);
2822   }
2823 };
2824
2825 var fiveArgumentPooler = function(a1, a2, a3, a4, a5) {
2826   var Klass = this;
2827   if (Klass.instancePool.length) {
2828     var instance = Klass.instancePool.pop();
2829     Klass.call(instance, a1, a2, a3, a4, a5);
2830     return instance;
2831   } else {
2832     return new Klass(a1, a2, a3, a4, a5);
2833   }
2834 };
2835
2836 var standardReleaser = function(instance) {
2837   var Klass = this;
2838   if (instance.destructor) {
2839     instance.destructor();
2840   }
2841   if (Klass.instancePool.length < Klass.poolSize) {
2842     Klass.instancePool.push(instance);
2843   }
2844 };
2845
2846 var DEFAULT_POOL_SIZE = 10;
2847 var DEFAULT_POOLER = oneArgumentPooler;
2848
2849 /**
2850  * Augments `CopyConstructor` to be a poolable class, augmenting only the class
2851  * itself (statically) not adding any prototypical fields. Any CopyConstructor
2852  * you give this may have a `poolSize` property, and will look for a
2853  * prototypical `destructor` on instances (optional).
2854  *
2855  * @param {Function} CopyConstructor Constructor that can be used to reset.
2856  * @param {Function} pooler Customizable pooler.
2857  */
2858 var addPoolingTo = function(CopyConstructor, pooler) {
2859   var NewKlass = CopyConstructor;
2860   NewKlass.instancePool = [];
2861   NewKlass.getPooled = pooler || DEFAULT_POOLER;
2862   if (!NewKlass.poolSize) {
2863     NewKlass.poolSize = DEFAULT_POOL_SIZE;
2864   }
2865   NewKlass.release = standardReleaser;
2866   return NewKlass;
2867 };
2868
2869 var PooledClass = {
2870   addPoolingTo: addPoolingTo,
2871   oneArgumentPooler: oneArgumentPooler,
2872   twoArgumentPooler: twoArgumentPooler,
2873   threeArgumentPooler: threeArgumentPooler,
2874   fiveArgumentPooler: fiveArgumentPooler
2875 };
2876
2877 module.exports = PooledClass;
2878
2879 },{}],21:[function(require,module,exports){
2880 /**
2881  * Copyright 2013 Facebook, Inc.
2882  *
2883  * Licensed under the Apache License, Version 2.0 (the "License");
2884  * you may not use this file except in compliance with the License.
2885  * You may obtain a copy of the License at
2886  *
2887  * http://www.apache.org/licenses/LICENSE-2.0
2888  *
2889  * Unless required by applicable law or agreed to in writing, software
2890  * distributed under the License is distributed on an "AS IS" BASIS,
2891  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
2892  * See the License for the specific language governing permissions and
2893  * limitations under the License.
2894  *
2895  * @providesModule React
2896  */
2897
2898 "use strict";
2899
2900 var ReactCompositeComponent = require("./ReactCompositeComponent");
2901 var ReactComponent = require("./ReactComponent");
2902 var ReactDOM = require("./ReactDOM");
2903 var ReactMount = require("./ReactMount");
2904 var ReactPropTypes = require("./ReactPropTypes");
2905 var ReactServerRendering = require("./ReactServerRendering");
2906
2907 var ReactDefaultInjection = require("./ReactDefaultInjection");
2908
2909 ReactDefaultInjection.inject();
2910
2911 var React = {
2912   DOM: ReactDOM,
2913   PropTypes: ReactPropTypes,
2914   initializeTouchEvents: function(shouldUseTouch) {
2915     ReactMount.useTouchEvents = shouldUseTouch;
2916   },
2917   autoBind: ReactCompositeComponent.autoBind,
2918   createClass: ReactCompositeComponent.createClass,
2919   constructAndRenderComponent: ReactMount.constructAndRenderComponent,
2920   constructAndRenderComponentByID: ReactMount.constructAndRenderComponentByID,
2921   renderComponent: ReactMount.renderComponent,
2922   renderComponentToString: ReactServerRendering.renderComponentToString,
2923   unmountAndReleaseReactRootNode: ReactMount.unmountAndReleaseReactRootNode,
2924   isValidComponent: ReactComponent.isValidComponent
2925 };
2926
2927 module.exports = React;
2928
2929 },{"./ReactComponent":22,"./ReactCompositeComponent":23,"./ReactDOM":25,"./ReactDefaultInjection":32,"./ReactMount":38,"./ReactPropTypes":44,"./ReactServerRendering":46}],22:[function(require,module,exports){
2930 /**
2931  * Copyright 2013 Facebook, Inc.
2932  *
2933  * Licensed under the Apache License, Version 2.0 (the "License");
2934  * you may not use this file except in compliance with the License.
2935  * You may obtain a copy of the License at
2936  *
2937  * http://www.apache.org/licenses/LICENSE-2.0
2938  *
2939  * Unless required by applicable law or agreed to in writing, software
2940  * distributed under the License is distributed on an "AS IS" BASIS,
2941  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
2942  * See the License for the specific language governing permissions and
2943  * limitations under the License.
2944  *
2945  * @providesModule ReactComponent
2946  */
2947
2948 /*jslint evil: true */
2949
2950 "use strict";
2951
2952 var ReactCurrentOwner = require("./ReactCurrentOwner");
2953 var ReactDOMIDOperations = require("./ReactDOMIDOperations");
2954 var ReactID = require("./ReactID");
2955 var ReactMount = require("./ReactMount");
2956 var