https://adorow.github.io/js/generated/react/githubprojects/bundle.js

1/******/ (function(modules) { // webpackBootstrap
2/******/ 	// The module cache
3/******/ 	var installedModules = {};
4/******/
5/******/ 	// The require function
6/******/ 	function __webpack_require__(moduleId) {
7/******/
8/******/ 		// Check if module is in cache
9/******/ 		if(installedModules[moduleId]) {
10/******/ 			return installedModules[moduleId].exports;
11/******/ 		}
12/******/ 		// Create a new module (and put it into the cache)
13/******/ 		var module = installedModules[moduleId] = {
14/******/ 			i: moduleId,
15/******/ 			l: false,
16/******/ 			exports: {}
17/******/ 		};
18/******/
19/******/ 		// Execute the module function
20/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
21/******/
22/******/ 		// Flag the module as loaded
23/******/ 		module.l = true;
24/******/
25/******/ 		// Return the exports of the module
26/******/ 		return module.exports;
27/******/ 	}
28/******/
29/******/
30/******/ 	// expose the modules object (__webpack_modules__)
31/******/ 	__webpack_require__.m = modules;
32/******/
33/******/ 	// expose the module cache
34/******/ 	__webpack_require__.c = installedModules;
35/******/
36/******/ 	// identity function for calling harmony imports with the correct context
37/******/ 	__webpack_require__.i = function(value) { return value; };
38/******/
39/******/ 	// define getter function for harmony exports
40/******/ 	__webpack_require__.d = function(exports, name, getter) {
41/******/ 		if(!__webpack_require__.o(exports, name)) {
42/******/ 			Object.defineProperty(exports, name, {
43/******/ 				configurable: false,
44/******/ 				enumerable: true,
45/******/ 				get: getter
46/******/ 			});
47/******/ 		}
48/******/ 	};
49/******/
50/******/ 	// getDefaultExport function for compatibility with non-harmony modules
51/******/ 	__webpack_require__.n = function(module) {
52/******/ 		var getter = module && module.__esModule ?
53/******/ 			function getDefault() { return module['default']; } :
54/******/ 			function getModuleExports() { return module; };
55/******/ 		__webpack_require__.d(getter, 'a', getter);
56/******/ 		return getter;
57/******/ 	};
58/******/
59/******/ 	// Object.prototype.hasOwnProperty.call
60/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
61/******/
62/******/ 	// __webpack_public_path__
63/******/ 	__webpack_require__.p = "";
64/******/
65/******/ 	// Load entry module and return exports
66/******/ 	return __webpack_require__(__webpack_require__.s = 85);
67/******/ })
68/************************************************************************/
69/******/ ([
70/* 0 */
71/***/ (function(module, exports) {
72
73// shim for using process in browser
74var process = module.exports = {};
75
76// cached from whatever global is present so that test runners that stub it
77// don't break things.  But we need to wrap it in a try catch in case it is
78// wrapped in strict mode code which doesn't define any globals.  It's inside a
79// function because try/catches deoptimize in certain engines.
80
81var cachedSetTimeout;
82var cachedClearTimeout;
83
84function defaultSetTimout() {
85    throw new Error('setTimeout has not been defined');
86}
87function defaultClearTimeout () {
88    throw new Error('clearTimeout has not been defined');
89}
90(function () {
91    try {
92        if (typeof setTimeout === 'function') {
93            cachedSetTimeout = setTimeout;
94        } else {
95            cachedSetTimeout = defaultSetTimout;
96        }
97    } catch (e) {
98        cachedSetTimeout = defaultSetTimout;
99    }
100    try {
101        if (typeof clearTimeout === 'function') {
102            cachedClearTimeout = clearTimeout;
103        } else {
104            cachedClearTimeout = defaultClearTimeout;
105        }
106    } catch (e) {
107        cachedClearTimeout = defaultClearTimeout;
108    }
109} ())
110function runTimeout(fun) {
111    if (cachedSetTimeout === setTimeout) {
112        //normal enviroments in sane situations
113        return setTimeout(fun, 0);
114    }
115    // if setTimeout wasn't available but was latter defined
116    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
117        cachedSetTimeout = setTimeout;
118        return setTimeout(fun, 0);
119    }
120    try {
121        // when when somebody has screwed with setTimeout but no I.E. maddness
122        return cachedSetTimeout(fun, 0);
123    } catch(e){
124        try {
125            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
126            return cachedSetTimeout.call(null, fun, 0);
127        } catch(e){
128            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
129            return cachedSetTimeout.call(this, fun, 0);
130        }
131    }
132
133
134}
135function runClearTimeout(marker) {
136    if (cachedClearTimeout === clearTimeout) {
137        //normal enviroments in sane situations
138        return clearTimeout(marker);
139    }
140    // if clearTimeout wasn't available but was latter defined
141    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
142        cachedClearTimeout = clearTimeout;
143        return clearTimeout(marker);
144    }
145    try {
146        // when when somebody has screwed with setTimeout but no I.E. maddness
147        return cachedClearTimeout(marker);
148    } catch (e){
149        try {
150            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
151            return cachedClearTimeout.call(null, marker);
152        } catch (e){
153            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
154            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
155            return cachedClearTimeout.call(this, marker);
156        }
157    }
158
159
160
161}
162var queue = [];
163var draining = false;

164var currentQueue;
165var queueIndex = -1;
166
167function cleanUpNextTick() {
168    if (!draining || !currentQueue) {
169        return;
170    }
171    draining = false;
172    if (currentQueue.length) {
173        queue = currentQueue.concat(queue);
174    } else {
175        queueIndex = -1;
176    }
177    if (queue.length) {
178        drainQueue();
179    }
180}
181
182function drainQueue() {
183    if (draining) {
184        return;
185    }
186    var timeout = runTimeout(cleanUpNextTick);
187    draining = true;
188
189    var len = queue.length;
190    while(len) {
191        currentQueue = queue;
192        queue = [];
193        while (++queueIndex < len) {
194            if (currentQueue) {
195                currentQueue[queueIndex].run();
196            }
197        }
198        queueIndex = -1;
199        len = queue.length;
200    }
201    currentQueue = null;
202    draining = false;
203    runClearTimeout(timeout);
204}
205
206process.nextTick = function (fun) {
207    var args = new Array(arguments.length - 1);
208    if (arguments.length > 1) {
209        for (var i = 1; i < arguments.length; i++) {
210            args[i - 1] = arguments[i];
211        }
212    }
213    queue.push(new Item(fun, args));
214    if (queue.length === 1 && !draining) {
215        runTimeout(drainQueue);
216    }
217};
218
219// v8 likes predictible objects
220function Item(fun, array) {
221    this.fun = fun;
222    this.array = array;
223}
224Item.prototype.run = function () {
225    this.fun.apply(null, this.array);
226};
227process.title = 'browser';
228process.browser = true;
229process.env = {};
230process.argv = [];
231process.version = ''; // empty string to avoid regexp issues
232process.versions = {};
233
234function noop() {}
235
236process.on = noop;
237process.addListener = noop;
238process.once = noop;
239process.off = noop;
240process.removeListener = noop;
241process.removeAllListeners = noop;
242process.emit = noop;
243process.prependListener = noop;
244process.prependOnceListener = noop;
245
246process.listeners = function (name) { return [] }
247
248process.binding = function (name) {
249    throw new Error('process.binding is not supported');
250};
251
252process.cwd = function () { return '/' };
253process.chdir = function (dir) {
254    throw new Error('process.chdir is not supported');
255};
256process.umask = function() { return 0; };
257
258
259/***/ }),
260/* 1 */
261/***/ (function(module, exports, __webpack_require__) {
262
263"use strict";
264/* WEBPACK VAR INJECTION */(function(process) {/**
265 * Copyright (c) 2013-present, Facebook, Inc.
266 * All rights reserved.
267 *
268 * This source code is licensed under the BSD-style license found in the
269 * LICENSE file in the root directory of this source tree. An additional grant
270 * of patent rights can be found in the PATENTS file in the same directory.
271 *
272 */
273
274
275
276/**
277 * Use invariant() to assert state which your program assumes to be true.
278 *
279 * Provide sprintf-style format (only %s is supported) and arguments
280 * to provide information about what broke and what you were
281 * expecting.
282 *
283 * The invariant message will be stripped in production, but the invariant
284 * will remain to ensure logic does not differ in production.
285 */
286
287var validateFormat = function validateFormat(format) {};
288
289if (process.env.NODE_ENV !== 'production') {
290  validateFormat = function validateFormat(format) {
291    if (format === undefined) {
292      throw new Error('invariant requires an error message argument');
293    }
294  };
295}
296
297function invariant(condition, format, a, b, c, d, e, f) {
298  validateFormat(format);
299
300  if (!condition) {
301    var error;
302    if (format === undefined) {
303      error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');
304    } else {
305      var args = [a, b, c, d, e, f];
306      var argIndex = 0;
307      error = new Error(format.replace(/%s/g, function () {
308        return args[argIndex++];
309      }));
310      error.name = 'Invariant Violation';
311    }
312
313    error.framesToPop = 1; // we don't care about invariant's own frame
314    throw error;
315  }
316}
317
318module.exports = invariant;
319/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
320
321/***/ }),
322/* 2 */
323/***/ (function(module, exports, __webpack_require__) {
324
325"use strict";
326/* WEBPACK VAR INJECTION */(function(process) {/**
327 * Copyright 2014-2015, Facebook, Inc.
328 * All rights reserved.
329 *
330 * This source code is licensed under the BSD-style license found in the
331 * LICENSE file in the root directory of this source tree. An additional grant
332 * of patent rights can be found in the PATENTS file in the same directory.
333 *
334 */
335
336
337
338var emptyFunction = __webpack_require__(9);
339
340/**
341 * Similar to invariant but only logs a warning if the condition is not met.
342 * This can be used to log issues in development environments in critical
343 * paths. Removing the logging code for production environments will keep the
344 * same logic and follow the same code paths.
345 */
346
347var warning = emptyFunction;
348
349if (process.env.NODE_ENV !== 'production') {
350  (function () {
351    var printWarning = function printWarning(format) {
352      for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
353        args[_key - 1] = arguments[_key];
354      }
355
356      var argIndex = 0;
357      var message = 'Warning: ' + format.replace(/%s/g, function () {
358        return args[argIndex++];
359      });
360      if (typeof console !== 'undefined') {
361        console.error(message);
362      }

363      try {
364        // --- Welcome to debugging React ---
365        // This error was thrown as a convenience so that you can use this stack
366        // to find the callsite that caused this warning to fire.
367        throw new Error(message);
368      } catch (x) {}
369    };
370
371    warning = function warning(condition, format) {
372      if (format === undefined) {
373        throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument');
374      }
375
376      if (format.indexOf('Failed Composite propType: ') === 0) {
377        return; // Ignore CompositeComponent proptype check.
378      }
379
380      if (!condition) {
381        for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
382          args[_key2 - 2] = arguments[_key2];
383        }
384
385        printWarning.apply(undefined, [format].concat(args));
386      }
387    };
388  })();
389}
390
391module.exports = warning;
392/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
393
394/***/ }),
395/* 3 */
396/***/ (function(module, exports, __webpack_require__) {
397
398"use strict";
399/**
400 * Copyright (c) 2013-present, Facebook, Inc.
401 * All rights reserved.
402 *
403 * This source code is licensed under the BSD-style license found in the
404 * LICENSE file in the root directory of this source tree. An additional grant
405 * of patent rights can be found in the PATENTS file in the same directory.
406 *
407 * 
408 */
409
410
411/**
412 * WARNING: DO NOT manually require this module.
413 * This is a replacement for `invariant(...)` used by the error code system
414 * and will _only_ be required by the corresponding babel pass.
415 * It always throws.
416 */
417
418function reactProdInvariant(code) {
419  var argCount = arguments.length - 1;
420
421  var message = 'Minified React error #' + code + '; visit ' + 'http://facebook.github.io/react/docs/error-decoder.html?invariant=' + code;
422
423  for (var argIdx = 0; argIdx < argCount; argIdx++) {
424    message += '&args[]=' + encodeURIComponent(arguments[argIdx + 1]);
425  }
426
427  message += ' for the full message or use the non-minified dev environment' + ' for full errors and additional helpful warnings.';
428
429  var error = new Error(message);
430  error.name = 'Invariant Violation';
431  error.framesToPop = 1; // we don't care about reactProdInvariant's own frame
432
433  throw error;
434}
435
436module.exports = reactProdInvariant;
437
438/***/ }),
439/* 4 */
440/***/ (function(module, exports, __webpack_require__) {
441
442"use strict";
443/*
444object-assign
445(c) Sindre Sorhus
446@license MIT

447*/
448
449
450/* eslint-disable no-unused-vars */
451var getOwnPropertySymbols = Object.getOwnPropertySymbols;
452var hasOwnProperty = Object.prototype.hasOwnProperty;
453var propIsEnumerable = Object.prototype.propertyIsEnumerable;
454
455function toObject(val) {
456	if (val === null || val === undefined) {
457		throw new TypeError('Object.assign cannot be called with null or undefined');
458	}
459
460	return Object(val);
461}
462
463function shouldUseNative() {
464	try {
465		if (!Object.assign) {
466			return false;
467		}
468
469		// Detect buggy property enumeration order in older V8 versions.
470
471		// https://bugs.chromium.org/p/v8/issues/detail?id=4118
472		var test1 = new String('abc');  // eslint-disable-line no-new-wrappers
473		test1[5] = 'de';
474		if (Object.getOwnPropertyNames(test1)[0] === '5') {
475			return false;
476		}
477
478		// https://bugs.chromium.org/p/v8/issues/detail?id=3056
479		var test2 = {};
480		for (var i = 0; i < 10; i++) {
481			test2['_' + String.fromCharCode(i)] = i;
482		}
483		var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
484			return test2[n];
485		});
486		if (order2.join('') !== '0123456789') {
487			return false;
488		}
489
490		// https://bugs.chromium.org/p/v8/issues/detail?id=3056
491		var test3 = {};
492		'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
493			test3[letter] = letter;
494		});
495		if (Object.keys(Object.assign({}, test3)).join('') !==
496				'abcdefghijklmnopqrst') {
497			return false;
498		}
499
500		return true;
501	} catch (err) {
502		// We don't expect any of the above to throw, but better to be safe.
503		return false;
504	}
505}
506
507module.exports = shouldUseNative() ? Object.assign : function (target, source) {
508	var from;
509	var to = toObject(target);
510	var symbols;
511
512	for (var s = 1; s < arguments.length; s++) {
513		from = Object(arguments[s]);
514
515		for (var key in from) {
516			if (hasOwnProperty.call(from, key)) {
517				to[key] = from[key];
518			}
519		}
520
521		if (getOwnPropertySymbols) {
522			symbols = getOwnPropertySymbols(from);
523			for (var i = 0; i < symbols.length; i++) {
524				if (propIsEnumerable.call(from, symbols[i])) {
525					to[symbols[i]] = from[symbols[i]];
526				}
527			}
528		}
529	}
530
531	return to;
532};
533
534
535/***/ }),
536/* 5 */
537/***/ (function(module, exports, __webpack_require__) {
538
539"use strict";
540/* WEBPACK VAR INJECTION */(function(process) {/**
541 * Copyright 2013-present, Facebook, Inc.
542 * All rights reserved.
543 *
544 * This source code is licensed under the BSD-style license found in the
545 * LICENSE file in the root directory of this source tree. An additional grant
546 * of patent rights can be found in the PATENTS file in the same directory.
547 *
548 */
549
550
551
552var _prodInvariant = __webpack_require__(3);
553
554var DOMProperty = __webpack_require__(13);
555var ReactDOMComponentFlags = __webpack_require__(59);
556
557var invariant = __webpack_require__(1);
558
559var ATTR_NAME = DOMProperty.ID_ATTRIBUTE_NAME;
560var Flags = ReactDOMComponentFlags;
561
562var internalInstanceKey = '__reactInternalInstance$' + Math.random().toString(36).slice(2);
563
564/**
565 * Check if a given node should be cached.
566 */
567function shouldPrecacheNode(node, nodeID) {
568  return node.nodeType === 1 && node.getAttribute(ATTR_NAME) === String(nodeID) || node.nodeType === 8 && node.nodeValue === ' react-text: ' + nodeID + ' ' || node.nodeType === 8 && node.nodeValue === ' react-empty: ' + nodeID + ' ';
569}
570
571/**
572 * Drill down (through composites and empty components) until we get a host or
573 * host text component.
574 *
575 * This is pretty polymorphic but unavoidable with the current structure we have
576 * for `_renderedChildren`.
577 */
578function getRenderedHostOrTextFromComponent(component) {
579  var rendered;
580  while (rendered = component._renderedComponent) {
581    component = rendered;
582  }
583  return component;
584}
585
586/**
587 * Populate `_hostNode` on the rendered host/text component with the given
588 * DOM node. The passed `inst` can be a composite.
589 */
590function precacheNode(inst, node) {
591  var hostInst = getRenderedHostOrTextFromComponent(inst);
592  hostInst._hostNode = node;
593  node[internalInstanceKey] = hostInst;
594}
595
596function uncacheNode(inst) {
597  var node = inst._hostNode;
598  if (node) {
599    delete node[internalInstanceKey];
600    inst._hostNode = null;
601  }
602}
603
604/**
605 * Populate `_hostNode` on each child of `inst`, assuming that the children
606 * match up with the DOM (element) children of `node`.
607 *
608 * We cache entire levels at once to avoid an n^2 problem where we access the
609 * children of a node sequentially and have to walk from the start to our target
610 * node every time.
611 *
612 * Since we update `_renderedChildren` and the actual DOM at (slightly)
613 * different times, we could race here and see a newer `_renderedChildren` than
614 * the DOM nodes we see. To avoid this, ReactMultiChild calls
615 * `prepareToManageChildren` before we change `_renderedChildren`, at which
616 * time the container's child nodes are always cached (until it unmounts).
617 */
618function precacheChildNodes(inst, node) {
619  if (inst._flags & Flags.hasCachedChildNodes) {
620    return;
621  }
622  var children = inst._renderedChildren;
623  var childNode = node.firstChild;
624  outer: for (var name in children) {
625    if (!children.hasOwnProperty(name)) {
626      continue;
627    }
628    var childInst = children[name];
629    var childID = getRenderedHostOrTextFromComponent(childInst)._domID;
630    if (childID === 0) {
631      // We're currently unmounting this child in ReactMultiChild; skip it.
632      continue;
633    }
634    // We assume the child nodes are in the same order as the child instances.
635    for (; childNode !== null; childNode = childNode.nextSibling) {
636      if (shouldPrecacheNode(childNode, childID)) {
637        precacheNode(childInst, childNode);
638        continue outer;
639      }
640    }
641    // We reached the end of the DOM children without finding an ID match.
642     true ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Unable to find element with ID %s.', childID) : _prodInvariant('32', childID) : void 0;
643  }
644  inst._flags |= Flags.hasCachedChildNodes;
645}
646
647/**
648 * Given a DOM node, return the closest ReactDOMComponent or
649 * ReactDOMTextComponent instance ancestor.
650 */
651function getClosestInstanceFromNode(node) {
652  if (node[internalInstanceKey]) {
653    return node[internalInstanceKey];
654  }
655
656  // Walk up the tree until we find an ancestor whose instance we have cached.
657  var parents = [];
658  while (!node[internalInstanceKey]) {
659    parents.push(node);
660    if (node.parentNode) {
661      node = node.parentNode;
662    } else {
663      // Top of the tree. This node must not be part of a React tree (or is
664      // unmounted, potentially).
665      return null;
666    }
667  }
668
669  var closest;
670  var inst;
671  for (; node && (inst = node[internalInstanceKey]); node = parents.pop()) {
672    closest = inst;
673    if (parents.length) {
674      precacheChildNodes(inst, node);
675    }
676  }
677
678  return closest;
679}
680

681/**
682 * Given a DOM node, return the ReactDOMComponent or ReactDOMTextComponent
683 * instance, or null if the node was not rendered by this React.
684 */
685function getInstanceFromNode(node) {
686  var inst = getClosestInstanceFromNode(node);
687  if (inst != null && inst._hostNode === node) {
688    return inst;
689  } else {
690    return null;
691  }
692}
693
694/**
695 * Given a ReactDOMComponent or ReactDOMTextComponent, return the corresponding
696 * DOM node.
697 */
698function getNodeFromInstance(inst) {
699  // Without this first invariant, passing a non-DOM-component triggers the next
700  // invariant for a missing parent, which is super confusing.
701  !(inst._hostNode !== undefined) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'getNodeFromInstance: Invalid argument.') : _prodInvariant('33') : void 0;
702
703  if (inst._hostNode) {
704    return inst._hostNode;
705  }
706
707  // Walk up the tree until we find an ancestor whose DOM node we have cached.
708  var parents = [];
709  while (!inst._hostNode) {
710    parents.push(inst);
711    !inst._hostParent ? process.env.NODE_ENV !== 'production' ? invariant(false, 'React DOM tree root should always have a node reference.') : _prodInvariant('34') : void 0;
712    inst = inst._hostParent;
713  }
714
715  // Now parents contains each ancestor that does *not* have a cached native
716  // node, and `inst` is the deepest ancestor that does.
717  for (; parents.length; inst = parents.pop()) {
718    precacheChildNodes(inst, inst._hostNode);
719  }
720
721  return inst._hostNode;
722}
723
724var ReactDOMComponentTree = {
725  getClosestInstanceFromNode: getClosestInstanceFromNode,
726  getInstanceFromNode: getInstanceFromNode,
727  getNodeFromInstance: getNodeFromInstance,
728  precacheChildNodes: precacheChildNodes,
729  precacheNode: precacheNode,
730  uncacheNode: uncacheNode
731};
732
733module.exports = ReactDOMComponentTree;
734/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
735
736/***/ }),
737/* 6 */
738/***/ (function(module, exports, __webpack_require__) {
739
740"use strict";
741/**
742 * Copyright (c) 2013-present, Facebook, Inc.
743 * All rights reserved.
744 *
745 * This source code is licensed under the BSD-style license found in the
746 * LICENSE file in the root directory of this source tree. An additional grant
747 * of patent rights can be found in the PATENTS file in the same directory.
748 *
749 */
750
751
752
753var canUseDOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement);
754
755/**
756 * Simple, lightweight module assisting with the detection and context of
757 * Worker. Helps avoid circular dependencies and allows code to reason about
758 * whether or not they are in a Worker, even if they never include the main
759 * `ReactWorker` dependency.
760 */
761var ExecutionEnvironment = {
762
763  canUseDOM: canUseDOM,
764
765  canUseWorkers: typeof Worker !== 'undefined',
766
767  canUseEventListeners: canUseDOM && !!(window.addEventListener || window.attachEvent),
768
769  canUseViewport: canUseDOM && !!window.screen,
770
771  isInWorker: !canUseDOM // For now, this is true - might change in the future.
772
773};
774
775module.exports = ExecutionEnvironment;
776
777/***/ }),
778/* 7 */
779/***/ (function(module, exports, __webpack_require__) {
780
781"use strict";
782/* WEBPACK VAR INJECTION */(function(process) {/**
783 * Copyright 2016-present, Facebook, Inc.
784 * All rights reserved.
785 *
786 * This source code is licensed under the BSD-style license found in the
787 * LICENSE file in the root directory of this source tree. An additional grant
788 * of patent rights can be found in the PATENTS file in the same directory.
789 *
790 * 
791 */
792
793
794
795var _prodInvariant = __webpack_require__(16);
796
797var ReactCurrentOwner = __webpack_require__(11);
798
799var invariant = __webpack_require__(1);
800var warning = __webpack_require__(2);
801
802function isNative(fn) {
803  // Based on isNative() from Lodash
804  var funcToString = Function.prototype.toString;
805  var hasOwnProperty = Object.prototype.hasOwnProperty;
806  var reIsNative = RegExp('^' + funcToString
807  // Take an example native function source for comparison
808  .call(hasOwnProperty)
809  // Strip regex characters so we can use it for regex
810  .replace(/[\\^$.*+?()[\]{}|]/g, '\\$&')
811  // Remove hasOwnProperty from the template to make it generic
812  .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$');
813  try {
814    var source = funcToString.call(fn);
815    return reIsNative.test(source);
816  } catch (err) {
817    return false;

818  }
819}
820
821var canUseCollections =
822// Array.from
823typeof Array.from === 'function' &&
824// Map
825typeof Map === 'function' && isNative(Map) &&
826// Map.prototype.keys
827Map.prototype != null && typeof Map.prototype.keys === 'function' && isNative(Map.prototype.keys) &&
828// Set
829typeof Set === 'function' && isNative(Set) &&
830// Set.prototype.keys
831Set.prototype != null && typeof Set.prototype.keys === 'function' && isNative(Set.prototype.keys);
832
833var setItem;
834var getItem;
835var removeItem;
836var getItemIDs;
837var addRoot;
838var removeRoot;
839var getRootIDs;
840
841if (canUseCollections) {
842  var itemMap = new Map();
843  var rootIDSet = new Set();
844
845  setItem = function (id, item) {
846    itemMap.set(id, item);
847  };
848  getItem = function (id) {
849    return itemMap.get(id);
850  };
851  removeItem = function (id) {
852    itemMap['delete'](id);
853  };
854  getItemIDs = function () {
855    return Array.from(itemMap.keys());
856  };
857
858  addRoot = function (id) {
859    rootIDSet.add(id);
860  };
861  removeRoot = function (id) {
862    rootIDSet['delete'](id);
863  };
864  getRootIDs = function () {
865    return Array.from(rootIDSet.keys());
866  };
867} else {
868  var itemByKey = {};
869  var rootByKey = {};
870
871  // Use non-numeric keys to prevent V8 performance issues:
872  // https://github.com/facebook/react/pull/7232
873  var getKeyFromID = function (id) {
874    return '.' + id;
875  };
876  var getIDFromKey = function (key) {
877    return parseInt(key.substr(1), 10);
878  };
879
880  setItem = function (id, item) {
881    var key = getKeyFromID(id);
882    itemByKey[key] = item;
883  };
884  getItem = function (id) {
885    var key = getKeyFromID(id);
886    return itemByKey[key];
887  };
888  removeItem = function (id) {
889    var key = getKeyFromID(id);
890    delete itemByKey[key];
891  };
892  getItemIDs = function () {
893    return Object.keys(itemByKey).map(getIDFromKey);
894  };
895
896  addRoot = function (id) {
897    var key = getKeyFromID(id);
898    rootByKey[key] = true;
899  };
900  removeRoot = function (id) {
901    var key = getKeyFromID(id);
902    delete rootByKey[key];
903  };
904  getRootIDs = function () {
905    return Object.keys(rootByKey).map(getIDFromKey);
906  };
907}
908
909var unmountedIDs = [];
910
911function purgeDeep(id) {
912  var item = getItem(id);
913  if (item) {
914    var childIDs = item.childIDs;
915
916    removeItem(id);
917    childIDs.forEach(purgeDeep);
918  }
919}
920
921function describeComponentFrame(name, source, ownerName) {
922  return '\n    in ' + (name || 'Unknown') + (source ? ' (at ' + source.fileName.replace(/^.*[\\\/]/, '') + ':' + source.lineNumber + ')' : ownerName ? ' (created by ' + ownerName + ')' : '');
923}
924
925function getDisplayName(element) {
926  if (element == null) {
927    return '#empty';
928  } else if (typeof element === 'string' || typeof element === 'number') {
929    return '#text';
930  } else if (typeof element.type === 'string') {
931    return element.type;
932  } else {
933    return element.type.displayName || element.type.name || 'Unknown';
934  }
935}
936
937function describeID(id) {
938  var name = ReactComponentTreeHook.getDisplayName(id);
939  var element = ReactComponentTreeHook.getElement(id);
940  var ownerID = ReactComponentTreeHook.getOwnerID(id);
941  var ownerName;
942  if (ownerID) {
943    ownerName = ReactComponentTreeHook.getDisplayName(ownerID);
944  }
945  process.env.NODE_ENV !== 'production' ? warning(element, 'ReactComponentTreeHook: Missing React element for debugID %s when ' + 'building stack', id) : void 0;
946  return describeComponentFrame(name, element && element._source, ownerName);
947}
948
949var ReactComponentTreeHook = {
950  onSetChildren: function (id, nextChildIDs) {
951    var item = getItem(id);
952    !item ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Item must have been set') : _prodInvariant('144') : void 0;
953    item.childIDs = nextChildIDs;
954
955    for (var i = 0; i < nextChildIDs.length; i++) {
956      var nextChildID = nextChildIDs[i];
957      var nextChild = getItem(nextChildID);
958      !nextChild ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Expected hook events to fire for the child before its parent includes it in onSetChildren().') : _prodInvariant('140') : void 0;
959      !(nextChild.childIDs != null || typeof nextChild.element !== 'object' || nextChild.element == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Expected onSetChildren() to fire for a container child before its parent includes it in onSetChildren().') : _prodInvariant('141') : void 0;
960      !nextChild.isMounted ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Expected onMountComponent() to fire for the child before its parent includes it in onSetChildren().') : _prodInvariant('71') : void 0;
961      if (nextChild.parentID == null) {
962        nextChild.parentID = id;
963        // TODO: This shouldn't be necessary but mounting a new root during in
964        // componentWillMount currently causes not-yet-mounted components to
965        // be purged from our tree data so their parent id is missing.
966      }
967      !(nextChild.parentID === id) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Expected onBeforeMountComponent() parent and onSetChildren() to be consistent (%s has parents %s and %s).', nextChildID, nextChild.parentID, id) : _prodInvariant('142', nextChildID, nextChild.parentID, id) : void 0;
968    }
969  },
970  onBeforeMountComponent: function (id, element, parentID) {
971    var item = {
972      element: element,
973      parentID: parentID,
974      text: null,
975      childIDs: [],
976      isMounted: false,
977      updateCount: 0
978    };
979    setItem(id, item);
980  },
981  onBeforeUpdateComponent: function (id, element) {
982    var item = getItem(id);
983    if (!item || !item.isMounted) {
984      // We may end up here as a result of setState() in componentWillUnmount().
985      // In this case, ignore the element.
986      return;
987    }
988    item.element = element;
989  },
990  onMountComponent: function (id) {
991    var item = getItem(id);
992    !item ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Item must have been set') : _prodInvariant('144') : void 0;
993    item.isMounted = true;

994    var isRoot = item.parentID === 0;
995    if (isRoot) {
996      addRoot(id);
997    }
998  },
999  onUpdateComponent: function (id) {
1000    var item = getItem(id);
1001    if (!item || !item.isMounted) {
1002      // We may end up here as a result of setState() in componentWillUnmount().
1003      // In this case, ignore the element.
1004      return;
1005    }
1006    item.updateCount++;
1007  },
1008  onUnmountComponent: function (id) {
1009    var item = getItem(id);
1010    if (item) {
1011      // We need to check if it exists.
1012      // `item` might not exist if it is inside an error boundary, and a sibling
1013      // error boundary child threw while mounting. Then this instance never
1014      // got a chance to mount, but it still gets an unmounting event during
1015      // the error boundary cleanup.
1016      item.isMounted = false;
1017      var isRoot = item.parentID === 0;
1018      if (isRoot) {
1019        removeRoot(id);
1020      }
1021    }
1022    unmountedIDs.push(id);
1023  },
1024  purgeUnmountedComponents: function () {
1025    if (ReactComponentTreeHook._preventPurging) {
1026      // Should only be used for testing.
1027      return;
1028    }
1029
1030    for (var i = 0; i < unmountedIDs.length; i++) {
1031      var id = unmountedIDs[i];
1032      purgeDeep(id);
1033    }
1034    unmountedIDs.length = 0;
1035  },
1036  isMounted: function (id) {
1037    var item = getItem(id);
1038    return item ? item.isMounted : false;
1039  },
1040  getCurrentStackAddendum: function (topElement) {
1041    var info = '';
1042    if (topElement) {
1043      var name = getDisplayName(topElement);
1044      var owner = topElement._owner;
1045      info += describeComponentFrame(name, topElement._source, owner && owner.getName());
1046    }
1047
1048    var currentOwner = ReactCurrentOwner.current;
1049    var id = currentOwner && currentOwner._debugID;
1050
1051    info += ReactComponentTreeHook.getStackAddendumByID(id);
1052    return info;
1053  },
1054  getStackAddendumByID: function (id) {
1055    var info = '';
1056    while (id) {
1057      info += describeID(id);
1058      id = ReactComponentTreeHook.getParentID(id);
1059    }
1060    return info;
1061  },
1062  getChildIDs: function (id) {
1063    var item = getItem(id);
1064    return item ? item.childIDs : [];
1065  },
1066  getDisplayName: function (id) {
1067    var element = ReactComponentTreeHook.getElement(id);
1068    if (!element) {
1069      return null;
1070    }
1071    return getDisplayName(element);
1072  },
1073  getElement: function (id) {
1074    var item = getItem(id);
1075    return item ? item.element : null;
1076  },
1077  getOwnerID: function (id) {
1078    var element = ReactComponentTreeHook.getElement(id);
1079    if (!element || !element._owner) {
1080      return null;
1081    }
1082    return element._owner._debugID;
1083  },
1084  getParentID: function (id) {
1085    var item = getItem(id);
1086    return item ? item.parentID : null;
1087  },
1088  getSource: function (id) {
1089    var item = getItem(id);
1090    var element = item ? item.element : null;
1091    var source = element != null ? element._source : null;
1092    return source;
1093  },
1094  getText: function (id) {
1095    var element = ReactComponentTreeHook.getElement(id);
1096    if (typeof element === 'string') {
1097      return element;
1098    } else if (typeof element === 'number') {
1099      return '' + element;
1100    } else {
1101      return null;
1102    }
1103  },
1104  getUpdateCount: function (id) {
1105    var item = getItem(id);
1106    return item ? item.updateCount : 0;
1107  },
1108
1109
1110  getRootIDs: getRootIDs,
1111  getRegisteredIDs: getItemIDs
1112};
1113
1114module.exports = ReactComponentTreeHook;
1115/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
1116
1117/***/ }),
1118/* 8 */
1119/***/ (function(module, exports, __webpack_require__) {
1120
1121"use strict";
1122/* WEBPACK VAR INJECTION */(function(process) {/**
1123 * Copyright 2016-present, Facebook, Inc.
1124 * All rights reserved.
1125 *
1126 * This source code is licensed under the BSD-style license found in the
1127 * LICENSE file in the root directory of this source tree. An additional grant
1128 * of patent rights can be found in the PATENTS file in the same directory.
1129 *
1130 * 
1131 */
1132
1133
1134
1135// Trust the developer to only use ReactInstrumentation with a __DEV__ check
1136
1137var debugTool = null;
1138
1139if (process.env.NODE_ENV !== 'production') {
1140  var ReactDebugTool = __webpack_require__(133);
1141  debugTool = ReactDebugTool;
1142}
1143
1144module.exports = { debugTool: debugTool };
1145/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
1146
1147/***/ }),
1148/* 9 */
1149/***/ (function(module, exports, __webpack_require__) {
1150
1151"use strict";
1152
1153
1154/**
1155 * Copyright (c) 2013-present, Facebook, Inc.
1156 * All rights reserved.
1157 *
1158 * This source code is licensed under the BSD-style license found in the
1159 * LICENSE file in the root directory of this source tree. An additional grant
1160 * of patent rights can be found in the PATENTS file in the same directory.
1161 *
1162 * 
1163 */
1164
1165function makeEmptyFunction(arg) {
1166  return function () {
1167    return arg;
1168  };
1169}
1170
1171/**
1172 * This function accepts and discards inputs; it has no side effects. This is
1173 * primarily useful idiomatically for overridable function endpoints which
1174 * always need to be callable, since JS lacks a null-call idiom ala Cocoa.
1175 */
1176var emptyFunction = function emptyFunction() {};
1177
1178emptyFunction.thatReturns = makeEmptyFunction;
1179emptyFunction.thatReturnsFalse = makeEmptyFunction(false);
1180emptyFunction.thatReturnsTrue = makeEmptyFunction(true);
1181emptyFunction.thatReturnsNull = makeEmptyFunction(null);
1182emptyFunction.thatReturnsThis = function () {
1183  return this;
1184};
1185emptyFunction.thatReturnsArgument = function (arg) {
1186  return arg;
1187};
1188
1189module.exports = emptyFunction;
1190
1191/***/ }),
1192/* 10 */
1193/***/ (function(module, exports, __webpack_require__) {
1194
1195"use strict";
1196/* WEBPACK VAR INJECTION */(function(process) {/**
1197 * Copyright 2013-present, Facebook, Inc.
1198 * All rights reserved.
1199 *
1200 * This source code is licensed under the BSD-style license found in the
1201 * LICENSE file in the root directory of this source tree. An additional grant
1202 * of patent rights can be found in the PATENTS file in the same directory.
1203 *
1204 */
1205
1206
1207
1208var _prodInvariant = __webpack_require__(3),
1209    _assign = __webpack_require__(4);
1210
1211var CallbackQueue = __webpack_require__(57);
1212var PooledClass = __webpack_require__(14);
1213var ReactFeatureFlags = __webpack_require__(62);
1214var ReactReconciler = __webpack_require__(18);
1215var Transaction = __webpack_require__(29);
1216
1217var invariant = __webpack_require__(1);
1218
1219var dirtyComponents = [];
1220var updateBatchNumber = 0;
1221var asapCallbackQueue = CallbackQueue.getPooled();
1222var asapEnqueued = false;

1223
1224var batchingStrategy = null;
1225
1226function ensureInjected() {
1227  !(ReactUpdates.ReactReconcileTransaction && batchingStrategy) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactUpdates: must inject a reconcile transaction class and batching strategy') : _prodInvariant('123') : void 0;
1228}
1229
1230var NESTED_UPDATES = {
1231  initialize: function () {
1232    this.dirtyComponentsLength = dirtyComponents.length;
1233  },
1234  close: function () {
1235    if (this.dirtyComponentsLength !== dirtyComponents.length) {
1236      // Additional updates were enqueued by componentDidUpdate handlers or
1237      // similar; before our own UPDATE_QUEUEING wrapper closes, we want to run
1238      // these new updates so that if A's componentDidUpdate calls setState on
1239      // B, B will update before the callback A's updater provided when calling
1240      // setState.
1241      dirtyComponents.splice(0, this.dirtyComponentsLength);
1242      flushBatchedUpdates();
1243    } else {
1244      dirtyComponents.length = 0;
1245    }
1246  }
1247};
1248
1249var UPDATE_QUEUEING = {
1250  initialize: function () {
1251    this.callbackQueue.reset();
1252  },
1253  close: function () {
1254    this.callbackQueue.notifyAll();
1255  }
1256};
1257
1258var TRANSACTION_WRAPPERS = [NESTED_UPDATES, UPDATE_QUEUEING];
1259
1260function ReactUpdatesFlushTransaction() {
1261  this.reinitializeTransaction();
1262  this.dirtyComponentsLength = null;
1263  this.callbackQueue = CallbackQueue.getPooled();
1264  this.reconcileTransaction = ReactUpdates.ReactReconcileTransaction.getPooled(
1265  /* useCreateElement */true);
1266}
1267
1268_assign(ReactUpdatesFlushTransaction.prototype, Transaction, {
1269  getTransactionWrappers: function () {
1270    return TRANSACTION_WRAPPERS;
1271  },
1272
1273  destructor: function () {
1274    this.dirtyComponentsLength = null;
1275    CallbackQueue.release(this.callbackQueue);
1276    this.callbackQueue = null;
1277    ReactUpdates.ReactReconcileTransaction.release(this.reconcileTransaction);
1278    this.reconcileTransaction = null;
1279  },
1280
1281  perform: function (method, scope, a) {
1282    // Essentially calls `this.reconcileTransaction.perform(method, scope, a)`
1283    // with this transaction's wrappers around it.
1284    return Transaction.perform.call(this, this.reconcileTransaction.perform, this.reconcileTransaction, method, scope, a);
1285  }
1286});
1287
1288PooledClass.addPoolingTo(ReactUpdatesFlushTransaction);
1289
1290function batchedUpdates(callback, a, b, c, d, e) {
1291  ensureInjected();
1292  return batchingStrategy.batchedUpdates(callback, a, b, c, d, e);
1293}
1294
1295/**
1296 * Array comparator for ReactComponents by mount ordering.
1297 *
1298 * @param {ReactComponent} c1 first component you're comparing
1299 * @param {ReactComponent} c2 second component you're comparing
1300 * @return {number} Return value usable by Array.prototype.sort().
1301 */
1302function mountOrderComparator(c1, c2) {
1303  return c1._mountOrder - c2._mountOrder;
1304}
1305
1306function runBatchedUpdates(transaction) {
1307  var len = transaction.dirtyComponentsLength;
1308  !(len === dirtyComponents.length) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Expected flush transaction\'s stored dirty-components length (%s) to match dirty-components array length (%s).', len, dirtyComponents.length) : _prodInvariant('124', len, dirtyComponents.length) : void 0;
1309
1310  // Since reconciling a component higher in the owner hierarchy usually (not
1311  // always -- see shouldComponentUpdate()) will reconcile children, reconcile
1312  // them before their children by sorting the array.
1313  dirtyComponents.sort(mountOrderComparator);
1314
1315  // Any updates enqueued while reconciling must be performed after this entire
1316  // batch. Otherwise, if dirtyComponents is [A, B] where A has children B and
1317  // C, B could update twice in a single batch if C's render enqueues an update
1318  // to B (since B would have already updated, we should skip it, and the only
1319  // way we can know to do so is by checking the batch counter).
1320  updateBatchNumber++;
1321
1322  for (var i = 0; i < len; i++) {
1323    // If a component is unmounted before pending changes apply, it will still
1324    // be here, but we assume that it has cleared its _pendingCallbacks and
1325    // that performUpdateIfNecessary is a noop.
1326    var component = dirtyComponents[i];
1327
1328    // If performUpdateIfNecessary happens to enqueue any new updates, we
1329    // shouldn't execute the callbacks until the next render happens, so
1330    // stash the callbacks first
1331    var callbacks = component._pendingCallbacks;
1332    component._pendingCallbacks = null;
1333
1334    var markerName;
1335    if (ReactFeatureFlags.logTopLevelRenders) {
1336      var namedComponent = component;
1337      // Duck type TopLevelWrapper. This is probably always true.
1338      if (component._currentElement.type.isReactTopLevelWrapper) {
1339        namedComponent = component._renderedComponent;
1340      }
1341      markerName = 'React update: ' + namedComponent.getName();
1342      console.time(markerName);
1343    }
1344
1345    ReactReconciler.performUpdateIfNecessary(component, transaction.reconcileTransaction, updateBatchNumber);
1346
1347    if (markerName) {
1348      console.timeEnd(markerName);
1349    }
1350
1351    if (callbacks) {
1352      for (var j = 0; j < callbacks.length; j++) {
1353        transaction.callbackQueue.enqueue(callbacks[j], component.getPublicInstance());
1354      }
1355    }
1356  }
1357}
1358

1359var flushBatchedUpdates = function () {
1360  // ReactUpdatesFlushTransaction's wrappers will clear the dirtyComponents
1361  // array and perform any updates enqueued by mount-ready handlers (i.e.,
1362  // componentDidUpdate) but we need to check here too in order to catch
1363  // updates enqueued by setState callbacks and asap calls.
1364  while (dirtyComponents.length || asapEnqueued) {
1365    if (dirtyComponents.length) {
1366      var transaction = ReactUpdatesFlushTransaction.getPooled();
1367      transaction.perform(runBatchedUpdates, null, transaction);
1368      ReactUpdatesFlushTransaction.release(transaction);
1369    }
1370
1371    if (asapEnqueued) {
1372      asapEnqueued = false;
1373      var queue = asapCallbackQueue;
1374      asapCallbackQueue = CallbackQueue.getPooled();
1375      queue.notifyAll();
1376      CallbackQueue.release(queue);
1377    }
1378  }
1379};
1380
1381/**
1382 * Mark a component as needing a rerender, adding an optional callback to a
1383 * list of functions which will be executed once the rerender occurs.
1384 */
1385function enqueueUpdate(component) {
1386  ensureInjected();
1387
1388  // Various parts of our code (such as ReactCompositeComponent's
1389  // _renderValidatedComponent) assume that calls to render aren't nested;
1390  // verify that that's the case. (This is called by each top-level update
1391  // function, like setState, forceUpdate, etc.; creation and
1392  // destruction of top-level components is guarded in ReactMount.)
1393
1394  if (!batchingStrategy.isBatchingUpdates) {
1395    batchingStrategy.batchedUpdates(enqueueUpdate, component);
1396    return;
1397  }
1398
1399  dirtyComponents.push(component);
1400  if (component._updateBatchNumber == null) {
1401    component._updateBatchNumber = updateBatchNumber + 1;
1402  }
1403}
1404
1405/**
1406 * Enqueue a callback to be run at the end of the current batching cycle. Throws
1407 * if no updates are currently being performed.
1408 */
1409function asap(callback, context) {
1410  !batchingStrategy.isBatchingUpdates ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactUpdates.asap: Can\'t enqueue an asap callback in a context whereupdates are not being batched.') : _prodInvariant('125') : void 0;
1411  asapCallbackQueue.enqueue(callback, context);
1412  asapEnqueued = true;
1413}
1414
1415var ReactUpdatesInjection = {
1416  injectReconcileTransaction: function (ReconcileTransaction) {
1417    !ReconcileTransaction ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactUpdates: must provide a reconcile transaction class') : _prodInvariant('126') : void 0;
1418    ReactUpdates.ReactReconcileTransaction = ReconcileTransaction;
1419  },
1420
1421  injectBatchingStrategy: function (_batchingStrategy) {
1422    !_batchingStrategy ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactUpdates: must provide a batching strategy') : _prodInvariant('127') : void 0;
1423    !(typeof _batchingStrategy.batchedUpdates === 'function') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactUpdates: must provide a batchedUpdates() function') : _prodInvariant('128') : void 0;
1424    !(typeof _batchingStrategy.isBatchingUpdates === 'boolean') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactUpdates: must provide an isBatchingUpdates boolean attribute') : _prodInvariant('129') : void 0;
1425    batchingStrategy = _batchingStrategy;
1426  }
1427};
1428
1429var ReactUpdates = {
1430  /**
1431   * React references `ReactReconcileTransaction` using this property in order
1432   * to allow dependency injection.
1433   *
1434   * @internal
1435   */
1436  ReactReconcileTransaction: null,
1437
1438  batchedUpdates: batchedUpdates,
1439  enqueueUpdate: enqueueUpdate,
1440  flushBatchedUpdates: flushBatchedUpdates,
1441  injection: ReactUpdatesInjection,
1442  asap: asap
1443};
1444
1445module.exports = ReactUpdates;
1446/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
1447
1448/***/ }),
1449/* 11 */
1450/***/ (function(module, exports, __webpack_require__) {
1451
1452"use strict";
1453/**
1454 * Copyright 2013-present, Facebook, Inc.
1455 * All rights reserved.
1456 *
1457 * This source code is licensed under the BSD-style license found in the
1458 * LICENSE file in the root directory of this source tree. An additional grant
1459 * of patent rights can be found in the PATENTS file in the same directory.
1460 *
1461 * 
1462 */
1463
1464
1465
1466/**
1467 * Keeps track of the current owner.
1468 *
1469 * The current owner is the component who should own any components that are
1470 * currently being constructed.
1471 */
1472var ReactCurrentOwner = {
1473
1474  /**
1475   * @internal
1476   * @type {ReactComponent}
1477   */
1478  current: null
1479
1480};
1481
1482module.exports = ReactCurrentOwner;
1483
1484/***/ }),
1485/* 12 */
1486/***/ (function(module, exports, __webpack_require__) {
1487
1488"use strict";
1489/* WEBPACK VAR INJECTION */(function(process) {/**
1490 * Copyright 2013-present, Facebook, Inc.
1491 * All rights reserved.
1492 *
1493 * This source code is licensed under the BSD-style license found in the
1494 * LICENSE file in the root directory of this source tree. An additional grant
1495 * of patent rights can be found in the PATENTS file in the same directory.
1496 *
1497 */
1498
1499
1500
1501var _assign = __webpack_require__(4);
1502
1503var PooledClass = __webpack_require__(14);
1504
1505var emptyFunction = __webpack_require__(9);
1506var warning = __webpack_require__(2);
1507
1508var didWarnForAddedNewProperty = false;

1509var isProxySupported = typeof Proxy === 'function';
1510
1511var shouldBeReleasedProperties = ['dispatchConfig', '_targetInst', 'nativeEvent', 'isDefaultPrevented', 'isPropagationStopped', '_dispatchListeners', '_dispatchInstances'];
1512
1513/**
1514 * @interface Event
1515 * @see http://www.w3.org/TR/DOM-Level-3-Events/
1516 */
1517var EventInterface = {
1518  type: null,
1519  target: null,
1520  // currentTarget is set when dispatching; no use in copying it here
1521  currentTarget: emptyFunction.thatReturnsNull,
1522  eventPhase: null,
1523  bubbles: null,
1524  cancelable: null,
1525  timeStamp: function (event) {
1526    return event.timeStamp || Date.now();
1527  },
1528  defaultPrevented: null,
1529  isTrusted: null
1530};
1531
1532/**
1533 * Synthetic events are dispatched by event plugins, typically in response to a
1534 * top-level event delegation handler.
1535 *
1536 * These systems should generally use pooling to reduce the frequency of garbage
1537 * collection. The system should check `isPersistent` to determine whether the
1538 * event should be released into the pool after being dispatched. Users that
1539 * need a persisted event should invoke `persist`.
1540 *
1541 * Synthetic events (and subclasses) implement the DOM Level 3 Events API by
1542 * normalizing browser quirks. Subclasses do not necessarily have to implement a
1543 * DOM interface; custom application-specific events can also subclass this.
1544 *
1545 * @param {object} dispatchConfig Configuration used to dispatch this event.
1546 * @param {*} targetInst Marker identifying the event target.
1547 * @param {object} nativeEvent Native browser event.
1548 * @param {DOMEventTarget} nativeEventTarget Target node.
1549 */
1550function SyntheticEvent(dispatchConfig, targetInst, nativeEvent, nativeEventTarget) {
1551  if (process.env.NODE_ENV !== 'production') {
1552    // these have a getter/setter for warnings
1553    delete this.nativeEvent;
1554    delete this.preventDefault;
1555    delete this.stopPropagation;
1556  }
1557
1558  this.dispatchConfig = dispatchConfig;
1559  this._targetInst = targetInst;
1560  this.nativeEvent = nativeEvent;
1561
1562  var Interface = this.constructor.Interface;
1563  for (var propName in Interface) {
1564    if (!Interface.hasOwnProperty(propName)) {
1565      continue;
1566    }
1567    if (process.env.NODE_ENV !== 'production') {
1568      delete this[propName]; // this has a getter/setter for warnings
1569    }
1570    var normalize = Interface[propName];
1571    if (normalize) {
1572      this[propName] = normalize(nativeEvent);
1573    } else {
1574      if (propName === 'target') {
1575        this.target = nativeEventTarget;
1576      } else {
1577        this[propName] = nativeEvent[propName];
1578      }
1579    }
1580  }
1581
1582  var defaultPrevented = nativeEvent.defaultPrevented != null ? nativeEvent.defaultPrevented : nativeEvent.returnValue === false;
1583  if (defaultPrevented) {
1584    this.isDefaultPrevented = emptyFunction.thatReturnsTrue;
1585  } else {
1586    this.isDefaultPrevented = emptyFunction.thatReturnsFalse;
1587  }
1588  this.isPropagationStopped = emptyFunction.thatReturnsFalse;
1589  return this;
1590}
1591
1592_assign(SyntheticEvent.prototype, {
1593
1594  preventDefault: function () {
1595    this.defaultPrevented = true;
1596    var event = this.nativeEvent;
1597    if (!event) {
1598      return;
1599    }
1600
1601    if (event.preventDefault) {
1602      event.preventDefault();
1603    } else if (typeof event.returnValue !== 'unknown') {
1604      // eslint-disable-line valid-typeof
1605      event.returnValue = false;
1606    }
1607    this.isDefaultPrevented = emptyFunction.thatReturnsTrue;
1608  },
1609
1610  stopPropagation: function () {
1611    var event = this.nativeEvent;
1612    if (!event) {
1613      return;
1614    }
1615
1616    if (event.stopPropagation) {
1617      event.stopPropagation();
1618    } else if (typeof event.cancelBubble !== 'unknown') {
1619      // eslint-disable-line valid-typeof
1620      // The ChangeEventPlugin registers a "propertychange" event for
1621      // IE. This event does not support bubbling or cancelling, and
1622      // any references to cancelBubble throw "Member not found".  A
1623      // typeof check of "unknown" circumvents this issue (and is also
1624      // IE specific).
1625      event.cancelBubble = true;
1626    }
1627
1628    this.isPropagationStopped = emptyFunction.thatReturnsTrue;
1629  },
1630
1631  /**
1632   * We release all dispatched `SyntheticEvent`s after each event loop, adding
1633   * them back into the pool. This allows a way to hold onto a reference that
1634   * won't be added back into the pool.
1635   */
1636  persist: function () {
1637    this.isPersistent = emptyFunction.thatReturnsTrue;
1638  },
1639
1640  /**
1641   * Checks if this event should be released back into the pool.
1642   *
1643   * @return {boolean} True if this should not be released, false otherwise.
1644   */
1645  isPersistent: emptyFunction.thatReturnsFalse,
1646
1647  /**
1648   * `PooledClass` looks for `destructor` on each instance it releases.
1649   */
1650  destructor: function () {
1651    var Interface = this.constructor.Interface;
1652    for (var propName in Interface) {
1653      if (process.env.NODE_ENV !== 'production') {
1654        Object.defineProperty(this, propName, getPooledWarningPropertyDefinition(propName, Interface[propName]));
1655      } else {
1656        this[propName] = null;
1657      }
1658    }
1659    for (var i = 0; i < shouldBeReleasedProperties.length; i++) {
1660      this[shouldBeReleasedProperties[i]] = null;
1661    }
1662    if (process.env.NODE_ENV !== 'production') {
1663      Object.defineProperty(this, 'nativeEvent', getPooledWarningPropertyDefinition('nativeEvent', null));
1664      Object.defineProperty(this, 'preventDefault', getPooledWarningPropertyDefinition('preventDefault', emptyFunction));
1665      Object.defineProperty(this, 'stopPropagation', getPooledWarningPropertyDefinition('stopPropagation', emptyFunction));
1666    }
1667  }
1668
1669});
1670
1671SyntheticEvent.Interface = EventInterface;
1672
1673if (process.env.NODE_ENV !== 'production') {
1674  if (isProxySupported) {
1675    /*eslint-disable no-func-assign */
1676    SyntheticEvent = new Proxy(SyntheticEvent, {
1677      construct: function (target, args) {
1678        return this.apply(target, Object.create(target.prototype), args);
1679      },
1680      apply: function (constructor, that, args) {
1681        return new Proxy(constructor.apply(that, args), {
1682          set: function (target, prop, value) {
1683            if (prop !== 'isPersistent' && !target.constructor.Interface.hasOwnProperty(prop) && shouldBeReleasedProperties.indexOf(prop) === -1) {
1684              process.env.NODE_ENV !== 'production' ? warning(didWarnForAddedNewProperty || target.isPersistent

1684(), 'This synthetic event is reused for performance reasons. If you\'re ' + 'seeing this, you\'re adding a new property in the synthetic event object. ' + 'The property is never released. See ' + 'https://fb.me/react-event-pooling for more information.') : void 0;
1685              didWarnForAddedNewProperty = true;
1686            }
1687            target[prop] = value;
1688            return true;
1689          }
1690        });
1691      }
1692    });
1693    /*eslint-enable no-func-assign */
1694  }
1695}
1696/**
1697 * Helper to reduce boilerplate when creating subclasses.
1698 *
1699 * @param {function} Class
1700 * @param {?object} Interface
1701 */
1702SyntheticEvent.augmentClass = function (Class, Interface) {
1703  var Super = this;
1704
1705  var E = function () {};
1706  E.prototype = Super.prototype;
1707  var prototype = new E();
1708
1709  _assign(prototype, Class.prototype);
1710  Class.prototype = prototype;
1711  Class.prototype.constructor = Class;
1712
1713  Class.Interface = _assign({}, Super.Interface, Interface);
1714  Class.augmentClass = Super.augmentClass;
1715
1716  PooledClass.addPoolingTo(Class, PooledClass.fourArgumentPooler);
1717};
1718
1719PooledClass.addPoolingTo(SyntheticEvent, PooledClass.fourArgumentPooler);
1720
1721module.exports = SyntheticEvent;
1722
1723/**
1724  * Helper to nullify syntheticEvent instance properties when destructing
1725  *
1726  * @param {object} SyntheticEvent
1727  * @param {String} propName
1728  * @return {object} defineProperty object
1729  */
1730function getPooledWarningPropertyDefinition(propName, getVal) {
1731  var isFunction = typeof getVal === 'function';
1732  return {
1733    configurable: true,
1734    set: set,
1735    get: get
1736  };
1737
1738  function set(val) {
1739    var action = isFunction ? 'setting the method' : 'setting the property';
1740    warn(action, 'This is effectively a no-op');
1741    return val;
1742  }
1743
1744  function get() {
1745    var action = isFunction ? 'accessing the method' : 'accessing the property';
1746    var result = isFunction ? 'This is a no-op function' : 'This is set to null';
1747    warn(action, result);
1748    return getVal;
1749  }
1750
1751  function warn(action, result) {
1752    var warningCondition = false;
1753    process.env.NODE_ENV !== 'production' ? warning(warningCondition, 'This synthetic event is reused for performance reasons. If you\'re seeing this, ' + 'you\'re %s `%s` on a released/nullified synthetic event. %s. ' + 'If you must keep the original synthetic event around, use event.persist(). ' + 'See https://fb.me/react-event-pooling for more information.', action, propName, result) : void 0;
1754  }
1755}
1756/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
1757
1758/***/ }),
1759/* 13 */
1760/***/ (function(module, exports, __webpack_require__) {
1761
1762"use strict";
1763/* WEBPACK VAR INJECTION */(function(process) {/**
1764 * Copyright 2013-present, Facebook, Inc.
1765 * All rights reserved.
1766 *
1767 * This source code is licensed under the BSD-style license found in the
1768 * LICENSE file in the root directory of this source tree. An additional grant
1769 * of patent rights can be found in the PATENTS file in the same directory.
1770 *
1771 */
1772
1773
1774
1775var _prodInvariant = __webpack_require__(3);
1776
1777var invariant = __webpack_require__(1);
1778
1779function checkMask(value, bitmask) {
1780  return (value & bitmask) === bitmask;
1781}
1782
1783var DOMPropertyInjection = {
1784  /**
1785   * Mapping from normalized, camelcased property names to a configuration that
1786   * specifies how the associated DOM property should be accessed or rendered.
1787   */
1788  MUST_USE_PROPERTY: 0x1,
1789  HAS_BOOLEAN_VALUE: 0x4,
1790  HAS_NUMERIC_VALUE: 0x8,
1791  HAS_POSITIVE_NUMERIC_VALUE: 0x10 | 0x8,
1792  HAS_OVERLOADED_BOOLEAN_VALUE: 0x20,
1793
1794  /**
1795   * Inject some specialized knowledge about the DOM. This takes a config object
1796   * with the following properties:
1797   *
1798   * isCustomAttribute: function that given an attribute name will return true
1799   * if it can be inserted into the DOM verbatim. Useful for data-* or aria-*
1800   * attributes where it's impossible to enumerate all of the possible
1801   * attribute names,
1802   *
1803   * Properties: object mapping DOM property name to one of the
1804   * DOMPropertyInjection constants or null. If your attribute isn't in here,
1805   * it won't get written to the DOM.
1806   *
1807   * DOMAttributeNames: object mapping React attribute name to the DOM
1808   * attribute name. Attribute names not specified use the **lowercase**
1809   * normalized name.
1810   *
1811   * DOMAttributeNamespaces: object mapping React attribute name to the DOM
1812   * attribute namespace URL. (Attribute names not specified use no namespace.)
1813   *
1814   * DOMPropertyNames: similar to DOMAttributeNames but for DOM properties.
1815   * Property names not specified use the normalized name.
1816   *
1817   * DOMMutationMethods: Properties that require special mutation methods. If
1818   * `value` is undefined, the mutation method should unset the property.
1819   *
1820   * @param {object} domPropertyConfig the config as described above.
1821   */
1822  injectDOMPropertyConfig: function (domPropertyConfig) {
1823    var Injection = DOMPropertyInjection;
1824    var Properties = domPropertyConfig.Properties || {};
1825    var DOMAttributeNamespaces = domPropertyConfig.DOMAttributeNamespaces || {};
1826    var DOMAttributeNames = domPropertyConfig.DOMAttributeNames || {};
1827    var DOMPropertyNames = domPropertyConfig.DOMPropertyNames || {};
1828    var DOMMutationMethods = domPropertyConfig.DOMMutationMethods || {};
1829
1830    if (domPropertyConfig.isCustomAttribute) {
1831      DOMProperty._isCustomAttributeFunctions.push(domPropertyConfig.isCustomAttribute);
1832    }
1833
1834    for (var propName in Properties) {
1835      !!DOMProperty.properties.hasOwnProperty(propName) ? process.env.NODE_ENV !== '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;
1836
1837      var lowerCased = propName.toLowerCase();
1838      var propConfig = Properties[propName];
1839
1840      var propertyInfo = {
1841        attributeName: lowerCased,
1842        attributeNamespace: null,
1843        propertyName: propName,
1844        mutationMethod: null,
1845
1846        mustUseProperty: checkMask(propConfig, Injection.MUST_USE_PROPERTY),
1847        hasBooleanValue: checkMask(propConfig, Injection.HAS_BOOLEAN_VALUE),
1848        hasNumericValue: checkMask(propConfig, Injection.HAS_NUMERIC_VALUE),
1849        hasPositiveNumericValue: checkMask(propConfig, Injection.HAS_POSITIVE_NUMERIC_VALUE),
1850        hasOverloadedBooleanValue: checkMask(propConfig, Injection.HAS_OVERLOADED_BOOLEAN_VALUE)
1851      };
1852      !(propertyInfo.hasBooleanValue + propertyInfo.hasNumericValue + propertyInfo.hasOverloadedBooleanValue <= 1) ? process.env.NODE_ENV !== '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;
1853
1854      if (process.env.NODE_ENV !== 'production') {
1855        DOMProperty.getPossibleStandardName[lowerCased] = propName;
1856      }
1857
1858      if (DOMAttributeNames.hasOwnProperty(propName)) {
1859        var attributeName = DOMAttributeNames[propName];
1860        propertyInfo.attributeName = attributeName;
1861        if (process.env.NODE_ENV !== 'production') {
1862          DOMProperty.getPossibleStandardName[attributeName] = propName;
1863        }
1864      }
1865
1866      if (DOMAttributeNamespaces.hasOwnProperty(propName)) {
1867        propertyInfo.attributeNamespace = DOMAttributeNamespaces[propName];
1868      }
1869
1870      if (DOMPropertyNames.hasOwnProperty(propName)) {
1871        propertyInfo.propertyName = DOMPropertyNames[propName];
1872      }
1873
1874      if (DOMMutationMethods.hasOwnProperty(propName)) {
1875        propertyInfo.mutationMethod = DOMMutationMethods[propName];
1876      }
1877
1878      DOMProperty.properties[propName] = propertyInfo;
1879    }
1880  }
1881};
1882
1883/* eslint-disable max-len */
1884var ATTRIBUTE_NAME_START_CHAR = ':A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u

1884037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD';
1885/* eslint-enable max-len */
1886
1887/**
1888 * DOMProperty exports lookup objects that can be used like functions:
1889 *
1890 *   > DOMProperty.isValid['id']
1891 *   true
1892 *   > DOMProperty.isValid['foobar']
1893 *   undefined
1894 *
1895 * Although this may be confusing, it performs better in general.
1896 *
1897 * @see http://jsperf.com/key-exists
1898 * @see http://jsperf.com/key-missing
1899 */
1900var DOMProperty = {
1901
1902  ID_ATTRIBUTE_NAME: 'data-reactid',
1903  ROOT_ATTRIBUTE_NAME: 'data-reactroot',
1904
1905  ATTRIBUTE_NAME_START_CHAR: ATTRIBUTE_NAME_START_CHAR,
1906  ATTRIBUTE_NAME_CHAR: ATTRIBUTE_NAME_START_CHAR + '\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040',
1907
1908  /**
1909   * Map from property "standard name" to an object with info about how to set
1910   * the property in the DOM. Each object contains:
1911   *
1912   * attributeName:
1913   *   Used when rendering markup or with `*Attribute()`.
1914   * attributeNamespace
1915   * propertyName:
1916   *   Used on DOM node instances. (This includes properties that mutate due to
1917   *   external factors.)
1918   * mutationMethod:
1919   *   If non-null, used instead of the property or `setAttribute()` after
1920   *   initial render.
1921   * mustUseProperty:
1922   *   Whether the property must be accessed and mutated as an object property.
1923   * hasBooleanValue:
1924   *   Whether the property should be removed when set to a falsey value.
1925   * hasNumericValue:
1926   *   Whether the property must be numeric or parse as a numeric and should be
1927   *   removed when set to a falsey value.
1928   * hasPositiveNumericValue:
1929   *   Whether the property must be positive numeric or parse as a positive
1930   *   numeric and should be removed when set to a falsey value.
1931   * hasOverloadedBooleanValue:
1932   *   Whether the property can be used as a flag as well as with a value.
1933   *   Removed when strictly equal to false; present without a value when
1934   *   strictly equal to true; present with a value otherwise.
1935   */
1936  properties: {},
1937
1938  /**
1939   * Mapping from lowercase property names to the properly cased version, used
1940   * to warn in the case of missing properties. Available only in __DEV__.
1941   *
1942   * autofocus is predefined, because adding it to the property whitelist
1943   * causes unintended side effects.
1944   *
1945   * @type {Object}
1946   */
1947  getPossibleStandardName: process.env.NODE_ENV !== 'production' ? { autofocus: 'autoFocus' } : null,
1948
1949  /**
1950   * All of the isCustomAttribute() functions that have been injected.
1951   */
1952  _isCustomAttributeFunctions: [],
1953
1954  /**
1955   * Checks whether a property name is a custom attribute.
1956   * @method
1957   */
1958  isCustomAttribute: function (attributeName) {
1959    for (var i = 0; i < DOMProperty._isCustomAttributeFunctions.length; i++) {
1960      var isCustomAttributeFn = DOMProperty._isCustomAttributeFunctions[i];
1961      if (isCustomAttributeFn(attributeName)) {
1962        return true;
1963      }
1964    }
1965    return false;
1966  },
1967
1968  injection: DOMPropertyInjection
1969};
1970
1971module.exports = DOMProperty;
1972/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
1973
1974/***/ }),
1975/* 14 */
1976/***/ (function(module, exports, __webpack_require__) {
1977
1978"use strict";
1979/* WEBPACK VAR INJECTION */(function(process) {/**
1980 * Copyright 2013-present, Facebook, Inc.
1981 * All rights reserved.
1982 *
1983 * This source code is licensed under the BSD-style license found in the
1984 * LICENSE file in the root directory of this source tree. An additional grant
1985 * of patent rights can be found in the PATENTS file in the same directory.
1986 *
1987 * 
1988 */
1989
1990
1991
1992var _prodInvariant = __webpack_require__(3);
1993
1994var invariant = __webpack_require__(1);
1995
1996/**
1997 * Static poolers. Several custom versions for each potential number of
1998 * arguments. A completely generic pooler is easy to implement, but would
1999 * require accessing the `arguments` object. In each of these, `this` refers to
2000 * the Class itself, not an instance. If any others are needed, simply add them

2001 * here, or in their own files.
2002 */
2003var oneArgumentPooler = function (copyFieldsFrom) {
2004  var Klass = this;
2005  if (Klass.instancePool.length) {
2006    var instance = Klass.instancePool.pop();
2007    Klass.call(instance, copyFieldsFrom);
2008    return instance;
2009  } else {
2010    return new Klass(copyFieldsFrom);
2011  }
2012};
2013
2014var twoArgumentPooler = function (a1, a2) {
2015  var Klass = this;
2016  if (Klass.instancePool.length) {
2017    var instance = Klass.instancePool.pop();
2018    Klass.call(instance, a1, a2);
2019    return instance;
2020  } else {
2021    return new Klass(a1, a2);
2022  }
2023};
2024
2025var threeArgumentPooler = function (a1, a2, a3) {
2026  var Klass = this;
2027  if (Klass.instancePool.length) {
2028    var instance = Klass.instancePool.pop();
2029    Klass.call(instance, a1, a2, a3);
2030    return instance;
2031  } else {
2032    return new Klass(a1, a2, a3);
2033  }
2034};
2035
2036var fourArgumentPooler = function (a1, a2, a3, a4) {
2037  var Klass = this;
2038  if (Klass.instancePool.length) {
2039    var instance = Klass.instancePool.pop();
2040    Klass.call(instance, a1, a2, a3, a4);
2041    return instance;
2042  } else {
2043    return new Klass(a1, a2, a3, a4);
2044  }
2045};
2046
2047var standardReleaser = function (instance) {
2048  var Klass = this;
2049  !(instance instanceof Klass) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Trying to release an instance into a pool of a different type.') : _prodInvariant('25') : void 0;
2050  instance.destructor();
2051  if (Klass.instancePool.length < Klass.poolSize) {
2052    Klass.instancePool.push(instance);
2053  }
2054};
2055
2056var DEFAULT_POOL_SIZE = 10;
2057var DEFAULT_POOLER = oneArgumentPooler;
2058
2059/**
2060 * Augments `CopyConstructor` to be a poolable class, augmenting only the class
2061 * itself (statically) not adding any prototypical fields. Any CopyConstructor
2062 * you give this may have a `poolSize` property, and will look for a
2063 * prototypical `destructor` on instances.
2064 *
2065 * @param {Function} CopyConstructor Constructor that can be used to reset.
2066 * @param {Function} pooler Customizable pooler.
2067 */
2068var addPoolingTo = function (CopyConstructor, pooler) {
2069  // Casting as any so that flow ignores the actual implementation and trusts
2070  // it to match the type we declared
2071  var NewKlass = CopyConstructor;
2072  NewKlass.instancePool = [];
2073  NewKlass.getPooled = pooler || DEFAULT_POOLER;
2074  if (!NewKlass.poolSize) {
2075    NewKlass.poolSize = DEFAULT_POOL_SIZE;
2076  }
2077  NewKlass.release = standardReleaser;
2078  return NewKlass;
2079};
2080
2081var PooledClass = {
2082  addPoolingTo: addPoolingTo,
2083  oneArgumentPooler: oneArgumentPooler,
2084  twoArgumentPooler: twoArgumentPooler,
2085  threeArgumentPooler: threeArgumentPooler,
2086  fourArgumentPooler: fourArgumentPooler
2087};
2088
2089module.exports = PooledClass;
2090/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
2091
2092/***/ }),
2093/* 15 */
2094/***/ (function(module, exports, __webpack_require__) {
2095
2096"use strict";
2097/* WEBPACK VAR INJECTION */(function(process) {/**
2098 * Copyright 2014-present, Facebook, Inc.
2099 * All rights reserved.
2100 *
2101 * This source code is licensed under the BSD-style license found in the
2102 * LICENSE file in the root directory of this source tree. An additional grant
2103 * of patent rights can be found in the PATENTS file in the same directory.
2104 *
2105 */
2106
2107
2108
2109var _assign = __webpack_require__(4);
2110
2111var ReactCurrentOwner = __webpack_require__(11);
2112
2113var warning = __webpack_require__(2);
2114var canDefineProperty = __webpack_require__(32);
2115var hasOwnProperty = Object.prototype.hasOwnProperty;
2116
2117var REACT_ELEMENT_TYPE = __webpack_require__(77);
2118
2119var RESERVED_PROPS = {
2120  key: true,
2121  ref: true,
2122  __self: true,
2123  __source: true
2124};
2125
2126var specialPropKeyWarningShown, specialPropRefWarningShown;
2127
2128function hasValidRef(config) {
2129  if (process.env.NODE_ENV !== 'production') {
2130    if (hasOwnProperty.call(config, 'ref')) {
2131      var getter = Object.getOwnPropertyDescriptor(config, 'ref').get;
2132      if (getter && getter.isReactWarning) {
2133        return false;
2134      }
2135    }
2136  }
2137  return config.ref !== undefined;
2138}
2139
2140function hasValidKey(config) {
2141  if (process.env.NODE_ENV !== 'production') {
2142    if (hasOwnProperty.call(config, 'key')) {
2143      var getter = Object.getOwnPropertyDescriptor(config, 'key').get;
2144      if (getter && getter.isReactWarning) {
2145        return false;

2146      }
2147    }
2148  }
2149  return config.key !== undefined;
2150}
2151
2152function defineKeyPropWarningGetter(props, displayName) {
2153  var warnAboutAccessingKey = function () {
2154    if (!specialPropKeyWarningShown) {
2155      specialPropKeyWarningShown = true;
2156      process.env.NODE_ENV !== '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;
2157    }
2158  };
2159  warnAboutAccessingKey.isReactWarning = true;
2160  Object.defineProperty(props, 'key', {
2161    get: warnAboutAccessingKey,
2162    configurable: true
2163  });
2164}
2165
2166function defineRefPropWarningGetter(props, displayName) {
2167  var warnAboutAccessingRef = function () {
2168    if (!specialPropRefWarningShown) {
2169      specialPropRefWarningShown = true;
2170      process.env.NODE_ENV !== '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;
2171    }
2172  };
2173  warnAboutAccessingRef.isReactWarning = true;
2174  Object.defineProperty(props, 'ref', {
2175    get: warnAboutAccessingRef,
2176    configurable: true
2177  });
2178}
2179
2180/**
2181 * Factory method to create a new React element. This no longer adheres to
2182 * the class pattern, so do not use new to call it. Also, no instanceof check
2183 * will work. Instead test $$typeof field against Symbol.for('react.element') to check
2184 * if something is a React Element.
2185 *
2186 * @param {*} type
2187 * @param {*} key
2188 * @param {string|object} ref
2189 * @param {*} self A *temporary* helper to detect places where `this` is
2190 * different from the `owner` when React.createElement is called, so that we
2191 * can warn. We want to get rid of owner and replace string `ref`s with arrow
2192 * functions, and as long as `this` and owner are the same, there will be no
2193 * change in behavior.
2194 * @param {*} source An annotation object (added by a transpiler or otherwise)
2195 * indicating filename, line number, and/or other information.
2196 * @param {*} owner
2197 * @param {*} props
2198 * @internal
2199 */
2200var ReactElement = function (type, key, ref, self, source, owner, props) {
2201  var element = {
2202    // This tag allow us to uniquely identify this as a React Element
2203    $$typeof: REACT_ELEMENT_TYPE,
2204
2205    // Built-in properties that belong on the element
2206    type: type,
2207    key: key,
2208    ref: ref,
2209    props: props,
2210
2211    // Record the component responsible for creating this element.
2212    _owner: owner
2213  };
2214
2215  if (process.env.NODE_ENV !== 'production') {
2216    // The validation flag is currently mutative. We put it on
2217    // an external backing store so that we can freeze the whole object.
2218    // This can be replaced with a WeakMap once they are implemented in
2219    // commonly used development environments.
2220    element._store = {};
2221
2222    // To make comparing ReactElements easier for testing purposes, we make
2223    // the validation flag non-enumerable (where possible, which should
2224    // include every environment we run tests in), so the test framework
2225    // ignores it.
2226    if (canDefineProperty) {
2227      Object.defineProperty(element._store, 'validated', {
2228        configurable: false,
2229        enumerable: false,
2230        writable: true,
2231        value: false
2232      });
2233      // self and source are DEV only properties.
2234      Object.defineProperty(element, '_self', {
2235        configurable: false,
2236        enumerable: false,
2237        writable: false,
2238        value: self
2239      });
2240      // Two elements created in two different places should be considered
2241      // equal for testing purposes and therefore we hide it from enumeration.
2242      Object.defineProperty(element, '_source', {
2243        configurable: false,
2244        enumerable: false,
2245        writable: false,
2246        value: source
2247      });
2248    } else {
2249      element._store.validated = false;
2250      element._self = self;
2251      element._source = source;
2252    }
2253    if (Object.freeze) {
2254      Object.freeze(element.props);
2255      Object.freeze(element);
2256    }
2257  }
2258
2259  return element;
2260};
2261
2262/**
2263 * Create and return a new ReactElement of the given type.
2264 * See https://facebook.github.io/react/docs/top-level-api.html#react.createelement
2265 */
2266ReactElement.createElement = function (type, config, children) {
2267  var propName;
2268
2269  // Reserved names are extracted
2270  var props = {};
2271
2272  var key = null;
2273  var ref = null;
2274  var self = null;
2275  var source = null;
2276
2277  if (config != null) {
2278    if (hasValidRef(config)) {
2279      ref = config.ref;
2280    }
2281    if (hasValidKey(config)) {
2282      key = '' + config.key;
2283    }
2284
2285    self = config.__self === undefined ? null : config.__self;
2286    source = config.__source === undefined ? null : config.__source;
2287    // Remaining properties are added to a new props object
2288    for (propName in config) {
2289      if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
2290        props[propName] = config[propName];
2291      }
2292    }
2293  }
2294
2295  // Children can be more than one argument, and those are transferred onto
2296  // the newly allocated props object.
2297  var childrenLength = arguments.length - 2;
2298  if (childrenLength === 1) {
2299    props.children = children;
2300  } else if (childrenLength > 1) {
2301    var childArray = Array(childrenLength);
2302    for (var i = 0; i < childrenLength; i++) {
2303      childArray[i] = arguments[i + 2];
2304    }
2305    if (process.env.NODE_ENV !== 'production') {
2306      if (Object.freeze) {
2307        Object.freeze(childArray);
2308      }
2309    }
2310    props.children = childArray;
2311  }
2312
2313  // Resolve default props
2314  if (type && type.defaultProps) {
2315    var defaultProps = type.defaultProps;
2316    for (propName in defaultProps) {
2317      if (props[propName] === undefined) {
2318        props[propName] = defaultProps[propName];
2319      }
2320    }
2321  }
2322  if (process.env.NODE_ENV !== 'production') {
2323    if (key || ref) {
2324      if (typeof props.$$typeof === 'undefined' || props.$$typeof !== REACT_ELEMENT_TYPE) {
2325        var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type;
2326        if (key) {
2327          defineKeyPropWarningGetter(props, displayName);
2328        }
2329        if (ref) {
2330          defineRefPropWarningGetter(props, displayName);
2331        }
2332      }
2333    }
2334  }
2335  return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
2336};
2337
2338/**
2339 * Return a function that produces ReactElements of a given type.
2340 * See https://facebook.github.io/react/docs/top-level-api.html#react.createfactory
2341 */
2342ReactElement.createFactory = function (type) {
2343  var factory = ReactElement.createElement.bind(null, type);
2344  // Expose the type on the factory and the prototype so that it can be
2345  // easily accessed on elements. E.g. `<Foo />.type === Foo`.
2346  // This should not be named `constructor` since this may not be the function
2347  // that created the element, and it may not even be a constructor.
2348  // Legacy hook TODO: Warn if this is accessed
2349  factory.type = type;
2350  return factory;
2351};
2352
2353ReactElement.cloneAndReplaceKey = function (oldElement, newKey) {
2354  var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props);
2355
2356  return newElement;
2357};
2358
2359/**
2360 * Clone and return a new ReactElement using element as the starting point.
2361 * See https://facebook.github.io/react/docs/top-level-api.html#react.cloneelement
2362 */
2363ReactElement.cloneElement = function (element, config, children) {
2364  var propName;
2365
2366  // Original props are copied
2367  var props = _assign({}, element.props);
2368
2369  // Reserved names are extracted
2370  var key = element.key;
2371  var ref = element.ref;
2372  // Self is preserved since the owner is preserved.
2373  var self = element._self;
2374  // Source is preserved since cloneElement is unlikely to be targeted by a
2375  // transpiler, and the original source is probably a better indicator of the
2376  // true owner.
2377  var source = element._source;
2378
2379  // Owner will be preserved, unless ref is overridden
2380  var owner = element._owner;
2381
2382  if (config != null) {
2383    if (hasValidRef(config)) {
2384      // Silently steal the ref from the parent.
2385      ref = config.ref;
2386      owner = ReactCurrentOwner.current;
2387    }
2388    if (hasValidKey(config)) {
2389      key = '' + config.key;
2390    }
2391
2392    // Remaining properties override existing props
2393    var defaultProps;
2394    if (element.type && element.type.defaultProps) {
2395      defaultProps = element.type.defaultProps;
2396    }
2397    for (propName in config) {
2398      if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
2399        if (config[propName] === undefined && defaultProps !== undefined) {
2400          // Resolve default props
2401          props[propName] = defaultProps[propName];
2402        } else {
2403          props[propName] = config[propName];
2404        }
2405      }
2406    }
2407  }
2408
2409  // Children can be more than one argument, and those are transferred onto
2410  // the newly allocated props object.
2411  var childrenLength = arguments.length - 2;
2412  if (childrenLength === 1) {
2413    props.children = children;
2414  } else if (childrenLength > 1) {
2415    var childArray = Array(childrenLength);
2416    for (var i = 0; i < childrenLength; i++) {
2417      childArray[i] = arguments[i + 2];
2418    }
2419    props.children = childArray;
2420  }
2421
2422  return ReactElement(element.type, key, ref, self, source, owner, props);
2423};
2424
2425/**
2426 * Verifies the object is a ReactElement.
2427 * See https://facebook.github.io/react/docs/top-level-api.html#react.isvali

2427delement
2428 * @param {?object} object
2429 * @return {boolean} True if `object` is a valid component.
2430 * @final
2431 */
2432ReactElement.isValidElement = function (object) {
2433  return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
2434};
2435
2436module.exports = ReactElement;
2437/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
2438
2439/***/ }),
2440/* 16 */
2441/***/ (function(module, exports, __webpack_require__) {
2442
2443"use strict";
2444/**
2445 * Copyright (c) 2013-present, Facebook, Inc.
2446 * All rights reserved.
2447 *
2448 * This source code is licensed under the BSD-style license found in the
2449 * LICENSE file in the root directory of this source tree. An additional grant
2450 * of patent rights can be found in the PATENTS file in the same directory.
2451 *
2452 * 
2453 */
2454
2455
2456/**
2457 * WARNING: DO NOT manually require this module.
2458 * This is a replacement for `invariant(...)` used by the error code system
2459 * and will _only_ be required by the corresponding babel pass.
2460 * It always throws.
2461 */
2462
2463function reactProdInvariant(code) {
2464  var argCount = arguments.length - 1;
2465
2466  var message = 'Minified React error #' + code + '; visit ' + 'http://facebook.github.io/react/docs/error-decoder.html?invariant=' + code;
2467
2468  for (var argIdx = 0; argIdx < argCount; argIdx++) {
2469    message += '&args[]=' + encodeURIComponent(arguments[argIdx + 1]);
2470  }
2471
2472  message += ' for the full message or use the non-minified dev environment' + ' for full errors and additional helpful warnings.';
2473
2474  var error = new Error(message);
2475  error.name = 'Invariant Violation';
2476  error.framesToPop = 1; // we don't care about reactProdInvariant's own frame
2477
2478  throw error;
2479}
2480
2481module.exports = reactProdInvariant;
2482
2483/***/ }),
2484/* 17 */
2485/***/ (function(module, exports, __webpack_require__) {
2486
2487"use strict";
2488/**
2489 * Copyright 2015-present, Facebook, Inc.
2490 * All rights reserved.
2491 *
2492 * This source code is licensed under the BSD-style license found in the
2493 * LICENSE file in the root directory of this source tree. An additional grant
2494 * of patent rights can be found in the PATENTS file in the same directory.
2495 *
2496 */
2497
2498
2499
2500var DOMNamespaces = __webpack_require__(35);
2501var setInnerHTML = __webpack_require__(31);
2502
2503var createMicrosoftUnsafeLocalFunction = __webpack_require__(42);
2504var setTextContent = __webpack_require__(75);
2505
2506var ELEMENT_NODE_TYPE = 1;
2507var DOCUMENT_FRAGMENT_NODE_TYPE = 11;
2508
2509/**
2510 * In IE (8-11) and Edge, appending nodes with no children is dramatically
2511 * faster than appending a full subtree, so we essentially queue up the
2512 * .appendChild calls here and apply them so each node is added to its parent
2513 * before any children are added.
2514 *
2515 * In other browsers, doing so is slower or neutral compared to the other order
2516 * (in Firefox, twice as slow) so we only do this inversion in IE.
2517 *
2518 * See https://github.com/spicyj/innerhtml-vs-createelement-vs-clonenode.
2519 */
2520var enableLazy = typeof document !== 'undefined' && typeof document.documentMode === 'number' || typeof navigator !== 'undefined' && typeof navigator.userAgent === 'string' && /\bEdge\/\d/.test(navigator.userAgent);
2521
2522function insertTreeChildren(tree) {
2523  if (!enableLazy) {
2524    return;
2525  }
2526  var node = tree.node;
2527  var children = tree.children;
2528  if (children.length) {
2529    for (var i = 0; i < children.length; i++) {
2530      insertTreeBefore(node, children[i], null);
2531    }
2532  } else if (tree.html != null) {
2533    setInnerHTML(node, tree.html);
2534  } else if (tree.text != null) {
2535    setTextContent(node, tree.text);
2536  }
2537}
2538
2539var insertTreeBefore = createMicrosoftUnsafeLocalFunction(function (parentNode, tree, referenceNode) {
2540  // DocumentFragments aren't actually part of the DOM after insertion so
2541  // appending children won't update the DOM. We need to ensure the fragment
2542  // is properly populated first, breaking out of our lazy approach for just
2543  // this level. Also, some <object> plugins (like Flash Player) will read
2544  // <param> nodes immediately upon insertion into the DOM, so <object>
2545  // must also be populated prior to insertion into the DOM.
2546  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)) {
2547    insertTreeChildren(tree);
2548    parentNode.insertBefore(tree.node, referenceNode);
2549  } else {
2550    parentNode.insertBefore(tree.node, referenceNode);
2551    insertTreeChildren(tree);
2552  }
2553});
2554
2555function replaceChildWithTree(oldNode, newTree) {
2556  oldNode.parentNode.replaceChild(newTree.node, oldNode);
2557  insertTreeChildren(newTree);
2558}
2559
2560function queueChild(parentTree, childTree) {
2561  if (enableLazy) {
2562    parentTree.children.push(childTree);
2563  } else {
2564    parentTree.node.appendChild(childTree.node);
2565  }
2566}
2567
2568function queueHTML(tree, html) {
2569  if (enableLazy) {
2570    tree.html = html;
2571  } else {
2572    setInnerHTML(tree.node, html);
2573  }
2574}
2575
2576function queueText(tree, text) {
2577  if (enableLazy) {
2578    tree.text = text;
2579  } else {
2580    setTextContent(tree.node, text);
2581  }
2582}
2583
2584function toString() {
2585  return this.node.nodeName;
2586}
2587
2588function DOMLazyTree(node) {
2589  return {
2590    node: node,
2591    children: [],
2592    html: null,
2593    text: null,
2594    toString: toString
2595  };
2596}
2597
2598DOMLazyTree.insertTreeBefore = insertTreeBefore;
2599DOMLazyTree.replaceChildWithTree = replaceChildWithTree;
2600DOMLazyTree.queueChild = queueChild;
2601DOMLazyTree.queueHTML = queueHTML;
2602DOMLazyTree.queueText = queueText;
2603
2604module.exports = DOMLazyTree;
2605
2606/***/ }),
2607/* 18 */
2608/***/ (function(module, exports, __webpack_require__) {
2609
2610"use strict";
2611/* WEBPACK VAR INJECTION */(function(process) {/**
2612 * Copyright 2013-present, Facebook, Inc.
2613 * All rights reserved.
2614 *
2615 * This source code is licensed under the BSD-style license found in the
2616 * LICENSE file in the root directory of this source tree. An additional grant
2617 * of patent rights can be found in the PATENTS file in the same directory.
2618 *
2619 */
2620
2621
2622
2623var ReactRef = __webpack_require__(147);
2624var ReactInstrumentation = __webpack_require__(8);
2625
2626var warning = __webpack_require__(2);
2627
2628/**
2629 * Helper to call ReactRef.attachRefs with this composite component, split out
2630 * to avoid allocations in the transaction mount-ready queue.
2631 */
2632function attachRefs() {
2633  ReactRef.attachRefs(this, this._currentElement);
2634}
2635
2636var ReactReconciler = {
2637
2638  /**
2639   * Initializes the component, renders markup, and registers event listeners.
2640   *
2641   * @param {ReactComponent} internalInstance
2642   * @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction
2643   * @param {?object} the containing host component instance
2644   * @param {?object} info about the host container
2645   * @return {?string} Rendered markup to be inserted into the DOM.
2646   * @final
2647   * @internal
2648   */
2649  mountComponent: function (internalInstance, transaction, hostParent, hostContainerInfo, context, parentDebugID // 0 in production and for roots
2650  ) {
2651    if (process.env.NODE_ENV !== 'production') {
2652      if (internalInstance._debugID !== 0) {
2653        ReactInstrumentation.debugTool.onBeforeMountComponent(internalInstance._debugID, internalInstance._currentElement, parentDebugID);
2654      }
2655    }
2656    var markup = internalInstance.mountComponent(transaction, hostParent, hostContainerInfo, context, parentDebugID);
2657    if (internalInstance._currentElement && internalInstance._currentElement.ref != null) {
2658      transaction.getReactMountReady().enqueue(attachRefs, internalInstance);
2659    }
2660    if (process.env.NODE_ENV !== 'production') {
2661      if (internalInstance._debugID !== 0) {
2662        ReactInstrumentation.debugTool.onMountComponent(internalInstance._debugID);
2663      }
2664    }
2665    return markup;
2666  },
2667
2668  /**
2669   * Returns a value that can be passed to
2670   * ReactComponentEnvironment.replaceNodeWithMarkup.
2671   */
2672  getHostNode: function (internalInstance) {
2673    return internalInstance.getHostNode();
2674  },
2675
2676  /**
2677   * Releases any resources allocated by `mountComponent`.
2678   *
2679   * @final
2680   * @internal
2681   */
2682  unmountComponent: function (internalInstance, safely) {
2683    if (process.env.NODE_ENV !== 'production') {
2684      if (internalInstance._debugID !== 0) {
2685        ReactInstrumentation.debugTool.onBeforeUnmountComponent(internalInstance._debugID);
2686      }
2687    }
2688    ReactRef.detachRefs(internalInstance, internalInstance._currentElement);
2689    internalInstance.unmountComponent(safely);
2690    if (process.env.NODE_ENV !== 'production') {
2691      if (internalInstance._debugID !== 0) {
2692        ReactInstrumentation.debugTool.onUnmountComponent(internalInstance._debugID);
2693      }
2694    }
2695  },
2696
2697  /**
2698   * Update a component using a new element.
2699   *
2700   * @param {ReactComponent} internalInstance
2701   * @param {ReactElement} nextElement
2702   * @param {ReactReconcileTransaction} transaction
2703   * @param {object} context
2704   * @internal
2705   */
2706  receiveComponent: function (internalInstance, nextElement, transaction, context) {
2707    var prevElement = internalInstance._currentElement;
2708
2709    if (nextElement === prevElement && context === internalInstance._context) {
2710      // Since elements are immutable after the owner is rendered,
2711      // we can do a cheap identity compare here to determine if this is a
2712      // superfluous reconcile. It's possible for state to be mutable but such
2713      // change should trigger an update of the owner which would recreate
2714      // the element. We explicitly check for the existence of an owner since
2715      // it's possible for an element created outside a composite to be
2716      // deeply mutated and reused.
2717
2718      // TODO: Bailing out early is just a perf optimization right?
2719      // TODO: Removing the return statement should affect correctness?
2720      return;
2721    }
2722
2723    if (process.env.NODE_ENV !== 'production') {
2724      if (internalInstance._debugID !== 0) {
2725        ReactInstrumentation.debugTool.onBeforeUpdateComponent(internalInstance._debugID, nextElement);
2726      }
2727    }
2728
2729    var refsChanged = ReactRef.shouldUpdateRefs(prevElement, nextElement);
2730
2731    if (refsChanged) {
2732      ReactRef.detachRefs(internalInstance, prevElement);
2733    }
2734
2735    internalInstance.receiveComponent(nextElement, transaction, context);
2736
2737    if (refsChanged && internalInstance._currentElement && internalInstance._currentElement.ref != null) {
2738      transaction.getReactMountReady().enqueue(attachRefs, internalInstance);
2739    }
2740
2741    if (process.env.NODE_ENV !== 'production') {
2742      if (internalInstance._debugID !== 0) {
2743        ReactInstrumentation.debugTool.onUpdateComponent(internalInstance._debugID);
2744      }
2745    }
2746  },
2747
2748  /**
2749   * Flush any dirty changes in a component.
2750   *
2751   * @param {ReactComponent} internalInstance
2752   * @param {ReactReconcileTransaction} transaction
2753   * @internal
2754   */
2755  performUpdateIfNecessary: function (internalInstance, transaction, updateBatchNumber) {
2756    if (internalInstance._updateBatchNumber !== updateBatchNumber) {
2757      // The component's enqueued batch number should always be the current
2758      // batch or the following one.
2759      process.env.NODE_ENV !== 'production' ? warning(internalInstance._updateBatchNumber == null || internalInstance._updateBatchNumber === updateBatchNumber + 1, 'performUpdateIfNecessary: Unexpected batch number (current %s, ' + 'pending