@samitouri / QOS-React-2 / commits / 05ace7365a

Move new example changes to fixtures folder

Nathan Hunzaker committed Dec 19, 2016 at 08:43 UTC 05ace7365a24bf67affccc4d4ab02768f27aac34
7 files changed +22799 -3
examples/basic/index.html
+2 -3
@@ -23,9 +23,8 @@
23 Learn more about React at
24 <a href="https://facebook.github.io/react" target="_blank">facebook.github.io/react</a>.
25 </p>
26 -
27 - <script src="../react-loader.js"></script>
28 -
26 + <script src="../../build/react.js"></script>
27 + <script src="../../build/react-dom.js"></script>
28 <script>
29 var ExampleApplication = React.createClass({
30 render: function() {
fixtures/dom/public/react-dom.js new
+18938
@@ -0,0 +1,18938 @@
1 + /**
2 + * ReactDOM v16.0.0-alpha
3 + */
4 +
5 +;(function(f) {
6 + // CommonJS
7 + if (typeof exports === "object" && typeof module !== "undefined") {
8 + module.exports = f(require('react'));
9 +
10 + // RequireJS
11 + } else if (typeof define === "function" && define.amd) {
12 + define(['react'], f);
13 +
14 + // <script>
15 + } else {
16 + var g;
17 + if (typeof window !== "undefined") {
18 + g = window;
19 + } else if (typeof global !== "undefined") {
20 + g = global;
21 + } else if (typeof self !== "undefined") {
22 + g = self;
23 + } else {
24 + // works providing we're not in "use strict";
25 + // needed for Java 8 Nashorn
26 + // see https://github.com/facebook/react/issues/3037
27 + g = this;
28 + }
29 + g.ReactDOM = f(g.React);
30 + }
31 +})(function(React) {
32 + return (function(f){return f()})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){
33 +/**
34 + * Copyright 2013-present, Facebook, Inc.
35 + * All rights reserved.
36 + *
37 + * This source code is licensed under the BSD-style license found in the
38 + * LICENSE file in the root directory of this source tree. An additional grant
39 + * of patent rights can be found in the PATENTS file in the same directory.
40 + *
41 + */
42 +
43 +'use strict';
44 +
45 +var ARIADOMPropertyConfig = {
46 + Properties: {
47 + // Global States and Properties
48 + 'aria-current': 0, // state
49 + 'aria-details': 0,
50 + 'aria-disabled': 0, // state
51 + 'aria-hidden': 0, // state
52 + 'aria-invalid': 0, // state
53 + 'aria-keyshortcuts': 0,
54 + 'aria-label': 0,
55 + 'aria-roledescription': 0,
56 + // Widget Attributes
57 + 'aria-autocomplete': 0,
58 + 'aria-checked': 0,
59 + 'aria-expanded': 0,
60 + 'aria-haspopup': 0,
61 + 'aria-level': 0,
62 + 'aria-modal': 0,
63 + 'aria-multiline': 0,
64 + 'aria-multiselectable': 0,
65 + 'aria-orientation': 0,
66 + 'aria-placeholder': 0,
67 + 'aria-pressed': 0,
68 + 'aria-readonly': 0,
69 + 'aria-required': 0,
70 + 'aria-selected': 0,
71 + 'aria-sort': 0,
72 + 'aria-valuemax': 0,
73 + 'aria-valuemin': 0,
74 + 'aria-valuenow': 0,
75 + 'aria-valuetext': 0,
76 + // Live Region Attributes
77 + 'aria-atomic': 0,
78 + 'aria-busy': 0,
79 + 'aria-live': 0,
80 + 'aria-relevant': 0,
81 + // Drag-and-Drop Attributes
82 + 'aria-dropeffect': 0,
83 + 'aria-grabbed': 0,
84 + // Relationship Attributes
85 + 'aria-activedescendant': 0,
86 + 'aria-colcount': 0,
87 + 'aria-colindex': 0,
88 + 'aria-colspan': 0,
89 + 'aria-controls': 0,
90 + 'aria-describedby': 0,
91 + 'aria-errormessage': 0,
92 + 'aria-flowto': 0,
93 + 'aria-labelledby': 0,
94 + 'aria-owns': 0,
95 + 'aria-posinset': 0,
96 + 'aria-rowcount': 0,
97 + 'aria-rowindex': 0,
98 + 'aria-rowspan': 0,
99 + 'aria-setsize': 0
100 + },
101 + DOMAttributeNames: {},
102 + DOMPropertyNames: {}
103 +};
104 +
105 +module.exports = ARIADOMPropertyConfig;
106 +},{}],2:[function(_dereq_,module,exports){
107 +/**
108 + * Copyright 2013-present, Facebook, Inc.
109 + * All rights reserved.
110 + *
111 + * This source code is licensed under the BSD-style license found in the
112 + * LICENSE file in the root directory of this source tree. An additional grant
113 + * of patent rights can be found in the PATENTS file in the same directory.
114 + *
115 + */
116 +
117 +'use strict';
118 +
119 +var ReactDOMComponentTree = _dereq_(35);
120 +
121 +var focusNode = _dereq_(151);
122 +
123 +var AutoFocusUtils = {
124 + focusDOMComponent: function () {
125 + focusNode(ReactDOMComponentTree.getNodeFromInstance(this));
126 + }
127 +};
128 +
129 +module.exports = AutoFocusUtils;
130 +},{"151":151,"35":35}],3:[function(_dereq_,module,exports){
131 +/**
132 + * Copyright 2013-present Facebook, Inc.
133 + * All rights reserved.
134 + *
135 + * This source code is licensed under the BSD-style license found in the
136 + * LICENSE file in the root directory of this source tree. An additional grant
137 + * of patent rights can be found in the PATENTS file in the same directory.
138 + *
139 + */
140 +
141 +'use strict';
142 +
143 +var EventPropagators = _dereq_(20);
144 +var ExecutionEnvironment = _dereq_(143);
145 +var FallbackCompositionState = _dereq_(21);
146 +var SyntheticCompositionEvent = _dereq_(94);
147 +var SyntheticInputEvent = _dereq_(98);
148 +
149 +var END_KEYCODES = [9, 13, 27, 32]; // Tab, Return, Esc, Space
150 +var START_KEYCODE = 229;
151 +
152 +var canUseCompositionEvent = ExecutionEnvironment.canUseDOM && 'CompositionEvent' in window;
153 +
154 +var documentMode = null;
155 +if (ExecutionEnvironment.canUseDOM && 'documentMode' in document) {
156 + documentMode = document.documentMode;
157 +}
158 +
159 +// Webkit offers a very useful `textInput` event that can be used to
160 +// directly represent `beforeInput`. The IE `textinput` event is not as
161 +// useful, so we don't use it.
162 +var canUseTextInputEvent = ExecutionEnvironment.canUseDOM && 'TextEvent' in window && !documentMode && !isPresto();
163 +
164 +// In IE9+, we have access to composition events, but the data supplied
165 +// by the native compositionend event may be incorrect. Japanese ideographic
166 +// spaces, for instance (\u3000) are not recorded correctly.
167 +var useFallbackCompositionData = ExecutionEnvironment.canUseDOM && (!canUseCompositionEvent || documentMode && documentMode > 8 && documentMode <= 11);
168 +
169 +/**
170 + * Opera <= 12 includes TextEvent in window, but does not fire
171 + * text input events. Rely on keypress instead.
172 + */
173 +function isPresto() {
174 + var opera = window.opera;
175 + return typeof opera === 'object' && typeof opera.version === 'function' && parseInt(opera.version(), 10) <= 12;
176 +}
177 +
178 +var SPACEBAR_CODE = 32;
179 +var SPACEBAR_CHAR = String.fromCharCode(SPACEBAR_CODE);
180 +
181 +// Events and their corresponding property names.
182 +var eventTypes = {
183 + beforeInput: {
184 + phasedRegistrationNames: {
185 + bubbled: 'onBeforeInput',
186 + captured: 'onBeforeInputCapture'
187 + },
188 + dependencies: ['topCompositionEnd', 'topKeyPress', 'topTextInput', 'topPaste']
189 + },
190 + compositionEnd: {
191 + phasedRegistrationNames: {
192 + bubbled: 'onCompositionEnd',
193 + captured: 'onCompositionEndCapture'
194 + },
195 + dependencies: ['topBlur', 'topCompositionEnd', 'topKeyDown', 'topKeyPress', 'topKeyUp', 'topMouseDown']
196 + },
197 + compositionStart: {
198 + phasedRegistrationNames: {
199 + bubbled: 'onCompositionStart',
200 + captured: 'onCompositionStartCapture'
201 + },
202 + dependencies: ['topBlur', 'topCompositionStart', 'topKeyDown', 'topKeyPress', 'topKeyUp', 'topMouseDown']
203 + },
204 + compositionUpdate: {
205 + phasedRegistrationNames: {
206 + bubbled: 'onCompositionUpdate',
207 + captured: 'onCompositionUpdateCapture'
208 + },
209 + dependencies: ['topBlur', 'topCompositionUpdate', 'topKeyDown', 'topKeyPress', 'topKeyUp', 'topMouseDown']
210 + }
211 +};
212 +
213 +// Track whether we've ever handled a keypress on the space key.
214 +var hasSpaceKeypress = false;
215 +
216 +/**
217 + * Return whether a native keypress event is assumed to be a command.
218 + * This is required because Firefox fires `keypress` events for key commands
219 + * (cut, copy, select-all, etc.) even though no character is inserted.
220 + */
221 +function isKeypressCommand(nativeEvent) {
222 + return (nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) &&
223 + // ctrlKey && altKey is equivalent to AltGr, and is not a command.
224 + !(nativeEvent.ctrlKey && nativeEvent.altKey);
225 +}
226 +
227 +/**
228 + * Translate native top level events into event types.
229 + *
230 + * @param {string} topLevelType
231 + * @return {object}
232 + */
233 +function getCompositionEventType(topLevelType) {
234 + switch (topLevelType) {
235 + case 'topCompositionStart':
236 + return eventTypes.compositionStart;
237 + case 'topCompositionEnd':
238 + return eventTypes.compositionEnd;
239 + case 'topCompositionUpdate':
240 + return eventTypes.compositionUpdate;
241 + }
242 +}
243 +
244 +/**
245 + * Does our fallback best-guess model think this event signifies that
246 + * composition has begun?
247 + *
248 + * @param {string} topLevelType
249 + * @param {object} nativeEvent
250 + * @return {boolean}
251 + */
252 +function isFallbackCompositionStart(topLevelType, nativeEvent) {
253 + return topLevelType === 'topKeyDown' && nativeEvent.keyCode === START_KEYCODE;
254 +}
255 +
256 +/**
257 + * Does our fallback mode think that this event is the end of composition?
258 + *
259 + * @param {string} topLevelType
260 + * @param {object} nativeEvent
261 + * @return {boolean}
262 + */
263 +function isFallbackCompositionEnd(topLevelType, nativeEvent) {
264 + switch (topLevelType) {
265 + case 'topKeyUp':
266 + // Command keys insert or clear IME input.
267 + return END_KEYCODES.indexOf(nativeEvent.keyCode) !== -1;
268 + case 'topKeyDown':
269 + // Expect IME keyCode on each keydown. If we get any other
270 + // code we must have exited earlier.
271 + return nativeEvent.keyCode !== START_KEYCODE;
272 + case 'topKeyPress':
273 + case 'topMouseDown':
274 + case 'topBlur':
275 + // Events are not possible without cancelling IME.
276 + return true;
277 + default:
278 + return false;
279 + }
280 +}
281 +
282 +/**
283 + * Google Input Tools provides composition data via a CustomEvent,
284 + * with the `data` property populated in the `detail` object. If this
285 + * is available on the event object, use it. If not, this is a plain
286 + * composition event and we have nothing special to extract.
287 + *
288 + * @param {object} nativeEvent
289 + * @return {?string}
290 + */
291 +function getDataFromCustomEvent(nativeEvent) {
292 + var detail = nativeEvent.detail;
293 + if (typeof detail === 'object' && 'data' in detail) {
294 + return detail.data;
295 + }
296 + return null;
297 +}
298 +
299 +// Track the current IME composition fallback object, if any.
300 +var currentComposition = null;
301 +
302 +/**
303 + * @return {?object} A SyntheticCompositionEvent.
304 + */
305 +function extractCompositionEvent(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
306 + var eventType;
307 + var fallbackData;
308 +
309 + if (canUseCompositionEvent) {
310 + eventType = getCompositionEventType(topLevelType);
311 + } else if (!currentComposition) {
312 + if (isFallbackCompositionStart(topLevelType, nativeEvent)) {
313 + eventType = eventTypes.compositionStart;
314 + }
315 + } else if (isFallbackCompositionEnd(topLevelType, nativeEvent)) {
316 + eventType = eventTypes.compositionEnd;
317 + }
318 +
319 + if (!eventType) {
320 + return null;
321 + }
322 +
323 + if (useFallbackCompositionData) {
324 + // The current composition is stored statically and must not be
325 + // overwritten while composition continues.
326 + if (!currentComposition && eventType === eventTypes.compositionStart) {
327 + currentComposition = FallbackCompositionState.getPooled(nativeEventTarget);
328 + } else if (eventType === eventTypes.compositionEnd) {
329 + if (currentComposition) {
330 + fallbackData = currentComposition.getData();
331 + }
332 + }
333 + }
334 +
335 + var event = SyntheticCompositionEvent.getPooled(eventType, targetInst, nativeEvent, nativeEventTarget);
336 +
337 + if (fallbackData) {
338 + // Inject data generated from fallback path into the synthetic event.
339 + // This matches the property of native CompositionEventInterface.
340 + event.data = fallbackData;
341 + } else {
342 + var customData = getDataFromCustomEvent(nativeEvent);
343 + if (customData !== null) {
344 + event.data = customData;
345 + }
346 + }
347 +
348 + EventPropagators.accumulateTwoPhaseDispatches(event);
349 + return event;
350 +}
351 +
352 +/**
353 + * @param {string} topLevelType Record from `EventConstants`.
354 + * @param {object} nativeEvent Native browser event.
355 + * @return {?string} The string corresponding to this `beforeInput` event.
356 + */
357 +function getNativeBeforeInputChars(topLevelType, nativeEvent) {
358 + switch (topLevelType) {
359 + case 'topCompositionEnd':
360 + return getDataFromCustomEvent(nativeEvent);
361 + case 'topKeyPress':
362 + /**
363 + * If native `textInput` events are available, our goal is to make
364 + * use of them. However, there is a special case: the spacebar key.
365 + * In Webkit, preventing default on a spacebar `textInput` event
366 + * cancels character insertion, but it *also* causes the browser
367 + * to fall back to its default spacebar behavior of scrolling the
368 + * page.
369 + *
370 + * Tracking at:
371 + * https://code.google.com/p/chromium/issues/detail?id=355103
372 + *
373 + * To avoid this issue, use the keypress event as if no `textInput`
374 + * event is available.
375 + */
376 + var which = nativeEvent.which;
377 + if (which !== SPACEBAR_CODE) {
378 + return null;
379 + }
380 +
381 + hasSpaceKeypress = true;
382 + return SPACEBAR_CHAR;
383 +
384 + case 'topTextInput':
385 + // Record the characters to be added to the DOM.
386 + var chars = nativeEvent.data;
387 +
388 + // If it's a spacebar character, assume that we have already handled
389 + // it at the keypress level and bail immediately. Android Chrome
390 + // doesn't give us keycodes, so we need to blacklist it.
391 + if (chars === SPACEBAR_CHAR && hasSpaceKeypress) {
392 + return null;
393 + }
394 +
395 + return chars;
396 +
397 + default:
398 + // For other native event types, do nothing.
399 + return null;
400 + }
401 +}
402 +
403 +/**
404 + * For browsers that do not provide the `textInput` event, extract the
405 + * appropriate string to use for SyntheticInputEvent.
406 + *
407 + * @param {string} topLevelType Record from `EventConstants`.
408 + * @param {object} nativeEvent Native browser event.
409 + * @return {?string} The fallback string for this `beforeInput` event.
410 + */
411 +function getFallbackBeforeInputChars(topLevelType, nativeEvent) {
412 + // If we are currently composing (IME) and using a fallback to do so,
413 + // try to extract the composed characters from the fallback object.
414 + // If composition event is available, we extract a string only at
415 + // compositionevent, otherwise extract it at fallback events.
416 + if (currentComposition) {
417 + if (topLevelType === 'topCompositionEnd' || !canUseCompositionEvent && isFallbackCompositionEnd(topLevelType, nativeEvent)) {
418 + var chars = currentComposition.getData();
419 + FallbackCompositionState.release(currentComposition);
420 + currentComposition = null;
421 + return chars;
422 + }
423 + return null;
424 + }
425 +
426 + switch (topLevelType) {
427 + case 'topPaste':
428 + // If a paste event occurs after a keypress, throw out the input
429 + // chars. Paste events should not lead to BeforeInput events.
430 + return null;
431 + case 'topKeyPress':
432 + /**
433 + * As of v27, Firefox may fire keypress events even when no character
434 + * will be inserted. A few possibilities:
435 + *
436 + * - `which` is `0`. Arrow keys, Esc key, etc.
437 + *
438 + * - `which` is the pressed key code, but no char is available.
439 + * Ex: 'AltGr + d` in Polish. There is no modified character for
440 + * this key combination and no character is inserted into the
441 + * document, but FF fires the keypress for char code `100` anyway.
442 + * No `input` event will occur.
443 + *
444 + * - `which` is the pressed key code, but a command combination is
445 + * being used. Ex: `Cmd+C`. No character is inserted, and no
446 + * `input` event will occur.
447 + */
448 + if (nativeEvent.which && !isKeypressCommand(nativeEvent)) {
449 + return String.fromCharCode(nativeEvent.which);
450 + }
451 + return null;
452 + case 'topCompositionEnd':
453 + return useFallbackCompositionData ? null : nativeEvent.data;
454 + default:
455 + return null;
456 + }
457 +}
458 +
459 +/**
460 + * Extract a SyntheticInputEvent for `beforeInput`, based on either native
461 + * `textInput` or fallback behavior.
462 + *
463 + * @return {?object} A SyntheticInputEvent.
464 + */
465 +function extractBeforeInputEvent(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
466 + var chars;
467 +
468 + if (canUseTextInputEvent) {
469 + chars = getNativeBeforeInputChars(topLevelType, nativeEvent);
470 + } else {
471 + chars = getFallbackBeforeInputChars(topLevelType, nativeEvent);
472 + }
473 +
474 + // If no characters are being inserted, no BeforeInput event should
475 + // be fired.
476 + if (!chars) {
477 + return null;
478 + }
479 +
480 + var event = SyntheticInputEvent.getPooled(eventTypes.beforeInput, targetInst, nativeEvent, nativeEventTarget);
481 +
482 + event.data = chars;
483 + EventPropagators.accumulateTwoPhaseDispatches(event);
484 + return event;
485 +}
486 +
487 +/**
488 + * Create an `onBeforeInput` event to match
489 + * http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105/#events-inputevents.
490 + *
491 + * This event plugin is based on the native `textInput` event
492 + * available in Chrome, Safari, Opera, and IE. This event fires after
493 + * `onKeyPress` and `onCompositionEnd`, but before `onInput`.
494 + *
495 + * `beforeInput` is spec'd but not implemented in any browsers, and
496 + * the `input` event does not provide any useful information about what has
497 + * actually been added, contrary to the spec. Thus, `textInput` is the best
498 + * available event to identify the characters that have actually been inserted
499 + * into the target node.
500 + *
501 + * This plugin is also responsible for emitting `composition` events, thus
502 + * allowing us to share composition fallback code for both `beforeInput` and
503 + * `composition` event types.
504 + */
505 +var BeforeInputEventPlugin = {
506 +
507 + eventTypes: eventTypes,
508 +
509 + extractEvents: function (topLevelType, targetInst, nativeEvent, nativeEventTarget) {
510 + return [extractCompositionEvent(topLevelType, targetInst, nativeEvent, nativeEventTarget), extractBeforeInputEvent(topLevelType, targetInst, nativeEvent, nativeEventTarget)];
511 + }
512 +};
513 +
514 +module.exports = BeforeInputEventPlugin;
515 +},{"143":143,"20":20,"21":21,"94":94,"98":98}],4:[function(_dereq_,module,exports){
516 +/**
517 + * Copyright 2013-present, Facebook, Inc.
518 + * All rights reserved.
519 + *
520 + * This source code is licensed under the BSD-style license found in the
521 + * LICENSE file in the root directory of this source tree. An additional grant
522 + * of patent rights can be found in the PATENTS file in the same directory.
523 + *
524 + */
525 +
526 +'use strict';
527 +
528 +/**
529 + * CSS properties which accept numbers but are not in units of "px".
530 + */
531 +
532 +var isUnitlessNumber = {
533 + animationIterationCount: true,
534 + borderImageOutset: true,
535 + borderImageSlice: true,
536 + borderImageWidth: true,
537 + boxFlex: true,
538 + boxFlexGroup: true,
539 + boxOrdinalGroup: true,
540 + columnCount: true,
541 + flex: true,
542 + flexGrow: true,
543 + flexPositive: true,
544 + flexShrink: true,
545 + flexNegative: true,
546 + flexOrder: true,
547 + gridRow: true,
548 + gridColumn: true,
549 + fontWeight: true,
550 + lineClamp: true,
551 + lineHeight: true,
552 + opacity: true,
553 + order: true,
554 + orphans: true,
555 + tabSize: true,
556 + widows: true,
557 + zIndex: true,
558 + zoom: true,
559 +
560 + // SVG-related properties
561 + fillOpacity: true,
562 + floodOpacity: true,
563 + stopOpacity: true,
564 + strokeDasharray: true,
565 + strokeDashoffset: true,
566 + strokeMiterlimit: true,
567 + strokeOpacity: true,
568 + strokeWidth: true
569 +};
570 +
571 +/**
572 + * @param {string} prefix vendor-specific prefix, eg: Webkit
573 + * @param {string} key style name, eg: transitionDuration
574 + * @return {string} style name prefixed with `prefix`, properly camelCased, eg:
575 + * WebkitTransitionDuration
576 + */
577 +function prefixKey(prefix, key) {
578 + return prefix + key.charAt(0).toUpperCase() + key.substring(1);
579 +}
580 +
581 +/**
582 + * Support style names that may come passed in prefixed by adding permutations
583 + * of vendor prefixes.
584 + */
585 +var prefixes = ['Webkit', 'ms', 'Moz', 'O'];
586 +
587 +// Using Object.keys here, or else the vanilla for-in loop makes IE8 go into an
588 +// infinite loop, because it iterates over the newly added props too.
589 +Object.keys(isUnitlessNumber).forEach(function (prop) {
590 + prefixes.forEach(function (prefix) {
591 + isUnitlessNumber[prefixKey(prefix, prop)] = isUnitlessNumber[prop];
592 + });
593 +});
594 +
595 +/**
596 + * Most style properties can be unset by doing .style[prop] = '' but IE8
597 + * doesn't like doing that with shorthand properties so for the properties that
598 + * IE8 breaks on, which are listed here, we instead unset each of the
599 + * individual properties. See http://bugs.jquery.com/ticket/12385.
600 + * The 4-value 'clock' properties like margin, padding, border-width seem to
601 + * behave without any problems. Curiously, list-style works too without any
602 + * special prodding.
603 + */
604 +var shorthandPropertyExpansions = {
605 + background: {
606 + backgroundAttachment: true,
607 + backgroundColor: true,
608 + backgroundImage: true,
609 + backgroundPositionX: true,
610 + backgroundPositionY: true,
611 + backgroundRepeat: true
612 + },
613 + backgroundPosition: {
614 + backgroundPositionX: true,
615 + backgroundPositionY: true
616 + },
617 + border: {
618 + borderWidth: true,
619 + borderStyle: true,
620 + borderColor: true
621 + },
622 + borderBottom: {
623 + borderBottomWidth: true,
624 + borderBottomStyle: true,
625 + borderBottomColor: true
626 + },
627 + borderLeft: {
628 + borderLeftWidth: true,
629 + borderLeftStyle: true,
630 + borderLeftColor: true
631 + },
632 + borderRight: {
633 + borderRightWidth: true,
634 + borderRightStyle: true,
635 + borderRightColor: true
636 + },
637 + borderTop: {
638 + borderTopWidth: true,
639 + borderTopStyle: true,
640 + borderTopColor: true
641 + },
642 + font: {
643 + fontStyle: true,
644 + fontVariant: true,
645 + fontWeight: true,
646 + fontSize: true,
647 + lineHeight: true,
648 + fontFamily: true
649 + },
650 + outline: {
651 + outlineWidth: true,
652 + outlineStyle: true,
653 + outlineColor: true
654 + }
655 +};
656 +
657 +var CSSProperty = {
658 + isUnitlessNumber: isUnitlessNumber,
659 + shorthandPropertyExpansions: shorthandPropertyExpansions
660 +};
661 +
662 +module.exports = CSSProperty;
663 +},{}],5:[function(_dereq_,module,exports){
664 +/**
665 + * Copyright 2013-present, Facebook, Inc.
666 + * All rights reserved.
667 + *
668 + * This source code is licensed under the BSD-style license found in the
669 + * LICENSE file in the root directory of this source tree. An additional grant
670 + * of patent rights can be found in the PATENTS file in the same directory.
671 + *
672 + */
673 +
674 +'use strict';
675 +
676 +var CSSProperty = _dereq_(4);
677 +var ExecutionEnvironment = _dereq_(143);
678 +
679 +var camelizeStyleName = _dereq_(145);
680 +var dangerousStyleValue = _dereq_(111);
681 +var getComponentName = _dereq_(116);
682 +var hyphenateStyleName = _dereq_(156);
683 +var memoizeStringOnly = _dereq_(160);
684 +var warning = _dereq_(164);
685 +
686 +if ("development" !== 'production') {
687 + var _require = _dereq_(52),
688 + getCurrentFiberOwnerName = _require.getCurrentFiberOwnerName;
689 +}
690 +
691 +var processStyleName = memoizeStringOnly(function (styleName) {
692 + return hyphenateStyleName(styleName);
693 +});
694 +
695 +var hasShorthandPropertyBug = false;
696 +var styleFloatAccessor = 'cssFloat';
697 +if (ExecutionEnvironment.canUseDOM) {
698 + var tempStyle = document.createElement('div').style;
699 + try {
700 + // IE8 throws "Invalid argument." if resetting shorthand style properties.
701 + tempStyle.font = '';
702 + } catch (e) {
703 + hasShorthandPropertyBug = true;
704 + }
705 + // IE8 only supports accessing cssFloat (standard) as styleFloat
706 + if (document.documentElement.style.cssFloat === undefined) {
707 + styleFloatAccessor = 'styleFloat';
708 + }
709 +}
710 +
711 +if ("development" !== 'production') {
712 + // 'msTransform' is correct, but the other prefixes should be capitalized
713 + var badVendoredStyleNamePattern = /^(?:webkit|moz|o)[A-Z]/;
714 +
715 + // style values shouldn't contain a semicolon
716 + var badStyleValueWithSemicolonPattern = /;\s*$/;
717 +
718 + var warnedStyleNames = {};
719 + var warnedStyleValues = {};
720 + var warnedForNaNValue = false;
721 +
722 + var warnHyphenatedStyleName = function (name, owner) {
723 + if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {
724 + return;
725 + }
726 +
727 + warnedStyleNames[name] = true;
728 + "development" !== 'production' ? warning(false, 'Unsupported style property %s. Did you mean %s?%s', name, camelizeStyleName(name), checkRenderMessage(owner)) : void 0;
729 + };
730 +
731 + var warnBadVendoredStyleName = function (name, owner) {
732 + if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {
733 + return;
734 + }
735 +
736 + warnedStyleNames[name] = true;
737 + "development" !== 'production' ? warning(false, 'Unsupported vendor-prefixed style property %s. Did you mean %s?%s', name, name.charAt(0).toUpperCase() + name.slice(1), checkRenderMessage(owner)) : void 0;
738 + };
739 +
740 + var warnStyleValueWithSemicolon = function (name, value, owner) {
741 + if (warnedStyleValues.hasOwnProperty(value) && warnedStyleValues[value]) {
742 + return;
743 + }
744 +
745 + warnedStyleValues[value] = true;
746 + "development" !== 'production' ? warning(false, 'Style property values shouldn\'t contain a semicolon.%s ' + 'Try "%s: %s" instead.', checkRenderMessage(owner), name, value.replace(badStyleValueWithSemicolonPattern, '')) : void 0;
747 + };
748 +
749 + var warnStyleValueIsNaN = function (name, value, owner) {
750 + if (warnedForNaNValue) {
751 + return;
752 + }
753 +
754 + warnedForNaNValue = true;
755 + "development" !== 'production' ? warning(false, '`NaN` is an invalid value for the `%s` css style property.%s', name, checkRenderMessage(owner)) : void 0;
756 + };
757 +
758 + var checkRenderMessage = function (owner) {
759 + var ownerName;
760 + if (owner != null) {
761 + // Stack passes the owner manually all the way to CSSPropertyOperations.
762 + ownerName = getComponentName(owner);
763 + } else {
764 + // Fiber doesn't pass it but uses ReactDebugCurrentFiber to track it.
765 + // It is only enabled in development and tracks host components too.
766 + ownerName = getCurrentFiberOwnerName();
767 + // TODO: also report the stack.
768 + }
769 + if (ownerName) {
770 + return ' Check the render method of `' + ownerName + '`.';
771 + }
772 + return '';
773 + };
774 +
775 + /**
776 + * @param {string} name
777 + * @param {*} value
778 + * @param {ReactDOMComponent} component
779 + */
780 + var warnValidStyle = function (name, value, component) {
781 + var owner;
782 + if (component) {
783 + owner = component._currentElement._owner;
784 + }
785 + if (name.indexOf('-') > -1) {
786 + warnHyphenatedStyleName(name, owner);
787 + } else if (badVendoredStyleNamePattern.test(name)) {
788 + warnBadVendoredStyleName(name, owner);
789 + } else if (badStyleValueWithSemicolonPattern.test(value)) {
790 + warnStyleValueWithSemicolon(name, value, owner);
791 + }
792 +
793 + if (typeof value === 'number' && isNaN(value)) {
794 + warnStyleValueIsNaN(name, value, owner);
795 + }
796 + };
797 +}
798 +
799 +/**
800 + * Operations for dealing with CSS properties.
801 + */
802 +var CSSPropertyOperations = {
803 +
804 + /**
805 + * Serializes a mapping of style properties for use as inline styles:
806 + *
807 + * > createMarkupForStyles({width: '200px', height: 0})
808 + * "width:200px;height:0;"
809 + *
810 + * Undefined values are ignored so that declarative programming is easier.
811 + * The result should be HTML-escaped before insertion into the DOM.
812 + *
813 + * @param {object} styles
814 + * @param {ReactDOMComponent} component
815 + * @return {?string}
816 + */
817 + createMarkupForStyles: function (styles, component) {
818 + var serialized = '';
819 + for (var styleName in styles) {
820 + if (!styles.hasOwnProperty(styleName)) {
821 + continue;
822 + }
823 + var styleValue = styles[styleName];
824 + if ("development" !== 'production') {
825 + warnValidStyle(styleName, styleValue, component);
826 + }
827 + if (styleValue != null) {
828 + serialized += processStyleName(styleName) + ':';
829 + serialized += dangerousStyleValue(styleName, styleValue, component) + ';';
830 + }
831 + }
832 + return serialized || null;
833 + },
834 +
835 + /**
836 + * Sets the value for multiple styles on a node. If a value is specified as
837 + * '' (empty string), the corresponding style property will be unset.
838 + *
839 + * @param {DOMElement} node
840 + * @param {object} styles
841 + * @param {ReactDOMComponent} component
842 + */
843 + setValueForStyles: function (node, styles, component) {
844 + var style = node.style;
845 + for (var styleName in styles) {
846 + if (!styles.hasOwnProperty(styleName)) {
847 + continue;
848 + }
849 + if ("development" !== 'production') {
850 + warnValidStyle(styleName, styles[styleName], component);
851 + }
852 + var styleValue = dangerousStyleValue(styleName, styles[styleName], component);
853 + if (styleName === 'float' || styleName === 'cssFloat') {
854 + styleName = styleFloatAccessor;
855 + }
856 + if (styleValue) {
857 + style[styleName] = styleValue;
858 + } else {
859 + var expansion = hasShorthandPropertyBug && CSSProperty.shorthandPropertyExpansions[styleName];
860 + if (expansion) {
861 + // Shorthand property that IE8 won't like unsetting, so unset each
862 + // component to placate it
863 + for (var individualStyleName in expansion) {
864 + style[individualStyleName] = '';
865 + }
866 + } else {
867 + style[styleName] = '';
868 + }
869 + }
870 + }
871 + }
872 +
873 +};
874 +
875 +module.exports = CSSPropertyOperations;
876 +},{"111":111,"116":116,"143":143,"145":145,"156":156,"160":160,"164":164,"4":4,"52":52}],6:[function(_dereq_,module,exports){
877 +/**
878 + * Copyright 2013-present, Facebook, Inc.
879 + * All rights reserved.
880 + *
881 + * This source code is licensed under the BSD-style license found in the
882 + * LICENSE file in the root directory of this source tree. An additional grant
883 + * of patent rights can be found in the PATENTS file in the same directory.
884 + *
885 + *
886 + */
887 +
888 +'use strict';
889 +
890 +var _prodInvariant = _dereq_(133);
891 +
892 +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
893 +
894 +var PooledClass = _dereq_(24);
895 +
896 +var invariant = _dereq_(157);
897 +
898 +/**
899 + * A specialized pseudo-event module to help keep track of components waiting to
900 + * be notified when their DOM representations are available for use.
901 + *
902 + * This implements `PooledClass`, so you should never need to instantiate this.
903 + * Instead, use `CallbackQueue.getPooled()`.
904 + *
905 + * @class ReactMountReady
906 + * @implements PooledClass
907 + * @internal
908 + */
909 +
910 +var CallbackQueue = function () {
911 + function CallbackQueue(arg) {
912 + _classCallCheck(this, CallbackQueue);
913 +
914 + this._callbacks = null;
915 + this._contexts = null;
916 + this._arg = arg;
917 + }
918 +
919 + /**
920 + * Enqueues a callback to be invoked when `notifyAll` is invoked.
921 + *
922 + * @param {function} callback Invoked when `notifyAll` is invoked.
923 + * @param {?object} context Context to call `callback` with.
924 + * @internal
925 + */
926 +
927 +
928 + CallbackQueue.prototype.enqueue = function enqueue(callback, context) {
929 + this._callbacks = this._callbacks || [];
930 + this._callbacks.push(callback);
931 + this._contexts = this._contexts || [];
932 + this._contexts.push(context);
933 + };
934 +
935 + /**
936 + * Invokes all enqueued callbacks and clears the queue. This is invoked after
937 + * the DOM representation of a component has been created or updated.
938 + *
939 + * @internal
940 + */
941 +
942 +
943 + CallbackQueue.prototype.notifyAll = function notifyAll() {
944 + var callbacks = this._callbacks;
945 + var contexts = this._contexts;
946 + var arg = this._arg;
947 + if (callbacks && contexts) {
948 + !(callbacks.length === contexts.length) ? "development" !== 'production' ? invariant(false, 'Mismatched list of contexts in callback queue') : _prodInvariant('24') : void 0;
949 + this._callbacks = null;
950 + this._contexts = null;
951 + for (var i = 0; i < callbacks.length; i++) {
952 + callbacks[i].call(contexts[i], arg);
953 + }
954 + callbacks.length = 0;
955 + contexts.length = 0;
956 + }
957 + };
958 +
959 + CallbackQueue.prototype.checkpoint = function checkpoint() {
960 + return this._callbacks ? this._callbacks.length : 0;
961 + };
962 +
963 + CallbackQueue.prototype.rollback = function rollback(len) {
964 + if (this._callbacks && this._contexts) {
965 + this._callbacks.length = len;
966 + this._contexts.length = len;
967 + }
968 + };
969 +
970 + /**
971 + * Resets the internal queue.
972 + *
973 + * @internal
974 + */
975 +
976 +
977 + CallbackQueue.prototype.reset = function reset() {
978 + this._callbacks = null;
979 + this._contexts = null;
980 + };
981 +
982 + /**
983 + * `PooledClass` looks for this.
984 + */
985 +
986 +
987 + CallbackQueue.prototype.destructor = function destructor() {
988 + this.reset();
989 + };
990 +
991 + return CallbackQueue;
992 +}();
993 +
994 +module.exports = PooledClass.addPoolingTo(CallbackQueue);
995 +},{"133":133,"157":157,"24":24}],7:[function(_dereq_,module,exports){
996 +/**
997 + * Copyright 2013-present, Facebook, Inc.
998 + * All rights reserved.
999 + *
1000 + * This source code is licensed under the BSD-style license found in the
1001 + * LICENSE file in the root directory of this source tree. An additional grant
1002 + * of patent rights can be found in the PATENTS file in the same directory.
1003 + *
1004 + */
1005 +
1006 +'use strict';
1007 +
1008 +var EventPluginHub = _dereq_(17);
1009 +var EventPropagators = _dereq_(20);
1010 +var ExecutionEnvironment = _dereq_(143);
1011 +var ReactControlledComponent = _dereq_(30);
1012 +var ReactDOMComponentTree = _dereq_(35);
1013 +var ReactGenericBatching = _dereq_(62);
1014 +var SyntheticEvent = _dereq_(96);
1015 +
1016 +var inputValueTracking = _dereq_(128);
1017 +var getEventTarget = _dereq_(121);
1018 +var isEventSupported = _dereq_(130);
1019 +var isTextInputElement = _dereq_(131);
1020 +
1021 +var eventTypes = {
1022 + change: {
1023 + phasedRegistrationNames: {
1024 + bubbled: 'onChange',
1025 + captured: 'onChangeCapture'
1026 + },
1027 + dependencies: ['topBlur', 'topChange', 'topClick', 'topFocus', 'topInput', 'topKeyDown', 'topKeyUp', 'topSelectionChange']
1028 + }
1029 +};
1030 +
1031 +function createAndAccumulateChangeEvent(inst, nativeEvent, target) {
1032 + var event = SyntheticEvent.getPooled(eventTypes.change, inst, nativeEvent, target);
1033 + event.type = 'change';
1034 + // Flag this event loop as needing state restore.
1035 + ReactControlledComponent.enqueueStateRestore(target);
1036 + EventPropagators.accumulateTwoPhaseDispatches(event);
1037 + return event;
1038 +}
1039 +/**
1040 + * For IE shims
1041 + */
1042 +var activeElement = null;
1043 +var activeElementInst = null;
1044 +
1045 +/**
1046 + * SECTION: handle `change` event
1047 + */
1048 +function shouldUseChangeEvent(elem) {
1049 + var nodeName = elem.nodeName && elem.nodeName.toLowerCase();
1050 + return nodeName === 'select' || nodeName === 'input' && elem.type === 'file';
1051 +}
1052 +
1053 +var doesChangeEventBubble = false;
1054 +if (ExecutionEnvironment.canUseDOM) {
1055 + // See `handleChange` comment below
1056 + doesChangeEventBubble = isEventSupported('change') && (!document.documentMode || document.documentMode > 8);
1057 +}
1058 +
1059 +function manualDispatchChangeEvent(nativeEvent) {
1060 + var event = createAndAccumulateChangeEvent(activeElementInst, nativeEvent, getEventTarget(nativeEvent));
1061 +
1062 + // If change and propertychange bubbled, we'd just bind to it like all the
1063 + // other events and have it go through ReactBrowserEventEmitter. Since it
1064 + // doesn't, we manually listen for the events and so we have to enqueue and
1065 + // process the abstract event manually.
1066 + //
1067 + // Batching is necessary here in order to ensure that all event handlers run
1068 + // before the next rerender (including event handlers attached to ancestor
1069 + // elements instead of directly on the input). Without this, controlled
1070 + // components don't work properly in conjunction with event bubbling because
1071 + // the component is rerendered and the value reverted before all the event
1072 + // handlers can run. See https://github.com/facebook/react/issues/708.
1073 + ReactGenericBatching.batchedUpdates(runEventInBatch, event);
1074 +}
1075 +
1076 +function runEventInBatch(event) {
1077 + EventPluginHub.enqueueEvents(event);
1078 + EventPluginHub.processEventQueue(false);
1079 +}
1080 +
1081 +function startWatchingForChangeEventIE8(target, targetInst) {
1082 + activeElement = target;
1083 + activeElementInst = targetInst;
1084 + activeElement.attachEvent('onchange', manualDispatchChangeEvent);
1085 +}
1086 +
1087 +function stopWatchingForChangeEventIE8() {
1088 + if (!activeElement) {
1089 + return;
1090 + }
1091 + activeElement.detachEvent('onchange', manualDispatchChangeEvent);
1092 + activeElement = null;
1093 + activeElementInst = null;
1094 +}
1095 +
1096 +function getInstIfValueChanged(targetInst) {
1097 + if (inputValueTracking.updateValueIfChanged(targetInst)) {
1098 + return targetInst;
1099 + }
1100 +}
1101 +
1102 +function getTargetInstForChangeEvent(topLevelType, targetInst) {
1103 + if (topLevelType === 'topChange') {
1104 + return targetInst;
1105 + }
1106 +}
1107 +
1108 +function handleEventsForChangeEventIE8(topLevelType, target, targetInst) {
1109 + if (topLevelType === 'topFocus') {
1110 + // stopWatching() should be a noop here but we call it just in case we
1111 + // missed a blur event somehow.
1112 + stopWatchingForChangeEventIE8();
1113 + startWatchingForChangeEventIE8(target, targetInst);
1114 + } else if (topLevelType === 'topBlur') {
1115 + stopWatchingForChangeEventIE8();
1116 + }
1117 +}
1118 +
1119 +/**
1120 + * SECTION: handle `input` event
1121 + */
1122 +var isInputEventSupported = false;
1123 +if (ExecutionEnvironment.canUseDOM) {
1124 + // IE9 claims to support the input event but fails to trigger it when
1125 + // deleting text, so we ignore its input events.
1126 + isInputEventSupported = isEventSupported('input') && (!document.documentMode || document.documentMode > 9);
1127 +}
1128 +
1129 +/**
1130 + * (For IE <=9) Starts tracking propertychange events on the passed-in element
1131 + * and override the value property so that we can distinguish user events from
1132 + * value changes in JS.
1133 + */
1134 +function startWatchingForValueChange(target, targetInst) {
1135 + activeElement = target;
1136 + activeElementInst = targetInst;
1137 + activeElement.attachEvent('onpropertychange', handlePropertyChange);
1138 +}
1139 +
1140 +/**
1141 + * (For IE <=9) Removes the event listeners from the currently-tracked element,
1142 + * if any exists.
1143 + */
1144 +function stopWatchingForValueChange() {
1145 + if (!activeElement) {
1146 + return;
1147 + }
1148 + activeElement.detachEvent('onpropertychange', handlePropertyChange);
1149 + activeElement = null;
1150 + activeElementInst = null;
1151 +}
1152 +
1153 +/**
1154 + * (For IE <=9) Handles a propertychange event, sending a `change` event if
1155 + * the value of the active element has changed.
1156 + */
1157 +function handlePropertyChange(nativeEvent) {
1158 + if (nativeEvent.propertyName !== 'value') {
1159 + return;
1160 + }
1161 + if (getInstIfValueChanged(activeElementInst)) {
1162 + manualDispatchChangeEvent(nativeEvent);
1163 + }
1164 +}
1165 +
1166 +function handleEventsForInputEventPolyfill(topLevelType, target, targetInst) {
1167 + if (topLevelType === 'topFocus') {
1168 + // In IE8, we can capture almost all .value changes by adding a
1169 + // propertychange handler and looking for events with propertyName
1170 + // equal to 'value'
1171 + // In IE9, propertychange fires for most input events but is buggy and
1172 + // doesn't fire when text is deleted, but conveniently, selectionchange
1173 + // appears to fire in all of the remaining cases so we catch those and
1174 + // forward the event if the value has changed
1175 + // In either case, we don't want to call the event handler if the value
1176 + // is changed from JS so we redefine a setter for `.value` that updates
1177 + // our activeElementValue variable, allowing us to ignore those changes
1178 + //
1179 + // stopWatching() should be a noop here but we call it just in case we
1180 + // missed a blur event somehow.
1181 + stopWatchingForValueChange();
1182 + startWatchingForValueChange(target, targetInst);
1183 + } else if (topLevelType === 'topBlur') {
1184 + stopWatchingForValueChange();
1185 + }
1186 +}
1187 +
1188 +// For IE8 and IE9.
1189 +function getTargetInstForInputEventPolyfill(topLevelType, targetInst) {
1190 + if (topLevelType === 'topSelectionChange' || topLevelType === 'topKeyUp' || topLevelType === 'topKeyDown') {
1191 + // On the selectionchange event, the target is just document which isn't
1192 + // helpful for us so just check activeElement instead.
1193 + //
1194 + // 99% of the time, keydown and keyup aren't necessary. IE8 fails to fire
1195 + // propertychange on the first input event after setting `value` from a
1196 + // script and fires only keydown, keypress, keyup. Catching keyup usually
1197 + // gets it and catching keydown lets us fire an event for the first
1198 + // keystroke if user does a key repeat (it'll be a little delayed: right
1199 + // before the second keystroke). Other input methods (e.g., paste) seem to
1200 + // fire selectionchange normally.
1201 + return getInstIfValueChanged(activeElementInst);
1202 + }
1203 +}
1204 +
1205 +/**
1206 + * SECTION: handle `click` event
1207 + */
1208 +function shouldUseClickEvent(elem) {
1209 + // Use the `click` event to detect changes to checkbox and radio inputs.
1210 + // This approach works across all browsers, whereas `change` does not fire
1211 + // until `blur` in IE8.
1212 + var nodeName = elem.nodeName;
1213 + return nodeName && nodeName.toLowerCase() === 'input' && (elem.type === 'checkbox' || elem.type === 'radio');
1214 +}
1215 +
1216 +function getTargetInstForClickEvent(topLevelType, targetInst) {
1217 + if (topLevelType === 'topClick') {
1218 + return getInstIfValueChanged(targetInst);
1219 + }
1220 +}
1221 +
1222 +function getTargetInstForInputOrChangeEvent(topLevelType, targetInst) {
1223 + if (topLevelType === 'topInput' || topLevelType === 'topChange') {
1224 + return getInstIfValueChanged(targetInst);
1225 + }
1226 +}
1227 +
1228 +function handleControlledInputBlur(inst, node) {
1229 + // Fiber and ReactDOM keep wrapper state in separate places
1230 + var state = inst._wrapperState || node._wrapperState;
1231 +
1232 + if (!state || !state.controlled || node.type !== 'number') {
1233 + return;
1234 + }
1235 +
1236 + // If controlled, assign the value attribute to the current value on blur
1237 + var value = '' + node.value;
1238 + if (node.getAttribute('value') !== value) {
1239 + node.setAttribute('value', value);
1240 + }
1241 +}
1242 +
1243 +/**
1244 + * This plugin creates an `onChange` event that normalizes change events
1245 + * across form elements. This event fires at a time when it's possible to
1246 + * change the element's value without seeing a flicker.
1247 + *
1248 + * Supported elements are:
1249 + * - input (see `isTextInputElement`)
1250 + * - textarea
1251 + * - select
1252 + */
1253 +var ChangeEventPlugin = {
1254 +
1255 + eventTypes: eventTypes,
1256 +
1257 + _isInputEventSupported: isInputEventSupported,
1258 +
1259 + extractEvents: function (topLevelType, targetInst, nativeEvent, nativeEventTarget) {
1260 + var targetNode = targetInst ? ReactDOMComponentTree.getNodeFromInstance(targetInst) : window;
1261 +
1262 + var getTargetInstFunc, handleEventFunc;
1263 + if (shouldUseChangeEvent(targetNode)) {
1264 + if (doesChangeEventBubble) {
1265 + getTargetInstFunc = getTargetInstForChangeEvent;
1266 + } else {
1267 + handleEventFunc = handleEventsForChangeEventIE8;
1268 + }
1269 + } else if (isTextInputElement(targetNode)) {
1270 + if (isInputEventSupported) {
1271 + getTargetInstFunc = getTargetInstForInputOrChangeEvent;
1272 + } else {
1273 + getTargetInstFunc = getTargetInstForInputEventPolyfill;
1274 + handleEventFunc = handleEventsForInputEventPolyfill;
1275 + }
1276 + } else if (shouldUseClickEvent(targetNode)) {
1277 + getTargetInstFunc = getTargetInstForClickEvent;
1278 + }
1279 +
1280 + if (getTargetInstFunc) {
1281 + var inst = getTargetInstFunc(topLevelType, targetInst);
1282 + if (inst) {
1283 + var event = createAndAccumulateChangeEvent(inst, nativeEvent, nativeEventTarget);
1284 + return event;
1285 + }
1286 + }
1287 +
1288 + if (handleEventFunc) {
1289 + handleEventFunc(topLevelType, targetNode, targetInst);
1290 + }
1291 +
1292 + // When blurring, set the value attribute for number inputs
1293 + if (topLevelType === 'topBlur') {
1294 + handleControlledInputBlur(targetInst, targetNode);
1295 + }
1296 + }
1297 +
1298 +};
1299 +
1300 +module.exports = ChangeEventPlugin;
1301 +},{"121":121,"128":128,"130":130,"131":131,"143":143,"17":17,"20":20,"30":30,"35":35,"62":62,"96":96}],8:[function(_dereq_,module,exports){
1302 +/**
1303 + * Copyright 2013-present, Facebook, Inc.
1304 + * All rights reserved.
1305 + *
1306 + * This source code is licensed under the BSD-style license found in the
1307 + * LICENSE file in the root directory of this source tree. An additional grant
1308 + * of patent rights can be found in the PATENTS file in the same directory.
1309 + *
1310 + */
1311 +
1312 +'use strict';
1313 +
1314 +var DOMLazyTree = _dereq_(10);
1315 +var Danger = _dereq_(14);
1316 +var ReactDOMComponentTree = _dereq_(35);
1317 +var ReactInstrumentation = _dereq_(67);
1318 +
1319 +var createMicrosoftUnsafeLocalFunction = _dereq_(110);
1320 +var setInnerHTML = _dereq_(134);
1321 +var setTextContent = _dereq_(135);
1322 +
1323 +function getNodeAfter(parentNode, node) {
1324 + // Special case for text components, which return [open, close] comments
1325 + // from getHostNode.
1326 + if (Array.isArray(node)) {
1327 + node = node[1];
1328 + }
1329 + return node ? node.nextSibling : parentNode.firstChild;
1330 +}
1331 +
1332 +/**
1333 + * Inserts `childNode` as a child of `parentNode` at the `index`.
1334 + *
1335 + * @param {DOMElement} parentNode Parent node in which to insert.
1336 + * @param {DOMElement} childNode Child node to insert.
1337 + * @param {number} index Index at which to insert the child.
1338 + * @internal
1339 + */
1340 +var insertChildAt = createMicrosoftUnsafeLocalFunction(function (parentNode, childNode, referenceNode) {
1341 + // We rely exclusively on `insertBefore(node, null)` instead of also using
1342 + // `appendChild(node)`. (Using `undefined` is not allowed by all browsers so
1343 + // we are careful to use `null`.)
1344 + parentNode.insertBefore(childNode, referenceNode);
1345 +});
1346 +
1347 +function insertLazyTreeChildAt(parentNode, childTree, referenceNode) {
1348 + DOMLazyTree.insertTreeBefore(parentNode, childTree, referenceNode);
1349 +}
1350 +
1351 +function moveChild(parentNode, childNode, referenceNode) {
1352 + if (Array.isArray(childNode)) {
1353 + moveDelimitedText(parentNode, childNode[0], childNode[1], referenceNode);
1354 + } else {
1355 + insertChildAt(parentNode, childNode, referenceNode);
1356 + }
1357 +}
1358 +
1359 +function removeChild(parentNode, childNode) {
1360 + if (Array.isArray(childNode)) {
1361 + var closingComment = childNode[1];
1362 + childNode = childNode[0];
1363 + removeDelimitedText(parentNode, childNode, closingComment);
1364 + parentNode.removeChild(closingComment);
1365 + }
1366 + parentNode.removeChild(childNode);
1367 +}
1368 +
1369 +function moveDelimitedText(parentNode, openingComment, closingComment, referenceNode) {
1370 + var node = openingComment;
1371 + while (true) {
1372 + var nextNode = node.nextSibling;
1373 + insertChildAt(parentNode, node, referenceNode);
1374 + if (node === closingComment) {
1375 + break;
1376 + }
1377 + node = nextNode;
1378 + }
1379 +}
1380 +
1381 +function removeDelimitedText(parentNode, startNode, closingComment) {
1382 + while (true) {
1383 + var node = startNode.nextSibling;
1384 + if (node === closingComment) {
1385 + // The closing comment is removed by ReactMultiChild.
1386 + break;
1387 + } else {
1388 + parentNode.removeChild(node);
1389 + }
1390 + }
1391 +}
1392 +
1393 +function replaceDelimitedText(openingComment, closingComment, stringText) {
1394 + var parentNode = openingComment.parentNode;
1395 + var nodeAfterComment = openingComment.nextSibling;
1396 + if (nodeAfterComment === closingComment) {
1397 + // There are no text nodes between the opening and closing comments; insert
1398 + // a new one if stringText isn't empty.
1399 + if (stringText) {
1400 + insertChildAt(parentNode, document.createTextNode(stringText), nodeAfterComment);
1401 + }
1402 + } else {
1403 + if (stringText) {
1404 + // Set the text content of the first node after the opening comment, and
1405 + // remove all following nodes up until the closing comment.
1406 + setTextContent(nodeAfterComment, stringText);
1407 + removeDelimitedText(parentNode, nodeAfterComment, closingComment);
1408 + } else {
1409 + removeDelimitedText(parentNode, openingComment, closingComment);
1410 + }
1411 + }
1412 +
1413 + if ("development" !== 'production') {
1414 + ReactInstrumentation.debugTool.onHostOperation({
1415 + instanceID: ReactDOMComponentTree.getInstanceFromNode(openingComment)._debugID,
1416 + type: 'replace text',
1417 + payload: stringText
1418 + });
1419 + }
1420 +}
1421 +
1422 +var dangerouslyReplaceNodeWithMarkup = Danger.dangerouslyReplaceNodeWithMarkup;
1423 +if ("development" !== 'production') {
1424 + dangerouslyReplaceNodeWithMarkup = function (oldChild, markup, prevInstance) {
1425 + Danger.dangerouslyReplaceNodeWithMarkup(oldChild, markup);
1426 + if (prevInstance._debugID !== 0) {
1427 + ReactInstrumentation.debugTool.onHostOperation({
1428 + instanceID: prevInstance._debugID,
1429 + type: 'replace with',
1430 + payload: markup.toString()
1431 + });
1432 + } else {
1433 + var nextInstance = ReactDOMComponentTree.getInstanceFromNode(markup.node);
1434 + if (nextInstance._debugID !== 0) {
1435 + ReactInstrumentation.debugTool.onHostOperation({
1436 + instanceID: nextInstance._debugID,
1437 + type: 'mount',
1438 + payload: markup.toString()
1439 + });
1440 + }
1441 + }
1442 + };
1443 +}
1444 +
1445 +/**
1446 + * Operations for updating with DOM children.
1447 + */
1448 +var DOMChildrenOperations = {
1449 +
1450 + dangerouslyReplaceNodeWithMarkup: dangerouslyReplaceNodeWithMarkup,
1451 +
1452 + replaceDelimitedText: replaceDelimitedText,
1453 +
1454 + /**
1455 + * Updates a component's children by processing a series of updates. The
1456 + * update configurations are each expected to have a `parentNode` property.
1457 + *
1458 + * @param {array<object>} updates List of update configurations.
1459 + * @internal
1460 + */
1461 + processUpdates: function (parentNode, updates) {
1462 + if ("development" !== 'production') {
1463 + var parentNodeDebugID = ReactDOMComponentTree.getInstanceFromNode(parentNode)._debugID;
1464 + }
1465 +
1466 + for (var k = 0; k < updates.length; k++) {
1467 + var update = updates[k];
1468 + switch (update.type) {
1469 + case 'INSERT_MARKUP':
1470 + insertLazyTreeChildAt(parentNode, update.content, getNodeAfter(parentNode, update.afterNode));
1471 + if ("development" !== 'production') {
1472 + ReactInstrumentation.debugTool.onHostOperation({
1473 + instanceID: parentNodeDebugID,
1474 + type: 'insert child',
1475 + payload: { toIndex: update.toIndex, content: update.content.toString() }
1476 + });
1477 + }
1478 + break;
1479 + case 'MOVE_EXISTING':
1480 + moveChild(parentNode, update.fromNode, getNodeAfter(parentNode, update.afterNode));
1481 + if ("development" !== 'production') {
1482 + ReactInstrumentation.debugTool.onHostOperation({
1483 + instanceID: parentNodeDebugID,
1484 + type: 'move child',
1485 + payload: { fromIndex: update.fromIndex, toIndex: update.toIndex }
1486 + });
1487 + }
1488 + break;
1489 + case 'SET_MARKUP':
1490 + setInnerHTML(parentNode, update.content);
1491 + if ("development" !== 'production') {
1492 + ReactInstrumentation.debugTool.onHostOperation({
1493 + instanceID: parentNodeDebugID,
1494 + type: 'replace children',
1495 + payload: update.content.toString()
1496 + });
1497 + }
1498 + break;
1499 + case 'TEXT_CONTENT':
1500 + setTextContent(parentNode, update.content);
1501 + if ("development" !== 'production') {
1502 + ReactInstrumentation.debugTool.onHostOperation({
1503 + instanceID: parentNodeDebugID,
1504 + type: 'replace text',
1505 + payload: update.content.toString()
1506 + });
1507 + }
1508 + break;
1509 + case 'REMOVE_NODE':
1510 + removeChild(parentNode, update.fromNode);
1511 + if ("development" !== 'production') {
1512 + ReactInstrumentation.debugTool.onHostOperation({
1513 + instanceID: parentNodeDebugID,
1514 + type: 'remove child',
1515 + payload: { fromIndex: update.fromIndex }
1516 + });
1517 + }
1518 + break;
1519 + }
1520 + }
1521 + }
1522 +
1523 +};
1524 +
1525 +module.exports = DOMChildrenOperations;
1526 +},{"10":10,"110":110,"134":134,"135":135,"14":14,"35":35,"67":67}],9:[function(_dereq_,module,exports){
1527 +/**
1528 + * Copyright 2013-present, Facebook, Inc.
1529 + * All rights reserved.
1530 + *
1531 + * This source code is licensed under the BSD-style license found in the
1532 + * LICENSE file in the root directory of this source tree. An additional grant
1533 + * of patent rights can be found in the PATENTS file in the same directory.
1534 + *
1535 + */
1536 +
1537 +'use strict';
1538 +
1539 +/**
1540 + * Module that is injectable into `EventPluginHub`, that specifies a
1541 + * deterministic ordering of `EventPlugin`s. A convenient way to reason about
1542 + * plugins, without having to package every one of them. This is better than
1543 + * having plugins be ordered in the same order that they are injected because
1544 + * that ordering would be influenced by the packaging order.
1545 + * `ResponderEventPlugin` must occur before `SimpleEventPlugin` so that
1546 + * preventing default on events is convenient in `SimpleEventPlugin` handlers.
1547 + */
1548 +
1549 +var DOMEventPluginOrder = ['ResponderEventPlugin', 'SimpleEventPlugin', 'TapEventPlugin', 'EnterLeaveEventPlugin', 'ChangeEventPlugin', 'SelectEventPlugin', 'BeforeInputEventPlugin'];
1550 +
1551 +module.exports = DOMEventPluginOrder;
1552 +},{}],10:[function(_dereq_,module,exports){
1553 +/**
1554 + * Copyright 2015-present, Facebook, Inc.
1555 + * All rights reserved.
1556 + *
1557 + * This source code is licensed under the BSD-style license found in the
1558 + * LICENSE file in the root directory of this source tree. An additional grant
1559 + * of patent rights can be found in the PATENTS file in the same directory.
1560 + *
1561 + */
1562 +
1563 +'use strict';
1564 +
1565 +var DOMNamespaces = _dereq_(11);
1566 +var setInnerHTML = _dereq_(134);
1567 +
1568 +var createMicrosoftUnsafeLocalFunction = _dereq_(110);
1569 +var setTextContent = _dereq_(135);
1570 +
1571 +var ELEMENT_NODE_TYPE = 1;
1572 +var DOCUMENT_FRAGMENT_NODE_TYPE = 11;
1573 +
1574 +/**
1575 + * In IE (8-11) and Edge, appending nodes with no children is dramatically
1576 + * faster than appending a full subtree, so we essentially queue up the
1577 + * .appendChild calls here and apply them so each node is added to its parent
1578 + * before any children are added.
1579 + *
1580 + * In other browsers, doing so is slower or neutral compared to the other order
1581 + * (in Firefox, twice as slow) so we only do this inversion in IE.
1582 + *
1583 + * See https://github.com/spicyj/innerhtml-vs-createelement-vs-clonenode.
1584 + */
1585 +var enableLazy = typeof document !== 'undefined' && typeof document.documentMode === 'number' || typeof navigator !== 'undefined' && typeof navigator.userAgent === 'string' && /\bEdge\/\d/.test(navigator.userAgent);
1586 +
1587 +function insertTreeChildren(tree) {
1588 + if (!enableLazy) {
1589 + return;
1590 + }
1591 + var node = tree.node;
1592 + var children = tree.children;
1593 + if (children.length) {
1594 + for (var i = 0; i < children.length; i++) {
1595 + insertTreeBefore(node, children[i], null);
1596 + }
1597 + } else if (tree.html != null) {
1598 + setInnerHTML(node, tree.html);
1599 + } else if (tree.text != null) {
1600 + setTextContent(node, tree.text);
1601 + }
1602 +}
1603 +
1604 +var insertTreeBefore = createMicrosoftUnsafeLocalFunction(function (parentNode, tree, referenceNode) {
1605 + // DocumentFragments aren't actually part of the DOM after insertion so
1606 + // appending children won't update the DOM. We need to ensure the fragment
1607 + // is properly populated first, breaking out of our lazy approach for just
1608 + // this level. Also, some <object> plugins (like Flash Player) will read
1609 + // <param> nodes immediately upon insertion into the DOM, so <object>
1610 + // must also be populated prior to insertion into the DOM.
1611 + if (tree.node.nodeType === DOCUMENT_FRAGMENT_NODE_TYPE || tree.node.nodeType === ELEMENT_NODE_TYPE && tree.node.nodeName.toLowerCase() === 'object' && (tree.node.namespaceURI == null || tree.node.namespaceURI === DOMNamespaces.html)) {
1612 + insertTreeChildren(tree);
1613 + parentNode.insertBefore(tree.node, referenceNode);
1614 + } else {
1615 + parentNode.insertBefore(tree.node, referenceNode);
1616 + insertTreeChildren(tree);
1617 + }
1618 +});
1619 +
1620 +function replaceChildWithTree(oldNode, newTree) {
1621 + oldNode.parentNode.replaceChild(newTree.node, oldNode);
1622 + insertTreeChildren(newTree);
1623 +}
1624 +
1625 +function queueChild(parentTree, childTree) {
1626 + if (enableLazy) {
1627 + parentTree.children.push(childTree);
1628 + } else {
1629 + parentTree.node.appendChild(childTree.node);
1630 + }
1631 +}
1632 +
1633 +function queueHTML(tree, html) {
1634 + if (enableLazy) {
1635 + tree.html = html;
1636 + } else {
1637 + setInnerHTML(tree.node, html);
1638 + }
1639 +}
1640 +
1641 +function queueText(tree, text) {
1642 + if (enableLazy) {
1643 + tree.text = text;
1644 + } else {
1645 + setTextContent(tree.node, text);
1646 + }
1647 +}
1648 +
1649 +function toString() {
1650 + return this.node.nodeName;
1651 +}
1652 +
1653 +function DOMLazyTree(node) {
1654 + return {
1655 + node: node,
1656 + children: [],
1657 + html: null,
1658 + text: null,
1659 + toString: toString
1660 + };
1661 +}
1662 +
1663 +DOMLazyTree.insertTreeBefore = insertTreeBefore;
1664 +DOMLazyTree.replaceChildWithTree = replaceChildWithTree;
1665 +DOMLazyTree.queueChild = queueChild;
1666 +DOMLazyTree.queueHTML = queueHTML;
1667 +DOMLazyTree.queueText = queueText;
1668 +
1669 +module.exports = DOMLazyTree;
1670 +},{"11":11,"110":110,"134":134,"135":135}],11:[function(_dereq_,module,exports){
1671 +/**
1672 + * Copyright 2013-present, Facebook, Inc.
1673 + * All rights reserved.
1674 + *
1675 + * This source code is licensed under the BSD-style license found in the
1676 + * LICENSE file in the root directory of this source tree. An additional grant
1677 + * of patent rights can be found in the PATENTS file in the same directory.
1678 + *
1679 + */
1680 +
1681 +'use strict';
1682 +
1683 +var DOMNamespaces = {
1684 + html: 'http://www.w3.org/1999/xhtml',
1685 + mathml: 'http://www.w3.org/1998/Math/MathML',
1686 + svg: 'http://www.w3.org/2000/svg'
1687 +};
1688 +
1689 +module.exports = DOMNamespaces;
1690 +},{}],12:[function(_dereq_,module,exports){
1691 +/**
1692 + * Copyright 2013-present, Facebook, Inc.
1693 + * All rights reserved.
1694 + *
1695 + * This source code is licensed under the BSD-style license found in the
1696 + * LICENSE file in the root directory of this source tree. An additional grant
1697 + * of patent rights can be found in the PATENTS file in the same directory.
1698 + *
1699 + */
1700 +
1701 +'use strict';
1702 +
1703 +var _prodInvariant = _dereq_(133);
1704 +
1705 +var invariant = _dereq_(157);
1706 +
1707 +function checkMask(value, bitmask) {
1708 + return (value & bitmask) === bitmask;
1709 +}
1710 +
1711 +var DOMPropertyInjection = {
1712 + /**
1713 + * Mapping from normalized, camelcased property names to a configuration that
1714 + * specifies how the associated DOM property should be accessed or rendered.
1715 + */
1716 + MUST_USE_PROPERTY: 0x1,
1717 + HAS_BOOLEAN_VALUE: 0x4,
1718 + HAS_NUMERIC_VALUE: 0x8,
1719 + HAS_POSITIVE_NUMERIC_VALUE: 0x10 | 0x8,
1720 + HAS_OVERLOADED_BOOLEAN_VALUE: 0x20,
1721 +
1722 + /**
1723 + * Inject some specialized knowledge about the DOM. This takes a config object
1724 + * with the following properties:
1725 + *
1726 + * isCustomAttribute: function that given an attribute name will return true
1727 + * if it can be inserted into the DOM verbatim. Useful for data-* or aria-*
1728 + * attributes where it's impossible to enumerate all of the possible
1729 + * attribute names,
1730 + *
1731 + * Properties: object mapping DOM property name to one of the
1732 + * DOMPropertyInjection constants or null. If your attribute isn't in here,
1733 + * it won't get written to the DOM.
1734 + *
1735 + * DOMAttributeNames: object mapping React attribute name to the DOM
1736 + * attribute name. Attribute names not specified use the **lowercase**
1737 + * normalized name.
1738 + *
1739 + * DOMAttributeNamespaces: object mapping React attribute name to the DOM
1740 + * attribute namespace URL. (Attribute names not specified use no namespace.)
1741 + *
1742 + * DOMPropertyNames: similar to DOMAttributeNames but for DOM properties.
1743 + * Property names not specified use the normalized name.
1744 + *
1745 + * DOMMutationMethods: Properties that require special mutation methods. If
1746 + * `value` is undefined, the mutation method should unset the property.
1747 + *
1748 + * @param {object} domPropertyConfig the config as described above.
1749 + */
1750 + injectDOMPropertyConfig: function (domPropertyConfig) {
1751 + var Injection = DOMPropertyInjection;
1752 + var Properties = domPropertyConfig.Properties || {};
1753 + var DOMAttributeNamespaces = domPropertyConfig.DOMAttributeNamespaces || {};
1754 + var DOMAttributeNames = domPropertyConfig.DOMAttributeNames || {};
1755 + var DOMPropertyNames = domPropertyConfig.DOMPropertyNames || {};
1756 + var DOMMutationMethods = domPropertyConfig.DOMMutationMethods || {};
1757 +
1758 + if (domPropertyConfig.isCustomAttribute) {
1759 + DOMProperty._isCustomAttributeFunctions.push(domPropertyConfig.isCustomAttribute);
1760 + }
1761 +
1762 + for (var propName in Properties) {
1763 + !!DOMProperty.properties.hasOwnProperty(propName) ? "development" !== 'production' ? invariant(false, 'injectDOMPropertyConfig(...): You\'re trying to inject DOM property \'%s\' which has already been injected. You may be accidentally injecting the same DOM property config twice, or you may be injecting two configs that have conflicting property names.', propName) : _prodInvariant('48', propName) : void 0;
1764 +
1765 + var lowerCased = propName.toLowerCase();
1766 + var propConfig = Properties[propName];
1767 +
1768 + var propertyInfo = {
1769 + attributeName: lowerCased,
1770 + attributeNamespace: null,
1771 + propertyName: propName,
1772 + mutationMethod: null,
1773 +
1774 + mustUseProperty: checkMask(propConfig, Injection.MUST_USE_PROPERTY),
1775 + hasBooleanValue: checkMask(propConfig, Injection.HAS_BOOLEAN_VALUE),
1776 + hasNumericValue: checkMask(propConfig, Injection.HAS_NUMERIC_VALUE),
1777 + hasPositiveNumericValue: checkMask(propConfig, Injection.HAS_POSITIVE_NUMERIC_VALUE),
1778 + hasOverloadedBooleanValue: checkMask(propConfig, Injection.HAS_OVERLOADED_BOOLEAN_VALUE)
1779 + };
1780 + !(propertyInfo.hasBooleanValue + propertyInfo.hasNumericValue + propertyInfo.hasOverloadedBooleanValue <= 1) ? "development" !== 'production' ? invariant(false, 'DOMProperty: Value can be one of boolean, overloaded boolean, or numeric value, but not a combination: %s', propName) : _prodInvariant('50', propName) : void 0;
1781 +
1782 + if ("development" !== 'production') {
1783 + DOMProperty.getPossibleStandardName[lowerCased] = propName;
1784 + }
1785 +
1786 + if (DOMAttributeNames.hasOwnProperty(propName)) {
1787 + var attributeName = DOMAttributeNames[propName];
1788 + propertyInfo.attributeName = attributeName;
1789 + if ("development" !== 'production') {
1790 + DOMProperty.getPossibleStandardName[attributeName] = propName;
1791 + }
1792 + }
1793 +
1794 + if (DOMAttributeNamespaces.hasOwnProperty(propName)) {
1795 + propertyInfo.attributeNamespace = DOMAttributeNamespaces[propName];
1796 + }
1797 +
1798 + if (DOMPropertyNames.hasOwnProperty(propName)) {
1799 + propertyInfo.propertyName = DOMPropertyNames[propName];
1800 + }
1801 +
1802 + if (DOMMutationMethods.hasOwnProperty(propName)) {
1803 + propertyInfo.mutationMethod = DOMMutationMethods[propName];
1804 + }
1805 +
1806 + DOMProperty.properties[propName] = propertyInfo;
1807 + }
1808 + }
1809 +};
1810 +
1811 +/* eslint-disable max-len */
1812 +var ATTRIBUTE_NAME_START_CHAR = ':A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD';
1813 +/* eslint-enable max-len */
1814 +
1815 +/**
1816 + * DOMProperty exports lookup objects that can be used like functions:
1817 + *
1818 + * > DOMProperty.isValid['id']
1819 + * true
1820 + * > DOMProperty.isValid['foobar']
1821 + * undefined
1822 + *
1823 + * Although this may be confusing, it performs better in general.
1824 + *
1825 + * @see http://jsperf.com/key-exists
1826 + * @see http://jsperf.com/key-missing
1827 + */
1828 +var DOMProperty = {
1829 +
1830 + ID_ATTRIBUTE_NAME: 'data-reactid',
1831 + ROOT_ATTRIBUTE_NAME: 'data-reactroot',
1832 +
1833 + ATTRIBUTE_NAME_START_CHAR: ATTRIBUTE_NAME_START_CHAR,
1834 + ATTRIBUTE_NAME_CHAR: ATTRIBUTE_NAME_START_CHAR + '\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040',
1835 +
1836 + /**
1837 + * Map from property "standard name" to an object with info about how to set
1838 + * the property in the DOM. Each object contains:
1839 + *
1840 + * attributeName:
1841 + * Used when rendering markup or with `*Attribute()`.
1842 + * attributeNamespace
1843 + * propertyName:
1844 + * Used on DOM node instances. (This includes properties that mutate due to
1845 + * external factors.)
1846 + * mutationMethod:
1847 + * If non-null, used instead of the property or `setAttribute()` after
1848 + * initial render.
1849 + * mustUseProperty:
1850 + * Whether the property must be accessed and mutated as an object property.
1851 + * hasBooleanValue:
1852 + * Whether the property should be removed when set to a falsey value.
1853 + * hasNumericValue:
1854 + * Whether the property must be numeric or parse as a numeric and should be
1855 + * removed when set to a falsey value.
1856 + * hasPositiveNumericValue:
1857 + * Whether the property must be positive numeric or parse as a positive
1858 + * numeric and should be removed when set to a falsey value.
1859 + * hasOverloadedBooleanValue:
1860 + * Whether the property can be used as a flag as well as with a value.
1861 + * Removed when strictly equal to false; present without a value when
1862 + * strictly equal to true; present with a value otherwise.
1863 + */
1864 + properties: {},
1865 +
1866 + /**
1867 + * Mapping from lowercase property names to the properly cased version, used
1868 + * to warn in the case of missing properties. Available only in __DEV__.
1869 + *
1870 + * autofocus is predefined, because adding it to the property whitelist
1871 + * causes unintended side effects.
1872 + *
1873 + * @type {Object}
1874 + */
1875 + getPossibleStandardName: "development" !== 'production' ? { autofocus: 'autoFocus' } : null,
1876 +
1877 + /**
1878 + * All of the isCustomAttribute() functions that have been injected.
1879 + */
1880 + _isCustomAttributeFunctions: [],
1881 +
1882 + /**
1883 + * Checks whether a property name is a custom attribute.
1884 + * @method
1885 + */
1886 + isCustomAttribute: function (attributeName) {
1887 + for (var i = 0; i < DOMProperty._isCustomAttributeFunctions.length; i++) {
1888 + var isCustomAttributeFn = DOMProperty._isCustomAttributeFunctions[i];
1889 + if (isCustomAttributeFn(attributeName)) {
1890 + return true;
1891 + }
1892 + }
1893 + return false;
1894 + },
1895 +
1896 + injection: DOMPropertyInjection
1897 +};
1898 +
1899 +module.exports = DOMProperty;
1900 +},{"133":133,"157":157}],13:[function(_dereq_,module,exports){
1901 +/**
1902 + * Copyright 2013-present, Facebook, Inc.
1903 + * All rights reserved.
1904 + *
1905 + * This source code is licensed under the BSD-style license found in the
1906 + * LICENSE file in the root directory of this source tree. An additional grant
1907 + * of patent rights can be found in the PATENTS file in the same directory.
1908 + *
1909 + */
1910 +
1911 +'use strict';
1912 +
1913 +var DOMProperty = _dereq_(12);
1914 +var ReactDOMComponentTree = _dereq_(35);
1915 +var ReactInstrumentation = _dereq_(67);
1916 +
1917 +var quoteAttributeValueForBrowser = _dereq_(132);
1918 +var warning = _dereq_(164);
1919 +
1920 +var VALID_ATTRIBUTE_NAME_REGEX = new RegExp('^[' + DOMProperty.ATTRIBUTE_NAME_START_CHAR + '][' + DOMProperty.ATTRIBUTE_NAME_CHAR + ']*$');
1921 +var illegalAttributeNameCache = {};
1922 +var validatedAttributeNameCache = {};
1923 +
1924 +function isAttributeNameSafe(attributeName) {
1925 + if (validatedAttributeNameCache.hasOwnProperty(attributeName)) {
1926 + return true;
1927 + }
1928 + if (illegalAttributeNameCache.hasOwnProperty(attributeName)) {
1929 + return false;
1930 + }
1931 + if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) {
1932 + validatedAttributeNameCache[attributeName] = true;
1933 + return true;
1934 + }
1935 + illegalAttributeNameCache[attributeName] = true;
1936 + "development" !== 'production' ? warning(false, 'Invalid attribute name: `%s`', attributeName) : void 0;
1937 + return false;
1938 +}
1939 +
1940 +function shouldIgnoreValue(propertyInfo, value) {
1941 + return value == null || propertyInfo.hasBooleanValue && !value || propertyInfo.hasNumericValue && isNaN(value) || propertyInfo.hasPositiveNumericValue && value < 1 || propertyInfo.hasOverloadedBooleanValue && value === false;
1942 +}
1943 +
1944 +/**
1945 + * Operations for dealing with DOM properties.
1946 + */
1947 +var DOMPropertyOperations = {
1948 +
1949 + /**
1950 + * Creates markup for the ID property.
1951 + *
1952 + * @param {string} id Unescaped ID.
1953 + * @return {string} Markup string.
1954 + */
1955 + createMarkupForID: function (id) {
1956 + return DOMProperty.ID_ATTRIBUTE_NAME + '=' + quoteAttributeValueForBrowser(id);
1957 + },
1958 +
1959 + setAttributeForID: function (node, id) {
1960 + node.setAttribute(DOMProperty.ID_ATTRIBUTE_NAME, id);
1961 + },
1962 +
1963 + createMarkupForRoot: function () {
1964 + return DOMProperty.ROOT_ATTRIBUTE_NAME + '=""';
1965 + },
1966 +
1967 + setAttributeForRoot: function (node) {
1968 + node.setAttribute(DOMProperty.ROOT_ATTRIBUTE_NAME, '');
1969 + },
1970 +
1971 + /**
1972 + * Creates markup for a property.
1973 + *
1974 + * @param {string} name
1975 + * @param {*} value
1976 + * @return {?string} Markup string, or null if the property was invalid.
1977 + */
1978 + createMarkupForProperty: function (name, value) {
1979 + var propertyInfo = DOMProperty.properties.hasOwnProperty(name) ? DOMProperty.properties[name] : null;
1980 + if (propertyInfo) {
1981 + if (shouldIgnoreValue(propertyInfo, value)) {
1982 + return '';
1983 + }
1984 + var attributeName = propertyInfo.attributeName;
1985 + if (propertyInfo.hasBooleanValue || propertyInfo.hasOverloadedBooleanValue && value === true) {
1986 + return attributeName + '=""';
1987 + }
1988 + return attributeName + '=' + quoteAttributeValueForBrowser(value);
1989 + } else if (DOMProperty.isCustomAttribute(name)) {
1990 + if (value == null) {
1991 + return '';
1992 + }
1993 + return name + '=' + quoteAttributeValueForBrowser(value);
1994 + }
1995 + return null;
1996 + },
1997 +
1998 + /**
1999 + * Creates markup for a custom property.
2000 + *
2001 + * @param {string} name
2002 + * @param {*} value
2003 + * @return {string} Markup string, or empty string if the property was invalid.
2004 + */
2005 + createMarkupForCustomAttribute: function (name, value) {
2006 + if (!isAttributeNameSafe(name) || value == null) {
2007 + return '';
2008 + }
2009 + return name + '=' + quoteAttributeValueForBrowser(value);
2010 + },
2011 +
2012 + /**
2013 + * Sets the value for a property on a node.
2014 + *
2015 + * @param {DOMElement} node
2016 + * @param {string} name
2017 + * @param {*} value
2018 + */
2019 + setValueForProperty: function (node, name, value) {
2020 + var propertyInfo = DOMProperty.properties.hasOwnProperty(name) ? DOMProperty.properties[name] : null;
2021 + if (propertyInfo) {
2022 + var mutationMethod = propertyInfo.mutationMethod;
2023 + if (mutationMethod) {
2024 + mutationMethod(node, value);
2025 + } else if (shouldIgnoreValue(propertyInfo, value)) {
2026 + this.deleteValueForProperty(node, name);
2027 + return;
2028 + } else if (propertyInfo.mustUseProperty) {
2029 + // Contrary to `setAttribute`, object properties are properly
2030 + // `toString`ed by IE8/9.
2031 + node[propertyInfo.propertyName] = value;
2032 + } else {
2033 + var attributeName = propertyInfo.attributeName;
2034 + var namespace = propertyInfo.attributeNamespace;
2035 + // `setAttribute` with objects becomes only `[object]` in IE8/9,
2036 + // ('' + value) makes it output the correct toString()-value.
2037 + if (namespace) {
2038 + node.setAttributeNS(namespace, attributeName, '' + value);
2039 + } else if (propertyInfo.hasBooleanValue || propertyInfo.hasOverloadedBooleanValue && value === true) {
2040 + node.setAttribute(attributeName, '');
2041 + } else {
2042 + node.setAttribute(attributeName, '' + value);
2043 + }
2044 + }
2045 + } else if (DOMProperty.isCustomAttribute(name)) {
2046 + DOMPropertyOperations.setValueForAttribute(node, name, value);
2047 + return;
2048 + }
2049 +
2050 + if ("development" !== 'production') {
2051 + var payload = {};
2052 + payload[name] = value;
2053 + ReactInstrumentation.debugTool.onHostOperation({
2054 + instanceID: ReactDOMComponentTree.getInstanceFromNode(node)._debugID,
2055 + type: 'update attribute',
2056 + payload: payload
2057 + });
2058 + }
2059 + },
2060 +
2061 + setValueForAttribute: function (node, name, value) {
2062 + if (!isAttributeNameSafe(name)) {
2063 + return;
2064 + }
2065 + if (value == null) {
2066 + node.removeAttribute(name);
2067 + } else {
2068 + node.setAttribute(name, '' + value);
2069 + }
2070 +
2071 + if ("development" !== 'production') {
2072 + var payload = {};
2073 + payload[name] = value;
2074 + ReactInstrumentation.debugTool.onHostOperation({
2075 + instanceID: ReactDOMComponentTree.getInstanceFromNode(node)._debugID,
2076 + type: 'update attribute',
2077 + payload: payload
2078 + });
2079 + }
2080 + },
2081 +
2082 + /**
2083 + * Deletes an attributes from a node.
2084 + *
2085 + * @param {DOMElement} node
2086 + * @param {string} name
2087 + */
2088 + deleteValueForAttribute: function (node, name) {
2089 + node.removeAttribute(name);
2090 + if ("development" !== 'production') {
2091 + ReactInstrumentation.debugTool.onHostOperation({
2092 + instanceID: ReactDOMComponentTree.getInstanceFromNode(node)._debugID,
2093 + type: 'remove attribute',
2094 + payload: name
2095 + });
2096 + }
2097 + },
2098 +
2099 + /**
2100 + * Deletes the value for a property on a node.
2101 + *
2102 + * @param {DOMElement} node
2103 + * @param {string} name
2104 + */
2105 + deleteValueForProperty: function (node, name) {
2106 + var propertyInfo = DOMProperty.properties.hasOwnProperty(name) ? DOMProperty.properties[name] : null;
2107 + if (propertyInfo) {
2108 + var mutationMethod = propertyInfo.mutationMethod;
2109 + if (mutationMethod) {
2110 + mutationMethod(node, undefined);
2111 + } else if (propertyInfo.mustUseProperty) {
2112 + var propName = propertyInfo.propertyName;
2113 + if (propertyInfo.hasBooleanValue) {
2114 + node[propName] = false;
2115 + } else {
2116 + node[propName] = '';
2117 + }
2118 + } else {
2119 + node.removeAttribute(propertyInfo.attributeName);
2120 + }
2121 + } else if (DOMProperty.isCustomAttribute(name)) {
2122 + node.removeAttribute(name);
2123 + }
2124 +
2125 + if ("development" !== 'production') {
2126 + ReactInstrumentation.debugTool.onHostOperation({
2127 + instanceID: ReactDOMComponentTree.getInstanceFromNode(node)._debugID,
2128 + type: 'remove attribute',
2129 + payload: name
2130 + });
2131 + }
2132 + }
2133 +
2134 +};
2135 +
2136 +module.exports = DOMPropertyOperations;
2137 +},{"12":12,"132":132,"164":164,"35":35,"67":67}],14:[function(_dereq_,module,exports){
2138 +/**
2139 + * Copyright 2013-present, Facebook, Inc.
2140 + * All rights reserved.
2141 + *
2142 + * This source code is licensed under the BSD-style license found in the
2143 + * LICENSE file in the root directory of this source tree. An additional grant
2144 + * of patent rights can be found in the PATENTS file in the same directory.
2145 + *
2146 + */
2147 +
2148 +'use strict';
2149 +
2150 +var _prodInvariant = _dereq_(133);
2151 +
2152 +var DOMLazyTree = _dereq_(10);
2153 +var ExecutionEnvironment = _dereq_(143);
2154 +
2155 +var createNodesFromMarkup = _dereq_(148);
2156 +var emptyFunction = _dereq_(149);
2157 +var invariant = _dereq_(157);
2158 +
2159 +var Danger = {
2160 +
2161 + /**
2162 + * Replaces a node with a string of markup at its current position within its
2163 + * parent. The markup must render into a single root node.
2164 + *
2165 + * @param {DOMElement} oldChild Child node to replace.
2166 + * @param {string} markup Markup to render in place of the child node.
2167 + * @internal
2168 + */
2169 + dangerouslyReplaceNodeWithMarkup: function (oldChild, markup) {
2170 + !ExecutionEnvironment.canUseDOM ? "development" !== 'production' ? invariant(false, 'dangerouslyReplaceNodeWithMarkup(...): Cannot render markup in a worker thread. Make sure `window` and `document` are available globally before requiring React when unit testing or use ReactDOMServer.renderToString() for server rendering.') : _prodInvariant('56') : void 0;
2171 + !markup ? "development" !== 'production' ? invariant(false, 'dangerouslyReplaceNodeWithMarkup(...): Missing markup.') : _prodInvariant('57') : void 0;
2172 + !(oldChild.nodeName !== 'HTML') ? "development" !== 'production' ? invariant(false, 'dangerouslyReplaceNodeWithMarkup(...): Cannot replace markup of the <html> node. This is because browser quirks make this unreliable and/or slow. If you want to render to the root you must use server rendering. See ReactDOMServer.renderToString().') : _prodInvariant('58') : void 0;
2173 +
2174 + if (typeof markup === 'string') {
2175 + var newChild = createNodesFromMarkup(markup, emptyFunction)[0];
2176 + oldChild.parentNode.replaceChild(newChild, oldChild);
2177 + } else {
2178 + DOMLazyTree.replaceChildWithTree(oldChild, markup);
2179 + }
2180 + }
2181 +
2182 +};
2183 +
2184 +module.exports = Danger;
2185 +},{"10":10,"133":133,"143":143,"148":148,"149":149,"157":157}],15:[function(_dereq_,module,exports){
2186 +/**
2187 + * Copyright 2013-present, Facebook, Inc.
2188 + * All rights reserved.
2189 + *
2190 + * This source code is licensed under the BSD-style license found in the
2191 + * LICENSE file in the root directory of this source tree. An additional grant
2192 + * of patent rights can be found in the PATENTS file in the same directory.
2193 + *
2194 + */
2195 +
2196 +'use strict';
2197 +
2198 +var EventPropagators = _dereq_(20);
2199 +var ReactDOMComponentTree = _dereq_(35);
2200 +var SyntheticMouseEvent = _dereq_(100);
2201 +
2202 +var eventTypes = {
2203 + mouseEnter: {
2204 + registrationName: 'onMouseEnter',
2205 + dependencies: ['topMouseOut', 'topMouseOver']
2206 + },
2207 + mouseLeave: {
2208 + registrationName: 'onMouseLeave',
2209 + dependencies: ['topMouseOut', 'topMouseOver']
2210 + }
2211 +};
2212 +
2213 +var EnterLeaveEventPlugin = {
2214 +
2215 + eventTypes: eventTypes,
2216 +
2217 + /**
2218 + * For almost every interaction we care about, there will be both a top-level
2219 + * `mouseover` and `mouseout` event that occurs. Only use `mouseout` so that
2220 + * we do not extract duplicate events. However, moving the mouse into the
2221 + * browser from outside will not fire a `mouseout` event. In this case, we use
2222 + * the `mouseover` top-level event.
2223 + */
2224 + extractEvents: function (topLevelType, targetInst, nativeEvent, nativeEventTarget) {
2225 + if (topLevelType === 'topMouseOver' && (nativeEvent.relatedTarget || nativeEvent.fromElement)) {
2226 + return null;
2227 + }
2228 + if (topLevelType !== 'topMouseOut' && topLevelType !== 'topMouseOver') {
2229 + // Must not be a mouse in or mouse out - ignoring.
2230 + return null;
2231 + }
2232 +
2233 + var win;
2234 + if (nativeEventTarget.window === nativeEventTarget) {
2235 + // `nativeEventTarget` is probably a window object.
2236 + win = nativeEventTarget;
2237 + } else {
2238 + // TODO: Figure out why `ownerDocument` is sometimes undefined in IE8.
2239 + var doc = nativeEventTarget.ownerDocument;
2240 + if (doc) {
2241 + win = doc.defaultView || doc.parentWindow;
2242 + } else {
2243 + win = window;
2244 + }
2245 + }
2246 +
2247 + var from;
2248 + var to;
2249 + if (topLevelType === 'topMouseOut') {
2250 + from = targetInst;
2251 + var related = nativeEvent.relatedTarget || nativeEvent.toElement;
2252 + to = related ? ReactDOMComponentTree.getClosestInstanceFromNode(related) : null;
2253 + } else {
2254 + // Moving to a node from outside the window.
2255 + from = null;
2256 + to = targetInst;
2257 + }
2258 +
2259 + if (from === to) {
2260 + // Nothing pertains to our managed components.
2261 + return null;
2262 + }
2263 +
2264 + var fromNode = from == null ? win : ReactDOMComponentTree.getNodeFromInstance(from);
2265 + var toNode = to == null ? win : ReactDOMComponentTree.getNodeFromInstance(to);
2266 +
2267 + var leave = SyntheticMouseEvent.getPooled(eventTypes.mouseLeave, from, nativeEvent, nativeEventTarget);
2268 + leave.type = 'mouseleave';
2269 + leave.target = fromNode;
2270 + leave.relatedTarget = toNode;
2271 +
2272 + var enter = SyntheticMouseEvent.getPooled(eventTypes.mouseEnter, to, nativeEvent, nativeEventTarget);
2273 + enter.type = 'mouseenter';
2274 + enter.target = toNode;
2275 + enter.relatedTarget = fromNode;
2276 +
2277 + EventPropagators.accumulateEnterLeaveDispatches(leave, enter, from, to);
2278 +
2279 + return [leave, enter];
2280 + }
2281 +
2282 +};
2283 +
2284 +module.exports = EnterLeaveEventPlugin;
2285 +},{"100":100,"20":20,"35":35}],16:[function(_dereq_,module,exports){
2286 +/**
2287 + * Copyright 2013-present, Facebook, Inc.
2288 + * All rights reserved.
2289 + *
2290 + * This source code is licensed under the BSD-style license found in the
2291 + * LICENSE file in the root directory of this source tree. An additional grant
2292 + * of patent rights can be found in the PATENTS file in the same directory.
2293 + *
2294 + */
2295 +
2296 +'use strict';
2297 +
2298 +/**
2299 + * Types of raw signals from the browser caught at the top level.
2300 + */
2301 +var topLevelTypes = {
2302 + topAbort: null,
2303 + topAnimationEnd: null,
2304 + topAnimationIteration: null,
2305 + topAnimationStart: null,
2306 + topBlur: null,
2307 + topCanPlay: null,
2308 + topCanPlayThrough: null,
2309 + topChange: null,
2310 + topClick: null,
2311 + topCompositionEnd: null,
2312 + topCompositionStart: null,
2313 + topCompositionUpdate: null,
2314 + topContextMenu: null,
2315 + topCopy: null,
2316 + topCut: null,
2317 + topDoubleClick: null,
2318 + topDrag: null,
2319 + topDragEnd: null,
2320 + topDragEnter: null,
2321 + topDragExit: null,
2322 + topDragLeave: null,
2323 + topDragOver: null,
2324 + topDragStart: null,
2325 + topDrop: null,
2326 + topDurationChange: null,
2327 + topEmptied: null,
2328 + topEncrypted: null,
2329 + topEnded: null,
2330 + topError: null,
2331 + topFocus: null,
2332 + topInput: null,
2333 + topInvalid: null,
2334 + topKeyDown: null,
2335 + topKeyPress: null,
2336 + topKeyUp: null,
2337 + topLoad: null,
2338 + topLoadedData: null,
2339 + topLoadedMetadata: null,
2340 + topLoadStart: null,
2341 + topMouseDown: null,
2342 + topMouseMove: null,
2343 + topMouseOut: null,
2344 + topMouseOver: null,
2345 + topMouseUp: null,
2346 + topPaste: null,
2347 + topPause: null,
2348 + topPlay: null,
2349 + topPlaying: null,
2350 + topProgress: null,
2351 + topRateChange: null,
2352 + topReset: null,
2353 + topScroll: null,
2354 + topSeeked: null,
2355 + topSeeking: null,
2356 + topSelectionChange: null,
2357 + topStalled: null,
2358 + topSubmit: null,
2359 + topSuspend: null,
2360 + topTextInput: null,
2361 + topTimeUpdate: null,
2362 + topTouchCancel: null,
2363 + topTouchEnd: null,
2364 + topTouchMove: null,
2365 + topTouchStart: null,
2366 + topTransitionEnd: null,
2367 + topVolumeChange: null,
2368 + topWaiting: null,
2369 + topWheel: null
2370 +};
2371 +
2372 +var EventConstants = {
2373 + topLevelTypes: topLevelTypes
2374 +};
2375 +
2376 +module.exports = EventConstants;
2377 +},{}],17:[function(_dereq_,module,exports){
2378 +/**
2379 + * Copyright 2013-present, Facebook, Inc.
2380 + * All rights reserved.
2381 + *
2382 + * This source code is licensed under the BSD-style license found in the
2383 + * LICENSE file in the root directory of this source tree. An additional grant
2384 + * of patent rights can be found in the PATENTS file in the same directory.
2385 + *
2386 + */
2387 +
2388 +'use strict';
2389 +
2390 +var _prodInvariant = _dereq_(133);
2391 +
2392 +var EventPluginRegistry = _dereq_(18);
2393 +var EventPluginUtils = _dereq_(19);
2394 +var ReactErrorUtils = _dereq_(57);
2395 +
2396 +var accumulateInto = _dereq_(107);
2397 +var forEachAccumulated = _dereq_(115);
2398 +var invariant = _dereq_(157);
2399 +
2400 +/**
2401 + * Internal queue of events that have accumulated their dispatches and are
2402 + * waiting to have their dispatches executed.
2403 + */
2404 +var eventQueue = null;
2405 +
2406 +/**
2407 + * Dispatches an event and releases it back into the pool, unless persistent.
2408 + *
2409 + * @param {?object} event Synthetic event to be dispatched.
2410 + * @param {boolean} simulated If the event is simulated (changes exn behavior)
2411 + * @private
2412 + */
2413 +var executeDispatchesAndRelease = function (event, simulated) {
2414 + if (event) {
2415 + EventPluginUtils.executeDispatchesInOrder(event, simulated);
2416 +
2417 + if (!event.isPersistent()) {
2418 + event.constructor.release(event);
2419 + }
2420 + }
2421 +};
2422 +var executeDispatchesAndReleaseSimulated = function (e) {
2423 + return executeDispatchesAndRelease(e, true);
2424 +};
2425 +var executeDispatchesAndReleaseTopLevel = function (e) {
2426 + return executeDispatchesAndRelease(e, false);
2427 +};
2428 +
2429 +function isInteractive(tag) {
2430 + return tag === 'button' || tag === 'input' || tag === 'select' || tag === 'textarea';
2431 +}
2432 +
2433 +function shouldPreventMouseEvent(name, type, props) {
2434 + switch (name) {
2435 + case 'onClick':
2436 + case 'onClickCapture':
2437 + case 'onDoubleClick':
2438 + case 'onDoubleClickCapture':
2439 + case 'onMouseDown':
2440 + case 'onMouseDownCapture':
2441 + case 'onMouseMove':
2442 + case 'onMouseMoveCapture':
2443 + case 'onMouseUp':
2444 + case 'onMouseUpCapture':
2445 + return !!(props.disabled && isInteractive(type));
2446 + default:
2447 + return false;
2448 + }
2449 +}
2450 +
2451 +/**
2452 + * This is a unified interface for event plugins to be installed and configured.
2453 + *
2454 + * Event plugins can implement the following properties:
2455 + *
2456 + * `extractEvents` {function(string, DOMEventTarget, string, object): *}
2457 + * Required. When a top-level event is fired, this method is expected to
2458 + * extract synthetic events that will in turn be queued and dispatched.
2459 + *
2460 + * `eventTypes` {object}
2461 + * Optional, plugins that fire events must publish a mapping of registration
2462 + * names that are used to register listeners. Values of this mapping must
2463 + * be objects that contain `registrationName` or `phasedRegistrationNames`.
2464 + *
2465 + * `executeDispatch` {function(object, function, string)}
2466 + * Optional, allows plugins to override how an event gets dispatched. By
2467 + * default, the listener is simply invoked.
2468 + *
2469 + * Each plugin that is injected into `EventsPluginHub` is immediately operable.
2470 + *
2471 + * @public
2472 + */
2473 +var EventPluginHub = {
2474 +
2475 + /**
2476 + * Methods for injecting dependencies.
2477 + */
2478 + injection: {
2479 +
2480 + /**
2481 + * @param {array} InjectedEventPluginOrder
2482 + * @public
2483 + */
2484 + injectEventPluginOrder: EventPluginRegistry.injectEventPluginOrder,
2485 +
2486 + /**
2487 + * @param {object} injectedNamesToPlugins Map from names to plugin modules.
2488 + */
2489 + injectEventPluginsByName: EventPluginRegistry.injectEventPluginsByName
2490 +
2491 + },
2492 +
2493 + /**
2494 + * @param {object} inst The instance, which is the source of events.
2495 + * @param {string} registrationName Name of listener (e.g. `onClick`).
2496 + * @return {?function} The stored callback.
2497 + */
2498 + getListener: function (inst, registrationName) {
2499 + var listener;
2500 +
2501 + // TODO: shouldPreventMouseEvent is DOM-specific and definitely should not
2502 + // live here; needs to be moved to a better place soon
2503 + if (typeof inst.tag === 'number') {
2504 + var props = inst.memoizedProps;
2505 + listener = props[registrationName];
2506 + if (shouldPreventMouseEvent(registrationName, inst.type, props)) {
2507 + return null;
2508 + }
2509 + } else {
2510 + var _props = inst._currentElement.props;
2511 + listener = _props[registrationName];
2512 + if (shouldPreventMouseEvent(registrationName, inst._currentElement.type, _props)) {
2513 + return null;
2514 + }
2515 + }
2516 +
2517 + !(!listener || typeof listener === 'function') ? "development" !== 'production' ? invariant(false, 'Expected %s listener to be a function, instead got type %s', registrationName, typeof listener) : _prodInvariant('94', registrationName, typeof listener) : void 0;
2518 + return listener;
2519 + },
2520 +
2521 + /**
2522 + * Allows registered plugins an opportunity to extract events from top-level
2523 + * native browser events.
2524 + *
2525 + * @return {*} An accumulation of synthetic events.
2526 + * @internal
2527 + */
2528 + extractEvents: function (topLevelType, targetInst, nativeEvent, nativeEventTarget) {
2529 + var events;
2530 + var plugins = EventPluginRegistry.plugins;
2531 + for (var i = 0; i < plugins.length; i++) {
2532 + // Not every plugin in the ordering may be loaded at runtime.
2533 + var possiblePlugin = plugins[i];
2534 + if (possiblePlugin) {
2535 + var extractedEvents = possiblePlugin.extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget);
2536 + if (extractedEvents) {
2537 + events = accumulateInto(events, extractedEvents);
2538 + }
2539 + }
2540 + }
2541 + return events;
2542 + },
2543 +
2544 + /**
2545 + * Enqueues a synthetic event that should be dispatched when
2546 + * `processEventQueue` is invoked.
2547 + *
2548 + * @param {*} events An accumulation of synthetic events.
2549 + * @internal
2550 + */
2551 + enqueueEvents: function (events) {
2552 + if (events) {
2553 + eventQueue = accumulateInto(eventQueue, events);
2554 + }
2555 + },
2556 +
2557 + /**
2558 + * Dispatches all synthetic events on the event queue.
2559 + *
2560 + * @internal
2561 + */
2562 + processEventQueue: function (simulated) {
2563 + // Set `eventQueue` to null before processing it so that we can tell if more
2564 + // events get enqueued while processing.
2565 + var processingEventQueue = eventQueue;
2566 + eventQueue = null;
2567 + if (simulated) {
2568 + forEachAccumulated(processingEventQueue, executeDispatchesAndReleaseSimulated);
2569 + } else {
2570 + forEachAccumulated(processingEventQueue, executeDispatchesAndReleaseTopLevel);
2571 + }
2572 + !!eventQueue ? "development" !== 'production' ? invariant(false, 'processEventQueue(): Additional events were enqueued while processing an event queue. Support for this has not yet been implemented.') : _prodInvariant('95') : void 0;
2573 + // This would be a good time to rethrow if any of the event handlers threw.
2574 + ReactErrorUtils.rethrowCaughtError();
2575 + }
2576 +
2577 +};
2578 +
2579 +module.exports = EventPluginHub;
2580 +},{"107":107,"115":115,"133":133,"157":157,"18":18,"19":19,"57":57}],18:[function(_dereq_,module,exports){
2581 +/**
2582 + * Copyright 2013-present, Facebook, Inc.
2583 + * All rights reserved.
2584 + *
2585 + * This source code is licensed under the BSD-style license found in the
2586 + * LICENSE file in the root directory of this source tree. An additional grant
2587 + * of patent rights can be found in the PATENTS file in the same directory.
2588 + *
2589 + *
2590 + */
2591 +
2592 +'use strict';
2593 +
2594 +var _prodInvariant = _dereq_(133);
2595 +
2596 +var invariant = _dereq_(157);
2597 +
2598 +/**
2599 + * Injectable ordering of event plugins.
2600 + */
2601 +var eventPluginOrder = null;
2602 +
2603 +/**
2604 + * Injectable mapping from names to event plugin modules.
2605 + */
2606 +var namesToPlugins = {};
2607 +
2608 +/**
2609 + * Recomputes the plugin list using the injected plugins and plugin ordering.
2610 + *
2611 + * @private
2612 + */
2613 +function recomputePluginOrdering() {
2614 + if (!eventPluginOrder) {
2615 + // Wait until an `eventPluginOrder` is injected.
2616 + return;
2617 + }
2618 + for (var pluginName in namesToPlugins) {
2619 + var pluginModule = namesToPlugins[pluginName];
2620 + var pluginIndex = eventPluginOrder.indexOf(pluginName);
2621 + !(pluginIndex > -1) ? "development" !== 'production' ? invariant(false, 'EventPluginRegistry: Cannot inject event plugins that do not exist in the plugin ordering, `%s`.', pluginName) : _prodInvariant('96', pluginName) : void 0;
2622 + if (EventPluginRegistry.plugins[pluginIndex]) {
2623 + continue;
2624 + }
2625 + !pluginModule.extractEvents ? "development" !== 'production' ? invariant(false, 'EventPluginRegistry: Event plugins must implement an `extractEvents` method, but `%s` does not.', pluginName) : _prodInvariant('97', pluginName) : void 0;
2626 + EventPluginRegistry.plugins[pluginIndex] = pluginModule;
2627 + var publishedEvents = pluginModule.eventTypes;
2628 + for (var eventName in publishedEvents) {
2629 + !publishEventForPlugin(publishedEvents[eventName], pluginModule, eventName) ? "development" !== 'production' ? invariant(false, 'EventPluginRegistry: Failed to publish event `%s` for plugin `%s`.', eventName, pluginName) : _prodInvariant('98', eventName, pluginName) : void 0;
2630 + }
2631 + }
2632 +}
2633 +
2634 +/**
2635 + * Publishes an event so that it can be dispatched by the supplied plugin.
2636 + *
2637 + * @param {object} dispatchConfig Dispatch configuration for the event.
2638 + * @param {object} PluginModule Plugin publishing the event.
2639 + * @return {boolean} True if the event was successfully published.
2640 + * @private
2641 + */
2642 +function publishEventForPlugin(dispatchConfig, pluginModule, eventName) {
2643 + !!EventPluginRegistry.eventNameDispatchConfigs.hasOwnProperty(eventName) ? "development" !== 'production' ? invariant(false, 'EventPluginHub: More than one plugin attempted to publish the same event name, `%s`.', eventName) : _prodInvariant('99', eventName) : void 0;
2644 + EventPluginRegistry.eventNameDispatchConfigs[eventName] = dispatchConfig;
2645 +
2646 + var phasedRegistrationNames = dispatchConfig.phasedRegistrationNames;
2647 + if (phasedRegistrationNames) {
2648 + for (var phaseName in phasedRegistrationNames) {
2649 + if (phasedRegistrationNames.hasOwnProperty(phaseName)) {
2650 + var phasedRegistrationName = phasedRegistrationNames[phaseName];
2651 + publishRegistrationName(phasedRegistrationName, pluginModule, eventName);
2652 + }
2653 + }
2654 + return true;
2655 + } else if (dispatchConfig.registrationName) {
2656 + publishRegistrationName(dispatchConfig.registrationName, pluginModule, eventName);
2657 + return true;
2658 + }
2659 + return false;
2660 +}
2661 +
2662 +/**
2663 + * Publishes a registration name that is used to identify dispatched events.
2664 + *
2665 + * @param {string} registrationName Registration name to add.
2666 + * @param {object} PluginModule Plugin publishing the event.
2667 + * @private
2668 + */
2669 +function publishRegistrationName(registrationName, pluginModule, eventName) {
2670 + !!EventPluginRegistry.registrationNameModules[registrationName] ? "development" !== 'production' ? invariant(false, 'EventPluginHub: More than one plugin attempted to publish the same registration name, `%s`.', registrationName) : _prodInvariant('100', registrationName) : void 0;
2671 + EventPluginRegistry.registrationNameModules[registrationName] = pluginModule;
2672 + EventPluginRegistry.registrationNameDependencies[registrationName] = pluginModule.eventTypes[eventName].dependencies;
2673 +
2674 + if ("development" !== 'production') {
2675 + var lowerCasedName = registrationName.toLowerCase();
2676 + EventPluginRegistry.possibleRegistrationNames[lowerCasedName] = registrationName;
2677 +
2678 + if (registrationName === 'onDoubleClick') {
2679 + EventPluginRegistry.possibleRegistrationNames.ondblclick = registrationName;
2680 + }
2681 + }
2682 +}
2683 +
2684 +/**
2685 + * Registers plugins so that they can extract and dispatch events.
2686 + *
2687 + * @see {EventPluginHub}
2688 + */
2689 +var EventPluginRegistry = {
2690 +
2691 + /**
2692 + * Ordered list of injected plugins.
2693 + */
2694 + plugins: [],
2695 +
2696 + /**
2697 + * Mapping from event name to dispatch config
2698 + */
2699 + eventNameDispatchConfigs: {},
2700 +
2701 + /**
2702 + * Mapping from registration name to plugin module
2703 + */
2704 + registrationNameModules: {},
2705 +
2706 + /**
2707 + * Mapping from registration name to event name
2708 + */
2709 + registrationNameDependencies: {},
2710 +
2711 + /**
2712 + * Mapping from lowercase registration names to the properly cased version,
2713 + * used to warn in the case of missing event handlers. Available
2714 + * only in __DEV__.
2715 + * @type {Object}
2716 + */
2717 + possibleRegistrationNames: "development" !== 'production' ? {} : null,
2718 + // Trust the developer to only use possibleRegistrationNames in __DEV__
2719 +
2720 + /**
2721 + * Injects an ordering of plugins (by plugin name). This allows the ordering
2722 + * to be decoupled from injection of the actual plugins so that ordering is
2723 + * always deterministic regardless of packaging, on-the-fly injection, etc.
2724 + *
2725 + * @param {array} InjectedEventPluginOrder
2726 + * @internal
2727 + * @see {EventPluginHub.injection.injectEventPluginOrder}
2728 + */
2729 + injectEventPluginOrder: function (injectedEventPluginOrder) {
2730 + !!eventPluginOrder ? "development" !== 'production' ? invariant(false, 'EventPluginRegistry: Cannot inject event plugin ordering more than once. You are likely trying to load more than one copy of React.') : _prodInvariant('101') : void 0;
2731 + // Clone the ordering so it cannot be dynamically mutated.
2732 + eventPluginOrder = Array.prototype.slice.call(injectedEventPluginOrder);
2733 + recomputePluginOrdering();
2734 + },
2735 +
2736 + /**
2737 + * Injects plugins to be used by `EventPluginHub`. The plugin names must be
2738 + * in the ordering injected by `injectEventPluginOrder`.
2739 + *
2740 + * Plugins can be injected as part of page initialization or on-the-fly.
2741 + *
2742 + * @param {object} injectedNamesToPlugins Map from names to plugin modules.
2743 + * @internal
2744 + * @see {EventPluginHub.injection.injectEventPluginsByName}
2745 + */
2746 + injectEventPluginsByName: function (injectedNamesToPlugins) {
2747 + var isOrderingDirty = false;
2748 + for (var pluginName in injectedNamesToPlugins) {
2749 + if (!injectedNamesToPlugins.hasOwnProperty(pluginName)) {
2750 + continue;
2751 + }
2752 + var pluginModule = injectedNamesToPlugins[pluginName];
2753 + if (!namesToPlugins.hasOwnProperty(pluginName) || namesToPlugins[pluginName] !== pluginModule) {
2754 + !!namesToPlugins[pluginName] ? "development" !== 'production' ? invariant(false, 'EventPluginRegistry: Cannot inject two different event plugins using the same name, `%s`.', pluginName) : _prodInvariant('102', pluginName) : void 0;
2755 + namesToPlugins[pluginName] = pluginModule;
2756 + isOrderingDirty = true;
2757 + }
2758 + }
2759 + if (isOrderingDirty) {
2760 + recomputePluginOrdering();
2761 + }
2762 + },
2763 +
2764 + /**
2765 + * Looks up the plugin for the supplied event.
2766 + *
2767 + * @param {object} event A synthetic event.
2768 + * @return {?object} The plugin that created the supplied event.
2769 + * @internal
2770 + */
2771 + getPluginModuleForEvent: function (event) {
2772 + var dispatchConfig = event.dispatchConfig;
2773 + if (dispatchConfig.registrationName) {
2774 + return EventPluginRegistry.registrationNameModules[dispatchConfig.registrationName] || null;
2775 + }
2776 + if (dispatchConfig.phasedRegistrationNames !== undefined) {
2777 + // pulling phasedRegistrationNames out of dispatchConfig helps Flow see
2778 + // that it is not undefined.
2779 + var phasedRegistrationNames = dispatchConfig.phasedRegistrationNames;
2780 +
2781 + for (var phase in phasedRegistrationNames) {
2782 + if (!phasedRegistrationNames.hasOwnProperty(phase)) {
2783 + continue;
2784 + }
2785 + var pluginModule = EventPluginRegistry.registrationNameModules[phasedRegistrationNames[phase]];
2786 + if (pluginModule) {
2787 + return pluginModule;
2788 + }
2789 + }
2790 + }
2791 + return null;
2792 + },
2793 +
2794 + /**
2795 + * Exposed for unit testing.
2796 + * @private
2797 + */
2798 + _resetEventPlugins: function () {
2799 + eventPluginOrder = null;
2800 + for (var pluginName in namesToPlugins) {
2801 + if (namesToPlugins.hasOwnProperty(pluginName)) {
2802 + delete namesToPlugins[pluginName];
2803 + }
2804 + }
2805 + EventPluginRegistry.plugins.length = 0;
2806 +
2807 + var eventNameDispatchConfigs = EventPluginRegistry.eventNameDispatchConfigs;
2808 + for (var eventName in eventNameDispatchConfigs) {
2809 + if (eventNameDispatchConfigs.hasOwnProperty(eventName)) {
2810 + delete eventNameDispatchConfigs[eventName];
2811 + }
2812 + }
2813 +
2814 + var registrationNameModules = EventPluginRegistry.registrationNameModules;
2815 + for (var registrationName in registrationNameModules) {
2816 + if (registrationNameModules.hasOwnProperty(registrationName)) {
2817 + delete registrationNameModules[registrationName];
2818 + }
2819 + }
2820 +
2821 + if ("development" !== 'production') {
2822 + var possibleRegistrationNames = EventPluginRegistry.possibleRegistrationNames;
2823 + for (var lowerCasedName in possibleRegistrationNames) {
2824 + if (possibleRegistrationNames.hasOwnProperty(lowerCasedName)) {
2825 + delete possibleRegistrationNames[lowerCasedName];
2826 + }
2827 + }
2828 + }
2829 + }
2830 +
2831 +};
2832 +
2833 +module.exports = EventPluginRegistry;
2834 +},{"133":133,"157":157}],19:[function(_dereq_,module,exports){
2835 +/**
2836 + * Copyright 2013-present, Facebook, Inc.
2837 + * All rights reserved.
2838 + *
2839 + * This source code is licensed under the BSD-style license found in the
2840 + * LICENSE file in the root directory of this source tree. An additional grant
2841 + * of patent rights can be found in the PATENTS file in the same directory.
2842 + *
2843 + */
2844 +
2845 +'use strict';
2846 +
2847 +var _prodInvariant = _dereq_(133);
2848 +
2849 +var ReactErrorUtils = _dereq_(57);
2850 +
2851 +var invariant = _dereq_(157);
2852 +var warning = _dereq_(164);
2853 +
2854 +/**
2855 + * Injected dependencies:
2856 + */
2857 +
2858 +/**
2859 + * - `ComponentTree`: [required] Module that can convert between React instances
2860 + * and actual node references.
2861 + */
2862 +var ComponentTree;
2863 +var injection = {
2864 + injectComponentTree: function (Injected) {
2865 + ComponentTree = Injected;
2866 + if ("development" !== 'production') {
2867 + "development" !== 'production' ? warning(Injected && Injected.getNodeFromInstance && Injected.getInstanceFromNode, 'EventPluginUtils.injection.injectComponentTree(...): Injected ' + 'module is missing getNodeFromInstance or getInstanceFromNode.') : void 0;
2868 + }
2869 + }
2870 +};
2871 +
2872 +function isEndish(topLevelType) {
2873 + return topLevelType === 'topMouseUp' || topLevelType === 'topTouchEnd' || topLevelType === 'topTouchCancel';
2874 +}
2875 +
2876 +function isMoveish(topLevelType) {
2877 + return topLevelType === 'topMouseMove' || topLevelType === 'topTouchMove';
2878 +}
2879 +function isStartish(topLevelType) {
2880 + return topLevelType === 'topMouseDown' || topLevelType === 'topTouchStart';
2881 +}
2882 +
2883 +var validateEventDispatches;
2884 +if ("development" !== 'production') {
2885 + validateEventDispatches = function (event) {
2886 + var dispatchListeners = event._dispatchListeners;
2887 + var dispatchInstances = event._dispatchInstances;
2888 +
2889 + var listenersIsArr = Array.isArray(dispatchListeners);
2890 + var listenersLen = listenersIsArr ? dispatchListeners.length : dispatchListeners ? 1 : 0;
2891 +
2892 + var instancesIsArr = Array.isArray(dispatchInstances);
2893 + var instancesLen = instancesIsArr ? dispatchInstances.length : dispatchInstances ? 1 : 0;
2894 +
2895 + "development" !== 'production' ? warning(instancesIsArr === listenersIsArr && instancesLen === listenersLen, 'EventPluginUtils: Invalid `event`.') : void 0;
2896 + };
2897 +}
2898 +
2899 +/**
2900 + * Dispatch the event to the listener.
2901 + * @param {SyntheticEvent} event SyntheticEvent to handle
2902 + * @param {boolean} simulated If the event is simulated (changes exn behavior)
2903 + * @param {function} listener Application-level callback
2904 + * @param {*} inst Internal component instance
2905 + */
2906 +function executeDispatch(event, simulated, listener, inst) {
2907 + var type = event.type || 'unknown-event';
2908 + event.currentTarget = EventPluginUtils.getNodeFromInstance(inst);
2909 + if (simulated) {
2910 + ReactErrorUtils.invokeGuardedCallbackWithCatch(type, listener, event);
2911 + } else {
2912 + ReactErrorUtils.invokeGuardedCallback(type, listener, event);
2913 + }
2914 + event.currentTarget = null;
2915 +}
2916 +
2917 +/**
2918 + * Standard/simple iteration through an event's collected dispatches.
2919 + */
2920 +function executeDispatchesInOrder(event, simulated) {
2921 + var dispatchListeners = event._dispatchListeners;
2922 + var dispatchInstances = event._dispatchInstances;
2923 + if ("development" !== 'production') {
2924 + validateEventDispatches(event);
2925 + }
2926 + if (Array.isArray(dispatchListeners)) {
2927 + for (var i = 0; i < dispatchListeners.length; i++) {
2928 + if (event.isPropagationStopped()) {
2929 + break;
2930 + }
2931 + // Listeners and Instances are two parallel arrays that are always in sync.
2932 + executeDispatch(event, simulated, dispatchListeners[i], dispatchInstances[i]);
2933 + }
2934 + } else if (dispatchListeners) {
2935 + executeDispatch(event, simulated, dispatchListeners, dispatchInstances);
2936 + }
2937 + event._dispatchListeners = null;
2938 + event._dispatchInstances = null;
2939 +}
2940 +
2941 +/**
2942 + * Standard/simple iteration through an event's collected dispatches, but stops
2943 + * at the first dispatch execution returning true, and returns that id.
2944 + *
2945 + * @return {?string} id of the first dispatch execution who's listener returns
2946 + * true, or null if no listener returned true.
2947 + */
2948 +function executeDispatchesInOrderStopAtTrueImpl(event) {
2949 + var dispatchListeners = event._dispatchListeners;
2950 + var dispatchInstances = event._dispatchInstances;
2951 + if ("development" !== 'production') {
2952 + validateEventDispatches(event);
2953 + }
2954 + if (Array.isArray(dispatchListeners)) {
2955 + for (var i = 0; i < dispatchListeners.length; i++) {
2956 + if (event.isPropagationStopped()) {
2957 + break;
2958 + }
2959 + // Listeners and Instances are two parallel arrays that are always in sync.
2960 + if (dispatchListeners[i](event, dispatchInstances[i])) {
2961 + return dispatchInstances[i];
2962 + }
2963 + }
2964 + } else if (dispatchListeners) {
2965 + if (dispatchListeners(event, dispatchInstances)) {
2966 + return dispatchInstances;
2967 + }
2968 + }
2969 + return null;
2970 +}
2971 +
2972 +/**
2973 + * @see executeDispatchesInOrderStopAtTrueImpl
2974 + */
2975 +function executeDispatchesInOrderStopAtTrue(event) {
2976 + var ret = executeDispatchesInOrderStopAtTrueImpl(event);
2977 + event._dispatchInstances = null;
2978 + event._dispatchListeners = null;
2979 + return ret;
2980 +}
2981 +
2982 +/**
2983 + * Execution of a "direct" dispatch - there must be at most one dispatch
2984 + * accumulated on the event or it is considered an error. It doesn't really make
2985 + * sense for an event with multiple dispatches (bubbled) to keep track of the
2986 + * return values at each dispatch execution, but it does tend to make sense when
2987 + * dealing with "direct" dispatches.
2988 + *
2989 + * @return {*} The return value of executing the single dispatch.
2990 + */
2991 +function executeDirectDispatch(event) {
2992 + if ("development" !== 'production') {
2993 + validateEventDispatches(event);
2994 + }
2995 + var dispatchListener = event._dispatchListeners;
2996 + var dispatchInstance = event._dispatchInstances;
2997 + !!Array.isArray(dispatchListener) ? "development" !== 'production' ? invariant(false, 'executeDirectDispatch(...): Invalid `event`.') : _prodInvariant('103') : void 0;
2998 + event.currentTarget = dispatchListener ? EventPluginUtils.getNodeFromInstance(dispatchInstance) : null;
2999 + var res = dispatchListener ? dispatchListener(event) : null;
3000 + event.currentTarget = null;
3001 + event._dispatchListeners = null;
3002 + event._dispatchInstances = null;
3003 + return res;
3004 +}
3005 +
3006 +/**
3007 + * @param {SyntheticEvent} event
3008 + * @return {boolean} True iff number of dispatches accumulated is greater than 0.
3009 + */
3010 +function hasDispatches(event) {
3011 + return !!event._dispatchListeners;
3012 +}
3013 +
3014 +/**
3015 + * General utilities that are useful in creating custom Event Plugins.
3016 + */
3017 +var EventPluginUtils = {
3018 + isEndish: isEndish,
3019 + isMoveish: isMoveish,
3020 + isStartish: isStartish,
3021 +
3022 + executeDirectDispatch: executeDirectDispatch,
3023 + executeDispatchesInOrder: executeDispatchesInOrder,
3024 + executeDispatchesInOrderStopAtTrue: executeDispatchesInOrderStopAtTrue,
3025 + hasDispatches: hasDispatches,
3026 +
3027 + getInstanceFromNode: function (node) {
3028 + return ComponentTree.getInstanceFromNode(node);
3029 + },
3030 + getNodeFromInstance: function (node) {
3031 + return ComponentTree.getNodeFromInstance(node);
3032 + },
3033 +
3034 + injection: injection
3035 +};
3036 +
3037 +module.exports = EventPluginUtils;
3038 +},{"133":133,"157":157,"164":164,"57":57}],20:[function(_dereq_,module,exports){
3039 +/**
3040 + * Copyright 2013-present, Facebook, Inc.
3041 + * All rights reserved.
3042 + *
3043 + * This source code is licensed under the BSD-style license found in the
3044 + * LICENSE file in the root directory of this source tree. An additional grant
3045 + * of patent rights can be found in the PATENTS file in the same directory.
3046 + *
3047 + */
3048 +
3049 +'use strict';
3050 +
3051 +var EventPluginHub = _dereq_(17);
3052 +var ReactTreeTraversal = _dereq_(83);
3053 +
3054 +var accumulateInto = _dereq_(107);
3055 +var forEachAccumulated = _dereq_(115);
3056 +var warning = _dereq_(164);
3057 +
3058 +var getListener = EventPluginHub.getListener;
3059 +
3060 +/**
3061 + * Some event types have a notion of different registration names for different
3062 + * "phases" of propagation. This finds listeners by a given phase.
3063 + */
3064 +function listenerAtPhase(inst, event, propagationPhase) {
3065 + var registrationName = event.dispatchConfig.phasedRegistrationNames[propagationPhase];
3066 + return getListener(inst, registrationName);
3067 +}
3068 +
3069 +/**
3070 + * Tags a `SyntheticEvent` with dispatched listeners. Creating this function
3071 + * here, allows us to not have to bind or create functions for each event.
3072 + * Mutating the event's members allows us to not have to create a wrapping
3073 + * "dispatch" object that pairs the event with the listener.
3074 + */
3075 +function accumulateDirectionalDispatches(inst, phase, event) {
3076 + if ("development" !== 'production') {
3077 + "development" !== 'production' ? warning(inst, 'Dispatching inst must not be null') : void 0;
3078 + }
3079 + var listener = listenerAtPhase(inst, event, phase);
3080 + if (listener) {
3081 + event._dispatchListeners = accumulateInto(event._dispatchListeners, listener);
3082 + event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);
3083 + }
3084 +}
3085 +
3086 +/**
3087 + * Collect dispatches (must be entirely collected before dispatching - see unit
3088 + * tests). Lazily allocate the array to conserve memory. We must loop through
3089 + * each event and perform the traversal for each one. We cannot perform a
3090 + * single traversal for the entire collection of events because each event may
3091 + * have a different target.
3092 + */
3093 +function accumulateTwoPhaseDispatchesSingle(event) {
3094 + if (event && event.dispatchConfig.phasedRegistrationNames) {
3095 + ReactTreeTraversal.traverseTwoPhase(event._targetInst, accumulateDirectionalDispatches, event);
3096 + }
3097 +}
3098 +
3099 +/**
3100 + * Same as `accumulateTwoPhaseDispatchesSingle`, but skips over the targetID.
3101 + */
3102 +function accumulateTwoPhaseDispatchesSingleSkipTarget(event) {
3103 + if (event && event.dispatchConfig.phasedRegistrationNames) {
3104 + var targetInst = event._targetInst;
3105 + var parentInst = targetInst ? ReactTreeTraversal.getParentInstance(targetInst) : null;
3106 + ReactTreeTraversal.traverseTwoPhase(parentInst, accumulateDirectionalDispatches, event);
3107 + }
3108 +}
3109 +
3110 +/**
3111 + * Accumulates without regard to direction, does not look for phased
3112 + * registration names. Same as `accumulateDirectDispatchesSingle` but without
3113 + * requiring that the `dispatchMarker` be the same as the dispatched ID.
3114 + */
3115 +function accumulateDispatches(inst, ignoredDirection, event) {
3116 + if (event && event.dispatchConfig.registrationName) {
3117 + var registrationName = event.dispatchConfig.registrationName;
3118 + var listener = getListener(inst, registrationName);
3119 + if (listener) {
3120 + event._dispatchListeners = accumulateInto(event._dispatchListeners, listener);
3121 + event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);
3122 + }
3123 + }
3124 +}
3125 +
3126 +/**
3127 + * Accumulates dispatches on an `SyntheticEvent`, but only for the
3128 + * `dispatchMarker`.
3129 + * @param {SyntheticEvent} event
3130 + */
3131 +function accumulateDirectDispatchesSingle(event) {
3132 + if (event && event.dispatchConfig.registrationName) {
3133 + accumulateDispatches(event._targetInst, null, event);
3134 + }
3135 +}
3136 +
3137 +function accumulateTwoPhaseDispatches(events) {
3138 + forEachAccumulated(events, accumulateTwoPhaseDispatchesSingle);
3139 +}
3140 +
3141 +function accumulateTwoPhaseDispatchesSkipTarget(events) {
3142 + forEachAccumulated(events, accumulateTwoPhaseDispatchesSingleSkipTarget);
3143 +}
3144 +
3145 +function accumulateEnterLeaveDispatches(leave, enter, from, to) {
3146 + ReactTreeTraversal.traverseEnterLeave(from, to, accumulateDispatches, leave, enter);
3147 +}
3148 +
3149 +function accumulateDirectDispatches(events) {
3150 + forEachAccumulated(events, accumulateDirectDispatchesSingle);
3151 +}
3152 +
3153 +/**
3154 + * A small set of propagation patterns, each of which will accept a small amount
3155 + * of information, and generate a set of "dispatch ready event objects" - which
3156 + * are sets of events that have already been annotated with a set of dispatched
3157 + * listener functions/ids. The API is designed this way to discourage these
3158 + * propagation strategies from actually executing the dispatches, since we
3159 + * always want to collect the entire set of dispatches before executing event a
3160 + * single one.
3161 + *
3162 + * @constructor EventPropagators
3163 + */
3164 +var EventPropagators = {
3165 + accumulateTwoPhaseDispatches: accumulateTwoPhaseDispatches,
3166 + accumulateTwoPhaseDispatchesSkipTarget: accumulateTwoPhaseDispatchesSkipTarget,
3167 + accumulateDirectDispatches: accumulateDirectDispatches,
3168 + accumulateEnterLeaveDispatches: accumulateEnterLeaveDispatches
3169 +};
3170 +
3171 +module.exports = EventPropagators;
3172 +},{"107":107,"115":115,"164":164,"17":17,"83":83}],21:[function(_dereq_,module,exports){
3173 +/**
3174 + * Copyright 2013-present, Facebook, Inc.
3175 + * All rights reserved.
3176 + *
3177 + * This source code is licensed under the BSD-style license found in the
3178 + * LICENSE file in the root directory of this source tree. An additional grant
3179 + * of patent rights can be found in the PATENTS file in the same directory.
3180 + *
3181 + */
3182 +
3183 +'use strict';
3184 +
3185 +var _assign = _dereq_(165);
3186 +
3187 +var PooledClass = _dereq_(24);
3188 +
3189 +var getTextContentAccessor = _dereq_(126);
3190 +
3191 +/**
3192 + * This helper class stores information about text content of a target node,
3193 + * allowing comparison of content before and after a given event.
3194 + *
3195 + * Identify the node where selection currently begins, then observe
3196 + * both its text content and its current position in the DOM. Since the
3197 + * browser may natively replace the target node during composition, we can
3198 + * use its position to find its replacement.
3199 + *
3200 + * @param {DOMEventTarget} root
3201 + */
3202 +function FallbackCompositionState(root) {
3203 + this._root = root;
3204 + this._startText = this.getText();
3205 + this._fallbackText = null;
3206 +}
3207 +
3208 +_assign(FallbackCompositionState.prototype, {
3209 + destructor: function () {
3210 + this._root = null;
3211 + this._startText = null;
3212 + this._fallbackText = null;
3213 + },
3214 +
3215 + /**
3216 + * Get current text of input.
3217 + *
3218 + * @return {string}
3219 + */
3220 + getText: function () {
3221 + if ('value' in this._root) {
3222 + return this._root.value;
3223 + }
3224 + return this._root[getTextContentAccessor()];
3225 + },
3226 +
3227 + /**
3228 + * Determine the differing substring between the initially stored
3229 + * text content and the current content.
3230 + *
3231 + * @return {string}
3232 + */
3233 + getData: function () {
3234 + if (this._fallbackText) {
3235 + return this._fallbackText;
3236 + }
3237 +
3238 + var start;
3239 + var startValue = this._startText;
3240 + var startLength = startValue.length;
3241 + var end;
3242 + var endValue = this.getText();
3243 + var endLength = endValue.length;
3244 +
3245 + for (start = 0; start < startLength; start++) {
3246 + if (startValue[start] !== endValue[start]) {
3247 + break;
3248 + }
3249 + }
3250 +
3251 + var minEnd = startLength - start;
3252 + for (end = 1; end <= minEnd; end++) {
3253 + if (startValue[startLength - end] !== endValue[endLength - end]) {
3254 + break;
3255 + }
3256 + }
3257 +
3258 + var sliceTail = end > 1 ? 1 - end : undefined;
3259 + this._fallbackText = endValue.slice(start, sliceTail);
3260 + return this._fallbackText;
3261 + }
3262 +});
3263 +
3264 +PooledClass.addPoolingTo(FallbackCompositionState);
3265 +
3266 +module.exports = FallbackCompositionState;
3267 +},{"126":126,"165":165,"24":24}],22:[function(_dereq_,module,exports){
3268 +/**
3269 + * Copyright 2013-present, Facebook, Inc.
3270 + * All rights reserved.
3271 + *
3272 + * This source code is licensed under the BSD-style license found in the
3273 + * LICENSE file in the root directory of this source tree. An additional grant
3274 + * of patent rights can be found in the PATENTS file in the same directory.
3275 + *
3276 + */
3277 +
3278 +'use strict';
3279 +
3280 +var DOMProperty = _dereq_(12);
3281 +
3282 +var MUST_USE_PROPERTY = DOMProperty.injection.MUST_USE_PROPERTY;
3283 +var HAS_BOOLEAN_VALUE = DOMProperty.injection.HAS_BOOLEAN_VALUE;
3284 +var HAS_NUMERIC_VALUE = DOMProperty.injection.HAS_NUMERIC_VALUE;
3285 +var HAS_POSITIVE_NUMERIC_VALUE = DOMProperty.injection.HAS_POSITIVE_NUMERIC_VALUE;
3286 +var HAS_OVERLOADED_BOOLEAN_VALUE = DOMProperty.injection.HAS_OVERLOADED_BOOLEAN_VALUE;
3287 +
3288 +var HTMLDOMPropertyConfig = {
3289 + isCustomAttribute: RegExp.prototype.test.bind(new RegExp('^(data|aria)-[' + DOMProperty.ATTRIBUTE_NAME_CHAR + ']*$')),
3290 + Properties: {
3291 + /**
3292 + * Standard Properties
3293 + */
3294 + accept: 0,
3295 + acceptCharset: 0,
3296 + accessKey: 0,
3297 + action: 0,
3298 + allowFullScreen: HAS_BOOLEAN_VALUE,
3299 + allowTransparency: 0,
3300 + alt: 0,
3301 + // specifies target context for links with `preload` type
3302 + as: 0,
3303 + async: HAS_BOOLEAN_VALUE,
3304 + autoComplete: 0,
3305 + // autoFocus is polyfilled/normalized by AutoFocusUtils
3306 + // autoFocus: HAS_BOOLEAN_VALUE,
3307 + autoPlay: HAS_BOOLEAN_VALUE,
3308 + capture: HAS_BOOLEAN_VALUE,
3309 + cellPadding: 0,
3310 + cellSpacing: 0,
3311 + charSet: 0,
3312 + challenge: 0,
3313 + checked: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,
3314 + cite: 0,
3315 + classID: 0,
3316 + className: 0,
3317 + cols: HAS_POSITIVE_NUMERIC_VALUE,
3318 + colSpan: 0,
3319 + content: 0,
3320 + contentEditable: 0,
3321 + contextMenu: 0,
3322 + controls: HAS_BOOLEAN_VALUE,
3323 + coords: 0,
3324 + crossOrigin: 0,
3325 + data: 0, // For `<object />` acts as `src`.
3326 + dateTime: 0,
3327 + 'default': HAS_BOOLEAN_VALUE,
3328 + defer: HAS_BOOLEAN_VALUE,
3329 + dir: 0,
3330 + disabled: HAS_BOOLEAN_VALUE,
3331 + download: HAS_OVERLOADED_BOOLEAN_VALUE,
3332 + draggable: 0,
3333 + encType: 0,
3334 + form: 0,
3335 + formAction: 0,
3336 + formEncType: 0,
3337 + formMethod: 0,
3338 + formNoValidate: HAS_BOOLEAN_VALUE,
3339 + formTarget: 0,
3340 + frameBorder: 0,
3341 + headers: 0,
3342 + height: 0,
3343 + hidden: HAS_BOOLEAN_VALUE,
3344 + high: 0,
3345 + href: 0,
3346 + hrefLang: 0,
3347 + htmlFor: 0,
3348 + httpEquiv: 0,
3349 + id: 0,
3350 + inputMode: 0,
3351 + integrity: 0,
3352 + is: 0,
3353 + keyParams: 0,
3354 + keyType: 0,
3355 + kind: 0,
3356 + label: 0,
3357 + lang: 0,
3358 + list: 0,
3359 + loop: HAS_BOOLEAN_VALUE,
3360 + low: 0,
3361 + manifest: 0,
3362 + marginHeight: 0,
3363 + marginWidth: 0,
3364 + max: 0,
3365 + maxLength: 0,
3366 + media: 0,
3367 + mediaGroup: 0,
3368 + method: 0,
3369 + min: 0,
3370 + minLength: 0,
3371 + // Caution; `option.selected` is not updated if `select.multiple` is
3372 + // disabled with `removeAttribute`.
3373 + multiple: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,
3374 + muted: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,
3375 + name: 0,
3376 + nonce: 0,
3377 + noValidate: HAS_BOOLEAN_VALUE,
3378 + open: HAS_BOOLEAN_VALUE,
3379 + optimum: 0,
3380 + pattern: 0,
3381 + placeholder: 0,
3382 + playsInline: HAS_BOOLEAN_VALUE,
3383 + poster: 0,
3384 + preload: 0,
3385 + profile: 0,
3386 + radioGroup: 0,
3387 + readOnly: HAS_BOOLEAN_VALUE,
3388 + referrerPolicy: 0,
3389 + rel: 0,
3390 + required: HAS_BOOLEAN_VALUE,
3391 + reversed: HAS_BOOLEAN_VALUE,
3392 + role: 0,
3393 + rows: HAS_POSITIVE_NUMERIC_VALUE,
3394 + rowSpan: HAS_NUMERIC_VALUE,
3395 + sandbox: 0,
3396 + scope: 0,
3397 + scoped: HAS_BOOLEAN_VALUE,
3398 + scrolling: 0,
3399 + seamless: HAS_BOOLEAN_VALUE,
3400 + selected: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,
3401 + shape: 0,
3402 + size: HAS_POSITIVE_NUMERIC_VALUE,
3403 + sizes: 0,
3404 + // support for projecting regular DOM Elements via V1 named slots ( shadow dom )
3405 + slot: 0,
3406 + span: HAS_POSITIVE_NUMERIC_VALUE,
3407 + spellCheck: 0,
3408 + src: 0,
3409 + srcDoc: 0,
3410 + srcLang: 0,
3411 + srcSet: 0,
3412 + start: HAS_NUMERIC_VALUE,
3413 + step: 0,
3414 + style: 0,
3415 + summary: 0,
3416 + tabIndex: 0,
3417 + target: 0,
3418 + title: 0,
3419 + // Setting .type throws on non-<input> tags
3420 + type: 0,
3421 + useMap: 0,
3422 + value: 0,
3423 + width: 0,
3424 + wmode: 0,
3425 + wrap: 0,
3426 +
3427 + /**
3428 + * RDFa Properties
3429 + */
3430 + about: 0,
3431 + datatype: 0,
3432 + inlist: 0,
3433 + prefix: 0,
3434 + // property is also supported for OpenGraph in meta tags.
3435 + property: 0,
3436 + resource: 0,
3437 + 'typeof': 0,
3438 + vocab: 0,
3439 +
3440 + /**
3441 + * Non-standard Properties
3442 + */
3443 + // autoCapitalize and autoCorrect are supported in Mobile Safari for
3444 + // keyboard hints.
3445 + autoCapitalize: 0,
3446 + autoCorrect: 0,
3447 + // autoSave allows WebKit/Blink to persist values of input fields on page reloads
3448 + autoSave: 0,
3449 + // color is for Safari mask-icon link
3450 + color: 0,
3451 + // itemProp, itemScope, itemType are for
3452 + // Microdata support. See http://schema.org/docs/gs.html
3453 + itemProp: 0,
3454 + itemScope: HAS_BOOLEAN_VALUE,
3455 + itemType: 0,
3456 + // itemID and itemRef are for Microdata support as well but
3457 + // only specified in the WHATWG spec document. See
3458 + // https://html.spec.whatwg.org/multipage/microdata.html#microdata-dom-api
3459 + itemID: 0,
3460 + itemRef: 0,
3461 + // results show looking glass icon and recent searches on input
3462 + // search fields in WebKit/Blink
3463 + results: 0,
3464 + // IE-only attribute that specifies security restrictions on an iframe
3465 + // as an alternative to the sandbox attribute on IE<10
3466 + security: 0,
3467 + // IE-only attribute that controls focus behavior
3468 + unselectable: 0
3469 + },
3470 + DOMAttributeNames: {
3471 + acceptCharset: 'accept-charset',
3472 + className: 'class',
3473 + htmlFor: 'for',
3474 + httpEquiv: 'http-equiv'
3475 + },
3476 + DOMPropertyNames: {},
3477 + DOMMutationMethods: {
3478 + value: function (node, value) {
3479 + if (value == null) {
3480 + return node.removeAttribute('value');
3481 + }
3482 +
3483 + // Number inputs get special treatment due to some edge cases in
3484 + // Chrome. Let everything else assign the value attribute as normal.
3485 + // https://github.com/facebook/react/issues/7253#issuecomment-236074326
3486 + if (node.type !== 'number' || node.hasAttribute('value') === false) {
3487 + node.setAttribute('value', '' + value);
3488 + } else if (node.validity && !node.validity.badInput && node.ownerDocument.activeElement !== node) {
3489 + // Don't assign an attribute if validation reports bad
3490 + // input. Chrome will clear the value. Additionally, don't
3491 + // operate on inputs that have focus, otherwise Chrome might
3492 + // strip off trailing decimal places and cause the user's
3493 + // cursor position to jump to the beginning of the input.
3494 + //
3495 + // In ReactDOMInput, we have an onBlur event that will trigger
3496 + // this function again when focus is lost.
3497 + node.setAttribute('value', '' + value);
3498 + }
3499 + }
3500 + }
3501 +};
3502 +
3503 +module.exports = HTMLDOMPropertyConfig;
3504 +},{"12":12}],23:[function(_dereq_,module,exports){
3505 +/**
3506 + * Copyright 2013-present, Facebook, Inc.
3507 + * All rights reserved.
3508 + *
3509 + * This source code is licensed under the BSD-style license found in the
3510 + * LICENSE file in the root directory of this source tree. An additional grant
3511 + * of patent rights can be found in the PATENTS file in the same directory.
3512 + *
3513 + *
3514 + */
3515 +
3516 +'use strict';
3517 +
3518 +/**
3519 + * Escape and wrap key so it is safe to use as a reactid
3520 + *
3521 + * @param {string} key to be escaped.
3522 + * @return {string} the escaped key.
3523 + */
3524 +
3525 +function escape(key) {
3526 + var escapeRegex = /[=:]/g;
3527 + var escaperLookup = {
3528 + '=': '=0',
3529 + ':': '=2'
3530 + };
3531 + var escapedString = ('' + key).replace(escapeRegex, function (match) {
3532 + return escaperLookup[match];
3533 + });
3534 +
3535 + return '$' + escapedString;
3536 +}
3537 +
3538 +/**
3539 + * Unescape and unwrap key for human-readable display
3540 + *
3541 + * @param {string} key to unescape.
3542 + * @return {string} the unescaped key.
3543 + */
3544 +function unescape(key) {
3545 + var unescapeRegex = /(=0|=2)/g;
3546 + var unescaperLookup = {
3547 + '=0': '=',
3548 + '=2': ':'
3549 + };
3550 + var keySubstring = key[0] === '.' && key[1] === '$' ? key.substring(2) : key.substring(1);
3551 +
3552 + return ('' + keySubstring).replace(unescapeRegex, function (match) {
3553 + return unescaperLookup[match];
3554 + });
3555 +}
3556 +
3557 +var KeyEscapeUtils = {
3558 + escape: escape,
3559 + unescape: unescape
3560 +};
3561 +
3562 +module.exports = KeyEscapeUtils;
3563 +},{}],24:[function(_dereq_,module,exports){
3564 +/**
3565 + * Copyright 2013-present, Facebook, Inc.
3566 + * All rights reserved.
3567 + *
3568 + * This source code is licensed under the BSD-style license found in the
3569 + * LICENSE file in the root directory of this source tree. An additional grant
3570 + * of patent rights can be found in the PATENTS file in the same directory.
3571 + *
3572 + *
3573 + */
3574 +
3575 +'use strict';
3576 +
3577 +var _prodInvariant = _dereq_(133);
3578 +
3579 +var invariant = _dereq_(157);
3580 +
3581 +/**
3582 + * Static poolers. Several custom versions for each potential number of
3583 + * arguments. A completely generic pooler is easy to implement, but would
3584 + * require accessing the `arguments` object. In each of these, `this` refers to
3585 + * the Class itself, not an instance. If any others are needed, simply add them
3586 + * here, or in their own files.
3587 + */
3588 +var oneArgumentPooler = function (copyFieldsFrom) {
3589 + var Klass = this;
3590 + if (Klass.instancePool.length) {
3591 + var instance = Klass.instancePool.pop();
3592 + Klass.call(instance, copyFieldsFrom);
3593 + return instance;
3594 + } else {
3595 + return new Klass(copyFieldsFrom);
3596 + }
3597 +};
3598 +
3599 +var twoArgumentPooler = function (a1, a2) {
3600 + var Klass = this;
3601 + if (Klass.instancePool.length) {
3602 + var instance = Klass.instancePool.pop();
3603 + Klass.call(instance, a1, a2);
3604 + return instance;
3605 + } else {
3606 + return new Klass(a1, a2);
3607 + }
3608 +};
3609 +
3610 +var threeArgumentPooler = function (a1, a2, a3) {
3611 + var Klass = this;
3612 + if (Klass.instancePool.length) {
3613 + var instance = Klass.instancePool.pop();
3614 + Klass.call(instance, a1, a2, a3);
3615 + return instance;
3616 + } else {
3617 + return new Klass(a1, a2, a3);
3618 + }
3619 +};
3620 +
3621 +var fourArgumentPooler = function (a1, a2, a3, a4) {
3622 + var Klass = this;
3623 + if (Klass.instancePool.length) {
3624 + var instance = Klass.instancePool.pop();
3625 + Klass.call(instance, a1, a2, a3, a4);
3626 + return instance;
3627 + } else {
3628 + return new Klass(a1, a2, a3, a4);
3629 + }
3630 +};
3631 +
3632 +var standardReleaser = function (instance) {
3633 + var Klass = this;
3634 + !(instance instanceof Klass) ? "development" !== 'production' ? invariant(false, 'Trying to release an instance into a pool of a different type.') : _prodInvariant('25') : void 0;
3635 + instance.destructor();
3636 + if (Klass.instancePool.length < Klass.poolSize) {
3637 + Klass.instancePool.push(instance);
3638 + }
3639 +};
3640 +
3641 +var DEFAULT_POOL_SIZE = 10;
3642 +var DEFAULT_POOLER = oneArgumentPooler;
3643 +
3644 +/**
3645 + * Augments `CopyConstructor` to be a poolable class, augmenting only the class
3646 + * itself (statically) not adding any prototypical fields. Any CopyConstructor
3647 + * you give this may have a `poolSize` property, and will look for a
3648 + * prototypical `destructor` on instances.
3649 + *
3650 + * @param {Function} CopyConstructor Constructor that can be used to reset.
3651 + * @param {Function} pooler Customizable pooler.
3652 + */
3653 +var addPoolingTo = function (CopyConstructor, pooler) {
3654 + // Casting as any so that flow ignores the actual implementation and trusts
3655 + // it to match the type we declared
3656 + var NewKlass = CopyConstructor;
3657 + NewKlass.instancePool = [];
3658 + NewKlass.getPooled = pooler || DEFAULT_POOLER;
3659 + if (!NewKlass.poolSize) {
3660 + NewKlass.poolSize = DEFAULT_POOL_SIZE;
3661 + }
3662 + NewKlass.release = standardReleaser;
3663 + return NewKlass;
3664 +};
3665 +
3666 +var PooledClass = {
3667 + addPoolingTo: addPoolingTo,
3668 + oneArgumentPooler: oneArgumentPooler,
3669 + twoArgumentPooler: twoArgumentPooler,
3670 + threeArgumentPooler: threeArgumentPooler,
3671 + fourArgumentPooler: fourArgumentPooler
3672 +};
3673 +
3674 +module.exports = PooledClass;
3675 +},{"133":133,"157":157}],25:[function(_dereq_,module,exports){
3676 +/**
3677 + * Copyright 2013-present, Facebook, Inc.
3678 + * All rights reserved.
3679 + *
3680 + * This source code is licensed under the BSD-style license found in the
3681 + * LICENSE file in the root directory of this source tree. An additional grant
3682 + * of patent rights can be found in the PATENTS file in the same directory.
3683 + *
3684 + */
3685 +
3686 +'use strict';
3687 +
3688 +var _assign = _dereq_(165);
3689 +
3690 +var EventPluginRegistry = _dereq_(18);
3691 +var ReactEventEmitterMixin = _dereq_(58);
3692 +var ViewportMetrics = _dereq_(106);
3693 +
3694 +var getVendorPrefixedEventName = _dereq_(127);
3695 +var isEventSupported = _dereq_(130);
3696 +
3697 +/**
3698 + * Summary of `ReactBrowserEventEmitter` event handling:
3699 + *
3700 + * - Top-level delegation is used to trap most native browser events. This
3701 + * may only occur in the main thread and is the responsibility of
3702 + * ReactEventListener, which is injected and can therefore support pluggable
3703 + * event sources. This is the only work that occurs in the main thread.
3704 + *
3705 + * - We normalize and de-duplicate events to account for browser quirks. This
3706 + * may be done in the worker thread.
3707 + *
3708 + * - Forward these native events (with the associated top-level type used to
3709 + * trap it) to `EventPluginHub`, which in turn will ask plugins if they want
3710 + * to extract any synthetic events.
3711 + *
3712 + * - The `EventPluginHub` will then process each event by annotating them with
3713 + * "dispatches", a sequence of listeners and IDs that care about that event.
3714 + *
3715 + * - The `EventPluginHub` then dispatches the events.
3716 + *
3717 + * Overview of React and the event system:
3718 + *
3719 + * +------------+ .
3720 + * | DOM | .
3721 + * +------------+ .
3722 + * | .
3723 + * v .
3724 + * +------------+ .
3725 + * | ReactEvent | .
3726 + * | Listener | .
3727 + * +------------+ . +-----------+
3728 + * | . +--------+|SimpleEvent|
3729 + * | . | |Plugin |
3730 + * +-----|------+ . v +-----------+
3731 + * | | | . +--------------+ +------------+
3732 + * | +-----------.--->|EventPluginHub| | Event |
3733 + * | | . | | +-----------+ | Propagators|
3734 + * | ReactEvent | . | | |TapEvent | |------------|
3735 + * | Emitter | . | |<---+|Plugin | |other plugin|
3736 + * | | . | | +-----------+ | utilities |
3737 + * | +-----------.--->| | +------------+
3738 + * | | | . +--------------+
3739 + * +-----|------+ . ^ +-----------+
3740 + * | . | |Enter/Leave|
3741 + * + . +-------+|Plugin |
3742 + * +-------------+ . +-----------+
3743 + * | application | .
3744 + * |-------------| .
3745 + * | | .
3746 + * | | .
3747 + * +-------------+ .
3748 + * .
3749 + * React Core . General Purpose Event Plugin System
3750 + */
3751 +
3752 +var hasEventPageXY;
3753 +var alreadyListeningTo = {};
3754 +var isMonitoringScrollValue = false;
3755 +var reactTopListenersCounter = 0;
3756 +
3757 +// For events like 'submit' which don't consistently bubble (which we trap at a
3758 +// lower node than `document`), binding at `document` would cause duplicate
3759 +// events so we don't include them here
3760 +var topEventMapping = {
3761 + topAbort: 'abort',
3762 + topAnimationEnd: getVendorPrefixedEventName('animationend') || 'animationend',
3763 + topAnimationIteration: getVendorPrefixedEventName('animationiteration') || 'animationiteration',
3764 + topAnimationStart: getVendorPrefixedEventName('animationstart') || 'animationstart',
3765 + topBlur: 'blur',
3766 + topCanPlay: 'canplay',
3767 + topCanPlayThrough: 'canplaythrough',
3768 + topChange: 'change',
3769 + topClick: 'click',
3770 + topCompositionEnd: 'compositionend',
3771 + topCompositionStart: 'compositionstart',
3772 + topCompositionUpdate: 'compositionupdate',
3773 + topContextMenu: 'contextmenu',
3774 + topCopy: 'copy',
3775 + topCut: 'cut',
3776 + topDoubleClick: 'dblclick',
3777 + topDrag: 'drag',
3778 + topDragEnd: 'dragend',
3779 + topDragEnter: 'dragenter',
3780 + topDragExit: 'dragexit',
3781 + topDragLeave: 'dragleave',
3782 + topDragOver: 'dragover',
3783 + topDragStart: 'dragstart',
3784 + topDrop: 'drop',
3785 + topDurationChange: 'durationchange',
3786 + topEmptied: 'emptied',
3787 + topEncrypted: 'encrypted',
3788 + topEnded: 'ended',
3789 + topError: 'error',
3790 + topFocus: 'focus',
3791 + topInput: 'input',
3792 + topKeyDown: 'keydown',
3793 + topKeyPress: 'keypress',
3794 + topKeyUp: 'keyup',
3795 + topLoadedData: 'loadeddata',
3796 + topLoadedMetadata: 'loadedmetadata',
3797 + topLoadStart: 'loadstart',
3798 + topMouseDown: 'mousedown',
3799 + topMouseMove: 'mousemove',
3800 + topMouseOut: 'mouseout',
3801 + topMouseOver: 'mouseover',
3802 + topMouseUp: 'mouseup',
3803 + topPaste: 'paste',
3804 + topPause: 'pause',
3805 + topPlay: 'play',
3806 + topPlaying: 'playing',
3807 + topProgress: 'progress',
3808 + topRateChange: 'ratechange',
3809 + topScroll: 'scroll',
3810 + topSeeked: 'seeked',
3811 + topSeeking: 'seeking',
3812 + topSelectionChange: 'selectionchange',
3813 + topStalled: 'stalled',
3814 + topSuspend: 'suspend',
3815 + topTextInput: 'textInput',
3816 + topTimeUpdate: 'timeupdate',
3817 + topTouchCancel: 'touchcancel',
3818 + topTouchEnd: 'touchend',
3819 + topTouchMove: 'touchmove',
3820 + topTouchStart: 'touchstart',
3821 + topTransitionEnd: getVendorPrefixedEventName('transitionend') || 'transitionend',
3822 + topVolumeChange: 'volumechange',
3823 + topWaiting: 'waiting',
3824 + topWheel: 'wheel'
3825 +};
3826 +
3827 +/**
3828 + * To ensure no conflicts with other potential React instances on the page
3829 + */
3830 +var topListenersIDKey = '_reactListenersID' + String(Math.random()).slice(2);
3831 +
3832 +function getListeningForDocument(mountAt) {
3833 + // In IE8, `mountAt` is a host object and doesn't have `hasOwnProperty`
3834 + // directly.
3835 + if (!Object.prototype.hasOwnProperty.call(mountAt, topListenersIDKey)) {
3836 + mountAt[topListenersIDKey] = reactTopListenersCounter++;
3837 + alreadyListeningTo[mountAt[topListenersIDKey]] = {};
3838 + }
3839 + return alreadyListeningTo[mountAt[topListenersIDKey]];
3840 +}
3841 +
3842 +var ReactBrowserEventEmitter = _assign({}, ReactEventEmitterMixin, {
3843 +
3844 + /**
3845 + * Injectable event backend
3846 + */
3847 + ReactEventListener: null,
3848 +
3849 + injection: {
3850 + /**
3851 + * @param {object} ReactEventListener
3852 + */
3853 + injectReactEventListener: function (ReactEventListener) {
3854 + ReactEventListener.setHandleTopLevel(ReactBrowserEventEmitter.handleTopLevel);
3855 + ReactBrowserEventEmitter.ReactEventListener = ReactEventListener;
3856 + }
3857 + },
3858 +
3859 + /**
3860 + * Sets whether or not any created callbacks should be enabled.
3861 + *
3862 + * @param {boolean} enabled True if callbacks should be enabled.
3863 + */
3864 + setEnabled: function (enabled) {
3865 + if (ReactBrowserEventEmitter.ReactEventListener) {
3866 + ReactBrowserEventEmitter.ReactEventListener.setEnabled(enabled);
3867 + }
3868 + },
3869 +
3870 + /**
3871 + * @return {boolean} True if callbacks are enabled.
3872 + */
3873 + isEnabled: function () {
3874 + return !!(ReactBrowserEventEmitter.ReactEventListener && ReactBrowserEventEmitter.ReactEventListener.isEnabled());
3875 + },
3876 +
3877 + /**
3878 + * We listen for bubbled touch events on the document object.
3879 + *
3880 + * Firefox v8.01 (and possibly others) exhibited strange behavior when
3881 + * mounting `onmousemove` events at some node that was not the document
3882 + * element. The symptoms were that if your mouse is not moving over something
3883 + * contained within that mount point (for example on the background) the
3884 + * top-level listeners for `onmousemove` won't be called. However, if you
3885 + * register the `mousemove` on the document object, then it will of course
3886 + * catch all `mousemove`s. This along with iOS quirks, justifies restricting
3887 + * top-level listeners to the document object only, at least for these
3888 + * movement types of events and possibly all events.
3889 + *
3890 + * @see http://www.quirksmode.org/blog/archives/2010/09/click_event_del.html
3891 + *
3892 + * Also, `keyup`/`keypress`/`keydown` do not bubble to the window on IE, but
3893 + * they bubble to document.
3894 + *
3895 + * @param {string} registrationName Name of listener (e.g. `onClick`).
3896 + * @param {object} contentDocumentHandle Document which owns the container
3897 + */
3898 + listenTo: function (registrationName, contentDocumentHandle) {
3899 + var mountAt = contentDocumentHandle;
3900 + var isListening = getListeningForDocument(mountAt);
3901 + var dependencies = EventPluginRegistry.registrationNameDependencies[registrationName];
3902 +
3903 + for (var i = 0; i < dependencies.length; i++) {
3904 + var dependency = dependencies[i];
3905 + if (!(isListening.hasOwnProperty(dependency) && isListening[dependency])) {
3906 + if (dependency === 'topWheel') {
3907 + if (isEventSupported('wheel')) {
3908 + ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent('topWheel', 'wheel', mountAt);
3909 + } else if (isEventSupported('mousewheel')) {
3910 + ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent('topWheel', 'mousewheel', mountAt);
3911 + } else {
3912 + // Firefox needs to capture a different mouse scroll event.
3913 + // @see http://www.quirksmode.org/dom/events/tests/scroll.html
3914 + ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent('topWheel', 'DOMMouseScroll', mountAt);
3915 + }
3916 + } else if (dependency === 'topScroll') {
3917 +
3918 + if (isEventSupported('scroll', true)) {
3919 + ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent('topScroll', 'scroll', mountAt);
3920 + } else {
3921 + ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent('topScroll', 'scroll', ReactBrowserEventEmitter.ReactEventListener.WINDOW_HANDLE);
3922 + }
3923 + } else if (dependency === 'topFocus' || dependency === 'topBlur') {
3924 +
3925 + if (isEventSupported('focus', true)) {
3926 + ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent('topFocus', 'focus', mountAt);
3927 + ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent('topBlur', 'blur', mountAt);
3928 + } else if (isEventSupported('focusin')) {
3929 + // IE has `focusin` and `focusout` events which bubble.
3930 + // @see http://www.quirksmode.org/blog/archives/2008/04/delegating_the.html
3931 + ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent('topFocus', 'focusin', mountAt);
3932 + ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent('topBlur', 'focusout', mountAt);
3933 + }
3934 +
3935 + // to make sure blur and focus event listeners are only attached once
3936 + isListening.topBlur = true;
3937 + isListening.topFocus = true;
3938 + } else if (topEventMapping.hasOwnProperty(dependency)) {
3939 + ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(dependency, topEventMapping[dependency], mountAt);
3940 + }
3941 +
3942 + isListening[dependency] = true;
3943 + }
3944 + }
3945 + },
3946 +
3947 + isListeningToAllDependencies: function (registrationName, mountAt) {
3948 + var isListening = getListeningForDocument(mountAt);
3949 + var dependencies = EventPluginRegistry.registrationNameDependencies[registrationName];
3950 + for (var i = 0; i < dependencies.length; i++) {
3951 + var dependency = dependencies[i];
3952 + if (!(isListening.hasOwnProperty(dependency) && isListening[dependency])) {
3953 + return false;
3954 + }
3955 + }
3956 + return true;
3957 + },
3958 +
3959 + trapBubbledEvent: function (topLevelType, handlerBaseName, handle) {
3960 + return ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(topLevelType, handlerBaseName, handle);
3961 + },
3962 +
3963 + trapCapturedEvent: function (topLevelType, handlerBaseName, handle) {
3964 + return ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent(topLevelType, handlerBaseName, handle);
3965 + },
3966 +
3967 + /**
3968 + * Protect against document.createEvent() returning null
3969 + * Some popup blocker extensions appear to do this:
3970 + * https://github.com/facebook/react/issues/6887
3971 + */
3972 + supportsEventPageXY: function () {
3973 + if (!document.createEvent) {
3974 + return false;
3975 + }
3976 + var ev = document.createEvent('MouseEvent');
3977 + return ev != null && 'pageX' in ev;
3978 + },
3979 +
3980 + /**
3981 + * Listens to window scroll and resize events. We cache scroll values so that
3982 + * application code can access them without triggering reflows.
3983 + *
3984 + * ViewportMetrics is only used by SyntheticMouse/TouchEvent and only when
3985 + * pageX/pageY isn't supported (legacy browsers).
3986 + *
3987 + * NOTE: Scroll events do not bubble.
3988 + *
3989 + * @see http://www.quirksmode.org/dom/events/scroll.html
3990 + */
3991 + ensureScrollValueMonitoring: function () {
3992 + if (hasEventPageXY === undefined) {
3993 + hasEventPageXY = ReactBrowserEventEmitter.supportsEventPageXY();
3994 + }
3995 + if (!hasEventPageXY && !isMonitoringScrollValue) {
3996 + var refresh = ViewportMetrics.refreshScrollValues;
3997 + ReactBrowserEventEmitter.ReactEventListener.monitorScrollValue(refresh);
3998 + isMonitoringScrollValue = true;
3999 + }
4000 + }
4001 +
4002 +});
4003 +
4004 +module.exports = ReactBrowserEventEmitter;
4005 +},{"106":106,"127":127,"130":130,"165":165,"18":18,"58":58}],26:[function(_dereq_,module,exports){
4006 +(function (process){
4007 +/**
4008 + * Copyright 2014-present, Facebook, Inc.
4009 + * All rights reserved.
4010 + *
4011 + * This source code is licensed under the BSD-style license found in the
4012 + * LICENSE file in the root directory of this source tree. An additional grant
4013 + * of patent rights can be found in the PATENTS file in the same directory.
4014 + *
4015 + */
4016 +
4017 +'use strict';
4018 +
4019 +var KeyEscapeUtils = _dereq_(23);
4020 +var ReactFeatureFlags = _dereq_(60);
4021 +var ReactReconciler = _dereq_(77);
4022 +
4023 +var instantiateReactComponent = _dereq_(129);
4024 +var shouldUpdateReactComponent = _dereq_(136);
4025 +var traverseAllChildren = _dereq_(137);
4026 +var warning = _dereq_(164);
4027 +
4028 +var ReactComponentTreeHook;
4029 +
4030 +if (typeof process !== 'undefined' && process.env && "development" === 'test') {
4031 + // Temporary hack.
4032 + // Inline requires don't work well with Jest:
4033 + // https://github.com/facebook/react/issues/7240
4034 + // Remove the inline requires when we don't need them anymore:
4035 + // https://github.com/facebook/react/pull/7178
4036 + ReactComponentTreeHook = _dereq_(139);
4037 +}
4038 +
4039 +function instantiateChild(childInstances, child, name, selfDebugID) {
4040 + // We found a component instance.
4041 + var keyUnique = childInstances[name] === undefined;
4042 + if ("development" !== 'production') {
4043 + if (!ReactComponentTreeHook) {
4044 + ReactComponentTreeHook = _dereq_(139);
4045 + }
4046 + if (!keyUnique) {
4047 + "development" !== 'production' ? warning(false, 'flattenChildren(...): Encountered two children with the same key, ' + '`%s`. Child keys must be unique; when two children share a key, only ' + 'the first child will be used.%s', KeyEscapeUtils.unescape(name), ReactComponentTreeHook.getStackAddendumByID(selfDebugID)) : void 0;
4048 + }
4049 + }
4050 + if (child != null && keyUnique) {
4051 + childInstances[name] = instantiateReactComponent(child, true);
4052 + }
4053 +}
4054 +
4055 +/**
4056 + * ReactChildReconciler provides helpers for initializing or updating a set of
4057 + * children. Its output is suitable for passing it onto ReactMultiChild which
4058 + * does diffed reordering and insertion.
4059 + */
4060 +var ReactChildReconciler = {
4061 + /**
4062 + * Generates a "mount image" for each of the supplied children. In the case
4063 + * of `ReactDOMComponent`, a mount image is a string of markup.
4064 + *
4065 + * @param {?object} nestedChildNodes Nested child maps.
4066 + * @return {?object} A set of child instances.
4067 + * @internal
4068 + */
4069 + instantiateChildren: function (nestedChildNodes, transaction, context, selfDebugID // 0 in production and for roots
4070 + ) {
4071 + if (nestedChildNodes == null) {
4072 + return null;
4073 + }
4074 + var childInstances = {};
4075 +
4076 + if ("development" !== 'production') {
4077 + traverseAllChildren(nestedChildNodes, function (childInsts, child, name) {
4078 + return instantiateChild(childInsts, child, name, selfDebugID);
4079 + }, childInstances);
4080 + } else {
4081 + traverseAllChildren(nestedChildNodes, instantiateChild, childInstances);
4082 + }
4083 + return childInstances;
4084 + },
4085 +
4086 + /**
4087 + * Updates the rendered children and returns a new set of children.
4088 + *
4089 + * @param {?object} prevChildren Previously initialized set of children.
4090 + * @param {?object} nextChildren Flat child element maps.
4091 + * @param {ReactReconcileTransaction} transaction
4092 + * @param {object} context
4093 + * @return {?object} A new set of child instances.
4094 + * @internal
4095 + */
4096 + updateChildren: function (prevChildren, nextChildren, mountImages, removedNodes, transaction, hostParent, hostContainerInfo, context, selfDebugID // 0 in production and for roots
4097 + ) {
4098 + // We currently don't have a way to track moves here but if we use iterators
4099 + // instead of for..in we can zip the iterators and check if an item has
4100 + // moved.
4101 + // TODO: If nothing has changed, return the prevChildren object so that we
4102 + // can quickly bailout if nothing has changed.
4103 + if (!nextChildren && !prevChildren) {
4104 + return;
4105 + }
4106 + var name;
4107 + var prevChild;
4108 + for (name in nextChildren) {
4109 + if (!nextChildren.hasOwnProperty(name)) {
4110 + continue;
4111 + }
4112 + prevChild = prevChildren && prevChildren[name];
4113 + var prevElement = prevChild && prevChild._currentElement;
4114 + var nextElement = nextChildren[name];
4115 + if (prevChild != null && shouldUpdateReactComponent(prevElement, nextElement)) {
4116 + ReactReconciler.receiveComponent(prevChild, nextElement, transaction, context);
4117 + nextChildren[name] = prevChild;
4118 + } else {
4119 + if (!ReactFeatureFlags.prepareNewChildrenBeforeUnmountInStack && prevChild) {
4120 + removedNodes[name] = ReactReconciler.getHostNode(prevChild);
4121 + ReactReconciler.unmountComponent(prevChild, false, /* safely */
4122 + false /* skipLifecycle */
4123 + );
4124 + }
4125 + // The child must be instantiated before it's mounted.
4126 + var nextChildInstance = instantiateReactComponent(nextElement, true);
4127 + nextChildren[name] = nextChildInstance;
4128 + // Creating mount image now ensures refs are resolved in right order
4129 + // (see https://github.com/facebook/react/pull/7101 for explanation).
4130 + var nextChildMountImage = ReactReconciler.mountComponent(nextChildInstance, transaction, hostParent, hostContainerInfo, context, selfDebugID);
4131 + mountImages.push(nextChildMountImage);
4132 + if (ReactFeatureFlags.prepareNewChildrenBeforeUnmountInStack && prevChild) {
4133 + removedNodes[name] = ReactReconciler.getHostNode(prevChild);
4134 + ReactReconciler.unmountComponent(prevChild, false, /* safely */
4135 + false /* skipLifecycle */
4136 + );
4137 + }
4138 + }
4139 + }
4140 + // Unmount children that are no longer present.
4141 + for (name in prevChildren) {
4142 + if (prevChildren.hasOwnProperty(name) && !(nextChildren && nextChildren.hasOwnProperty(name))) {
4143 + prevChild = prevChildren[name];
4144 + removedNodes[name] = ReactReconciler.getHostNode(prevChild);
4145 + ReactReconciler.unmountComponent(prevChild, false, /* safely */
4146 + false /* skipLifecycle */
4147 + );
4148 + }
4149 + }
4150 + },
4151 +
4152 + /**
4153 + * Unmounts all rendered children. This should be used to clean up children
4154 + * when this component is unmounted.
4155 + *
4156 + * @param {?object} renderedChildren Previously initialized set of children.
4157 + * @internal
4158 + */
4159 + unmountChildren: function (renderedChildren, safely, skipLifecycle) {
4160 + for (var name in renderedChildren) {
4161 + if (renderedChildren.hasOwnProperty(name)) {
4162 + var renderedChild = renderedChildren[name];
4163 + ReactReconciler.unmountComponent(renderedChild, safely, skipLifecycle);
4164 + }
4165 + }
4166 + }
4167 +
4168 +};
4169 +
4170 +module.exports = ReactChildReconciler;
4171 +}).call(this,undefined)
4172 +},{"129":129,"136":136,"137":137,"139":139,"164":164,"23":23,"60":60,"77":77}],27:[function(_dereq_,module,exports){
4173 +/**
4174 + * Copyright 2013-present, Facebook, Inc.
4175 + * All rights reserved.
4176 + *
4177 + * This source code is licensed under the BSD-style license found in the
4178 + * LICENSE file in the root directory of this source tree. An additional grant
4179 + * of patent rights can be found in the PATENTS file in the same directory.
4180 + *
4181 + */
4182 +
4183 +'use strict';
4184 +
4185 +var DOMChildrenOperations = _dereq_(8);
4186 +var ReactDOMIDOperations = _dereq_(39);
4187 +
4188 +/**
4189 + * Abstracts away all functionality of the reconciler that requires knowledge of
4190 + * the browser context. TODO: These callers should be refactored to avoid the
4191 + * need for this injection.
4192 + */
4193 +var ReactComponentBrowserEnvironment = {
4194 +
4195 + processChildrenUpdates: ReactDOMIDOperations.dangerouslyProcessChildrenUpdates,
4196 +
4197 + replaceNodeWithMarkup: DOMChildrenOperations.dangerouslyReplaceNodeWithMarkup
4198 +
4199 +};
4200 +
4201 +module.exports = ReactComponentBrowserEnvironment;
4202 +},{"39":39,"8":8}],28:[function(_dereq_,module,exports){
4203 +/**
4204 + * Copyright 2014-present, Facebook, Inc.
4205 + * All rights reserved.
4206 + *
4207 + * This source code is licensed under the BSD-style license found in the
4208 + * LICENSE file in the root directory of this source tree. An additional grant
4209 + * of patent rights can be found in the PATENTS file in the same directory.
4210 + *
4211 + *
4212 + */
4213 +
4214 +'use strict';
4215 +
4216 +var _prodInvariant = _dereq_(133);
4217 +
4218 +var invariant = _dereq_(157);
4219 +
4220 +var injected = false;
4221 +
4222 +var ReactComponentEnvironment = {
4223 +
4224 + /**
4225 + * Optionally injectable hook for swapping out mount images in the middle of
4226 + * the tree.
4227 + */
4228 + replaceNodeWithMarkup: null,
4229 +
4230 + /**
4231 + * Optionally injectable hook for processing a queue of child updates. Will
4232 + * later move into MultiChildComponents.
4233 + */
4234 + processChildrenUpdates: null,
4235 +
4236 + injection: {
4237 + injectEnvironment: function (environment) {
4238 + !!injected ? "development" !== 'production' ? invariant(false, 'ReactCompositeComponent: injectEnvironment() can only be called once.') : _prodInvariant('104') : void 0;
4239 + ReactComponentEnvironment.replaceNodeWithMarkup = environment.replaceNodeWithMarkup;
4240 + ReactComponentEnvironment.processChildrenUpdates = environment.processChildrenUpdates;
4241 + injected = true;
4242 + }
4243 + }
4244 +
4245 +};
4246 +
4247 +module.exports = ReactComponentEnvironment;
4248 +},{"133":133,"157":157}],29:[function(_dereq_,module,exports){
4249 +/**
4250 + * Copyright 2013-present, Facebook, Inc.
4251 + * All rights reserved.
4252 + *
4253 + * This source code is licensed under the BSD-style license found in the
4254 + * LICENSE file in the root directory of this source tree. An additional grant
4255 + * of patent rights can be found in the PATENTS file in the same directory.
4256 + *
4257 + */
4258 +
4259 +'use strict';
4260 +
4261 +var _prodInvariant = _dereq_(133),
4262 + _assign = _dereq_(165);
4263 +
4264 +var React = _dereq_(141);
4265 +var ReactComponentEnvironment = _dereq_(28);
4266 +var ReactCurrentOwner = _dereq_(140);
4267 +var ReactErrorUtils = _dereq_(57);
4268 +var ReactFeatureFlags = _dereq_(60);
4269 +var ReactInstanceMap = _dereq_(66);
4270 +var ReactInstrumentation = _dereq_(67);
4271 +var ReactNodeTypes = _dereq_(72);
4272 +var ReactReconciler = _dereq_(77);
4273 +
4274 +if ("development" !== 'production') {
4275 + var checkReactTypeSpec = _dereq_(109);
4276 +}
4277 +
4278 +var emptyObject = _dereq_(150);
4279 +var invariant = _dereq_(157);
4280 +var shallowEqual = _dereq_(163);
4281 +var shouldUpdateReactComponent = _dereq_(136);
4282 +var warning = _dereq_(164);
4283 +
4284 +var CompositeTypes = {
4285 + ImpureClass: 0,
4286 + PureClass: 1,
4287 + StatelessFunctional: 2
4288 +};
4289 +
4290 +function StatelessComponent(Component) {}
4291 +StatelessComponent.prototype.render = function () {
4292 + var Component = ReactInstanceMap.get(this)._currentElement.type;
4293 + var element = Component(this.props, this.context, this.updater);
4294 + warnIfInvalidElement(Component, element);
4295 + return element;
4296 +};
4297 +
4298 +function warnIfInvalidElement(Component, element) {
4299 + if ("development" !== 'production') {
4300 + "development" !== 'production' ? warning(element === null || element === false || React.isValidElement(element), '%s(...): A valid React element (or null) must be returned. You may have ' + 'returned undefined, an array or some other invalid object.', Component.displayName || Component.name || 'Component') : void 0;
4301 + "development" !== 'production' ? warning(!Component.childContextTypes, '%s(...): childContextTypes cannot be defined on a functional component.', Component.displayName || Component.name || 'Component') : void 0;
4302 + }
4303 +}
4304 +
4305 +function shouldConstruct(Component) {
4306 + return !!(Component.prototype && Component.prototype.isReactComponent);
4307 +}
4308 +
4309 +function isPureComponent(Component) {
4310 + return !!(Component.prototype && Component.prototype.isPureReactComponent);
4311 +}
4312 +
4313 +// Separated into a function to contain deoptimizations caused by try/finally.
4314 +function measureLifeCyclePerf(fn, debugID, timerType) {
4315 + if (debugID === 0) {
4316 + // Top-level wrappers (see ReactMount) and empty components (see
4317 + // ReactDOMEmptyComponent) are invisible to hooks and devtools.
4318 + // Both are implementation details that should go away in the future.
4319 + return fn();
4320 + }
4321 +
4322 + ReactInstrumentation.debugTool.onBeginLifeCycleTimer(debugID, timerType);
4323 + try {
4324 + return fn();
4325 + } finally {
4326 + ReactInstrumentation.debugTool.onEndLifeCycleTimer(debugID, timerType);
4327 + }
4328 +}
4329 +
4330 +/**
4331 + * ------------------ The Life-Cycle of a Composite Component ------------------
4332 + *
4333 + * - constructor: Initialization of state. The instance is now retained.
4334 + * - componentWillMount
4335 + * - render
4336 + * - [children's constructors]
4337 + * - [children's componentWillMount and render]
4338 + * - [children's componentDidMount]
4339 + * - componentDidMount
4340 + *
4341 + * Update Phases:
4342 + * - componentWillReceiveProps (only called if parent updated)
4343 + * - shouldComponentUpdate
4344 + * - componentWillUpdate
4345 + * - render
4346 + * - [children's constructors or receive props phases]
4347 + * - componentDidUpdate
4348 + *
4349 + * - componentWillUnmount
4350 + * - [children's componentWillUnmount]
4351 + * - [children destroyed]
4352 + * - (destroyed): The instance is now blank, released by React and ready for GC.
4353 + *
4354 + * -----------------------------------------------------------------------------
4355 + */
4356 +
4357 +/**
4358 + * An incrementing ID assigned to each component when it is mounted. This is
4359 + * used to enforce the order in which `ReactUpdates` updates dirty components.
4360 + *
4361 + * @private
4362 + */
4363 +var nextMountID = 1;
4364 +
4365 +/**
4366 + * @lends {ReactCompositeComponent.prototype}
4367 + */
4368 +var ReactCompositeComponent = {
4369 +
4370 + /**
4371 + * Base constructor for all composite component.
4372 + *
4373 + * @param {ReactElement} element
4374 + * @final
4375 + * @internal
4376 + */
4377 + construct: function (element) {
4378 + this._currentElement = element;
4379 + this._rootNodeID = 0;
4380 + this._compositeType = null;
4381 + this._instance = null;
4382 + this._hostParent = null;
4383 + this._hostContainerInfo = null;
4384 +
4385 + // See ReactUpdateQueue
4386 + this._updateBatchNumber = null;
4387 + this._pendingElement = null;
4388 + this._pendingStateQueue = null;
4389 + this._pendingReplaceState = false;
4390 + this._pendingForceUpdate = false;
4391 +
4392 + this._renderedNodeType = null;
4393 + this._renderedComponent = null;
4394 + this._context = null;
4395 + this._mountOrder = 0;
4396 + this._topLevelWrapper = null;
4397 +
4398 + // See ReactUpdates and ReactUpdateQueue.
4399 + this._pendingCallbacks = null;
4400 +
4401 + // ComponentWillUnmount shall only be called once
4402 + this._calledComponentWillUnmount = false;
4403 +
4404 + if ("development" !== 'production') {
4405 + this._warnedAboutRefsInRender = false;
4406 + }
4407 + },
4408 +
4409 + /**
4410 + * Initializes the component, renders markup, and registers event listeners.
4411 + *
4412 + * @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction
4413 + * @param {?object} hostParent
4414 + * @param {?object} hostContainerInfo
4415 + * @param {?object} context
4416 + * @return {?string} Rendered markup to be inserted into the DOM.
4417 + * @final
4418 + * @internal
4419 + */
4420 + mountComponent: function (transaction, hostParent, hostContainerInfo, context) {
4421 + var _this = this;
4422 +
4423 + this._context = context;
4424 + this._mountOrder = nextMountID++;
4425 + this._hostParent = hostParent;
4426 + this._hostContainerInfo = hostContainerInfo;
4427 +
4428 + var publicProps = this._currentElement.props;
4429 + var publicContext = this._processContext(context);
4430 +
4431 + var Component = this._currentElement.type;
4432 +
4433 + var updateQueue = transaction.getUpdateQueue();
4434 +
4435 + // Initialize the public class
4436 + var doConstruct = shouldConstruct(Component);
4437 + var inst = this._constructComponent(doConstruct, publicProps, publicContext, updateQueue);
4438 + var renderedElement;
4439 +
4440 + // Support functional components
4441 + if (!doConstruct && (inst == null || inst.render == null)) {
4442 + renderedElement = inst;
4443 + warnIfInvalidElement(Component, renderedElement);
4444 + !(inst === null || inst === false || React.isValidElement(inst)) ? "development" !== 'production' ? invariant(false, '%s(...): A valid React element (or null) must be returned. You may have returned undefined, an array or some other invalid object.', Component.displayName || Component.name || 'Component') : _prodInvariant('105', Component.displayName || Component.name || 'Component') : void 0;
4445 + inst = new StatelessComponent(Component);
4446 + this._compositeType = CompositeTypes.StatelessFunctional;
4447 + } else {
4448 + if (isPureComponent(Component)) {
4449 + this._compositeType = CompositeTypes.PureClass;
4450 + } else {
4451 + this._compositeType = CompositeTypes.ImpureClass;
4452 + }
4453 + }
4454 +
4455 + if ("development" !== 'production') {
4456 + // This will throw later in _renderValidatedComponent, but add an early
4457 + // warning now to help debugging
4458 + if (inst.render == null) {
4459 + "development" !== 'production' ? warning(false, '%s(...): No `render` method found on the returned component ' + 'instance: you may have forgotten to define `render`.', Component.displayName || Component.name || 'Component') : void 0;
4460 + }
4461 +
4462 + var propsMutated = inst.props !== publicProps;
4463 + var componentName = Component.displayName || Component.name || 'Component';
4464 +
4465 + "development" !== 'production' ? warning(inst.props === undefined || !propsMutated, '%s(...): When calling super() in `%s`, make sure to pass ' + 'up the same props that your component\'s constructor was passed.', componentName, componentName) : void 0;
4466 + }
4467 +
4468 + // These should be set up in the constructor, but as a convenience for
4469 + // simpler class abstractions, we set them up after the fact.
4470 + inst.props = publicProps;
4471 + inst.context = publicContext;
4472 + inst.refs = emptyObject;
4473 + inst.updater = updateQueue;
4474 +
4475 + this._instance = inst;
4476 +
4477 + // Store a reference from the instance back to the internal representation
4478 + ReactInstanceMap.set(inst, this);
4479 +
4480 + if ("development" !== 'production') {
4481 + // Since plain JS classes are defined without any special initialization
4482 + // logic, we can not catch common errors early. Therefore, we have to
4483 + // catch them here, at initialization time, instead.
4484 + "development" !== 'production' ? warning(!inst.getInitialState || inst.getInitialState.isReactClassApproved || inst.state, 'getInitialState was defined on %s, a plain JavaScript class. ' + 'This is only supported for classes created using React.createClass. ' + 'Did you mean to define a state property instead?', this.getName() || 'a component') : void 0;
4485 + "development" !== 'production' ? warning(!inst.getDefaultProps || inst.getDefaultProps.isReactClassApproved, 'getDefaultProps was defined on %s, a plain JavaScript class. ' + 'This is only supported for classes created using React.createClass. ' + 'Use a static property to define defaultProps instead.', this.getName() || 'a component') : void 0;
4486 + "development" !== 'production' ? warning(!inst.propTypes, 'propTypes was defined as an instance property on %s. Use a static ' + 'property to define propTypes instead.', this.getName() || 'a component') : void 0;
4487 + "development" !== 'production' ? warning(!inst.contextTypes, 'contextTypes was defined as an instance property on %s. Use a ' + 'static property to define contextTypes instead.', this.getName() || 'a component') : void 0;
4488 + "development" !== 'production' ? warning(typeof inst.componentShouldUpdate !== 'function', '%s has a method called ' + 'componentShouldUpdate(). Did you mean shouldComponentUpdate()? ' + 'The name is phrased as a question because the function is ' + 'expected to return a value.', this.getName() || 'A component') : void 0;
4489 + "development" !== 'production' ? warning(typeof inst.componentDidUnmount !== 'function', '%s has a method called ' + 'componentDidUnmount(). But there is no such lifecycle method. ' + 'Did you mean componentWillUnmount()?', this.getName() || 'A component') : void 0;
4490 + "development" !== 'production' ? warning(typeof inst.componentWillRecieveProps !== 'function', '%s has a method called ' + 'componentWillRecieveProps(). Did you mean componentWillReceiveProps()?', this.getName() || 'A component') : void 0;
4491 + }
4492 +
4493 + var initialState = inst.state;
4494 + if (initialState === undefined) {
4495 + inst.state = initialState = null;
4496 + }
4497 + !(typeof initialState === 'object' && !Array.isArray(initialState)) ? "development" !== 'production' ? invariant(false, '%s.state: must be set to an object or null', this.getName() || 'ReactCompositeComponent') : _prodInvariant('106', this.getName() || 'ReactCompositeComponent') : void 0;
4498 +
4499 + this._pendingStateQueue = null;
4500 + this._pendingReplaceState = false;
4501 + this._pendingForceUpdate = false;
4502 +
4503 + if (inst.componentWillMount) {
4504 + if ("development" !== 'production') {
4505 + measureLifeCyclePerf(function () {
4506 + return inst.componentWillMount();
4507 + }, this._debugID, 'componentWillMount');
4508 + } else {
4509 + inst.componentWillMount();
4510 + }
4511 + // When mounting, calls to `setState` by `componentWillMount` will set
4512 + // `this._pendingStateQueue` without triggering a re-render.
4513 + if (this._pendingStateQueue) {
4514 + inst.state = this._processPendingState(inst.props, inst.context);
4515 + }
4516 + }
4517 +
4518 + var markup;
4519 + if (inst.unstable_handleError) {
4520 + markup = this.performInitialMountWithErrorHandling(renderedElement, hostParent, hostContainerInfo, transaction, context);
4521 + } else {
4522 + markup = this.performInitialMount(renderedElement, hostParent, hostContainerInfo, transaction, context);
4523 + }
4524 +
4525 + if (inst.componentDidMount) {
4526 + if ("development" !== 'production') {
4527 + transaction.getReactMountReady().enqueue(function () {
4528 + measureLifeCyclePerf(function () {
4529 + return inst.componentDidMount();
4530 + }, _this._debugID, 'componentDidMount');
4531 + });
4532 + } else {
4533 + transaction.getReactMountReady().enqueue(inst.componentDidMount, inst);
4534 + }
4535 + }
4536 +
4537 + // setState callbacks during willMount should end up here
4538 + var callbacks = this._pendingCallbacks;
4539 + if (callbacks) {
4540 + this._pendingCallbacks = null;
4541 + for (var i = 0; i < callbacks.length; i++) {
4542 + transaction.getReactMountReady().enqueue(callbacks[i], inst);
4543 + }
4544 + }
4545 +
4546 + return markup;
4547 + },
4548 +
4549 + _constructComponent: function (doConstruct, publicProps, publicContext, updateQueue) {
4550 + if ("development" !== 'production') {
4551 + ReactCurrentOwner.current = this;
4552 + try {
4553 + return this._constructComponentWithoutOwner(doConstruct, publicProps, publicContext, updateQueue);
4554 + } finally {
4555 + ReactCurrentOwner.current = null;
4556 + }
4557 + } else {
4558 + return this._constructComponentWithoutOwner(doConstruct, publicProps, publicContext, updateQueue);
4559 + }
4560 + },
4561 +
4562 + _constructComponentWithoutOwner: function (doConstruct, publicProps, publicContext, updateQueue) {
4563 + var Component = this._currentElement.type;
4564 +
4565 + if (doConstruct) {
4566 + if ("development" !== 'production') {
4567 + return measureLifeCyclePerf(function () {
4568 + return new Component(publicProps, publicContext, updateQueue);
4569 + }, this._debugID, 'ctor');
4570 + } else {
4571 + return new Component(publicProps, publicContext, updateQueue);
4572 + }
4573 + }
4574 +
4575 + // This can still be an instance in case of factory components
4576 + // but we'll count this as time spent rendering as the more common case.
4577 + if ("development" !== 'production') {
4578 + return measureLifeCyclePerf(function () {
4579 + return Component(publicProps, publicContext, updateQueue);
4580 + }, this._debugID, 'render');
4581 + } else {
4582 + return Component(publicProps, publicContext, updateQueue);
4583 + }
4584 + },
4585 +
4586 + performInitialMountWithErrorHandling: function (renderedElement, hostParent, hostContainerInfo, transaction, context) {
4587 + var markup;
4588 + var checkpoint = transaction.checkpoint();
4589 + try {
4590 + markup = this.performInitialMount(renderedElement, hostParent, hostContainerInfo, transaction, context);
4591 + } catch (e) {
4592 + // Roll back to checkpoint, handle error (which may add items to the transaction), and take a new checkpoint
4593 + transaction.rollback(checkpoint);
4594 + this._instance.unstable_handleError(e);
4595 + if (this._pendingStateQueue) {
4596 + this._instance.state = this._processPendingState(this._instance.props, this._instance.context);
4597 + }
4598 + checkpoint = transaction.checkpoint();
4599 + this._renderedComponent.unmountComponent(true, /* safely */
4600 + // Don't call componentWillUnmount() because they never fully mounted:
4601 + true /* skipLifecyle */
4602 + );
4603 + transaction.rollback(checkpoint);
4604 +
4605 + // Try again - we've informed the component about the error, so they can render an error message this time.
4606 + // If this throws again, the error will bubble up (and can be caught by a higher error boundary).
4607 + markup = this.performInitialMount(renderedElement, hostParent, hostContainerInfo, transaction, context);
4608 + }
4609 + return markup;
4610 + },
4611 +
4612 + performInitialMount: function (renderedElement, hostParent, hostContainerInfo, transaction, context) {
4613 + // If not a stateless component, we now render
4614 + if (renderedElement === undefined) {
4615 + renderedElement = this._renderValidatedComponent();
4616 + }
4617 +
4618 + var nodeType = ReactNodeTypes.getType(renderedElement);
4619 + this._renderedNodeType = nodeType;
4620 + var child = this._instantiateReactComponent(renderedElement, nodeType !== ReactNodeTypes.EMPTY /* shouldHaveDebugID */
4621 + );
4622 + this._renderedComponent = child;
4623 +
4624 + var debugID = 0;
4625 + if ("development" !== 'production') {
4626 + debugID = this._debugID;
4627 + }
4628 +
4629 + var markup = ReactReconciler.mountComponent(child, transaction, hostParent, hostContainerInfo, this._processChildContext(context), debugID);
4630 +
4631 + if ("development" !== 'production') {
4632 + if (debugID !== 0) {
4633 + var childDebugIDs = child._debugID !== 0 ? [child._debugID] : [];
4634 + ReactInstrumentation.debugTool.onSetChildren(debugID, childDebugIDs);
4635 + }
4636 + }
4637 +
4638 + return markup;
4639 + },
4640 +
4641 + getHostNode: function () {
4642 + return ReactReconciler.getHostNode(this._renderedComponent);
4643 + },
4644 +
4645 + /**
4646 + * Releases any resources allocated by `mountComponent`.
4647 + *
4648 + * @final
4649 + * @internal
4650 + */
4651 + unmountComponent: function (safely, skipLifecycle) {
4652 + if (!this._renderedComponent) {
4653 + return;
4654 + }
4655 +
4656 + var inst = this._instance;
4657 +
4658 + if (inst.componentWillUnmount && !inst._calledComponentWillUnmount) {
4659 + inst._calledComponentWillUnmount = true;
4660 +
4661 + if (safely) {
4662 + if (!skipLifecycle) {
4663 + var name = this.getName() + '.componentWillUnmount()';
4664 + ReactErrorUtils.invokeGuardedCallback(name, inst.componentWillUnmount.bind(inst));
4665 + }
4666 + } else {
4667 + if ("development" !== 'production') {
4668 + measureLifeCyclePerf(function () {
4669 + return inst.componentWillUnmount();
4670 + }, this._debugID, 'componentWillUnmount');
4671 + } else {
4672 + inst.componentWillUnmount();
4673 + }
4674 + }
4675 + }
4676 +
4677 + if (this._renderedComponent) {
4678 + ReactReconciler.unmountComponent(this._renderedComponent, safely, skipLifecycle);
4679 + this._renderedNodeType = null;
4680 + this._renderedComponent = null;
4681 + this._instance = null;
4682 + }
4683 +
4684 + // Reset pending fields
4685 + // Even if this component is scheduled for another update in ReactUpdates,
4686 + // it would still be ignored because these fields are reset.
4687 + this._pendingStateQueue = null;
4688 + this._pendingReplaceState = false;
4689 + this._pendingForceUpdate = false;
4690 + this._pendingCallbacks = null;
4691 + this._pendingElement = null;
4692 +
4693 + // These fields do not really need to be reset since this object is no
4694 + // longer accessible.
4695 + this._context = null;
4696 + this._rootNodeID = 0;
4697 + this._topLevelWrapper = null;
4698 +
4699 + // Delete the reference from the instance to this internal representation
4700 + // which allow the internals to be properly cleaned up even if the user
4701 + // leaks a reference to the public instance.
4702 + ReactInstanceMap.remove(inst);
4703 +
4704 + // Some existing components rely on inst.props even after they've been
4705 + // destroyed (in event handlers).
4706 + // TODO: inst.props = null;
4707 + // TODO: inst.state = null;
4708 + // TODO: inst.context = null;
4709 + },
4710 +
4711 + /**
4712 + * Filters the context object to only contain keys specified in
4713 + * `contextTypes`
4714 + *
4715 + * @param {object} context
4716 + * @return {?object}
4717 + * @private
4718 + */
4719 + _maskContext: function (context) {
4720 + var Component = this._currentElement.type;
4721 + var contextTypes = Component.contextTypes;
4722 + if (!contextTypes) {
4723 + return emptyObject;
4724 + }
4725 + var maskedContext = {};
4726 + for (var contextName in contextTypes) {
4727 + maskedContext[contextName] = context[contextName];
4728 + }
4729 + return maskedContext;
4730 + },
4731 +
4732 + /**
4733 + * Filters the context object to only contain keys specified in
4734 + * `contextTypes`, and asserts that they are valid.
4735 + *
4736 + * @param {object} context
4737 + * @return {?object}
4738 + * @private
4739 + */
4740 + _processContext: function (context) {
4741 + var maskedContext = this._maskContext(context);
4742 + if ("development" !== 'production') {
4743 + var Component = this._currentElement.type;
4744 + if (Component.contextTypes) {
4745 + this._checkContextTypes(Component.contextTypes, maskedContext, 'context');
4746 + }
4747 + }
4748 + return maskedContext;
4749 + },
4750 +
4751 + /**
4752 + * @param {object} currentContext
4753 + * @return {object}
4754 + * @private
4755 + */
4756 + _processChildContext: function (currentContext) {
4757 + var Component = this._currentElement.type;
4758 + var inst = this._instance;
4759 + var childContext;
4760 +
4761 + if (typeof inst.getChildContext === 'function') {
4762 + if ("development" !== 'production') {
4763 + ReactInstrumentation.debugTool.onBeginProcessingChildContext();
4764 + try {
4765 + childContext = inst.getChildContext();
4766 + } finally {
4767 + ReactInstrumentation.debugTool.onEndProcessingChildContext();
4768 + }
4769 + } else {
4770 + childContext = inst.getChildContext();
4771 + }
4772 +
4773 + !(typeof Component.childContextTypes === 'object') ? "development" !== 'production' ? invariant(false, '%s.getChildContext(): childContextTypes must be defined in order to use getChildContext().', this.getName() || 'ReactCompositeComponent') : _prodInvariant('107', this.getName() || 'ReactCompositeComponent') : void 0;
4774 + if ("development" !== 'production') {
4775 + this._checkContextTypes(Component.childContextTypes, childContext, 'childContext');
4776 + }
4777 + for (var name in childContext) {
4778 + !(name in Component.childContextTypes) ? "development" !== 'production' ? invariant(false, '%s.getChildContext(): key "%s" is not defined in childContextTypes.', this.getName() || 'ReactCompositeComponent', name) : _prodInvariant('108', this.getName() || 'ReactCompositeComponent', name) : void 0;
4779 + }
4780 + return _assign({}, currentContext, childContext);
4781 + }
4782 + return currentContext;
4783 + },
4784 +
4785 + /**
4786 + * Assert that the context types are valid
4787 + *
4788 + * @param {object} typeSpecs Map of context field to a ReactPropType
4789 + * @param {object} values Runtime values that need to be type-checked
4790 + * @param {string} location e.g. "prop", "context", "child context"
4791 + * @private
4792 + */
4793 + _checkContextTypes: function (typeSpecs, values, location) {
4794 + if ("development" !== 'production') {
4795 + checkReactTypeSpec(typeSpecs, values, location, this.getName(), null, this._debugID);
4796 + }
4797 + },
4798 +
4799 + receiveComponent: function (nextElement, transaction, nextContext) {
4800 + var prevElement = this._currentElement;
4801 + var prevContext = this._context;
4802 +
4803 + this._pendingElement = null;
4804 +
4805 + this.updateComponent(transaction, prevElement, nextElement, prevContext, nextContext);
4806 + },
4807 +
4808 + /**
4809 + * If any of `_pendingElement`, `_pendingStateQueue`, or `_pendingForceUpdate`
4810 + * is set, update the component.
4811 + *
4812 + * @param {ReactReconcileTransaction} transaction
4813 + * @internal
4814 + */
4815 + performUpdateIfNecessary: function (transaction) {
4816 + if (this._pendingElement != null) {
4817 + ReactReconciler.receiveComponent(this, this._pendingElement, transaction, this._context);
4818 + } else if (this._pendingStateQueue !== null || this._pendingForceUpdate) {
4819 + this.updateComponent(transaction, this._currentElement, this._currentElement, this._context, this._context);
4820 + } else {
4821 + var callbacks = this._pendingCallbacks;
4822 + this._pendingCallbacks = null;
4823 + if (callbacks) {
4824 + for (var j = 0; j < callbacks.length; j++) {
4825 + transaction.getReactMountReady().enqueue(callbacks[j], this.getPublicInstance());
4826 + }
4827 + }
4828 + this._updateBatchNumber = null;
4829 + }
4830 + },
4831 +
4832 + /**
4833 + * Perform an update to a mounted component. The componentWillReceiveProps and
4834 + * shouldComponentUpdate methods are called, then (assuming the update isn't
4835 + * skipped) the remaining update lifecycle methods are called and the DOM
4836 + * representation is updated.
4837 + *
4838 + * By default, this implements React's rendering and reconciliation algorithm.
4839 + * Sophisticated clients may wish to override this.
4840 + *
4841 + * @param {ReactReconcileTransaction} transaction
4842 + * @param {ReactElement} prevParentElement
4843 + * @param {ReactElement} nextParentElement
4844 + * @internal
4845 + * @overridable
4846 + */
4847 + updateComponent: function (transaction, prevParentElement, nextParentElement, prevUnmaskedContext, nextUnmaskedContext) {
4848 + var inst = this._instance;
4849 + !(inst != null) ? "development" !== 'production' ? invariant(false, 'Attempted to update component `%s` that has already been unmounted (or failed to mount).', this.getName() || 'ReactCompositeComponent') : _prodInvariant('136', this.getName() || 'ReactCompositeComponent') : void 0;
4850 +
4851 + var willReceive = false;
4852 + var nextContext;
4853 +
4854 + // Determine if the context has changed or not
4855 + if (this._context === nextUnmaskedContext) {
4856 + nextContext = inst.context;
4857 + } else {
4858 + nextContext = this._processContext(nextUnmaskedContext);
4859 + willReceive = true;
4860 + }
4861 +
4862 + var prevProps = prevParentElement.props;
4863 + var nextProps = nextParentElement.props;
4864 +
4865 + // Not a simple state update but a props update
4866 + if (prevParentElement !== nextParentElement) {
4867 + willReceive = true;
4868 + }
4869 +
4870 + // An update here will schedule an update but immediately set
4871 + // _pendingStateQueue which will ensure that any state updates gets
4872 + // immediately reconciled instead of waiting for the next batch.
4873 + if (willReceive && inst.componentWillReceiveProps) {
4874 + if ("development" !== 'production') {
4875 + measureLifeCyclePerf(function () {
4876 + return inst.componentWillReceiveProps(nextProps, nextContext);
4877 + }, this._debugID, 'componentWillReceiveProps');
4878 + } else {
4879 + inst.componentWillReceiveProps(nextProps, nextContext);
4880 + }
4881 + }
4882 +
4883 + // If updating happens to enqueue any new updates, we shouldn't execute new
4884 + // callbacks until the next render happens, so stash the callbacks first.
4885 + var callbacks = this._pendingCallbacks;
4886 + this._pendingCallbacks = null;
4887 +
4888 + var nextState = this._processPendingState(nextProps, nextContext);
4889 + var shouldUpdate = true;
4890 +
4891 + if (!this._pendingForceUpdate) {
4892 + if (inst.shouldComponentUpdate) {
4893 + if ("development" !== 'production') {
4894 + shouldUpdate = measureLifeCyclePerf(function () {
4895 + return inst.shouldComponentUpdate(nextProps, nextState, nextContext);
4896 + }, this._debugID, 'shouldComponentUpdate');
4897 + } else {
4898 + shouldUpdate = inst.shouldComponentUpdate(nextProps, nextState, nextContext);
4899 + }
4900 + } else {
4901 + if (this._compositeType === CompositeTypes.PureClass) {
4902 + shouldUpdate = !shallowEqual(prevProps, nextProps) || !shallowEqual(inst.state, nextState);
4903 + }
4904 + }
4905 + }
4906 +
4907 + if ("development" !== 'production') {
4908 + "development" !== 'production' ? warning(shouldUpdate !== undefined, '%s.shouldComponentUpdate(): Returned undefined instead of a ' + 'boolean value. Make sure to return true or false.', this.getName() || 'ReactCompositeComponent') : void 0;
4909 + }
4910 +
4911 + this._updateBatchNumber = null;
4912 + if (shouldUpdate) {
4913 + this._pendingForceUpdate = false;
4914 + // Will set `this.props`, `this.state` and `this.context`.
4915 + this._performComponentUpdate(nextParentElement, nextProps, nextState, nextContext, transaction, nextUnmaskedContext);
4916 + } else {
4917 + // If it's determined that a component should not update, we still want
4918 + // to set props and state but we shortcut the rest of the update.
4919 + this._currentElement = nextParentElement;
4920 + this._context = nextUnmaskedContext;
4921 + inst.props = nextProps;
4922 + inst.state = nextState;
4923 + inst.context = nextContext;
4924 + }
4925 +
4926 + if (callbacks) {
4927 + for (var j = 0; j < callbacks.length; j++) {
4928 + transaction.getReactMountReady().enqueue(callbacks[j], this.getPublicInstance());
4929 + }
4930 + }
4931 + },
4932 +
4933 + _processPendingState: function (props, context) {
4934 + var inst = this._instance;
4935 + var queue = this._pendingStateQueue;
4936 + var replace = this._pendingReplaceState;
4937 + this._pendingReplaceState = false;
4938 + this._pendingStateQueue = null;
4939 +
4940 + if (!queue) {
4941 + return inst.state;
4942 + }
4943 +
4944 + if (replace && queue.length === 1) {
4945 + return queue[0];
4946 + }
4947 +
4948 + var nextState = _assign({}, replace ? queue[0] : inst.state);
4949 + for (var i = replace ? 1 : 0; i < queue.length; i++) {
4950 + var partial = queue[i];
4951 + _assign(nextState, typeof partial === 'function' ? partial.call(inst, nextState, props, context) : partial);
4952 + }
4953 +
4954 + return nextState;
4955 + },
4956 +
4957 + /**
4958 + * Merges new props and state, notifies delegate methods of update and
4959 + * performs update.
4960 + *
4961 + * @param {ReactElement} nextElement Next element
4962 + * @param {object} nextProps Next public object to set as properties.
4963 + * @param {?object} nextState Next object to set as state.
4964 + * @param {?object} nextContext Next public object to set as context.
4965 + * @param {ReactReconcileTransaction} transaction
4966 + * @param {?object} unmaskedContext
4967 + * @private
4968 + */
4969 + _performComponentUpdate: function (nextElement, nextProps, nextState, nextContext, transaction, unmaskedContext) {
4970 + var _this2 = this;
4971 +
4972 + var inst = this._instance;
4973 +
4974 + var hasComponentDidUpdate = Boolean(inst.componentDidUpdate);
4975 + var prevProps;
4976 + var prevState;
4977 + var prevContext;
4978 + if (hasComponentDidUpdate) {
4979 + prevProps = inst.props;
4980 + prevState = inst.state;
4981 + prevContext = inst.context;
4982 + }
4983 +
4984 + if (inst.componentWillUpdate) {
4985 + if ("development" !== 'production') {
4986 + measureLifeCyclePerf(function () {
4987 + return inst.componentWillUpdate(nextProps, nextState, nextContext);
4988 + }, this._debugID, 'componentWillUpdate');
4989 + } else {
4990 + inst.componentWillUpdate(nextProps, nextState, nextContext);
4991 + }
4992 + }
4993 +
4994 + this._currentElement = nextElement;
4995 + this._context = unmaskedContext;
4996 + inst.props = nextProps;
4997 + inst.state = nextState;
4998 + inst.context = nextContext;
4999 +

This file is too large to show in full.

fixtures/dom/public/react.js new
+3859
@@ -0,0 +1,3859 @@
1 + /**
2 + * React v16.0.0-alpha
3 + */
4 +(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.React = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){
5 +/**
6 + * Copyright 2013-present, Facebook, Inc.
7 + * All rights reserved.
8 + *
9 + * This source code is licensed under the BSD-style license found in the
10 + * LICENSE file in the root directory of this source tree. An additional grant
11 + * of patent rights can be found in the PATENTS file in the same directory.
12 + *
13 + *
14 + */
15 +
16 +'use strict';
17 +
18 +/**
19 + * Escape and wrap key so it is safe to use as a reactid
20 + *
21 + * @param {string} key to be escaped.
22 + * @return {string} the escaped key.
23 + */
24 +
25 +function escape(key) {
26 + var escapeRegex = /[=:]/g;
27 + var escaperLookup = {
28 + '=': '=0',
29 + ':': '=2'
30 + };
31 + var escapedString = ('' + key).replace(escapeRegex, function (match) {
32 + return escaperLookup[match];
33 + });
34 +
35 + return '$' + escapedString;
36 +}
37 +
38 +/**
39 + * Unescape and unwrap key for human-readable display
40 + *
41 + * @param {string} key to unescape.
42 + * @return {string} the unescaped key.
43 + */
44 +function unescape(key) {
45 + var unescapeRegex = /(=0|=2)/g;
46 + var unescaperLookup = {
47 + '=0': '=',
48 + '=2': ':'
49 + };
50 + var keySubstring = key[0] === '.' && key[1] === '$' ? key.substring(2) : key.substring(1);
51 +
52 + return ('' + keySubstring).replace(unescapeRegex, function (match) {
53 + return unescaperLookup[match];
54 + });
55 +}
56 +
57 +var KeyEscapeUtils = {
58 + escape: escape,
59 + unescape: unescape
60 +};
61 +
62 +module.exports = KeyEscapeUtils;
63 +},{}],2:[function(_dereq_,module,exports){
64 +/**
65 + * Copyright 2013-present, Facebook, Inc.
66 + * All rights reserved.
67 + *
68 + * This source code is licensed under the BSD-style license found in the
69 + * LICENSE file in the root directory of this source tree. An additional grant
70 + * of patent rights can be found in the PATENTS file in the same directory.
71 + *
72 + *
73 + */
74 +
75 +'use strict';
76 +
77 +var _prodInvariant = _dereq_(25);
78 +
79 +var invariant = _dereq_(29);
80 +
81 +/**
82 + * Static poolers. Several custom versions for each potential number of
83 + * arguments. A completely generic pooler is easy to implement, but would
84 + * require accessing the `arguments` object. In each of these, `this` refers to
85 + * the Class itself, not an instance. If any others are needed, simply add them
86 + * here, or in their own files.
87 + */
88 +var oneArgumentPooler = function (copyFieldsFrom) {
89 + var Klass = this;
90 + if (Klass.instancePool.length) {
91 + var instance = Klass.instancePool.pop();
92 + Klass.call(instance, copyFieldsFrom);
93 + return instance;
94 + } else {
95 + return new Klass(copyFieldsFrom);
96 + }
97 +};
98 +
99 +var twoArgumentPooler = function (a1, a2) {
100 + var Klass = this;
101 + if (Klass.instancePool.length) {
102 + var instance = Klass.instancePool.pop();
103 + Klass.call(instance, a1, a2);
104 + return instance;
105 + } else {
106 + return new Klass(a1, a2);
107 + }
108 +};
109 +
110 +var threeArgumentPooler = function (a1, a2, a3) {
111 + var Klass = this;
112 + if (Klass.instancePool.length) {
113 + var instance = Klass.instancePool.pop();
114 + Klass.call(instance, a1, a2, a3);
115 + return instance;
116 + } else {
117 + return new Klass(a1, a2, a3);
118 + }
119 +};
120 +
121 +var fourArgumentPooler = function (a1, a2, a3, a4) {
122 + var Klass = this;
123 + if (Klass.instancePool.length) {
124 + var instance = Klass.instancePool.pop();
125 + Klass.call(instance, a1, a2, a3, a4);
126 + return instance;
127 + } else {
128 + return new Klass(a1, a2, a3, a4);
129 + }
130 +};
131 +
132 +var standardReleaser = function (instance) {
133 + var Klass = this;
134 + !(instance instanceof Klass) ? "development" !== 'production' ? invariant(false, 'Trying to release an instance into a pool of a different type.') : _prodInvariant('25') : void 0;
135 + instance.destructor();
136 + if (Klass.instancePool.length < Klass.poolSize) {
137 + Klass.instancePool.push(instance);
138 + }
139 +};
140 +
141 +var DEFAULT_POOL_SIZE = 10;
142 +var DEFAULT_POOLER = oneArgumentPooler;
143 +
144 +/**
145 + * Augments `CopyConstructor` to be a poolable class, augmenting only the class
146 + * itself (statically) not adding any prototypical fields. Any CopyConstructor
147 + * you give this may have a `poolSize` property, and will look for a
148 + * prototypical `destructor` on instances.
149 + *
150 + * @param {Function} CopyConstructor Constructor that can be used to reset.
151 + * @param {Function} pooler Customizable pooler.
152 + */
153 +var addPoolingTo = function (CopyConstructor, pooler) {
154 + // Casting as any so that flow ignores the actual implementation and trusts
155 + // it to match the type we declared
156 + var NewKlass = CopyConstructor;
157 + NewKlass.instancePool = [];
158 + NewKlass.getPooled = pooler || DEFAULT_POOLER;
159 + if (!NewKlass.poolSize) {
160 + NewKlass.poolSize = DEFAULT_POOL_SIZE;
161 + }
162 + NewKlass.release = standardReleaser;
163 + return NewKlass;
164 +};
165 +
166 +var PooledClass = {
167 + addPoolingTo: addPoolingTo,
168 + oneArgumentPooler: oneArgumentPooler,
169 + twoArgumentPooler: twoArgumentPooler,
170 + threeArgumentPooler: threeArgumentPooler,
171 + fourArgumentPooler: fourArgumentPooler
172 +};
173 +
174 +module.exports = PooledClass;
175 +},{"25":25,"29":29}],3:[function(_dereq_,module,exports){
176 +/**
177 + * Copyright 2013-present, Facebook, Inc.
178 + * All rights reserved.
179 + *
180 + * This source code is licensed under the BSD-style license found in the
181 + * LICENSE file in the root directory of this source tree. An additional grant
182 + * of patent rights can be found in the PATENTS file in the same directory.
183 + *
184 + */
185 +
186 +'use strict';
187 +
188 +var _assign = _dereq_(31);
189 +
190 +var ReactChildren = _dereq_(4);
191 +var ReactComponent = _dereq_(6);
192 +var ReactPureComponent = _dereq_(16);
193 +var ReactClass = _dereq_(5);
194 +var ReactDOMFactories = _dereq_(9);
195 +var ReactElement = _dereq_(10);
196 +var ReactPropTypes = _dereq_(15);
197 +var ReactVersion = _dereq_(19);
198 +
199 +var onlyChild = _dereq_(24);
200 +var warning = _dereq_(30);
201 +
202 +var createElement = ReactElement.createElement;
203 +var createFactory = ReactElement.createFactory;
204 +var cloneElement = ReactElement.cloneElement;
205 +
206 +if ("development" !== 'production') {
207 + var ReactElementValidator = _dereq_(12);
208 + createElement = ReactElementValidator.createElement;
209 + createFactory = ReactElementValidator.createFactory;
210 + cloneElement = ReactElementValidator.cloneElement;
211 +}
212 +
213 +var __spread = _assign;
214 +
215 +if ("development" !== 'production') {
216 + var warned = false;
217 + __spread = function () {
218 + "development" !== 'production' ? warning(warned, 'React.__spread is deprecated and should not be used. Use ' + 'Object.assign directly or another helper function with similar ' + 'semantics. You may be seeing this warning due to your compiler. ' + 'See https://fb.me/react-spread-deprecation for more details.') : void 0;
219 + warned = true;
220 + return _assign.apply(null, arguments);
221 + };
222 +}
223 +
224 +var React = {
225 +
226 + // Modern
227 +
228 + Children: {
229 + map: ReactChildren.map,
230 + forEach: ReactChildren.forEach,
231 + count: ReactChildren.count,
232 + toArray: ReactChildren.toArray,
233 + only: onlyChild
234 + },
235 +
236 + Component: ReactComponent,
237 + PureComponent: ReactPureComponent,
238 +
239 + createElement: createElement,
240 + cloneElement: cloneElement,
241 + isValidElement: ReactElement.isValidElement,
242 +
243 + // Classic
244 +
245 + PropTypes: ReactPropTypes,
246 + createClass: ReactClass.createClass,
247 + createFactory: createFactory,
248 + createMixin: function (mixin) {
249 + // Currently a noop. Will be used to validate and trace mixins.
250 + return mixin;
251 + },
252 +
253 + // This looks DOM specific but these are actually isomorphic helpers
254 + // since they are just generating DOM strings.
255 + DOM: ReactDOMFactories,
256 +
257 + version: ReactVersion,
258 +
259 + // Deprecated hook for JSX spread, don't use this for anything.
260 + __spread: __spread
261 +};
262 +
263 +module.exports = React;
264 +},{"10":10,"12":12,"15":15,"16":16,"19":19,"24":24,"30":30,"31":31,"4":4,"5":5,"6":6,"9":9}],4:[function(_dereq_,module,exports){
265 +/**
266 + * Copyright 2013-present, Facebook, Inc.
267 + * All rights reserved.
268 + *
269 + * This source code is licensed under the BSD-style license found in the
270 + * LICENSE file in the root directory of this source tree. An additional grant
271 + * of patent rights can be found in the PATENTS file in the same directory.
272 + *
273 + */
274 +
275 +'use strict';
276 +
277 +var PooledClass = _dereq_(2);
278 +var ReactElement = _dereq_(10);
279 +
280 +var emptyFunction = _dereq_(27);
281 +var traverseAllChildren = _dereq_(26);
282 +
283 +var twoArgumentPooler = PooledClass.twoArgumentPooler;
284 +var fourArgumentPooler = PooledClass.fourArgumentPooler;
285 +
286 +var userProvidedKeyEscapeRegex = /\/+/g;
287 +function escapeUserProvidedKey(text) {
288 + return ('' + text).replace(userProvidedKeyEscapeRegex, '$&/');
289 +}
290 +
291 +/**
292 + * PooledClass representing the bookkeeping associated with performing a child
293 + * traversal. Allows avoiding binding callbacks.
294 + *
295 + * @constructor ForEachBookKeeping
296 + * @param {!function} forEachFunction Function to perform traversal with.
297 + * @param {?*} forEachContext Context to perform context with.
298 + */
299 +function ForEachBookKeeping(forEachFunction, forEachContext) {
300 + this.func = forEachFunction;
301 + this.context = forEachContext;
302 + this.count = 0;
303 +}
304 +ForEachBookKeeping.prototype.destructor = function () {
305 + this.func = null;
306 + this.context = null;
307 + this.count = 0;
308 +};
309 +PooledClass.addPoolingTo(ForEachBookKeeping, twoArgumentPooler);
310 +
311 +function forEachSingleChild(bookKeeping, child, name) {
312 + var func = bookKeeping.func,
313 + context = bookKeeping.context;
314 +
315 + func.call(context, child, bookKeeping.count++);
316 +}
317 +
318 +/**
319 + * Iterates through children that are typically specified as `props.children`.
320 + *
321 + * See https://facebook.github.io/react/docs/react-api.html#react.children.foreach
322 + *
323 + * The provided forEachFunc(child, index) will be called for each
324 + * leaf child.
325 + *
326 + * @param {?*} children Children tree container.
327 + * @param {function(*, int)} forEachFunc
328 + * @param {*} forEachContext Context for forEachContext.
329 + */
330 +function forEachChildren(children, forEachFunc, forEachContext) {
331 + if (children == null) {
332 + return children;
333 + }
334 + var traverseContext = ForEachBookKeeping.getPooled(forEachFunc, forEachContext);
335 + traverseAllChildren(children, forEachSingleChild, traverseContext);
336 + ForEachBookKeeping.release(traverseContext);
337 +}
338 +
339 +/**
340 + * PooledClass representing the bookkeeping associated with performing a child
341 + * mapping. Allows avoiding binding callbacks.
342 + *
343 + * @constructor MapBookKeeping
344 + * @param {!*} mapResult Object containing the ordered map of results.
345 + * @param {!function} mapFunction Function to perform mapping with.
346 + * @param {?*} mapContext Context to perform mapping with.
347 + */
348 +function MapBookKeeping(mapResult, keyPrefix, mapFunction, mapContext) {
349 + this.result = mapResult;
350 + this.keyPrefix = keyPrefix;
351 + this.func = mapFunction;
352 + this.context = mapContext;
353 + this.count = 0;
354 +}
355 +MapBookKeeping.prototype.destructor = function () {
356 + this.result = null;
357 + this.keyPrefix = null;
358 + this.func = null;
359 + this.context = null;
360 + this.count = 0;
361 +};
362 +PooledClass.addPoolingTo(MapBookKeeping, fourArgumentPooler);
363 +
364 +function mapSingleChildIntoContext(bookKeeping, child, childKey) {
365 + var result = bookKeeping.result,
366 + keyPrefix = bookKeeping.keyPrefix,
367 + func = bookKeeping.func,
368 + context = bookKeeping.context;
369 +
370 +
371 + var mappedChild = func.call(context, child, bookKeeping.count++);
372 + if (Array.isArray(mappedChild)) {
373 + mapIntoWithKeyPrefixInternal(mappedChild, result, childKey, emptyFunction.thatReturnsArgument);
374 + } else if (mappedChild != null) {
375 + if (ReactElement.isValidElement(mappedChild)) {
376 + mappedChild = ReactElement.cloneAndReplaceKey(mappedChild,
377 + // Keep both the (mapped) and old keys if they differ, just as
378 + // traverseAllChildren used to do for objects as children
379 + keyPrefix + (mappedChild.key && (!child || child.key !== mappedChild.key) ? escapeUserProvidedKey(mappedChild.key) + '/' : '') + childKey);
380 + }
381 + result.push(mappedChild);
382 + }
383 +}
384 +
385 +function mapIntoWithKeyPrefixInternal(children, array, prefix, func, context) {
386 + var escapedPrefix = '';
387 + if (prefix != null) {
388 + escapedPrefix = escapeUserProvidedKey(prefix) + '/';
389 + }
390 + var traverseContext = MapBookKeeping.getPooled(array, escapedPrefix, func, context);
391 + traverseAllChildren(children, mapSingleChildIntoContext, traverseContext);
392 + MapBookKeeping.release(traverseContext);
393 +}
394 +
395 +/**
396 + * Maps children that are typically specified as `props.children`.
397 + *
398 + * See https://facebook.github.io/react/docs/react-api.html#react.children.map
399 + *
400 + * The provided mapFunction(child, key, index) will be called for each
401 + * leaf child.
402 + *
403 + * @param {?*} children Children tree container.
404 + * @param {function(*, int)} func The map function.
405 + * @param {*} context Context for mapFunction.
406 + * @return {object} Object containing the ordered map of results.
407 + */
408 +function mapChildren(children, func, context) {
409 + if (children == null) {
410 + return children;
411 + }
412 + var result = [];
413 + mapIntoWithKeyPrefixInternal(children, result, null, func, context);
414 + return result;
415 +}
416 +
417 +function forEachSingleChildDummy(traverseContext, child, name) {
418 + return null;
419 +}
420 +
421 +/**
422 + * Count the number of children that are typically specified as
423 + * `props.children`.
424 + *
425 + * See https://facebook.github.io/react/docs/react-api.html#react.children.count
426 + *
427 + * @param {?*} children Children tree container.
428 + * @return {number} The number of children.
429 + */
430 +function countChildren(children, context) {
431 + return traverseAllChildren(children, forEachSingleChildDummy, null);
432 +}
433 +
434 +/**
435 + * Flatten a children object (typically specified as `props.children`) and
436 + * return an array with appropriately re-keyed children.
437 + *
438 + * See https://facebook.github.io/react/docs/react-api.html#react.children.toarray
439 + */
440 +function toArray(children) {
441 + var result = [];
442 + mapIntoWithKeyPrefixInternal(children, result, null, emptyFunction.thatReturnsArgument);
443 + return result;
444 +}
445 +
446 +var ReactChildren = {
447 + forEach: forEachChildren,
448 + map: mapChildren,
449 + mapIntoWithKeyPrefixInternal: mapIntoWithKeyPrefixInternal,
450 + count: countChildren,
451 + toArray: toArray
452 +};
453 +
454 +module.exports = ReactChildren;
455 +},{"10":10,"2":2,"26":26,"27":27}],5:[function(_dereq_,module,exports){
456 +/**
457 + * Copyright 2013-present, Facebook, Inc.
458 + * All rights reserved.
459 + *
460 + * This source code is licensed under the BSD-style license found in the
461 + * LICENSE file in the root directory of this source tree. An additional grant
462 + * of patent rights can be found in the PATENTS file in the same directory.
463 + *
464 + */
465 +
466 +'use strict';
467 +
468 +var _prodInvariant = _dereq_(25),
469 + _assign = _dereq_(31);
470 +
471 +var ReactComponent = _dereq_(6);
472 +var ReactElement = _dereq_(10);
473 +var ReactPropTypeLocationNames = _dereq_(14);
474 +var ReactNoopUpdateQueue = _dereq_(13);
475 +
476 +var emptyObject = _dereq_(28);
477 +var invariant = _dereq_(29);
478 +var warning = _dereq_(30);
479 +
480 +var MIXINS_KEY = 'mixins';
481 +
482 +// Helper function to allow the creation of anonymous functions which do not
483 +// have .name set to the name of the variable being assigned to.
484 +function identity(fn) {
485 + return fn;
486 +}
487 +
488 +/**
489 + * Policies that describe methods in `ReactClassInterface`.
490 + */
491 +
492 +
493 +/**
494 + * Composite components are higher-level components that compose other composite
495 + * or host components.
496 + *
497 + * To create a new type of `ReactClass`, pass a specification of
498 + * your new class to `React.createClass`. The only requirement of your class
499 + * specification is that you implement a `render` method.
500 + *
501 + * var MyComponent = React.createClass({
502 + * render: function() {
503 + * return <div>Hello World</div>;
504 + * }
505 + * });
506 + *
507 + * The class specification supports a specific protocol of methods that have
508 + * special meaning (e.g. `render`). See `ReactClassInterface` for
509 + * more the comprehensive protocol. Any other properties and methods in the
510 + * class specification will be available on the prototype.
511 + *
512 + * @interface ReactClassInterface
513 + * @internal
514 + */
515 +var ReactClassInterface = {
516 +
517 + /**
518 + * An array of Mixin objects to include when defining your component.
519 + *
520 + * @type {array}
521 + * @optional
522 + */
523 + mixins: 'DEFINE_MANY',
524 +
525 + /**
526 + * An object containing properties and methods that should be defined on
527 + * the component's constructor instead of its prototype (static methods).
528 + *
529 + * @type {object}
530 + * @optional
531 + */
532 + statics: 'DEFINE_MANY',
533 +
534 + /**
535 + * Definition of prop types for this component.
536 + *
537 + * @type {object}
538 + * @optional
539 + */
540 + propTypes: 'DEFINE_MANY',
541 +
542 + /**
543 + * Definition of context types for this component.
544 + *
545 + * @type {object}
546 + * @optional
547 + */
548 + contextTypes: 'DEFINE_MANY',
549 +
550 + /**
551 + * Definition of context types this component sets for its children.
552 + *
553 + * @type {object}
554 + * @optional
555 + */
556 + childContextTypes: 'DEFINE_MANY',
557 +
558 + // ==== Definition methods ====
559 +
560 + /**
561 + * Invoked when the component is mounted. Values in the mapping will be set on
562 + * `this.props` if that prop is not specified (i.e. using an `in` check).
563 + *
564 + * This method is invoked before `getInitialState` and therefore cannot rely
565 + * on `this.state` or use `this.setState`.
566 + *
567 + * @return {object}
568 + * @optional
569 + */
570 + getDefaultProps: 'DEFINE_MANY_MERGED',
571 +
572 + /**
573 + * Invoked once before the component is mounted. The return value will be used
574 + * as the initial value of `this.state`.
575 + *
576 + * getInitialState: function() {
577 + * return {
578 + * isOn: false,
579 + * fooBaz: new BazFoo()
580 + * }
581 + * }
582 + *
583 + * @return {object}
584 + * @optional
585 + */
586 + getInitialState: 'DEFINE_MANY_MERGED',
587 +
588 + /**
589 + * @return {object}
590 + * @optional
591 + */
592 + getChildContext: 'DEFINE_MANY_MERGED',
593 +
594 + /**
595 + * Uses props from `this.props` and state from `this.state` to render the
596 + * structure of the component.
597 + *
598 + * No guarantees are made about when or how often this method is invoked, so
599 + * it must not have side effects.
600 + *
601 + * render: function() {
602 + * var name = this.props.name;
603 + * return <div>Hello, {name}!</div>;
604 + * }
605 + *
606 + * @return {ReactComponent}
607 + * @nosideeffects
608 + * @required
609 + */
610 + render: 'DEFINE_ONCE',
611 +
612 + // ==== Delegate methods ====
613 +
614 + /**
615 + * Invoked when the component is initially created and about to be mounted.
616 + * This may have side effects, but any external subscriptions or data created
617 + * by this method must be cleaned up in `componentWillUnmount`.
618 + *
619 + * @optional
620 + */
621 + componentWillMount: 'DEFINE_MANY',
622 +
623 + /**
624 + * Invoked when the component has been mounted and has a DOM representation.
625 + * However, there is no guarantee that the DOM node is in the document.
626 + *
627 + * Use this as an opportunity to operate on the DOM when the component has
628 + * been mounted (initialized and rendered) for the first time.
629 + *
630 + * @param {DOMElement} rootNode DOM element representing the component.
631 + * @optional
632 + */
633 + componentDidMount: 'DEFINE_MANY',
634 +
635 + /**
636 + * Invoked before the component receives new props.
637 + *
638 + * Use this as an opportunity to react to a prop transition by updating the
639 + * state using `this.setState`. Current props are accessed via `this.props`.
640 + *
641 + * componentWillReceiveProps: function(nextProps, nextContext) {
642 + * this.setState({
643 + * likesIncreasing: nextProps.likeCount > this.props.likeCount
644 + * });
645 + * }
646 + *
647 + * NOTE: There is no equivalent `componentWillReceiveState`. An incoming prop
648 + * transition may cause a state change, but the opposite is not true. If you
649 + * need it, you are probably looking for `componentWillUpdate`.
650 + *
651 + * @param {object} nextProps
652 + * @optional
653 + */
654 + componentWillReceiveProps: 'DEFINE_MANY',
655 +
656 + /**
657 + * Invoked while deciding if the component should be updated as a result of
658 + * receiving new props, state and/or context.
659 + *
660 + * Use this as an opportunity to `return false` when you're certain that the
661 + * transition to the new props/state/context will not require a component
662 + * update.
663 + *
664 + * shouldComponentUpdate: function(nextProps, nextState, nextContext) {
665 + * return !equal(nextProps, this.props) ||
666 + * !equal(nextState, this.state) ||
667 + * !equal(nextContext, this.context);
668 + * }
669 + *
670 + * @param {object} nextProps
671 + * @param {?object} nextState
672 + * @param {?object} nextContext
673 + * @return {boolean} True if the component should update.
674 + * @optional
675 + */
676 + shouldComponentUpdate: 'DEFINE_ONCE',
677 +
678 + /**
679 + * Invoked when the component is about to update due to a transition from
680 + * `this.props`, `this.state` and `this.context` to `nextProps`, `nextState`
681 + * and `nextContext`.
682 + *
683 + * Use this as an opportunity to perform preparation before an update occurs.
684 + *
685 + * NOTE: You **cannot** use `this.setState()` in this method.
686 + *
687 + * @param {object} nextProps
688 + * @param {?object} nextState
689 + * @param {?object} nextContext
690 + * @param {ReactReconcileTransaction} transaction
691 + * @optional
692 + */
693 + componentWillUpdate: 'DEFINE_MANY',
694 +
695 + /**
696 + * Invoked when the component's DOM representation has been updated.
697 + *
698 + * Use this as an opportunity to operate on the DOM when the component has
699 + * been updated.
700 + *
701 + * @param {object} prevProps
702 + * @param {?object} prevState
703 + * @param {?object} prevContext
704 + * @param {DOMElement} rootNode DOM element representing the component.
705 + * @optional
706 + */
707 + componentDidUpdate: 'DEFINE_MANY',
708 +
709 + /**
710 + * Invoked when the component is about to be removed from its parent and have
711 + * its DOM representation destroyed.
712 + *
713 + * Use this as an opportunity to deallocate any external resources.
714 + *
715 + * NOTE: There is no `componentDidUnmount` since your component will have been
716 + * destroyed by that point.
717 + *
718 + * @optional
719 + */
720 + componentWillUnmount: 'DEFINE_MANY',
721 +
722 + // ==== Advanced methods ====
723 +
724 + /**
725 + * Updates the component's currently mounted DOM representation.
726 + *
727 + * By default, this implements React's rendering and reconciliation algorithm.
728 + * Sophisticated clients may wish to override this.
729 + *
730 + * @param {ReactReconcileTransaction} transaction
731 + * @internal
732 + * @overridable
733 + */
734 + updateComponent: 'OVERRIDE_BASE'
735 +
736 +};
737 +
738 +/**
739 + * Mapping from class specification keys to special processing functions.
740 + *
741 + * Although these are declared like instance properties in the specification
742 + * when defining classes using `React.createClass`, they are actually static
743 + * and are accessible on the constructor instead of the prototype. Despite
744 + * being static, they must be defined outside of the "statics" key under
745 + * which all other static methods are defined.
746 + */
747 +var RESERVED_SPEC_KEYS = {
748 + displayName: function (Constructor, displayName) {
749 + Constructor.displayName = displayName;
750 + },
751 + mixins: function (Constructor, mixins) {
752 + if (mixins) {
753 + for (var i = 0; i < mixins.length; i++) {
754 + mixSpecIntoComponent(Constructor, mixins[i]);
755 + }
756 + }
757 + },
758 + childContextTypes: function (Constructor, childContextTypes) {
759 + if ("development" !== 'production') {
760 + validateTypeDef(Constructor, childContextTypes, 'childContext');
761 + }
762 + Constructor.childContextTypes = _assign({}, Constructor.childContextTypes, childContextTypes);
763 + },
764 + contextTypes: function (Constructor, contextTypes) {
765 + if ("development" !== 'production') {
766 + validateTypeDef(Constructor, contextTypes, 'context');
767 + }
768 + Constructor.contextTypes = _assign({}, Constructor.contextTypes, contextTypes);
769 + },
770 + /**
771 + * Special case getDefaultProps which should move into statics but requires
772 + * automatic merging.
773 + */
774 + getDefaultProps: function (Constructor, getDefaultProps) {
775 + if (Constructor.getDefaultProps) {
776 + Constructor.getDefaultProps = createMergedResultFunction(Constructor.getDefaultProps, getDefaultProps);
777 + } else {
778 + Constructor.getDefaultProps = getDefaultProps;
779 + }
780 + },
781 + propTypes: function (Constructor, propTypes) {
782 + if ("development" !== 'production') {
783 + validateTypeDef(Constructor, propTypes, 'prop');
784 + }
785 + Constructor.propTypes = _assign({}, Constructor.propTypes, propTypes);
786 + },
787 + statics: function (Constructor, statics) {
788 + mixStaticSpecIntoComponent(Constructor, statics);
789 + },
790 + autobind: function () {} };
791 +
792 +function validateTypeDef(Constructor, typeDef, location) {
793 + for (var propName in typeDef) {
794 + if (typeDef.hasOwnProperty(propName)) {
795 + // use a warning instead of an invariant so components
796 + // don't show up in prod but only in __DEV__
797 + "development" !== 'production' ? warning(typeof typeDef[propName] === 'function', '%s: %s type `%s` is invalid; it must be a function, usually from ' + 'React.PropTypes.', Constructor.displayName || 'ReactClass', ReactPropTypeLocationNames[location], propName) : void 0;
798 + }
799 + }
800 +}
801 +
802 +function validateMethodOverride(isAlreadyDefined, name) {
803 + var specPolicy = ReactClassInterface.hasOwnProperty(name) ? ReactClassInterface[name] : null;
804 +
805 + // Disallow overriding of base class methods unless explicitly allowed.
806 + if (ReactClassMixin.hasOwnProperty(name)) {
807 + !(specPolicy === 'OVERRIDE_BASE') ? "development" !== 'production' ? invariant(false, 'ReactClassInterface: You are attempting to override `%s` from your class specification. Ensure that your method names do not overlap with React methods.', name) : _prodInvariant('73', name) : void 0;
808 + }
809 +
810 + // Disallow defining methods more than once unless explicitly allowed.
811 + if (isAlreadyDefined) {
812 + !(specPolicy === 'DEFINE_MANY' || specPolicy === 'DEFINE_MANY_MERGED') ? "development" !== 'production' ? invariant(false, 'ReactClassInterface: You are attempting to define `%s` on your component more than once. This conflict may be due to a mixin.', name) : _prodInvariant('74', name) : void 0;
813 + }
814 +}
815 +
816 +/**
817 + * Mixin helper which handles policy validation and reserved
818 + * specification keys when building React classes.
819 + */
820 +function mixSpecIntoComponent(Constructor, spec) {
821 + if (!spec) {
822 + if ("development" !== 'production') {
823 + var typeofSpec = typeof spec;
824 + var isMixinValid = typeofSpec === 'object' && spec !== null;
825 +
826 + "development" !== 'production' ? warning(isMixinValid, '%s: You\'re attempting to include a mixin that is either null ' + 'or not an object. Check the mixins included by the component, ' + 'as well as any mixins they include themselves. ' + 'Expected object but got %s.', Constructor.displayName || 'ReactClass', spec === null ? null : typeofSpec) : void 0;
827 + }
828 +
829 + return;
830 + }
831 +
832 + !(typeof spec !== 'function') ? "development" !== 'production' ? invariant(false, 'ReactClass: You\'re attempting to use a component class or function as a mixin. Instead, just use a regular object.') : _prodInvariant('75') : void 0;
833 + !!ReactElement.isValidElement(spec) ? "development" !== 'production' ? invariant(false, 'ReactClass: You\'re attempting to use a component as a mixin. Instead, just use a regular object.') : _prodInvariant('76') : void 0;
834 +
835 + var proto = Constructor.prototype;
836 + var autoBindPairs = proto.__reactAutoBindPairs;
837 +
838 + // By handling mixins before any other properties, we ensure the same
839 + // chaining order is applied to methods with DEFINE_MANY policy, whether
840 + // mixins are listed before or after these methods in the spec.
841 + if (spec.hasOwnProperty(MIXINS_KEY)) {
842 + RESERVED_SPEC_KEYS.mixins(Constructor, spec.mixins);
843 + }
844 +
845 + for (var name in spec) {
846 + if (!spec.hasOwnProperty(name)) {
847 + continue;
848 + }
849 +
850 + if (name === MIXINS_KEY) {
851 + // We have already handled mixins in a special case above.
852 + continue;
853 + }
854 +
855 + var property = spec[name];
856 + var isAlreadyDefined = proto.hasOwnProperty(name);
857 + validateMethodOverride(isAlreadyDefined, name);
858 +
859 + if (RESERVED_SPEC_KEYS.hasOwnProperty(name)) {
860 + RESERVED_SPEC_KEYS[name](Constructor, property);
861 + } else {
862 + // Setup methods on prototype:
863 + // The following member methods should not be automatically bound:
864 + // 1. Expected ReactClass methods (in the "interface").
865 + // 2. Overridden methods (that were mixed in).
866 + var isReactClassMethod = ReactClassInterface.hasOwnProperty(name);
867 + var isFunction = typeof property === 'function';
868 + var shouldAutoBind = isFunction && !isReactClassMethod && !isAlreadyDefined && spec.autobind !== false;
869 +
870 + if (shouldAutoBind) {
871 + autoBindPairs.push(name, property);
872 + proto[name] = property;
873 + } else {
874 + if (isAlreadyDefined) {
875 + var specPolicy = ReactClassInterface[name];
876 +
877 + // These cases should already be caught by validateMethodOverride.
878 + !(isReactClassMethod && (specPolicy === 'DEFINE_MANY_MERGED' || specPolicy === 'DEFINE_MANY')) ? "development" !== 'production' ? invariant(false, 'ReactClass: Unexpected spec policy %s for key %s when mixing in component specs.', specPolicy, name) : _prodInvariant('77', specPolicy, name) : void 0;
879 +
880 + // For methods which are defined more than once, call the existing
881 + // methods before calling the new property, merging if appropriate.
882 + if (specPolicy === 'DEFINE_MANY_MERGED') {
883 + proto[name] = createMergedResultFunction(proto[name], property);
884 + } else if (specPolicy === 'DEFINE_MANY') {
885 + proto[name] = createChainedFunction(proto[name], property);
886 + }
887 + } else {
888 + proto[name] = property;
889 + if ("development" !== 'production') {
890 + // Add verbose displayName to the function, which helps when looking
891 + // at profiling tools.
892 + if (typeof property === 'function' && spec.displayName) {
893 + proto[name].displayName = spec.displayName + '_' + name;
894 + }
895 + }
896 + }
897 + }
898 + }
899 + }
900 +}
901 +
902 +function mixStaticSpecIntoComponent(Constructor, statics) {
903 + if (!statics) {
904 + return;
905 + }
906 + for (var name in statics) {
907 + var property = statics[name];
908 + if (!statics.hasOwnProperty(name)) {
909 + continue;
910 + }
911 +
912 + var isReserved = name in RESERVED_SPEC_KEYS;
913 + !!isReserved ? "development" !== 'production' ? invariant(false, 'ReactClass: You are attempting to define a reserved property, `%s`, that shouldn\'t be on the "statics" key. Define it as an instance property instead; it will still be accessible on the constructor.', name) : _prodInvariant('78', name) : void 0;
914 +
915 + var isInherited = name in Constructor;
916 + !!isInherited ? "development" !== 'production' ? invariant(false, 'ReactClass: You are attempting to define `%s` on your component more than once. This conflict may be due to a mixin.', name) : _prodInvariant('79', name) : void 0;
917 + Constructor[name] = property;
918 + }
919 +}
920 +
921 +/**
922 + * Merge two objects, but throw if both contain the same key.
923 + *
924 + * @param {object} one The first object, which is mutated.
925 + * @param {object} two The second object
926 + * @return {object} one after it has been mutated to contain everything in two.
927 + */
928 +function mergeIntoWithNoDuplicateKeys(one, two) {
929 + !(one && two && typeof one === 'object' && typeof two === 'object') ? "development" !== 'production' ? invariant(false, 'mergeIntoWithNoDuplicateKeys(): Cannot merge non-objects.') : _prodInvariant('80') : void 0;
930 +
931 + for (var key in two) {
932 + if (two.hasOwnProperty(key)) {
933 + !(one[key] === undefined) ? "development" !== 'production' ? invariant(false, 'mergeIntoWithNoDuplicateKeys(): Tried to merge two objects with the same key: `%s`. This conflict may be due to a mixin; in particular, this may be caused by two getInitialState() or getDefaultProps() methods returning objects with clashing keys.', key) : _prodInvariant('81', key) : void 0;
934 + one[key] = two[key];
935 + }
936 + }
937 + return one;
938 +}
939 +
940 +/**
941 + * Creates a function that invokes two functions and merges their return values.
942 + *
943 + * @param {function} one Function to invoke first.
944 + * @param {function} two Function to invoke second.
945 + * @return {function} Function that invokes the two argument functions.
946 + * @private
947 + */
948 +function createMergedResultFunction(one, two) {
949 + return function mergedResult() {
950 + var a = one.apply(this, arguments);
951 + var b = two.apply(this, arguments);
952 + if (a == null) {
953 + return b;
954 + } else if (b == null) {
955 + return a;
956 + }
957 + var c = {};
958 + mergeIntoWithNoDuplicateKeys(c, a);
959 + mergeIntoWithNoDuplicateKeys(c, b);
960 + return c;
961 + };
962 +}
963 +
964 +/**
965 + * Creates a function that invokes two functions and ignores their return vales.
966 + *
967 + * @param {function} one Function to invoke first.
968 + * @param {function} two Function to invoke second.
969 + * @return {function} Function that invokes the two argument functions.
970 + * @private
971 + */
972 +function createChainedFunction(one, two) {
973 + return function chainedFunction() {
974 + one.apply(this, arguments);
975 + two.apply(this, arguments);
976 + };
977 +}
978 +
979 +/**
980 + * Binds a method to the component.
981 + *
982 + * @param {object} component Component whose method is going to be bound.
983 + * @param {function} method Method to be bound.
984 + * @return {function} The bound method.
985 + */
986 +function bindAutoBindMethod(component, method) {
987 + var boundMethod = method.bind(component);
988 + if ("development" !== 'production') {
989 + boundMethod.__reactBoundContext = component;
990 + boundMethod.__reactBoundMethod = method;
991 + boundMethod.__reactBoundArguments = null;
992 + var componentName = component.constructor.displayName;
993 + var _bind = boundMethod.bind;
994 + boundMethod.bind = function (newThis) {
995 + for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
996 + args[_key - 1] = arguments[_key];
997 + }
998 +
999 + // User is trying to bind() an autobound method; we effectively will
1000 + // ignore the value of "this" that the user is trying to use, so
1001 + // let's warn.
1002 + if (newThis !== component && newThis !== null) {
1003 + "development" !== 'production' ? warning(false, 'bind(): React component methods may only be bound to the ' + 'component instance. See %s', componentName) : void 0;
1004 + } else if (!args.length) {
1005 + "development" !== 'production' ? warning(false, 'bind(): You are binding a component method to the component. ' + 'React does this for you automatically in a high-performance ' + 'way, so you can safely remove this call. See %s', componentName) : void 0;
1006 + return boundMethod;
1007 + }
1008 + var reboundMethod = _bind.apply(boundMethod, arguments);
1009 + reboundMethod.__reactBoundContext = component;
1010 + reboundMethod.__reactBoundMethod = method;
1011 + reboundMethod.__reactBoundArguments = args;
1012 + return reboundMethod;
1013 + };
1014 + }
1015 + return boundMethod;
1016 +}
1017 +
1018 +/**
1019 + * Binds all auto-bound methods in a component.
1020 + *
1021 + * @param {object} component Component whose method is going to be bound.
1022 + */
1023 +function bindAutoBindMethods(component) {
1024 + var pairs = component.__reactAutoBindPairs;
1025 + for (var i = 0; i < pairs.length; i += 2) {
1026 + var autoBindKey = pairs[i];
1027 + var method = pairs[i + 1];
1028 + component[autoBindKey] = bindAutoBindMethod(component, method);
1029 + }
1030 +}
1031 +
1032 +/**
1033 + * Add more to the ReactClass base class. These are all legacy features and
1034 + * therefore not already part of the modern ReactComponent.
1035 + */
1036 +var ReactClassMixin = {
1037 +
1038 + /**
1039 + * TODO: This will be deprecated because state should always keep a consistent
1040 + * type signature and the only use case for this, is to avoid that.
1041 + */
1042 + replaceState: function (newState, callback) {
1043 + this.updater.enqueueReplaceState(this, newState, callback, 'replaceState');
1044 + },
1045 +
1046 + /**
1047 + * Checks whether or not this composite component is mounted.
1048 + * @return {boolean} True if mounted, false otherwise.
1049 + * @protected
1050 + * @final
1051 + */
1052 + isMounted: function () {
1053 + return this.updater.isMounted(this);
1054 + }
1055 +};
1056 +
1057 +var ReactClassComponent = function () {};
1058 +_assign(ReactClassComponent.prototype, ReactComponent.prototype, ReactClassMixin);
1059 +
1060 +/**
1061 + * Module for creating composite components.
1062 + *
1063 + * @class ReactClass
1064 + */
1065 +var ReactClass = {
1066 +
1067 + /**
1068 + * Creates a composite component class given a class specification.
1069 + * See https://facebook.github.io/react/docs/react-api.html#createclass
1070 + *
1071 + * @param {object} spec Class specification (which must define `render`).
1072 + * @return {function} Component constructor function.
1073 + * @public
1074 + */
1075 + createClass: function (spec) {
1076 + // To keep our warnings more understandable, we'll use a little hack here to
1077 + // ensure that Constructor.name !== 'Constructor'. This makes sure we don't
1078 + // unnecessarily identify a class without displayName as 'Constructor'.
1079 + var Constructor = identity(function (props, context, updater) {
1080 + // This constructor gets overridden by mocks. The argument is used
1081 + // by mocks to assert on what gets mounted.
1082 +
1083 + if ("development" !== 'production') {
1084 + "development" !== 'production' ? warning(this instanceof Constructor, 'Something is calling a React component directly. Use a factory or ' + 'JSX instead. See: https://fb.me/react-legacyfactory') : void 0;
1085 + }
1086 +
1087 + // Wire up auto-binding
1088 + if (this.__reactAutoBindPairs.length) {
1089 + bindAutoBindMethods(this);
1090 + }
1091 +
1092 + this.props = props;
1093 + this.context = context;
1094 + this.refs = emptyObject;
1095 + this.updater = updater || ReactNoopUpdateQueue;
1096 +
1097 + this.state = null;
1098 +
1099 + // ReactClasses doesn't have constructors. Instead, they use the
1100 + // getInitialState and componentWillMount methods for initialization.
1101 +
1102 + var initialState = this.getInitialState ? this.getInitialState() : null;
1103 + if ("development" !== 'production') {
1104 + // We allow auto-mocks to proceed as if they're returning null.
1105 + if (initialState === undefined && this.getInitialState._isMockFunction) {
1106 + // This is probably bad practice. Consider warning here and
1107 + // deprecating this convenience.
1108 + initialState = null;
1109 + }
1110 + }
1111 + !(typeof initialState === 'object' && !Array.isArray(initialState)) ? "development" !== 'production' ? invariant(false, '%s.getInitialState(): must return an object or null', Constructor.displayName || 'ReactCompositeComponent') : _prodInvariant('82', Constructor.displayName || 'ReactCompositeComponent') : void 0;
1112 +
1113 + this.state = initialState;
1114 + });
1115 + Constructor.prototype = new ReactClassComponent();
1116 + Constructor.prototype.constructor = Constructor;
1117 + Constructor.prototype.__reactAutoBindPairs = [];
1118 +
1119 + mixSpecIntoComponent(Constructor, spec);
1120 +
1121 + // Initialize the defaultProps property after all mixins have been merged.
1122 + if (Constructor.getDefaultProps) {
1123 + Constructor.defaultProps = Constructor.getDefaultProps();
1124 + }
1125 +
1126 + if ("development" !== 'production') {
1127 + // This is a tag to indicate that the use of these method names is ok,
1128 + // since it's used with createClass. If it's not, then it's likely a
1129 + // mistake so we'll warn you to use the static property, property
1130 + // initializer or constructor respectively.
1131 + if (Constructor.getDefaultProps) {
1132 + Constructor.getDefaultProps.isReactClassApproved = {};
1133 + }
1134 + if (Constructor.prototype.getInitialState) {
1135 + Constructor.prototype.getInitialState.isReactClassApproved = {};
1136 + }
1137 + }
1138 +
1139 + !Constructor.prototype.render ? "development" !== 'production' ? invariant(false, 'createClass(...): Class specification must implement a `render` method.') : _prodInvariant('83') : void 0;
1140 +
1141 + if ("development" !== 'production') {
1142 + "development" !== 'production' ? warning(!Constructor.prototype.componentShouldUpdate, '%s has a method called ' + 'componentShouldUpdate(). Did you mean shouldComponentUpdate()? ' + 'The name is phrased as a question because the function is ' + 'expected to return a value.', spec.displayName || 'A component') : void 0;
1143 + "development" !== 'production' ? warning(!Constructor.prototype.componentWillRecieveProps, '%s has a method called ' + 'componentWillRecieveProps(). Did you mean componentWillReceiveProps()?', spec.displayName || 'A component') : void 0;
1144 + }
1145 +
1146 + // Reduce time spent doing lookups by setting these on the prototype.
1147 + for (var methodName in ReactClassInterface) {
1148 + if (!Constructor.prototype[methodName]) {
1149 + Constructor.prototype[methodName] = null;
1150 + }
1151 + }
1152 +
1153 + return Constructor;
1154 + }
1155 +
1156 +};
1157 +
1158 +module.exports = ReactClass;
1159 +},{"10":10,"13":13,"14":14,"25":25,"28":28,"29":29,"30":30,"31":31,"6":6}],6:[function(_dereq_,module,exports){
1160 +/**
1161 + * Copyright 2013-present, Facebook, Inc.
1162 + * All rights reserved.
1163 + *
1164 + * This source code is licensed under the BSD-style license found in the
1165 + * LICENSE file in the root directory of this source tree. An additional grant
1166 + * of patent rights can be found in the PATENTS file in the same directory.
1167 + *
1168 + */
1169 +
1170 +'use strict';
1171 +
1172 +var _prodInvariant = _dereq_(25);
1173 +
1174 +var ReactNoopUpdateQueue = _dereq_(13);
1175 +
1176 +var canDefineProperty = _dereq_(20);
1177 +var emptyObject = _dereq_(28);
1178 +var invariant = _dereq_(29);
1179 +var warning = _dereq_(30);
1180 +
1181 +/**
1182 + * Base class helpers for the updating state of a component.
1183 + */
1184 +function ReactComponent(props, context, updater) {
1185 + this.props = props;
1186 + this.context = context;
1187 + this.refs = emptyObject;
1188 + // We initialize the default updater but the real one gets injected by the
1189 + // renderer.
1190 + this.updater = updater || ReactNoopUpdateQueue;
1191 +}
1192 +
1193 +ReactComponent.prototype.isReactComponent = {};
1194 +
1195 +/**
1196 + * Sets a subset of the state. Always use this to mutate
1197 + * state. You should treat `this.state` as immutable.
1198 + *
1199 + * There is no guarantee that `this.state` will be immediately updated, so
1200 + * accessing `this.state` after calling this method may return the old value.
1201 + *
1202 + * There is no guarantee that calls to `setState` will run synchronously,
1203 + * as they may eventually be batched together. You can provide an optional
1204 + * callback that will be executed when the call to setState is actually
1205 + * completed.
1206 + *
1207 + * When a function is provided to setState, it will be called at some point in
1208 + * the future (not synchronously). It will be called with the up to date
1209 + * component arguments (state, props, context). These values can be different
1210 + * from this.* because your function may be called after receiveProps but before
1211 + * shouldComponentUpdate, and this new state, props, and context will not yet be
1212 + * assigned to this.
1213 + *
1214 + * @param {object|function} partialState Next partial state or function to
1215 + * produce next partial state to be merged with current state.
1216 + * @param {?function} callback Called after state is updated.
1217 + * @final
1218 + * @protected
1219 + */
1220 +ReactComponent.prototype.setState = function (partialState, callback) {
1221 + !(typeof partialState === 'object' || typeof partialState === 'function' || partialState == null) ? "development" !== 'production' ? invariant(false, 'setState(...): takes an object of state variables to update or a function which returns an object of state variables.') : _prodInvariant('85') : void 0;
1222 + this.updater.enqueueSetState(this, partialState, callback, 'setState');
1223 +};
1224 +
1225 +/**
1226 + * Forces an update. This should only be invoked when it is known with
1227 + * certainty that we are **not** in a DOM transaction.
1228 + *
1229 + * You may want to call this when you know that some deeper aspect of the
1230 + * component's state has changed but `setState` was not called.
1231 + *
1232 + * This will not invoke `shouldComponentUpdate`, but it will invoke
1233 + * `componentWillUpdate` and `componentDidUpdate`.
1234 + *
1235 + * @param {?function} callback Called after update is complete.
1236 + * @final
1237 + * @protected
1238 + */
1239 +ReactComponent.prototype.forceUpdate = function (callback) {
1240 + this.updater.enqueueForceUpdate(this, callback, 'forceUpdate');
1241 +};
1242 +
1243 +/**
1244 + * Deprecated APIs. These APIs used to exist on classic React classes but since
1245 + * we would like to deprecate them, we're not going to move them over to this
1246 + * modern base class. Instead, we define a getter that warns if it's accessed.
1247 + */
1248 +if ("development" !== 'production') {
1249 + var deprecatedAPIs = {
1250 + isMounted: ['isMounted', 'Instead, make sure to clean up subscriptions and pending requests in ' + 'componentWillUnmount to prevent memory leaks.'],
1251 + replaceState: ['replaceState', 'Refactor your code to use setState instead (see ' + 'https://github.com/facebook/react/issues/3236).']
1252 + };
1253 + var defineDeprecationWarning = function (methodName, info) {
1254 + if (canDefineProperty) {
1255 + Object.defineProperty(ReactComponent.prototype, methodName, {
1256 + get: function () {
1257 + "development" !== 'production' ? warning(false, '%s(...) is deprecated in plain JavaScript React classes. %s', info[0], info[1]) : void 0;
1258 + return undefined;
1259 + }
1260 + });
1261 + }
1262 + };
1263 + for (var fnName in deprecatedAPIs) {
1264 + if (deprecatedAPIs.hasOwnProperty(fnName)) {
1265 + defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);
1266 + }
1267 + }
1268 +}
1269 +
1270 +module.exports = ReactComponent;
1271 +},{"13":13,"20":20,"25":25,"28":28,"29":29,"30":30}],7:[function(_dereq_,module,exports){
1272 +/**
1273 + * Copyright 2016-present, Facebook, Inc.
1274 + * All rights reserved.
1275 + *
1276 + * This source code is licensed under the BSD-style license found in the
1277 + * LICENSE file in the root directory of this source tree. An additional grant
1278 + * of patent rights can be found in the PATENTS file in the same directory.
1279 + *
1280 + *
1281 + */
1282 +
1283 +'use strict';
1284 +
1285 +var _prodInvariant = _dereq_(25);
1286 +
1287 +var ReactCurrentOwner = _dereq_(8);
1288 +var ReactTypeOfWork = _dereq_(17);
1289 +var IndeterminateComponent = ReactTypeOfWork.IndeterminateComponent,
1290 + FunctionalComponent = ReactTypeOfWork.FunctionalComponent,
1291 + ClassComponent = ReactTypeOfWork.ClassComponent,
1292 + HostComponent = ReactTypeOfWork.HostComponent;
1293 +
1294 +
1295 +var getComponentName = _dereq_(22);
1296 +var invariant = _dereq_(29);
1297 +var warning = _dereq_(30);
1298 +
1299 +function isNative(fn) {
1300 + // Based on isNative() from Lodash
1301 + var funcToString = Function.prototype.toString;
1302 + var hasOwnProperty = Object.prototype.hasOwnProperty;
1303 + var reIsNative = RegExp('^' + funcToString
1304 + // Take an example native function source for comparison
1305 + .call(hasOwnProperty)
1306 + // Strip regex characters so we can use it for regex
1307 + .replace(/[\\^$.*+?()[\]{}|]/g, '\\$&')
1308 + // Remove hasOwnProperty from the template to make it generic
1309 + .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$');
1310 + try {
1311 + var source = funcToString.call(fn);
1312 + return reIsNative.test(source);
1313 + } catch (err) {
1314 + return false;
1315 + }
1316 +}
1317 +
1318 +var canUseCollections =
1319 +// Array.from
1320 +typeof Array.from === 'function' &&
1321 +// Map
1322 +typeof Map === 'function' && isNative(Map) &&
1323 +// Map.prototype.keys
1324 +Map.prototype != null && typeof Map.prototype.keys === 'function' && isNative(Map.prototype.keys) &&
1325 +// Set
1326 +typeof Set === 'function' && isNative(Set) &&
1327 +// Set.prototype.keys
1328 +Set.prototype != null && typeof Set.prototype.keys === 'function' && isNative(Set.prototype.keys);
1329 +
1330 +var setItem;
1331 +var getItem;
1332 +var removeItem;
1333 +var getItemIDs;
1334 +var addRoot;
1335 +var removeRoot;
1336 +var getRootIDs;
1337 +
1338 +if (canUseCollections) {
1339 + var itemMap = new Map();
1340 + var rootIDSet = new Set();
1341 +
1342 + setItem = function (id, item) {
1343 + itemMap.set(id, item);
1344 + };
1345 + getItem = function (id) {
1346 + return itemMap.get(id);
1347 + };
1348 + removeItem = function (id) {
1349 + itemMap['delete'](id);
1350 + };
1351 + getItemIDs = function () {
1352 + return Array.from(itemMap.keys());
1353 + };
1354 +
1355 + addRoot = function (id) {
1356 + rootIDSet.add(id);
1357 + };
1358 + removeRoot = function (id) {
1359 + rootIDSet['delete'](id);
1360 + };
1361 + getRootIDs = function () {
1362 + return Array.from(rootIDSet.keys());
1363 + };
1364 +} else {
1365 + var itemByKey = {};
1366 + var rootByKey = {};
1367 +
1368 + // Use non-numeric keys to prevent V8 performance issues:
1369 + // https://github.com/facebook/react/pull/7232
1370 + var getKeyFromID = function (id) {
1371 + return '.' + id;
1372 + };
1373 + var getIDFromKey = function (key) {
1374 + return parseInt(key.substr(1), 10);
1375 + };
1376 +
1377 + setItem = function (id, item) {
1378 + var key = getKeyFromID(id);
1379 + itemByKey[key] = item;
1380 + };
1381 + getItem = function (id) {
1382 + var key = getKeyFromID(id);
1383 + return itemByKey[key];
1384 + };
1385 + removeItem = function (id) {
1386 + var key = getKeyFromID(id);
1387 + delete itemByKey[key];
1388 + };
1389 + getItemIDs = function () {
1390 + return Object.keys(itemByKey).map(getIDFromKey);
1391 + };
1392 +
1393 + addRoot = function (id) {
1394 + var key = getKeyFromID(id);
1395 + rootByKey[key] = true;
1396 + };
1397 + removeRoot = function (id) {
1398 + var key = getKeyFromID(id);
1399 + delete rootByKey[key];
1400 + };
1401 + getRootIDs = function () {
1402 + return Object.keys(rootByKey).map(getIDFromKey);
1403 + };
1404 +}
1405 +
1406 +var unmountedIDs = [];
1407 +
1408 +function purgeDeep(id) {
1409 + var item = getItem(id);
1410 + if (item) {
1411 + var childIDs = item.childIDs;
1412 +
1413 + removeItem(id);
1414 + childIDs.forEach(purgeDeep);
1415 + }
1416 +}
1417 +
1418 +function describeComponentFrame(name, source, ownerName) {
1419 + return '\n in ' + (name || 'Unknown') + (source ? ' (at ' + source.fileName.replace(/^.*[\\\/]/, '') + ':' + source.lineNumber + ')' : ownerName ? ' (created by ' + ownerName + ')' : '');
1420 +}
1421 +
1422 +function getDisplayName(element) {
1423 + if (element == null) {
1424 + return '#empty';
1425 + } else if (typeof element === 'string' || typeof element === 'number') {
1426 + return '#text';
1427 + } else if (typeof element.type === 'string') {
1428 + return element.type;
1429 + } else {
1430 + return element.type.displayName || element.type.name || 'Unknown';
1431 + }
1432 +}
1433 +
1434 +function describeID(id) {
1435 + var name = ReactComponentTreeHook.getDisplayName(id);
1436 + var element = ReactComponentTreeHook.getElement(id);
1437 + var ownerID = ReactComponentTreeHook.getOwnerID(id);
1438 + var ownerName;
1439 + if (ownerID) {
1440 + ownerName = ReactComponentTreeHook.getDisplayName(ownerID);
1441 + }
1442 + "development" !== 'production' ? warning(element, 'ReactComponentTreeHook: Missing React element for debugID %s when ' + 'building stack', id) : void 0;
1443 + return describeComponentFrame(name, element && element._source, ownerName);
1444 +}
1445 +
1446 +function describeFiber(fiber) {
1447 + switch (fiber.tag) {
1448 + case IndeterminateComponent:
1449 + case FunctionalComponent:
1450 + case ClassComponent:
1451 + case HostComponent:
1452 + var owner = fiber._debugOwner;
1453 + var source = fiber._debugSource;
1454 + var name = getComponentName(fiber);
1455 + var ownerName = null;
1456 + if (owner) {
1457 + ownerName = getComponentName(owner);
1458 + }
1459 + return describeComponentFrame(name, source, ownerName);
1460 + default:
1461 + return '';
1462 + }
1463 +}
1464 +
1465 +var ReactComponentTreeHook = {
1466 + onSetChildren: function (id, nextChildIDs) {
1467 + var item = getItem(id);
1468 + invariant(item, 'Item must have been set');
1469 + item.childIDs = nextChildIDs;
1470 +
1471 + for (var i = 0; i < nextChildIDs.length; i++) {
1472 + var nextChildID = nextChildIDs[i];
1473 + var nextChild = getItem(nextChildID);
1474 + !nextChild ? "development" !== 'production' ? invariant(false, 'Expected hook events to fire for the child before its parent includes it in onSetChildren().') : _prodInvariant('140') : void 0;
1475 + !(nextChild.childIDs != null || typeof nextChild.element !== 'object' || nextChild.element == null) ? "development" !== 'production' ? invariant(false, 'Expected onSetChildren() to fire for a container child before its parent includes it in onSetChildren().') : _prodInvariant('141') : void 0;
1476 + !nextChild.isMounted ? "development" !== 'production' ? invariant(false, 'Expected onMountComponent() to fire for the child before its parent includes it in onSetChildren().') : _prodInvariant('71') : void 0;
1477 + if (nextChild.parentID == null) {
1478 + nextChild.parentID = id;
1479 + // TODO: This shouldn't be necessary but mounting a new root during in
1480 + // componentWillMount currently causes not-yet-mounted components to
1481 + // be purged from our tree data so their parent id is missing.
1482 + }
1483 + !(nextChild.parentID === id) ? "development" !== 'production' ? invariant(false, 'Expected onBeforeMountComponent() parent and onSetChildren() to be consistent (%s has parents %s and %s).', nextChildID, nextChild.parentID, id) : _prodInvariant('142', nextChildID, nextChild.parentID, id) : void 0;
1484 + }
1485 + },
1486 + onBeforeMountComponent: function (id, element, parentID) {
1487 + var item = {
1488 + element: element,
1489 + parentID: parentID,
1490 + text: null,
1491 + childIDs: [],
1492 + isMounted: false,
1493 + updateCount: 0
1494 + };
1495 + setItem(id, item);
1496 + },
1497 + onBeforeUpdateComponent: function (id, element) {
1498 + var item = getItem(id);
1499 + if (!item || !item.isMounted) {
1500 + // We may end up here as a result of setState() in componentWillUnmount().
1501 + // In this case, ignore the element.
1502 + return;
1503 + }
1504 + item.element = element;
1505 + },
1506 + onMountComponent: function (id) {
1507 + var item = getItem(id);
1508 + invariant(item, 'Item must have been set');
1509 + item.isMounted = true;
1510 + var isRoot = item.parentID === 0;
1511 + if (isRoot) {
1512 + addRoot(id);
1513 + }
1514 + },
1515 + onUpdateComponent: function (id) {
1516 + var item = getItem(id);
1517 + if (!item || !item.isMounted) {
1518 + // We may end up here as a result of setState() in componentWillUnmount().
1519 + // In this case, ignore the element.
1520 + return;
1521 + }
1522 + item.updateCount++;
1523 + },
1524 + onUnmountComponent: function (id) {
1525 + var item = getItem(id);
1526 + if (item) {
1527 + // We need to check if it exists.
1528 + // `item` might not exist if it is inside an error boundary, and a sibling
1529 + // error boundary child threw while mounting. Then this instance never
1530 + // got a chance to mount, but it still gets an unmounting event during
1531 + // the error boundary cleanup.
1532 + item.isMounted = false;
1533 + var isRoot = item.parentID === 0;
1534 + if (isRoot) {
1535 + removeRoot(id);
1536 + }
1537 + }
1538 + unmountedIDs.push(id);
1539 + },
1540 + purgeUnmountedComponents: function () {
1541 + if (ReactComponentTreeHook._preventPurging) {
1542 + // Should only be used for testing.
1543 + return;
1544 + }
1545 +
1546 + for (var i = 0; i < unmountedIDs.length; i++) {
1547 + var id = unmountedIDs[i];
1548 + purgeDeep(id);
1549 + }
1550 + unmountedIDs.length = 0;
1551 + },
1552 + isMounted: function (id) {
1553 + var item = getItem(id);
1554 + return item ? item.isMounted : false;
1555 + },
1556 + getCurrentStackAddendum: function (topElement) {
1557 + var info = '';
1558 + if (topElement) {
1559 + var name = getDisplayName(topElement);
1560 + var owner = topElement._owner;
1561 + info += describeComponentFrame(name, topElement._source, owner && getComponentName(owner));
1562 + }
1563 +
1564 + var currentOwner = ReactCurrentOwner.current;
1565 + if (currentOwner) {
1566 + if (typeof currentOwner.tag === 'number') {
1567 + var workInProgress = currentOwner;
1568 + // Safe because if current owner exists, we are reconciling,
1569 + // and it is guaranteed to be the work-in-progress version.
1570 + info += ReactComponentTreeHook.getStackAddendumByWorkInProgressFiber(workInProgress);
1571 + } else if (typeof currentOwner._debugID === 'number') {
1572 + info += ReactComponentTreeHook.getStackAddendumByID(currentOwner._debugID);
1573 + }
1574 + }
1575 + return info;
1576 + },
1577 + getStackAddendumByID: function (id) {
1578 + var info = '';
1579 + while (id) {
1580 + info += describeID(id);
1581 + id = ReactComponentTreeHook.getParentID(id);
1582 + }
1583 + return info;
1584 + },
1585 +
1586 +
1587 + // This function can only be called with a work-in-progress fiber and
1588 + // only during begin or complete phase. Do not call it under any other
1589 + // circumstances.
1590 + getStackAddendumByWorkInProgressFiber: function (workInProgress) {
1591 + var info = '';
1592 + var node = workInProgress;
1593 + do {
1594 + info += describeFiber(node);
1595 + // Otherwise this return pointer might point to the wrong tree:
1596 + node = node['return'];
1597 + } while (node);
1598 + return info;
1599 + },
1600 + getChildIDs: function (id) {
1601 + var item = getItem(id);
1602 + return item ? item.childIDs : [];
1603 + },
1604 + getDisplayName: function (id) {
1605 + var element = ReactComponentTreeHook.getElement(id);
1606 + if (!element) {
1607 + return null;
1608 + }
1609 + return getDisplayName(element);
1610 + },
1611 + getElement: function (id) {
1612 + var item = getItem(id);
1613 + return item ? item.element : null;
1614 + },
1615 + getOwnerID: function (id) {
1616 + var element = ReactComponentTreeHook.getElement(id);
1617 + if (!element || !element._owner) {
1618 + return null;
1619 + }
1620 + return element._owner._debugID;
1621 + },
1622 + getParentID: function (id) {
1623 + var item = getItem(id);
1624 + return item ? item.parentID : null;
1625 + },
1626 + getSource: function (id) {
1627 + var item = getItem(id);
1628 + var element = item ? item.element : null;
1629 + var source = element != null ? element._source : null;
1630 + return source;
1631 + },
1632 + getText: function (id) {
1633 + var element = ReactComponentTreeHook.getElement(id);
1634 + if (typeof element === 'string') {
1635 + return element;
1636 + } else if (typeof element === 'number') {
1637 + return '' + element;
1638 + } else {
1639 + return null;
1640 + }
1641 + },
1642 + getUpdateCount: function (id) {
1643 + var item = getItem(id);
1644 + return item ? item.updateCount : 0;
1645 + },
1646 +
1647 +
1648 + getRootIDs: getRootIDs,
1649 + getRegisteredIDs: getItemIDs
1650 +};
1651 +
1652 +module.exports = ReactComponentTreeHook;
1653 +},{"17":17,"22":22,"25":25,"29":29,"30":30,"8":8}],8:[function(_dereq_,module,exports){
1654 +/**
1655 + * Copyright 2013-present, Facebook, Inc.
1656 + * All rights reserved.
1657 + *
1658 + * This source code is licensed under the BSD-style license found in the
1659 + * LICENSE file in the root directory of this source tree. An additional grant
1660 + * of patent rights can be found in the PATENTS file in the same directory.
1661 + *
1662 + *
1663 + */
1664 +
1665 +'use strict';
1666 +
1667 +/**
1668 + * Keeps track of the current owner.
1669 + *
1670 + * The current owner is the component who should own any components that are
1671 + * currently being constructed.
1672 + */
1673 +var ReactCurrentOwner = {
1674 +
1675 + /**
1676 + * @internal
1677 + * @type {ReactComponent}
1678 + */
1679 + current: null
1680 +
1681 +};
1682 +
1683 +module.exports = ReactCurrentOwner;
1684 +},{}],9:[function(_dereq_,module,exports){
1685 +/**
1686 + * Copyright 2013-present, Facebook, Inc.
1687 + * All rights reserved.
1688 + *
1689 + * This source code is licensed under the BSD-style license found in the
1690 + * LICENSE file in the root directory of this source tree. An additional grant
1691 + * of patent rights can be found in the PATENTS file in the same directory.
1692 + *
1693 + */
1694 +
1695 +'use strict';
1696 +
1697 +var ReactElement = _dereq_(10);
1698 +
1699 +/**
1700 + * Create a factory that creates HTML tag elements.
1701 + *
1702 + * @private
1703 + */
1704 +var createDOMFactory = ReactElement.createFactory;
1705 +if ("development" !== 'production') {
1706 + var ReactElementValidator = _dereq_(12);
1707 + createDOMFactory = ReactElementValidator.createFactory;
1708 +}
1709 +
1710 +/**
1711 + * Creates a mapping from supported HTML tags to `ReactDOMComponent` classes.
1712 + * This is also accessible via `React.DOM`.
1713 + *
1714 + * @public
1715 + */
1716 +var ReactDOMFactories = {
1717 + a: createDOMFactory('a'),
1718 + abbr: createDOMFactory('abbr'),
1719 + address: createDOMFactory('address'),
1720 + area: createDOMFactory('area'),
1721 + article: createDOMFactory('article'),
1722 + aside: createDOMFactory('aside'),
1723 + audio: createDOMFactory('audio'),
1724 + b: createDOMFactory('b'),
1725 + base: createDOMFactory('base'),
1726 + bdi: createDOMFactory('bdi'),
1727 + bdo: createDOMFactory('bdo'),
1728 + big: createDOMFactory('big'),
1729 + blockquote: createDOMFactory('blockquote'),
1730 + body: createDOMFactory('body'),
1731 + br: createDOMFactory('br'),
1732 + button: createDOMFactory('button'),
1733 + canvas: createDOMFactory('canvas'),
1734 + caption: createDOMFactory('caption'),
1735 + cite: createDOMFactory('cite'),
1736 + code: createDOMFactory('code'),
1737 + col: createDOMFactory('col'),
1738 + colgroup: createDOMFactory('colgroup'),
1739 + data: createDOMFactory('data'),
1740 + datalist: createDOMFactory('datalist'),
1741 + dd: createDOMFactory('dd'),
1742 + del: createDOMFactory('del'),
1743 + details: createDOMFactory('details'),
1744 + dfn: createDOMFactory('dfn'),
1745 + dialog: createDOMFactory('dialog'),
1746 + div: createDOMFactory('div'),
1747 + dl: createDOMFactory('dl'),
1748 + dt: createDOMFactory('dt'),
1749 + em: createDOMFactory('em'),
1750 + embed: createDOMFactory('embed'),
1751 + fieldset: createDOMFactory('fieldset'),
1752 + figcaption: createDOMFactory('figcaption'),
1753 + figure: createDOMFactory('figure'),
1754 + footer: createDOMFactory('footer'),
1755 + form: createDOMFactory('form'),
1756 + h1: createDOMFactory('h1'),
1757 + h2: createDOMFactory('h2'),
1758 + h3: createDOMFactory('h3'),
1759 + h4: createDOMFactory('h4'),
1760 + h5: createDOMFactory('h5'),
1761 + h6: createDOMFactory('h6'),
1762 + head: createDOMFactory('head'),
1763 + header: createDOMFactory('header'),
1764 + hgroup: createDOMFactory('hgroup'),
1765 + hr: createDOMFactory('hr'),
1766 + html: createDOMFactory('html'),
1767 + i: createDOMFactory('i'),
1768 + iframe: createDOMFactory('iframe'),
1769 + img: createDOMFactory('img'),
1770 + input: createDOMFactory('input'),
1771 + ins: createDOMFactory('ins'),
1772 + kbd: createDOMFactory('kbd'),
1773 + keygen: createDOMFactory('keygen'),
1774 + label: createDOMFactory('label'),
1775 + legend: createDOMFactory('legend'),
1776 + li: createDOMFactory('li'),
1777 + link: createDOMFactory('link'),
1778 + main: createDOMFactory('main'),
1779 + map: createDOMFactory('map'),
1780 + mark: createDOMFactory('mark'),
1781 + menu: createDOMFactory('menu'),
1782 + menuitem: createDOMFactory('menuitem'),
1783 + meta: createDOMFactory('meta'),
1784 + meter: createDOMFactory('meter'),
1785 + nav: createDOMFactory('nav'),
1786 + noscript: createDOMFactory('noscript'),
1787 + object: createDOMFactory('object'),
1788 + ol: createDOMFactory('ol'),
1789 + optgroup: createDOMFactory('optgroup'),
1790 + option: createDOMFactory('option'),
1791 + output: createDOMFactory('output'),
1792 + p: createDOMFactory('p'),
1793 + param: createDOMFactory('param'),
1794 + picture: createDOMFactory('picture'),
1795 + pre: createDOMFactory('pre'),
1796 + progress: createDOMFactory('progress'),
1797 + q: createDOMFactory('q'),
1798 + rp: createDOMFactory('rp'),
1799 + rt: createDOMFactory('rt'),
1800 + ruby: createDOMFactory('ruby'),
1801 + s: createDOMFactory('s'),
1802 + samp: createDOMFactory('samp'),
1803 + script: createDOMFactory('script'),
1804 + section: createDOMFactory('section'),
1805 + select: createDOMFactory('select'),
1806 + small: createDOMFactory('small'),
1807 + source: createDOMFactory('source'),
1808 + span: createDOMFactory('span'),
1809 + strong: createDOMFactory('strong'),
1810 + style: createDOMFactory('style'),
1811 + sub: createDOMFactory('sub'),
1812 + summary: createDOMFactory('summary'),
1813 + sup: createDOMFactory('sup'),
1814 + table: createDOMFactory('table'),
1815 + tbody: createDOMFactory('tbody'),
1816 + td: createDOMFactory('td'),
1817 + textarea: createDOMFactory('textarea'),
1818 + tfoot: createDOMFactory('tfoot'),
1819 + th: createDOMFactory('th'),
1820 + thead: createDOMFactory('thead'),
1821 + time: createDOMFactory('time'),
1822 + title: createDOMFactory('title'),
1823 + tr: createDOMFactory('tr'),
1824 + track: createDOMFactory('track'),
1825 + u: createDOMFactory('u'),
1826 + ul: createDOMFactory('ul'),
1827 + 'var': createDOMFactory('var'),
1828 + video: createDOMFactory('video'),
1829 + wbr: createDOMFactory('wbr'),
1830 +
1831 + // SVG
1832 + circle: createDOMFactory('circle'),
1833 + clipPath: createDOMFactory('clipPath'),
1834 + defs: createDOMFactory('defs'),
1835 + ellipse: createDOMFactory('ellipse'),
1836 + g: createDOMFactory('g'),
1837 + image: createDOMFactory('image'),
1838 + line: createDOMFactory('line'),
1839 + linearGradient: createDOMFactory('linearGradient'),
1840 + mask: createDOMFactory('mask'),
1841 + path: createDOMFactory('path'),
1842 + pattern: createDOMFactory('pattern'),
1843 + polygon: createDOMFactory('polygon'),
1844 + polyline: createDOMFactory('polyline'),
1845 + radialGradient: createDOMFactory('radialGradient'),
1846 + rect: createDOMFactory('rect'),
1847 + stop: createDOMFactory('stop'),
1848 + svg: createDOMFactory('svg'),
1849 + text: createDOMFactory('text'),
1850 + tspan: createDOMFactory('tspan')
1851 +};
1852 +
1853 +module.exports = ReactDOMFactories;
1854 +},{"10":10,"12":12}],10:[function(_dereq_,module,exports){
1855 +/**
1856 + * Copyright 2014-present, Facebook, Inc.
1857 + * All rights reserved.
1858 + *
1859 + * This source code is licensed under the BSD-style license found in the
1860 + * LICENSE file in the root directory of this source tree. An additional grant
1861 + * of patent rights can be found in the PATENTS file in the same directory.
1862 + *
1863 + */
1864 +
1865 +'use strict';
1866 +
1867 +var _assign = _dereq_(31);
1868 +
1869 +var ReactCurrentOwner = _dereq_(8);
1870 +
1871 +var warning = _dereq_(30);
1872 +var canDefineProperty = _dereq_(20);
1873 +var hasOwnProperty = Object.prototype.hasOwnProperty;
1874 +
1875 +var REACT_ELEMENT_TYPE = _dereq_(11);
1876 +
1877 +var RESERVED_PROPS = {
1878 + key: true,
1879 + ref: true,
1880 + __self: true,
1881 + __source: true
1882 +};
1883 +
1884 +var specialPropKeyWarningShown, specialPropRefWarningShown;
1885 +
1886 +function hasValidRef(config) {
1887 + if ("development" !== 'production') {
1888 + if (hasOwnProperty.call(config, 'ref')) {
1889 + var getter = Object.getOwnPropertyDescriptor(config, 'ref').get;
1890 + if (getter && getter.isReactWarning) {
1891 + return false;
1892 + }
1893 + }
1894 + }
1895 + return config.ref !== undefined;
1896 +}
1897 +
1898 +function hasValidKey(config) {
1899 + if ("development" !== 'production') {
1900 + if (hasOwnProperty.call(config, 'key')) {
1901 + var getter = Object.getOwnPropertyDescriptor(config, 'key').get;
1902 + if (getter && getter.isReactWarning) {
1903 + return false;
1904 + }
1905 + }
1906 + }
1907 + return config.key !== undefined;
1908 +}
1909 +
1910 +function defineKeyPropWarningGetter(props, displayName) {
1911 + var warnAboutAccessingKey = function () {
1912 + if (!specialPropKeyWarningShown) {
1913 + specialPropKeyWarningShown = true;
1914 + "development" !== 'production' ? warning(false, '%s: `key` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://fb.me/react-special-props)', displayName) : void 0;
1915 + }
1916 + };
1917 + warnAboutAccessingKey.isReactWarning = true;
1918 + Object.defineProperty(props, 'key', {
1919 + get: warnAboutAccessingKey,
1920 + configurable: true
1921 + });
1922 +}
1923 +
1924 +function defineRefPropWarningGetter(props, displayName) {
1925 + var warnAboutAccessingRef = function () {
1926 + if (!specialPropRefWarningShown) {
1927 + specialPropRefWarningShown = true;
1928 + "development" !== 'production' ? warning(false, '%s: `ref` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://fb.me/react-special-props)', displayName) : void 0;
1929 + }
1930 + };
1931 + warnAboutAccessingRef.isReactWarning = true;
1932 + Object.defineProperty(props, 'ref', {
1933 + get: warnAboutAccessingRef,
1934 + configurable: true
1935 + });
1936 +}
1937 +
1938 +/**
1939 + * Factory method to create a new React element. This no longer adheres to
1940 + * the class pattern, so do not use new to call it. Also, no instanceof check
1941 + * will work. Instead test $$typeof field against Symbol.for('react.element') to check
1942 + * if something is a React Element.
1943 + *
1944 + * @param {*} type
1945 + * @param {*} key
1946 + * @param {string|object} ref
1947 + * @param {*} self A *temporary* helper to detect places where `this` is
1948 + * different from the `owner` when React.createElement is called, so that we
1949 + * can warn. We want to get rid of owner and replace string `ref`s with arrow
1950 + * functions, and as long as `this` and owner are the same, there will be no
1951 + * change in behavior.
1952 + * @param {*} source An annotation object (added by a transpiler or otherwise)
1953 + * indicating filename, line number, and/or other information.
1954 + * @param {*} owner
1955 + * @param {*} props
1956 + * @internal
1957 + */
1958 +var ReactElement = function (type, key, ref, self, source, owner, props) {
1959 + var element = {
1960 + // This tag allow us to uniquely identify this as a React Element
1961 + $$typeof: REACT_ELEMENT_TYPE,
1962 +
1963 + // Built-in properties that belong on the element
1964 + type: type,
1965 + key: key,
1966 + ref: ref,
1967 + props: props,
1968 +
1969 + // Record the component responsible for creating this element.
1970 + _owner: owner
1971 + };
1972 +
1973 + if ("development" !== 'production') {
1974 + // The validation flag is currently mutative. We put it on
1975 + // an external backing store so that we can freeze the whole object.
1976 + // This can be replaced with a WeakMap once they are implemented in
1977 + // commonly used development environments.
1978 + element._store = {};
1979 +
1980 + // To make comparing ReactElements easier for testing purposes, we make
1981 + // the validation flag non-enumerable (where possible, which should
1982 + // include every environment we run tests in), so the test framework
1983 + // ignores it.
1984 + if (canDefineProperty) {
1985 + Object.defineProperty(element._store, 'validated', {
1986 + configurable: false,
1987 + enumerable: false,
1988 + writable: true,
1989 + value: false
1990 + });
1991 + // self and source are DEV only properties.
1992 + Object.defineProperty(element, '_self', {
1993 + configurable: false,
1994 + enumerable: false,
1995 + writable: false,
1996 + value: self
1997 + });
1998 + // Two elements created in two different places should be considered
1999 + // equal for testing purposes and therefore we hide it from enumeration.
2000 + Object.defineProperty(element, '_source', {
2001 + configurable: false,
2002 + enumerable: false,
2003 + writable: false,
2004 + value: source
2005 + });
2006 + } else {
2007 + element._store.validated = false;
2008 + element._self = self;
2009 + element._source = source;
2010 + }
2011 + if (Object.freeze) {
2012 + Object.freeze(element.props);
2013 + Object.freeze(element);
2014 + }
2015 + }
2016 +
2017 + return element;
2018 +};
2019 +
2020 +/**
2021 + * Create and return a new ReactElement of the given type.
2022 + * See https://facebook.github.io/react/docs/react-api.html#createelement
2023 + */
2024 +ReactElement.createElement = function (type, config, children) {
2025 + var propName;
2026 +
2027 + // Reserved names are extracted
2028 + var props = {};
2029 +
2030 + var key = null;
2031 + var ref = null;
2032 + var self = null;
2033 + var source = null;
2034 +
2035 + if (config != null) {
2036 + if (hasValidRef(config)) {
2037 + ref = config.ref;
2038 + }
2039 + if (hasValidKey(config)) {
2040 + key = '' + config.key;
2041 + }
2042 +
2043 + self = config.__self === undefined ? null : config.__self;
2044 + source = config.__source === undefined ? null : config.__source;
2045 + // Remaining properties are added to a new props object
2046 + for (propName in config) {
2047 + if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
2048 + props[propName] = config[propName];
2049 + }
2050 + }
2051 + }
2052 +
2053 + // Children can be more than one argument, and those are transferred onto
2054 + // the newly allocated props object.
2055 + var childrenLength = arguments.length - 2;
2056 + if (childrenLength === 1) {
2057 + props.children = children;
2058 + } else if (childrenLength > 1) {
2059 + var childArray = Array(childrenLength);
2060 + for (var i = 0; i < childrenLength; i++) {
2061 + childArray[i] = arguments[i + 2];
2062 + }
2063 + if ("development" !== 'production') {
2064 + if (Object.freeze) {
2065 + Object.freeze(childArray);
2066 + }
2067 + }
2068 + props.children = childArray;
2069 + }
2070 +
2071 + // Resolve default props
2072 + if (type && type.defaultProps) {
2073 + var defaultProps = type.defaultProps;
2074 + for (propName in defaultProps) {
2075 + if (props[propName] === undefined) {
2076 + props[propName] = defaultProps[propName];
2077 + }
2078 + }
2079 + }
2080 + if ("development" !== 'production') {
2081 + if (key || ref) {
2082 + if (typeof props.$$typeof === 'undefined' || props.$$typeof !== REACT_ELEMENT_TYPE) {
2083 + var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type;
2084 + if (key) {
2085 + defineKeyPropWarningGetter(props, displayName);
2086 + }
2087 + if (ref) {
2088 + defineRefPropWarningGetter(props, displayName);
2089 + }
2090 + }
2091 + }
2092 + }
2093 + return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
2094 +};
2095 +
2096 +/**
2097 + * Return a function that produces ReactElements of a given type.
2098 + * See https://facebook.github.io/react/docs/react-api.html#createfactory
2099 + */
2100 +ReactElement.createFactory = function (type) {
2101 + var factory = ReactElement.createElement.bind(null, type);
2102 + // Expose the type on the factory and the prototype so that it can be
2103 + // easily accessed on elements. E.g. `<Foo />.type === Foo`.
2104 + // This should not be named `constructor` since this may not be the function
2105 + // that created the element, and it may not even be a constructor.
2106 + // Legacy hook TODO: Warn if this is accessed
2107 + factory.type = type;
2108 + return factory;
2109 +};
2110 +
2111 +ReactElement.cloneAndReplaceKey = function (oldElement, newKey) {
2112 + var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props);
2113 +
2114 + return newElement;
2115 +};
2116 +
2117 +/**
2118 + * Clone and return a new ReactElement using element as the starting point.
2119 + * See https://facebook.github.io/react/docs/react-api.html#cloneelement
2120 + */
2121 +ReactElement.cloneElement = function (element, config, children) {
2122 + var propName;
2123 +
2124 + // Original props are copied
2125 + var props = _assign({}, element.props);
2126 +
2127 + // Reserved names are extracted
2128 + var key = element.key;
2129 + var ref = element.ref;
2130 + // Self is preserved since the owner is preserved.
2131 + var self = element._self;
2132 + // Source is preserved since cloneElement is unlikely to be targeted by a
2133 + // transpiler, and the original source is probably a better indicator of the
2134 + // true owner.
2135 + var source = element._source;
2136 +
2137 + // Owner will be preserved, unless ref is overridden
2138 + var owner = element._owner;
2139 +
2140 + if (config != null) {
2141 + if (hasValidRef(config)) {
2142 + // Silently steal the ref from the parent.
2143 + ref = config.ref;
2144 + owner = ReactCurrentOwner.current;
2145 + }
2146 + if (hasValidKey(config)) {
2147 + key = '' + config.key;
2148 + }
2149 +
2150 + // Remaining properties override existing props
2151 + var defaultProps;
2152 + if (element.type && element.type.defaultProps) {
2153 + defaultProps = element.type.defaultProps;
2154 + }
2155 + for (propName in config) {
2156 + if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
2157 + if (config[propName] === undefined && defaultProps !== undefined) {
2158 + // Resolve default props
2159 + props[propName] = defaultProps[propName];
2160 + } else {
2161 + props[propName] = config[propName];
2162 + }
2163 + }
2164 + }
2165 + }
2166 +
2167 + // Children can be more than one argument, and those are transferred onto
2168 + // the newly allocated props object.
2169 + var childrenLength = arguments.length - 2;
2170 + if (childrenLength === 1) {
2171 + props.children = children;
2172 + } else if (childrenLength > 1) {
2173 + var childArray = Array(childrenLength);
2174 + for (var i = 0; i < childrenLength; i++) {
2175 + childArray[i] = arguments[i + 2];
2176 + }
2177 + props.children = childArray;
2178 + }
2179 +
2180 + return ReactElement(element.type, key, ref, self, source, owner, props);
2181 +};
2182 +
2183 +/**
2184 + * Verifies the object is a ReactElement.
2185 + * See https://facebook.github.io/react/docs/react-api.html#isvalidelement
2186 + * @param {?object} object
2187 + * @return {boolean} True if `object` is a valid component.
2188 + * @final
2189 + */
2190 +ReactElement.isValidElement = function (object) {
2191 + return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
2192 +};
2193 +
2194 +module.exports = ReactElement;
2195 +},{"11":11,"20":20,"30":30,"31":31,"8":8}],11:[function(_dereq_,module,exports){
2196 +/**
2197 + * Copyright 2014-present, Facebook, Inc.
2198 + * All rights reserved.
2199 + *
2200 + * This source code is licensed under the BSD-style license found in the
2201 + * LICENSE file in the root directory of this source tree. An additional grant
2202 + * of patent rights can be found in the PATENTS file in the same directory.
2203 + *
2204 + *
2205 + */
2206 +
2207 +'use strict';
2208 +
2209 +// The Symbol used to tag the ReactElement type. If there is no native Symbol
2210 +// nor polyfill, then a plain number is used for performance.
2211 +
2212 +var REACT_ELEMENT_TYPE = typeof Symbol === 'function' && Symbol['for'] && Symbol['for']('react.element') || 0xeac7;
2213 +
2214 +module.exports = REACT_ELEMENT_TYPE;
2215 +},{}],12:[function(_dereq_,module,exports){
2216 +/**
2217 + * Copyright 2014-present, Facebook, Inc.
2218 + * All rights reserved.
2219 + *
2220 + * This source code is licensed under the BSD-style license found in the
2221 + * LICENSE file in the root directory of this source tree. An additional grant
2222 + * of patent rights can be found in the PATENTS file in the same directory.
2223 + *
2224 + */
2225 +
2226 +/**
2227 + * ReactElementValidator provides a wrapper around a element factory
2228 + * which validates the props passed to the element. This is intended to be
2229 + * used only in DEV and could be replaced by a static type checker for languages
2230 + * that support it.
2231 + */
2232 +
2233 +'use strict';
2234 +
2235 +var ReactCurrentOwner = _dereq_(8);
2236 +var ReactComponentTreeHook = _dereq_(7);
2237 +var ReactElement = _dereq_(10);
2238 +
2239 +var checkReactTypeSpec = _dereq_(21);
2240 +
2241 +var canDefineProperty = _dereq_(20);
2242 +var getComponentName = _dereq_(22);
2243 +var getIteratorFn = _dereq_(23);
2244 +var warning = _dereq_(30);
2245 +
2246 +function getDeclarationErrorAddendum() {
2247 + if (ReactCurrentOwner.current) {
2248 + var name = getComponentName(ReactCurrentOwner.current);
2249 + if (name) {
2250 + return ' Check the render method of `' + name + '`.';
2251 + }
2252 + }
2253 + return '';
2254 +}
2255 +
2256 +/**
2257 + * Warn if there's no key explicitly set on dynamic arrays of children or
2258 + * object keys are not valid. This allows us to keep track of children between
2259 + * updates.
2260 + */
2261 +var ownerHasKeyUseWarning = {};
2262 +
2263 +function getCurrentComponentErrorInfo(parentType) {
2264 + var info = getDeclarationErrorAddendum();
2265 +
2266 + if (!info) {
2267 + var parentName = typeof parentType === 'string' ? parentType : parentType.displayName || parentType.name;
2268 + if (parentName) {
2269 + info = ' Check the top-level render call using <' + parentName + '>.';
2270 + }
2271 + }
2272 + return info;
2273 +}
2274 +
2275 +/**
2276 + * Warn if the element doesn't have an explicit key assigned to it.
2277 + * This element is in an array. The array could grow and shrink or be
2278 + * reordered. All children that haven't already been validated are required to
2279 + * have a "key" property assigned to it. Error statuses are cached so a warning
2280 + * will only be shown once.
2281 + *
2282 + * @internal
2283 + * @param {ReactElement} element Element that requires a key.
2284 + * @param {*} parentType element's parent's type.
2285 + */
2286 +function validateExplicitKey(element, parentType) {
2287 + if (!element._store || element._store.validated || element.key != null) {
2288 + return;
2289 + }
2290 + element._store.validated = true;
2291 +
2292 + var memoizer = ownerHasKeyUseWarning.uniqueKey || (ownerHasKeyUseWarning.uniqueKey = {});
2293 +
2294 + var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);
2295 + if (memoizer[currentComponentErrorInfo]) {
2296 + return;
2297 + }
2298 + memoizer[currentComponentErrorInfo] = true;
2299 +
2300 + // Usually the current owner is the offender, but if it accepts children as a
2301 + // property, it may be the creator of the child that's responsible for
2302 + // assigning it a key.
2303 + var childOwner = '';
2304 + if (element && element._owner && element._owner !== ReactCurrentOwner.current) {
2305 + // Give the component that originally created this child.
2306 + childOwner = ' It was passed a child from ' + getComponentName(element._owner) + '.';
2307 + }
2308 +
2309 + "development" !== 'production' ? warning(false, 'Each child in an array or iterator should have a unique "key" prop.' + '%s%s See https://fb.me/react-warning-keys for more information.%s', currentComponentErrorInfo, childOwner, ReactComponentTreeHook.getCurrentStackAddendum(element)) : void 0;
2310 +}
2311 +
2312 +/**
2313 + * Ensure that every element either is passed in a static location, in an
2314 + * array with an explicit keys property defined, or in an object literal
2315 + * with valid key property.
2316 + *
2317 + * @internal
2318 + * @param {ReactNode} node Statically passed child of any type.
2319 + * @param {*} parentType node's parent's type.
2320 + */
2321 +function validateChildKeys(node, parentType) {
2322 + if (typeof node !== 'object') {
2323 + return;
2324 + }
2325 + if (Array.isArray(node)) {
2326 + for (var i = 0; i < node.length; i++) {
2327 + var child = node[i];
2328 + if (ReactElement.isValidElement(child)) {
2329 + validateExplicitKey(child, parentType);
2330 + }
2331 + }
2332 + } else if (ReactElement.isValidElement(node)) {
2333 + // This element was passed in a valid location.
2334 + if (node._store) {
2335 + node._store.validated = true;
2336 + }
2337 + } else if (node) {
2338 + var iteratorFn = getIteratorFn(node);
2339 + // Entry iterators provide implicit keys.
2340 + if (iteratorFn) {
2341 + if (iteratorFn !== node.entries) {
2342 + var iterator = iteratorFn.call(node);
2343 + var step;
2344 + while (!(step = iterator.next()).done) {
2345 + if (ReactElement.isValidElement(step.value)) {
2346 + validateExplicitKey(step.value, parentType);
2347 + }
2348 + }
2349 + }
2350 + }
2351 + }
2352 +}
2353 +
2354 +/**
2355 + * Given an element, validate that its props follow the propTypes definition,
2356 + * provided by the type.
2357 + *
2358 + * @param {ReactElement} element
2359 + */
2360 +function validatePropTypes(element) {
2361 + var componentClass = element.type;
2362 + if (typeof componentClass !== 'function') {
2363 + return;
2364 + }
2365 + var name = componentClass.displayName || componentClass.name;
2366 + if (componentClass.propTypes) {
2367 + checkReactTypeSpec(componentClass.propTypes, element.props, 'prop', name, element, null);
2368 + }
2369 + if (typeof componentClass.getDefaultProps === 'function') {
2370 + "development" !== 'production' ? warning(componentClass.getDefaultProps.isReactClassApproved, 'getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.') : void 0;
2371 + }
2372 +}
2373 +
2374 +var ReactElementValidator = {
2375 +
2376 + createElement: function (type, props, children) {
2377 + var validType = typeof type === 'string' || typeof type === 'function' || type !== null && typeof type === 'object' && typeof type.tag === 'number';
2378 + // We warn in this case but don't throw. We expect the element creation to
2379 + // succeed and there will likely be errors in render.
2380 + if (!validType) {
2381 + if (typeof type !== 'function' && typeof type !== 'string') {
2382 + var info = '';
2383 + if (type === undefined || typeof type === 'object' && type !== null && Object.keys(type).length === 0) {
2384 + info += ' You likely forgot to export your component from the file ' + 'it\'s defined in.';
2385 + }
2386 + info += getDeclarationErrorAddendum();
2387 + "development" !== 'production' ? warning(false, 'React.createElement: type is invalid -- expected a string (for ' + 'built-in components) or a class/function (for composite ' + 'components) but got: %s.%s', type == null ? type : typeof type, info) : void 0;
2388 + }
2389 + }
2390 +
2391 + var element = ReactElement.createElement.apply(this, arguments);
2392 +
2393 + // The result can be nullish if a mock or a custom function is used.
2394 + // TODO: Drop this when these are no longer allowed as the type argument.
2395 + if (element == null) {
2396 + return element;
2397 + }
2398 +
2399 + // Skip key warning if the type isn't valid since our key validation logic
2400 + // doesn't expect a non-string/function type and can throw confusing errors.
2401 + // We don't want exception behavior to differ between dev and prod.
2402 + // (Rendering will throw with a helpful message and as soon as the type is
2403 + // fixed, the key warnings will appear.)
2404 + if (validType) {
2405 + for (var i = 2; i < arguments.length; i++) {
2406 + validateChildKeys(arguments[i], type);
2407 + }
2408 + }
2409 +
2410 + validatePropTypes(element);
2411 +
2412 + return element;
2413 + },
2414 +
2415 + createFactory: function (type) {
2416 + var validatedFactory = ReactElementValidator.createElement.bind(null, type);
2417 + // Legacy hook TODO: Warn if this is accessed
2418 + validatedFactory.type = type;
2419 +
2420 + if ("development" !== 'production') {
2421 + if (canDefineProperty) {
2422 + Object.defineProperty(validatedFactory, 'type', {
2423 + enumerable: false,
2424 + get: function () {
2425 + "development" !== 'production' ? warning(false, 'Factory.type is deprecated. Access the class directly ' + 'before passing it to createFactory.') : void 0;
2426 + Object.defineProperty(this, 'type', {
2427 + value: type
2428 + });
2429 + return type;
2430 + }
2431 + });
2432 + }
2433 + }
2434 +
2435 + return validatedFactory;
2436 + },
2437 +
2438 + cloneElement: function (element, props, children) {
2439 + var newElement = ReactElement.cloneElement.apply(this, arguments);
2440 + for (var i = 2; i < arguments.length; i++) {
2441 + validateChildKeys(arguments[i], newElement.type);
2442 + }
2443 + validatePropTypes(newElement);
2444 + return newElement;
2445 + }
2446 +
2447 +};
2448 +
2449 +module.exports = ReactElementValidator;
2450 +},{"10":10,"20":20,"21":21,"22":22,"23":23,"30":30,"7":7,"8":8}],13:[function(_dereq_,module,exports){
2451 +/**
2452 + * Copyright 2015-present, Facebook, Inc.
2453 + * All rights reserved.
2454 + *
2455 + * This source code is licensed under the BSD-style license found in the
2456 + * LICENSE file in the root directory of this source tree. An additional grant
2457 + * of patent rights can be found in the PATENTS file in the same directory.
2458 + *
2459 + */
2460 +
2461 +'use strict';
2462 +
2463 +var warning = _dereq_(30);
2464 +
2465 +function warnNoop(publicInstance, callerName) {
2466 + if ("development" !== 'production') {
2467 + var constructor = publicInstance.constructor;
2468 + "development" !== 'production' ? warning(false, '%s(...): Can only update a mounted or mounting component. ' + 'This usually means you called %s() on an unmounted component. ' + 'This is a no-op. Please check the code for the %s component.', callerName, callerName, constructor && (constructor.displayName || constructor.name) || 'ReactClass') : void 0;
2469 + }
2470 +}
2471 +
2472 +/**
2473 + * This is the abstract API for an update queue.
2474 + */
2475 +var ReactNoopUpdateQueue = {
2476 +
2477 + /**
2478 + * Checks whether or not this composite component is mounted.
2479 + * @param {ReactClass} publicInstance The instance we want to test.
2480 + * @return {boolean} True if mounted, false otherwise.
2481 + * @protected
2482 + * @final
2483 + */
2484 + isMounted: function (publicInstance) {
2485 + return false;
2486 + },
2487 +
2488 + /**
2489 + * Forces an update. This should only be invoked when it is known with
2490 + * certainty that we are **not** in a DOM transaction.
2491 + *
2492 + * You may want to call this when you know that some deeper aspect of the
2493 + * component's state has changed but `setState` was not called.
2494 + *
2495 + * This will not invoke `shouldComponentUpdate`, but it will invoke
2496 + * `componentWillUpdate` and `componentDidUpdate`.
2497 + *
2498 + * @param {ReactClass} publicInstance The instance that should rerender.
2499 + * @param {?function} callback Called after component is updated.
2500 + * @param {?string} Name of the calling function in the public API.
2501 + * @internal
2502 + */
2503 + enqueueForceUpdate: function (publicInstance, callback, callerName) {
2504 + warnNoop(publicInstance, 'forceUpdate');
2505 + },
2506 +
2507 + /**
2508 + * Replaces all of the state. Always use this or `setState` to mutate state.
2509 + * You should treat `this.state` as immutable.
2510 + *
2511 + * There is no guarantee that `this.state` will be immediately updated, so
2512 + * accessing `this.state` after calling this method may return the old value.
2513 + *
2514 + * @param {ReactClass} publicInstance The instance that should rerender.
2515 + * @param {object} completeState Next state.
2516 + * @param {?function} callback Called after component is updated.
2517 + * @param {?string} Name of the calling function in the public API.
2518 + * @internal
2519 + */
2520 + enqueueReplaceState: function (publicInstance, completeState, callback, callerName) {
2521 + warnNoop(publicInstance, 'replaceState');
2522 + },
2523 +
2524 + /**
2525 + * Sets a subset of the state. This only exists because _pendingState is
2526 + * internal. This provides a merging strategy that is not available to deep
2527 + * properties which is confusing. TODO: Expose pendingState or don't use it
2528 + * during the merge.
2529 + *
2530 + * @param {ReactClass} publicInstance The instance that should rerender.
2531 + * @param {object} partialState Next partial state to be merged with state.
2532 + * @param {?function} callback Called after component is updated.
2533 + * @param {?string} Name of the calling function in the public API.
2534 + * @internal
2535 + */
2536 + enqueueSetState: function (publicInstance, partialState, callback, callerName) {
2537 + warnNoop(publicInstance, 'setState');
2538 + }
2539 +};
2540 +
2541 +module.exports = ReactNoopUpdateQueue;
2542 +},{"30":30}],14:[function(_dereq_,module,exports){
2543 +/**
2544 + * Copyright 2013-present, Facebook, Inc.
2545 + * All rights reserved.
2546 + *
2547 + * This source code is licensed under the BSD-style license found in the
2548 + * LICENSE file in the root directory of this source tree. An additional grant
2549 + * of patent rights can be found in the PATENTS file in the same directory.
2550 + *
2551 + *
2552 + */
2553 +
2554 +'use strict';
2555 +
2556 +var ReactPropTypeLocationNames = {};
2557 +
2558 +if ("development" !== 'production') {
2559 + ReactPropTypeLocationNames = {
2560 + prop: 'prop',
2561 + context: 'context',
2562 + childContext: 'child context'
2563 + };
2564 +}
2565 +
2566 +module.exports = ReactPropTypeLocationNames;
2567 +},{}],15:[function(_dereq_,module,exports){
2568 +/**
2569 + * Copyright 2013-present, Facebook, Inc.
2570 + * All rights reserved.
2571 + *
2572 + * This source code is licensed under the BSD-style license found in the
2573 + * LICENSE file in the root directory of this source tree. An additional grant
2574 + * of patent rights can be found in the PATENTS file in the same directory.
2575 + *
2576 + */
2577 +
2578 +'use strict';
2579 +
2580 +var _prodInvariant = _dereq_(25);
2581 +
2582 +var ReactElement = _dereq_(10);
2583 +var ReactPropTypeLocationNames = _dereq_(14);
2584 +
2585 +var emptyFunction = _dereq_(27);
2586 +var getIteratorFn = _dereq_(23);
2587 +var invariant = _dereq_(29);
2588 +var warning = _dereq_(30);
2589 +
2590 +/**
2591 + * Collection of methods that allow declaration and validation of props that are
2592 + * supplied to React components. Example usage:
2593 + *
2594 + * var Props = require('ReactPropTypes');
2595 + * var MyArticle = React.createClass({
2596 + * propTypes: {
2597 + * // An optional string prop named "description".
2598 + * description: Props.string,
2599 + *
2600 + * // A required enum prop named "category".
2601 + * category: Props.oneOf(['News','Photos']).isRequired,
2602 + *
2603 + * // A prop named "dialog" that requires an instance of Dialog.
2604 + * dialog: Props.instanceOf(Dialog).isRequired
2605 + * },
2606 + * render: function() { ... }
2607 + * });
2608 + *
2609 + * A more formal specification of how these methods are used:
2610 + *
2611 + * type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...)
2612 + * decl := ReactPropTypes.{type}(.isRequired)?
2613 + *
2614 + * Each and every declaration produces a function with the same signature. This
2615 + * allows the creation of custom validation functions. For example:
2616 + *
2617 + * var MyLink = React.createClass({
2618 + * propTypes: {
2619 + * // An optional string or URI prop named "href".
2620 + * href: function(props, propName, componentName) {
2621 + * var propValue = props[propName];
2622 + * if (propValue != null && typeof propValue !== 'string' &&
2623 + * !(propValue instanceof URI)) {
2624 + * return new Error(
2625 + * 'Expected a string or an URI for ' + propName + ' in ' +
2626 + * componentName
2627 + * );
2628 + * }
2629 + * }
2630 + * },
2631 + * render: function() {...}
2632 + * });
2633 + *
2634 + * @internal
2635 + */
2636 +
2637 +var ANONYMOUS = '<<anonymous>>';
2638 +
2639 +var ReactPropTypes;
2640 +
2641 +if ("development" !== 'production') {
2642 + // Keep in sync with production version below
2643 + ReactPropTypes = {
2644 + array: createPrimitiveTypeChecker('array'),
2645 + bool: createPrimitiveTypeChecker('boolean'),
2646 + func: createPrimitiveTypeChecker('function'),
2647 + number: createPrimitiveTypeChecker('number'),
2648 + object: createPrimitiveTypeChecker('object'),
2649 + string: createPrimitiveTypeChecker('string'),
2650 + symbol: createPrimitiveTypeChecker('symbol'),
2651 +
2652 + any: createAnyTypeChecker(),
2653 + arrayOf: createArrayOfTypeChecker,
2654 + element: createElementTypeChecker(),
2655 + instanceOf: createInstanceTypeChecker,
2656 + node: createNodeChecker(),
2657 + objectOf: createObjectOfTypeChecker,
2658 + oneOf: createEnumTypeChecker,
2659 + oneOfType: createUnionTypeChecker,
2660 + shape: createShapeTypeChecker
2661 + };
2662 +} else {
2663 + var productionTypeChecker = function () {
2664 + invariant(false, 'React.PropTypes type checking code is stripped in production.');
2665 + };
2666 + productionTypeChecker.isRequired = productionTypeChecker;
2667 + var getProductionTypeChecker = function () {
2668 + return productionTypeChecker;
2669 + };
2670 + // Keep in sync with development version above
2671 + ReactPropTypes = {
2672 + array: productionTypeChecker,
2673 + bool: productionTypeChecker,
2674 + func: productionTypeChecker,
2675 + number: productionTypeChecker,
2676 + object: productionTypeChecker,
2677 + string: productionTypeChecker,
2678 + symbol: productionTypeChecker,
2679 +
2680 + any: productionTypeChecker,
2681 + arrayOf: getProductionTypeChecker,
2682 + element: productionTypeChecker,
2683 + instanceOf: getProductionTypeChecker,
2684 + node: productionTypeChecker,
2685 + objectOf: getProductionTypeChecker,
2686 + oneOf: getProductionTypeChecker,
2687 + oneOfType: getProductionTypeChecker,
2688 + shape: getProductionTypeChecker
2689 + };
2690 +}
2691 +
2692 +/**
2693 + * inlined Object.is polyfill to avoid requiring consumers ship their own
2694 + * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
2695 + */
2696 +/*eslint-disable no-self-compare*/
2697 +function is(x, y) {
2698 + // SameValue algorithm
2699 + if (x === y) {
2700 + // Steps 1-5, 7-10
2701 + // Steps 6.b-6.e: +0 != -0
2702 + return x !== 0 || 1 / x === 1 / y;
2703 + } else {
2704 + // Step 6.a: NaN == NaN
2705 + return x !== x && y !== y;
2706 + }
2707 +}
2708 +/*eslint-enable no-self-compare*/
2709 +
2710 +/**
2711 + * We use an Error-like object for backward compatibility as people may call
2712 + * PropTypes directly and inspect their output. However we don't use real
2713 + * Errors anymore. We don't inspect their stack anyway, and creating them
2714 + * is prohibitively expensive if they are created too often, such as what
2715 + * happens in oneOfType() for any type before the one that matched.
2716 + */
2717 +function PropTypeError(message) {
2718 + this.message = message;
2719 + this.stack = '';
2720 +}
2721 +// Make `instanceof Error` still work for returned errors.
2722 +PropTypeError.prototype = Error.prototype;
2723 +
2724 +function createChainableTypeChecker(validate) {
2725 + function checkType(isRequired, props, propName, componentName, location, propFullName) {
2726 + componentName = componentName || ANONYMOUS;
2727 + propFullName = propFullName || propName;
2728 + if (props[propName] == null) {
2729 + var locationName = ReactPropTypeLocationNames[location];
2730 + if (isRequired) {
2731 + if (props[propName] === null) {
2732 + return new PropTypeError('The ' + locationName + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));
2733 + }
2734 + return new PropTypeError('The ' + locationName + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.'));
2735 + }
2736 + return null;
2737 + } else {
2738 + return validate(props, propName, componentName, location, propFullName);
2739 + }
2740 + }
2741 +
2742 + var chainedCheckType = checkType.bind(null, false);
2743 + chainedCheckType.isRequired = checkType.bind(null, true);
2744 +
2745 + return chainedCheckType;
2746 +}
2747 +
2748 +function createPrimitiveTypeChecker(expectedType) {
2749 + function validate(props, propName, componentName, location, propFullName) {
2750 + var propValue = props[propName];
2751 + var propType = getPropType(propValue);
2752 + if (propType !== expectedType) {
2753 + var locationName = ReactPropTypeLocationNames[location];
2754 + // `propValue` being instance of, say, date/regexp, pass the 'object'
2755 + // check, but we can offer a more precise error message here rather than
2756 + // 'of type `object`'.
2757 + var preciseType = getPreciseType(propValue);
2758 +
2759 + return new PropTypeError('Invalid ' + locationName + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'));
2760 + }
2761 + return null;
2762 + }
2763 + return createChainableTypeChecker(validate);
2764 +}
2765 +
2766 +function createAnyTypeChecker() {
2767 + return createChainableTypeChecker(emptyFunction.thatReturns(null));
2768 +}
2769 +
2770 +function createArrayOfTypeChecker(typeChecker) {
2771 + function validate(props, propName, componentName, location, propFullName) {
2772 + if (typeof typeChecker !== 'function') {
2773 + return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside arrayOf.');
2774 + }
2775 + var propValue = props[propName];
2776 + if (!Array.isArray(propValue)) {
2777 + var locationName = ReactPropTypeLocationNames[location];
2778 + var propType = getPropType(propValue);
2779 + return new PropTypeError('Invalid ' + locationName + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an array.'));
2780 + }
2781 + for (var i = 0; i < propValue.length; i++) {
2782 + var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']');
2783 + if (error instanceof Error) {
2784 + return error;
2785 + }
2786 + }
2787 + return null;
2788 + }
2789 + return createChainableTypeChecker(validate);
2790 +}
2791 +
2792 +function createElementTypeChecker() {
2793 + function validate(props, propName, componentName, location, propFullName) {
2794 + var propValue = props[propName];
2795 + if (!ReactElement.isValidElement(propValue)) {
2796 + var locationName = ReactPropTypeLocationNames[location];
2797 + var propType = getPropType(propValue);
2798 + return new PropTypeError('Invalid ' + locationName + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement.'));
2799 + }
2800 + return null;
2801 + }
2802 + return createChainableTypeChecker(validate);
2803 +}
2804 +
2805 +function createInstanceTypeChecker(expectedClass) {
2806 + function validate(props, propName, componentName, location, propFullName) {
2807 + if (!(props[propName] instanceof expectedClass)) {
2808 + var locationName = ReactPropTypeLocationNames[location];
2809 + var expectedClassName = expectedClass.name || ANONYMOUS;
2810 + var actualClassName = getClassName(props[propName]);
2811 + return new PropTypeError('Invalid ' + locationName + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.'));
2812 + }
2813 + return null;
2814 + }
2815 + return createChainableTypeChecker(validate);
2816 +}
2817 +
2818 +function createEnumTypeChecker(expectedValues) {
2819 + if (!Array.isArray(expectedValues)) {
2820 + "development" !== 'production' ? warning(false, 'Invalid argument supplied to oneOf, expected an instance of array.') : void 0;
2821 + return emptyFunction.thatReturnsNull;
2822 + }
2823 +
2824 + function validate(props, propName, componentName, location, propFullName) {
2825 + var propValue = props[propName];
2826 + for (var i = 0; i < expectedValues.length; i++) {
2827 + if (is(propValue, expectedValues[i])) {
2828 + return null;
2829 + }
2830 + }
2831 +
2832 + var locationName = ReactPropTypeLocationNames[location];
2833 + var valuesString = JSON.stringify(expectedValues);
2834 + return new PropTypeError('Invalid ' + locationName + ' `' + propFullName + '` of value `' + propValue + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));
2835 + }
2836 + return createChainableTypeChecker(validate);
2837 +}
2838 +
2839 +function createObjectOfTypeChecker(typeChecker) {
2840 + function validate(props, propName, componentName, location, propFullName) {
2841 + if (typeof typeChecker !== 'function') {
2842 + return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.');
2843 + }
2844 + var propValue = props[propName];
2845 + var propType = getPropType(propValue);
2846 + if (propType !== 'object') {
2847 + var locationName = ReactPropTypeLocationNames[location];
2848 + return new PropTypeError('Invalid ' + locationName + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.'));
2849 + }
2850 + for (var key in propValue) {
2851 + if (propValue.hasOwnProperty(key)) {
2852 + var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key);
2853 + if (error instanceof Error) {
2854 + return error;
2855 + }
2856 + }
2857 + }
2858 + return null;
2859 + }
2860 + return createChainableTypeChecker(validate);
2861 +}
2862 +
2863 +function createUnionTypeChecker(arrayOfTypeCheckers) {
2864 + if (!Array.isArray(arrayOfTypeCheckers)) {
2865 + "development" !== 'production' ? warning(false, 'Invalid argument supplied to oneOfType, expected an instance of array.') : void 0;
2866 + return emptyFunction.thatReturnsNull;
2867 + }
2868 +
2869 + function validate(props, propName, componentName, location, propFullName) {
2870 + for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
2871 + var checker = arrayOfTypeCheckers[i];
2872 + if (checker(props, propName, componentName, location, propFullName) == null) {
2873 + return null;
2874 + }
2875 + }
2876 +
2877 + var locationName = ReactPropTypeLocationNames[location];
2878 + return new PropTypeError('Invalid ' + locationName + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`.'));
2879 + }
2880 + return createChainableTypeChecker(validate);
2881 +}
2882 +
2883 +function createNodeChecker() {
2884 + function validate(props, propName, componentName, location, propFullName) {
2885 + if (!isNode(props[propName])) {
2886 + var locationName = ReactPropTypeLocationNames[location];
2887 + return new PropTypeError('Invalid ' + locationName + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.'));
2888 + }
2889 + return null;
2890 + }
2891 + return createChainableTypeChecker(validate);
2892 +}
2893 +
2894 +function createShapeTypeChecker(shapeTypes) {
2895 + function validate(props, propName, componentName, location, propFullName) {
2896 + var propValue = props[propName];
2897 + var propType = getPropType(propValue);
2898 + if (propType !== 'object') {
2899 + var locationName = ReactPropTypeLocationNames[location];
2900 + return new PropTypeError('Invalid ' + locationName + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
2901 + }
2902 + for (var key in shapeTypes) {
2903 + var checker = shapeTypes[key];
2904 + if (!checker) {
2905 + continue;
2906 + }
2907 + var error = checker(propValue, key, componentName, location, propFullName + '.' + key);
2908 + if (error) {
2909 + return error;
2910 + }
2911 + }
2912 + return null;
2913 + }
2914 + return createChainableTypeChecker(validate);
2915 +}
2916 +
2917 +function isNode(propValue) {
2918 + switch (typeof propValue) {
2919 + case 'number':
2920 + case 'string':
2921 + case 'undefined':
2922 + return true;
2923 + case 'boolean':
2924 + return !propValue;
2925 + case 'object':
2926 + if (Array.isArray(propValue)) {
2927 + return propValue.every(isNode);
2928 + }
2929 + if (propValue === null || ReactElement.isValidElement(propValue)) {
2930 + return true;
2931 + }
2932 +
2933 + var iteratorFn = getIteratorFn(propValue);
2934 + if (iteratorFn) {
2935 + var iterator = iteratorFn.call(propValue);
2936 + var step;
2937 + if (iteratorFn !== propValue.entries) {
2938 + while (!(step = iterator.next()).done) {
2939 + if (!isNode(step.value)) {
2940 + return false;
2941 + }
2942 + }
2943 + } else {
2944 + // Iterator will provide entry [k,v] tuples rather than values.
2945 + while (!(step = iterator.next()).done) {
2946 + var entry = step.value;
2947 + if (entry) {
2948 + if (!isNode(entry[1])) {
2949 + return false;
2950 + }
2951 + }
2952 + }
2953 + }
2954 + } else {
2955 + return false;
2956 + }
2957 +
2958 + return true;
2959 + default:
2960 + return false;
2961 + }
2962 +}
2963 +
2964 +function isSymbol(propType, propValue) {
2965 + // Native Symbol.
2966 + if (propType === 'symbol') {
2967 + return true;
2968 + }
2969 +
2970 + // 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'
2971 + if (propValue['@@toStringTag'] === 'Symbol') {
2972 + return true;
2973 + }
2974 +
2975 + // Fallback for non-spec compliant Symbols which are polyfilled.
2976 + if (typeof Symbol === 'function' && propValue instanceof Symbol) {
2977 + return true;
2978 + }
2979 +
2980 + return false;
2981 +}
2982 +
2983 +// Equivalent of `typeof` but with special handling for array and regexp.
2984 +function getPropType(propValue) {
2985 + var propType = typeof propValue;
2986 + if (Array.isArray(propValue)) {
2987 + return 'array';
2988 + }
2989 + if (propValue instanceof RegExp) {
2990 + // Old webkits (at least until Android 4.0) return 'function' rather than
2991 + // 'object' for typeof a RegExp. We'll normalize this here so that /bla/
2992 + // passes PropTypes.object.
2993 + return 'object';
2994 + }
2995 + if (isSymbol(propType, propValue)) {
2996 + return 'symbol';
2997 + }
2998 + return propType;
2999 +}
3000 +
3001 +// This handles more types than `getPropType`. Only used for error messages.
3002 +// See `createPrimitiveTypeChecker`.
3003 +function getPreciseType(propValue) {
3004 + var propType = getPropType(propValue);
3005 + if (propType === 'object') {
3006 + if (propValue instanceof Date) {
3007 + return 'date';
3008 + } else if (propValue instanceof RegExp) {
3009 + return 'regexp';
3010 + }
3011 + }
3012 + return propType;
3013 +}
3014 +
3015 +// Returns class name of the object, if any.
3016 +function getClassName(propValue) {
3017 + if (!propValue.constructor || !propValue.constructor.name) {
3018 + return ANONYMOUS;
3019 + }
3020 + return propValue.constructor.name;
3021 +}
3022 +
3023 +module.exports = ReactPropTypes;
3024 +},{"10":10,"14":14,"23":23,"25":25,"27":27,"29":29,"30":30}],16:[function(_dereq_,module,exports){
3025 +/**
3026 + * Copyright 2013-present, Facebook, Inc.
3027 + * All rights reserved.
3028 + *
3029 + * This source code is licensed under the BSD-style license found in the
3030 + * LICENSE file in the root directory of this source tree. An additional grant
3031 + * of patent rights can be found in the PATENTS file in the same directory.
3032 + *
3033 + */
3034 +
3035 +'use strict';
3036 +
3037 +var _assign = _dereq_(31);
3038 +
3039 +var ReactComponent = _dereq_(6);
3040 +var ReactNoopUpdateQueue = _dereq_(13);
3041 +
3042 +var emptyObject = _dereq_(28);
3043 +
3044 +/**
3045 + * Base class helpers for the updating state of a component.
3046 + */
3047 +function ReactPureComponent(props, context, updater) {
3048 + // Duplicated from ReactComponent.
3049 + this.props = props;
3050 + this.context = context;
3051 + this.refs = emptyObject;
3052 + // We initialize the default updater but the real one gets injected by the
3053 + // renderer.
3054 + this.updater = updater || ReactNoopUpdateQueue;
3055 +}
3056 +
3057 +function ComponentDummy() {}
3058 +ComponentDummy.prototype = ReactComponent.prototype;
3059 +ReactPureComponent.prototype = new ComponentDummy();
3060 +ReactPureComponent.prototype.constructor = ReactPureComponent;
3061 +// Avoid an extra prototype jump for these methods.
3062 +_assign(ReactPureComponent.prototype, ReactComponent.prototype);
3063 +ReactPureComponent.prototype.isPureReactComponent = true;
3064 +
3065 +module.exports = ReactPureComponent;
3066 +},{"13":13,"28":28,"31":31,"6":6}],17:[function(_dereq_,module,exports){
3067 +/**
3068 + * Copyright 2013-present, Facebook, Inc.
3069 + * All rights reserved.
3070 + *
3071 + * This source code is licensed under the BSD-style license found in the
3072 + * LICENSE file in the root directory of this source tree. An additional grant
3073 + * of patent rights can be found in the PATENTS file in the same directory.
3074 + *
3075 + *
3076 + */
3077 +
3078 +'use strict';
3079 +
3080 +module.exports = {
3081 + IndeterminateComponent: 0, // Before we know whether it is functional or class
3082 + FunctionalComponent: 1,
3083 + ClassComponent: 2,
3084 + HostRoot: 3, // Root of a host tree. Could be nested inside another node.
3085 + HostPortal: 4, // A subtree. Could be an entry point to a different renderer.
3086 + HostComponent: 5,
3087 + HostText: 6,
3088 + CoroutineComponent: 7,
3089 + CoroutineHandlerPhase: 8,
3090 + YieldComponent: 9,
3091 + Fragment: 10
3092 +};
3093 +},{}],18:[function(_dereq_,module,exports){
3094 +/**
3095 + * Copyright 2013-present, Facebook, Inc.
3096 + * All rights reserved.
3097 + *
3098 + * This source code is licensed under the BSD-style license found in the
3099 + * LICENSE file in the root directory of this source tree. An additional grant
3100 + * of patent rights can be found in the PATENTS file in the same directory.
3101 + *
3102 + */
3103 +
3104 +'use strict';
3105 +
3106 +var _assign = _dereq_(31);
3107 +
3108 +var React = _dereq_(3);
3109 +
3110 +// `version` will be added here by the React module.
3111 +var ReactUMDEntry = _assign({
3112 + __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: {
3113 + ReactCurrentOwner: _dereq_(8)
3114 + }
3115 +}, React);
3116 +
3117 +if ("development" !== 'production') {
3118 + _assign(ReactUMDEntry.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED, {
3119 + // ReactComponentTreeHook should not be included in production.
3120 + ReactComponentTreeHook: _dereq_(7)
3121 + });
3122 +}
3123 +
3124 +module.exports = ReactUMDEntry;
3125 +},{"3":3,"31":31,"7":7,"8":8}],19:[function(_dereq_,module,exports){
3126 +/**
3127 + * Copyright 2013-present, Facebook, Inc.
3128 + * All rights reserved.
3129 + *
3130 + * This source code is licensed under the BSD-style license found in the
3131 + * LICENSE file in the root directory of this source tree. An additional grant
3132 + * of patent rights can be found in the PATENTS file in the same directory.
3133 + *
3134 + */
3135 +
3136 +'use strict';
3137 +
3138 +module.exports = '16.0.0-alpha';
3139 +},{}],20:[function(_dereq_,module,exports){
3140 +/**
3141 + * Copyright 2013-present, Facebook, Inc.
3142 + * All rights reserved.
3143 + *
3144 + * This source code is licensed under the BSD-style license found in the
3145 + * LICENSE file in the root directory of this source tree. An additional grant
3146 + * of patent rights can be found in the PATENTS file in the same directory.
3147 + *
3148 + *
3149 + */
3150 +
3151 +'use strict';
3152 +
3153 +var canDefineProperty = false;
3154 +if ("development" !== 'production') {
3155 + try {
3156 + // $FlowFixMe https://github.com/facebook/flow/issues/285
3157 + Object.defineProperty({}, 'x', { get: function () {} });
3158 + canDefineProperty = true;
3159 + } catch (x) {
3160 + // IE will fail on defineProperty
3161 + }
3162 +}
3163 +
3164 +module.exports = canDefineProperty;
3165 +},{}],21:[function(_dereq_,module,exports){
3166 +(function (process){
3167 +/**
3168 + * Copyright 2013-present, Facebook, Inc.
3169 + * All rights reserved.
3170 + *
3171 + * This source code is licensed under the BSD-style license found in the
3172 + * LICENSE file in the root directory of this source tree. An additional grant
3173 + * of patent rights can be found in the PATENTS file in the same directory.
3174 + *
3175 + */
3176 +
3177 +'use strict';
3178 +
3179 +var _prodInvariant = _dereq_(25);
3180 +
3181 +var ReactPropTypeLocationNames = _dereq_(14);
3182 +
3183 +var invariant = _dereq_(29);
3184 +var warning = _dereq_(30);
3185 +
3186 +var ReactComponentTreeHook;
3187 +
3188 +if (typeof process !== 'undefined' && process.env && "development" === 'test') {
3189 + // Temporary hack.
3190 + // Inline requires don't work well with Jest:
3191 + // https://github.com/facebook/react/issues/7240
3192 + // Remove the inline requires when we don't need them anymore:
3193 + // https://github.com/facebook/react/pull/7178
3194 + ReactComponentTreeHook = _dereq_(7);
3195 +}
3196 +
3197 +var loggedTypeFailures = {};
3198 +
3199 +/**
3200 + * Assert that the values match with the type specs.
3201 + * Error messages are memorized and will only be shown once.
3202 + *
3203 + * @param {object} typeSpecs Map of name to a ReactPropType
3204 + * @param {object} values Runtime values that need to be type-checked
3205 + * @param {string} location e.g. "prop", "context", "child context"
3206 + * @param {string} componentName Name of the component for error messages.
3207 + * @param {?object} element The React element that is being type-checked
3208 + * @param {?number} workInProgressOrDebugID The React component instance that is being type-checked
3209 + * @private
3210 + */
3211 +function checkReactTypeSpec(typeSpecs, values, location, componentName, element,
3212 +// It is only safe to pass fiber if it is the work-in-progress version, and
3213 +workInProgressOrDebugID) {
3214 + for (var typeSpecName in typeSpecs) {
3215 + if (typeSpecs.hasOwnProperty(typeSpecName)) {
3216 + var error;
3217 + // Prop type validation may throw. In case they do, we don't want to
3218 + // fail the render phase where it didn't fail before. So we log it.
3219 + // After these have been cleaned up, we'll let them throw.
3220 + try {
3221 + // This is intentionally an invariant that gets caught. It's the same
3222 + // behavior as without this statement except with a better message.
3223 + !(typeof typeSpecs[typeSpecName] === 'function') ? "development" !== 'production' ? invariant(false, '%s: %s type `%s` is invalid; it must be a function, usually from React.PropTypes.', componentName || 'React class', ReactPropTypeLocationNames[location], typeSpecName) : _prodInvariant('84', componentName || 'React class', ReactPropTypeLocationNames[location], typeSpecName) : void 0;
3224 + error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location);
3225 + } catch (ex) {
3226 + error = ex;
3227 + }
3228 + "development" !== 'production' ? warning(!error || error instanceof Error, '%s: type specification of %s `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', ReactPropTypeLocationNames[location], typeSpecName, typeof error) : void 0;
3229 + if (error instanceof Error && !(error.message in loggedTypeFailures)) {
3230 + // Only monitor this failure once because there tends to be a lot of the
3231 + // same error.
3232 + loggedTypeFailures[error.message] = true;
3233 +
3234 + var componentStackInfo = '';
3235 +
3236 + if ("development" !== 'production') {
3237 + if (!ReactComponentTreeHook) {
3238 + ReactComponentTreeHook = _dereq_(7);
3239 + }
3240 + if (workInProgressOrDebugID != null) {
3241 + if (typeof workInProgressOrDebugID === 'number') {
3242 + // DebugID from Stack.
3243 + var debugID = workInProgressOrDebugID;
3244 + componentStackInfo = ReactComponentTreeHook.getStackAddendumByID(debugID);
3245 + } else if (typeof workInProgressOrDebugID.tag === 'number') {
3246 + // This is a Fiber.
3247 + // The stack will only be correct if this is a work in progress
3248 + // version and we're calling it during reconciliation.
3249 + var workInProgress = workInProgressOrDebugID;
3250 + componentStackInfo = ReactComponentTreeHook.getStackAddendumByWorkInProgressFiber(workInProgress);
3251 + }
3252 + } else if (element !== null) {
3253 + componentStackInfo = ReactComponentTreeHook.getCurrentStackAddendum(element);
3254 + }
3255 + }
3256 +
3257 + "development" !== 'production' ? warning(false, 'Failed %s type: %s%s', location, error.message, componentStackInfo) : void 0;
3258 + }
3259 + }
3260 + }
3261 +}
3262 +
3263 +module.exports = checkReactTypeSpec;
3264 +}).call(this,undefined)
3265 +},{"14":14,"25":25,"29":29,"30":30,"7":7}],22:[function(_dereq_,module,exports){
3266 +/**
3267 + * Copyright 2013-present, Facebook, Inc.
3268 + * All rights reserved.
3269 + *
3270 + * This source code is licensed under the BSD-style license found in the
3271 + * LICENSE file in the root directory of this source tree. An additional grant
3272 + * of patent rights can be found in the PATENTS file in the same directory.
3273 + *
3274 + *
3275 + */
3276 +
3277 +'use strict';
3278 +
3279 +function getComponentName(instanceOrFiber) {
3280 + if ("development" !== 'production') {
3281 + if (typeof instanceOrFiber.getName === 'function') {
3282 + // Stack reconciler
3283 + var instance = instanceOrFiber;
3284 + return instance.getName() || 'Component';
3285 + }
3286 + if (typeof instanceOrFiber.tag === 'number') {
3287 + // Fiber reconciler
3288 + var fiber = instanceOrFiber;
3289 + var type = fiber.type;
3290 +
3291 + if (typeof type === 'string') {
3292 + return type;
3293 + }
3294 + if (typeof type === 'function') {
3295 + return type.displayName || type.name || null;
3296 + }
3297 + }
3298 + }
3299 + return null;
3300 +}
3301 +
3302 +module.exports = getComponentName;
3303 +},{}],23:[function(_dereq_,module,exports){
3304 +/**
3305 + * Copyright 2013-present, Facebook, Inc.
3306 + * All rights reserved.
3307 + *
3308 + * This source code is licensed under the BSD-style license found in the
3309 + * LICENSE file in the root directory of this source tree. An additional grant
3310 + * of patent rights can be found in the PATENTS file in the same directory.
3311 + *
3312 + *
3313 + */
3314 +
3315 +'use strict';
3316 +
3317 +/* global Symbol */
3318 +
3319 +var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
3320 +var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.
3321 +
3322 +/**
3323 + * Returns the iterator method function contained on the iterable object.
3324 + *
3325 + * Be sure to invoke the function with the iterable as context:
3326 + *
3327 + * var iteratorFn = getIteratorFn(myIterable);
3328 + * if (iteratorFn) {
3329 + * var iterator = iteratorFn.call(myIterable);
3330 + * ...
3331 + * }
3332 + *
3333 + * @param {?object} maybeIterable
3334 + * @return {?function}
3335 + */
3336 +function getIteratorFn(maybeIterable) {
3337 + var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);
3338 + if (typeof iteratorFn === 'function') {
3339 + return iteratorFn;
3340 + }
3341 +}
3342 +
3343 +module.exports = getIteratorFn;
3344 +},{}],24:[function(_dereq_,module,exports){
3345 +/**
3346 + * Copyright 2013-present, Facebook, Inc.
3347 + * All rights reserved.
3348 + *
3349 + * This source code is licensed under the BSD-style license found in the
3350 + * LICENSE file in the root directory of this source tree. An additional grant
3351 + * of patent rights can be found in the PATENTS file in the same directory.
3352 + *
3353 + */
3354 +'use strict';
3355 +
3356 +var _prodInvariant = _dereq_(25);
3357 +
3358 +var ReactElement = _dereq_(10);
3359 +
3360 +var invariant = _dereq_(29);
3361 +
3362 +/**
3363 + * Returns the first child in a collection of children and verifies that there
3364 + * is only one child in the collection.
3365 + *
3366 + * See https://facebook.github.io/react/docs/react-api.html#react.children.only
3367 + *
3368 + * The current implementation of this function assumes that a single child gets
3369 + * passed without a wrapper, but the purpose of this helper function is to
3370 + * abstract away the particular structure of children.
3371 + *
3372 + * @param {?object} children Child collection structure.
3373 + * @return {ReactElement} The first and only `ReactElement` contained in the
3374 + * structure.
3375 + */
3376 +function onlyChild(children) {
3377 + !ReactElement.isValidElement(children) ? "development" !== 'production' ? invariant(false, 'React.Children.only expected to receive a single React element child.') : _prodInvariant('143') : void 0;
3378 + return children;
3379 +}
3380 +
3381 +module.exports = onlyChild;
3382 +},{"10":10,"25":25,"29":29}],25:[function(_dereq_,module,exports){
3383 +/**
3384 + * Copyright (c) 2013-present, Facebook, Inc.
3385 + * All rights reserved.
3386 + *
3387 + * This source code is licensed under the BSD-style license found in the
3388 + * LICENSE file in the root directory of this source tree. An additional grant
3389 + * of patent rights can be found in the PATENTS file in the same directory.
3390 + *
3391 + *
3392 + */
3393 +'use strict';
3394 +
3395 +/**
3396 + * WARNING: DO NOT manually require this module.
3397 + * This is a replacement for `invariant(...)` used by the error code system
3398 + * and will _only_ be required by the corresponding babel pass.
3399 + * It always throws.
3400 + */
3401 +
3402 +function reactProdInvariant(code) {
3403 + var argCount = arguments.length - 1;
3404 +
3405 + var message = 'Minified React error #' + code + '; visit ' + 'http://facebook.github.io/react/docs/error-decoder.html?invariant=' + code;
3406 +
3407 + for (var argIdx = 0; argIdx < argCount; argIdx++) {
3408 + message += '&args[]=' + encodeURIComponent(arguments[argIdx + 1]);
3409 + }
3410 +
3411 + message += ' for the full message or use the non-minified dev environment' + ' for full errors and additional helpful warnings.';
3412 +
3413 + var error = new Error(message);
3414 + error.name = 'Invariant Violation';
3415 + error.framesToPop = 1; // we don't care about reactProdInvariant's own frame
3416 +
3417 + throw error;
3418 +}
3419 +
3420 +module.exports = reactProdInvariant;
3421 +},{}],26:[function(_dereq_,module,exports){
3422 +/**
3423 + * Copyright 2013-present, Facebook, Inc.
3424 + * All rights reserved.
3425 + *
3426 + * This source code is licensed under the BSD-style license found in the
3427 + * LICENSE file in the root directory of this source tree. An additional grant
3428 + * of patent rights can be found in the PATENTS file in the same directory.
3429 + *
3430 + */
3431 +
3432 +'use strict';
3433 +
3434 +var _prodInvariant = _dereq_(25);
3435 +
3436 +var ReactCurrentOwner = _dereq_(8);
3437 +var REACT_ELEMENT_TYPE = _dereq_(11);
3438 +
3439 +var getIteratorFn = _dereq_(23);
3440 +var invariant = _dereq_(29);
3441 +var KeyEscapeUtils = _dereq_(1);
3442 +var warning = _dereq_(30);
3443 +
3444 +var SEPARATOR = '.';
3445 +var SUBSEPARATOR = ':';
3446 +
3447 +/**
3448 + * This is inlined from ReactElement since this file is shared between
3449 + * isomorphic and renderers. We could extract this to a
3450 + *
3451 + */
3452 +
3453 +/**
3454 + * TODO: Test that a single child and an array with one item have the same key
3455 + * pattern.
3456 + */
3457 +
3458 +var didWarnAboutMaps = false;
3459 +
3460 +/**
3461 + * Generate a key string that identifies a component within a set.
3462 + *
3463 + * @param {*} component A component that could contain a manual key.
3464 + * @param {number} index Index that is used if a manual key is not provided.
3465 + * @return {string}
3466 + */
3467 +function getComponentKey(component, index) {
3468 + // Do some typechecking here since we call this blindly. We want to ensure
3469 + // that we don't block potential future ES APIs.
3470 + if (component && typeof component === 'object' && component.key != null) {
3471 + // Explicit key
3472 + return KeyEscapeUtils.escape(component.key);
3473 + }
3474 + // Implicit key determined by the index in the set
3475 + return index.toString(36);
3476 +}
3477 +
3478 +/**
3479 + * @param {?*} children Children tree container.
3480 + * @param {!string} nameSoFar Name of the key path so far.
3481 + * @param {!function} callback Callback to invoke with each child found.
3482 + * @param {?*} traverseContext Used to pass information throughout the traversal
3483 + * process.
3484 + * @return {!number} The number of children in this subtree.
3485 + */
3486 +function traverseAllChildrenImpl(children, nameSoFar, callback, traverseContext) {
3487 + var type = typeof children;
3488 +
3489 + if (type === 'undefined' || type === 'boolean') {
3490 + // All of the above are perceived as null.
3491 + children = null;
3492 + }
3493 +
3494 + if (children === null || type === 'string' || type === 'number' ||
3495 + // The following is inlined from ReactElement. This means we can optimize
3496 + // some checks. React Fiber also inlines this logic for similar purposes.
3497 + type === 'object' && children.$$typeof === REACT_ELEMENT_TYPE) {
3498 + callback(traverseContext, children,
3499 + // If it's the only child, treat the name as if it was wrapped in an array
3500 + // so that it's consistent if the number of children grows.
3501 + nameSoFar === '' ? SEPARATOR + getComponentKey(children, 0) : nameSoFar);
3502 + return 1;
3503 + }
3504 +
3505 + var child;
3506 + var nextName;
3507 + var subtreeCount = 0; // Count of children found in the current subtree.
3508 + var nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR;
3509 +
3510 + if (Array.isArray(children)) {
3511 + for (var i = 0; i < children.length; i++) {
3512 + child = children[i];
3513 + nextName = nextNamePrefix + getComponentKey(child, i);
3514 + subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);
3515 + }
3516 + } else {
3517 + var iteratorFn = getIteratorFn(children);
3518 + if (iteratorFn) {
3519 + var iterator = iteratorFn.call(children);
3520 + var step;
3521 + if (iteratorFn !== children.entries) {
3522 + var ii = 0;
3523 + while (!(step = iterator.next()).done) {
3524 + child = step.value;
3525 + nextName = nextNamePrefix + getComponentKey(child, ii++);
3526 + subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);
3527 + }
3528 + } else {
3529 + if ("development" !== 'production') {
3530 + var mapsAsChildrenAddendum = '';
3531 + if (ReactCurrentOwner.current) {
3532 + var mapsAsChildrenOwnerName = ReactCurrentOwner.current.getName();
3533 + if (mapsAsChildrenOwnerName) {
3534 + mapsAsChildrenAddendum = ' Check the render method of `' + mapsAsChildrenOwnerName + '`.';
3535 + }
3536 + }
3537 + "development" !== 'production' ? warning(didWarnAboutMaps, 'Using Maps as children is not yet fully supported. It is an ' + 'experimental feature that might be removed. Convert it to a ' + 'sequence / iterable of keyed ReactElements instead.%s', mapsAsChildrenAddendum) : void 0;
3538 + didWarnAboutMaps = true;
3539 + }
3540 + // Iterator will provide entry [k,v] tuples rather than values.
3541 + while (!(step = iterator.next()).done) {
3542 + var entry = step.value;
3543 + if (entry) {
3544 + child = entry[1];
3545 + nextName = nextNamePrefix + KeyEscapeUtils.escape(entry[0]) + SUBSEPARATOR + getComponentKey(child, 0);
3546 + subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);
3547 + }
3548 + }
3549 + }
3550 + } else if (type === 'object') {
3551 + var addendum = '';
3552 + if ("development" !== 'production') {
3553 + addendum = ' If you meant to render a collection of children, use an array ' + 'instead or wrap the object using createFragment(object) from the ' + 'React add-ons.';
3554 + if (children._isReactElement) {
3555 + addendum = ' It looks like you\'re using an element created by a different ' + 'version of React. Make sure to use only one copy of React.';
3556 + }
3557 + if (ReactCurrentOwner.current) {
3558 + var name = ReactCurrentOwner.current.getName();
3559 + if (name) {
3560 + addendum += ' Check the render method of `' + name + '`.';
3561 + }
3562 + }
3563 + }
3564 + var childrenString = String(children);
3565 + !false ? "development" !== 'production' ? invariant(false, 'Objects are not valid as a React child (found: %s).%s', childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString, addendum) : _prodInvariant('31', childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString, addendum) : void 0;
3566 + }
3567 + }
3568 +
3569 + return subtreeCount;
3570 +}
3571 +
3572 +/**
3573 + * Traverses children that are typically specified as `props.children`, but
3574 + * might also be specified through attributes:
3575 + *
3576 + * - `traverseAllChildren(this.props.children, ...)`
3577 + * - `traverseAllChildren(this.props.leftPanelChildren, ...)`
3578 + *
3579 + * The `traverseContext` is an optional argument that is passed through the
3580 + * entire traversal. It can be used to store accumulations or anything else that
3581 + * the callback might find relevant.
3582 + *
3583 + * @param {?*} children Children tree object.
3584 + * @param {!function} callback To invoke upon traversing each child.
3585 + * @param {?*} traverseContext Context for traversal.
3586 + * @return {!number} The number of children in this subtree.
3587 + */
3588 +function traverseAllChildren(children, callback, traverseContext) {
3589 + if (children == null) {
3590 + return 0;
3591 + }
3592 +
3593 + return traverseAllChildrenImpl(children, '', callback, traverseContext);
3594 +}
3595 +
3596 +module.exports = traverseAllChildren;
3597 +},{"1":1,"11":11,"23":23,"25":25,"29":29,"30":30,"8":8}],27:[function(_dereq_,module,exports){
3598 +"use strict";
3599 +
3600 +/**
3601 + * Copyright (c) 2013-present, Facebook, Inc.
3602 + * All rights reserved.
3603 + *
3604 + * This source code is licensed under the BSD-style license found in the
3605 + * LICENSE file in the root directory of this source tree. An additional grant
3606 + * of patent rights can be found in the PATENTS file in the same directory.
3607 + *
3608 + *
3609 + */
3610 +
3611 +function makeEmptyFunction(arg) {
3612 + return function () {
3613 + return arg;
3614 + };
3615 +}
3616 +
3617 +/**
3618 + * This function accepts and discards inputs; it has no side effects. This is
3619 + * primarily useful idiomatically for overridable function endpoints which
3620 + * always need to be callable, since JS lacks a null-call idiom ala Cocoa.
3621 + */
3622 +var emptyFunction = function emptyFunction() {};
3623 +
3624 +emptyFunction.thatReturns = makeEmptyFunction;
3625 +emptyFunction.thatReturnsFalse = makeEmptyFunction(false);
3626 +emptyFunction.thatReturnsTrue = makeEmptyFunction(true);
3627 +emptyFunction.thatReturnsNull = makeEmptyFunction(null);
3628 +emptyFunction.thatReturnsThis = function () {
3629 + return this;
3630 +};
3631 +emptyFunction.thatReturnsArgument = function (arg) {
3632 + return arg;
3633 +};
3634 +
3635 +module.exports = emptyFunction;
3636 +},{}],28:[function(_dereq_,module,exports){
3637 +/**
3638 + * Copyright (c) 2013-present, Facebook, Inc.
3639 + * All rights reserved.
3640 + *
3641 + * This source code is licensed under the BSD-style license found in the
3642 + * LICENSE file in the root directory of this source tree. An additional grant
3643 + * of patent rights can be found in the PATENTS file in the same directory.
3644 + *
3645 + */
3646 +
3647 +'use strict';
3648 +
3649 +var emptyObject = {};
3650 +
3651 +if ("development" !== 'production') {
3652 + Object.freeze(emptyObject);
3653 +}
3654 +
3655 +module.exports = emptyObject;
3656 +},{}],29:[function(_dereq_,module,exports){
3657 +/**
3658 + * Copyright (c) 2013-present, Facebook, Inc.
3659 + * All rights reserved.
3660 + *
3661 + * This source code is licensed under the BSD-style license found in the
3662 + * LICENSE file in the root directory of this source tree. An additional grant
3663 + * of patent rights can be found in the PATENTS file in the same directory.
3664 + *
3665 + */
3666 +
3667 +'use strict';
3668 +
3669 +/**
3670 + * Use invariant() to assert state which your program assumes to be true.
3671 + *
3672 + * Provide sprintf-style format (only %s is supported) and arguments
3673 + * to provide information about what broke and what you were
3674 + * expecting.
3675 + *
3676 + * The invariant message will be stripped in production, but the invariant
3677 + * will remain to ensure logic does not differ in production.
3678 + */
3679 +
3680 +function invariant(condition, format, a, b, c, d, e, f) {
3681 + if ("development" !== 'production') {
3682 + if (format === undefined) {
3683 + throw new Error('invariant requires an error message argument');
3684 + }
3685 + }
3686 +
3687 + if (!condition) {
3688 + var error;
3689 + if (format === undefined) {
3690 + error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');
3691 + } else {
3692 + var args = [a, b, c, d, e, f];
3693 + var argIndex = 0;
3694 + error = new Error(format.replace(/%s/g, function () {
3695 + return args[argIndex++];
3696 + }));
3697 + error.name = 'Invariant Violation';
3698 + }
3699 +
3700 + error.framesToPop = 1; // we don't care about invariant's own frame
3701 + throw error;
3702 + }
3703 +}
3704 +
3705 +module.exports = invariant;
3706 +},{}],30:[function(_dereq_,module,exports){
3707 +/**
3708 + * Copyright 2014-2015, Facebook, Inc.
3709 + * All rights reserved.
3710 + *
3711 + * This source code is licensed under the BSD-style license found in the
3712 + * LICENSE file in the root directory of this source tree. An additional grant
3713 + * of patent rights can be found in the PATENTS file in the same directory.
3714 + *
3715 + */
3716 +
3717 +'use strict';
3718 +
3719 +var emptyFunction = _dereq_(27);
3720 +
3721 +/**
3722 + * Similar to invariant but only logs a warning if the condition is not met.
3723 + * This can be used to log issues in development environments in critical
3724 + * paths. Removing the logging code for production environments will keep the
3725 + * same logic and follow the same code paths.
3726 + */
3727 +
3728 +var warning = emptyFunction;
3729 +
3730 +if ("development" !== 'production') {
3731 + (function () {
3732 + var printWarning = function printWarning(format) {
3733 + for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
3734 + args[_key - 1] = arguments[_key];
3735 + }
3736 +
3737 + var argIndex = 0;
3738 + var message = 'Warning: ' + format.replace(/%s/g, function () {
3739 + return args[argIndex++];
3740 + });
3741 + if (typeof console !== 'undefined') {
3742 + console.error(message);
3743 + }
3744 + try {
3745 + // --- Welcome to debugging React ---
3746 + // This error was thrown as a convenience so that you can use this stack
3747 + // to find the callsite that caused this warning to fire.
3748 + throw new Error(message);
3749 + } catch (x) {}
3750 + };
3751 +
3752 + warning = function warning(condition, format) {
3753 + if (format === undefined) {
3754 + throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument');
3755 + }
3756 +
3757 + if (format.indexOf('Failed Composite propType: ') === 0) {
3758 + return; // Ignore CompositeComponent proptype check.
3759 + }
3760 +
3761 + if (!condition) {
3762 + for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
3763 + args[_key2 - 2] = arguments[_key2];
3764 + }
3765 +
3766 + printWarning.apply(undefined, [format].concat(args));
3767 + }
3768 + };
3769 + })();
3770 +}
3771 +
3772 +module.exports = warning;
3773 +},{"27":27}],31:[function(_dereq_,module,exports){
3774 +'use strict';
3775 +/* eslint-disable no-unused-vars */
3776 +var hasOwnProperty = Object.prototype.hasOwnProperty;
3777 +var propIsEnumerable = Object.prototype.propertyIsEnumerable;
3778 +
3779 +function toObject(val) {
3780 + if (val === null || val === undefined) {
3781 + throw new TypeError('Object.assign cannot be called with null or undefined');
3782 + }
3783 +
3784 + return Object(val);
3785 +}
3786 +
3787 +function shouldUseNative() {
3788 + try {
3789 + if (!Object.assign) {
3790 + return false;
3791 + }
3792 +
3793 + // Detect buggy property enumeration order in older V8 versions.
3794 +
3795 + // https://bugs.chromium.org/p/v8/issues/detail?id=4118
3796 + var test1 = new String('abc'); // eslint-disable-line
3797 + test1[5] = 'de';
3798 + if (Object.getOwnPropertyNames(test1)[0] === '5') {
3799 + return false;
3800 + }
3801 +
3802 + // https://bugs.chromium.org/p/v8/issues/detail?id=3056
3803 + var test2 = {};
3804 + for (var i = 0; i < 10; i++) {
3805 + test2['_' + String.fromCharCode(i)] = i;
3806 + }
3807 + var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
3808 + return test2[n];
3809 + });
3810 + if (order2.join('') !== '0123456789') {
3811 + return false;
3812 + }
3813 +
3814 + // https://bugs.chromium.org/p/v8/issues/detail?id=3056
3815 + var test3 = {};
3816 + 'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
3817 + test3[letter] = letter;
3818 + });
3819 + if (Object.keys(Object.assign({}, test3)).join('') !==
3820 + 'abcdefghijklmnopqrst') {
3821 + return false;
3822 + }
3823 +
3824 + return true;
3825 + } catch (e) {
3826 + // We don't expect any of the above to throw, but better to be safe.
3827 + return false;
3828 + }
3829 +}
3830 +
3831 +module.exports = shouldUseNative() ? Object.assign : function (target, source) {
3832 + var from;
3833 + var to = toObject(target);
3834 + var symbols;
3835 +
3836 + for (var s = 1; s < arguments.length; s++) {
3837 + from = Object(arguments[s]);
3838 +
3839 + for (var key in from) {
3840 + if (hasOwnProperty.call(from, key)) {
3841 + to[key] = from[key];
3842 + }
3843 + }
3844 +
3845 + if (Object.getOwnPropertySymbols) {
3846 + symbols = Object.getOwnPropertySymbols(from);
3847 + for (var i = 0; i < symbols.length; i++) {
3848 + if (propIsEnumerable.call(from, symbols[i])) {
3849 + to[symbols[i]] = from[symbols[i]];
3850 + }
3851 + }
3852 + }
3853 + }
3854 +
3855 + return to;
3856 +};
3857 +
3858 +},{}]},{},[18])(18)
3859 +});
\ No newline at end of file
fixtures/inputs/README.md renamed
fixtures/inputs/index.html renamed
fixtures/react-loader.js renamed
fixtures/test.html renamed