diff --git a/bundle.js b/bundle.js index b3683ab..c98a1de 100644 --- a/bundle.js +++ b/bundle.js @@ -1,5 +1,6024 @@ -!function(e){function t(o){if(n[o])return n[o].exports;var r=n[o]={i:o,l:!1,exports:{}};return e[o].call(r.exports,r,r.exports,t),r.l=!0,r.exports}var n={};return t.m=e,t.c=n,t.i=function(e){return e},t.d=function(e,t,n){Object.defineProperty(e,t,{configurable:!1,enumerable:!0,get:n})},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p="",t(t.s=90)}([function(e,t){"use strict";function n(){p&&l&&(p=!1,l.length?c=l.concat(c):d=-1,c.length&&o())}function o(){if(!p){var e=a(n);p=!0;for(var t=c.length;t;){for(l=c,c=[];++d1)for(var n=1;n2?n-2:0),r=2;r1){for(var y=Array(g),E=0;E1){for(var y=Array(g),E=0;E-1?void 0:"production"!==t.env.NODE_ENV?a(!1,"EventPluginRegistry: Cannot inject event plugins that do not exist in the plugin ordering, `%s`.",e):a(!1),!l.plugins[o]){n.extractEvents?void 0:"production"!==t.env.NODE_ENV?a(!1,"EventPluginRegistry: Event plugins must implement an `extractEvents` method, but `%s` does not.",e):a(!1),l.plugins[o]=n;var i=n.eventTypes;for(var c in i)r(i[c],n,c)?void 0:"production"!==t.env.NODE_ENV?a(!1,"EventPluginRegistry: Failed to publish event `%s` for plugin `%s`.",c,e):a(!1)}}}function r(e,n,o){l.eventNameDispatchConfigs.hasOwnProperty(o)?"production"!==t.env.NODE_ENV?a(!1,"EventPluginHub: More than one plugin attempted to publish the same event name, `%s`.",o):a(!1):void 0,l.eventNameDispatchConfigs[o]=e;var r=e.phasedRegistrationNames;if(r){for(var u in r)if(r.hasOwnProperty(u)){var s=r[u];i(s,n,o)}return!0}return!!e.registrationName&&(i(e.registrationName,n,o),!0)}function i(e,n,o){if(l.registrationNameModules[e]?"production"!==t.env.NODE_ENV?a(!1,"EventPluginHub: More than one plugin attempted to publish the same registration name, `%s`.",e):a(!1):void 0,l.registrationNameModules[e]=n,l.registrationNameDependencies[e]=n.eventTypes[o].dependencies,"production"!==t.env.NODE_ENV){var r=e.toLowerCase();l.possibleRegistrationNames[r]=e}}var a=n(1),u=null,s={},l={plugins:[],eventNameDispatchConfigs:{},registrationNameModules:{},registrationNameDependencies:{},possibleRegistrationNames:"production"!==t.env.NODE_ENV?{}:null,injectEventPluginOrder:function(e){u?"production"!==t.env.NODE_ENV?a(!1,"EventPluginRegistry: Cannot inject event plugin ordering more than once. You are likely trying to load more than one copy of React."):a(!1):void 0,u=Array.prototype.slice.call(e),o()},injectEventPluginsByName:function(e){var n=!1;for(var r in e)if(e.hasOwnProperty(r)){var i=e[r];s.hasOwnProperty(r)&&s[r]===i||(s[r]?"production"!==t.env.NODE_ENV?a(!1,"EventPluginRegistry: Cannot inject two different event plugins using the same name, `%s`.",r):a(!1):void 0,s[r]=i,n=!0)}n&&o()},getPluginModuleForEvent:function(e){var t=e.dispatchConfig;if(t.registrationName)return l.registrationNameModules[t.registrationName]||null;for(var n in t.phasedRegistrationNames)if(t.phasedRegistrationNames.hasOwnProperty(n)){var o=l.registrationNameModules[t.phasedRegistrationNames[n]];if(o)return o}return null},_resetEventPlugins:function(){u=null;for(var e in s)s.hasOwnProperty(e)&&delete s[e];l.plugins.length=0;var n=l.eventNameDispatchConfigs;for(var o in n)n.hasOwnProperty(o)&&delete n[o];var r=l.registrationNameModules;for(var i in r)r.hasOwnProperty(i)&&delete r[i];if("production"!==t.env.NODE_ENV){var a=l.possibleRegistrationNames;for(var c in a)a.hasOwnProperty(c)&&delete a[c]}}};e.exports=l}).call(t,n(0))},function(e,t,n){"use strict";function o(e){return Object.prototype.hasOwnProperty.call(e,m)||(e[m]=h++,d[e[m]]={}),d[e[m]]}var r,i=n(3),a=n(10),u=n(23),s=n(125),l=n(73),c=n(155),p=n(46),d={},f=!1,h=0,v={topAbort:"abort",topAnimationEnd:c("animationend")||"animationend",topAnimationIteration:c("animationiteration")||"animationiteration", -topAnimationStart:c("animationstart")||"animationstart",topBlur:"blur",topCanPlay:"canplay",topCanPlayThrough:"canplaythrough",topChange:"change",topClick:"click",topCompositionEnd:"compositionend",topCompositionStart:"compositionstart",topCompositionUpdate:"compositionupdate",topContextMenu:"contextmenu",topCopy:"copy",topCut:"cut",topDoubleClick:"dblclick",topDrag:"drag",topDragEnd:"dragend",topDragEnter:"dragenter",topDragExit:"dragexit",topDragLeave:"dragleave",topDragOver:"dragover",topDragStart:"dragstart",topDrop:"drop",topDurationChange:"durationchange",topEmptied:"emptied",topEncrypted:"encrypted",topEnded:"ended",topError:"error",topFocus:"focus",topInput:"input",topKeyDown:"keydown",topKeyPress:"keypress",topKeyUp:"keyup",topLoadedData:"loadeddata",topLoadedMetadata:"loadedmetadata",topLoadStart:"loadstart",topMouseDown:"mousedown",topMouseMove:"mousemove",topMouseOut:"mouseout",topMouseOver:"mouseover",topMouseUp:"mouseup",topPaste:"paste",topPause:"pause",topPlay:"play",topPlaying:"playing",topProgress:"progress",topRateChange:"ratechange",topScroll:"scroll",topSeeked:"seeked",topSeeking:"seeking",topSelectionChange:"selectionchange",topStalled:"stalled",topSuspend:"suspend",topTextInput:"textInput",topTimeUpdate:"timeupdate",topTouchCancel:"touchcancel",topTouchEnd:"touchend",topTouchMove:"touchmove",topTouchStart:"touchstart",topTransitionEnd:c("transitionend")||"transitionend",topVolumeChange:"volumechange",topWaiting:"waiting",topWheel:"wheel"},m="_reactListenersID"+String(Math.random()).slice(2),g=i({},s,{ReactEventListener:null,injection:{injectReactEventListener:function(e){e.setHandleTopLevel(g.handleTopLevel),g.ReactEventListener=e}},setEnabled:function(e){g.ReactEventListener&&g.ReactEventListener.setEnabled(e)},isEnabled:function(){return!(!g.ReactEventListener||!g.ReactEventListener.isEnabled())},listenTo:function(e,t){for(var n=t,r=o(n),i=u.registrationNameDependencies[e],s=a.topLevelTypes,l=0;l":">","<":"<",'"':""","'":"'"},i=/[&><"']/g;e.exports=o},function(e,t,n){"use strict";(function(t){var n={};"production"!==t.env.NODE_ENV&&Object.freeze(n),e.exports=n}).call(t,n(0))},function(e,t,n){"use strict";(function(t){var o=n(1),r=function(e){var n,r={};e instanceof Object&&!Array.isArray(e)?void 0:"production"!==t.env.NODE_ENV?o(!1,"keyMirror(...): Argument must be an object."):o(!1);for(n in e)e.hasOwnProperty(n)&&(r[n]=n);return r};e.exports=r}).call(t,n(0))},function(e,t,n){"use strict";(function(t){function o(e,t){return Array.isArray(t)&&(t=t[1]),t?t.nextSibling:e.firstChild}function r(e,t,n){c.insertTreeBefore(e,t,n)}function i(e,t,n){Array.isArray(t)?u(e,t[0],t[1],n):y(e,t,n)}function a(e,t){if(Array.isArray(t)){var n=t[1];t=t[0],s(e,t,n),e.removeChild(n)}e.removeChild(t)}function u(e,t,n,o){for(var r=t;;){var i=r.nextSibling;if(y(e,r,o),r===n)break;r=i}}function s(e,t,n){for(;;){var o=t.nextSibling;if(o===n)break;e.removeChild(o)}}function l(e,n,o){var r=e.parentNode,i=e.nextSibling;i===n?o&&y(r,document.createTextNode(o),i):o?(g(i,o),s(r,i,n)):s(r,e,n),"production"!==t.env.NODE_ENV&&h.debugTool.onNativeOperation(f.getInstanceFromNode(e)._debugID,"replace text",o)}var c=n(16),p=n(96),d=n(66),f=n(4),h=n(6),v=n(41),m=n(47),g=n(80),y=v(function(e,t,n){e.insertBefore(t,n)}),E=p.dangerouslyReplaceNodeWithMarkup;"production"!==t.env.NODE_ENV&&(E=function(e,t,n){if(p.dangerouslyReplaceNodeWithMarkup(e,t),0!==n._debugID)h.debugTool.onNativeOperation(n._debugID,"replace with",t.toString());else{var o=f.getInstanceFromNode(t.node);0!==o._debugID&&h.debugTool.onNativeOperation(o._debugID,"mount",t.toString())}});var b={dangerouslyReplaceNodeWithMarkup:E,replaceDelimitedText:l,processUpdates:function(e,n){if("production"!==t.env.NODE_ENV)var u=f.getInstanceFromNode(e)._debugID;for(var s=0;s=32||13===t?t:0}e.exports=n},function(e,t){"use strict";function n(e){var t=this,n=t.nativeEvent;if(n.getModifierState)return n.getModifierState(e);var o=r[e];return!!o&&!!n[o]}function o(e){return n}var r={Alt:"altKey",Control:"ctrlKey",Meta:"metaKey",Shift:"shiftKey"};e.exports=o},function(e,t){"use strict";function n(e){var t=e.target||e.srcElement||window;return t.correspondingUseElement&&(t=t.correspondingUseElement),3===t.nodeType?t.parentNode:t}e.exports=n},function(e,t){"use strict";function n(e){var t=e&&(o&&e[o]||e[r]);if("function"==typeof t)return t}var o="function"==typeof Symbol&&Symbol.iterator,r="@@iterator";e.exports=n},function(e,t,n){"use strict";/** +/******/ (function(modules) { // webpackBootstrap +/******/ // The module cache +/******/ var installedModules = {}; +/******/ +/******/ // The require function +/******/ function __webpack_require__(moduleId) { +/******/ +/******/ // Check if module is in cache +/******/ if(installedModules[moduleId]) { +/******/ return installedModules[moduleId].exports; +/******/ } +/******/ // Create a new module (and put it into the cache) +/******/ var module = installedModules[moduleId] = { +/******/ i: moduleId, +/******/ l: false, +/******/ exports: {} +/******/ }; +/******/ +/******/ // Execute the module function +/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); +/******/ +/******/ // Flag the module as loaded +/******/ module.l = true; +/******/ +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } +/******/ +/******/ +/******/ // expose the modules object (__webpack_modules__) +/******/ __webpack_require__.m = modules; +/******/ +/******/ // expose the module cache +/******/ __webpack_require__.c = installedModules; +/******/ +/******/ // define getter function for harmony exports +/******/ __webpack_require__.d = function(exports, name, getter) { +/******/ if(!__webpack_require__.o(exports, name)) { +/******/ Object.defineProperty(exports, name, { +/******/ configurable: false, +/******/ enumerable: true, +/******/ get: getter +/******/ }); +/******/ } +/******/ }; +/******/ +/******/ // getDefaultExport function for compatibility with non-harmony modules +/******/ __webpack_require__.n = function(module) { +/******/ var getter = module && module.__esModule ? +/******/ function getDefault() { return module['default']; } : +/******/ function getModuleExports() { return module; }; +/******/ __webpack_require__.d(getter, 'a', getter); +/******/ return getter; +/******/ }; +/******/ +/******/ // Object.prototype.hasOwnProperty.call +/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; +/******/ +/******/ // __webpack_public_path__ +/******/ __webpack_require__.p = ""; +/******/ +/******/ // Load entry module and return exports +/******/ return __webpack_require__(__webpack_require__.s = 18); +/******/ }) +/************************************************************************/ +/******/ ([ +/* 0 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +// shim for using process in browser +var process = module.exports = {}; + +// cached from whatever global is present so that test runners that stub it +// don't break things. But we need to wrap it in a try catch in case it is +// wrapped in strict mode code which doesn't define any globals. It's inside a +// function because try/catches deoptimize in certain engines. + +var cachedSetTimeout; +var cachedClearTimeout; + +function defaultSetTimout() { + throw new Error('setTimeout has not been defined'); +} +function defaultClearTimeout() { + throw new Error('clearTimeout has not been defined'); +} +(function () { + try { + if (typeof setTimeout === 'function') { + cachedSetTimeout = setTimeout; + } else { + cachedSetTimeout = defaultSetTimout; + } + } catch (e) { + cachedSetTimeout = defaultSetTimout; + } + try { + if (typeof clearTimeout === 'function') { + cachedClearTimeout = clearTimeout; + } else { + cachedClearTimeout = defaultClearTimeout; + } + } catch (e) { + cachedClearTimeout = defaultClearTimeout; + } +})(); +function runTimeout(fun) { + if (cachedSetTimeout === setTimeout) { + //normal enviroments in sane situations + return setTimeout(fun, 0); + } + // if setTimeout wasn't available but was latter defined + if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { + cachedSetTimeout = setTimeout; + return setTimeout(fun, 0); + } + try { + // when when somebody has screwed with setTimeout but no I.E. maddness + return cachedSetTimeout(fun, 0); + } catch (e) { + try { + // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally + return cachedSetTimeout.call(null, fun, 0); + } catch (e) { + // 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 + return cachedSetTimeout.call(this, fun, 0); + } + } +} +function runClearTimeout(marker) { + if (cachedClearTimeout === clearTimeout) { + //normal enviroments in sane situations + return clearTimeout(marker); + } + // if clearTimeout wasn't available but was latter defined + if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { + cachedClearTimeout = clearTimeout; + return clearTimeout(marker); + } + try { + // when when somebody has screwed with setTimeout but no I.E. maddness + return cachedClearTimeout(marker); + } catch (e) { + try { + // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally + return cachedClearTimeout.call(null, marker); + } catch (e) { + // 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. + // Some versions of I.E. have different rules for clearTimeout vs setTimeout + return cachedClearTimeout.call(this, marker); + } + } +} +var queue = []; +var draining = false; +var currentQueue; +var queueIndex = -1; + +function cleanUpNextTick() { + if (!draining || !currentQueue) { + return; + } + draining = false; + if (currentQueue.length) { + queue = currentQueue.concat(queue); + } else { + queueIndex = -1; + } + if (queue.length) { + drainQueue(); + } +} + +function drainQueue() { + if (draining) { + return; + } + var timeout = runTimeout(cleanUpNextTick); + draining = true; + + var len = queue.length; + while (len) { + currentQueue = queue; + queue = []; + while (++queueIndex < len) { + if (currentQueue) { + currentQueue[queueIndex].run(); + } + } + queueIndex = -1; + len = queue.length; + } + currentQueue = null; + draining = false; + runClearTimeout(timeout); +} + +process.nextTick = function (fun) { + var args = new Array(arguments.length - 1); + if (arguments.length > 1) { + for (var i = 1; i < arguments.length; i++) { + args[i - 1] = arguments[i]; + } + } + queue.push(new Item(fun, args)); + if (queue.length === 1 && !draining) { + runTimeout(drainQueue); + } +}; + +// v8 likes predictible objects +function Item(fun, array) { + this.fun = fun; + this.array = array; +} +Item.prototype.run = function () { + this.fun.apply(null, this.array); +}; +process.title = 'browser'; +process.browser = true; +process.env = {}; +process.argv = []; +process.version = ''; // empty string to avoid regexp issues +process.versions = {}; + +function noop() {} + +process.on = noop; +process.addListener = noop; +process.once = noop; +process.off = noop; +process.removeListener = noop; +process.removeAllListeners = noop; +process.emit = noop; +process.prependListener = noop; +process.prependOnceListener = noop; + +process.listeners = function (name) { + return []; +}; + +process.binding = function (name) { + throw new Error('process.binding is not supported'); +}; + +process.cwd = function () { + return '/'; +}; +process.chdir = function (dir) { + throw new Error('process.chdir is not supported'); +}; +process.umask = function () { + return 0; +}; + +/***/ }), +/* 1 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +/* WEBPACK VAR INJECTION */(function(process) { + +if (process.env.NODE_ENV === 'production') { + module.exports = __webpack_require__(19); +} else { + module.exports = __webpack_require__(20); +} +/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0))) + +/***/ }), +/* 2 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + * + */ + +function makeEmptyFunction(arg) { + return function () { + return arg; + }; +} + +/** + * This function accepts and discards inputs; it has no side effects. This is + * primarily useful idiomatically for overridable function endpoints which + * always need to be callable, since JS lacks a null-call idiom ala Cocoa. + */ +var emptyFunction = function emptyFunction() {}; + +emptyFunction.thatReturns = makeEmptyFunction; +emptyFunction.thatReturnsFalse = makeEmptyFunction(false); +emptyFunction.thatReturnsTrue = makeEmptyFunction(true); +emptyFunction.thatReturnsNull = makeEmptyFunction(null); +emptyFunction.thatReturnsThis = function () { + return this; +}; +emptyFunction.thatReturnsArgument = function (arg) { + return arg; +}; + +module.exports = emptyFunction; + +/***/ }), +/* 3 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +/* WEBPACK VAR INJECTION */(function(process) {/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + */ + + + +/** + * Use invariant() to assert state which your program assumes to be true. + * + * Provide sprintf-style format (only %s is supported) and arguments + * to provide information about what broke and what you were + * expecting. + * + * The invariant message will be stripped in production, but the invariant + * will remain to ensure logic does not differ in production. + */ + +var validateFormat = function validateFormat(format) {}; + +if (process.env.NODE_ENV !== 'production') { + validateFormat = function validateFormat(format) { + if (format === undefined) { + throw new Error('invariant requires an error message argument'); + } + }; +} + +function invariant(condition, format, a, b, c, d, e, f) { + validateFormat(format); + + if (!condition) { + var error; + if (format === undefined) { + error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.'); + } else { + var args = [a, b, c, d, e, f]; + var argIndex = 0; + error = new Error(format.replace(/%s/g, function () { + return args[argIndex++]; + })); + error.name = 'Invariant Violation'; + } + + error.framesToPop = 1; // we don't care about invariant's own frame + throw error; + } +} + +module.exports = invariant; +/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0))) + +/***/ }), +/* 4 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +/* +object-assign +(c) Sindre Sorhus +@license MIT +*/ + + +/* eslint-disable no-unused-vars */ + +var getOwnPropertySymbols = Object.getOwnPropertySymbols; +var hasOwnProperty = Object.prototype.hasOwnProperty; +var propIsEnumerable = Object.prototype.propertyIsEnumerable; + +function toObject(val) { + if (val === null || val === undefined) { + throw new TypeError('Object.assign cannot be called with null or undefined'); + } + + return Object(val); +} + +function shouldUseNative() { + try { + if (!Object.assign) { + return false; + } + + // Detect buggy property enumeration order in older V8 versions. + + // https://bugs.chromium.org/p/v8/issues/detail?id=4118 + var test1 = new String('abc'); // eslint-disable-line no-new-wrappers + test1[5] = 'de'; + if (Object.getOwnPropertyNames(test1)[0] === '5') { + return false; + } + + // https://bugs.chromium.org/p/v8/issues/detail?id=3056 + var test2 = {}; + for (var i = 0; i < 10; i++) { + test2['_' + String.fromCharCode(i)] = i; + } + var order2 = Object.getOwnPropertyNames(test2).map(function (n) { + return test2[n]; + }); + if (order2.join('') !== '0123456789') { + return false; + } + + // https://bugs.chromium.org/p/v8/issues/detail?id=3056 + var test3 = {}; + 'abcdefghijklmnopqrst'.split('').forEach(function (letter) { + test3[letter] = letter; + }); + if (Object.keys(Object.assign({}, test3)).join('') !== 'abcdefghijklmnopqrst') { + return false; + } + + return true; + } catch (err) { + // We don't expect any of the above to throw, but better to be safe. + return false; + } +} + +module.exports = shouldUseNative() ? Object.assign : function (target, source) { + var from; + var to = toObject(target); + var symbols; + + for (var s = 1; s < arguments.length; s++) { + from = Object(arguments[s]); + + for (var key in from) { + if (hasOwnProperty.call(from, key)) { + to[key] = from[key]; + } + } + + if (getOwnPropertySymbols) { + symbols = getOwnPropertySymbols(from); + for (var i = 0; i < symbols.length; i++) { + if (propIsEnumerable.call(from, symbols[i])) { + to[symbols[i]] = from[symbols[i]]; + } + } + } + } + + return to; +}; + +/***/ }), +/* 5 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +/* WEBPACK VAR INJECTION */(function(process) {/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + */ + + + +var emptyObject = {}; + +if (process.env.NODE_ENV !== 'production') { + Object.freeze(emptyObject); +} + +module.exports = emptyObject; +/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0))) + +/***/ }), +/* 6 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +/* WEBPACK VAR INJECTION */(function(process) {/** + * Copyright (c) 2014-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + */ + + + +var emptyFunction = __webpack_require__(2); + +/** + * Similar to invariant but only logs a warning if the condition is not met. + * This can be used to log issues in development environments in critical + * paths. Removing the logging code for production environments will keep the + * same logic and follow the same code paths. + */ + +var warning = emptyFunction; + +if (process.env.NODE_ENV !== 'production') { + var printWarning = function printWarning(format) { + for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } + + var argIndex = 0; + var message = 'Warning: ' + format.replace(/%s/g, function () { + return args[argIndex++]; + }); + if (typeof console !== 'undefined') { + console.error(message); + } + try { + // --- Welcome to debugging React --- + // This error was thrown as a convenience so that you can use this stack + // to find the callsite that caused this warning to fire. + throw new Error(message); + } catch (x) {} + }; + + warning = function warning(condition, format) { + if (format === undefined) { + throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument'); + } + + if (format.indexOf('Failed Composite propType: ') === 0) { + return; // Ignore CompositeComponent proptype check. + } + + if (!condition) { + for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) { + args[_key2 - 2] = arguments[_key2]; + } + + printWarning.apply(undefined, [format].concat(args)); + } + }; +} + +module.exports = warning; +/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0))) + +/***/ }), +/* 7 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +/* WEBPACK VAR INJECTION */(function(process) {/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + + + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + +if (process.env.NODE_ENV !== 'production') { + var invariant = __webpack_require__(3); + var warning = __webpack_require__(6); + var ReactPropTypesSecret = __webpack_require__(8); + var loggedTypeFailures = {}; +} + +/** + * Assert that the values match with the type specs. + * Error messages are memorized and will only be shown once. + * + * @param {object} typeSpecs Map of name to a ReactPropType + * @param {object} values Runtime values that need to be type-checked + * @param {string} location e.g. "prop", "context", "child context" + * @param {string} componentName Name of the component for error messages. + * @param {?Function} getStack Returns the component stack. + * @private + */ +function checkPropTypes(typeSpecs, values, location, componentName, getStack) { + if (process.env.NODE_ENV !== 'production') { + for (var typeSpecName in typeSpecs) { + if (typeSpecs.hasOwnProperty(typeSpecName)) { + var error; + // Prop type validation may throw. In case they do, we don't want to + // fail the render phase where it didn't fail before. So we log it. + // After these have been cleaned up, we'll let them throw. + try { + // This is intentionally an invariant that gets caught. It's the same + // behavior as without this statement except with a better message. + invariant(typeof typeSpecs[typeSpecName] === 'function', '%s: %s type `%s` is invalid; it must be a function, usually from ' + 'the `prop-types` package, but received `%s`.', componentName || 'React class', location, typeSpecName, _typeof(typeSpecs[typeSpecName])); + error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret); + } catch (ex) { + error = ex; + } + warning(!error || error instanceof Error, '%s: type specification of %s `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', location, typeSpecName, typeof error === 'undefined' ? 'undefined' : _typeof(error)); + if (error instanceof Error && !(error.message in loggedTypeFailures)) { + // Only monitor this failure once because there tends to be a lot of the + // same error. + loggedTypeFailures[error.message] = true; + + var stack = getStack ? getStack() : ''; + + warning(false, 'Failed %s type: %s%s', location, error.message, stack != null ? stack : ''); + } + } + } + } +} + +module.exports = checkPropTypes; +/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0))) + +/***/ }), +/* 8 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + + + +var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED'; + +module.exports = ReactPropTypesSecret; + +/***/ }), +/* 9 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + */ + + + +var canUseDOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement); + +/** + * Simple, lightweight module assisting with the detection and context of + * Worker. Helps avoid circular dependencies and allows code to reason about + * whether or not they are in a Worker, even if they never include the main + * `ReactWorker` dependency. + */ +var ExecutionEnvironment = { + + canUseDOM: canUseDOM, + + canUseWorkers: typeof Worker !== 'undefined', + + canUseEventListeners: canUseDOM && !!(window.addEventListener || window.attachEvent), + + canUseViewport: canUseDOM && !!window.screen, + + isInWorker: !canUseDOM // For now, this is true - might change in the future. + +}; + +module.exports = ExecutionEnvironment; + +/***/ }), +/* 10 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +/* WEBPACK VAR INJECTION */(function(process) { + +function checkDCE() { + /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */ + if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === 'undefined' || typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE !== 'function') { + return; + } + if (process.env.NODE_ENV !== 'production') { + // This branch is unreachable because this function is only called + // in production, but the condition is true only in development. + // Therefore if the branch is still here, dead code elimination wasn't + // properly applied. + // Don't change the message. React DevTools relies on it. Also make sure + // this message doesn't occur elsewhere in this function, or it will cause + // a false positive. + throw new Error('^_^'); + } + try { + // Verify that the code above has been dead code eliminated (DCE'd). + __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(checkDCE); + } catch (err) { + // DevTools shouldn't crash React, no matter what. + // We should still report in case we break this code. + console.error(err); + } +} + +if (process.env.NODE_ENV === 'production') { + // DCE check should happen before ReactDOM bundle executes so that + // DevTools can report bad minification during injection. + checkDCE(); + module.exports = __webpack_require__(21); +} else { + module.exports = __webpack_require__(24); +} +/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0))) + +/***/ }), +/* 11 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +/* WEBPACK VAR INJECTION */(function(process) { + +/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + * @typechecks + */ + +var emptyFunction = __webpack_require__(2); + +/** + * Upstream version of event listener. Does not take into account specific + * nature of platform. + */ +var EventListener = { + /** + * Listen to DOM events during the bubble phase. + * + * @param {DOMEventTarget} target DOM element to register listener on. + * @param {string} eventType Event type, e.g. 'click' or 'mouseover'. + * @param {function} callback Callback function. + * @return {object} Object with a `remove` method. + */ + listen: function listen(target, eventType, callback) { + if (target.addEventListener) { + target.addEventListener(eventType, callback, false); + return { + remove: function remove() { + target.removeEventListener(eventType, callback, false); + } + }; + } else if (target.attachEvent) { + target.attachEvent('on' + eventType, callback); + return { + remove: function remove() { + target.detachEvent('on' + eventType, callback); + } + }; + } + }, + + /** + * Listen to DOM events during the capture phase. + * + * @param {DOMEventTarget} target DOM element to register listener on. + * @param {string} eventType Event type, e.g. 'click' or 'mouseover'. + * @param {function} callback Callback function. + * @return {object} Object with a `remove` method. + */ + capture: function capture(target, eventType, callback) { + if (target.addEventListener) { + target.addEventListener(eventType, callback, true); + return { + remove: function remove() { + target.removeEventListener(eventType, callback, true); + } + }; + } else { + if (process.env.NODE_ENV !== 'production') { + console.error('Attempted to listen to events during the capture phase on a ' + 'browser that does not support the capture phase. Your application ' + 'will not receive some events.'); + } + return { + remove: emptyFunction + }; + } + }, + + registerDefault: function registerDefault() {} +}; + +module.exports = EventListener; +/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0))) + +/***/ }), +/* 12 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + * @typechecks + * + */ + +/*eslint-disable no-self-compare */ + + + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + +var hasOwnProperty = Object.prototype.hasOwnProperty; + +/** + * inlined Object.is polyfill to avoid requiring consumers ship their own + * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is + */ +function is(x, y) { + // SameValue algorithm + if (x === y) { + // Steps 1-5, 7-10 + // Steps 6.b-6.e: +0 != -0 + // Added the nonzero y check to make Flow happy, but it is redundant + return x !== 0 || y !== 0 || 1 / x === 1 / y; + } else { + // Step 6.a: NaN == NaN + return x !== x && y !== y; + } +} + +/** + * Performs equality by iterating through keys on an object and returning false + * when any key has values which are not strictly equal between the arguments. + * Returns true when the values of all keys are strictly equal. + */ +function shallowEqual(objA, objB) { + if (is(objA, objB)) { + return true; + } + + if ((typeof objA === 'undefined' ? 'undefined' : _typeof(objA)) !== 'object' || objA === null || (typeof objB === 'undefined' ? 'undefined' : _typeof(objB)) !== 'object' || objB === null) { + return false; + } + + var keysA = Object.keys(objA); + var keysB = Object.keys(objB); + + if (keysA.length !== keysB.length) { + return false; + } + + // Test for A's keys different from B. + for (var i = 0; i < keysA.length; i++) { + if (!hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) { + return false; + } + } + + return true; +} + +module.exports = shallowEqual; + +/***/ }), +/* 13 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + * + */ + +var isTextNode = __webpack_require__(22); + +/*eslint-disable no-bitwise */ + +/** + * Checks if a given DOM node contains or is another DOM node. + */ +function containsNode(outerNode, innerNode) { + if (!outerNode || !innerNode) { + return false; + } else if (outerNode === innerNode) { + return true; + } else if (isTextNode(outerNode)) { + return false; + } else if (isTextNode(innerNode)) { + return containsNode(outerNode, innerNode.parentNode); + } else if ('contains' in outerNode) { + return outerNode.contains(innerNode); + } else if (outerNode.compareDocumentPosition) { + return !!(outerNode.compareDocumentPosition(innerNode) & 16); + } else { + return false; + } +} + +module.exports = containsNode; + +/***/ }), +/* 14 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + */ + + + +/** + * @param {DOMElement} node input/textarea to focus + */ + +function focusNode(node) { + // IE8 can throw "Can't move focus to the control because it is invisible, + // not enabled, or of a type that does not accept the focus." for all kinds of + // reasons that are too expensive and fragile to test. + try { + node.focus(); + } catch (e) {} +} + +module.exports = focusNode; + +/***/ }), +/* 15 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + * @typechecks + */ + +/* eslint-disable fb-www/typeof-undefined */ + +/** + * Same as document.activeElement but wraps in a try-catch block. In IE it is + * not safe to call document.activeElement if there is nothing focused. + * + * The activeElement will be null only if the document or document body is not + * yet defined. + * + * @param {?DOMDocument} doc Defaults to current document. + * @return {?DOMElement} + */ + +function getActiveElement(doc) /*?DOMElement*/{ + doc = doc || (typeof document !== 'undefined' ? document : undefined); + if (typeof doc === 'undefined') { + return null; + } + try { + return doc.activeElement || doc.body; + } catch (e) { + return doc.body; + } +} + +module.exports = getActiveElement; + +/***/ }), +/* 16 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +/* WEBPACK VAR INJECTION */(function(process) { + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + +/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +if (process.env.NODE_ENV !== 'production') { + var REACT_ELEMENT_TYPE = typeof Symbol === 'function' && Symbol.for && Symbol.for('react.element') || 0xeac7; + + var isValidElement = function isValidElement(object) { + return (typeof object === 'undefined' ? 'undefined' : _typeof(object)) === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE; + }; + + // By explicitly using `prop-types` you are opting into new development behavior. + // http://fb.me/prop-types-in-prod + var throwOnDirectAccess = true; + module.exports = __webpack_require__(31)(isValidElement, throwOnDirectAccess); +} else { + // By explicitly using `prop-types` you are opting into new production behavior. + // http://fb.me/prop-types-in-prod + module.exports = __webpack_require__(32)(); +} +/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0))) + +/***/ }), +/* 17 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +Object.defineProperty(exports, "__esModule", { + value: true +}); + +var _SortableComposition = __webpack_require__(35); + +Object.defineProperty(exports, 'sortable', { + enumerable: true, + get: function get() { + return _SortableComposition.SortableComposition; + } +}); +Object.defineProperty(exports, 'Sortable', { + enumerable: true, + get: function get() { + return _SortableComposition.SortableComposition; + } +}); +Object.defineProperty(exports, 'HORIZONTAL', { + enumerable: true, + get: function get() { + return _SortableComposition.HORIZONTAL; + } +}); +Object.defineProperty(exports, 'VERTICAL', { + enumerable: true, + get: function get() { + return _SortableComposition.VERTICAL; + } +}); + +/***/ }), +/* 18 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +var _react = __webpack_require__(1); + +var _react2 = _interopRequireDefault(_react); + +var _reactDom = __webpack_require__(10); + +var _reactDom2 = _interopRequireDefault(_reactDom); + +var _SortableList = __webpack_require__(33); + +var _SortableList2 = _interopRequireDefault(_SortableList); + +var _SortableGrid = __webpack_require__(37); + +var _SortableGrid2 = _interopRequireDefault(_SortableGrid); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var items = ["Gold", "Crimson", "Hotpink", "Blueviolet", "Cornflowerblue", "Skyblue", "Lightblue", "Aquamarine", "Burlywood"]; + +_reactDom2.default.render(_react2.default.createElement( + 'div', + null, + _react2.default.createElement(_SortableList2.default, { items: items }), + _react2.default.createElement(_SortableGrid2.default, { items: items }) +), document.getElementById('app')); + +/***/ }), +/* 19 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +/* + React v16.0.0 + react.production.min.js + + Copyright (c) 2013-present, Facebook, Inc. + + This source code is licensed under the MIT license found in the + LICENSE file in the root directory of this source tree. +*/ + + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + +var f = __webpack_require__(4), + p = __webpack_require__(5);__webpack_require__(3);var r = __webpack_require__(2); +function t(a) { + for (var b = arguments.length - 1, d = "Minified React error #" + a + "; visit http://facebook.github.io/react/docs/error-decoder.html?invariant\x3d" + a, e = 0; e < b; e++) { + d += "\x26args[]\x3d" + encodeURIComponent(arguments[e + 1]); + }b = Error(d + " for the full message or use the non-minified dev environment for full errors and additional helpful warnings.");b.name = "Invariant Violation";b.framesToPop = 1;throw b; +} +var u = { isMounted: function isMounted() { + return !1; + }, enqueueForceUpdate: function enqueueForceUpdate() {}, enqueueReplaceState: function enqueueReplaceState() {}, enqueueSetState: function enqueueSetState() {} };function v(a, b, d) { + this.props = a;this.context = b;this.refs = p;this.updater = d || u; +}v.prototype.isReactComponent = {};v.prototype.setState = function (a, b) { + "object" !== (typeof a === "undefined" ? "undefined" : _typeof(a)) && "function" !== typeof a && null != a ? t("85") : void 0;this.updater.enqueueSetState(this, a, b, "setState"); +};v.prototype.forceUpdate = function (a) { + this.updater.enqueueForceUpdate(this, a, "forceUpdate"); +}; +function w(a, b, d) { + this.props = a;this.context = b;this.refs = p;this.updater = d || u; +}function x() {}x.prototype = v.prototype;var y = w.prototype = new x();y.constructor = w;f(y, v.prototype);y.isPureReactComponent = !0;function z(a, b, d) { + this.props = a;this.context = b;this.refs = p;this.updater = d || u; +}var A = z.prototype = new x();A.constructor = z;f(A, v.prototype);A.unstable_isAsyncReactComponent = !0;A.render = function () { + return this.props.children; +}; +var B = { Component: v, PureComponent: w, AsyncComponent: z }, + C = { current: null }, + D = Object.prototype.hasOwnProperty, + E = "function" === typeof Symbol && Symbol["for"] && Symbol["for"]("react.element") || 60103, + F = { key: !0, ref: !0, __self: !0, __source: !0 };function G(a, b, d, e, c, g, k) { + return { $$typeof: E, type: a, key: b, ref: d, props: k, _owner: g }; +} +G.createElement = function (a, b, d) { + var e, + c = {}, + g = null, + k = null, + m = null, + q = null;if (null != b) for (e in void 0 !== b.ref && (k = b.ref), void 0 !== b.key && (g = "" + b.key), m = void 0 === b.__self ? null : b.__self, q = void 0 === b.__source ? null : b.__source, b) { + D.call(b, e) && !F.hasOwnProperty(e) && (c[e] = b[e]); + }var l = arguments.length - 2;if (1 === l) c.children = d;else if (1 < l) { + for (var h = Array(l), n = 0; n < l; n++) { + h[n] = arguments[n + 2]; + }c.children = h; + }if (a && a.defaultProps) for (e in l = a.defaultProps, l) { + void 0 === c[e] && (c[e] = l[e]); + }return G(a, g, k, m, q, C.current, c); +}; +G.createFactory = function (a) { + var b = G.createElement.bind(null, a);b.type = a;return b; +};G.cloneAndReplaceKey = function (a, b) { + return G(a.type, b, a.ref, a._self, a._source, a._owner, a.props); +}; +G.cloneElement = function (a, b, d) { + var e = f({}, a.props), + c = a.key, + g = a.ref, + k = a._self, + m = a._source, + q = a._owner;if (null != b) { + void 0 !== b.ref && (g = b.ref, q = C.current);void 0 !== b.key && (c = "" + b.key);if (a.type && a.type.defaultProps) var l = a.type.defaultProps;for (h in b) { + D.call(b, h) && !F.hasOwnProperty(h) && (e[h] = void 0 === b[h] && void 0 !== l ? l[h] : b[h]); + } + }var h = arguments.length - 2;if (1 === h) e.children = d;else if (1 < h) { + l = Array(h);for (var n = 0; n < h; n++) { + l[n] = arguments[n + 2]; + }e.children = l; + }return G(a.type, c, g, k, m, q, e); +}; +G.isValidElement = function (a) { + return "object" === (typeof a === "undefined" ? "undefined" : _typeof(a)) && null !== a && a.$$typeof === E; +};var H = "function" === typeof Symbol && Symbol.iterator, + I = "function" === typeof Symbol && Symbol["for"] && Symbol["for"]("react.element") || 60103;function escape(a) { + var b = { "\x3d": "\x3d0", ":": "\x3d2" };return "$" + ("" + a).replace(/[=:]/g, function (a) { + return b[a]; + }); +}var J = /\/+/g, + K = []; +function L(a, b, d, e) { + if (K.length) { + var c = K.pop();c.result = a;c.keyPrefix = b;c.func = d;c.context = e;c.count = 0;return c; + }return { result: a, keyPrefix: b, func: d, context: e, count: 0 }; +}function M(a) { + a.result = null;a.keyPrefix = null;a.func = null;a.context = null;a.count = 0;10 > K.length && K.push(a); +} +function N(a, b, d, e) { + var c = typeof a === "undefined" ? "undefined" : _typeof(a);if ("undefined" === c || "boolean" === c) a = null;if (null === a || "string" === c || "number" === c || "object" === c && a.$$typeof === I) return d(e, a, "" === b ? "." + O(a, 0) : b), 1;var g = 0;b = "" === b ? "." : b + ":";if (Array.isArray(a)) for (var k = 0; k < a.length; k++) { + c = a[k];var m = b + O(c, k);g += N(c, m, d, e); + } else if (m = H && a[H] || a["@@iterator"], "function" === typeof m) for (a = m.call(a), k = 0; !(c = a.next()).done;) { + c = c.value, m = b + O(c, k++), g += N(c, m, d, e); + } else "object" === c && (d = "" + a, t("31", "[object Object]" === d ? "object with keys {" + Object.keys(a).join(", ") + "}" : d, ""));return g; +}function O(a, b) { + return "object" === (typeof a === "undefined" ? "undefined" : _typeof(a)) && null !== a && null != a.key ? escape(a.key) : b.toString(36); +}function P(a, b) { + a.func.call(a.context, b, a.count++); +}function Q(a, b, d) { + var e = a.result, + c = a.keyPrefix;a = a.func.call(a.context, b, a.count++);Array.isArray(a) ? R(a, e, d, r.thatReturnsArgument) : null != a && (G.isValidElement(a) && (a = G.cloneAndReplaceKey(a, c + (!a.key || b && b.key === a.key ? "" : ("" + a.key).replace(J, "$\x26/") + "/") + d)), e.push(a)); +} +function R(a, b, d, e, c) { + var g = "";null != d && (g = ("" + d).replace(J, "$\x26/") + "/");b = L(b, g, e, c);null == a || N(a, "", Q, b);M(b); +}var S = { forEach: function forEach(a, b, d) { + if (null == a) return a;b = L(null, null, b, d);null == a || N(a, "", P, b);M(b); + }, map: function map(a, b, d) { + if (null == a) return a;var e = [];R(a, e, null, b, d);return e; + }, count: function count(a) { + return null == a ? 0 : N(a, "", r.thatReturnsNull, null); + }, toArray: function toArray(a) { + var b = [];R(a, b, null, r.thatReturnsArgument);return b; + } }; +module.exports = { Children: { map: S.map, forEach: S.forEach, count: S.count, toArray: S.toArray, only: function only(a) { + G.isValidElement(a) ? void 0 : t("143");return a; + } }, Component: B.Component, PureComponent: B.PureComponent, unstable_AsyncComponent: B.AsyncComponent, createElement: G.createElement, cloneElement: G.cloneElement, isValidElement: G.isValidElement, createFactory: G.createFactory, version: "16.0.0", __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: { ReactCurrentOwner: C, assign: f } }; + +/***/ }), +/* 20 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +/* WEBPACK VAR INJECTION */(function(process) {/** @license React v16.0.0 + * react.development.js + * + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + +if (process.env.NODE_ENV !== "production") { + (function () { + + 'use strict'; + + var objectAssign$1 = __webpack_require__(4); + var require$$0 = __webpack_require__(6); + var emptyObject = __webpack_require__(5); + var invariant = __webpack_require__(3); + var emptyFunction = __webpack_require__(2); + var checkPropTypes = __webpack_require__(7); + + /** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + * @providesModule reactProdInvariant + * + */ + + { + var warning = require$$0; + } + + function warnNoop(publicInstance, callerName) { + { + var constructor = publicInstance.constructor; + warning(false, '%s(...): Can only update a mounted or mounting component. ' + 'This usually means you called %s() on an unmounted component. ' + 'This is a no-op.\n\nPlease check the code for the %s component.', callerName, callerName, constructor && (constructor.displayName || constructor.name) || 'ReactClass'); + } + } + + /** + * This is the abstract API for an update queue. + */ + var ReactNoopUpdateQueue = { + /** + * Checks whether or not this composite component is mounted. + * @param {ReactClass} publicInstance The instance we want to test. + * @return {boolean} True if mounted, false otherwise. + * @protected + * @final + */ + isMounted: function isMounted(publicInstance) { + return false; + }, + + /** + * Forces an update. This should only be invoked when it is known with + * certainty that we are **not** in a DOM transaction. + * + * You may want to call this when you know that some deeper aspect of the + * component's state has changed but `setState` was not called. + * + * This will not invoke `shouldComponentUpdate`, but it will invoke + * `componentWillUpdate` and `componentDidUpdate`. + * + * @param {ReactClass} publicInstance The instance that should rerender. + * @param {?function} callback Called after component is updated. + * @param {?string} callerName name of the calling function in the public API. + * @internal + */ + enqueueForceUpdate: function enqueueForceUpdate(publicInstance, callback, callerName) { + warnNoop(publicInstance, 'forceUpdate'); + }, + + /** + * Replaces all of the state. Always use this or `setState` to mutate state. + * You should treat `this.state` as immutable. + * + * There is no guarantee that `this.state` will be immediately updated, so + * accessing `this.state` after calling this method may return the old value. + * + * @param {ReactClass} publicInstance The instance that should rerender. + * @param {object} completeState Next state. + * @param {?function} callback Called after component is updated. + * @param {?string} callerName name of the calling function in the public API. + * @internal + */ + enqueueReplaceState: function enqueueReplaceState(publicInstance, completeState, callback, callerName) { + warnNoop(publicInstance, 'replaceState'); + }, + + /** + * Sets a subset of the state. This only exists because _pendingState is + * internal. This provides a merging strategy that is not available to deep + * properties which is confusing. TODO: Expose pendingState or don't use it + * during the merge. + * + * @param {ReactClass} publicInstance The instance that should rerender. + * @param {object} partialState Next partial state to be merged with state. + * @param {?function} callback Called after component is updated. + * @param {?string} Name of the calling function in the public API. + * @internal + */ + enqueueSetState: function enqueueSetState(publicInstance, partialState, callback, callerName) { + warnNoop(publicInstance, 'setState'); + } + }; + + var ReactNoopUpdateQueue_1 = ReactNoopUpdateQueue; + + /** + * Copyright (c) 2014-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + * @providesModule lowPriorityWarning + */ + + /** + * Forked from fbjs/warning: + * https://github.com/facebook/fbjs/blob/e66ba20ad5be433eb54423f2b097d829324d9de6/packages/fbjs/src/__forks__/warning.js + * + * Only change is we use console.warn instead of console.error, + * and do nothing when 'console' is not supported. + * This really simplifies the code. + * --- + * Similar to invariant but only logs a warning if the condition is not met. + * This can be used to log issues in development environments in critical + * paths. Removing the logging code for production environments will keep the + * same logic and follow the same code paths. + */ + + var lowPriorityWarning = function lowPriorityWarning() {}; + + { + var printWarning = function printWarning(format) { + for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } + + var argIndex = 0; + var message = 'Warning: ' + format.replace(/%s/g, function () { + return args[argIndex++]; + }); + if (typeof console !== 'undefined') { + console.warn(message); + } + try { + // --- Welcome to debugging React --- + // This error was thrown as a convenience so that you can use this stack + // to find the callsite that caused this warning to fire. + throw new Error(message); + } catch (x) {} + }; + + lowPriorityWarning = function lowPriorityWarning(condition, format) { + if (format === undefined) { + throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument'); + } + if (!condition) { + for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) { + args[_key2 - 2] = arguments[_key2]; + } + + printWarning.apply(undefined, [format].concat(args)); + } + }; + } + + var lowPriorityWarning_1 = lowPriorityWarning; + + /** + * Base class helpers for the updating state of a component. + */ + function ReactComponent(props, context, updater) { + this.props = props; + this.context = context; + this.refs = emptyObject; + // We initialize the default updater but the real one gets injected by the + // renderer. + this.updater = updater || ReactNoopUpdateQueue_1; + } + + ReactComponent.prototype.isReactComponent = {}; + + /** + * Sets a subset of the state. Always use this to mutate + * state. You should treat `this.state` as immutable. + * + * There is no guarantee that `this.state` will be immediately updated, so + * accessing `this.state` after calling this method may return the old value. + * + * There is no guarantee that calls to `setState` will run synchronously, + * as they may eventually be batched together. You can provide an optional + * callback that will be executed when the call to setState is actually + * completed. + * + * When a function is provided to setState, it will be called at some point in + * the future (not synchronously). It will be called with the up to date + * component arguments (state, props, context). These values can be different + * from this.* because your function may be called after receiveProps but before + * shouldComponentUpdate, and this new state, props, and context will not yet be + * assigned to this. + * + * @param {object|function} partialState Next partial state or function to + * produce next partial state to be merged with current state. + * @param {?function} callback Called after state is updated. + * @final + * @protected + */ + ReactComponent.prototype.setState = function (partialState, callback) { + !((typeof partialState === 'undefined' ? 'undefined' : _typeof(partialState)) === 'object' || typeof partialState === 'function' || partialState == null) ? invariant(false, 'setState(...): takes an object of state variables to update or a function which returns an object of state variables.') : void 0; + this.updater.enqueueSetState(this, partialState, callback, 'setState'); + }; + + /** + * Forces an update. This should only be invoked when it is known with + * certainty that we are **not** in a DOM transaction. + * + * You may want to call this when you know that some deeper aspect of the + * component's state has changed but `setState` was not called. + * + * This will not invoke `shouldComponentUpdate`, but it will invoke + * `componentWillUpdate` and `componentDidUpdate`. + * + * @param {?function} callback Called after update is complete. + * @final + * @protected + */ + ReactComponent.prototype.forceUpdate = function (callback) { + this.updater.enqueueForceUpdate(this, callback, 'forceUpdate'); + }; + + /** + * Deprecated APIs. These APIs used to exist on classic React classes but since + * we would like to deprecate them, we're not going to move them over to this + * modern base class. Instead, we define a getter that warns if it's accessed. + */ + { + var deprecatedAPIs = { + isMounted: ['isMounted', 'Instead, make sure to clean up subscriptions and pending requests in ' + 'componentWillUnmount to prevent memory leaks.'], + replaceState: ['replaceState', 'Refactor your code to use setState instead (see ' + 'https://github.com/facebook/react/issues/3236).'] + }; + var defineDeprecationWarning = function defineDeprecationWarning(methodName, info) { + Object.defineProperty(ReactComponent.prototype, methodName, { + get: function get() { + lowPriorityWarning_1(false, '%s(...) is deprecated in plain JavaScript React classes. %s', info[0], info[1]); + return undefined; + } + }); + }; + for (var fnName in deprecatedAPIs) { + if (deprecatedAPIs.hasOwnProperty(fnName)) { + defineDeprecationWarning(fnName, deprecatedAPIs[fnName]); + } + } + } + + /** + * Base class helpers for the updating state of a component. + */ + function ReactPureComponent(props, context, updater) { + // Duplicated from ReactComponent. + this.props = props; + this.context = context; + this.refs = emptyObject; + // We initialize the default updater but the real one gets injected by the + // renderer. + this.updater = updater || ReactNoopUpdateQueue_1; + } + + function ComponentDummy() {} + ComponentDummy.prototype = ReactComponent.prototype; + var pureComponentPrototype = ReactPureComponent.prototype = new ComponentDummy(); + pureComponentPrototype.constructor = ReactPureComponent; + // Avoid an extra prototype jump for these methods. + objectAssign$1(pureComponentPrototype, ReactComponent.prototype); + pureComponentPrototype.isPureReactComponent = true; + + function ReactAsyncComponent(props, context, updater) { + // Duplicated from ReactComponent. + this.props = props; + this.context = context; + this.refs = emptyObject; + // We initialize the default updater but the real one gets injected by the + // renderer. + this.updater = updater || ReactNoopUpdateQueue_1; + } + + var asyncComponentPrototype = ReactAsyncComponent.prototype = new ComponentDummy(); + asyncComponentPrototype.constructor = ReactAsyncComponent; + // Avoid an extra prototype jump for these methods. + objectAssign$1(asyncComponentPrototype, ReactComponent.prototype); + asyncComponentPrototype.unstable_isAsyncReactComponent = true; + asyncComponentPrototype.render = function () { + return this.props.children; + }; + + var ReactBaseClasses = { + Component: ReactComponent, + PureComponent: ReactPureComponent, + AsyncComponent: ReactAsyncComponent + }; + + /** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + * @providesModule ReactCurrentOwner + * + */ + + /** + * Keeps track of the current owner. + * + * The current owner is the component who should own any components that are + * currently being constructed. + */ + var ReactCurrentOwner = { + /** + * @internal + * @type {ReactComponent} + */ + current: null + }; + + var ReactCurrentOwner_1 = ReactCurrentOwner; + + var hasOwnProperty = Object.prototype.hasOwnProperty; + + { + var warning$2 = require$$0; + } + + // The Symbol used to tag the ReactElement type. If there is no native Symbol + // nor polyfill, then a plain number is used for performance. + var REACT_ELEMENT_TYPE$1 = typeof Symbol === 'function' && Symbol['for'] && Symbol['for']('react.element') || 0xeac7; + + var RESERVED_PROPS = { + key: true, + ref: true, + __self: true, + __source: true + }; + + var specialPropKeyWarningShown; + var specialPropRefWarningShown; + + function hasValidRef(config) { + { + if (hasOwnProperty.call(config, 'ref')) { + var getter = Object.getOwnPropertyDescriptor(config, 'ref').get; + if (getter && getter.isReactWarning) { + return false; + } + } + } + return config.ref !== undefined; + } + + function hasValidKey(config) { + { + if (hasOwnProperty.call(config, 'key')) { + var getter = Object.getOwnPropertyDescriptor(config, 'key').get; + if (getter && getter.isReactWarning) { + return false; + } + } + } + return config.key !== undefined; + } + + function defineKeyPropWarningGetter(props, displayName) { + var warnAboutAccessingKey = function warnAboutAccessingKey() { + if (!specialPropKeyWarningShown) { + specialPropKeyWarningShown = true; + warning$2(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); + } + }; + warnAboutAccessingKey.isReactWarning = true; + Object.defineProperty(props, 'key', { + get: warnAboutAccessingKey, + configurable: true + }); + } + + function defineRefPropWarningGetter(props, displayName) { + var warnAboutAccessingRef = function warnAboutAccessingRef() { + if (!specialPropRefWarningShown) { + specialPropRefWarningShown = true; + warning$2(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); + } + }; + warnAboutAccessingRef.isReactWarning = true; + Object.defineProperty(props, 'ref', { + get: warnAboutAccessingRef, + configurable: true + }); + } + + /** + * Factory method to create a new React element. This no longer adheres to + * the class pattern, so do not use new to call it. Also, no instanceof check + * will work. Instead test $$typeof field against Symbol.for('react.element') to check + * if something is a React Element. + * + * @param {*} type + * @param {*} key + * @param {string|object} ref + * @param {*} self A *temporary* helper to detect places where `this` is + * different from the `owner` when React.createElement is called, so that we + * can warn. We want to get rid of owner and replace string `ref`s with arrow + * functions, and as long as `this` and owner are the same, there will be no + * change in behavior. + * @param {*} source An annotation object (added by a transpiler or otherwise) + * indicating filename, line number, and/or other information. + * @param {*} owner + * @param {*} props + * @internal + */ + var ReactElement = function ReactElement(type, key, ref, self, source, owner, props) { + var element = { + // This tag allow us to uniquely identify this as a React Element + $$typeof: REACT_ELEMENT_TYPE$1, + + // Built-in properties that belong on the element + type: type, + key: key, + ref: ref, + props: props, + + // Record the component responsible for creating this element. + _owner: owner + }; + + { + // The validation flag is currently mutative. We put it on + // an external backing store so that we can freeze the whole object. + // This can be replaced with a WeakMap once they are implemented in + // commonly used development environments. + element._store = {}; + + // To make comparing ReactElements easier for testing purposes, we make + // the validation flag non-enumerable (where possible, which should + // include every environment we run tests in), so the test framework + // ignores it. + Object.defineProperty(element._store, 'validated', { + configurable: false, + enumerable: false, + writable: true, + value: false + }); + // self and source are DEV only properties. + Object.defineProperty(element, '_self', { + configurable: false, + enumerable: false, + writable: false, + value: self + }); + // Two elements created in two different places should be considered + // equal for testing purposes and therefore we hide it from enumeration. + Object.defineProperty(element, '_source', { + configurable: false, + enumerable: false, + writable: false, + value: source + }); + if (Object.freeze) { + Object.freeze(element.props); + Object.freeze(element); + } + } + + return element; + }; + + /** + * Create and return a new ReactElement of the given type. + * See https://facebook.github.io/react/docs/react-api.html#createelement + */ + ReactElement.createElement = function (type, config, children) { + var propName; + + // Reserved names are extracted + var props = {}; + + var key = null; + var ref = null; + var self = null; + var source = null; + + if (config != null) { + if (hasValidRef(config)) { + ref = config.ref; + } + if (hasValidKey(config)) { + key = '' + config.key; + } + + self = config.__self === undefined ? null : config.__self; + source = config.__source === undefined ? null : config.__source; + // Remaining properties are added to a new props object + for (propName in config) { + if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) { + props[propName] = config[propName]; + } + } + } + + // Children can be more than one argument, and those are transferred onto + // the newly allocated props object. + var childrenLength = arguments.length - 2; + if (childrenLength === 1) { + props.children = children; + } else if (childrenLength > 1) { + var childArray = Array(childrenLength); + for (var i = 0; i < childrenLength; i++) { + childArray[i] = arguments[i + 2]; + } + { + if (Object.freeze) { + Object.freeze(childArray); + } + } + props.children = childArray; + } + + // Resolve default props + if (type && type.defaultProps) { + var defaultProps = type.defaultProps; + for (propName in defaultProps) { + if (props[propName] === undefined) { + props[propName] = defaultProps[propName]; + } + } + } + { + if (key || ref) { + if (typeof props.$$typeof === 'undefined' || props.$$typeof !== REACT_ELEMENT_TYPE$1) { + var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type; + if (key) { + defineKeyPropWarningGetter(props, displayName); + } + if (ref) { + defineRefPropWarningGetter(props, displayName); + } + } + } + } + return ReactElement(type, key, ref, self, source, ReactCurrentOwner_1.current, props); + }; + + /** + * Return a function that produces ReactElements of a given type. + * See https://facebook.github.io/react/docs/react-api.html#createfactory + */ + ReactElement.createFactory = function (type) { + var factory = ReactElement.createElement.bind(null, type); + // Expose the type on the factory and the prototype so that it can be + // easily accessed on elements. E.g. `.type === Foo`. + // This should not be named `constructor` since this may not be the function + // that created the element, and it may not even be a constructor. + // Legacy hook TODO: Warn if this is accessed + factory.type = type; + return factory; + }; + + ReactElement.cloneAndReplaceKey = function (oldElement, newKey) { + var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props); + + return newElement; + }; + + /** + * Clone and return a new ReactElement using element as the starting point. + * See https://facebook.github.io/react/docs/react-api.html#cloneelement + */ + ReactElement.cloneElement = function (element, config, children) { + var propName; + + // Original props are copied + var props = objectAssign$1({}, element.props); + + // Reserved names are extracted + var key = element.key; + var ref = element.ref; + // Self is preserved since the owner is preserved. + var self = element._self; + // Source is preserved since cloneElement is unlikely to be targeted by a + // transpiler, and the original source is probably a better indicator of the + // true owner. + var source = element._source; + + // Owner will be preserved, unless ref is overridden + var owner = element._owner; + + if (config != null) { + if (hasValidRef(config)) { + // Silently steal the ref from the parent. + ref = config.ref; + owner = ReactCurrentOwner_1.current; + } + if (hasValidKey(config)) { + key = '' + config.key; + } + + // Remaining properties override existing props + var defaultProps; + if (element.type && element.type.defaultProps) { + defaultProps = element.type.defaultProps; + } + for (propName in config) { + if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) { + if (config[propName] === undefined && defaultProps !== undefined) { + // Resolve default props + props[propName] = defaultProps[propName]; + } else { + props[propName] = config[propName]; + } + } + } + } + + // Children can be more than one argument, and those are transferred onto + // the newly allocated props object. + var childrenLength = arguments.length - 2; + if (childrenLength === 1) { + props.children = children; + } else if (childrenLength > 1) { + var childArray = Array(childrenLength); + for (var i = 0; i < childrenLength; i++) { + childArray[i] = arguments[i + 2]; + } + props.children = childArray; + } + + return ReactElement(element.type, key, ref, self, source, owner, props); + }; + + /** + * Verifies the object is a ReactElement. + * See https://facebook.github.io/react/docs/react-api.html#isvalidelement + * @param {?object} object + * @return {boolean} True if `object` is a valid component. + * @final + */ + ReactElement.isValidElement = function (object) { + return (typeof object === 'undefined' ? 'undefined' : _typeof(object)) === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE$1; + }; + + var ReactElement_1 = ReactElement; + + /** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + * @providesModule ReactDebugCurrentFrame + * + */ + + var ReactDebugCurrentFrame = {}; + + { + // Component that is being worked on + ReactDebugCurrentFrame.getCurrentStack = null; + + ReactDebugCurrentFrame.getStackAddendum = function () { + var impl = ReactDebugCurrentFrame.getCurrentStack; + if (impl) { + return impl(); + } + return null; + }; + } + + var ReactDebugCurrentFrame_1 = ReactDebugCurrentFrame; + + { + var warning$1 = require$$0; + + var _require = ReactDebugCurrentFrame_1, + getStackAddendum = _require.getStackAddendum; + } + + var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator; + var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec. + // The Symbol used to tag the ReactElement type. If there is no native Symbol + // nor polyfill, then a plain number is used for performance. + var REACT_ELEMENT_TYPE = typeof Symbol === 'function' && Symbol['for'] && Symbol['for']('react.element') || 0xeac7; + + var SEPARATOR = '.'; + var SUBSEPARATOR = ':'; + + /** + * Escape and wrap key so it is safe to use as a reactid + * + * @param {string} key to be escaped. + * @return {string} the escaped key. + */ + function escape(key) { + var escapeRegex = /[=:]/g; + var escaperLookup = { + '=': '=0', + ':': '=2' + }; + var escapedString = ('' + key).replace(escapeRegex, function (match) { + return escaperLookup[match]; + }); + + return '$' + escapedString; + } + + /** + * TODO: Test that a single child and an array with one item have the same key + * pattern. + */ + + var didWarnAboutMaps = false; + + var userProvidedKeyEscapeRegex = /\/+/g; + function escapeUserProvidedKey(text) { + return ('' + text).replace(userProvidedKeyEscapeRegex, '$&/'); + } + + var POOL_SIZE = 10; + var traverseContextPool = []; + function getPooledTraverseContext(mapResult, keyPrefix, mapFunction, mapContext) { + if (traverseContextPool.length) { + var traverseContext = traverseContextPool.pop(); + traverseContext.result = mapResult; + traverseContext.keyPrefix = keyPrefix; + traverseContext.func = mapFunction; + traverseContext.context = mapContext; + traverseContext.count = 0; + return traverseContext; + } else { + return { + result: mapResult, + keyPrefix: keyPrefix, + func: mapFunction, + context: mapContext, + count: 0 + }; + } + } + + function releaseTraverseContext(traverseContext) { + traverseContext.result = null; + traverseContext.keyPrefix = null; + traverseContext.func = null; + traverseContext.context = null; + traverseContext.count = 0; + if (traverseContextPool.length < POOL_SIZE) { + traverseContextPool.push(traverseContext); + } + } + + /** + * @param {?*} children Children tree container. + * @param {!string} nameSoFar Name of the key path so far. + * @param {!function} callback Callback to invoke with each child found. + * @param {?*} traverseContext Used to pass information throughout the traversal + * process. + * @return {!number} The number of children in this subtree. + */ + function traverseAllChildrenImpl(children, nameSoFar, callback, traverseContext) { + var type = typeof children === 'undefined' ? 'undefined' : _typeof(children); + + if (type === 'undefined' || type === 'boolean') { + // All of the above are perceived as null. + children = null; + } + + if (children === null || type === 'string' || type === 'number' || + // The following is inlined from ReactElement. This means we can optimize + // some checks. React Fiber also inlines this logic for similar purposes. + type === 'object' && children.$$typeof === REACT_ELEMENT_TYPE) { + callback(traverseContext, children, + // If it's the only child, treat the name as if it was wrapped in an array + // so that it's consistent if the number of children grows. + nameSoFar === '' ? SEPARATOR + getComponentKey(children, 0) : nameSoFar); + return 1; + } + + var child; + var nextName; + var subtreeCount = 0; // Count of children found in the current subtree. + var nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR; + + if (Array.isArray(children)) { + for (var i = 0; i < children.length; i++) { + child = children[i]; + nextName = nextNamePrefix + getComponentKey(child, i); + subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext); + } + } else { + var iteratorFn = ITERATOR_SYMBOL && children[ITERATOR_SYMBOL] || children[FAUX_ITERATOR_SYMBOL]; + if (typeof iteratorFn === 'function') { + { + // Warn about using Maps as children + if (iteratorFn === children.entries) { + warning$1(didWarnAboutMaps, 'Using Maps as children is unsupported and will likely yield ' + 'unexpected results. Convert it to a sequence/iterable of keyed ' + 'ReactElements instead.%s', getStackAddendum()); + didWarnAboutMaps = true; + } + } + + var iterator = iteratorFn.call(children); + var step; + var ii = 0; + while (!(step = iterator.next()).done) { + child = step.value; + nextName = nextNamePrefix + getComponentKey(child, ii++); + subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext); + } + } else if (type === 'object') { + var addendum = ''; + { + addendum = ' If you meant to render a collection of children, use an array ' + 'instead.' + getStackAddendum(); + } + var childrenString = '' + children; + invariant(false, 'Objects are not valid as a React child (found: %s).%s', childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString, addendum); + } + } + + return subtreeCount; + } + + /** + * Traverses children that are typically specified as `props.children`, but + * might also be specified through attributes: + * + * - `traverseAllChildren(this.props.children, ...)` + * - `traverseAllChildren(this.props.leftPanelChildren, ...)` + * + * The `traverseContext` is an optional argument that is passed through the + * entire traversal. It can be used to store accumulations or anything else that + * the callback might find relevant. + * + * @param {?*} children Children tree object. + * @param {!function} callback To invoke upon traversing each child. + * @param {?*} traverseContext Context for traversal. + * @return {!number} The number of children in this subtree. + */ + function traverseAllChildren(children, callback, traverseContext) { + if (children == null) { + return 0; + } + + return traverseAllChildrenImpl(children, '', callback, traverseContext); + } + + /** + * Generate a key string that identifies a component within a set. + * + * @param {*} component A component that could contain a manual key. + * @param {number} index Index that is used if a manual key is not provided. + * @return {string} + */ + function getComponentKey(component, index) { + // Do some typechecking here since we call this blindly. We want to ensure + // that we don't block potential future ES APIs. + if ((typeof component === 'undefined' ? 'undefined' : _typeof(component)) === 'object' && component !== null && component.key != null) { + // Explicit key + return escape(component.key); + } + // Implicit key determined by the index in the set + return index.toString(36); + } + + function forEachSingleChild(bookKeeping, child, name) { + var func = bookKeeping.func, + context = bookKeeping.context; + + func.call(context, child, bookKeeping.count++); + } + + /** + * Iterates through children that are typically specified as `props.children`. + * + * See https://facebook.github.io/react/docs/react-api.html#react.children.foreach + * + * The provided forEachFunc(child, index) will be called for each + * leaf child. + * + * @param {?*} children Children tree container. + * @param {function(*, int)} forEachFunc + * @param {*} forEachContext Context for forEachContext. + */ + function forEachChildren(children, forEachFunc, forEachContext) { + if (children == null) { + return children; + } + var traverseContext = getPooledTraverseContext(null, null, forEachFunc, forEachContext); + traverseAllChildren(children, forEachSingleChild, traverseContext); + releaseTraverseContext(traverseContext); + } + + function mapSingleChildIntoContext(bookKeeping, child, childKey) { + var result = bookKeeping.result, + keyPrefix = bookKeeping.keyPrefix, + func = bookKeeping.func, + context = bookKeeping.context; + + var mappedChild = func.call(context, child, bookKeeping.count++); + if (Array.isArray(mappedChild)) { + mapIntoWithKeyPrefixInternal(mappedChild, result, childKey, emptyFunction.thatReturnsArgument); + } else if (mappedChild != null) { + if (ReactElement_1.isValidElement(mappedChild)) { + mappedChild = ReactElement_1.cloneAndReplaceKey(mappedChild, + // Keep both the (mapped) and old keys if they differ, just as + // traverseAllChildren used to do for objects as children + keyPrefix + (mappedChild.key && (!child || child.key !== mappedChild.key) ? escapeUserProvidedKey(mappedChild.key) + '/' : '') + childKey); + } + result.push(mappedChild); + } + } + + function mapIntoWithKeyPrefixInternal(children, array, prefix, func, context) { + var escapedPrefix = ''; + if (prefix != null) { + escapedPrefix = escapeUserProvidedKey(prefix) + '/'; + } + var traverseContext = getPooledTraverseContext(array, escapedPrefix, func, context); + traverseAllChildren(children, mapSingleChildIntoContext, traverseContext); + releaseTraverseContext(traverseContext); + } + + /** + * Maps children that are typically specified as `props.children`. + * + * See https://facebook.github.io/react/docs/react-api.html#react.children.map + * + * The provided mapFunction(child, key, index) will be called for each + * leaf child. + * + * @param {?*} children Children tree container. + * @param {function(*, int)} func The map function. + * @param {*} context Context for mapFunction. + * @return {object} Object containing the ordered map of results. + */ + function mapChildren(children, func, context) { + if (children == null) { + return children; + } + var result = []; + mapIntoWithKeyPrefixInternal(children, result, null, func, context); + return result; + } + + /** + * Count the number of children that are typically specified as + * `props.children`. + * + * See https://facebook.github.io/react/docs/react-api.html#react.children.count + * + * @param {?*} children Children tree container. + * @return {number} The number of children. + */ + function countChildren(children, context) { + return traverseAllChildren(children, emptyFunction.thatReturnsNull, null); + } + + /** + * Flatten a children object (typically specified as `props.children`) and + * return an array with appropriately re-keyed children. + * + * See https://facebook.github.io/react/docs/react-api.html#react.children.toarray + */ + function toArray(children) { + var result = []; + mapIntoWithKeyPrefixInternal(children, result, null, emptyFunction.thatReturnsArgument); + return result; + } + + var ReactChildren = { + forEach: forEachChildren, + map: mapChildren, + count: countChildren, + toArray: toArray + }; + + var ReactChildren_1 = ReactChildren; + + /** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + * @providesModule ReactVersion + */ + + var ReactVersion = '16.0.0'; + + /** + * Returns the first child in a collection of children and verifies that there + * is only one child in the collection. + * + * See https://facebook.github.io/react/docs/react-api.html#react.children.only + * + * The current implementation of this function assumes that a single child gets + * passed without a wrapper, but the purpose of this helper function is to + * abstract away the particular structure of children. + * + * @param {?object} children Child collection structure. + * @return {ReactElement} The first and only `ReactElement` contained in the + * structure. + */ + function onlyChild(children) { + !ReactElement_1.isValidElement(children) ? invariant(false, 'React.Children.only expected to receive a single React element child.') : void 0; + return children; + } + + var onlyChild_1 = onlyChild; + + /** + * Copyright (c) 2016-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + * + * @providesModule describeComponentFrame + */ + + var describeComponentFrame$1 = function describeComponentFrame$1(name, source, ownerName) { + return '\n in ' + (name || 'Unknown') + (source ? ' (at ' + source.fileName.replace(/^.*[\\\/]/, '') + ':' + source.lineNumber + ')' : ownerName ? ' (created by ' + ownerName + ')' : ''); + }; + + /** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + * @providesModule getComponentName + * + */ + + function getComponentName$1(instanceOrFiber) { + if (typeof instanceOrFiber.getName === 'function') { + // Stack reconciler + var instance = instanceOrFiber; + return instance.getName(); + } + if (typeof instanceOrFiber.tag === 'number') { + // Fiber reconciler + var fiber = instanceOrFiber; + var type = fiber.type; + + if (typeof type === 'string') { + return type; + } + if (typeof type === 'function') { + return type.displayName || type.name; + } + } + return null; + } + + var getComponentName_1 = getComponentName$1; + + { + var checkPropTypes$1 = checkPropTypes; + var lowPriorityWarning$1 = lowPriorityWarning_1; + var ReactDebugCurrentFrame$1 = ReactDebugCurrentFrame_1; + var warning$3 = require$$0; + var describeComponentFrame = describeComponentFrame$1; + var getComponentName = getComponentName_1; + + var currentlyValidatingElement = null; + + var getDisplayName = function getDisplayName(element) { + if (element == null) { + return '#empty'; + } else if (typeof element === 'string' || typeof element === 'number') { + return '#text'; + } else if (typeof element.type === 'string') { + return element.type; + } else { + return element.type.displayName || element.type.name || 'Unknown'; + } + }; + + var getStackAddendum$1 = function getStackAddendum$1() { + var stack = ''; + if (currentlyValidatingElement) { + var name = getDisplayName(currentlyValidatingElement); + var owner = currentlyValidatingElement._owner; + stack += describeComponentFrame(name, currentlyValidatingElement._source, owner && getComponentName(owner)); + } + stack += ReactDebugCurrentFrame$1.getStackAddendum() || ''; + return stack; + }; + } + + var ITERATOR_SYMBOL$1 = typeof Symbol === 'function' && Symbol.iterator; + var FAUX_ITERATOR_SYMBOL$1 = '@@iterator'; // Before Symbol spec. + + function getDeclarationErrorAddendum() { + if (ReactCurrentOwner_1.current) { + var name = getComponentName(ReactCurrentOwner_1.current); + if (name) { + return '\n\nCheck the render method of `' + name + '`.'; + } + } + return ''; + } + + function getSourceInfoErrorAddendum(elementProps) { + if (elementProps !== null && elementProps !== undefined && elementProps.__source !== undefined) { + var source = elementProps.__source; + var fileName = source.fileName.replace(/^.*[\\\/]/, ''); + var lineNumber = source.lineNumber; + return '\n\nCheck your code at ' + fileName + ':' + lineNumber + '.'; + } + return ''; + } + + /** + * Warn if there's no key explicitly set on dynamic arrays of children or + * object keys are not valid. This allows us to keep track of children between + * updates. + */ + var ownerHasKeyUseWarning = {}; + + function getCurrentComponentErrorInfo(parentType) { + var info = getDeclarationErrorAddendum(); + + if (!info) { + var parentName = typeof parentType === 'string' ? parentType : parentType.displayName || parentType.name; + if (parentName) { + info = '\n\nCheck the top-level render call using <' + parentName + '>.'; + } + } + return info; + } + + /** + * Warn if the element doesn't have an explicit key assigned to it. + * This element is in an array. The array could grow and shrink or be + * reordered. All children that haven't already been validated are required to + * have a "key" property assigned to it. Error statuses are cached so a warning + * will only be shown once. + * + * @internal + * @param {ReactElement} element Element that requires a key. + * @param {*} parentType element's parent's type. + */ + function validateExplicitKey(element, parentType) { + if (!element._store || element._store.validated || element.key != null) { + return; + } + element._store.validated = true; + + var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType); + if (ownerHasKeyUseWarning[currentComponentErrorInfo]) { + return; + } + ownerHasKeyUseWarning[currentComponentErrorInfo] = true; + + // Usually the current owner is the offender, but if it accepts children as a + // property, it may be the creator of the child that's responsible for + // assigning it a key. + var childOwner = ''; + if (element && element._owner && element._owner !== ReactCurrentOwner_1.current) { + // Give the component that originally created this child. + childOwner = ' It was passed a child from ' + getComponentName(element._owner) + '.'; + } + + currentlyValidatingElement = element; + { + warning$3(false, 'Each child in an array or iterator should have a unique "key" prop.' + '%s%s See https://fb.me/react-warning-keys for more information.%s', currentComponentErrorInfo, childOwner, getStackAddendum$1()); + } + currentlyValidatingElement = null; + } + + /** + * Ensure that every element either is passed in a static location, in an + * array with an explicit keys property defined, or in an object literal + * with valid key property. + * + * @internal + * @param {ReactNode} node Statically passed child of any type. + * @param {*} parentType node's parent's type. + */ + function validateChildKeys(node, parentType) { + if ((typeof node === 'undefined' ? 'undefined' : _typeof(node)) !== 'object') { + return; + } + if (Array.isArray(node)) { + for (var i = 0; i < node.length; i++) { + var child = node[i]; + if (ReactElement_1.isValidElement(child)) { + validateExplicitKey(child, parentType); + } + } + } else if (ReactElement_1.isValidElement(node)) { + // This element was passed in a valid location. + if (node._store) { + node._store.validated = true; + } + } else if (node) { + var iteratorFn = ITERATOR_SYMBOL$1 && node[ITERATOR_SYMBOL$1] || node[FAUX_ITERATOR_SYMBOL$1]; + if (typeof iteratorFn === 'function') { + // Entry iterators used to provide implicit keys, + // but now we print a separate warning for them later. + if (iteratorFn !== node.entries) { + var iterator = iteratorFn.call(node); + var step; + while (!(step = iterator.next()).done) { + if (ReactElement_1.isValidElement(step.value)) { + validateExplicitKey(step.value, parentType); + } + } + } + } + } + } + + /** + * Given an element, validate that its props follow the propTypes definition, + * provided by the type. + * + * @param {ReactElement} element + */ + function validatePropTypes(element) { + var componentClass = element.type; + if (typeof componentClass !== 'function') { + return; + } + var name = componentClass.displayName || componentClass.name; + var propTypes = componentClass.propTypes; + + if (propTypes) { + currentlyValidatingElement = element; + checkPropTypes$1(propTypes, element.props, 'prop', name, getStackAddendum$1); + currentlyValidatingElement = null; + } + if (typeof componentClass.getDefaultProps === 'function') { + warning$3(componentClass.getDefaultProps.isReactClassApproved, 'getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.'); + } + } + + var ReactElementValidator$1 = { + createElement: function createElement(type, props, children) { + var validType = typeof type === 'string' || typeof type === 'function'; + // We warn in this case but don't throw. We expect the element creation to + // succeed and there will likely be errors in render. + if (!validType) { + var info = ''; + if (type === undefined || (typeof type === 'undefined' ? 'undefined' : _typeof(type)) === 'object' && type !== null && Object.keys(type).length === 0) { + info += ' You likely forgot to export your component from the file ' + "it's defined in."; + } + + var sourceInfo = getSourceInfoErrorAddendum(props); + if (sourceInfo) { + info += sourceInfo; + } else { + info += getDeclarationErrorAddendum(); + } + + info += ReactDebugCurrentFrame$1.getStackAddendum() || ''; + + warning$3(false, 'React.createElement: type is invalid -- expected a string (for ' + 'built-in components) or a class/function (for composite ' + 'components) but got: %s.%s', type == null ? type : typeof type === 'undefined' ? 'undefined' : _typeof(type), info); + } + + var element = ReactElement_1.createElement.apply(this, arguments); + + // The result can be nullish if a mock or a custom function is used. + // TODO: Drop this when these are no longer allowed as the type argument. + if (element == null) { + return element; + } + + // Skip key warning if the type isn't valid since our key validation logic + // doesn't expect a non-string/function type and can throw confusing errors. + // We don't want exception behavior to differ between dev and prod. + // (Rendering will throw with a helpful message and as soon as the type is + // fixed, the key warnings will appear.) + if (validType) { + for (var i = 2; i < arguments.length; i++) { + validateChildKeys(arguments[i], type); + } + } + + validatePropTypes(element); + + return element; + }, + + createFactory: function createFactory(type) { + var validatedFactory = ReactElementValidator$1.createElement.bind(null, type); + // Legacy hook TODO: Warn if this is accessed + validatedFactory.type = type; + + { + Object.defineProperty(validatedFactory, 'type', { + enumerable: false, + get: function get() { + lowPriorityWarning$1(false, 'Factory.type is deprecated. Access the class directly ' + 'before passing it to createFactory.'); + Object.defineProperty(this, 'type', { + value: type + }); + return type; + } + }); + } + + return validatedFactory; + }, + + cloneElement: function cloneElement(element, props, children) { + var newElement = ReactElement_1.cloneElement.apply(this, arguments); + for (var i = 2; i < arguments.length; i++) { + validateChildKeys(arguments[i], newElement.type); + } + validatePropTypes(newElement); + return newElement; + } + }; + + var ReactElementValidator_1 = ReactElementValidator$1; + + { + var warning$4 = require$$0; + } + + function isNative(fn) { + // Based on isNative() from Lodash + var funcToString = Function.prototype.toString; + var reIsNative = RegExp('^' + funcToString + // Take an example native function source for comparison + .call(Object.prototype.hasOwnProperty) + // Strip regex characters so we can use it for regex + .replace(/[\\^$.*+?()[\]{}|]/g, '\\$&') + // Remove hasOwnProperty from the template to make it generic + .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'); + try { + var source = funcToString.call(fn); + return reIsNative.test(source); + } catch (err) { + return false; + } + } + + var canUseCollections = + // Array.from + typeof Array.from === 'function' && + // Map + typeof Map === 'function' && isNative(Map) && + // Map.prototype.keys + Map.prototype != null && typeof Map.prototype.keys === 'function' && isNative(Map.prototype.keys) && + // Set + typeof Set === 'function' && isNative(Set) && + // Set.prototype.keys + Set.prototype != null && typeof Set.prototype.keys === 'function' && isNative(Set.prototype.keys); + + var setItem; + var getItem; + var removeItem; + var getItemIDs; + var addRoot; + var removeRoot; + var getRootIDs; + + if (canUseCollections) { + var itemMap = new Map(); + var rootIDSet = new Set(); + + setItem = function setItem(id, item) { + itemMap.set(id, item); + }; + getItem = function getItem(id) { + return itemMap.get(id); + }; + removeItem = function removeItem(id) { + itemMap['delete'](id); + }; + getItemIDs = function getItemIDs() { + return Array.from(itemMap.keys()); + }; + + addRoot = function addRoot(id) { + rootIDSet.add(id); + }; + removeRoot = function removeRoot(id) { + rootIDSet['delete'](id); + }; + getRootIDs = function getRootIDs() { + return Array.from(rootIDSet.keys()); + }; + } else { + var itemByKey = {}; + var rootByKey = {}; + + // Use non-numeric keys to prevent V8 performance issues: + // https://github.com/facebook/react/pull/7232 + var getKeyFromID = function getKeyFromID(id) { + return '.' + id; + }; + var getIDFromKey = function getIDFromKey(key) { + return parseInt(key.substr(1), 10); + }; + + setItem = function setItem(id, item) { + var key = getKeyFromID(id); + itemByKey[key] = item; + }; + getItem = function getItem(id) { + var key = getKeyFromID(id); + return itemByKey[key]; + }; + removeItem = function removeItem(id) { + var key = getKeyFromID(id); + delete itemByKey[key]; + }; + getItemIDs = function getItemIDs() { + return Object.keys(itemByKey).map(getIDFromKey); + }; + + addRoot = function addRoot(id) { + var key = getKeyFromID(id); + rootByKey[key] = true; + }; + removeRoot = function removeRoot(id) { + var key = getKeyFromID(id); + delete rootByKey[key]; + }; + getRootIDs = function getRootIDs() { + return Object.keys(rootByKey).map(getIDFromKey); + }; + } + + var unmountedIDs = []; + + function purgeDeep(id) { + var item = getItem(id); + if (item) { + var childIDs = item.childIDs; + + removeItem(id); + childIDs.forEach(purgeDeep); + } + } + + function getDisplayName$1(element) { + if (element == null) { + return '#empty'; + } else if (typeof element === 'string' || typeof element === 'number') { + return '#text'; + } else if (typeof element.type === 'string') { + return element.type; + } else { + return element.type.displayName || element.type.name || 'Unknown'; + } + } + + function describeID(id) { + var name = ReactComponentTreeHook.getDisplayName(id); + var element = ReactComponentTreeHook.getElement(id); + var ownerID = ReactComponentTreeHook.getOwnerID(id); + var ownerName = void 0; + + if (ownerID) { + ownerName = ReactComponentTreeHook.getDisplayName(ownerID); + } + warning$4(element, 'ReactComponentTreeHook: Missing React element for debugID %s when ' + 'building stack', id); + return describeComponentFrame$1(name || '', element && element._source, ownerName || ''); + } + + var ReactComponentTreeHook = { + onSetChildren: function onSetChildren(id, nextChildIDs) { + var item = getItem(id); + !item ? invariant(false, 'Item must have been set') : void 0; + item.childIDs = nextChildIDs; + + for (var i = 0; i < nextChildIDs.length; i++) { + var nextChildID = nextChildIDs[i]; + var nextChild = getItem(nextChildID); + !nextChild ? invariant(false, 'Expected hook events to fire for the child before its parent includes it in onSetChildren().') : void 0; + !(nextChild.childIDs != null || _typeof(nextChild.element) !== 'object' || nextChild.element == null) ? invariant(false, 'Expected onSetChildren() to fire for a container child before its parent includes it in onSetChildren().') : void 0; + !nextChild.isMounted ? invariant(false, 'Expected onMountComponent() to fire for the child before its parent includes it in onSetChildren().') : void 0; + if (nextChild.parentID == null) { + nextChild.parentID = id; + // TODO: This shouldn't be necessary but mounting a new root during in + // componentWillMount currently causes not-yet-mounted components to + // be purged from our tree data so their parent id is missing. + } + !(nextChild.parentID === id) ? invariant(false, 'Expected onBeforeMountComponent() parent and onSetChildren() to be consistent (%s has parents %s and %s).', nextChildID, nextChild.parentID, id) : void 0; + } + }, + onBeforeMountComponent: function onBeforeMountComponent(id, element, parentID) { + var item = { + element: element, + parentID: parentID, + text: null, + childIDs: [], + isMounted: false, + updateCount: 0 + }; + setItem(id, item); + }, + onBeforeUpdateComponent: function onBeforeUpdateComponent(id, element) { + var item = getItem(id); + if (!item || !item.isMounted) { + // We may end up here as a result of setState() in componentWillUnmount(). + // In this case, ignore the element. + return; + } + item.element = element; + }, + onMountComponent: function onMountComponent(id) { + var item = getItem(id); + !item ? invariant(false, 'Item must have been set') : void 0; + item.isMounted = true; + var isRoot = item.parentID === 0; + if (isRoot) { + addRoot(id); + } + }, + onUpdateComponent: function onUpdateComponent(id) { + var item = getItem(id); + if (!item || !item.isMounted) { + // We may end up here as a result of setState() in componentWillUnmount(). + // In this case, ignore the element. + return; + } + item.updateCount++; + }, + onUnmountComponent: function onUnmountComponent(id) { + var item = getItem(id); + if (item) { + // We need to check if it exists. + // `item` might not exist if it is inside an error boundary, and a sibling + // error boundary child threw while mounting. Then this instance never + // got a chance to mount, but it still gets an unmounting event during + // the error boundary cleanup. + item.isMounted = false; + var isRoot = item.parentID === 0; + if (isRoot) { + removeRoot(id); + } + } + unmountedIDs.push(id); + }, + purgeUnmountedComponents: function purgeUnmountedComponents() { + if (ReactComponentTreeHook._preventPurging) { + // Should only be used for testing. + return; + } + + for (var i = 0; i < unmountedIDs.length; i++) { + var id = unmountedIDs[i]; + purgeDeep(id); + } + unmountedIDs.length = 0; + }, + isMounted: function isMounted(id) { + var item = getItem(id); + return item ? item.isMounted : false; + }, + getCurrentStackAddendum: function getCurrentStackAddendum() { + var info = ''; + var currentOwner = ReactCurrentOwner_1.current; + if (currentOwner) { + !(typeof currentOwner.tag !== 'number') ? invariant(false, 'Fiber owners should not show up in Stack stack traces.') : void 0; + if (typeof currentOwner._debugID === 'number') { + info += ReactComponentTreeHook.getStackAddendumByID(currentOwner._debugID); + } + } + return info; + }, + getStackAddendumByID: function getStackAddendumByID(id) { + var info = ''; + while (id) { + info += describeID(id); + id = ReactComponentTreeHook.getParentID(id); + } + return info; + }, + getChildIDs: function getChildIDs(id) { + var item = getItem(id); + return item ? item.childIDs : []; + }, + getDisplayName: function getDisplayName(id) { + var element = ReactComponentTreeHook.getElement(id); + if (!element) { + return null; + } + return getDisplayName$1(element); + }, + getElement: function getElement(id) { + var item = getItem(id); + return item ? item.element : null; + }, + getOwnerID: function getOwnerID(id) { + var element = ReactComponentTreeHook.getElement(id); + if (!element || !element._owner) { + return null; + } + return element._owner._debugID; + }, + getParentID: function getParentID(id) { + var item = getItem(id); + return item ? item.parentID : null; + }, + getSource: function getSource(id) { + var item = getItem(id); + var element = item ? item.element : null; + var source = element != null ? element._source : null; + return source; + }, + getText: function getText(id) { + var element = ReactComponentTreeHook.getElement(id); + if (typeof element === 'string') { + return element; + } else if (typeof element === 'number') { + return '' + element; + } else { + return null; + } + }, + getUpdateCount: function getUpdateCount(id) { + var item = getItem(id); + return item ? item.updateCount : 0; + }, + + getRootIDs: getRootIDs, + getRegisteredIDs: getItemIDs + }; + + var ReactComponentTreeHook_1 = ReactComponentTreeHook; + + var createElement = ReactElement_1.createElement; + var createFactory = ReactElement_1.createFactory; + var cloneElement = ReactElement_1.cloneElement; + + { + var ReactElementValidator = ReactElementValidator_1; + createElement = ReactElementValidator.createElement; + createFactory = ReactElementValidator.createFactory; + cloneElement = ReactElementValidator.cloneElement; + } + + var React = { + Children: { + map: ReactChildren_1.map, + forEach: ReactChildren_1.forEach, + count: ReactChildren_1.count, + toArray: ReactChildren_1.toArray, + only: onlyChild_1 + }, + + Component: ReactBaseClasses.Component, + PureComponent: ReactBaseClasses.PureComponent, + unstable_AsyncComponent: ReactBaseClasses.AsyncComponent, + + createElement: createElement, + cloneElement: cloneElement, + isValidElement: ReactElement_1.isValidElement, + + createFactory: createFactory, + + version: ReactVersion, + + __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: { + ReactCurrentOwner: ReactCurrentOwner_1, + // Used by renderers to avoid bundling object-assign twice in UMD bundles: + assign: objectAssign$1 + } + }; + + { + objectAssign$1(React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED, { + // These should not be included in production. + ReactComponentTreeHook: ReactComponentTreeHook_1, + ReactDebugCurrentFrame: ReactDebugCurrentFrame_1 + }); + } + + var ReactEntry = React; + + module.exports = ReactEntry; + })(); +} +/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0))) + +/***/ }), +/* 21 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +/* + React v16.0.0 + react-dom.production.min.js + + Copyright (c) 2013-present, Facebook, Inc. + + This source code is licensed under the MIT license found in the + LICENSE file in the root directory of this source tree. + Modernizr 3.0.0pre (Custom Build) | MIT +*/ + + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + +var aa = __webpack_require__(1);__webpack_require__(3);var l = __webpack_require__(9), + n = __webpack_require__(4), + ba = __webpack_require__(11), + ca = __webpack_require__(2), + da = __webpack_require__(5), + ea = __webpack_require__(12), + fa = __webpack_require__(13), + ha = __webpack_require__(14), + ia = __webpack_require__(15); +function w(a) { + for (var b = arguments.length - 1, c = "Minified React error #" + a + "; visit http://facebook.github.io/react/docs/error-decoder.html?invariant\x3d" + a, d = 0; d < b; d++) { + c += "\x26args[]\x3d" + encodeURIComponent(arguments[d + 1]); + }b = Error(c + " for the full message or use the non-minified dev environment for full errors and additional helpful warnings.");b.name = "Invariant Violation";b.framesToPop = 1;throw b; +}aa ? void 0 : w("227"); +function ja(a) { + switch (a) {case "svg": + return "http://www.w3.org/2000/svg";case "math": + return "http://www.w3.org/1998/Math/MathML";default: + return "http://www.w3.org/1999/xhtml";} +} +var ka = { Namespaces: { html: "http://www.w3.org/1999/xhtml", mathml: "http://www.w3.org/1998/Math/MathML", svg: "http://www.w3.org/2000/svg" }, getIntrinsicNamespace: ja, getChildNamespace: function getChildNamespace(a, b) { + return null == a || "http://www.w3.org/1999/xhtml" === a ? ja(b) : "http://www.w3.org/2000/svg" === a && "foreignObject" === b ? "http://www.w3.org/1999/xhtml" : a; + } }, + la = null, + oa = {}; +function pa() { + if (la) for (var a in oa) { + var b = oa[a], + c = la.indexOf(a);-1 < c ? void 0 : w("96", a);if (!qa.plugins[c]) { + b.extractEvents ? void 0 : w("97", a);qa.plugins[c] = b;c = b.eventTypes;for (var d in c) { + var e = void 0;var f = c[d], + g = b, + h = d;qa.eventNameDispatchConfigs.hasOwnProperty(h) ? w("99", h) : void 0;qa.eventNameDispatchConfigs[h] = f;var k = f.phasedRegistrationNames;if (k) { + for (e in k) { + k.hasOwnProperty(e) && ra(k[e], g, h); + }e = !0; + } else f.registrationName ? (ra(f.registrationName, g, h), e = !0) : e = !1;e ? void 0 : w("98", d, a); + } + } + } +} +function ra(a, b, c) { + qa.registrationNameModules[a] ? w("100", a) : void 0;qa.registrationNameModules[a] = b;qa.registrationNameDependencies[a] = b.eventTypes[c].dependencies; +} +var qa = { plugins: [], eventNameDispatchConfigs: {}, registrationNameModules: {}, registrationNameDependencies: {}, possibleRegistrationNames: null, injectEventPluginOrder: function injectEventPluginOrder(a) { + la ? w("101") : void 0;la = Array.prototype.slice.call(a);pa(); + }, injectEventPluginsByName: function injectEventPluginsByName(a) { + var b = !1, + c;for (c in a) { + if (a.hasOwnProperty(c)) { + var d = a[c];oa.hasOwnProperty(c) && oa[c] === d || (oa[c] ? w("102", c) : void 0, oa[c] = d, b = !0); + } + }b && pa(); + } }, + sa = qa, + ta = { children: !0, dangerouslySetInnerHTML: !0, autoFocus: !0, defaultValue: !0, defaultChecked: !0, + innerHTML: !0, suppressContentEditableWarning: !0, style: !0 };function ua(a, b) { + return (a & b) === b; +} +var wa = { MUST_USE_PROPERTY: 1, HAS_BOOLEAN_VALUE: 4, HAS_NUMERIC_VALUE: 8, HAS_POSITIVE_NUMERIC_VALUE: 24, HAS_OVERLOADED_BOOLEAN_VALUE: 32, HAS_STRING_BOOLEAN_VALUE: 64, injectDOMPropertyConfig: function injectDOMPropertyConfig(a) { + var b = wa, + c = a.Properties || {}, + d = a.DOMAttributeNamespaces || {}, + e = a.DOMAttributeNames || {};a = a.DOMMutationMethods || {};for (var f in c) { + xa.properties.hasOwnProperty(f) ? w("48", f) : void 0;var g = f.toLowerCase(), + h = c[f];g = { attributeName: g, attributeNamespace: null, propertyName: f, mutationMethod: null, mustUseProperty: ua(h, b.MUST_USE_PROPERTY), + hasBooleanValue: ua(h, b.HAS_BOOLEAN_VALUE), hasNumericValue: ua(h, b.HAS_NUMERIC_VALUE), hasPositiveNumericValue: ua(h, b.HAS_POSITIVE_NUMERIC_VALUE), hasOverloadedBooleanValue: ua(h, b.HAS_OVERLOADED_BOOLEAN_VALUE), hasStringBooleanValue: ua(h, b.HAS_STRING_BOOLEAN_VALUE) };1 >= g.hasBooleanValue + g.hasNumericValue + g.hasOverloadedBooleanValue ? void 0 : w("50", f);e.hasOwnProperty(f) && (g.attributeName = e[f]);d.hasOwnProperty(f) && (g.attributeNamespace = d[f]);a.hasOwnProperty(f) && (g.mutationMethod = a[f]);xa.properties[f] = g; + } + } }, + xa = { ID_ATTRIBUTE_NAME: "data-reactid", ROOT_ATTRIBUTE_NAME: "data-reactroot", ATTRIBUTE_NAME_START_CHAR: ":A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD", ATTRIBUTE_NAME_CHAR: ":A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040", + properties: {}, shouldSetAttribute: function shouldSetAttribute(a, b) { + if (xa.isReservedProp(a) || !("o" !== a[0] && "O" !== a[0] || "n" !== a[1] && "N" !== a[1])) return !1;if (null === b) return !0;switch (typeof b === "undefined" ? "undefined" : _typeof(b)) {case "boolean": + return xa.shouldAttributeAcceptBooleanValue(a);case "undefined":case "number":case "string":case "object": + return !0;default: + return !1;} + }, getPropertyInfo: function getPropertyInfo(a) { + return xa.properties.hasOwnProperty(a) ? xa.properties[a] : null; + }, shouldAttributeAcceptBooleanValue: function shouldAttributeAcceptBooleanValue(a) { + if (xa.isReservedProp(a)) return !0;var b = xa.getPropertyInfo(a); + if (b) return b.hasBooleanValue || b.hasStringBooleanValue || b.hasOverloadedBooleanValue;a = a.toLowerCase().slice(0, 5);return "data-" === a || "aria-" === a; + }, isReservedProp: function isReservedProp(a) { + return ta.hasOwnProperty(a); + }, injection: wa }, + A = xa, + E = { IndeterminateComponent: 0, FunctionalComponent: 1, ClassComponent: 2, HostRoot: 3, HostPortal: 4, HostComponent: 5, HostText: 6, CoroutineComponent: 7, CoroutineHandlerPhase: 8, YieldComponent: 9, Fragment: 10 }, + F = { ELEMENT_NODE: 1, TEXT_NODE: 3, COMMENT_NODE: 8, DOCUMENT_NODE: 9, DOCUMENT_FRAGMENT_NODE: 11 }, + ya = E.HostComponent, + za = E.HostText, + Aa = F.ELEMENT_NODE, + Ba = F.COMMENT_NODE, + Ea = A.ID_ATTRIBUTE_NAME, + Fa = { hasCachedChildNodes: 1 }, + Ga = Math.random().toString(36).slice(2), + Ha = "__reactInternalInstance$" + Ga, + Ia = "__reactEventHandlers$" + Ga;function La(a) { + for (var b; b = a._renderedComponent;) { + a = b; + }return a; +}function Ma(a, b) { + a = La(a);a._hostNode = b;b[Ha] = a; +} +function Na(a, b) { + if (!(a._flags & Fa.hasCachedChildNodes)) { + var c = a._renderedChildren;b = b.firstChild;var d;a: for (d in c) { + if (c.hasOwnProperty(d)) { + var e = c[d], + f = La(e)._domID;if (0 !== f) { + for (; null !== b; b = b.nextSibling) { + var g = b, + h = f;if (g.nodeType === Aa && g.getAttribute(Ea) === "" + h || g.nodeType === Ba && g.nodeValue === " react-text: " + h + " " || g.nodeType === Ba && g.nodeValue === " react-empty: " + h + " ") { + Ma(e, b);continue a; + } + }w("32", f); + } + } + }a._flags |= Fa.hasCachedChildNodes; + } +} +function Oa(a) { + if (a[Ha]) return a[Ha];for (var b = []; !a[Ha];) { + if (b.push(a), a.parentNode) a = a.parentNode;else return null; + }var c = a[Ha];if (c.tag === ya || c.tag === za) return c;for (; a && (c = a[Ha]); a = b.pop()) { + var d = c;b.length && Na(c, a); + }return d; +} +var G = { getClosestInstanceFromNode: Oa, getInstanceFromNode: function getInstanceFromNode(a) { + var b = a[Ha];if (b) return b.tag === ya || b.tag === za ? b : b._hostNode === a ? b : null;b = Oa(a);return null != b && b._hostNode === a ? b : null; + }, getNodeFromInstance: function getNodeFromInstance(a) { + if (a.tag === ya || a.tag === za) return a.stateNode;void 0 === a._hostNode ? w("33") : void 0;if (a._hostNode) return a._hostNode;for (var b = []; !a._hostNode;) { + b.push(a), a._hostParent ? void 0 : w("34"), a = a._hostParent; + }for (; b.length; a = b.pop()) { + Na(a, a._hostNode); + }return a._hostNode; + }, precacheChildNodes: Na, + precacheNode: Ma, uncacheNode: function uncacheNode(a) { + var b = a._hostNode;b && (delete b[Ha], a._hostNode = null); + }, precacheFiberNode: function precacheFiberNode(a, b) { + b[Ha] = a; + }, getFiberCurrentPropsFromNode: function getFiberCurrentPropsFromNode(a) { + return a[Ia] || null; + }, updateFiberProps: function updateFiberProps(a, b) { + a[Ia] = b; + } }, + Pa = { remove: function remove(a) { + a._reactInternalFiber = void 0; + }, get: function get(a) { + return a._reactInternalFiber; + }, has: function has(a) { + return void 0 !== a._reactInternalFiber; + }, set: function set(a, b) { + a._reactInternalFiber = b; + } }, + Qa = { ReactCurrentOwner: aa.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner }; +function Ra(a) { + if ("function" === typeof a.getName) return a.getName();if ("number" === typeof a.tag) { + a = a.type;if ("string" === typeof a) return a;if ("function" === typeof a) return a.displayName || a.name; + }return null; +}var J = { NoEffect: 0, PerformedWork: 1, Placement: 2, Update: 4, PlacementAndUpdate: 6, Deletion: 8, ContentReset: 16, Callback: 32, Err: 64, Ref: 128 }, + Sa = E.HostComponent, + Ta = E.HostRoot, + Ua = E.HostPortal, + Va = E.HostText, + Wa = J.NoEffect, + Xa = J.Placement; +function Za(a) { + var b = a;if (a.alternate) for (; b["return"];) { + b = b["return"]; + } else { + if ((b.effectTag & Xa) !== Wa) return 1;for (; b["return"];) { + if (b = b["return"], (b.effectTag & Xa) !== Wa) return 1; + } + }return b.tag === Ta ? 2 : 3; +}function $a(a) { + 2 !== Za(a) ? w("188") : void 0; +} +function ab(a) { + var b = a.alternate;if (!b) return b = Za(a), 3 === b ? w("188") : void 0, 1 === b ? null : a;for (var c = a, d = b;;) { + var e = c["return"], + f = e ? e.alternate : null;if (!e || !f) break;if (e.child === f.child) { + for (var g = e.child; g;) { + if (g === c) return $a(e), a;if (g === d) return $a(e), b;g = g.sibling; + }w("188"); + }if (c["return"] !== d["return"]) c = e, d = f;else { + g = !1;for (var h = e.child; h;) { + if (h === c) { + g = !0;c = e;d = f;break; + }if (h === d) { + g = !0;d = e;c = f;break; + }h = h.sibling; + }if (!g) { + for (h = f.child; h;) { + if (h === c) { + g = !0;c = f;d = e;break; + }if (h === d) { + g = !0;d = f;c = e;break; + }h = h.sibling; + }g ? void 0 : w("189"); + } + }c.alternate !== d ? w("190") : void 0; + }c.tag !== Ta ? w("188") : void 0;return c.stateNode.current === c ? a : b; +} +var bb = { isFiberMounted: function isFiberMounted(a) { + return 2 === Za(a); + }, isMounted: function isMounted(a) { + return (a = Pa.get(a)) ? 2 === Za(a) : !1; + }, findCurrentFiberUsingSlowPath: ab, findCurrentHostFiber: function findCurrentHostFiber(a) { + a = ab(a);if (!a) return null;for (var b = a;;) { + if (b.tag === Sa || b.tag === Va) return b;if (b.child) b.child["return"] = b, b = b.child;else { + if (b === a) break;for (; !b.sibling;) { + if (!b["return"] || b["return"] === a) return null;b = b["return"]; + }b.sibling["return"] = b["return"];b = b.sibling; + } + }return null; + }, findCurrentHostFiberWithNoPortals: function findCurrentHostFiberWithNoPortals(a) { + a = ab(a); + if (!a) return null;for (var b = a;;) { + if (b.tag === Sa || b.tag === Va) return b;if (b.child && b.tag !== Ua) b.child["return"] = b, b = b.child;else { + if (b === a) break;for (; !b.sibling;) { + if (!b["return"] || b["return"] === a) return null;b = b["return"]; + }b.sibling["return"] = b["return"];b = b.sibling; + } + }return null; + } }, + K = { _caughtError: null, _hasCaughtError: !1, _rethrowError: null, _hasRethrowError: !1, injection: { injectErrorUtils: function injectErrorUtils(a) { + "function" !== typeof a.invokeGuardedCallback ? w("197") : void 0;cb = a.invokeGuardedCallback; + } }, invokeGuardedCallback: function invokeGuardedCallback(a, b, c, d, e, f, g, h, k) { + cb.apply(K, arguments); + }, invokeGuardedCallbackAndCatchFirstError: function invokeGuardedCallbackAndCatchFirstError(a, b, c, d, e, f, g, h, k) { + K.invokeGuardedCallback.apply(this, arguments);if (K.hasCaughtError()) { + var p = K.clearCaughtError();K._hasRethrowError || (K._hasRethrowError = !0, K._rethrowError = p); + } + }, rethrowCaughtError: function rethrowCaughtError() { + return db.apply(K, arguments); + }, hasCaughtError: function hasCaughtError() { + return K._hasCaughtError; + }, clearCaughtError: function clearCaughtError() { + if (K._hasCaughtError) { + var a = K._caughtError;K._caughtError = null;K._hasCaughtError = !1;return a; + }w("198"); + } }; +function cb(a, b, c, d, e, f, g, h, k) { + K._hasCaughtError = !1;K._caughtError = null;var p = Array.prototype.slice.call(arguments, 3);try { + b.apply(c, p); + } catch (x) { + K._caughtError = x, K._hasCaughtError = !0; + } +}function db() { + if (K._hasRethrowError) { + var a = K._rethrowError;K._rethrowError = null;K._hasRethrowError = !1;throw a; + } +}var eb = K, + fb;function gb(a, b, c, d) { + b = a.type || "unknown-event";a.currentTarget = hb.getNodeFromInstance(d);eb.invokeGuardedCallbackAndCatchFirstError(b, c, void 0, a);a.currentTarget = null; +} +var hb = { isEndish: function isEndish(a) { + return "topMouseUp" === a || "topTouchEnd" === a || "topTouchCancel" === a; + }, isMoveish: function isMoveish(a) { + return "topMouseMove" === a || "topTouchMove" === a; + }, isStartish: function isStartish(a) { + return "topMouseDown" === a || "topTouchStart" === a; + }, executeDirectDispatch: function executeDirectDispatch(a) { + var b = a._dispatchListeners, + c = a._dispatchInstances;Array.isArray(b) ? w("103") : void 0;a.currentTarget = b ? hb.getNodeFromInstance(c) : null;b = b ? b(a) : null;a.currentTarget = null;a._dispatchListeners = null;a._dispatchInstances = null;return b; + }, executeDispatchesInOrder: function executeDispatchesInOrder(a, b) { + var c = a._dispatchListeners, + d = a._dispatchInstances;if (Array.isArray(c)) for (var e = 0; e < c.length && !a.isPropagationStopped(); e++) { + gb(a, b, c[e], d[e]); + } else c && gb(a, b, c, d);a._dispatchListeners = null;a._dispatchInstances = null; + }, executeDispatchesInOrderStopAtTrue: function executeDispatchesInOrderStopAtTrue(a) { + a: { + var b = a._dispatchListeners;var c = a._dispatchInstances;if (Array.isArray(b)) for (var d = 0; d < b.length && !a.isPropagationStopped(); d++) { + if (b[d](a, c[d])) { + b = c[d];break a; + } + } else if (b && b(a, c)) { + b = c;break a; + }b = null; + }a._dispatchInstances = null;a._dispatchListeners = null;return b; + }, hasDispatches: function hasDispatches(a) { + return !!a._dispatchListeners; + }, getFiberCurrentPropsFromNode: function getFiberCurrentPropsFromNode(a) { + return fb.getFiberCurrentPropsFromNode(a); + }, getInstanceFromNode: function getInstanceFromNode(a) { + return fb.getInstanceFromNode(a); + }, getNodeFromInstance: function getNodeFromInstance(a) { + return fb.getNodeFromInstance(a); + }, injection: { injectComponentTree: function injectComponentTree(a) { + fb = a; + } } }, + ib = hb, + jb = null, + kb = null, + lb = null; +function mb(a) { + if (a = ib.getInstanceFromNode(a)) if ("number" === typeof a.tag) { + jb && "function" === typeof jb.restoreControlledState ? void 0 : w("194");var b = ib.getFiberCurrentPropsFromNode(a.stateNode);jb.restoreControlledState(a.stateNode, a.type, b); + } else "function" !== typeof a.restoreControlledState ? w("195") : void 0, a.restoreControlledState(); +} +var nb = { injection: { injectFiberControlledHostComponent: function injectFiberControlledHostComponent(a) { + jb = a; + } }, enqueueStateRestore: function enqueueStateRestore(a) { + kb ? lb ? lb.push(a) : lb = [a] : kb = a; + }, restoreStateIfNeeded: function restoreStateIfNeeded() { + if (kb) { + var a = kb, + b = lb;lb = kb = null;mb(a);if (b) for (a = 0; a < b.length; a++) { + mb(b[a]); + } + } + } };function ob(a, b, c, d, e, f) { + return a(b, c, d, e, f); +}function pb(a, b) { + return a(b); +}function qb(a, b) { + return pb(a, b); +} +var rb = !1, + sb = { batchedUpdates: function batchedUpdates(a, b) { + if (rb) return ob(qb, a, b);rb = !0;try { + return ob(qb, a, b); + } finally { + rb = !1, nb.restoreStateIfNeeded(); + } + }, injection: { injectStackBatchedUpdates: function injectStackBatchedUpdates(a) { + ob = a; + }, injectFiberBatchedUpdates: function injectFiberBatchedUpdates(a) { + pb = a; + } } }, + tb = F.TEXT_NODE;function ub(a) { + a = a.target || a.srcElement || window;a.correspondingUseElement && (a = a.correspondingUseElement);return a.nodeType === tb ? a.parentNode : a; +}var vb = E.HostRoot, + wb = []; +function xb(a) { + var b = a.targetInst;do { + if (!b) { + a.ancestors.push(b);break; + }var c = b;if ("number" === typeof c.tag) { + for (; c["return"];) { + c = c["return"]; + }c = c.tag !== vb ? null : c.stateNode.containerInfo; + } else { + for (; c._hostParent;) { + c = c._hostParent; + }c = G.getNodeFromInstance(c).parentNode; + }if (!c) break;a.ancestors.push(b);b = G.getClosestInstanceFromNode(c); + } while (b);for (c = 0; c < a.ancestors.length; c++) { + b = a.ancestors[c], yb._handleTopLevel(a.topLevelType, b, a.nativeEvent, ub(a.nativeEvent)); + } +} +var yb = { _enabled: !0, _handleTopLevel: null, setHandleTopLevel: function setHandleTopLevel(a) { + yb._handleTopLevel = a; + }, setEnabled: function setEnabled(a) { + yb._enabled = !!a; + }, isEnabled: function isEnabled() { + return yb._enabled; + }, trapBubbledEvent: function trapBubbledEvent(a, b, c) { + return c ? ba.listen(c, b, yb.dispatchEvent.bind(null, a)) : null; + }, trapCapturedEvent: function trapCapturedEvent(a, b, c) { + return c ? ba.capture(c, b, yb.dispatchEvent.bind(null, a)) : null; + }, dispatchEvent: function dispatchEvent(a, b) { + if (yb._enabled) { + var c = ub(b);c = G.getClosestInstanceFromNode(c);null === c || "number" !== typeof c.tag || bb.isFiberMounted(c) || (c = null);if (wb.length) { + var d = wb.pop();d.topLevelType = a;d.nativeEvent = b;d.targetInst = c;a = d; + } else a = { topLevelType: a, nativeEvent: b, targetInst: c, ancestors: [] };try { + sb.batchedUpdates(xb, a); + } finally { + a.topLevelType = null, a.nativeEvent = null, a.targetInst = null, a.ancestors.length = 0, 10 > wb.length && wb.push(a); + } + } + } }, + L = yb;function Cb(a, b) { + null == b ? w("30") : void 0;if (null == a) return b;if (Array.isArray(a)) { + if (Array.isArray(b)) return a.push.apply(a, b), a;a.push(b);return a; + }return Array.isArray(b) ? [a].concat(b) : [a, b]; +} +function Db(a, b, c) { + Array.isArray(a) ? a.forEach(b, c) : a && b.call(c, a); +}var Eb = null;function Fb(a, b) { + a && (ib.executeDispatchesInOrder(a, b), a.isPersistent() || a.constructor.release(a)); +}function Gb(a) { + return Fb(a, !0); +}function Hb(a) { + return Fb(a, !1); +} +function Ib(a, b, c) { + switch (a) {case "onClick":case "onClickCapture":case "onDoubleClick":case "onDoubleClickCapture":case "onMouseDown":case "onMouseDownCapture":case "onMouseMove":case "onMouseMoveCapture":case "onMouseUp":case "onMouseUpCapture": + return !(!c.disabled || "button" !== b && "input" !== b && "select" !== b && "textarea" !== b);default: + return !1;} +} +var Jb = { injection: { injectEventPluginOrder: sa.injectEventPluginOrder, injectEventPluginsByName: sa.injectEventPluginsByName }, getListener: function getListener(a, b) { + if ("number" === typeof a.tag) { + var c = a.stateNode;if (!c) return null;var d = ib.getFiberCurrentPropsFromNode(c);if (!d) return null;c = d[b];if (Ib(b, a.type, d)) return null; + } else { + d = a._currentElement;if ("string" === typeof d || "number" === typeof d || !a._rootNodeID) return null;a = d.props;c = a[b];if (Ib(b, d.type, a)) return null; + }c && "function" !== typeof c ? w("231", b, typeof c === "undefined" ? "undefined" : _typeof(c)) : void 0; + return c; + }, extractEvents: function extractEvents(a, b, c, d) { + for (var e, f = sa.plugins, g = 0; g < f.length; g++) { + var h = f[g];h && (h = h.extractEvents(a, b, c, d)) && (e = Cb(e, h)); + }return e; + }, enqueueEvents: function enqueueEvents(a) { + a && (Eb = Cb(Eb, a)); + }, processEventQueue: function processEventQueue(a) { + var b = Eb;Eb = null;a ? Db(b, Gb) : Db(b, Hb);Eb ? w("95") : void 0;eb.rethrowCaughtError(); + } }, + Kb;l.canUseDOM && (Kb = document.implementation && document.implementation.hasFeature && !0 !== document.implementation.hasFeature("", "")); +function Lb(a, b) { + if (!l.canUseDOM || b && !("addEventListener" in document)) return !1;b = "on" + a;var c = b in document;c || (c = document.createElement("div"), c.setAttribute(b, "return;"), c = "function" === typeof c[b]);!c && Kb && "wheel" === a && (c = document.implementation.hasFeature("Events.wheel", "3.0"));return c; +}function Mb(a, b) { + var c = {};c[a.toLowerCase()] = b.toLowerCase();c["Webkit" + a] = "webkit" + b;c["Moz" + a] = "moz" + b;c["ms" + a] = "MS" + b;c["O" + a] = "o" + b.toLowerCase();return c; +} +var Nb = { animationend: Mb("Animation", "AnimationEnd"), animationiteration: Mb("Animation", "AnimationIteration"), animationstart: Mb("Animation", "AnimationStart"), transitionend: Mb("Transition", "TransitionEnd") }, + Ob = {}, + Pb = {};l.canUseDOM && (Pb = document.createElement("div").style, "AnimationEvent" in window || (delete Nb.animationend.animation, delete Nb.animationiteration.animation, delete Nb.animationstart.animation), "TransitionEvent" in window || delete Nb.transitionend.transition); +function Qb(a) { + if (Ob[a]) return Ob[a];if (!Nb[a]) return a;var b = Nb[a], + c;for (c in b) { + if (b.hasOwnProperty(c) && c in Pb) return Ob[a] = b[c]; + }return ""; +} +var Rb = { topAbort: "abort", topAnimationEnd: Qb("animationend") || "animationend", topAnimationIteration: Qb("animationiteration") || "animationiteration", topAnimationStart: Qb("animationstart") || "animationstart", topBlur: "blur", topCancel: "cancel", topCanPlay: "canplay", topCanPlayThrough: "canplaythrough", topChange: "change", topClick: "click", topClose: "close", topCompositionEnd: "compositionend", topCompositionStart: "compositionstart", topCompositionUpdate: "compositionupdate", topContextMenu: "contextmenu", topCopy: "copy", + topCut: "cut", topDoubleClick: "dblclick", topDrag: "drag", topDragEnd: "dragend", topDragEnter: "dragenter", topDragExit: "dragexit", topDragLeave: "dragleave", topDragOver: "dragover", topDragStart: "dragstart", topDrop: "drop", topDurationChange: "durationchange", topEmptied: "emptied", topEncrypted: "encrypted", topEnded: "ended", topError: "error", topFocus: "focus", topInput: "input", topKeyDown: "keydown", topKeyPress: "keypress", topKeyUp: "keyup", topLoadedData: "loadeddata", topLoad: "load", topLoadedMetadata: "loadedmetadata", topLoadStart: "loadstart", + topMouseDown: "mousedown", topMouseMove: "mousemove", topMouseOut: "mouseout", topMouseOver: "mouseover", topMouseUp: "mouseup", topPaste: "paste", topPause: "pause", topPlay: "play", topPlaying: "playing", topProgress: "progress", topRateChange: "ratechange", topScroll: "scroll", topSeeked: "seeked", topSeeking: "seeking", topSelectionChange: "selectionchange", topStalled: "stalled", topSuspend: "suspend", topTextInput: "textInput", topTimeUpdate: "timeupdate", topToggle: "toggle", topTouchCancel: "touchcancel", topTouchEnd: "touchend", topTouchMove: "touchmove", + topTouchStart: "touchstart", topTransitionEnd: Qb("transitionend") || "transitionend", topVolumeChange: "volumechange", topWaiting: "waiting", topWheel: "wheel" }, + Sb = {}, + Tb = 0, + Ub = "_reactListenersID" + ("" + Math.random()).slice(2);function Vb(a) { + Object.prototype.hasOwnProperty.call(a, Ub) || (a[Ub] = Tb++, Sb[a[Ub]] = {});return Sb[a[Ub]]; +} +var M = n({}, { handleTopLevel: function handleTopLevel(a, b, c, d) { + a = Jb.extractEvents(a, b, c, d);Jb.enqueueEvents(a);Jb.processEventQueue(!1); + } }, { setEnabled: function setEnabled(a) { + L && L.setEnabled(a); + }, isEnabled: function isEnabled() { + return !(!L || !L.isEnabled()); + }, listenTo: function listenTo(a, b) { + var c = Vb(b);a = sa.registrationNameDependencies[a];for (var d = 0; d < a.length; d++) { + var e = a[d];c.hasOwnProperty(e) && c[e] || ("topWheel" === e ? Lb("wheel") ? L.trapBubbledEvent("topWheel", "wheel", b) : Lb("mousewheel") ? L.trapBubbledEvent("topWheel", "mousewheel", b) : L.trapBubbledEvent("topWheel", "DOMMouseScroll", b) : "topScroll" === e ? L.trapCapturedEvent("topScroll", "scroll", b) : "topFocus" === e || "topBlur" === e ? (L.trapCapturedEvent("topFocus", "focus", b), L.trapCapturedEvent("topBlur", "blur", b), c.topBlur = !0, c.topFocus = !0) : "topCancel" === e ? (Lb("cancel", !0) && L.trapCapturedEvent("topCancel", "cancel", b), c.topCancel = !0) : "topClose" === e ? (Lb("close", !0) && L.trapCapturedEvent("topClose", "close", b), c.topClose = !0) : Rb.hasOwnProperty(e) && L.trapBubbledEvent(e, Rb[e], b), c[e] = !0); + } + }, isListeningToAllDependencies: function isListeningToAllDependencies(a, b) { + b = Vb(b);a = sa.registrationNameDependencies[a];for (var c = 0; c < a.length; c++) { + var d = a[c];if (!b.hasOwnProperty(d) || !b[d]) return !1; + }return !0; + }, trapBubbledEvent: function trapBubbledEvent(a, b, c) { + return L.trapBubbledEvent(a, b, c); + }, trapCapturedEvent: function trapCapturedEvent(a, b, c) { + return L.trapCapturedEvent(a, b, c); + } }), + Wb = { animationIterationCount: !0, borderImageOutset: !0, borderImageSlice: !0, borderImageWidth: !0, boxFlex: !0, boxFlexGroup: !0, boxOrdinalGroup: !0, columnCount: !0, columns: !0, flex: !0, flexGrow: !0, flexPositive: !0, flexShrink: !0, flexNegative: !0, + flexOrder: !0, gridRow: !0, gridRowEnd: !0, gridRowSpan: !0, gridRowStart: !0, gridColumn: !0, gridColumnEnd: !0, gridColumnSpan: !0, gridColumnStart: !0, fontWeight: !0, lineClamp: !0, lineHeight: !0, opacity: !0, order: !0, orphans: !0, tabSize: !0, widows: !0, zIndex: !0, zoom: !0, fillOpacity: !0, floodOpacity: !0, stopOpacity: !0, strokeDasharray: !0, strokeDashoffset: !0, strokeMiterlimit: !0, strokeOpacity: !0, strokeWidth: !0 }, + Xb = ["Webkit", "ms", "Moz", "O"]; +Object.keys(Wb).forEach(function (a) { + Xb.forEach(function (b) { + b = b + a.charAt(0).toUpperCase() + a.substring(1);Wb[b] = Wb[a]; + }); +}); +var Yb = { isUnitlessNumber: Wb, shorthandPropertyExpansions: { background: { backgroundAttachment: !0, backgroundColor: !0, backgroundImage: !0, backgroundPositionX: !0, backgroundPositionY: !0, backgroundRepeat: !0 }, backgroundPosition: { backgroundPositionX: !0, backgroundPositionY: !0 }, border: { borderWidth: !0, borderStyle: !0, borderColor: !0 }, borderBottom: { borderBottomWidth: !0, borderBottomStyle: !0, borderBottomColor: !0 }, borderLeft: { borderLeftWidth: !0, borderLeftStyle: !0, borderLeftColor: !0 }, borderRight: { borderRightWidth: !0, borderRightStyle: !0, + borderRightColor: !0 }, borderTop: { borderTopWidth: !0, borderTopStyle: !0, borderTopColor: !0 }, font: { fontStyle: !0, fontVariant: !0, fontWeight: !0, fontSize: !0, lineHeight: !0, fontFamily: !0 }, outline: { outlineWidth: !0, outlineStyle: !0, outlineColor: !0 } } }, + Zb = Yb.isUnitlessNumber, + $b = !1;if (l.canUseDOM) { + var ac = document.createElement("div").style;try { + ac.font = ""; + } catch (a) { + $b = !0; + } +} +var bc = { createDangerousStringForStyles: function createDangerousStringForStyles() {}, setValueForStyles: function setValueForStyles(a, b) { + a = a.style;for (var c in b) { + if (b.hasOwnProperty(c)) { + var d = 0 === c.indexOf("--");var e = c;var f = b[c];e = null == f || "boolean" === typeof f || "" === f ? "" : d || "number" !== typeof f || 0 === f || Zb.hasOwnProperty(e) && Zb[e] ? ("" + f).trim() : f + "px";"float" === c && (c = "cssFloat");if (d) a.setProperty(c, e);else if (e) a[c] = e;else if (d = $b && Yb.shorthandPropertyExpansions[c]) for (var g in d) { + a[g] = ""; + } else a[c] = ""; + } + } + } }, + cc = new RegExp("^[" + A.ATTRIBUTE_NAME_START_CHAR + "][" + A.ATTRIBUTE_NAME_CHAR + "]*$"), + dc = {}, + ec = {};function fc(a) { + if (ec.hasOwnProperty(a)) return !0;if (dc.hasOwnProperty(a)) return !1;if (cc.test(a)) return ec[a] = !0;dc[a] = !0;return !1; +} +var gc = { setAttributeForID: function setAttributeForID(a, b) { + a.setAttribute(A.ID_ATTRIBUTE_NAME, b); + }, setAttributeForRoot: function setAttributeForRoot(a) { + a.setAttribute(A.ROOT_ATTRIBUTE_NAME, ""); + }, getValueForProperty: function getValueForProperty() {}, getValueForAttribute: function getValueForAttribute() {}, setValueForProperty: function setValueForProperty(a, b, c) { + var d = A.getPropertyInfo(b);if (d && A.shouldSetAttribute(b, c)) { + var e = d.mutationMethod;e ? e(a, c) : null == c || d.hasBooleanValue && !c || d.hasNumericValue && isNaN(c) || d.hasPositiveNumericValue && 1 > c || d.hasOverloadedBooleanValue && !1 === c ? gc.deleteValueForProperty(a, b) : d.mustUseProperty ? a[d.propertyName] = c : (b = d.attributeName, (e = d.attributeNamespace) ? a.setAttributeNS(e, b, "" + c) : d.hasBooleanValue || d.hasOverloadedBooleanValue && !0 === c ? a.setAttribute(b, "") : a.setAttribute(b, "" + c)); + } else gc.setValueForAttribute(a, b, A.shouldSetAttribute(b, c) ? c : null); + }, setValueForAttribute: function setValueForAttribute(a, b, c) { + fc(b) && (null == c ? a.removeAttribute(b) : a.setAttribute(b, "" + c)); + }, deleteValueForAttribute: function deleteValueForAttribute(a, b) { + a.removeAttribute(b); + }, deleteValueForProperty: function deleteValueForProperty(a, b) { + var c = A.getPropertyInfo(b); + c ? (b = c.mutationMethod) ? b(a, void 0) : c.mustUseProperty ? a[c.propertyName] = c.hasBooleanValue ? !1 : "" : a.removeAttribute(c.attributeName) : a.removeAttribute(b); + } }, + hc = gc, + ic = Qa.ReactDebugCurrentFrame;function jc() { + return null; +} +var kc = { current: null, phase: null, resetCurrentFiber: function resetCurrentFiber() { + ic.getCurrentStack = null;kc.current = null;kc.phase = null; + }, setCurrentFiber: function setCurrentFiber(a, b) { + ic.getCurrentStack = jc;kc.current = a;kc.phase = b; + }, getCurrentFiberOwnerName: function getCurrentFiberOwnerName() { + return null; + }, getCurrentFiberStackAddendum: jc }, + lc = kc, + mc = { getHostProps: function getHostProps(a, b) { + var c = b.value, + d = b.checked;return n({ type: void 0, step: void 0, min: void 0, max: void 0 }, b, { defaultChecked: void 0, defaultValue: void 0, value: null != c ? c : a._wrapperState.initialValue, checked: null != d ? d : a._wrapperState.initialChecked }); + }, initWrapperState: function initWrapperState(a, b) { + var c = b.defaultValue;a._wrapperState = { initialChecked: null != b.checked ? b.checked : b.defaultChecked, initialValue: null != b.value ? b.value : c, controlled: "checkbox" === b.type || "radio" === b.type ? null != b.checked : null != b.value }; + }, updateWrapper: function updateWrapper(a, b) { + var c = b.checked;null != c && hc.setValueForProperty(a, "checked", c || !1);c = b.value;if (null != c) { + if (0 === c && "" === a.value) a.value = "0";else if ("number" === b.type) { + if (b = parseFloat(a.value) || 0, c != b || c == b && a.value != c) a.value = "" + c; + } else a.value !== "" + c && (a.value = "" + c); + } else null == b.value && null != b.defaultValue && a.defaultValue !== "" + b.defaultValue && (a.defaultValue = "" + b.defaultValue), null == b.checked && null != b.defaultChecked && (a.defaultChecked = !!b.defaultChecked); + }, postMountWrapper: function postMountWrapper(a, b) { + switch (b.type) {case "submit":case "reset": + break;case "color":case "date":case "datetime":case "datetime-local":case "month":case "time":case "week": + a.value = "";a.value = a.defaultValue;break;default: + a.value = a.value;}b = a.name;"" !== b && (a.name = "");a.defaultChecked = !a.defaultChecked;a.defaultChecked = !a.defaultChecked;"" !== b && (a.name = b); + }, restoreControlledState: function restoreControlledState(a, b) { + mc.updateWrapper(a, b);var c = b.name;if ("radio" === b.type && null != c) { + for (b = a; b.parentNode;) { + b = b.parentNode; + }c = b.querySelectorAll("input[name\x3d" + JSON.stringify("" + c) + '][type\x3d"radio"]');for (b = 0; b < c.length; b++) { + var d = c[b];if (d !== a && d.form === a.form) { + var e = G.getFiberCurrentPropsFromNode(d);e ? void 0 : w("90");mc.updateWrapper(d, e); + } + } + } + } }, + qc = mc; +function rc(a) { + var b = "";aa.Children.forEach(a, function (a) { + null == a || "string" !== typeof a && "number" !== typeof a || (b += a); + });return b; +}var sc = { validateProps: function validateProps() {}, postMountWrapper: function postMountWrapper(a, b) { + null != b.value && a.setAttribute("value", b.value); + }, getHostProps: function getHostProps(a, b) { + a = n({ children: void 0 }, b);if (b = rc(b.children)) a.children = b;return a; + } }; +function tc(a, b, c) { + a = a.options;if (b) { + b = {};for (var d = 0; d < c.length; d++) { + b["$" + c[d]] = !0; + }for (c = 0; c < a.length; c++) { + d = b.hasOwnProperty("$" + a[c].value), a[c].selected !== d && (a[c].selected = d); + } + } else { + c = "" + c;b = null;for (d = 0; d < a.length; d++) { + if (a[d].value === c) { + a[d].selected = !0;return; + }null !== b || a[d].disabled || (b = a[d]); + }null !== b && (b.selected = !0); + } +} +var uc = { getHostProps: function getHostProps(a, b) { + return n({}, b, { value: void 0 }); + }, initWrapperState: function initWrapperState(a, b) { + var c = b.value;a._wrapperState = { initialValue: null != c ? c : b.defaultValue, wasMultiple: !!b.multiple }; + }, postMountWrapper: function postMountWrapper(a, b) { + a.multiple = !!b.multiple;var c = b.value;null != c ? tc(a, !!b.multiple, c) : null != b.defaultValue && tc(a, !!b.multiple, b.defaultValue); + }, postUpdateWrapper: function postUpdateWrapper(a, b) { + a._wrapperState.initialValue = void 0;var c = a._wrapperState.wasMultiple;a._wrapperState.wasMultiple = !!b.multiple;var d = b.value; + null != d ? tc(a, !!b.multiple, d) : c !== !!b.multiple && (null != b.defaultValue ? tc(a, !!b.multiple, b.defaultValue) : tc(a, !!b.multiple, b.multiple ? [] : "")); + }, restoreControlledState: function restoreControlledState(a, b) { + var c = b.value;null != c && tc(a, !!b.multiple, c); + } }, + vc = { getHostProps: function getHostProps(a, b) { + null != b.dangerouslySetInnerHTML ? w("91") : void 0;return n({}, b, { value: void 0, defaultValue: void 0, children: "" + a._wrapperState.initialValue }); + }, initWrapperState: function initWrapperState(a, b) { + var c = b.value, + d = c;null == c && (c = b.defaultValue, b = b.children, null != b && (null != c ? w("92") : void 0, Array.isArray(b) && (1 >= b.length ? void 0 : w("93"), b = b[0]), c = "" + b), null == c && (c = ""), d = c);a._wrapperState = { initialValue: "" + d }; + }, updateWrapper: function updateWrapper(a, b) { + var c = b.value;null != c && (c = "" + c, c !== a.value && (a.value = c), null == b.defaultValue && (a.defaultValue = c));null != b.defaultValue && (a.defaultValue = b.defaultValue); + }, postMountWrapper: function postMountWrapper(a) { + var b = a.textContent;b === a._wrapperState.initialValue && (a.value = b); + }, restoreControlledState: function restoreControlledState(a, b) { + vc.updateWrapper(a, b); + } }, + wc = vc, + xc = n({ menuitem: !0 }, { area: !0, + base: !0, br: !0, col: !0, embed: !0, hr: !0, img: !0, input: !0, keygen: !0, link: !0, meta: !0, param: !0, source: !0, track: !0, wbr: !0 });function yc(a, b) { + b && (xc[a] && (null != b.children || null != b.dangerouslySetInnerHTML ? w("137", a, "") : void 0), null != b.dangerouslySetInnerHTML && (null != b.children ? w("60") : void 0, "object" === _typeof(b.dangerouslySetInnerHTML) && "__html" in b.dangerouslySetInnerHTML ? void 0 : w("61")), null != b.style && "object" !== _typeof(b.style) ? w("62", "") : void 0); +} +function zc(a) { + var b = a.type;return (a = a.nodeName) && "input" === a.toLowerCase() && ("checkbox" === b || "radio" === b); +} +function Ac(a) { + var b = zc(a) ? "checked" : "value", + c = Object.getOwnPropertyDescriptor(a.constructor.prototype, b), + d = "" + a[b];if (!a.hasOwnProperty(b) && "function" === typeof c.get && "function" === typeof c.set) return Object.defineProperty(a, b, { enumerable: c.enumerable, configurable: !0, get: function get() { + return c.get.call(this); + }, set: function set(a) { + d = "" + a;c.set.call(this, a); + } }), { getValue: function getValue() { + return d; + }, setValue: function setValue(a) { + d = "" + a; + }, stopTracking: function stopTracking() { + a._valueTracker = null;delete a[b]; + } }; +} +var Bc = { _getTrackerFromNode: function _getTrackerFromNode(a) { + return a._valueTracker; + }, track: function track(a) { + a._valueTracker || (a._valueTracker = Ac(a)); + }, updateValueIfChanged: function updateValueIfChanged(a) { + if (!a) return !1;var b = a._valueTracker;if (!b) return !0;var c = b.getValue();var d = "";a && (d = zc(a) ? a.checked ? "true" : "false" : a.value);a = d;return a !== c ? (b.setValue(a), !0) : !1; + }, stopTracking: function stopTracking(a) { + (a = a._valueTracker) && a.stopTracking(); + } }; +function Cc(a, b) { + if (-1 === a.indexOf("-")) return "string" === typeof b.is;switch (a) {case "annotation-xml":case "color-profile":case "font-face":case "font-face-src":case "font-face-uri":case "font-face-format":case "font-face-name":case "missing-glyph": + return !1;default: + return !0;} +} +var Dc = ka.Namespaces, + Ec, + Fc = function (a) { + return "undefined" !== typeof MSApp && MSApp.execUnsafeLocalFunction ? function (b, c, d, e) { + MSApp.execUnsafeLocalFunction(function () { + return a(b, c, d, e); + }); + } : a; +}(function (a, b) { + if (a.namespaceURI !== Dc.svg || "innerHTML" in a) a.innerHTML = b;else for (Ec = Ec || document.createElement("div"), Ec.innerHTML = "\x3csvg\x3e" + b + "\x3c/svg\x3e", b = Ec.firstChild; b.firstChild;) { + a.appendChild(b.firstChild); + } +}), + Gc = /["'&<>]/, + Hc = F.TEXT_NODE; +function Ic(a, b) { + if (b) { + var c = a.firstChild;if (c && c === a.lastChild && c.nodeType === Hc) { + c.nodeValue = b;return; + } + }a.textContent = b; +} +l.canUseDOM && ("textContent" in document.documentElement || (Ic = function Ic(a, b) { + if (a.nodeType === Hc) a.nodeValue = b;else { + if ("boolean" === typeof b || "number" === typeof b) b = "" + b;else { + b = "" + b;var c = Gc.exec(b);if (c) { + var d = "", + e, + f = 0;for (e = c.index; e < b.length; e++) { + switch (b.charCodeAt(e)) {case 34: + c = "\x26quot;";break;case 38: + c = "\x26amp;";break;case 39: + c = "\x26#x27;";break;case 60: + c = "\x26lt;";break;case 62: + c = "\x26gt;";break;default: + continue;}f !== e && (d += b.substring(f, e));f = e + 1;d += c; + }b = f !== e ? d + b.substring(f, e) : d; + } + }Fc(a, b); + } +})); +var Jc = Ic, + Kc = lc.getCurrentFiberOwnerName, + Lc = F.DOCUMENT_NODE, + Mc = F.DOCUMENT_FRAGMENT_NODE, + Nc = M.listenTo, + Oc = sa.registrationNameModules, + Pc = ka.Namespaces.html, + Qc = ka.getIntrinsicNamespace;function Rc(a, b) { + Nc(b, a.nodeType === Lc || a.nodeType === Mc ? a : a.ownerDocument); +} +var Sc = { topAbort: "abort", topCanPlay: "canplay", topCanPlayThrough: "canplaythrough", topDurationChange: "durationchange", topEmptied: "emptied", topEncrypted: "encrypted", topEnded: "ended", topError: "error", topLoadedData: "loadeddata", topLoadedMetadata: "loadedmetadata", topLoadStart: "loadstart", topPause: "pause", topPlay: "play", topPlaying: "playing", topProgress: "progress", topRateChange: "ratechange", topSeeked: "seeked", topSeeking: "seeking", topStalled: "stalled", topSuspend: "suspend", topTimeUpdate: "timeupdate", topVolumeChange: "volumechange", + topWaiting: "waiting" }, + N = { createElement: function createElement(a, b, c, d) { + c = c.nodeType === Lc ? c : c.ownerDocument;d === Pc && (d = Qc(a));d === Pc ? "script" === a ? (a = c.createElement("div"), a.innerHTML = "\x3cscript\x3e\x3c/script\x3e", a = a.removeChild(a.firstChild)) : a = "string" === typeof b.is ? c.createElement(a, { is: b.is }) : c.createElement(a) : a = c.createElementNS(d, a);return a; + }, createTextNode: function createTextNode(a, b) { + return (b.nodeType === Lc ? b : b.ownerDocument).createTextNode(a); + }, setInitialProperties: function setInitialProperties(a, b, c, d) { + var e = Cc(b, c);switch (b) {case "iframe":case "object": + M.trapBubbledEvent("topLoad", "load", a);var f = c;break;case "video":case "audio": + for (f in Sc) { + Sc.hasOwnProperty(f) && M.trapBubbledEvent(f, Sc[f], a); + }f = c;break;case "source": + M.trapBubbledEvent("topError", "error", a);f = c;break;case "img":case "image": + M.trapBubbledEvent("topError", "error", a);M.trapBubbledEvent("topLoad", "load", a);f = c;break;case "form": + M.trapBubbledEvent("topReset", "reset", a);M.trapBubbledEvent("topSubmit", "submit", a);f = c;break;case "details": + M.trapBubbledEvent("topToggle", "toggle", a);f = c;break;case "input": + qc.initWrapperState(a, c);f = qc.getHostProps(a, c);M.trapBubbledEvent("topInvalid", "invalid", a);Rc(d, "onChange");break;case "option": + sc.validateProps(a, c);f = sc.getHostProps(a, c);break;case "select": + uc.initWrapperState(a, c);f = uc.getHostProps(a, c);M.trapBubbledEvent("topInvalid", "invalid", a);Rc(d, "onChange");break;case "textarea": + wc.initWrapperState(a, c);f = wc.getHostProps(a, c);M.trapBubbledEvent("topInvalid", "invalid", a);Rc(d, "onChange");break;default: + f = c;}yc(b, f, Kc);var g = f, + h;for (h in g) { + if (g.hasOwnProperty(h)) { + var k = g[h];"style" === h ? bc.setValueForStyles(a, k) : "dangerouslySetInnerHTML" === h ? (k = k ? k.__html : void 0, null != k && Fc(a, k)) : "children" === h ? "string" === typeof k ? Jc(a, k) : "number" === typeof k && Jc(a, "" + k) : "suppressContentEditableWarning" !== h && (Oc.hasOwnProperty(h) ? null != k && Rc(d, h) : e ? hc.setValueForAttribute(a, h, k) : null != k && hc.setValueForProperty(a, h, k)); + } + }switch (b) {case "input": + Bc.track(a);qc.postMountWrapper(a, c);break;case "textarea": + Bc.track(a);wc.postMountWrapper(a, c);break;case "option": + sc.postMountWrapper(a, c);break;case "select": + uc.postMountWrapper(a, c);break;default: + "function" === typeof f.onClick && (a.onclick = ca);} + }, diffProperties: function diffProperties(a, b, c, d, e) { + var f = null;switch (b) {case "input": + c = qc.getHostProps(a, c);d = qc.getHostProps(a, d);f = [];break;case "option": + c = sc.getHostProps(a, c);d = sc.getHostProps(a, d);f = [];break;case "select": + c = uc.getHostProps(a, c);d = uc.getHostProps(a, d);f = [];break;case "textarea": + c = wc.getHostProps(a, c);d = wc.getHostProps(a, d);f = [];break;default: + "function" !== typeof c.onClick && "function" === typeof d.onClick && (a.onclick = ca);}yc(b, d, Kc); + var g, h;a = null;for (g in c) { + if (!d.hasOwnProperty(g) && c.hasOwnProperty(g) && null != c[g]) if ("style" === g) for (h in b = c[g], b) { + b.hasOwnProperty(h) && (a || (a = {}), a[h] = ""); + } else "dangerouslySetInnerHTML" !== g && "children" !== g && "suppressContentEditableWarning" !== g && (Oc.hasOwnProperty(g) ? f || (f = []) : (f = f || []).push(g, null)); + }for (g in d) { + var k = d[g];b = null != c ? c[g] : void 0;if (d.hasOwnProperty(g) && k !== b && (null != k || null != b)) if ("style" === g) { + if (b) { + for (h in b) { + !b.hasOwnProperty(h) || k && k.hasOwnProperty(h) || (a || (a = {}), a[h] = ""); + }for (h in k) { + k.hasOwnProperty(h) && b[h] !== k[h] && (a || (a = {}), a[h] = k[h]); + } + } else a || (f || (f = []), f.push(g, a)), a = k; + } else "dangerouslySetInnerHTML" === g ? (k = k ? k.__html : void 0, b = b ? b.__html : void 0, null != k && b !== k && (f = f || []).push(g, "" + k)) : "children" === g ? b === k || "string" !== typeof k && "number" !== typeof k || (f = f || []).push(g, "" + k) : "suppressContentEditableWarning" !== g && (Oc.hasOwnProperty(g) ? (null != k && Rc(e, g), f || b === k || (f = [])) : (f = f || []).push(g, k)); + }a && (f = f || []).push("style", a);return f; + }, updateProperties: function updateProperties(a, b, c, d, e) { + Cc(c, d);d = Cc(c, e);for (var f = 0; f < b.length; f += 2) { + var g = b[f], + h = b[f + 1];"style" === g ? bc.setValueForStyles(a, h) : "dangerouslySetInnerHTML" === g ? Fc(a, h) : "children" === g ? Jc(a, h) : d ? null != h ? hc.setValueForAttribute(a, g, h) : hc.deleteValueForAttribute(a, g) : null != h ? hc.setValueForProperty(a, g, h) : hc.deleteValueForProperty(a, g); + }switch (c) {case "input": + qc.updateWrapper(a, e);Bc.updateValueIfChanged(a);break;case "textarea": + wc.updateWrapper(a, e);break;case "select": + uc.postUpdateWrapper(a, e);} + }, diffHydratedProperties: function diffHydratedProperties(a, b, c, d, e) { + switch (b) {case "iframe":case "object": + M.trapBubbledEvent("topLoad", "load", a);break;case "video":case "audio": + for (var f in Sc) { + Sc.hasOwnProperty(f) && M.trapBubbledEvent(f, Sc[f], a); + }break;case "source": + M.trapBubbledEvent("topError", "error", a);break;case "img":case "image": + M.trapBubbledEvent("topError", "error", a);M.trapBubbledEvent("topLoad", "load", a);break;case "form": + M.trapBubbledEvent("topReset", "reset", a);M.trapBubbledEvent("topSubmit", "submit", a);break;case "details": + M.trapBubbledEvent("topToggle", "toggle", a);break;case "input": + qc.initWrapperState(a, c);M.trapBubbledEvent("topInvalid", "invalid", a);Rc(e, "onChange");break;case "option": + sc.validateProps(a, c);break;case "select": + uc.initWrapperState(a, c);M.trapBubbledEvent("topInvalid", "invalid", a);Rc(e, "onChange");break;case "textarea": + wc.initWrapperState(a, c), M.trapBubbledEvent("topInvalid", "invalid", a), Rc(e, "onChange");}yc(b, c, Kc);d = null;for (var g in c) { + c.hasOwnProperty(g) && (f = c[g], "children" === g ? "string" === typeof f ? a.textContent !== f && (d = ["children", f]) : "number" === typeof f && a.textContent !== "" + f && (d = ["children", "" + f]) : Oc.hasOwnProperty(g) && null != f && Rc(e, g)); + }switch (b) {case "input": + Bc.track(a);qc.postMountWrapper(a, c);break;case "textarea": + Bc.track(a);wc.postMountWrapper(a, c);break;case "select":case "option": + break;default: + "function" === typeof c.onClick && (a.onclick = ca);}return d; + }, diffHydratedText: function diffHydratedText(a, b) { + return a.nodeValue !== b; + }, warnForDeletedHydratableElement: function warnForDeletedHydratableElement() {}, warnForDeletedHydratableText: function warnForDeletedHydratableText() {}, warnForInsertedHydratedElement: function warnForInsertedHydratedElement() {}, warnForInsertedHydratedText: function warnForInsertedHydratedText() {}, restoreControlledState: function restoreControlledState(a, b, c) { + switch (b) {case "input": + qc.restoreControlledState(a, c);break;case "textarea": + wc.restoreControlledState(a, c);break;case "select": + uc.restoreControlledState(a, c);} + } }, + Tc = void 0; +if (l.canUseDOM) { + if ("function" !== typeof requestIdleCallback) { + var Uc = null, + Vc = null, + Wc = !1, + Xc = !1, + Yc = 0, + Zc = 33, + $c = 33, + ad = { timeRemaining: "object" === (typeof performance === "undefined" ? "undefined" : _typeof(performance)) && "function" === typeof performance.now ? function () { + return Yc - performance.now(); + } : function () { + return Yc - Date.now(); + } }, + bd = "__reactIdleCallback$" + Math.random().toString(36).slice(2);window.addEventListener("message", function (a) { + a.source === window && a.data === bd && (Wc = !1, a = Vc, Vc = null, null !== a && a(ad)); + }, !1);var cd = function cd(a) { + Xc = !1;var b = a - Yc + $c;b < $c && Zc < $c ? (8 > b && (b = 8), $c = b < Zc ? Zc : b) : Zc = b;Yc = a + $c;Wc || (Wc = !0, window.postMessage(bd, "*"));b = Uc;Uc = null;null !== b && b(a); + };Tc = function Tc(a) { + Vc = a;Xc || (Xc = !0, requestAnimationFrame(cd));return 0; + }; + } else Tc = requestIdleCallback; +} else Tc = function Tc(a) { + setTimeout(function () { + a({ timeRemaining: function timeRemaining() { + return Infinity; + } }); + });return 0; +}; +var dd = { rIC: Tc }, + ed = { enableAsyncSubtreeAPI: !0 }, + Q = { NoWork: 0, SynchronousPriority: 1, TaskPriority: 2, HighPriority: 3, LowPriority: 4, OffscreenPriority: 5 }, + fd = J.Callback, + gd = Q.NoWork, + hd = Q.SynchronousPriority, + id = Q.TaskPriority, + jd = E.ClassComponent, + kd = E.HostRoot, + md = void 0, + nd = void 0;function od(a, b) { + return a !== id && a !== hd || b !== id && b !== hd ? a === gd && b !== gd ? -255 : a !== gd && b === gd ? 255 : a - b : 0; +}function pd() { + return { first: null, last: null, hasForceUpdate: !1, callbackList: null }; +} +function qd(a, b, c, d) { + null !== c ? c.next = b : (b.next = a.first, a.first = b);null !== d ? b.next = d : a.last = b; +}function rd(a, b) { + b = b.priorityLevel;var c = null;if (null !== a.last && 0 >= od(a.last.priorityLevel, b)) c = a.last;else for (a = a.first; null !== a && 0 >= od(a.priorityLevel, b);) { + c = a, a = a.next; + }return c; +} +function sd(a, b) { + var c = a.alternate, + d = a.updateQueue;null === d && (d = a.updateQueue = pd());null !== c ? (a = c.updateQueue, null === a && (a = c.updateQueue = pd())) : a = null;md = d;nd = a !== d ? a : null;var e = md;c = nd;var f = rd(e, b), + g = null !== f ? f.next : e.first;if (null === c) return qd(e, b, f, g), null;d = rd(c, b);a = null !== d ? d.next : c.first;qd(e, b, f, g);if (g === a && null !== g || f === d && null !== f) return null === d && (c.first = b), null === a && (c.last = null), null;b = { priorityLevel: b.priorityLevel, partialState: b.partialState, callback: b.callback, isReplace: b.isReplace, + isForced: b.isForced, isTopLevelUnmount: b.isTopLevelUnmount, next: null };qd(c, b, d, a);return b; +}function td(a, b, c, d) { + a = a.partialState;return "function" === typeof a ? a.call(b, c, d) : a; +} +var ud = { addUpdate: function addUpdate(a, b, c, d) { + sd(a, { priorityLevel: d, partialState: b, callback: c, isReplace: !1, isForced: !1, isTopLevelUnmount: !1, next: null }); + }, addReplaceUpdate: function addReplaceUpdate(a, b, c, d) { + sd(a, { priorityLevel: d, partialState: b, callback: c, isReplace: !0, isForced: !1, isTopLevelUnmount: !1, next: null }); + }, addForceUpdate: function addForceUpdate(a, b, c) { + sd(a, { priorityLevel: c, partialState: null, callback: b, isReplace: !1, isForced: !0, isTopLevelUnmount: !1, next: null }); + }, getUpdatePriority: function getUpdatePriority(a) { + var b = a.updateQueue;return null === b || a.tag !== jd && a.tag !== kd ? gd : null !== b.first ? b.first.priorityLevel : gd; + }, addTopLevelUpdate: function addTopLevelUpdate(a, b, c, d) { + var e = null === b.element;b = { priorityLevel: d, partialState: b, callback: c, isReplace: !1, isForced: !1, isTopLevelUnmount: e, next: null };a = sd(a, b);e && (e = md, c = nd, null !== e && null !== b.next && (b.next = null, e.last = b), null !== c && null !== a && null !== a.next && (a.next = null, c.last = b)); + }, beginUpdateQueue: function beginUpdateQueue(a, b, c, d, e, f, g) { + null !== a && a.updateQueue === c && (c = b.updateQueue = { first: c.first, last: c.last, callbackList: null, hasForceUpdate: !1 }); + a = c.callbackList;for (var h = c.hasForceUpdate, k = !0, p = c.first; null !== p && 0 >= od(p.priorityLevel, g);) { + c.first = p.next;null === c.first && (c.last = null);var x;if (p.isReplace) e = td(p, d, e, f), k = !0;else if (x = td(p, d, e, f)) e = k ? n({}, e, x) : n(e, x), k = !1;p.isForced && (h = !0);null === p.callback || p.isTopLevelUnmount && null !== p.next || (a = null !== a ? a : [], a.push(p.callback), b.effectTag |= fd);p = p.next; + }c.callbackList = a;c.hasForceUpdate = h;null !== c.first || null !== a || h || (b.updateQueue = null);return e; + }, commitCallbacks: function commitCallbacks(a, b, c) { + a = b.callbackList; + if (null !== a) for (b.callbackList = null, b = 0; b < a.length; b++) { + var d = a[b];"function" !== typeof d ? w("191", d) : void 0;d.call(c); + } + } }, + vd = [], + wd = -1, + xd = { createCursor: function createCursor(a) { + return { current: a }; + }, isEmpty: function isEmpty() { + return -1 === wd; + }, pop: function pop(a) { + 0 > wd || (a.current = vd[wd], vd[wd] = null, wd--); + }, push: function push(a, b) { + wd++;vd[wd] = a.current;a.current = b; + }, reset: function reset() { + for (; -1 < wd;) { + vd[wd] = null, wd--; + } + } }, + yd = bb.isFiberMounted, + zd = E.ClassComponent, + Ad = E.HostRoot, + Bd = xd.createCursor, + Cd = xd.pop, + Dd = xd.push, + Ed = Bd(da), + Fd = Bd(!1), + Ld = da; +function Md(a, b, c) { + a = a.stateNode;a.__reactInternalMemoizedUnmaskedChildContext = b;a.__reactInternalMemoizedMaskedChildContext = c; +}function Nd(a) { + return a.tag === zd && null != a.type.childContextTypes; +}function Od(a, b) { + var c = a.stateNode, + d = a.type.childContextTypes;if ("function" !== typeof c.getChildContext) return b;c = c.getChildContext();for (var e in c) { + e in d ? void 0 : w("108", Ra(a) || "Unknown", e); + }return n({}, b, c); +} +var R = { getUnmaskedContext: function getUnmaskedContext(a) { + return Nd(a) ? Ld : Ed.current; + }, cacheContext: Md, getMaskedContext: function getMaskedContext(a, b) { + var c = a.type.contextTypes;if (!c) return da;var d = a.stateNode;if (d && d.__reactInternalMemoizedUnmaskedChildContext === b) return d.__reactInternalMemoizedMaskedChildContext;var e = {}, + f;for (f in c) { + e[f] = b[f]; + }d && Md(a, b, e);return e; + }, hasContextChanged: function hasContextChanged() { + return Fd.current; + }, isContextConsumer: function isContextConsumer(a) { + return a.tag === zd && null != a.type.contextTypes; + }, isContextProvider: Nd, popContextProvider: function popContextProvider(a) { + Nd(a) && (Cd(Fd, a), Cd(Ed, a)); + }, popTopLevelContextObject: function popTopLevelContextObject(a) { + Cd(Fd, a);Cd(Ed, a); + }, pushTopLevelContextObject: function pushTopLevelContextObject(a, b, c) { + null != Ed.cursor ? w("168") : void 0;Dd(Ed, b, a);Dd(Fd, c, a); + }, processChildContext: Od, pushContextProvider: function pushContextProvider(a) { + if (!Nd(a)) return !1;var b = a.stateNode;b = b && b.__reactInternalMemoizedMergedChildContext || da;Ld = Ed.current;Dd(Ed, b, a);Dd(Fd, Fd.current, a);return !0; + }, invalidateContextProvider: function invalidateContextProvider(a, b) { + var c = a.stateNode;c ? void 0 : w("169");if (b) { + var d = Od(a, Ld, !0);c.__reactInternalMemoizedMergedChildContext = d;Cd(Fd, a);Cd(Ed, a);Dd(Ed, d, a); + } else Cd(Fd, a);Dd(Fd, b, a); + }, resetContext: function resetContext() { + Ld = da;Ed.current = da;Fd.current = !1; + }, findCurrentUnmaskedContext: function findCurrentUnmaskedContext(a) { + for (yd(a) && a.tag === zd ? void 0 : w("170"); a.tag !== Ad;) { + if (Nd(a)) return a.stateNode.__reactInternalMemoizedMergedChildContext;(a = a["return"]) ? void 0 : w("171"); + }return a.stateNode.context; + } }, + Pd = { NoContext: 0, AsyncUpdates: 1 }, + Qd = E.IndeterminateComponent, + Rd = E.ClassComponent, + Sd = E.HostRoot, + Td = E.HostComponent, + Ud = E.HostText, + Vd = E.HostPortal, + Wd = E.CoroutineComponent, + Xd = E.YieldComponent, + Yd = E.Fragment, + Zd = Q.NoWork, + $d = Pd.NoContext, + ae = J.NoEffect;function be(a, b, c) { + this.tag = a;this.key = b;this.stateNode = this.type = null;this.sibling = this.child = this["return"] = null;this.index = 0;this.memoizedState = this.updateQueue = this.memoizedProps = this.pendingProps = this.ref = null;this.internalContextTag = c;this.effectTag = ae;this.lastEffect = this.firstEffect = this.nextEffect = null;this.pendingWorkPriority = Zd;this.alternate = null; +} +function ce(a, b, c) { + var d = void 0;"function" === typeof a ? (d = a.prototype && a.prototype.isReactComponent ? new be(Rd, b, c) : new be(Qd, b, c), d.type = a) : "string" === typeof a ? (d = new be(Td, b, c), d.type = a) : "object" === (typeof a === "undefined" ? "undefined" : _typeof(a)) && null !== a && "number" === typeof a.tag ? d = a : w("130", null == a ? a : typeof a === "undefined" ? "undefined" : _typeof(a), "");return d; +} +var de = { createWorkInProgress: function createWorkInProgress(a, b) { + var c = a.alternate;null === c ? (c = new be(a.tag, a.key, a.internalContextTag), c.type = a.type, c.stateNode = a.stateNode, c.alternate = a, a.alternate = c) : (c.effectTag = ae, c.nextEffect = null, c.firstEffect = null, c.lastEffect = null);c.pendingWorkPriority = b;c.child = a.child;c.memoizedProps = a.memoizedProps;c.memoizedState = a.memoizedState;c.updateQueue = a.updateQueue;c.sibling = a.sibling;c.index = a.index;c.ref = a.ref;return c; + }, createHostRootFiber: function createHostRootFiber() { + return new be(Sd, null, $d); + }, + createFiberFromElement: function createFiberFromElement(a, b, c) { + b = ce(a.type, a.key, b, null);b.pendingProps = a.props;b.pendingWorkPriority = c;return b; + }, createFiberFromFragment: function createFiberFromFragment(a, b, c) { + b = new be(Yd, null, b);b.pendingProps = a;b.pendingWorkPriority = c;return b; + }, createFiberFromText: function createFiberFromText(a, b, c) { + b = new be(Ud, null, b);b.pendingProps = a;b.pendingWorkPriority = c;return b; + }, createFiberFromElementType: ce, createFiberFromHostInstanceForDeletion: function createFiberFromHostInstanceForDeletion() { + var a = new be(Td, null, $d);a.type = "DELETED";return a; + }, createFiberFromCoroutine: function createFiberFromCoroutine(a, b, c) { + b = new be(Wd, a.key, b);b.type = a.handler;b.pendingProps = a;b.pendingWorkPriority = c;return b; + }, createFiberFromYield: function createFiberFromYield(a, b) { + return new be(Xd, null, b); + }, createFiberFromPortal: function createFiberFromPortal(a, b, c) { + b = new be(Vd, a.key, b);b.pendingProps = a.children || [];b.pendingWorkPriority = c;b.stateNode = { containerInfo: a.containerInfo, implementation: a.implementation };return b; + }, largerPriority: function largerPriority(a, b) { + return a !== Zd && (b === Zd || b > a) ? a : b; + } }, + ee = de.createHostRootFiber, + fe = E.IndeterminateComponent, + ge = E.FunctionalComponent, + he = E.ClassComponent, + ie = E.HostComponent, + je, + ke;"function" === typeof Symbol && Symbol["for"] ? (je = Symbol["for"]("react.coroutine"), ke = Symbol["for"]("react.yield")) : (je = 60104, ke = 60105); +var le = { createCoroutine: function createCoroutine(a, b, c) { + var d = 3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;return { $$typeof: je, key: null == d ? null : "" + d, children: a, handler: b, props: c }; + }, createYield: function createYield(a) { + return { $$typeof: ke, value: a }; + }, isCoroutine: function isCoroutine(a) { + return "object" === (typeof a === "undefined" ? "undefined" : _typeof(a)) && null !== a && a.$$typeof === je; + }, isYield: function isYield(a) { + return "object" === (typeof a === "undefined" ? "undefined" : _typeof(a)) && null !== a && a.$$typeof === ke; + }, REACT_YIELD_TYPE: ke, REACT_COROUTINE_TYPE: je }, + me = "function" === typeof Symbol && Symbol["for"] && Symbol["for"]("react.portal") || 60106, + ne = { createPortal: function createPortal(a, b, c) { + var d = 3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;return { $$typeof: me, key: null == d ? null : "" + d, children: a, containerInfo: b, implementation: c }; + }, isPortal: function isPortal(a) { + return "object" === (typeof a === "undefined" ? "undefined" : _typeof(a)) && null !== a && a.$$typeof === me; + }, REACT_PORTAL_TYPE: me }, + oe = le.REACT_COROUTINE_TYPE, + pe = le.REACT_YIELD_TYPE, + qe = ne.REACT_PORTAL_TYPE, + re = de.createWorkInProgress, + se = de.createFiberFromElement, + te = de.createFiberFromFragment, + ue = de.createFiberFromText, + ve = de.createFiberFromCoroutine, + we = de.createFiberFromYield, + xe = de.createFiberFromPortal, + ye = Array.isArray, + ze = E.FunctionalComponent, + Ae = E.ClassComponent, + Be = E.HostText, + Ce = E.HostPortal, + De = E.CoroutineComponent, + Ee = E.YieldComponent, + Fe = E.Fragment, + Ge = J.NoEffect, + He = J.Placement, + Ie = J.Deletion, + Je = "function" === typeof Symbol && Symbol.iterator, + Ke = "function" === typeof Symbol && Symbol["for"] && Symbol["for"]("react.element") || 60103; +function Le(a) { + if (null === a || "undefined" === typeof a) return null;a = Je && a[Je] || a["@@iterator"];return "function" === typeof a ? a : null; +} +function Me(a, b) { + var c = b.ref;if (null !== c && "function" !== typeof c) { + if (b._owner) { + b = b._owner;var d = void 0;b && ("number" === typeof b.tag ? (b.tag !== Ae ? w("110") : void 0, d = b.stateNode) : d = b.getPublicInstance());d ? void 0 : w("147", c);var e = "" + c;if (null !== a && null !== a.ref && a.ref._stringRef === e) return a.ref;a = function a(_a) { + var b = d.refs === da ? d.refs = {} : d.refs;null === _a ? delete b[e] : b[e] = _a; + };a._stringRef = e;return a; + }"string" !== typeof c ? w("148") : void 0;b._owner ? void 0 : w("149", c); + }return c; +} +function Ne(a, b) { + "textarea" !== a.type && w("31", "[object Object]" === Object.prototype.toString.call(b) ? "object with keys {" + Object.keys(b).join(", ") + "}" : b, ""); +} +function Oe(a, b) { + function c(c, d) { + if (b) { + if (!a) { + if (null === d.alternate) return;d = d.alternate; + }var m = c.lastEffect;null !== m ? (m.nextEffect = d, c.lastEffect = d) : c.firstEffect = c.lastEffect = d;d.nextEffect = null;d.effectTag = Ie; + } + }function d(a, d) { + if (!b) return null;for (; null !== d;) { + c(a, d), d = d.sibling; + }return null; + }function e(a, b) { + for (a = new Map(); null !== b;) { + null !== b.key ? a.set(b.key, b) : a.set(b.index, b), b = b.sibling; + }return a; + }function f(b, c) { + if (a) return b = re(b, c), b.index = 0, b.sibling = null, b;b.pendingWorkPriority = c;b.effectTag = Ge; + b.index = 0;b.sibling = null;return b; + }function g(a, c, d) { + a.index = d;if (!b) return c;d = a.alternate;if (null !== d) return d = d.index, d < c ? (a.effectTag = He, c) : d;a.effectTag = He;return c; + }function h(a) { + b && null === a.alternate && (a.effectTag = He);return a; + }function k(a, b, c, d) { + if (null === b || b.tag !== Be) return c = ue(c, a.internalContextTag, d), c["return"] = a, c;b = f(b, d);b.pendingProps = c;b["return"] = a;return b; + }function p(a, b, c, d) { + if (null === b || b.type !== c.type) return d = se(c, a.internalContextTag, d), d.ref = Me(b, c), d["return"] = a, d;d = f(b, d);d.ref = Me(b, c);d.pendingProps = c.props;d["return"] = a;return d; + }function x(a, b, c, d) { + if (null === b || b.tag !== De) return c = ve(c, a.internalContextTag, d), c["return"] = a, c;b = f(b, d);b.pendingProps = c;b["return"] = a;return b; + }function S(a, b, c, d) { + if (null === b || b.tag !== Ee) return b = we(c, a.internalContextTag, d), b.type = c.value, b["return"] = a, b;b = f(b, d);b.type = c.value;b["return"] = a;return b; + }function D(a, b, c, d) { + if (null === b || b.tag !== Ce || b.stateNode.containerInfo !== c.containerInfo || b.stateNode.implementation !== c.implementation) return c = xe(c, a.internalContextTag, d), c["return"] = a, c;b = f(b, d);b.pendingProps = c.children || [];b["return"] = a;return b; + }function y(a, b, c, d) { + if (null === b || b.tag !== Fe) return c = te(c, a.internalContextTag, d), c["return"] = a, c;b = f(b, d);b.pendingProps = c;b["return"] = a;return b; + }function B(a, b, c) { + if ("string" === typeof b || "number" === typeof b) return b = ue("" + b, a.internalContextTag, c), b["return"] = a, b;if ("object" === (typeof b === "undefined" ? "undefined" : _typeof(b)) && null !== b) { + switch (b.$$typeof) {case Ke: + return c = se(b, a.internalContextTag, c), c.ref = Me(null, b), c["return"] = a, c;case oe: + return b = ve(b, a.internalContextTag, c), b["return"] = a, b;case pe: + return c = we(b, a.internalContextTag, c), c.type = b.value, c["return"] = a, c;case qe: + return b = xe(b, a.internalContextTag, c), b["return"] = a, b;}if (ye(b) || Le(b)) return b = te(b, a.internalContextTag, c), b["return"] = a, b;Ne(a, b); + }return null; + }function H(a, b, c, d) { + var e = null !== b ? b.key : null;if ("string" === typeof c || "number" === typeof c) return null !== e ? null : k(a, b, "" + c, d);if ("object" === (typeof c === "undefined" ? "undefined" : _typeof(c)) && null !== c) { + switch (c.$$typeof) {case Ke: + return c.key === e ? p(a, b, c, d) : null;case oe: + return c.key === e ? x(a, b, c, d) : null;case pe: + return null === e ? S(a, b, c, d) : null;case qe: + return c.key === e ? D(a, b, c, d) : null;}if (ye(c) || Le(c)) return null !== e ? null : y(a, b, c, d);Ne(a, c); + }return null; + }function C(a, b, c, d, e) { + if ("string" === typeof d || "number" === typeof d) return a = a.get(c) || null, k(b, a, "" + d, e);if ("object" === (typeof d === "undefined" ? "undefined" : _typeof(d)) && null !== d) { + switch (d.$$typeof) {case Ke: + return a = a.get(null === d.key ? c : d.key) || null, p(b, a, d, e);case oe: + return a = a.get(null === d.key ? c : d.key) || null, x(b, a, d, e);case pe: + return a = a.get(c) || null, S(b, a, d, e);case qe: + return a = a.get(null === d.key ? c : d.key) || null, D(b, a, d, e);}if (ye(d) || Le(d)) return a = a.get(c) || null, y(b, a, d, e);Ne(b, d); + }return null; + }function Ca(a, f, h, k) { + for (var m = null, t = null, q = f, r = f = 0, p = null; null !== q && r < h.length; r++) { + q.index > r ? (p = q, q = null) : p = q.sibling;var v = H(a, q, h[r], k);if (null === v) { + null === q && (q = p);break; + }b && q && null === v.alternate && c(a, q);f = g(v, f, r);null === t ? m = v : t.sibling = v;t = v;q = p; + }if (r === h.length) return d(a, q), m;if (null === q) { + for (; r < h.length; r++) { + if (q = B(a, h[r], k)) f = g(q, f, r), null === t ? m = q : t.sibling = q, t = q; + }return m; + }for (q = e(a, q); r < h.length; r++) { + if (p = C(q, a, r, h[r], k)) { + if (b && null !== p.alternate) q["delete"](null === p.key ? r : p.key);f = g(p, f, r);null === t ? m = p : t.sibling = p;t = p; + } + }b && q.forEach(function (b) { + return c(a, b); + });return m; + }function r(a, f, h, r) { + var m = Le(h);"function" !== typeof m ? w("150") : void 0;h = m.call(h);null == h ? w("151") : void 0;for (var t = m = null, q = f, k = f = 0, p = null, v = h.next(); null !== q && !v.done; k++, v = h.next()) { + q.index > k ? (p = q, q = null) : p = q.sibling;var V = H(a, q, v.value, r);if (null === V) { + q || (q = p);break; + }b && q && null === V.alternate && c(a, q);f = g(V, f, k);null === t ? m = V : t.sibling = V;t = V;q = p; + }if (v.done) return d(a, q), m;if (null === q) { + for (; !v.done; k++, v = h.next()) { + v = B(a, v.value, r), null !== v && (f = g(v, f, k), null === t ? m = v : t.sibling = v, t = v); + }return m; + }for (q = e(a, q); !v.done; k++, v = h.next()) { + if (v = C(q, a, k, v.value, r), null !== v) { + if (b && null !== v.alternate) q["delete"](null === v.key ? k : v.key);f = g(v, f, k);null === t ? m = v : t.sibling = v;t = v; + } + }b && q.forEach(function (b) { + return c(a, b); + });return m; + }return function (a, b, e, g) { + var m = "object" === (typeof e === "undefined" ? "undefined" : _typeof(e)) && null !== e;if (m) switch (e.$$typeof) {case Ke: + a: { + var C = e.key;for (m = b; null !== m;) { + if (m.key === C) { + if (m.type === e.type) { + d(a, m.sibling);b = f(m, g);b.ref = Me(m, e);b.pendingProps = e.props;b["return"] = a;a = b;break a; + } else { + d(a, m);break; + } + } else c(a, m);m = m.sibling; + }g = se(e, a.internalContextTag, g);g.ref = Me(b, e);g["return"] = a;a = g; + }return h(a);case oe: + a: { + for (m = e.key; null !== b;) { + if (b.key === m) { + if (b.tag === De) { + d(a, b.sibling);b = f(b, g);b.pendingProps = e;b["return"] = a;a = b;break a; + } else { + d(a, b);break; + } + } else c(a, b);b = b.sibling; + }e = ve(e, a.internalContextTag, g);e["return"] = a;a = e; + }return h(a);case pe: + a: { + if (null !== b) if (b.tag === Ee) { + d(a, b.sibling);b = f(b, g);b.type = e.value;b["return"] = a;a = b;break a; + } else d(a, b);b = we(e, a.internalContextTag, g);b.type = e.value;b["return"] = a;a = b; + }return h(a);case qe: + a: { + for (m = e.key; null !== b;) { + if (b.key === m) { + if (b.tag === Ce && b.stateNode.containerInfo === e.containerInfo && b.stateNode.implementation === e.implementation) { + d(a, b.sibling);b = f(b, g);b.pendingProps = e.children || [];b["return"] = a;a = b;break a; + } else { + d(a, b);break; + } + } else c(a, b);b = b.sibling; + }e = xe(e, a.internalContextTag, g);e["return"] = a;a = e; + }return h(a);}if ("string" === typeof e || "number" === typeof e) return e = "" + e, null !== b && b.tag === Be ? (d(a, b.sibling), b = f(b, g), b.pendingProps = e, b["return"] = a, a = b) : (d(a, b), e = ue(e, a.internalContextTag, g), e["return"] = a, a = e), h(a);if (ye(e)) return Ca(a, b, e, g);if (Le(e)) return r(a, b, e, g);m && Ne(a, e);if ("undefined" === typeof e) switch (a.tag) {case Ae:case ze: + e = a.type, w("152", e.displayName || e.name || "Component");}return d(a, b); + }; +} +var Pe = Oe(!0, !0), + Qe = Oe(!1, !0), + Re = Oe(!1, !1), + Se = { reconcileChildFibers: Pe, reconcileChildFibersInPlace: Qe, mountChildFibersInPlace: Re, cloneChildFibers: function cloneChildFibers(a, b) { + null !== a && b.child !== a.child ? w("153") : void 0;if (null !== b.child) { + a = b.child;var c = re(a, a.pendingWorkPriority);c.pendingProps = a.pendingProps;b.child = c;for (c["return"] = b; null !== a.sibling;) { + a = a.sibling, c = c.sibling = re(a, a.pendingWorkPriority), c.pendingProps = a.pendingProps, c["return"] = b; + }c.sibling = null; + } + } }, + Te = J.Update, + Ue = Pd.AsyncUpdates, + Ve = R.cacheContext, + We = R.getMaskedContext, + Xe = R.getUnmaskedContext, + Ye = R.isContextConsumer, + Ze = ud.addUpdate, + $e = ud.addReplaceUpdate, + af = ud.addForceUpdate, + bf = ud.beginUpdateQueue, + cf = R.hasContextChanged, + df = bb.isMounted; +function ef(a, b, c, d) { + function e(a, b) { + b.updater = f;a.stateNode = b;Pa.set(b, a); + }var f = { isMounted: df, enqueueSetState: function enqueueSetState(c, d, e) { + c = Pa.get(c);var f = b(c, !1);Ze(c, d, void 0 === e ? null : e, f);a(c, f); + }, enqueueReplaceState: function enqueueReplaceState(c, d, e) { + c = Pa.get(c);var f = b(c, !1);$e(c, d, void 0 === e ? null : e, f);a(c, f); + }, enqueueForceUpdate: function enqueueForceUpdate(c, d) { + c = Pa.get(c);var e = b(c, !1);af(c, void 0 === d ? null : d, e);a(c, e); + } };return { adoptClassInstance: e, constructClassInstance: function constructClassInstance(a, b) { + var c = a.type, + d = Xe(a), + f = Ye(a), + g = f ? We(a, d) : da;b = new c(b, g); + e(a, b);f && Ve(a, d, g);return b; + }, mountClassInstance: function mountClassInstance(a, b) { + var c = a.alternate, + d = a.stateNode, + e = d.state || null, + g = a.pendingProps;g ? void 0 : w("158");var h = Xe(a);d.props = g;d.state = e;d.refs = da;d.context = We(a, h);ed.enableAsyncSubtreeAPI && null != a.type && null != a.type.prototype && !0 === a.type.prototype.unstable_isAsyncReactComponent && (a.internalContextTag |= Ue);"function" === typeof d.componentWillMount && (h = d.state, d.componentWillMount(), h !== d.state && f.enqueueReplaceState(d, d.state, null), h = a.updateQueue, null !== h && (d.state = bf(c, a, h, d, e, g, b)));"function" === typeof d.componentDidMount && (a.effectTag |= Te); + }, updateClassInstance: function updateClassInstance(a, b, e) { + var g = b.stateNode;g.props = b.memoizedProps;g.state = b.memoizedState;var h = b.memoizedProps, + k = b.pendingProps;k || (k = h, null == k ? w("159") : void 0);var D = g.context, + y = Xe(b);y = We(b, y);"function" !== typeof g.componentWillReceiveProps || h === k && D === y || (D = g.state, g.componentWillReceiveProps(k, y), g.state !== D && f.enqueueReplaceState(g, g.state, null));D = b.memoizedState;e = null !== b.updateQueue ? bf(a, b, b.updateQueue, g, D, k, e) : D;if (!(h !== k || D !== e || cf() || null !== b.updateQueue && b.updateQueue.hasForceUpdate)) return "function" !== typeof g.componentDidUpdate || h === a.memoizedProps && D === a.memoizedState || (b.effectTag |= Te), !1;var B = k;if (null === h || null !== b.updateQueue && b.updateQueue.hasForceUpdate) B = !0;else { + var H = b.stateNode, + C = b.type;B = "function" === typeof H.shouldComponentUpdate ? H.shouldComponentUpdate(B, e, y) : C.prototype && C.prototype.isPureReactComponent ? !ea(h, B) || !ea(D, e) : !0; + }B ? ("function" === typeof g.componentWillUpdate && g.componentWillUpdate(k, e, y), "function" === typeof g.componentDidUpdate && (b.effectTag |= Te)) : ("function" !== typeof g.componentDidUpdate || h === a.memoizedProps && D === a.memoizedState || (b.effectTag |= Te), c(b, k), d(b, e));g.props = k;g.state = e;g.context = y;return B; + } }; +} +var ff = Se.mountChildFibersInPlace, + gf = Se.reconcileChildFibers, + hf = Se.reconcileChildFibersInPlace, + jf = Se.cloneChildFibers, + kf = ud.beginUpdateQueue, + lf = R.getMaskedContext, + mf = R.getUnmaskedContext, + nf = R.hasContextChanged, + of = R.pushContextProvider, + pf = R.pushTopLevelContextObject, + qf = R.invalidateContextProvider, + rf = E.IndeterminateComponent, + sf = E.FunctionalComponent, + tf = E.ClassComponent, + uf = E.HostRoot, + wf = E.HostComponent, + xf = E.HostText, + yf = E.HostPortal, + zf = E.CoroutineComponent, + Af = E.CoroutineHandlerPhase, + Bf = E.YieldComponent, + Cf = E.Fragment, + Df = Q.NoWork, + Ef = Q.OffscreenPriority, + Ff = J.PerformedWork, + Gf = J.Placement, + Hf = J.ContentReset, + If = J.Err, + Jf = J.Ref, + Kf = Qa.ReactCurrentOwner; +function Lf(a, b, c, d, e) { + function f(a, b, c) { + g(a, b, c, b.pendingWorkPriority); + }function g(a, b, c, d) { + b.child = null === a ? ff(b, b.child, c, d) : a.child === b.child ? gf(b, b.child, c, d) : hf(b, b.child, c, d); + }function h(a, b) { + var c = b.ref;null === c || a && a.ref === c || (b.effectTag |= Jf); + }function k(a, b, c, d) { + h(a, b);if (!c) return d && qf(b, !1), x(a, b);c = b.stateNode;Kf.current = b;var e = c.render();b.effectTag |= Ff;f(a, b, e);b.memoizedState = c.state;b.memoizedProps = c.props;d && qf(b, !0);return b.child; + }function p(a) { + var b = a.stateNode;b.pendingContext ? pf(a, b.pendingContext, b.pendingContext !== b.context) : b.context && pf(a, b.context, !1);C(a, b.containerInfo); + }function x(a, b) { + jf(a, b);return b.child; + }function S(a, b) { + switch (b.tag) {case uf: + p(b);break;case tf: + of(b);break;case yf: + C(b, b.stateNode.containerInfo);}return null; + }var D = a.shouldSetTextContent, + y = a.useSyncScheduling, + B = a.shouldDeprioritizeSubtree, + H = b.pushHostContext, + C = b.pushHostContainer, + Ca = c.enterHydrationState, + r = c.resetHydrationState, + m = c.tryToClaimNextHydratableInstance;a = ef(d, e, function (a, b) { + a.memoizedProps = b; + }, function (a, b) { + a.memoizedState = b; + });var t = a.adoptClassInstance, + v = a.constructClassInstance, + V = a.mountClassInstance, + ld = a.updateClassInstance;return { beginWork: function beginWork(a, b, c) { + if (b.pendingWorkPriority === Df || b.pendingWorkPriority > c) return S(a, b);switch (b.tag) {case rf: + null !== a ? w("155") : void 0;var d = b.type, + e = b.pendingProps, + g = mf(b);g = lf(b, g);d = d(e, g);b.effectTag |= Ff;"object" === (typeof d === "undefined" ? "undefined" : _typeof(d)) && null !== d && "function" === typeof d.render ? (b.tag = tf, e = of(b), t(b, d), V(b, c), b = k(a, b, !0, e)) : (b.tag = sf, f(a, b, d), b.memoizedProps = e, b = b.child);return b;case sf: + a: { + e = b.type;c = b.pendingProps;d = b.memoizedProps;if (nf()) null === c && (c = d);else if (null === c || d === c) { + b = x(a, b);break a; + }d = mf(b);d = lf(b, d);e = e(c, d);b.effectTag |= Ff;f(a, b, e);b.memoizedProps = c;b = b.child; + }return b;case tf: + return e = of(b), d = void 0, null === a ? b.stateNode ? w("153") : (v(b, b.pendingProps), V(b, c), d = !0) : d = ld(a, b, c), k(a, b, d, e);case uf: + return p(b), d = b.updateQueue, null !== d ? (e = b.memoizedState, d = kf(a, b, d, null, e, null, c), e === d ? (r(), b = x(a, b)) : (e = d.element, null !== a && null !== a.child || !Ca(b) ? (r(), f(a, b, e)) : (b.effectTag |= Gf, b.child = ff(b, b.child, e, c)), b.memoizedState = d, b = b.child)) : (r(), b = x(a, b)), b;case wf: + H(b);null === a && m(b);e = b.type;var q = b.memoizedProps;d = b.pendingProps;null === d && (d = q, null === d ? w("154") : void 0);g = null !== a ? a.memoizedProps : null;nf() || null !== d && q !== d ? (q = d.children, D(e, d) ? q = null : g && D(e, g) && (b.effectTag |= Hf), h(a, b), c !== Ef && !y && B(e, d) ? (b.pendingWorkPriority = Ef, b = null) : (f(a, b, q), b.memoizedProps = d, b = b.child)) : b = x(a, b);return b;case xf: + return null === a && m(b), a = b.pendingProps, null === a && (a = b.memoizedProps), b.memoizedProps = a, null;case Af: + b.tag = zf;case zf: + c = b.pendingProps;if (nf()) null === c && (c = a && a.memoizedProps, null === c ? w("154") : void 0);else if (null === c || b.memoizedProps === c) c = b.memoizedProps;e = c.children;d = b.pendingWorkPriority;b.stateNode = null === a ? ff(b, b.stateNode, e, d) : a.child === b.child ? gf(b, b.stateNode, e, d) : hf(b, b.stateNode, e, d);b.memoizedProps = c;return b.stateNode;case Bf: + return null;case yf: + a: { + C(b, b.stateNode.containerInfo);c = b.pendingWorkPriority;e = b.pendingProps;if (nf()) null === e && (e = a && a.memoizedProps, null == e ? w("154") : void 0);else if (null === e || b.memoizedProps === e) { + b = x(a, b);break a; + }null === a ? b.child = hf(b, b.child, e, c) : f(a, b, e);b.memoizedProps = e;b = b.child; + }return b;case Cf: + a: { + c = b.pendingProps;if (nf()) null === c && (c = b.memoizedProps);else if (null === c || b.memoizedProps === c) { + b = x(a, b);break a; + }f(a, b, c);b.memoizedProps = c;b = b.child; + }return b;default: + w("156");} + }, beginFailedWork: function beginFailedWork(a, b, c) { + switch (b.tag) {case tf: + of(b);break;case uf: + p(b);break;default: + w("157");}b.effectTag |= If;null === a ? b.child = null : b.child !== a.child && (b.child = a.child);if (b.pendingWorkPriority === Df || b.pendingWorkPriority > c) return S(a, b);b.firstEffect = null;b.lastEffect = null;g(a, b, null, c);b.tag === tf && (a = b.stateNode, b.memoizedProps = a.props, b.memoizedState = a.state);return b.child; + } }; +} +var Mf = Se.reconcileChildFibers, + Nf = R.popContextProvider, + Of = R.popTopLevelContextObject, + Pf = E.IndeterminateComponent, + Qf = E.FunctionalComponent, + Rf = E.ClassComponent, + Sf = E.HostRoot, + Tf = E.HostComponent, + Uf = E.HostText, + Vf = E.HostPortal, + Wf = E.CoroutineComponent, + Xf = E.CoroutineHandlerPhase, + Yf = E.YieldComponent, + Zf = E.Fragment, + ag = J.Placement, + bg = J.Ref, + cg = J.Update, + dg = Q.OffscreenPriority; +function eg(a, b, c) { + var d = a.createInstance, + e = a.createTextInstance, + f = a.appendInitialChild, + g = a.finalizeInitialChildren, + h = a.prepareUpdate, + k = b.getRootHostContainer, + p = b.popHostContext, + x = b.getHostContext, + S = b.popHostContainer, + D = c.prepareToHydrateHostInstance, + y = c.prepareToHydrateHostTextInstance, + B = c.popHydrationState;return { completeWork: function completeWork(a, b, c) { + var r = b.pendingProps;if (null === r) r = b.memoizedProps;else if (b.pendingWorkPriority !== dg || c === dg) b.pendingProps = null;switch (b.tag) {case Qf: + return null;case Rf: + return Nf(b), null;case Sf: + S(b);Of(b);r = b.stateNode;r.pendingContext && (r.context = r.pendingContext, r.pendingContext = null);if (null === a || null === a.child) B(b), b.effectTag &= ~ag;return null;case Tf: + p(b);c = k();var m = b.type;if (null !== a && null != b.stateNode) { + var t = a.memoizedProps, + C = b.stateNode, + V = x();r = h(C, m, t, r, c, V);if (b.updateQueue = r) b.effectTag |= cg;a.ref !== b.ref && (b.effectTag |= bg); + } else { + if (!r) return null === b.stateNode ? w("166") : void 0, null;a = x();if (B(b)) D(b, c, a) && (b.effectTag |= cg);else { + a = d(m, r, c, a, b);a: for (t = b.child; null !== t;) { + if (t.tag === Tf || t.tag === Uf) f(a, t.stateNode);else if (t.tag !== Vf && null !== t.child) { + t = t.child;continue; + }if (t === b) break a;for (; null === t.sibling;) { + if (null === t["return"] || t["return"] === b) break a;t = t["return"]; + }t = t.sibling; + }g(a, m, r, c) && (b.effectTag |= cg);b.stateNode = a; + }null !== b.ref && (b.effectTag |= bg); + }return null;case Uf: + if (a && null != b.stateNode) a.memoizedProps !== r && (b.effectTag |= cg);else { + if ("string" !== typeof r) return null === b.stateNode ? w("166") : void 0, null;a = k();c = x();B(b) ? y(b) && (b.effectTag |= cg) : b.stateNode = e(r, a, c, b); + }return null;case Wf: + (r = b.memoizedProps) ? void 0 : w("165");b.tag = Xf;c = [];a: for ((m = b.stateNode) && (m["return"] = b); null !== m;) { + if (m.tag === Tf || m.tag === Uf || m.tag === Vf) w("164");else if (m.tag === Yf) c.push(m.type);else if (null !== m.child) { + m.child["return"] = m;m = m.child;continue; + }for (; null === m.sibling;) { + if (null === m["return"] || m["return"] === b) break a;m = m["return"]; + }m.sibling["return"] = m["return"];m = m.sibling; + }m = r.handler;r = m(r.props, c);b.child = Mf(b, null !== a ? a.child : null, r, b.pendingWorkPriority);return b.child; + case Xf: + return b.tag = Wf, null;case Yf: + return null;case Zf: + return null;case Vf: + return b.effectTag |= cg, S(b), null;case Pf: + w("167");default: + w("156");} + } }; +}var fg = null, + gg = null;function hg(a) { + return function (b) { + try { + return a(b); + } catch (c) {} + }; +} +var ig = { injectInternals: function injectInternals(a) { + if ("undefined" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__) return !1;var b = __REACT_DEVTOOLS_GLOBAL_HOOK__;if (!b.supportsFiber) return !0;try { + var c = b.inject(a);fg = hg(function (a) { + return b.onCommitFiberRoot(c, a); + });gg = hg(function (a) { + return b.onCommitFiberUnmount(c, a); + }); + } catch (d) {}return !0; + }, onCommitRoot: function onCommitRoot(a) { + "function" === typeof fg && fg(a); + }, onCommitUnmount: function onCommitUnmount(a) { + "function" === typeof gg && gg(a); + } }, + jg = E.ClassComponent, + kg = E.HostRoot, + lg = E.HostComponent, + mg = E.HostText, + ng = E.HostPortal, + og = E.CoroutineComponent, + pg = ud.commitCallbacks, + qg = ig.onCommitUnmount, + rg = J.Placement, + sg = J.Update, + tg = J.Callback, + ug = J.ContentReset; +function vg(a, b) { + function c(a) { + var c = a.ref;if (null !== c) try { + c(null); + } catch (t) { + b(a, t); + } + }function d(a) { + return a.tag === lg || a.tag === kg || a.tag === ng; + }function e(a) { + for (var b = a;;) { + if (g(b), null !== b.child && b.tag !== ng) b.child["return"] = b, b = b.child;else { + if (b === a) break;for (; null === b.sibling;) { + if (null === b["return"] || b["return"] === a) return;b = b["return"]; + }b.sibling["return"] = b["return"];b = b.sibling; + } + } + }function f(a) { + for (var b = a, c = !1, d = void 0, f = void 0;;) { + if (!c) { + c = b["return"];a: for (;;) { + null === c ? w("160") : void 0;switch (c.tag) {case lg: + d = c.stateNode;f = !1;break a;case kg: + d = c.stateNode.containerInfo;f = !0;break a;case ng: + d = c.stateNode.containerInfo;f = !0;break a;}c = c["return"]; + }c = !0; + }if (b.tag === lg || b.tag === mg) e(b), f ? C(d, b.stateNode) : H(d, b.stateNode);else if (b.tag === ng ? d = b.stateNode.containerInfo : g(b), null !== b.child) { + b.child["return"] = b;b = b.child;continue; + }if (b === a) break;for (; null === b.sibling;) { + if (null === b["return"] || b["return"] === a) return;b = b["return"];b.tag === ng && (c = !1); + }b.sibling["return"] = b["return"];b = b.sibling; + } + }function g(a) { + "function" === typeof qg && qg(a);switch (a.tag) {case jg: + c(a);var d = a.stateNode;if ("function" === typeof d.componentWillUnmount) try { + d.props = a.memoizedProps, d.state = a.memoizedState, d.componentWillUnmount(); + } catch (t) { + b(a, t); + }break;case lg: + c(a);break;case og: + e(a.stateNode);break;case ng: + f(a);} + }var h = a.commitMount, + k = a.commitUpdate, + p = a.resetTextContent, + x = a.commitTextUpdate, + S = a.appendChild, + D = a.appendChildToContainer, + y = a.insertBefore, + B = a.insertInContainerBefore, + H = a.removeChild, + C = a.removeChildFromContainer, + Ca = a.getPublicInstance; + return { commitPlacement: function commitPlacement(a) { + a: { + for (var b = a["return"]; null !== b;) { + if (d(b)) { + var c = b;break a; + }b = b["return"]; + }w("160");c = void 0; + }var e = b = void 0;switch (c.tag) {case lg: + b = c.stateNode;e = !1;break;case kg: + b = c.stateNode.containerInfo;e = !0;break;case ng: + b = c.stateNode.containerInfo;e = !0;break;default: + w("161");}c.effectTag & ug && (p(b), c.effectTag &= ~ug);a: b: for (c = a;;) { + for (; null === c.sibling;) { + if (null === c["return"] || d(c["return"])) { + c = null;break a; + }c = c["return"]; + }c.sibling["return"] = c["return"];for (c = c.sibling; c.tag !== lg && c.tag !== mg;) { + if (c.effectTag & rg) continue b;if (null === c.child || c.tag === ng) continue b;else c.child["return"] = c, c = c.child; + }if (!(c.effectTag & rg)) { + c = c.stateNode;break a; + } + }for (var f = a;;) { + if (f.tag === lg || f.tag === mg) c ? e ? B(b, f.stateNode, c) : y(b, f.stateNode, c) : e ? D(b, f.stateNode) : S(b, f.stateNode);else if (f.tag !== ng && null !== f.child) { + f.child["return"] = f;f = f.child;continue; + }if (f === a) break;for (; null === f.sibling;) { + if (null === f["return"] || f["return"] === a) return;f = f["return"]; + }f.sibling["return"] = f["return"];f = f.sibling; + } + }, + commitDeletion: function commitDeletion(a) { + f(a);a["return"] = null;a.child = null;a.alternate && (a.alternate.child = null, a.alternate["return"] = null); + }, commitWork: function commitWork(a, b) { + switch (b.tag) {case jg: + break;case lg: + var c = b.stateNode;if (null != c) { + var d = b.memoizedProps;a = null !== a ? a.memoizedProps : d;var e = b.type, + f = b.updateQueue;b.updateQueue = null;null !== f && k(c, f, e, a, d, b); + }break;case mg: + null === b.stateNode ? w("162") : void 0;c = b.memoizedProps;x(b.stateNode, null !== a ? a.memoizedProps : c, c);break;case kg: + break;case ng: + break;default: + w("163");} + }, + commitLifeCycles: function commitLifeCycles(a, b) { + switch (b.tag) {case jg: + var c = b.stateNode;if (b.effectTag & sg) if (null === a) c.props = b.memoizedProps, c.state = b.memoizedState, c.componentDidMount();else { + var d = a.memoizedProps;a = a.memoizedState;c.props = b.memoizedProps;c.state = b.memoizedState;c.componentDidUpdate(d, a); + }b.effectTag & tg && null !== b.updateQueue && pg(b, b.updateQueue, c);break;case kg: + a = b.updateQueue;null !== a && pg(b, a, b.child && b.child.stateNode);break;case lg: + c = b.stateNode;null === a && b.effectTag & sg && h(c, b.type, b.memoizedProps, b);break;case mg: + break;case ng: + break;default: + w("163");} + }, commitAttachRef: function commitAttachRef(a) { + var b = a.ref;if (null !== b) { + var c = a.stateNode;switch (a.tag) {case lg: + b(Ca(c));break;default: + b(c);} + } + }, commitDetachRef: function commitDetachRef(a) { + a = a.ref;null !== a && a(null); + } }; +}var wg = xd.createCursor, + xg = xd.pop, + yg = xd.push, + zg = {}; +function Ag(a) { + function b(a) { + a === zg ? w("174") : void 0;return a; + }var c = a.getChildHostContext, + d = a.getRootHostContext, + e = wg(zg), + f = wg(zg), + g = wg(zg);return { getHostContext: function getHostContext() { + return b(e.current); + }, getRootHostContainer: function getRootHostContainer() { + return b(g.current); + }, popHostContainer: function popHostContainer(a) { + xg(e, a);xg(f, a);xg(g, a); + }, popHostContext: function popHostContext(a) { + f.current === a && (xg(e, a), xg(f, a)); + }, pushHostContainer: function pushHostContainer(a, b) { + yg(g, b, a);b = d(b);yg(f, a, a);yg(e, b, a); + }, pushHostContext: function pushHostContext(a) { + var d = b(g.current), + h = b(e.current);d = c(h, a.type, d);h !== d && (yg(f, a, a), yg(e, d, a)); + }, resetHostContainer: function resetHostContainer() { + e.current = zg;g.current = zg; + } }; +}var Bg = E.HostComponent, + Cg = E.HostText, + Dg = E.HostRoot, + Eg = J.Deletion, + Fg = J.Placement, + Gg = de.createFiberFromHostInstanceForDeletion; +function Hg(a) { + function b(a, b) { + var c = Gg();c.stateNode = b;c["return"] = a;c.effectTag = Eg;null !== a.lastEffect ? (a.lastEffect.nextEffect = c, a.lastEffect = c) : a.firstEffect = a.lastEffect = c; + }function c(a, b) { + switch (a.tag) {case Bg: + return f(b, a.type, a.pendingProps);case Cg: + return g(b, a.pendingProps);default: + return !1;} + }function d(a) { + for (a = a["return"]; null !== a && a.tag !== Bg && a.tag !== Dg;) { + a = a["return"]; + }y = a; + }var e = a.shouldSetTextContent, + f = a.canHydrateInstance, + g = a.canHydrateTextInstance, + h = a.getNextHydratableSibling, + k = a.getFirstHydratableChild, + p = a.hydrateInstance, + x = a.hydrateTextInstance, + S = a.didNotHydrateInstance, + D = a.didNotFindHydratableInstance;a = a.didNotFindHydratableTextInstance;if (!(f && g && h && k && p && x && S && D && a)) return { enterHydrationState: function enterHydrationState() { + return !1; + }, resetHydrationState: function resetHydrationState() {}, tryToClaimNextHydratableInstance: function tryToClaimNextHydratableInstance() {}, prepareToHydrateHostInstance: function prepareToHydrateHostInstance() { + w("175"); + }, prepareToHydrateHostTextInstance: function prepareToHydrateHostTextInstance() { + w("176"); + }, popHydrationState: function popHydrationState() { + return !1; + } };var y = null, + B = null, + H = !1;return { enterHydrationState: function enterHydrationState(a) { + B = k(a.stateNode.containerInfo);y = a;return H = !0; + }, resetHydrationState: function resetHydrationState() { + B = y = null;H = !1; + }, tryToClaimNextHydratableInstance: function tryToClaimNextHydratableInstance(a) { + if (H) { + var d = B;if (d) { + if (!c(a, d)) { + d = h(d);if (!d || !c(a, d)) { + a.effectTag |= Fg;H = !1;y = a;return; + }b(y, B); + }a.stateNode = d;y = a;B = k(d); + } else a.effectTag |= Fg, H = !1, y = a; + } + }, prepareToHydrateHostInstance: function prepareToHydrateHostInstance(a, b, c) { + b = p(a.stateNode, a.type, a.memoizedProps, b, c, a);a.updateQueue = b;return null !== b ? !0 : !1; + }, prepareToHydrateHostTextInstance: function prepareToHydrateHostTextInstance(a) { + return x(a.stateNode, a.memoizedProps, a); + }, + popHydrationState: function popHydrationState(a) { + if (a !== y) return !1;if (!H) return d(a), H = !0, !1;var c = a.type;if (a.tag !== Bg || "head" !== c && "body" !== c && !e(c, a.memoizedProps)) for (c = B; c;) { + b(a, c), c = h(c); + }d(a);B = y ? h(a.stateNode) : null;return !0; + } }; +} +var Ig = R.popContextProvider, + Jg = xd.reset, + Kg = Qa.ReactCurrentOwner, + Lg = de.createWorkInProgress, + Mg = de.largerPriority, + Ng = ig.onCommitRoot, + T = Q.NoWork, + Og = Q.SynchronousPriority, + U = Q.TaskPriority, + Pg = Q.HighPriority, + Qg = Q.LowPriority, + Rg = Q.OffscreenPriority, + Sg = Pd.AsyncUpdates, + Tg = J.PerformedWork, + Ug = J.Placement, + Vg = J.Update, + Wg = J.PlacementAndUpdate, + Xg = J.Deletion, + Yg = J.ContentReset, + Zg = J.Callback, + $g = J.Err, + ah = J.Ref, + bh = E.HostRoot, + ch = E.HostComponent, + dh = E.HostPortal, + eh = E.ClassComponent, + fh = ud.getUpdatePriority, + gh = R.resetContext; +function hh(a) { + function b() { + for (; null !== ma && ma.current.pendingWorkPriority === T;) { + ma.isScheduled = !1;var a = ma.nextScheduledRoot;ma.nextScheduledRoot = null;if (ma === zb) return zb = ma = null, z = T, null;ma = a; + }a = ma;for (var b = null, c = T; null !== a;) { + a.current.pendingWorkPriority !== T && (c === T || c > a.current.pendingWorkPriority) && (c = a.current.pendingWorkPriority, b = a), a = a.nextScheduledRoot; + }null !== b ? (z = c, Jg(), gh(), t(), I = Lg(b.current, c), b !== nc && (oc = 0, nc = b)) : (z = T, nc = I = null); + }function c(c) { + Hd = !0;na = null;var d = c.stateNode;d.current === c ? w("177") : void 0;z !== Og && z !== U || oc++;Kg.current = null;if (c.effectTag > Tg) { + if (null !== c.lastEffect) { + c.lastEffect.nextEffect = c;var e = c.firstEffect; + } else e = c; + } else e = c.firstEffect;Ui();for (u = e; null !== u;) { + var f = !1, + g = void 0;try { + for (; null !== u;) { + var h = u.effectTag;h & Yg && a.resetTextContent(u.stateNode);if (h & ah) { + var k = u.alternate;null !== k && Ph(k); + }switch (h & ~(Zg | $g | Yg | ah | Tg)) {case Ug: + q(u);u.effectTag &= ~Ug;break;case Wg: + q(u);u.effectTag &= ~Ug;vf(u.alternate, u);break;case Vg: + vf(u.alternate, u);break;case Xg: + Id = !0, Mh(u), Id = !1;}u = u.nextEffect; + } + } catch (Jd) { + f = !0, g = Jd; + }f && (null === u ? w("178") : void 0, x(u, g), null !== u && (u = u.nextEffect)); + }Vi();d.current = c;for (u = e; null !== u;) { + d = !1;e = void 0;try { + for (; null !== u;) { + var Gd = u.effectTag;Gd & (Vg | Zg) && Nh(u.alternate, u);Gd & ah && Oh(u);if (Gd & $g) switch (f = u, g = void 0, null !== P && (g = P.get(f), P["delete"](f), null == g && null !== f.alternate && (f = f.alternate, g = P.get(f), P["delete"](f))), null == g ? w("184") : void 0, f.tag) {case eh: + f.stateNode.componentDidCatch(g.error, { componentStack: g.componentStack });break;case bh: + null === Ja && (Ja = g.error);break;default: + w("157");}var m = u.nextEffect;u.nextEffect = null;u = m; + } + } catch (Jd) { + d = !0, e = Jd; + }d && (null === u ? w("178") : void 0, x(u, e), null !== u && (u = u.nextEffect)); + }Hd = !1;"function" === typeof Ng && Ng(c.stateNode);va && (va.forEach(H), va = null);b(); + }function d(a) { + for (;;) { + var b = Lh(a.alternate, a, z), + c = a["return"], + d = a.sibling;var e = a;if (!(e.pendingWorkPriority !== T && e.pendingWorkPriority > z)) { + for (var f = fh(e), g = e.child; null !== g;) { + f = Mg(f, g.pendingWorkPriority), g = g.sibling; + }e.pendingWorkPriority = f; + }if (null !== b) return b; + null !== c && (null === c.firstEffect && (c.firstEffect = a.firstEffect), null !== a.lastEffect && (null !== c.lastEffect && (c.lastEffect.nextEffect = a.firstEffect), c.lastEffect = a.lastEffect), a.effectTag > Tg && (null !== c.lastEffect ? c.lastEffect.nextEffect = a : c.firstEffect = a, c.lastEffect = a));if (null !== d) return d;if (null !== c) a = c;else { + na = a;break; + } + }return null; + }function e(a) { + var b = V(a.alternate, a, z);null === b && (b = d(a));Kg.current = null;return b; + }function f(a) { + var b = ld(a.alternate, a, z);null === b && (b = d(a));Kg.current = null;return b; + } + function g(a) { + p(Rg, a); + }function h() { + if (null !== P && 0 < P.size && z === U) for (; null !== I;) { + var a = I;I = null !== P && (P.has(a) || null !== a.alternate && P.has(a.alternate)) ? f(I) : e(I);if (null === I && (null === na ? w("179") : void 0, O = U, c(na), O = z, null === P || 0 === P.size || z !== U)) break; + } + }function k(a, d) { + null !== na ? (O = U, c(na), h()) : null === I && b();if (!(z === T || z > a)) { + O = z;a: do { + if (z <= U) for (; null !== I && !(I = e(I), null === I && (null === na ? w("179") : void 0, O = U, c(na), O = z, h(), z === T || z > a || z > U));) {} else if (null !== d) for (; null !== I && !Ab;) { + if (1 < d.timeRemaining()) { + if (I = e(I), null === I) if (null === na ? w("179") : void 0, 1 < d.timeRemaining()) { + if (O = U, c(na), O = z, h(), z === T || z > a || z < Pg) break; + } else Ab = !0; + } else Ab = !0; + }switch (z) {case Og:case U: + if (z <= a) continue a;break a;case Pg:case Qg:case Rg: + if (null === d) break a;if (!Ab && z <= a) continue a;break a;case T: + break a;default: + w("181");} + } while (1); + } + }function p(a, b) { + Da ? w("182") : void 0;Da = !0;var c = O, + d = !1, + e = null;try { + k(a, b); + } catch (Kd) { + d = !0, e = Kd; + }for (; d;) { + if (Ya) { + Ja = e;break; + }var h = I;if (null === h) Ya = !0;else { + var p = x(h, e);null === p ? w("183") : void 0;if (!Ya) { + try { + d = p;e = a;p = b;for (var q = d; null !== h;) { + switch (h.tag) {case eh: + Ig(h);break;case ch: + m(h);break;case bh: + r(h);break;case dh: + r(h);}if (h === q || h.alternate === q) break;h = h["return"]; + }I = f(d);k(e, p); + } catch (Kd) { + d = !0;e = Kd;continue; + }break; + } + } + }O = c;null !== b && (Bb = !1);z > U && !Bb && ($f(g), Bb = !0);a = Ja;Ya = Ab = Da = !1;nc = Ka = P = Ja = null;oc = 0;if (null !== a) throw a; + }function x(a, b) { + var c = Kg.current = null, + d = !1, + e = !1, + f = null;if (a.tag === bh) c = a, S(a) && (Ya = !0);else for (var g = a["return"]; null !== g && null === c;) { + g.tag === eh ? "function" === typeof g.stateNode.componentDidCatch && (d = !0, f = Ra(g), c = g, e = !0) : g.tag === bh && (c = g);if (S(g)) { + if (Id || null !== va && (va.has(g) || null !== g.alternate && va.has(g.alternate))) return null;c = null;e = !1; + }g = g["return"]; + }if (null !== c) { + null === Ka && (Ka = new Set());Ka.add(c);var h = "";g = a;do { + a: switch (g.tag) {case fe:case ge:case he:case ie: + var k = g._debugOwner, + m = g._debugSource;var p = Ra(g);var q = null;k && (q = Ra(k));k = m;p = "\n in " + (p || "Unknown") + (k ? " (at " + k.fileName.replace(/^.*[\\\/]/, "") + ":" + k.lineNumber + ")" : q ? " (created by " + q + ")" : "");break a;default: + p = "";}h += p;g = g["return"]; + } while (g); + g = h;a = Ra(a);null === P && (P = new Map());b = { componentName: a, componentStack: g, error: b, errorBoundary: d ? c.stateNode : null, errorBoundaryFound: d, errorBoundaryName: f, willRetry: e };P.set(c, b);try { + console.error(b.error); + } catch (Wi) { + console.error(Wi); + }Hd ? (null === va && (va = new Set()), va.add(c)) : H(c);return c; + }null === Ja && (Ja = b);return null; + }function S(a) { + return null !== Ka && (Ka.has(a) || null !== a.alternate && Ka.has(a.alternate)); + }function D(a, b) { + return y(a, b, !1); + }function y(a, b) { + oc > Xi && (Ya = !0, w("185"));!Da && b <= z && (I = null);for (var c = !0; null !== a && c;) { + c = !1;if (a.pendingWorkPriority === T || a.pendingWorkPriority > b) c = !0, a.pendingWorkPriority = b;null !== a.alternate && (a.alternate.pendingWorkPriority === T || a.alternate.pendingWorkPriority > b) && (c = !0, a.alternate.pendingWorkPriority = b);if (null === a["return"]) if (a.tag === bh) { + var d = a.stateNode;b === T || d.isScheduled || (d.isScheduled = !0, zb ? zb.nextScheduledRoot = d : ma = d, zb = d);if (!Da) switch (b) {case Og: + pc ? p(Og, null) : p(U, null);break;case U: + W ? void 0 : w("186");break;default: + Bb || ($f(g), Bb = !0);} + } else break;a = a["return"]; + } + } + function B(a, b) { + var c = O;c === T && (c = !Yi || a.internalContextTag & Sg || b ? Qg : Og);return c === Og && (Da || W) ? U : c; + }function H(a) { + y(a, U, !0); + }var C = Ag(a), + Ca = Hg(a), + r = C.popHostContainer, + m = C.popHostContext, + t = C.resetHostContainer, + v = Lf(a, C, Ca, D, B), + V = v.beginWork, + ld = v.beginFailedWork, + Lh = eg(a, C, Ca).completeWork;C = vg(a, x);var q = C.commitPlacement, + Mh = C.commitDeletion, + vf = C.commitWork, + Nh = C.commitLifeCycles, + Oh = C.commitAttachRef, + Ph = C.commitDetachRef, + $f = a.scheduleDeferredCallback, + Yi = a.useSyncScheduling, + Ui = a.prepareForCommit, + Vi = a.resetAfterCommit, + O = T, + Da = !1, + Ab = !1, + W = !1, + pc = !1, + I = null, + z = T, + u = null, + na = null, + ma = null, + zb = null, + Bb = !1, + P = null, + Ka = null, + va = null, + Ja = null, + Ya = !1, + Hd = !1, + Id = !1, + Xi = 1E3, + oc = 0, + nc = null;return { scheduleUpdate: D, getPriorityContext: B, batchedUpdates: function batchedUpdates(a, b) { + var c = W;W = !0;try { + return a(b); + } finally { + W = c, Da || W || p(U, null); + } + }, unbatchedUpdates: function unbatchedUpdates(a) { + var b = pc, + c = W;pc = W;W = !1;try { + return a(); + } finally { + W = c, pc = b; + } + }, flushSync: function flushSync(a) { + var b = W, + c = O;W = !0;O = Og;try { + return a(); + } finally { + W = b, O = c, Da ? w("187") : void 0, p(U, null); + } + }, deferredUpdates: function deferredUpdates(a) { + var b = O;O = Qg;try { + return a(); + } finally { + O = b; + } + } }; +}function ih() { + w("196"); +}function jh(a) { + if (!a) return da;a = Pa.get(a);return "number" === typeof a.tag ? ih(a) : a._processChildContext(a._context); +}jh._injectFiber = function (a) { + ih = a; +};var kh = ud.addTopLevelUpdate, + lh = R.findCurrentUnmaskedContext, + mh = R.isContextProvider, + nh = R.processChildContext, + oh = E.HostComponent, + ph = bb.findCurrentHostFiber, + qh = bb.findCurrentHostFiberWithNoPortals;jh._injectFiber(function (a) { + var b = lh(a);return mh(a) ? nh(a, b, !1) : b; +});var rh = F.TEXT_NODE; +function sh(a) { + for (; a && a.firstChild;) { + a = a.firstChild; + }return a; +}function th(a, b) { + var c = sh(a);a = 0;for (var d; c;) { + if (c.nodeType === rh) { + d = a + c.textContent.length;if (a <= b && d >= b) return { node: c, offset: b - a };a = d; + }a: { + for (; c;) { + if (c.nextSibling) { + c = c.nextSibling;break a; + }c = c.parentNode; + }c = void 0; + }c = sh(c); + } +}var uh = null;function vh() { + !uh && l.canUseDOM && (uh = "textContent" in document.documentElement ? "textContent" : "innerText");return uh; +} +var wh = { getOffsets: function getOffsets(a) { + var b = window.getSelection && window.getSelection();if (!b || 0 === b.rangeCount) return null;var c = b.anchorNode, + d = b.anchorOffset, + e = b.focusNode, + f = b.focusOffset, + g = b.getRangeAt(0);try { + g.startContainer.nodeType, g.endContainer.nodeType; + } catch (k) { + return null; + }b = b.anchorNode === b.focusNode && b.anchorOffset === b.focusOffset ? 0 : g.toString().length;var h = g.cloneRange();h.selectNodeContents(a);h.setEnd(g.startContainer, g.startOffset);a = h.startContainer === h.endContainer && h.startOffset === h.endOffset ? 0 : h.toString().length;g = a + b;b = document.createRange();b.setStart(c, d);b.setEnd(e, f);c = b.collapsed;return { start: c ? g : a, end: c ? a : g }; + }, setOffsets: function setOffsets(a, b) { + if (window.getSelection) { + var c = window.getSelection(), + d = a[vh()].length, + e = Math.min(b.start, d);b = void 0 === b.end ? e : Math.min(b.end, d);!c.extend && e > b && (d = b, b = e, e = d);d = th(a, e);a = th(a, b);if (d && a) { + var f = document.createRange();f.setStart(d.node, d.offset);c.removeAllRanges();e > b ? (c.addRange(f), c.extend(a.node, a.offset)) : (f.setEnd(a.node, a.offset), c.addRange(f)); + } + } + } }, + xh = F.ELEMENT_NODE, + yh = { hasSelectionCapabilities: function hasSelectionCapabilities(a) { + var b = a && a.nodeName && a.nodeName.toLowerCase();return b && ("input" === b && "text" === a.type || "textarea" === b || "true" === a.contentEditable); + }, getSelectionInformation: function getSelectionInformation() { + var a = ia();return { focusedElem: a, selectionRange: yh.hasSelectionCapabilities(a) ? yh.getSelection(a) : null }; + }, restoreSelection: function restoreSelection(a) { + var b = ia(), + c = a.focusedElem;a = a.selectionRange;if (b !== c && fa(document.documentElement, c)) { + yh.hasSelectionCapabilities(c) && yh.setSelection(c, a);b = [];for (a = c; a = a.parentNode;) { + a.nodeType === xh && b.push({ element: a, left: a.scrollLeft, top: a.scrollTop }); + }ha(c);for (c = 0; c < b.length; c++) { + a = b[c], a.element.scrollLeft = a.left, a.element.scrollTop = a.top; + } + } + }, getSelection: function getSelection(a) { + return ("selectionStart" in a ? { start: a.selectionStart, end: a.selectionEnd } : wh.getOffsets(a)) || { start: 0, end: 0 }; + }, setSelection: function setSelection(a, b) { + var c = b.start, + d = b.end;void 0 === d && (d = c);"selectionStart" in a ? (a.selectionStart = c, a.selectionEnd = Math.min(d, a.value.length)) : wh.setOffsets(a, b); + } }, + zh = yh, + Ah = F.ELEMENT_NODE;function Bh() { + w("211"); +}function Ch() { + w("212"); +}function Dh(a) { + if (null == a) return null;if (a.nodeType === Ah) return a;var b = Pa.get(a);if (b) return "number" === typeof b.tag ? Bh(b) : Ch(b);"function" === typeof a.render ? w("188") : w("213", Object.keys(a)); +}Dh._injectFiber = function (a) { + Bh = a; +};Dh._injectStack = function (a) { + Ch = a; +};var Eh = E.HostComponent;function Fh(a) { + if (void 0 !== a._hostParent) return a._hostParent;if ("number" === typeof a.tag) { + do { + a = a["return"]; + } while (a && a.tag !== Eh);if (a) return a; + }return null; +} +function Gh(a, b) { + for (var c = 0, d = a; d; d = Fh(d)) { + c++; + }d = 0;for (var e = b; e; e = Fh(e)) { + d++; + }for (; 0 < c - d;) { + a = Fh(a), c--; + }for (; 0 < d - c;) { + b = Fh(b), d--; + }for (; c--;) { + if (a === b || a === b.alternate) return a;a = Fh(a);b = Fh(b); + }return null; +} +var Hh = { isAncestor: function isAncestor(a, b) { + for (; b;) { + if (a === b || a === b.alternate) return !0;b = Fh(b); + }return !1; + }, getLowestCommonAncestor: Gh, getParentInstance: function getParentInstance(a) { + return Fh(a); + }, traverseTwoPhase: function traverseTwoPhase(a, b, c) { + for (var d = []; a;) { + d.push(a), a = Fh(a); + }for (a = d.length; 0 < a--;) { + b(d[a], "captured", c); + }for (a = 0; a < d.length; a++) { + b(d[a], "bubbled", c); + } + }, traverseEnterLeave: function traverseEnterLeave(a, b, c, d, e) { + for (var f = a && b ? Gh(a, b) : null, g = []; a && a !== f;) { + g.push(a), a = Fh(a); + }for (a = []; b && b !== f;) { + a.push(b), b = Fh(b); + }for (b = 0; b < g.length; b++) { + c(g[b], "bubbled", d); + }for (b = a.length; 0 < b--;) { + c(a[b], "captured", e); + } + } }, + Ih = Jb.getListener;function Jh(a, b, c) { + if (b = Ih(a, c.dispatchConfig.phasedRegistrationNames[b])) c._dispatchListeners = Cb(c._dispatchListeners, b), c._dispatchInstances = Cb(c._dispatchInstances, a); +}function Kh(a) { + a && a.dispatchConfig.phasedRegistrationNames && Hh.traverseTwoPhase(a._targetInst, Jh, a); +}function Qh(a) { + if (a && a.dispatchConfig.phasedRegistrationNames) { + var b = a._targetInst;b = b ? Hh.getParentInstance(b) : null;Hh.traverseTwoPhase(b, Jh, a); + } +} +function Rh(a, b, c) { + a && c && c.dispatchConfig.registrationName && (b = Ih(a, c.dispatchConfig.registrationName)) && (c._dispatchListeners = Cb(c._dispatchListeners, b), c._dispatchInstances = Cb(c._dispatchInstances, a)); +}function Sh(a) { + a && a.dispatchConfig.registrationName && Rh(a._targetInst, null, a); +} +var Th = { accumulateTwoPhaseDispatches: function accumulateTwoPhaseDispatches(a) { + Db(a, Kh); + }, accumulateTwoPhaseDispatchesSkipTarget: function accumulateTwoPhaseDispatchesSkipTarget(a) { + Db(a, Qh); + }, accumulateDirectDispatches: function accumulateDirectDispatches(a) { + Db(a, Sh); + }, accumulateEnterLeaveDispatches: function accumulateEnterLeaveDispatches(a, b, c, d) { + Hh.traverseEnterLeave(c, d, Rh, a, b); + } }, + X = { _root: null, _startText: null, _fallbackText: null }, + Uh = { initialize: function initialize(a) { + X._root = a;X._startText = Uh.getText();return !0; + }, reset: function reset() { + X._root = null;X._startText = null;X._fallbackText = null; + }, getData: function getData() { + if (X._fallbackText) return X._fallbackText; + var a, + b = X._startText, + c = b.length, + d, + e = Uh.getText(), + f = e.length;for (a = 0; a < c && b[a] === e[a]; a++) {}var g = c - a;for (d = 1; d <= g && b[c - d] === e[f - d]; d++) {}X._fallbackText = e.slice(a, 1 < d ? 1 - d : void 0);return X._fallbackText; + }, getText: function getText() { + return "value" in X._root ? X._root.value : X._root[vh()]; + } }, + Vh = Uh, + Wh = "dispatchConfig _targetInst nativeEvent isDefaultPrevented isPropagationStopped _dispatchListeners _dispatchInstances".split(" "), + Xh = { type: null, target: null, currentTarget: ca.thatReturnsNull, eventPhase: null, bubbles: null, + cancelable: null, timeStamp: function timeStamp(a) { + return a.timeStamp || Date.now(); + }, defaultPrevented: null, isTrusted: null }; +function Y(a, b, c, d) { + this.dispatchConfig = a;this._targetInst = b;this.nativeEvent = c;a = this.constructor.Interface;for (var e in a) { + a.hasOwnProperty(e) && ((b = a[e]) ? this[e] = b(c) : "target" === e ? this.target = d : this[e] = c[e]); + }this.isDefaultPrevented = (null != c.defaultPrevented ? c.defaultPrevented : !1 === c.returnValue) ? ca.thatReturnsTrue : ca.thatReturnsFalse;this.isPropagationStopped = ca.thatReturnsFalse;return this; +} +n(Y.prototype, { preventDefault: function preventDefault() { + this.defaultPrevented = !0;var a = this.nativeEvent;a && (a.preventDefault ? a.preventDefault() : "unknown" !== typeof a.returnValue && (a.returnValue = !1), this.isDefaultPrevented = ca.thatReturnsTrue); + }, stopPropagation: function stopPropagation() { + var a = this.nativeEvent;a && (a.stopPropagation ? a.stopPropagation() : "unknown" !== typeof a.cancelBubble && (a.cancelBubble = !0), this.isPropagationStopped = ca.thatReturnsTrue); + }, persist: function persist() { + this.isPersistent = ca.thatReturnsTrue; + }, isPersistent: ca.thatReturnsFalse, + destructor: function destructor() { + var a = this.constructor.Interface, + b;for (b in a) { + this[b] = null; + }for (a = 0; a < Wh.length; a++) { + this[Wh[a]] = null; + } + } });Y.Interface = Xh;Y.augmentClass = function (a, b) { + function c() {}c.prototype = this.prototype;var d = new c();n(d, a.prototype);a.prototype = d;a.prototype.constructor = a;a.Interface = n({}, this.Interface, b);a.augmentClass = this.augmentClass;Yh(a); +};Yh(Y);function Zh(a, b, c, d) { + if (this.eventPool.length) { + var e = this.eventPool.pop();this.call(e, a, b, c, d);return e; + }return new this(a, b, c, d); +} +function $h(a) { + a instanceof this ? void 0 : w("223");a.destructor();10 > this.eventPool.length && this.eventPool.push(a); +}function Yh(a) { + a.eventPool = [];a.getPooled = Zh;a.release = $h; +}function ai(a, b, c, d) { + return Y.call(this, a, b, c, d); +}Y.augmentClass(ai, { data: null });function bi(a, b, c, d) { + return Y.call(this, a, b, c, d); +}Y.augmentClass(bi, { data: null });var ci = [9, 13, 27, 32], + di = l.canUseDOM && "CompositionEvent" in window, + ei = null;l.canUseDOM && "documentMode" in document && (ei = document.documentMode);var fi; +if (fi = l.canUseDOM && "TextEvent" in window && !ei) { + var gi = window.opera;fi = !("object" === (typeof gi === "undefined" ? "undefined" : _typeof(gi)) && "function" === typeof gi.version && 12 >= parseInt(gi.version(), 10)); +} +var hi = fi, + ii = l.canUseDOM && (!di || ei && 8 < ei && 11 >= ei), + ji = String.fromCharCode(32), + ki = { beforeInput: { phasedRegistrationNames: { bubbled: "onBeforeInput", captured: "onBeforeInputCapture" }, dependencies: ["topCompositionEnd", "topKeyPress", "topTextInput", "topPaste"] }, compositionEnd: { phasedRegistrationNames: { bubbled: "onCompositionEnd", captured: "onCompositionEndCapture" }, dependencies: "topBlur topCompositionEnd topKeyDown topKeyPress topKeyUp topMouseDown".split(" ") }, compositionStart: { phasedRegistrationNames: { bubbled: "onCompositionStart", + captured: "onCompositionStartCapture" }, dependencies: "topBlur topCompositionStart topKeyDown topKeyPress topKeyUp topMouseDown".split(" ") }, compositionUpdate: { phasedRegistrationNames: { bubbled: "onCompositionUpdate", captured: "onCompositionUpdateCapture" }, dependencies: "topBlur topCompositionUpdate topKeyDown topKeyPress topKeyUp topMouseDown".split(" ") } }, + li = !1; +function mi(a, b) { + switch (a) {case "topKeyUp": + return -1 !== ci.indexOf(b.keyCode);case "topKeyDown": + return 229 !== b.keyCode;case "topKeyPress":case "topMouseDown":case "topBlur": + return !0;default: + return !1;} +}function ni(a) { + a = a.detail;return "object" === (typeof a === "undefined" ? "undefined" : _typeof(a)) && "data" in a ? a.data : null; +}var oi = !1;function pi(a, b) { + switch (a) {case "topCompositionEnd": + return ni(b);case "topKeyPress": + if (32 !== b.which) return null;li = !0;return ji;case "topTextInput": + return a = b.data, a === ji && li ? null : a;default: + return null;} +} +function qi(a, b) { + if (oi) return "topCompositionEnd" === a || !di && mi(a, b) ? (a = Vh.getData(), Vh.reset(), oi = !1, a) : null;switch (a) {case "topPaste": + return null;case "topKeyPress": + if (!(b.ctrlKey || b.altKey || b.metaKey) || b.ctrlKey && b.altKey) { + if (b.char && 1 < b.char.length) return b.char;if (b.which) return String.fromCharCode(b.which); + }return null;case "topCompositionEnd": + return ii ? null : b.data;default: + return null;} +} +var ri = { eventTypes: ki, extractEvents: function extractEvents(a, b, c, d) { + var e;if (di) b: { + switch (a) {case "topCompositionStart": + var f = ki.compositionStart;break b;case "topCompositionEnd": + f = ki.compositionEnd;break b;case "topCompositionUpdate": + f = ki.compositionUpdate;break b;}f = void 0; + } else oi ? mi(a, c) && (f = ki.compositionEnd) : "topKeyDown" === a && 229 === c.keyCode && (f = ki.compositionStart);f ? (ii && (oi || f !== ki.compositionStart ? f === ki.compositionEnd && oi && (e = Vh.getData()) : oi = Vh.initialize(d)), f = ai.getPooled(f, b, c, d), e ? f.data = e : (e = ni(c), null !== e && (f.data = e)), Th.accumulateTwoPhaseDispatches(f), e = f) : e = null;(a = hi ? pi(a, c) : qi(a, c)) ? (b = bi.getPooled(ki.beforeInput, b, c, d), b.data = a, Th.accumulateTwoPhaseDispatches(b)) : b = null;return [e, b]; + } }, + si = { color: !0, date: !0, datetime: !0, "datetime-local": !0, email: !0, month: !0, number: !0, password: !0, range: !0, search: !0, tel: !0, text: !0, time: !0, url: !0, week: !0 };function ti(a) { + var b = a && a.nodeName && a.nodeName.toLowerCase();return "input" === b ? !!si[a.type] : "textarea" === b ? !0 : !1; +} +var ui = { change: { phasedRegistrationNames: { bubbled: "onChange", captured: "onChangeCapture" }, dependencies: "topBlur topChange topClick topFocus topInput topKeyDown topKeyUp topSelectionChange".split(" ") } };function vi(a, b, c) { + a = Y.getPooled(ui.change, a, b, c);a.type = "change";nb.enqueueStateRestore(c);Th.accumulateTwoPhaseDispatches(a);return a; +}var wi = null, + xi = null;function yi(a) { + Jb.enqueueEvents(a);Jb.processEventQueue(!1); +} +function zi(a) { + var b = G.getNodeFromInstance(a);if (Bc.updateValueIfChanged(b)) return a; +}function Ai(a, b) { + if ("topChange" === a) return b; +}var Bi = !1;l.canUseDOM && (Bi = Lb("input") && (!document.documentMode || 9 < document.documentMode));function Ci() { + wi && (wi.detachEvent("onpropertychange", Di), xi = wi = null); +}function Di(a) { + "value" === a.propertyName && zi(xi) && (a = vi(xi, a, ub(a)), sb.batchedUpdates(yi, a)); +}function Ei(a, b, c) { + "topFocus" === a ? (Ci(), wi = b, xi = c, wi.attachEvent("onpropertychange", Di)) : "topBlur" === a && Ci(); +} +function Fi(a) { + if ("topSelectionChange" === a || "topKeyUp" === a || "topKeyDown" === a) return zi(xi); +}function Gi(a, b) { + if ("topClick" === a) return zi(b); +}function Hi(a, b) { + if ("topInput" === a || "topChange" === a) return zi(b); +} +var Ii = { eventTypes: ui, _isInputEventSupported: Bi, extractEvents: function extractEvents(a, b, c, d) { + var e = b ? G.getNodeFromInstance(b) : window, + f = e.nodeName && e.nodeName.toLowerCase();if ("select" === f || "input" === f && "file" === e.type) var g = Ai;else if (ti(e)) { + if (Bi) g = Hi;else { + g = Fi;var h = Ei; + } + } else f = e.nodeName, !f || "input" !== f.toLowerCase() || "checkbox" !== e.type && "radio" !== e.type || (g = Gi);if (g && (g = g(a, b))) return vi(g, c, d);h && h(a, e, b);"topBlur" === a && null != b && (a = b._wrapperState || e._wrapperState) && a.controlled && "number" === e.type && (a = "" + e.value, e.getAttribute("value") !== a && e.setAttribute("value", a)); + } };function Ji(a, b, c, d) { + return Y.call(this, a, b, c, d); +}Y.augmentClass(Ji, { view: function view(a) { + if (a.view) return a.view;a = ub(a);return a.window === a ? a : (a = a.ownerDocument) ? a.defaultView || a.parentWindow : window; + }, detail: function detail(a) { + return a.detail || 0; + } });var Ki = { Alt: "altKey", Control: "ctrlKey", Meta: "metaKey", Shift: "shiftKey" };function Li(a) { + var b = this.nativeEvent;return b.getModifierState ? b.getModifierState(a) : (a = Ki[a]) ? !!b[a] : !1; +}function Mi() { + return Li; +} +function Ni(a, b, c, d) { + return Y.call(this, a, b, c, d); +}Ji.augmentClass(Ni, { screenX: null, screenY: null, clientX: null, clientY: null, pageX: null, pageY: null, ctrlKey: null, shiftKey: null, altKey: null, metaKey: null, getModifierState: Mi, button: null, buttons: null, relatedTarget: function relatedTarget(a) { + return a.relatedTarget || (a.fromElement === a.srcElement ? a.toElement : a.fromElement); + } }); +var Oi = { mouseEnter: { registrationName: "onMouseEnter", dependencies: ["topMouseOut", "topMouseOver"] }, mouseLeave: { registrationName: "onMouseLeave", dependencies: ["topMouseOut", "topMouseOver"] } }, + Pi = { eventTypes: Oi, extractEvents: function extractEvents(a, b, c, d) { + if ("topMouseOver" === a && (c.relatedTarget || c.fromElement) || "topMouseOut" !== a && "topMouseOver" !== a) return null;var e = d.window === d ? d : (e = d.ownerDocument) ? e.defaultView || e.parentWindow : window;"topMouseOut" === a ? (a = b, b = (b = c.relatedTarget || c.toElement) ? G.getClosestInstanceFromNode(b) : null) : a = null;if (a === b) return null;var f = null == a ? e : G.getNodeFromInstance(a);e = null == b ? e : G.getNodeFromInstance(b);var g = Ni.getPooled(Oi.mouseLeave, a, c, d);g.type = "mouseleave";g.target = f;g.relatedTarget = e;c = Ni.getPooled(Oi.mouseEnter, b, c, d);c.type = "mouseenter";c.target = e;c.relatedTarget = f;Th.accumulateEnterLeaveDispatches(g, c, a, b);return [g, c]; + } }, + Qi = F.DOCUMENT_NODE, + Ri = l.canUseDOM && "documentMode" in document && 11 >= document.documentMode, + Si = { select: { phasedRegistrationNames: { bubbled: "onSelect", captured: "onSelectCapture" }, + dependencies: "topBlur topContextMenu topFocus topKeyDown topKeyUp topMouseDown topMouseUp topSelectionChange".split(" ") } }, + Ti = null, + Zi = null, + $i = null, + aj = !1, + bj = M.isListeningToAllDependencies; +function cj(a, b) { + if (aj || null == Ti || Ti !== ia()) return null;var c = Ti;"selectionStart" in c && zh.hasSelectionCapabilities(c) ? c = { start: c.selectionStart, end: c.selectionEnd } : window.getSelection ? (c = window.getSelection(), c = { anchorNode: c.anchorNode, anchorOffset: c.anchorOffset, focusNode: c.focusNode, focusOffset: c.focusOffset }) : c = void 0;return $i && ea($i, c) ? null : ($i = c, a = Y.getPooled(Si.select, Zi, a, b), a.type = "select", a.target = Ti, Th.accumulateTwoPhaseDispatches(a), a); +} +var dj = { eventTypes: Si, extractEvents: function extractEvents(a, b, c, d) { + var e = d.window === d ? d.document : d.nodeType === Qi ? d : d.ownerDocument;if (!e || !bj("onSelect", e)) return null;e = b ? G.getNodeFromInstance(b) : window;switch (a) {case "topFocus": + if (ti(e) || "true" === e.contentEditable) Ti = e, Zi = b, $i = null;break;case "topBlur": + $i = Zi = Ti = null;break;case "topMouseDown": + aj = !0;break;case "topContextMenu":case "topMouseUp": + return aj = !1, cj(c, d);case "topSelectionChange": + if (Ri) break;case "topKeyDown":case "topKeyUp": + return cj(c, d);}return null; + } }; +function ej(a, b, c, d) { + return Y.call(this, a, b, c, d); +}Y.augmentClass(ej, { animationName: null, elapsedTime: null, pseudoElement: null });function fj(a, b, c, d) { + return Y.call(this, a, b, c, d); +}Y.augmentClass(fj, { clipboardData: function clipboardData(a) { + return "clipboardData" in a ? a.clipboardData : window.clipboardData; + } });function gj(a, b, c, d) { + return Y.call(this, a, b, c, d); +}Ji.augmentClass(gj, { relatedTarget: null });function hj(a) { + var b = a.keyCode;"charCode" in a ? (a = a.charCode, 0 === a && 13 === b && (a = 13)) : a = b;return 32 <= a || 13 === a ? a : 0; +} +var ij = { Esc: "Escape", Spacebar: " ", Left: "ArrowLeft", Up: "ArrowUp", Right: "ArrowRight", Down: "ArrowDown", Del: "Delete", Win: "OS", Menu: "ContextMenu", Apps: "ContextMenu", Scroll: "ScrollLock", MozPrintableKey: "Unidentified" }, + jj = { 8: "Backspace", 9: "Tab", 12: "Clear", 13: "Enter", 16: "Shift", 17: "Control", 18: "Alt", 19: "Pause", 20: "CapsLock", 27: "Escape", 32: " ", 33: "PageUp", 34: "PageDown", 35: "End", 36: "Home", 37: "ArrowLeft", 38: "ArrowUp", 39: "ArrowRight", 40: "ArrowDown", 45: "Insert", 46: "Delete", 112: "F1", 113: "F2", 114: "F3", 115: "F4", + 116: "F5", 117: "F6", 118: "F7", 119: "F8", 120: "F9", 121: "F10", 122: "F11", 123: "F12", 144: "NumLock", 145: "ScrollLock", 224: "Meta" };function kj(a, b, c, d) { + return Y.call(this, a, b, c, d); +} +Ji.augmentClass(kj, { key: function key(a) { + if (a.key) { + var b = ij[a.key] || a.key;if ("Unidentified" !== b) return b; + }return "keypress" === a.type ? (a = hj(a), 13 === a ? "Enter" : String.fromCharCode(a)) : "keydown" === a.type || "keyup" === a.type ? jj[a.keyCode] || "Unidentified" : ""; + }, location: null, ctrlKey: null, shiftKey: null, altKey: null, metaKey: null, repeat: null, locale: null, getModifierState: Mi, charCode: function charCode(a) { + return "keypress" === a.type ? hj(a) : 0; + }, keyCode: function keyCode(a) { + return "keydown" === a.type || "keyup" === a.type ? a.keyCode : 0; + }, which: function which(a) { + return "keypress" === a.type ? hj(a) : "keydown" === a.type || "keyup" === a.type ? a.keyCode : 0; + } });function lj(a, b, c, d) { + return Y.call(this, a, b, c, d); +}Ni.augmentClass(lj, { dataTransfer: null });function mj(a, b, c, d) { + return Y.call(this, a, b, c, d); +}Ji.augmentClass(mj, { touches: null, targetTouches: null, changedTouches: null, altKey: null, metaKey: null, ctrlKey: null, shiftKey: null, getModifierState: Mi });function nj(a, b, c, d) { + return Y.call(this, a, b, c, d); +}Y.augmentClass(nj, { propertyName: null, elapsedTime: null, pseudoElement: null }); +function oj(a, b, c, d) { + return Y.call(this, a, b, c, d); +}Ni.augmentClass(oj, { deltaX: function deltaX(a) { + return "deltaX" in a ? a.deltaX : "wheelDeltaX" in a ? -a.wheelDeltaX : 0; + }, deltaY: function deltaY(a) { + return "deltaY" in a ? a.deltaY : "wheelDeltaY" in a ? -a.wheelDeltaY : "wheelDelta" in a ? -a.wheelDelta : 0; + }, deltaZ: null, deltaMode: null });var pj = {}, + qj = {}; +"abort animationEnd animationIteration animationStart blur cancel canPlay canPlayThrough click close contextMenu copy cut doubleClick drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error focus input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing progress rateChange reset scroll seeked seeking stalled submit suspend timeUpdate toggle touchCancel touchEnd touchMove touchStart transitionEnd volumeChange waiting wheel".split(" ").forEach(function (a) { + var b = a[0].toUpperCase() + a.slice(1), + c = "on" + b;b = "top" + b;c = { phasedRegistrationNames: { bubbled: c, captured: c + "Capture" }, dependencies: [b] };pj[a] = c;qj[b] = c; +}); +var rj = { eventTypes: pj, extractEvents: function extractEvents(a, b, c, d) { + var e = qj[a];if (!e) return null;switch (a) {case "topAbort":case "topCancel":case "topCanPlay":case "topCanPlayThrough":case "topClose":case "topDurationChange":case "topEmptied":case "topEncrypted":case "topEnded":case "topError":case "topInput":case "topInvalid":case "topLoad":case "topLoadedData":case "topLoadedMetadata":case "topLoadStart":case "topPause":case "topPlay":case "topPlaying":case "topProgress":case "topRateChange":case "topReset":case "topSeeked":case "topSeeking":case "topStalled":case "topSubmit":case "topSuspend":case "topTimeUpdate":case "topToggle":case "topVolumeChange":case "topWaiting": + var f = Y; + break;case "topKeyPress": + if (0 === hj(c)) return null;case "topKeyDown":case "topKeyUp": + f = kj;break;case "topBlur":case "topFocus": + f = gj;break;case "topClick": + if (2 === c.button) return null;case "topDoubleClick":case "topMouseDown":case "topMouseMove":case "topMouseUp":case "topMouseOut":case "topMouseOver":case "topContextMenu": + f = Ni;break;case "topDrag":case "topDragEnd":case "topDragEnter":case "topDragExit":case "topDragLeave":case "topDragOver":case "topDragStart":case "topDrop": + f = lj;break;case "topTouchCancel":case "topTouchEnd":case "topTouchMove":case "topTouchStart": + f = mj;break;case "topAnimationEnd":case "topAnimationIteration":case "topAnimationStart": + f = ej;break;case "topTransitionEnd": + f = nj;break;case "topScroll": + f = Ji;break;case "topWheel": + f = oj;break;case "topCopy":case "topCut":case "topPaste": + f = fj;}f ? void 0 : w("86", a);a = f.getPooled(e, b, c, d);Th.accumulateTwoPhaseDispatches(a);return a; + } };L.setHandleTopLevel(M.handleTopLevel);Jb.injection.injectEventPluginOrder("ResponderEventPlugin SimpleEventPlugin TapEventPlugin EnterLeaveEventPlugin ChangeEventPlugin SelectEventPlugin BeforeInputEventPlugin".split(" ")); +ib.injection.injectComponentTree(G);Jb.injection.injectEventPluginsByName({ SimpleEventPlugin: rj, EnterLeaveEventPlugin: Pi, ChangeEventPlugin: Ii, SelectEventPlugin: dj, BeforeInputEventPlugin: ri }); +var sj = A.injection.MUST_USE_PROPERTY, + Z = A.injection.HAS_BOOLEAN_VALUE, + tj = A.injection.HAS_NUMERIC_VALUE, + uj = A.injection.HAS_POSITIVE_NUMERIC_VALUE, + vj = A.injection.HAS_STRING_BOOLEAN_VALUE, + wj = { Properties: { allowFullScreen: Z, allowTransparency: vj, async: Z, autoPlay: Z, capture: Z, checked: sj | Z, cols: uj, contentEditable: vj, controls: Z, "default": Z, defer: Z, disabled: Z, download: A.injection.HAS_OVERLOADED_BOOLEAN_VALUE, draggable: vj, formNoValidate: Z, hidden: Z, loop: Z, multiple: sj | Z, muted: sj | Z, noValidate: Z, open: Z, playsInline: Z, + readOnly: Z, required: Z, reversed: Z, rows: uj, rowSpan: tj, scoped: Z, seamless: Z, selected: sj | Z, size: uj, start: tj, span: uj, spellCheck: vj, style: 0, itemScope: Z, acceptCharset: 0, className: 0, htmlFor: 0, httpEquiv: 0, value: vj }, DOMAttributeNames: { acceptCharset: "accept-charset", className: "class", htmlFor: "for", httpEquiv: "http-equiv" }, DOMMutationMethods: { value: function value(a, b) { + if (null == b) return a.removeAttribute("value");"number" !== a.type || !1 === a.hasAttribute("value") ? a.setAttribute("value", "" + b) : a.validity && !a.validity.badInput && a.ownerDocument.activeElement !== a && a.setAttribute("value", "" + b); + } } }, + xj = A.injection.HAS_STRING_BOOLEAN_VALUE, + yj = { xlink: "http://www.w3.org/1999/xlink", xml: "http://www.w3.org/XML/1998/namespace" }, + zj = { Properties: { autoReverse: xj, externalResourcesRequired: xj, preserveAlpha: xj }, DOMAttributeNames: { autoReverse: "autoReverse", externalResourcesRequired: "externalResourcesRequired", preserveAlpha: "preserveAlpha" }, DOMAttributeNamespaces: { xlinkActuate: yj.xlink, xlinkArcrole: yj.xlink, xlinkHref: yj.xlink, xlinkRole: yj.xlink, + xlinkShow: yj.xlink, xlinkTitle: yj.xlink, xlinkType: yj.xlink, xmlBase: yj.xml, xmlLang: yj.xml, xmlSpace: yj.xml } }, + Aj = /[\-\:]([a-z])/g;function Bj(a) { + return a[1].toUpperCase(); +} +"accent-height alignment-baseline arabic-form baseline-shift cap-height clip-path clip-rule color-interpolation color-interpolation-filters color-profile color-rendering dominant-baseline enable-background fill-opacity fill-rule flood-color flood-opacity font-family font-size font-size-adjust font-stretch font-style font-variant font-weight glyph-name glyph-orientation-horizontal glyph-orientation-vertical horiz-adv-x horiz-origin-x image-rendering letter-spacing lighting-color marker-end marker-mid marker-start overline-position overline-thickness paint-order panose-1 pointer-events rendering-intent shape-rendering stop-color stop-opacity strikethrough-position strikethrough-thickness stroke-dasharray stroke-dashoffset stroke-linecap stroke-linejoin stroke-miterlimit stroke-opacity stroke-width text-anchor text-decoration text-rendering underline-position underline-thickness unicode-bidi unicode-range units-per-em v-alphabetic v-hanging v-ideographic v-mathematical vector-effect vert-adv-y vert-origin-x vert-origin-y word-spacing writing-mode x-height xlink:actuate xlink:arcrole xlink:href xlink:role xlink:show xlink:title xlink:type xml:base xmlns:xlink xml:lang xml:space".split(" ").forEach(function (a) { + var b = a.replace(Aj, Bj);zj.Properties[b] = 0;zj.DOMAttributeNames[b] = a; +});A.injection.injectDOMPropertyConfig(wj);A.injection.injectDOMPropertyConfig(zj); +var Cj = ig.injectInternals, + Dj = F.ELEMENT_NODE, + Ej = F.TEXT_NODE, + Fj = F.COMMENT_NODE, + Gj = F.DOCUMENT_NODE, + Hj = F.DOCUMENT_FRAGMENT_NODE, + Ij = A.ROOT_ATTRIBUTE_NAME, + Jj = ka.getChildNamespace, + Kj = N.createElement, + Lj = N.createTextNode, + Mj = N.setInitialProperties, + Nj = N.diffProperties, + Oj = N.updateProperties, + Pj = N.diffHydratedProperties, + Qj = N.diffHydratedText, + Rj = N.warnForDeletedHydratableElement, + Sj = N.warnForDeletedHydratableText, + Tj = N.warnForInsertedHydratedElement, + Uj = N.warnForInsertedHydratedText, + Vj = G.precacheFiberNode, + Wj = G.updateFiberProps; +nb.injection.injectFiberControlledHostComponent(N);Dh._injectFiber(function (a) { + return Xj.findHostInstance(a); +});var Yj = null, + Zj = null;function ak(a) { + return !(!a || a.nodeType !== Dj && a.nodeType !== Gj && a.nodeType !== Hj && (a.nodeType !== Fj || " react-mount-point-unstable " !== a.nodeValue)); +}function bk(a) { + a = a ? a.nodeType === Gj ? a.documentElement : a.firstChild : null;return !(!a || a.nodeType !== Dj || !a.hasAttribute(Ij)); +} +var Xj = function (a) { + var b = a.getPublicInstance;a = hh(a);var c = a.scheduleUpdate, + d = a.getPriorityContext;return { createContainer: function createContainer(a) { + var b = ee();a = { current: b, containerInfo: a, isScheduled: !1, nextScheduledRoot: null, context: null, pendingContext: null };return b.stateNode = a; + }, updateContainer: function updateContainer(a, b, g, h) { + var e = b.current;g = jh(g);null === b.context ? b.context = g : b.pendingContext = g;b = h;h = d(e, ed.enableAsyncSubtreeAPI && null != a && null != a.type && null != a.type.prototype && !0 === a.type.prototype.unstable_isAsyncReactComponent); + a = { element: a };kh(e, a, void 0 === b ? null : b, h);c(e, h); + }, batchedUpdates: a.batchedUpdates, unbatchedUpdates: a.unbatchedUpdates, deferredUpdates: a.deferredUpdates, flushSync: a.flushSync, getPublicRootInstance: function getPublicRootInstance(a) { + a = a.current;if (!a.child) return null;switch (a.child.tag) {case oh: + return b(a.child.stateNode);default: + return a.child.stateNode;} + }, findHostInstance: function findHostInstance(a) { + a = ph(a);return null === a ? null : a.stateNode; + }, findHostInstanceWithNoPortals: function findHostInstanceWithNoPortals(a) { + a = qh(a);return null === a ? null : a.stateNode; + } }; +}({ getRootHostContext: function getRootHostContext(a) { + if (a.nodeType === Gj) a = (a = a.documentElement) ? a.namespaceURI : Jj(null, "");else { + var b = a.nodeType === Fj ? a.parentNode : a;a = b.namespaceURI || null;b = b.tagName;a = Jj(a, b); + }return a; + }, getChildHostContext: function getChildHostContext(a, b) { + return Jj(a, b); + }, getPublicInstance: function getPublicInstance(a) { + return a; + }, prepareForCommit: function prepareForCommit() { + Yj = M.isEnabled();Zj = zh.getSelectionInformation();M.setEnabled(!1); + }, resetAfterCommit: function resetAfterCommit() { + zh.restoreSelection(Zj);Zj = null;M.setEnabled(Yj);Yj = null; + }, createInstance: function createInstance(a, b, c, d, e) { + a = Kj(a, b, c, d);Vj(e, a);Wj(a, b);return a; + }, appendInitialChild: function appendInitialChild(a, b) { + a.appendChild(b); + }, finalizeInitialChildren: function finalizeInitialChildren(a, b, c, d) { + Mj(a, b, c, d);a: { + switch (b) {case "button":case "input":case "select":case "textarea": + a = !!c.autoFocus;break a;}a = !1; + }return a; + }, prepareUpdate: function prepareUpdate(a, b, c, d, e) { + return Nj(a, b, c, d, e); + }, commitMount: function commitMount(a) { + a.focus(); + }, commitUpdate: function commitUpdate(a, b, c, d, e) { + Wj(a, e);Oj(a, b, c, d, e); + }, shouldSetTextContent: function shouldSetTextContent(a, b) { + return "textarea" === a || "string" === typeof b.children || "number" === typeof b.children || "object" === _typeof(b.dangerouslySetInnerHTML) && null !== b.dangerouslySetInnerHTML && "string" === typeof b.dangerouslySetInnerHTML.__html; + }, resetTextContent: function resetTextContent(a) { + a.textContent = ""; + }, shouldDeprioritizeSubtree: function shouldDeprioritizeSubtree(a, b) { + return !!b.hidden; + }, createTextInstance: function createTextInstance(a, b, c, d) { + a = Lj(a, b);Vj(d, a);return a; + }, commitTextUpdate: function commitTextUpdate(a, b, c) { + a.nodeValue = c; + }, appendChild: function appendChild(a, b) { + a.appendChild(b); + }, appendChildToContainer: function appendChildToContainer(a, b) { + a.nodeType === Fj ? a.parentNode.insertBefore(b, a) : a.appendChild(b); + }, insertBefore: function insertBefore(a, b, c) { + a.insertBefore(b, c); + }, insertInContainerBefore: function insertInContainerBefore(a, b, c) { + a.nodeType === Fj ? a.parentNode.insertBefore(b, c) : a.insertBefore(b, c); + }, removeChild: function removeChild(a, b) { + a.removeChild(b); + }, removeChildFromContainer: function removeChildFromContainer(a, b) { + a.nodeType === Fj ? a.parentNode.removeChild(b) : a.removeChild(b); + }, canHydrateInstance: function canHydrateInstance(a, b) { + return a.nodeType === Dj && b === a.nodeName.toLowerCase(); + }, canHydrateTextInstance: function canHydrateTextInstance(a, b) { + return "" === b ? !1 : a.nodeType === Ej; + }, getNextHydratableSibling: function getNextHydratableSibling(a) { + for (a = a.nextSibling; a && a.nodeType !== Dj && a.nodeType !== Ej;) { + a = a.nextSibling; + }return a; + }, getFirstHydratableChild: function getFirstHydratableChild(a) { + for (a = a.firstChild; a && a.nodeType !== Dj && a.nodeType !== Ej;) { + a = a.nextSibling; + }return a; + }, hydrateInstance: function hydrateInstance(a, b, c, d, e, f) { + Vj(f, a);Wj(a, c);return Pj(a, b, c, e, d); + }, hydrateTextInstance: function hydrateTextInstance(a, b, c) { + Vj(c, a);return Qj(a, b); + }, didNotHydrateInstance: function didNotHydrateInstance(a, b) { + 1 === b.nodeType ? Rj(a, b) : Sj(a, b); + }, didNotFindHydratableInstance: function didNotFindHydratableInstance(a, b, c) { + Tj(a, b, c); + }, didNotFindHydratableTextInstance: function didNotFindHydratableTextInstance(a, b) { + Uj(a, b); + }, scheduleDeferredCallback: dd.rIC, useSyncScheduling: !0 });sb.injection.injectFiberBatchedUpdates(Xj.batchedUpdates); +function ck(a, b, c, d, e) { + ak(c) ? void 0 : w("200");var f = c._reactRootContainer;if (f) Xj.updateContainer(b, f, a, e);else { + if (!d && !bk(c)) for (d = void 0; d = c.lastChild;) { + c.removeChild(d); + }var g = Xj.createContainer(c);f = c._reactRootContainer = g;Xj.unbatchedUpdates(function () { + Xj.updateContainer(b, g, a, e); + }); + }return Xj.getPublicRootInstance(f); +}function dk(a, b) { + var c = 2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : null;ak(b) ? void 0 : w("200");return ne.createPortal(a, b, null, c); +} +var ek = { createPortal: dk, hydrate: function hydrate(a, b, c) { + return ck(null, a, b, !0, c); + }, render: function render(a, b, c) { + return ck(null, a, b, !1, c); + }, unstable_renderSubtreeIntoContainer: function unstable_renderSubtreeIntoContainer(a, b, c, d) { + null != a && Pa.has(a) ? void 0 : w("38");return ck(a, b, c, !1, d); + }, unmountComponentAtNode: function unmountComponentAtNode(a) { + ak(a) ? void 0 : w("40");return a._reactRootContainer ? (Xj.unbatchedUpdates(function () { + ck(null, null, a, !1, function () { + a._reactRootContainer = null; + }); + }), !0) : !1; + }, findDOMNode: Dh, unstable_createPortal: dk, unstable_batchedUpdates: sb.batchedUpdates, + unstable_deferredUpdates: Xj.deferredUpdates, flushSync: Xj.flushSync, __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: { EventPluginHub: Jb, EventPluginRegistry: sa, EventPropagators: Th, ReactControlledComponent: nb, ReactDOMComponentTree: G, ReactDOMEventListener: L } };Cj({ findFiberByHostInstance: G.getClosestInstanceFromNode, findHostInstanceByFiber: Xj.findHostInstance, bundleType: 0, version: "16.0.0", rendererPackageName: "react-dom" });module.exports = ek; + +/***/ }), +/* 22 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + * @typechecks + */ + +var isNode = __webpack_require__(23); + +/** + * @param {*} object The object to check. + * @return {boolean} Whether or not the object is a DOM text node. + */ +function isTextNode(object) { + return isNode(object) && object.nodeType == 3; +} + +module.exports = isTextNode; + +/***/ }), +/* 23 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + * @typechecks + */ + +/** + * @param {*} object The object to check. + * @return {boolean} Whether or not the object is a DOM node. + */ + +var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + +function isNode(object) { + var doc = object ? object.ownerDocument || object : document; + var defaultView = doc.defaultView || window; + return !!(object && (typeof defaultView.Node === 'function' ? object instanceof defaultView.Node : (typeof object === 'undefined' ? 'undefined' : _typeof(object)) === 'object' && typeof object.nodeType === 'number' && typeof object.nodeName === 'string')); +} + +module.exports = isNode; + +/***/ }), +/* 24 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; +/* WEBPACK VAR INJECTION */(function(process) {/** @license React v16.0.0 + * react-dom.development.js + * + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */var _typeof=typeof Symbol==="function"&&typeof Symbol.iterator==="symbol"?function(obj){return typeof obj;}:function(obj){return obj&&typeof Symbol==="function"&&obj.constructor===Symbol&&obj!==Symbol.prototype?"symbol":typeof obj;};if(process.env.NODE_ENV!=="production"){(function(){'use strict';var react=__webpack_require__(1);var invariant=__webpack_require__(3);var ExecutionEnvironment=__webpack_require__(9);var _assign=__webpack_require__(4);var EventListener=__webpack_require__(11);var require$$0=__webpack_require__(6);var hyphenateStyleName=__webpack_require__(25);var emptyFunction=__webpack_require__(2);var camelizeStyleName=__webpack_require__(27);var performanceNow=__webpack_require__(29);var propTypes=__webpack_require__(16);var emptyObject=__webpack_require__(5);var checkPropTypes=__webpack_require__(7);var shallowEqual=__webpack_require__(12);var containsNode=__webpack_require__(13);var focusNode=__webpack_require__(14);var getActiveElement=__webpack_require__(15);/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + * @providesModule reactProdInvariant + * + *//** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + * @providesModule checkReact + * + */!react?invariant(false,'ReactDOM was loaded before React. Make sure you load the React package before loading ReactDOM.'):void 0;/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + * @providesModule DOMNamespaces + */var HTML_NAMESPACE='http://www.w3.org/1999/xhtml';var MATH_NAMESPACE='http://www.w3.org/1998/Math/MathML';var SVG_NAMESPACE='http://www.w3.org/2000/svg';var Namespaces={html:HTML_NAMESPACE,mathml:MATH_NAMESPACE,svg:SVG_NAMESPACE};// Assumes there is no parent namespace. +function getIntrinsicNamespace(type){switch(type){case'svg':return SVG_NAMESPACE;case'math':return MATH_NAMESPACE;default:return HTML_NAMESPACE;}}function getChildNamespace$1(parentNamespace,type){if(parentNamespace==null||parentNamespace===HTML_NAMESPACE){// No (or default) parent namespace: potential entry point. +return getIntrinsicNamespace(type);}if(parentNamespace===SVG_NAMESPACE&&type==='foreignObject'){// We're leaving SVG. +return HTML_NAMESPACE;}// By default, pass namespace below. +return parentNamespace;}var Namespaces_1=Namespaces;var getIntrinsicNamespace_1=getIntrinsicNamespace;var getChildNamespace_1=getChildNamespace$1;var DOMNamespaces={Namespaces:Namespaces_1,getIntrinsicNamespace:getIntrinsicNamespace_1,getChildNamespace:getChildNamespace_1};/** + * Injectable ordering of event plugins. + */var eventPluginOrder=null;/** + * Injectable mapping from names to event plugin modules. + */var namesToPlugins={};/** + * Recomputes the plugin list using the injected plugins and plugin ordering. + * + * @private + */function recomputePluginOrdering(){if(!eventPluginOrder){// Wait until an `eventPluginOrder` is injected. +return;}for(var pluginName in namesToPlugins){var pluginModule=namesToPlugins[pluginName];var pluginIndex=eventPluginOrder.indexOf(pluginName);!(pluginIndex>-1)?invariant(false,'EventPluginRegistry: Cannot inject event plugins that do not exist in the plugin ordering, `%s`.',pluginName):void 0;if(EventPluginRegistry.plugins[pluginIndex]){continue;}!pluginModule.extractEvents?invariant(false,'EventPluginRegistry: Event plugins must implement an `extractEvents` method, but `%s` does not.',pluginName):void 0;EventPluginRegistry.plugins[pluginIndex]=pluginModule;var publishedEvents=pluginModule.eventTypes;for(var eventName in publishedEvents){!publishEventForPlugin(publishedEvents[eventName],pluginModule,eventName)?invariant(false,'EventPluginRegistry: Failed to publish event `%s` for plugin `%s`.',eventName,pluginName):void 0;}}}/** + * Publishes an event so that it can be dispatched by the supplied plugin. + * + * @param {object} dispatchConfig Dispatch configuration for the event. + * @param {object} PluginModule Plugin publishing the event. + * @return {boolean} True if the event was successfully published. + * @private + */function publishEventForPlugin(dispatchConfig,pluginModule,eventName){!!EventPluginRegistry.eventNameDispatchConfigs.hasOwnProperty(eventName)?invariant(false,'EventPluginHub: More than one plugin attempted to publish the same event name, `%s`.',eventName):void 0;EventPluginRegistry.eventNameDispatchConfigs[eventName]=dispatchConfig;var phasedRegistrationNames=dispatchConfig.phasedRegistrationNames;if(phasedRegistrationNames){for(var phaseName in phasedRegistrationNames){if(phasedRegistrationNames.hasOwnProperty(phaseName)){var phasedRegistrationName=phasedRegistrationNames[phaseName];publishRegistrationName(phasedRegistrationName,pluginModule,eventName);}}return true;}else if(dispatchConfig.registrationName){publishRegistrationName(dispatchConfig.registrationName,pluginModule,eventName);return true;}return false;}/** + * Publishes a registration name that is used to identify dispatched events. + * + * @param {string} registrationName Registration name to add. + * @param {object} PluginModule Plugin publishing the event. + * @private + */function publishRegistrationName(registrationName,pluginModule,eventName){!!EventPluginRegistry.registrationNameModules[registrationName]?invariant(false,'EventPluginHub: More than one plugin attempted to publish the same registration name, `%s`.',registrationName):void 0;EventPluginRegistry.registrationNameModules[registrationName]=pluginModule;EventPluginRegistry.registrationNameDependencies[registrationName]=pluginModule.eventTypes[eventName].dependencies;{var lowerCasedName=registrationName.toLowerCase();EventPluginRegistry.possibleRegistrationNames[lowerCasedName]=registrationName;if(registrationName==='onDoubleClick'){EventPluginRegistry.possibleRegistrationNames.ondblclick=registrationName;}}}/** + * Registers plugins so that they can extract and dispatch events. + * + * @see {EventPluginHub} + */var EventPluginRegistry={/** + * Ordered list of injected plugins. + */plugins:[],/** + * Mapping from event name to dispatch config + */eventNameDispatchConfigs:{},/** + * Mapping from registration name to plugin module + */registrationNameModules:{},/** + * Mapping from registration name to event name + */registrationNameDependencies:{},/** + * Mapping from lowercase registration names to the properly cased version, + * used to warn in the case of missing event handlers. Available + * only in true. + * @type {Object} + */possibleRegistrationNames:{},// Trust the developer to only use possibleRegistrationNames in true +/** + * Injects an ordering of plugins (by plugin name). This allows the ordering + * to be decoupled from injection of the actual plugins so that ordering is + * always deterministic regardless of packaging, on-the-fly injection, etc. + * + * @param {array} InjectedEventPluginOrder + * @internal + * @see {EventPluginHub.injection.injectEventPluginOrder} + */injectEventPluginOrder:function injectEventPluginOrder(injectedEventPluginOrder){!!eventPluginOrder?invariant(false,'EventPluginRegistry: Cannot inject event plugin ordering more than once. You are likely trying to load more than one copy of React.'):void 0;// Clone the ordering so it cannot be dynamically mutated. +eventPluginOrder=Array.prototype.slice.call(injectedEventPluginOrder);recomputePluginOrdering();},/** + * Injects plugins to be used by `EventPluginHub`. The plugin names must be + * in the ordering injected by `injectEventPluginOrder`. + * + * Plugins can be injected as part of page initialization or on-the-fly. + * + * @param {object} injectedNamesToPlugins Map from names to plugin modules. + * @internal + * @see {EventPluginHub.injection.injectEventPluginsByName} + */injectEventPluginsByName:function injectEventPluginsByName(injectedNamesToPlugins){var isOrderingDirty=false;for(var pluginName in injectedNamesToPlugins){if(!injectedNamesToPlugins.hasOwnProperty(pluginName)){continue;}var pluginModule=injectedNamesToPlugins[pluginName];if(!namesToPlugins.hasOwnProperty(pluginName)||namesToPlugins[pluginName]!==pluginModule){!!namesToPlugins[pluginName]?invariant(false,'EventPluginRegistry: Cannot inject two different event plugins using the same name, `%s`.',pluginName):void 0;namesToPlugins[pluginName]=pluginModule;isOrderingDirty=true;}}if(isOrderingDirty){recomputePluginOrdering();}}};var EventPluginRegistry_1=EventPluginRegistry;// These attributes should be all lowercase to allow for +// case insensitive checks +var RESERVED_PROPS={children:true,dangerouslySetInnerHTML:true,autoFocus:true,defaultValue:true,defaultChecked:true,innerHTML:true,suppressContentEditableWarning:true,style:true};function checkMask(value,bitmask){return(value&bitmask)===bitmask;}var DOMPropertyInjection={/** + * Mapping from normalized, camelcased property names to a configuration that + * specifies how the associated DOM property should be accessed or rendered. + */MUST_USE_PROPERTY:0x1,HAS_BOOLEAN_VALUE:0x4,HAS_NUMERIC_VALUE:0x8,HAS_POSITIVE_NUMERIC_VALUE:0x10|0x8,HAS_OVERLOADED_BOOLEAN_VALUE:0x20,HAS_STRING_BOOLEAN_VALUE:0x40,/** + * Inject some specialized knowledge about the DOM. This takes a config object + * with the following properties: + * + * Properties: object mapping DOM property name to one of the + * DOMPropertyInjection constants or null. If your attribute isn't in here, + * it won't get written to the DOM. + * + * DOMAttributeNames: object mapping React attribute name to the DOM + * attribute name. Attribute names not specified use the **lowercase** + * normalized name. + * + * DOMAttributeNamespaces: object mapping React attribute name to the DOM + * attribute namespace URL. (Attribute names not specified use no namespace.) + * + * DOMPropertyNames: similar to DOMAttributeNames but for DOM properties. + * Property names not specified use the normalized name. + * + * DOMMutationMethods: Properties that require special mutation methods. If + * `value` is undefined, the mutation method should unset the property. + * + * @param {object} domPropertyConfig the config as described above. + */injectDOMPropertyConfig:function injectDOMPropertyConfig(domPropertyConfig){var Injection=DOMPropertyInjection;var Properties=domPropertyConfig.Properties||{};var DOMAttributeNamespaces=domPropertyConfig.DOMAttributeNamespaces||{};var DOMAttributeNames=domPropertyConfig.DOMAttributeNames||{};var DOMMutationMethods=domPropertyConfig.DOMMutationMethods||{};for(var propName in Properties){!!DOMProperty.properties.hasOwnProperty(propName)?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):void 0;var lowerCased=propName.toLowerCase();var propConfig=Properties[propName];var propertyInfo={attributeName:lowerCased,attributeNamespace:null,propertyName:propName,mutationMethod:null,mustUseProperty:checkMask(propConfig,Injection.MUST_USE_PROPERTY),hasBooleanValue:checkMask(propConfig,Injection.HAS_BOOLEAN_VALUE),hasNumericValue:checkMask(propConfig,Injection.HAS_NUMERIC_VALUE),hasPositiveNumericValue:checkMask(propConfig,Injection.HAS_POSITIVE_NUMERIC_VALUE),hasOverloadedBooleanValue:checkMask(propConfig,Injection.HAS_OVERLOADED_BOOLEAN_VALUE),hasStringBooleanValue:checkMask(propConfig,Injection.HAS_STRING_BOOLEAN_VALUE)};!(propertyInfo.hasBooleanValue+propertyInfo.hasNumericValue+propertyInfo.hasOverloadedBooleanValue<=1)?invariant(false,'DOMProperty: Value can be one of boolean, overloaded boolean, or numeric value, but not a combination: %s',propName):void 0;if(DOMAttributeNames.hasOwnProperty(propName)){var attributeName=DOMAttributeNames[propName];propertyInfo.attributeName=attributeName;}if(DOMAttributeNamespaces.hasOwnProperty(propName)){propertyInfo.attributeNamespace=DOMAttributeNamespaces[propName];}if(DOMMutationMethods.hasOwnProperty(propName)){propertyInfo.mutationMethod=DOMMutationMethods[propName];}// Downcase references to whitelist properties to check for membership +// without case-sensitivity. This allows the whitelist to pick up +// `allowfullscreen`, which should be written using the property configuration +// for `allowFullscreen` +DOMProperty.properties[propName]=propertyInfo;}}};/* eslint-disable max-len */var ATTRIBUTE_NAME_START_CHAR=':A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD';/* eslint-enable max-len *//** + * DOMProperty exports lookup objects that can be used like functions: + * + * > DOMProperty.isValid['id'] + * true + * > DOMProperty.isValid['foobar'] + * undefined + * + * Although this may be confusing, it performs better in general. + * + * @see http://jsperf.com/key-exists + * @see http://jsperf.com/key-missing + */var DOMProperty={ID_ATTRIBUTE_NAME:'data-reactid',ROOT_ATTRIBUTE_NAME:'data-reactroot',ATTRIBUTE_NAME_START_CHAR:ATTRIBUTE_NAME_START_CHAR,ATTRIBUTE_NAME_CHAR:ATTRIBUTE_NAME_START_CHAR+'\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040',/** + * Map from property "standard name" to an object with info about how to set + * the property in the DOM. Each object contains: + * + * attributeName: + * Used when rendering markup or with `*Attribute()`. + * attributeNamespace + * propertyName: + * Used on DOM node instances. (This includes properties that mutate due to + * external factors.) + * mutationMethod: + * If non-null, used instead of the property or `setAttribute()` after + * initial render. + * mustUseProperty: + * Whether the property must be accessed and mutated as an object property. + * hasBooleanValue: + * Whether the property should be removed when set to a falsey value. + * hasNumericValue: + * Whether the property must be numeric or parse as a numeric and should be + * removed when set to a falsey value. + * hasPositiveNumericValue: + * Whether the property must be positive numeric or parse as a positive + * numeric and should be removed when set to a falsey value. + * hasOverloadedBooleanValue: + * Whether the property can be used as a flag as well as with a value. + * Removed when strictly equal to false; present without a value when + * strictly equal to true; present with a value otherwise. + */properties:{},/** + * Checks whether a property name is a writeable attribute. + * @method + */shouldSetAttribute:function shouldSetAttribute(name,value){if(DOMProperty.isReservedProp(name)){return false;}if((name[0]==='o'||name[0]==='O')&&(name[1]==='n'||name[1]==='N')){return false;}if(value===null){return true;}switch(typeof value==='undefined'?'undefined':_typeof(value)){case'boolean':return DOMProperty.shouldAttributeAcceptBooleanValue(name);case'undefined':case'number':case'string':case'object':return true;default:// function, symbol +return false;}},getPropertyInfo:function getPropertyInfo(name){return DOMProperty.properties.hasOwnProperty(name)?DOMProperty.properties[name]:null;},shouldAttributeAcceptBooleanValue:function shouldAttributeAcceptBooleanValue(name){if(DOMProperty.isReservedProp(name)){return true;}var propertyInfo=DOMProperty.getPropertyInfo(name);if(propertyInfo){return propertyInfo.hasBooleanValue||propertyInfo.hasStringBooleanValue||propertyInfo.hasOverloadedBooleanValue;}var prefix=name.toLowerCase().slice(0,5);return prefix==='data-'||prefix==='aria-';},/** + * Checks to see if a property name is within the list of properties + * reserved for internal React operations. These properties should + * not be set on an HTML element. + * + * @private + * @param {string} name + * @return {boolean} If the name is within reserved props + */isReservedProp:function isReservedProp(name){return RESERVED_PROPS.hasOwnProperty(name);},injection:DOMPropertyInjection};var DOMProperty_1=DOMProperty;/** + * Copyright (c) 2015-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + * @providesModule ReactDOMComponentFlags + */var ReactDOMComponentFlags={hasCachedChildNodes:1<<0};var ReactDOMComponentFlags_1=ReactDOMComponentFlags;/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + * @providesModule ReactTypeOfWork + * + */var ReactTypeOfWork={IndeterminateComponent:0,// Before we know whether it is functional or class +FunctionalComponent:1,ClassComponent:2,HostRoot:3,// Root of a host tree. Could be nested inside another node. +HostPortal:4,// A subtree. Could be an entry point to a different renderer. +HostComponent:5,HostText:6,CoroutineComponent:7,CoroutineHandlerPhase:8,YieldComponent:9,Fragment:10};/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + * @providesModule HTMLNodeType + *//** + * HTML nodeType values that represent the type of the node + */var HTMLNodeType={ELEMENT_NODE:1,TEXT_NODE:3,COMMENT_NODE:8,DOCUMENT_NODE:9,DOCUMENT_FRAGMENT_NODE:11};var HTMLNodeType_1=HTMLNodeType;var HostComponent=ReactTypeOfWork.HostComponent;var HostText=ReactTypeOfWork.HostText;var ELEMENT_NODE$1=HTMLNodeType_1.ELEMENT_NODE;var COMMENT_NODE$1=HTMLNodeType_1.COMMENT_NODE;var ATTR_NAME=DOMProperty_1.ID_ATTRIBUTE_NAME;var Flags=ReactDOMComponentFlags_1;var randomKey=Math.random().toString(36).slice(2);var internalInstanceKey='__reactInternalInstance$'+randomKey;var internalEventHandlersKey='__reactEventHandlers$'+randomKey;/** + * Check if a given node should be cached. + */function shouldPrecacheNode(node,nodeID){return node.nodeType===ELEMENT_NODE$1&&node.getAttribute(ATTR_NAME)===''+nodeID||node.nodeType===COMMENT_NODE$1&&node.nodeValue===' react-text: '+nodeID+' '||node.nodeType===COMMENT_NODE$1&&node.nodeValue===' react-empty: '+nodeID+' ';}/** + * Drill down (through composites and empty components) until we get a host or + * host text component. + * + * This is pretty polymorphic but unavoidable with the current structure we have + * for `_renderedChildren`. + */function getRenderedHostOrTextFromComponent(component){var rendered;while(rendered=component._renderedComponent){component=rendered;}return component;}/** + * Populate `_hostNode` on the rendered host/text component with the given + * DOM node. The passed `inst` can be a composite. + */function precacheNode(inst,node){var hostInst=getRenderedHostOrTextFromComponent(inst);hostInst._hostNode=node;node[internalInstanceKey]=hostInst;}function precacheFiberNode$1(hostInst,node){node[internalInstanceKey]=hostInst;}function uncacheNode(inst){var node=inst._hostNode;if(node){delete node[internalInstanceKey];inst._hostNode=null;}}/** + * Populate `_hostNode` on each child of `inst`, assuming that the children + * match up with the DOM (element) children of `node`. + * + * We cache entire levels at once to avoid an n^2 problem where we access the + * children of a node sequentially and have to walk from the start to our target + * node every time. + * + * Since we update `_renderedChildren` and the actual DOM at (slightly) + * different times, we could race here and see a newer `_renderedChildren` than + * the DOM nodes we see. To avoid this, ReactMultiChild calls + * `prepareToManageChildren` before we change `_renderedChildren`, at which + * time the container's child nodes are always cached (until it unmounts). + */function precacheChildNodes(inst,node){if(inst._flags&Flags.hasCachedChildNodes){return;}var children=inst._renderedChildren;var childNode=node.firstChild;outer:for(var name in children){if(!children.hasOwnProperty(name)){continue;}var childInst=children[name];var childID=getRenderedHostOrTextFromComponent(childInst)._domID;if(childID===0){// We're currently unmounting this child in ReactMultiChild; skip it. +continue;}// We assume the child nodes are in the same order as the child instances. +for(;childNode!==null;childNode=childNode.nextSibling){if(shouldPrecacheNode(childNode,childID)){precacheNode(childInst,childNode);continue outer;}}// We reached the end of the DOM children without finding an ID match. +invariant(false,'Unable to find element with ID %s.',childID);}inst._flags|=Flags.hasCachedChildNodes;}/** + * Given a DOM node, return the closest ReactDOMComponent or + * ReactDOMTextComponent instance ancestor. + */function getClosestInstanceFromNode(node){if(node[internalInstanceKey]){return node[internalInstanceKey];}// Walk up the tree until we find an ancestor whose instance we have cached. +var parents=[];while(!node[internalInstanceKey]){parents.push(node);if(node.parentNode){node=node.parentNode;}else{// Top of the tree. This node must not be part of a React tree (or is +// unmounted, potentially). +return null;}}var closest;var inst=node[internalInstanceKey];if(inst.tag===HostComponent||inst.tag===HostText){// In Fiber, this will always be the deepest root. +return inst;}for(;node&&(inst=node[internalInstanceKey]);node=parents.pop()){closest=inst;if(parents.length){precacheChildNodes(inst,node);}}return closest;}/** + * Given a DOM node, return the ReactDOMComponent or ReactDOMTextComponent + * instance, or null if the node was not rendered by this React. + */function getInstanceFromNode(node){var inst=node[internalInstanceKey];if(inst){if(inst.tag===HostComponent||inst.tag===HostText){return inst;}else if(inst._hostNode===node){return inst;}else{return null;}}inst=getClosestInstanceFromNode(node);if(inst!=null&&inst._hostNode===node){return inst;}else{return null;}}/** + * Given a ReactDOMComponent or ReactDOMTextComponent, return the corresponding + * DOM node. + */function getNodeFromInstance(inst){if(inst.tag===HostComponent||inst.tag===HostText){// In Fiber this, is just the state node right now. We assume it will be +// a host component or host text. +return inst.stateNode;}// Without this first invariant, passing a non-DOM-component triggers the next +// invariant for a missing parent, which is super confusing. +!(inst._hostNode!==undefined)?invariant(false,'getNodeFromInstance: Invalid argument.'):void 0;if(inst._hostNode){return inst._hostNode;}// Walk up the tree until we find an ancestor whose DOM node we have cached. +var parents=[];while(!inst._hostNode){parents.push(inst);!inst._hostParent?invariant(false,'React DOM tree root should always have a node reference.'):void 0;inst=inst._hostParent;}// Now parents contains each ancestor that does *not* have a cached native +// node, and `inst` is the deepest ancestor that does. +for(;parents.length;inst=parents.pop()){precacheChildNodes(inst,inst._hostNode);}return inst._hostNode;}function getFiberCurrentPropsFromNode(node){return node[internalEventHandlersKey]||null;}function updateFiberProps$1(node,props){node[internalEventHandlersKey]=props;}var ReactDOMComponentTree={getClosestInstanceFromNode:getClosestInstanceFromNode,getInstanceFromNode:getInstanceFromNode,getNodeFromInstance:getNodeFromInstance,precacheChildNodes:precacheChildNodes,precacheNode:precacheNode,uncacheNode:uncacheNode,precacheFiberNode:precacheFiberNode$1,getFiberCurrentPropsFromNode:getFiberCurrentPropsFromNode,updateFiberProps:updateFiberProps$1};var ReactDOMComponentTree_1=ReactDOMComponentTree;/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + * @providesModule ReactInstanceMap + *//** + * `ReactInstanceMap` maintains a mapping from a public facing stateful + * instance (key) and the internal representation (value). This allows public + * methods to accept the user facing instance as an argument and map them back + * to internal methods. + */// TODO: Replace this with ES6: var ReactInstanceMap = new Map(); +var ReactInstanceMap={/** + * This API should be called `delete` but we'd have to make sure to always + * transform these to strings for IE support. When this transform is fully + * supported we can rename it. + */remove:function remove(key){key._reactInternalFiber=undefined;},get:function get(key){return key._reactInternalFiber;},has:function has(key){return key._reactInternalFiber!==undefined;},set:function set(key,value){key._reactInternalFiber=value;}};var ReactInstanceMap_1=ReactInstanceMap;var ReactInternals=react.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;var ReactGlobalSharedState={ReactCurrentOwner:ReactInternals.ReactCurrentOwner};{_assign(ReactGlobalSharedState,{ReactComponentTreeHook:ReactInternals.ReactComponentTreeHook,ReactDebugCurrentFrame:ReactInternals.ReactDebugCurrentFrame});}var ReactGlobalSharedState_1=ReactGlobalSharedState;/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + * @providesModule getComponentName + * + */function getComponentName(instanceOrFiber){if(typeof instanceOrFiber.getName==='function'){// Stack reconciler +var instance=instanceOrFiber;return instance.getName();}if(typeof instanceOrFiber.tag==='number'){// Fiber reconciler +var fiber=instanceOrFiber;var type=fiber.type;if(typeof type==='string'){return type;}if(typeof type==='function'){return type.displayName||type.name;}}return null;}var getComponentName_1=getComponentName;/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + * @providesModule ReactTypeOfSideEffect + * + */var ReactTypeOfSideEffect={// Don't change these two values: +NoEffect:0,// 0b00000000 +PerformedWork:1,// 0b00000001 +// You can change the rest (and add more). +Placement:2,// 0b00000010 +Update:4,// 0b00000100 +PlacementAndUpdate:6,// 0b00000110 +Deletion:8,// 0b00001000 +ContentReset:16,// 0b00010000 +Callback:32,// 0b00100000 +Err:64,// 0b01000000 +Ref:128};var ReactCurrentOwner=ReactGlobalSharedState_1.ReactCurrentOwner;{var warning$1=require$$0;}var ClassComponent=ReactTypeOfWork.ClassComponent;var HostComponent$1=ReactTypeOfWork.HostComponent;var HostRoot$1=ReactTypeOfWork.HostRoot;var HostPortal=ReactTypeOfWork.HostPortal;var HostText$1=ReactTypeOfWork.HostText;var NoEffect=ReactTypeOfSideEffect.NoEffect;var Placement=ReactTypeOfSideEffect.Placement;var MOUNTING=1;var MOUNTED=2;var UNMOUNTED=3;function isFiberMountedImpl(fiber){var node=fiber;if(!fiber.alternate){// If there is no alternate, this might be a new tree that isn't inserted +// yet. If it is, then it will have a pending insertion effect on it. +if((node.effectTag&Placement)!==NoEffect){return MOUNTING;}while(node['return']){node=node['return'];if((node.effectTag&Placement)!==NoEffect){return MOUNTING;}}}else{while(node['return']){node=node['return'];}}if(node.tag===HostRoot$1){// TODO: Check if this was a nested HostRoot when used with +// renderContainerIntoSubtree. +return MOUNTED;}// If we didn't hit the root, that means that we're in an disconnected tree +// that has been unmounted. +return UNMOUNTED;}var isFiberMounted=function isFiberMounted(fiber){return isFiberMountedImpl(fiber)===MOUNTED;};var isMounted=function isMounted(component){{var owner=ReactCurrentOwner.current;if(owner!==null&&owner.tag===ClassComponent){var ownerFiber=owner;var instance=ownerFiber.stateNode;warning$1(instance._warnedAboutRefsInRender,'%s is accessing isMounted inside its render() function. '+'render() should be a pure function of props and state. It should '+'never access something that requires stale data from the previous '+'render, such as refs. Move this logic to componentDidMount and '+'componentDidUpdate instead.',getComponentName_1(ownerFiber)||'A component');instance._warnedAboutRefsInRender=true;}}var fiber=ReactInstanceMap_1.get(component);if(!fiber){return false;}return isFiberMountedImpl(fiber)===MOUNTED;};function assertIsMounted(fiber){!(isFiberMountedImpl(fiber)===MOUNTED)?invariant(false,'Unable to find node on an unmounted component.'):void 0;}function findCurrentFiberUsingSlowPath(fiber){var alternate=fiber.alternate;if(!alternate){// If there is no alternate, then we only need to check if it is mounted. +var state=isFiberMountedImpl(fiber);!(state!==UNMOUNTED)?invariant(false,'Unable to find node on an unmounted component.'):void 0;if(state===MOUNTING){return null;}return fiber;}// If we have two possible branches, we'll walk backwards up to the root +// to see what path the root points to. On the way we may hit one of the +// special cases and we'll deal with them. +var a=fiber;var b=alternate;while(true){var parentA=a['return'];var parentB=parentA?parentA.alternate:null;if(!parentA||!parentB){// We're at the root. +break;}// If both copies of the parent fiber point to the same child, we can +// assume that the child is current. This happens when we bailout on low +// priority: the bailed out fiber's child reuses the current child. +if(parentA.child===parentB.child){var child=parentA.child;while(child){if(child===a){// We've determined that A is the current branch. +assertIsMounted(parentA);return fiber;}if(child===b){// We've determined that B is the current branch. +assertIsMounted(parentA);return alternate;}child=child.sibling;}// We should never have an alternate for any mounting node. So the only +// way this could possibly happen is if this was unmounted, if at all. +invariant(false,'Unable to find node on an unmounted component.');}if(a['return']!==b['return']){// The return pointer of A and the return pointer of B point to different +// fibers. We assume that return pointers never criss-cross, so A must +// belong to the child set of A.return, and B must belong to the child +// set of B.return. +a=parentA;b=parentB;}else{// The return pointers point to the same fiber. We'll have to use the +// default, slow path: scan the child sets of each parent alternate to see +// which child belongs to which set. +// +// Search parent A's child set +var didFindChild=false;var _child=parentA.child;while(_child){if(_child===a){didFindChild=true;a=parentA;b=parentB;break;}if(_child===b){didFindChild=true;b=parentA;a=parentB;break;}_child=_child.sibling;}if(!didFindChild){// Search parent B's child set +_child=parentB.child;while(_child){if(_child===a){didFindChild=true;a=parentB;b=parentA;break;}if(_child===b){didFindChild=true;b=parentB;a=parentA;break;}_child=_child.sibling;}!didFindChild?invariant(false,'Child was not found in either parent set. This indicates a bug in React related to the return pointer. Please file an issue.'):void 0;}}!(a.alternate===b)?invariant(false,'Return fibers should always be each others\' alternates. This error is likely caused by a bug in React. Please file an issue.'):void 0;}// If the root is not a host container, we're in a disconnected tree. I.e. +// unmounted. +!(a.tag===HostRoot$1)?invariant(false,'Unable to find node on an unmounted component.'):void 0;if(a.stateNode.current===a){// We've determined that A is the current branch. +return fiber;}// Otherwise B has to be current branch. +return alternate;}var findCurrentFiberUsingSlowPath_1=findCurrentFiberUsingSlowPath;var findCurrentHostFiber=function findCurrentHostFiber(parent){var currentParent=findCurrentFiberUsingSlowPath(parent);if(!currentParent){return null;}// Next we'll drill down this component to find the first HostComponent/Text. +var node=currentParent;while(true){if(node.tag===HostComponent$1||node.tag===HostText$1){return node;}else if(node.child){node.child['return']=node;node=node.child;continue;}if(node===currentParent){return null;}while(!node.sibling){if(!node['return']||node['return']===currentParent){return null;}node=node['return'];}node.sibling['return']=node['return'];node=node.sibling;}// Flow needs the return null here, but ESLint complains about it. +// eslint-disable-next-line no-unreachable +return null;};var findCurrentHostFiberWithNoPortals=function findCurrentHostFiberWithNoPortals(parent){var currentParent=findCurrentFiberUsingSlowPath(parent);if(!currentParent){return null;}// Next we'll drill down this component to find the first HostComponent/Text. +var node=currentParent;while(true){if(node.tag===HostComponent$1||node.tag===HostText$1){return node;}else if(node.child&&node.tag!==HostPortal){node.child['return']=node;node=node.child;continue;}if(node===currentParent){return null;}while(!node.sibling){if(!node['return']||node['return']===currentParent){return null;}node=node['return'];}node.sibling['return']=node['return'];node=node.sibling;}// Flow needs the return null here, but ESLint complains about it. +// eslint-disable-next-line no-unreachable +return null;};var ReactFiberTreeReflection={isFiberMounted:isFiberMounted,isMounted:isMounted,findCurrentFiberUsingSlowPath:findCurrentFiberUsingSlowPath_1,findCurrentHostFiber:findCurrentHostFiber,findCurrentHostFiberWithNoPortals:findCurrentHostFiberWithNoPortals};var ReactErrorUtils={// Used by Fiber to simulate a try-catch. +_caughtError:null,_hasCaughtError:false,// Used by event system to capture/rethrow the first error. +_rethrowError:null,_hasRethrowError:false,injection:{injectErrorUtils:function injectErrorUtils(injectedErrorUtils){!(typeof injectedErrorUtils.invokeGuardedCallback==='function')?invariant(false,'Injected invokeGuardedCallback() must be a function.'):void 0;_invokeGuardedCallback=injectedErrorUtils.invokeGuardedCallback;}},/** + * Call a function while guarding against errors that happens within it. + * Returns an error if it throws, otherwise null. + * + * In production, this is implemented using a try-catch. The reason we don't + * use a try-catch directly is so that we can swap out a different + * implementation in DEV mode. + * + * @param {String} name of the guard to use for logging or debugging + * @param {Function} func The function to invoke + * @param {*} context The context to use when calling the function + * @param {...*} args Arguments for function + */invokeGuardedCallback:function invokeGuardedCallback(name,func,context,a,b,c,d,e,f){_invokeGuardedCallback.apply(ReactErrorUtils,arguments);},/** + * Same as invokeGuardedCallback, but instead of returning an error, it stores + * it in a global so it can be rethrown by `rethrowCaughtError` later. + * TODO: See if _caughtError and _rethrowError can be unified. + * + * @param {String} name of the guard to use for logging or debugging + * @param {Function} func The function to invoke + * @param {*} context The context to use when calling the function + * @param {...*} args Arguments for function + */invokeGuardedCallbackAndCatchFirstError:function invokeGuardedCallbackAndCatchFirstError(name,func,context,a,b,c,d,e,f){ReactErrorUtils.invokeGuardedCallback.apply(this,arguments);if(ReactErrorUtils.hasCaughtError()){var error=ReactErrorUtils.clearCaughtError();if(!ReactErrorUtils._hasRethrowError){ReactErrorUtils._hasRethrowError=true;ReactErrorUtils._rethrowError=error;}}},/** + * During execution of guarded functions we will capture the first error which + * we will rethrow to be handled by the top level error handler. + */rethrowCaughtError:function rethrowCaughtError(){return _rethrowCaughtError.apply(ReactErrorUtils,arguments);},hasCaughtError:function hasCaughtError(){return ReactErrorUtils._hasCaughtError;},clearCaughtError:function clearCaughtError(){if(ReactErrorUtils._hasCaughtError){var error=ReactErrorUtils._caughtError;ReactErrorUtils._caughtError=null;ReactErrorUtils._hasCaughtError=false;return error;}else{invariant(false,'clearCaughtError was called but no error was captured. This error is likely caused by a bug in React. Please file an issue.');}}};var _invokeGuardedCallback=function _invokeGuardedCallback(name,func,context,a,b,c,d,e,f){ReactErrorUtils._hasCaughtError=false;ReactErrorUtils._caughtError=null;var funcArgs=Array.prototype.slice.call(arguments,3);try{func.apply(context,funcArgs);}catch(error){ReactErrorUtils._caughtError=error;ReactErrorUtils._hasCaughtError=true;}};{// In DEV mode, we swap out invokeGuardedCallback for a special version +// that plays more nicely with the browser's DevTools. The idea is to preserve +// "Pause on exceptions" behavior. Because React wraps all user-provided +// functions in invokeGuardedCallback, and the production version of +// invokeGuardedCallback uses a try-catch, all user exceptions are treated +// like caught exceptions, and the DevTools won't pause unless the developer +// takes the extra step of enabling pause on caught exceptions. This is +// untintuitive, though, because even though React has caught the error, from +// the developer's perspective, the error is uncaught. +// +// To preserve the expected "Pause on exceptions" behavior, we don't use a +// try-catch in DEV. Instead, we synchronously dispatch a fake event to a fake +// DOM node, and call the user-provided callback from inside an event handler +// for that fake event. If the callback throws, the error is "captured" using +// a global event handler. But because the error happens in a different +// event loop context, it does not interrupt the normal program flow. +// Effectively, this gives us try-catch behavior without actually using +// try-catch. Neat! +// Check that the browser supports the APIs we need to implement our special +// DEV version of invokeGuardedCallback +if(typeof window!=='undefined'&&typeof window.dispatchEvent==='function'&&typeof document!=='undefined'&&typeof document.createEvent==='function'){var fakeNode=document.createElement('react');var invokeGuardedCallbackDev=function invokeGuardedCallbackDev(name,func,context,a,b,c,d,e,f){// Keeps track of whether the user-provided callback threw an error. We +// set this to true at the beginning, then set it to false right after +// calling the function. If the function errors, `didError` will never be +// set to false. This strategy works even if the browser is flaky and +// fails to call our global error handler, because it doesn't rely on +// the error event at all. +var didError=true;// Create an event handler for our fake event. We will synchronously +// dispatch our fake event using `dispatchEvent`. Inside the handler, we +// call the user-provided callback. +var funcArgs=Array.prototype.slice.call(arguments,3);function callCallback(){// We immediately remove the callback from event listeners so that +// nested `invokeGuardedCallback` calls do not clash. Otherwise, a +// nested call would trigger the fake event handlers of any call higher +// in the stack. +fakeNode.removeEventListener(evtType,callCallback,false);func.apply(context,funcArgs);didError=false;}// Create a global error event handler. We use this to capture the value +// that was thrown. It's possible that this error handler will fire more +// than once; for example, if non-React code also calls `dispatchEvent` +// and a handler for that event throws. We should be resilient to most of +// those cases. Even if our error event handler fires more than once, the +// last error event is always used. If the callback actually does error, +// we know that the last error event is the correct one, because it's not +// possible for anything else to have happened in between our callback +// erroring and the code that follows the `dispatchEvent` call below. If +// the callback doesn't error, but the error event was fired, we know to +// ignore it because `didError` will be false, as described above. +var error=void 0;// Use this to track whether the error event is ever called. +var didSetError=false;var isCrossOriginError=false;function onError(event){error=event.error;didSetError=true;if(error===null&&event.colno===0&&event.lineno===0){isCrossOriginError=true;}}// Create a fake event type. +var evtType='react-'+(name?name:'invokeguardedcallback');// Attach our event handlers +window.addEventListener('error',onError);fakeNode.addEventListener(evtType,callCallback,false);// Synchronously dispatch our fake event. If the user-provided function +// errors, it will trigger our global error handler. +var evt=document.createEvent('Event');evt.initEvent(evtType,false,false);fakeNode.dispatchEvent(evt);if(didError){if(!didSetError){// The callback errored, but the error event never fired. +error=new Error('An error was thrown inside one of your components, but React '+"doesn't know what it was. This is likely due to browser "+'flakiness. React does its best to preserve the "Pause on '+'exceptions" behavior of the DevTools, which requires some '+"DEV-mode only tricks. It's possible that these don't work in "+'your browser. Try triggering the error in production mode, '+'or switching to a modern browser. If you suspect that this is '+'actually an issue with React, please file an issue.');}else if(isCrossOriginError){error=new Error("A cross-origin error was thrown. React doesn't have access to "+'the actual error object in development. '+'See https://fb.me/react-crossorigin-error for more information.');}ReactErrorUtils._hasCaughtError=true;ReactErrorUtils._caughtError=error;}else{ReactErrorUtils._hasCaughtError=false;ReactErrorUtils._caughtError=null;}// Remove our event listeners +window.removeEventListener('error',onError);};_invokeGuardedCallback=invokeGuardedCallbackDev;}}var _rethrowCaughtError=function _rethrowCaughtError(){if(ReactErrorUtils._hasRethrowError){var error=ReactErrorUtils._rethrowError;ReactErrorUtils._rethrowError=null;ReactErrorUtils._hasRethrowError=false;throw error;}};var ReactErrorUtils_1=ReactErrorUtils;{var warning$2=require$$0;}/** + * Injected dependencies: + *//** + * - `ComponentTree`: [required] Module that can convert between React instances + * and actual node references. + */var ComponentTree;var injection={injectComponentTree:function injectComponentTree(Injected){ComponentTree=Injected;{warning$2(Injected&&Injected.getNodeFromInstance&&Injected.getInstanceFromNode,'EventPluginUtils.injection.injectComponentTree(...): Injected '+'module is missing getNodeFromInstance or getInstanceFromNode.');}}};function isEndish(topLevelType){return topLevelType==='topMouseUp'||topLevelType==='topTouchEnd'||topLevelType==='topTouchCancel';}function isMoveish(topLevelType){return topLevelType==='topMouseMove'||topLevelType==='topTouchMove';}function isStartish(topLevelType){return topLevelType==='topMouseDown'||topLevelType==='topTouchStart';}var validateEventDispatches;{validateEventDispatches=function validateEventDispatches(event){var dispatchListeners=event._dispatchListeners;var dispatchInstances=event._dispatchInstances;var listenersIsArr=Array.isArray(dispatchListeners);var listenersLen=listenersIsArr?dispatchListeners.length:dispatchListeners?1:0;var instancesIsArr=Array.isArray(dispatchInstances);var instancesLen=instancesIsArr?dispatchInstances.length:dispatchInstances?1:0;warning$2(instancesIsArr===listenersIsArr&&instancesLen===listenersLen,'EventPluginUtils: Invalid `event`.');};}/** + * Dispatch the event to the listener. + * @param {SyntheticEvent} event SyntheticEvent to handle + * @param {boolean} simulated If the event is simulated (changes exn behavior) + * @param {function} listener Application-level callback + * @param {*} inst Internal component instance + */function executeDispatch(event,simulated,listener,inst){var type=event.type||'unknown-event';event.currentTarget=EventPluginUtils.getNodeFromInstance(inst);ReactErrorUtils_1.invokeGuardedCallbackAndCatchFirstError(type,listener,undefined,event);event.currentTarget=null;}/** + * Standard/simple iteration through an event's collected dispatches. + */function executeDispatchesInOrder(event,simulated){var dispatchListeners=event._dispatchListeners;var dispatchInstances=event._dispatchInstances;{validateEventDispatches(event);}if(Array.isArray(dispatchListeners)){for(var i=0;i element events #4963 +if(target.correspondingUseElement){target=target.correspondingUseElement;}// Safari may fire events on text nodes (Node.TEXT_NODE is 3). +// @see http://www.quirksmode.org/js/events_properties.html +return target.nodeType===TEXT_NODE$1?target.parentNode:target;}var getEventTarget_1=getEventTarget;var HostRoot=ReactTypeOfWork.HostRoot;var CALLBACK_BOOKKEEPING_POOL_SIZE=10;var callbackBookkeepingPool=[];/** + * Find the deepest React component completely containing the root of the + * passed-in instance (for use when entire React trees are nested within each + * other). If React trees are not nested, returns null. + */function findRootContainerNode(inst){// TODO: It may be a good idea to cache this to prevent unnecessary DOM +// traversal, but caching is difficult to do correctly without using a +// mutation observer to listen for all DOM changes. +if(typeof inst.tag==='number'){while(inst['return']){inst=inst['return'];}if(inst.tag!==HostRoot){// This can happen if we're in a detached tree. +return null;}return inst.stateNode.containerInfo;}else{while(inst._hostParent){inst=inst._hostParent;}var rootNode=ReactDOMComponentTree_1.getNodeFromInstance(inst);return rootNode.parentNode;}}// Used to store ancestor hierarchy in top level callback +function getTopLevelCallbackBookKeeping(topLevelType,nativeEvent,targetInst){if(callbackBookkeepingPool.length){var instance=callbackBookkeepingPool.pop();instance.topLevelType=topLevelType;instance.nativeEvent=nativeEvent;instance.targetInst=targetInst;return instance;}return{topLevelType:topLevelType,nativeEvent:nativeEvent,targetInst:targetInst,ancestors:[]};}function releaseTopLevelCallbackBookKeeping(instance){instance.topLevelType=null;instance.nativeEvent=null;instance.targetInst=null;instance.ancestors.length=0;if(callbackBookkeepingPool.length} An accumulation of items. + */function accumulateInto(current,next){!(next!=null)?invariant(false,'accumulateInto(...): Accumulated items must not be null or undefined.'):void 0;if(current==null){return next;}// Both are not empty. Warning: Never call x.concat(y) when you are not +// certain that x is an Array (x could be a string with concat method). +if(Array.isArray(current)){if(Array.isArray(next)){current.push.apply(current,next);return current;}current.push(next);return current;}if(Array.isArray(next)){// A bit too dangerous to mutate `next`. +return[current].concat(next);}return[current,next];}var accumulateInto_1=accumulateInto;/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + * @providesModule forEachAccumulated + * + *//** + * @param {array} arr an "accumulation" of items which is either an Array or + * a single item. Useful when paired with the `accumulate` module. This is a + * simple utility that allows us to reason about a collection of items, but + * handling the case when there is exactly one item (and we do not need to + * allocate an array). + * @param {function} cb Callback invoked with each element or a collection. + * @param {?} [scope] Scope used as `this` in a callback. + */function forEachAccumulated(arr,cb,scope){if(Array.isArray(arr)){arr.forEach(cb,scope);}else if(arr){cb.call(scope,arr);}}var forEachAccumulated_1=forEachAccumulated;/** + * Internal queue of events that have accumulated their dispatches and are + * waiting to have their dispatches executed. + */var eventQueue=null;/** + * Dispatches an event and releases it back into the pool, unless persistent. + * + * @param {?object} event Synthetic event to be dispatched. + * @param {boolean} simulated If the event is simulated (changes exn behavior) + * @private + */var executeDispatchesAndRelease=function executeDispatchesAndRelease(event,simulated){if(event){EventPluginUtils_1.executeDispatchesInOrder(event,simulated);if(!event.isPersistent()){event.constructor.release(event);}}};var executeDispatchesAndReleaseSimulated=function executeDispatchesAndReleaseSimulated(e){return executeDispatchesAndRelease(e,true);};var executeDispatchesAndReleaseTopLevel=function executeDispatchesAndReleaseTopLevel(e){return executeDispatchesAndRelease(e,false);};function isInteractive(tag){return tag==='button'||tag==='input'||tag==='select'||tag==='textarea';}function shouldPreventMouseEvent(name,type,props){switch(name){case'onClick':case'onClickCapture':case'onDoubleClick':case'onDoubleClickCapture':case'onMouseDown':case'onMouseDownCapture':case'onMouseMove':case'onMouseMoveCapture':case'onMouseUp':case'onMouseUpCapture':return!!(props.disabled&&isInteractive(type));default:return false;}}/** + * This is a unified interface for event plugins to be installed and configured. + * + * Event plugins can implement the following properties: + * + * `extractEvents` {function(string, DOMEventTarget, string, object): *} + * Required. When a top-level event is fired, this method is expected to + * extract synthetic events that will in turn be queued and dispatched. + * + * `eventTypes` {object} + * Optional, plugins that fire events must publish a mapping of registration + * names that are used to register listeners. Values of this mapping must + * be objects that contain `registrationName` or `phasedRegistrationNames`. + * + * `executeDispatch` {function(object, function, string)} + * Optional, allows plugins to override how an event gets dispatched. By + * default, the listener is simply invoked. + * + * Each plugin that is injected into `EventsPluginHub` is immediately operable. + * + * @public + */var EventPluginHub={/** + * Methods for injecting dependencies. + */injection:{/** + * @param {array} InjectedEventPluginOrder + * @public + */injectEventPluginOrder:EventPluginRegistry_1.injectEventPluginOrder,/** + * @param {object} injectedNamesToPlugins Map from names to plugin modules. + */injectEventPluginsByName:EventPluginRegistry_1.injectEventPluginsByName},/** + * @param {object} inst The instance, which is the source of events. + * @param {string} registrationName Name of listener (e.g. `onClick`). + * @return {?function} The stored callback. + */getListener:function getListener(inst,registrationName){var listener;// TODO: shouldPreventMouseEvent is DOM-specific and definitely should not +// live here; needs to be moved to a better place soon +if(typeof inst.tag==='number'){var stateNode=inst.stateNode;if(!stateNode){// Work in progress (ex: onload events in incremental mode). +return null;}var props=EventPluginUtils_1.getFiberCurrentPropsFromNode(stateNode);if(!props){// Work in progress. +return null;}listener=props[registrationName];if(shouldPreventMouseEvent(registrationName,inst.type,props)){return null;}}else{var currentElement=inst._currentElement;if(typeof currentElement==='string'||typeof currentElement==='number'){// Text node, let it bubble through. +return null;}if(!inst._rootNodeID){// If the instance is already unmounted, we have no listeners. +return null;}var _props=currentElement.props;listener=_props[registrationName];if(shouldPreventMouseEvent(registrationName,currentElement.type,_props)){return null;}}!(!listener||typeof listener==='function')?invariant(false,'Expected `%s` listener to be a function, instead got a value of `%s` type.',registrationName,typeof listener==='undefined'?'undefined':_typeof(listener)):void 0;return listener;},/** + * Allows registered plugins an opportunity to extract events from top-level + * native browser events. + * + * @return {*} An accumulation of synthetic events. + * @internal + */extractEvents:function extractEvents(topLevelType,targetInst,nativeEvent,nativeEventTarget){var events;var plugins=EventPluginRegistry_1.plugins;for(var i=0;i|EventPluginHub| | Event | + * | | . | | +-----------+ | Propagators| + * | ReactEvent | . | | |TapEvent | |------------| + * | Emitter | . | |<---+|Plugin | |other plugin| + * | | . | | +-----------+ | utilities | + * | +-----------.--->| | +------------+ + * | | | . +--------------+ + * +-----|------+ . ^ +-----------+ + * | . | |Enter/Leave| + * + . +-------+|Plugin | + * +-------------+ . +-----------+ + * | application | . + * |-------------| . + * | | . + * | | . + * +-------------+ . + * . + * React Core . General Purpose Event Plugin System + */var alreadyListeningTo={};var reactTopListenersCounter=0;/** + * To ensure no conflicts with other potential React instances on the page + */var topListenersIDKey='_reactListenersID'+(''+Math.random()).slice(2);function getListeningForDocument(mountAt){// In IE8, `mountAt` is a host object and doesn't have `hasOwnProperty` +// directly. +if(!Object.prototype.hasOwnProperty.call(mountAt,topListenersIDKey)){mountAt[topListenersIDKey]=reactTopListenersCounter++;alreadyListeningTo[mountAt[topListenersIDKey]]={};}return alreadyListeningTo[mountAt[topListenersIDKey]];}var ReactBrowserEventEmitter=_assign({},ReactEventEmitterMixin_1,{/** + * Sets whether or not any created callbacks should be enabled. + * + * @param {boolean} enabled True if callbacks should be enabled. + */setEnabled:function setEnabled(enabled){if(ReactDOMEventListener_1){ReactDOMEventListener_1.setEnabled(enabled);}},/** + * @return {boolean} True if callbacks are enabled. + */isEnabled:function isEnabled(){return!!(ReactDOMEventListener_1&&ReactDOMEventListener_1.isEnabled());},/** + * We listen for bubbled touch events on the document object. + * + * Firefox v8.01 (and possibly others) exhibited strange behavior when + * mounting `onmousemove` events at some node that was not the document + * element. The symptoms were that if your mouse is not moving over something + * contained within that mount point (for example on the background) the + * top-level listeners for `onmousemove` won't be called. However, if you + * register the `mousemove` on the document object, then it will of course + * catch all `mousemove`s. This along with iOS quirks, justifies restricting + * top-level listeners to the document object only, at least for these + * movement types of events and possibly all events. + * + * @see http://www.quirksmode.org/blog/archives/2010/09/click_event_del.html + * + * Also, `keyup`/`keypress`/`keydown` do not bubble to the window on IE, but + * they bubble to document. + * + * @param {string} registrationName Name of listener (e.g. `onClick`). + * @param {object} contentDocumentHandle Document which owns the container + */listenTo:function listenTo(registrationName,contentDocumentHandle){var mountAt=contentDocumentHandle;var isListening=getListeningForDocument(mountAt);var dependencies=EventPluginRegistry_1.registrationNameDependencies[registrationName];for(var i=0;i-1){warnHyphenatedStyleName(name,owner);}else if(badVendoredStyleNamePattern.test(name)){warnBadVendoredStyleName(name,owner);}else if(badStyleValueWithSemicolonPattern.test(value)){warnStyleValueWithSemicolon(name,value,owner);}if(typeof value==='number'){if(isNaN(value)){warnStyleValueIsNaN(name,value,owner);}else if(!isFinite(value)){warnStyleValueIsInfinity(name,value,owner);}}};}var warnValidStyle_1=warnValidStyle$1;{var hyphenateStyleName$1=hyphenateStyleName;var warnValidStyle=warnValidStyle_1;}var hasShorthandPropertyBug=false;if(ExecutionEnvironment.canUseDOM){var tempStyle=document.createElement('div').style;try{// IE8 throws "Invalid argument." if resetting shorthand style properties. +tempStyle.font='';}catch(e){hasShorthandPropertyBug=true;}}/** + * Operations for dealing with CSS properties. + */var CSSPropertyOperations={/** + * This creates a string that is expected to be equivalent to the style + * attribute generated by server-side rendering. It by-passes warnings and + * security checks so it's not safe to use this value for anything other than + * comparison. It is only used in DEV for SSR validation. + */createDangerousStringForStyles:function createDangerousStringForStyles(styles){{var serialized='';var delimiter='';for(var styleName in styles){if(!styles.hasOwnProperty(styleName)){continue;}var styleValue=styles[styleName];if(styleValue!=null){var isCustomProperty=styleName.indexOf('--')===0;serialized+=delimiter+hyphenateStyleName$1(styleName)+':';serialized+=dangerousStyleValue_1(styleName,styleValue,isCustomProperty);delimiter=';';}}return serialized||null;}},/** + * Sets the value for multiple styles on a node. If a value is specified as + * '' (empty string), the corresponding style property will be unset. + * + * @param {DOMElement} node + * @param {object} styles + * @param {ReactDOMComponent} component + */setValueForStyles:function setValueForStyles(node,styles,component){var style=node.style;for(var styleName in styles){if(!styles.hasOwnProperty(styleName)){continue;}var isCustomProperty=styleName.indexOf('--')===0;{if(!isCustomProperty){warnValidStyle(styleName,styles[styleName],component);}}var styleValue=dangerousStyleValue_1(styleName,styles[styleName],isCustomProperty);if(styleName==='float'){styleName='cssFloat';}if(isCustomProperty){style.setProperty(styleName,styleValue);}else if(styleValue){style[styleName]=styleValue;}else{var expansion=hasShorthandPropertyBug&&CSSProperty_1.shorthandPropertyExpansions[styleName];if(expansion){// Shorthand property that IE8 won't like unsetting, so unset each +// component to placate it +for(var individualStyleName in expansion){style[individualStyleName]='';}}else{style[styleName]='';}}}}};var CSSPropertyOperations_1=CSSPropertyOperations;var ReactInvalidSetStateWarningHook={};{var warning$7=require$$0;var processingChildContext=false;var warnInvalidSetState=function warnInvalidSetState(){warning$7(!processingChildContext,'setState(...): Cannot call setState() inside getChildContext()');};ReactInvalidSetStateWarningHook={onBeginProcessingChildContext:function onBeginProcessingChildContext(){processingChildContext=true;},onEndProcessingChildContext:function onEndProcessingChildContext(){processingChildContext=false;},onSetState:function onSetState(){warnInvalidSetState();}};}var ReactInvalidSetStateWarningHook_1=ReactInvalidSetStateWarningHook;/** + * Copyright (c) 2016-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + * + * @providesModule ReactHostOperationHistoryHook + * + */// Trust the developer to only use this with a true check +var ReactHostOperationHistoryHook=null;{var history=[];ReactHostOperationHistoryHook={onHostOperation:function onHostOperation(operation){history.push(operation);},clearHistory:function clearHistory(){if(ReactHostOperationHistoryHook._preventClearing){// Should only be used for tests. +return;}history=[];},getHistory:function getHistory(){return history;}};}var ReactHostOperationHistoryHook_1=ReactHostOperationHistoryHook;var ReactComponentTreeHook=ReactGlobalSharedState_1.ReactComponentTreeHook;{var warning$6=require$$0;}// Trust the developer to only use this with a true check +var ReactDebugTool$1=null;{var hooks=[];var didHookThrowForEvent={};var callHook=function callHook(event,fn,context,arg1,arg2,arg3,arg4,arg5){try{fn.call(context,arg1,arg2,arg3,arg4,arg5);}catch(e){warning$6(didHookThrowForEvent[event],'Exception thrown by hook while handling %s: %s',event,e+'\n'+e.stack);didHookThrowForEvent[event]=true;}};var emitEvent=function emitEvent(event,arg1,arg2,arg3,arg4,arg5){for(var i=0;i1&&arguments[1]!==undefined?arguments[1]:false;if(allowRoot&&debugID===0){return;}if(!debugID){warning$6(false,'ReactDebugTool: debugID may not be empty.');}};var beginLifeCycleTimer=function beginLifeCycleTimer(debugID,timerType){if(currentFlushNesting===0){return;}if(currentTimerType&&!lifeCycleTimerHasWarned){warning$6(false,'There is an internal error in the React performance measurement code.'+'\n\nDid not expect %s timer to start while %s timer is still in '+'progress for %s instance.',timerType,currentTimerType||'no',debugID===currentTimerDebugID?'the same':'another');lifeCycleTimerHasWarned=true;}currentTimerStartTime=performanceNow();currentTimerNestedFlushDuration=0;currentTimerDebugID=debugID;currentTimerType=timerType;};var endLifeCycleTimer=function endLifeCycleTimer(debugID,timerType){if(currentFlushNesting===0){return;}if(currentTimerType!==timerType&&!lifeCycleTimerHasWarned){warning$6(false,'There is an internal error in the React performance measurement code. '+'We did not expect %s timer to stop while %s timer is still in '+'progress for %s instance. Please report this as a bug in React.',timerType,currentTimerType||'no',debugID===currentTimerDebugID?'the same':'another');lifeCycleTimerHasWarned=true;}if(_isProfiling){currentFlushMeasurements.push({timerType:timerType,instanceID:debugID,duration:performanceNow()-currentTimerStartTime-currentTimerNestedFlushDuration});}currentTimerStartTime=0;currentTimerNestedFlushDuration=0;currentTimerDebugID=null;currentTimerType=null;};var pauseCurrentLifeCycleTimer=function pauseCurrentLifeCycleTimer(){var currentTimer={startTime:currentTimerStartTime,nestedFlushStartTime:performanceNow(),debugID:currentTimerDebugID,timerType:currentTimerType};lifeCycleTimerStack.push(currentTimer);currentTimerStartTime=0;currentTimerNestedFlushDuration=0;currentTimerDebugID=null;currentTimerType=null;};var resumeCurrentLifeCycleTimer=function resumeCurrentLifeCycleTimer(){var _lifeCycleTimerStack$=lifeCycleTimerStack.pop(),startTime=_lifeCycleTimerStack$.startTime,nestedFlushStartTime=_lifeCycleTimerStack$.nestedFlushStartTime,debugID=_lifeCycleTimerStack$.debugID,timerType=_lifeCycleTimerStack$.timerType;var nestedFlushDuration=performanceNow()-nestedFlushStartTime;currentTimerStartTime=startTime;currentTimerNestedFlushDuration+=nestedFlushDuration;currentTimerDebugID=debugID;currentTimerType=timerType;};var lastMarkTimeStamp=0;var canUsePerformanceMeasure=typeof performance!=='undefined'&&typeof performance.mark==='function'&&typeof performance.clearMarks==='function'&&typeof performance.measure==='function'&&typeof performance.clearMeasures==='function';var shouldMark=function shouldMark(debugID){if(!_isProfiling||!canUsePerformanceMeasure){return false;}var element=ReactComponentTreeHook.getElement(debugID);if(element==null||(typeof element==='undefined'?'undefined':_typeof(element))!=='object'){return false;}var isHostElement=typeof element.type==='string';if(isHostElement){return false;}return true;};var markBegin=function markBegin(debugID,markType){if(!shouldMark(debugID)){return;}var markName=debugID+'::'+markType;lastMarkTimeStamp=performanceNow();performance.mark(markName);};var markEnd=function markEnd(debugID,markType){if(!shouldMark(debugID)){return;}var markName=debugID+'::'+markType;var displayName=ReactComponentTreeHook.getDisplayName(debugID)||'Unknown';// Chrome has an issue of dropping markers recorded too fast: +// https://bugs.chromium.org/p/chromium/issues/detail?id=640652 +// To work around this, we will not report very small measurements. +// I determined the magic number by tweaking it back and forth. +// 0.05ms was enough to prevent the issue, but I set it to 0.1ms to be safe. +// When the bug is fixed, we can `measure()` unconditionally if we want to. +var timeStamp=performanceNow();if(timeStamp-lastMarkTimeStamp>0.1){var measurementName=displayName+' ['+markType+']';performance.measure(measurementName,markName);}performance.clearMarks(markName);if(measurementName){performance.clearMeasures(measurementName);}};ReactDebugTool$1={addHook:function addHook(hook){hooks.push(hook);},removeHook:function removeHook(hook){for(var i=0;i host component that allows setting these optional + * props: `checked`, `value`, `defaultChecked`, and `defaultValue`. + * + * If `checked` or `value` are not supplied (or null/undefined), user actions + * that affect the checked state or value will trigger updates to the element. + * + * If they are supplied (and not null/undefined), the rendered element will not + * trigger updates to the element. Instead, the props must change in order for + * the rendered element to be updated. + * + * The rendered element will be initialized as unchecked (or `defaultChecked`) + * with an empty value (or `defaultValue`). + * + * See http://www.w3.org/TR/2012/WD-html5-20121025/the-input-element.html + */var ReactDOMInput={getHostProps:function getHostProps(element,props){var node=element;var value=props.value;var checked=props.checked;var hostProps=_assign({// Make sure we set .type before any other properties (setting .value +// before .type means .value is lost in IE11 and below) +type:undefined,// Make sure we set .step before .value (setting .value before .step +// means .value is rounded on mount, based upon step precision) +step:undefined,// Make sure we set .min & .max before .value (to ensure proper order +// in corner cases such as min or max deriving from value, e.g. Issue #7170) +min:undefined,max:undefined},props,{defaultChecked:undefined,defaultValue:undefined,value:value!=null?value:node._wrapperState.initialValue,checked:checked!=null?checked:node._wrapperState.initialChecked});return hostProps;},initWrapperState:function initWrapperState(element,props){{ReactControlledValuePropTypes_1.checkPropTypes('input',props,getCurrentFiberStackAddendum$2);if(props.checked!==undefined&&props.defaultChecked!==undefined&&!didWarnCheckedDefaultChecked){warning$8(false,'%s contains an input of type %s with both checked and defaultChecked props. '+'Input elements must be either controlled or uncontrolled '+'(specify either the checked prop, or the defaultChecked prop, but not '+'both). Decide between using a controlled or uncontrolled input '+'element and remove one of these props. More info: '+'https://fb.me/react-controlled-components',getCurrentFiberOwnerName$3()||'A component',props.type);didWarnCheckedDefaultChecked=true;}if(props.value!==undefined&&props.defaultValue!==undefined&&!didWarnValueDefaultValue){warning$8(false,'%s contains an input of type %s with both value and defaultValue props. '+'Input elements must be either controlled or uncontrolled '+'(specify either the value prop, or the defaultValue prop, but not '+'both). Decide between using a controlled or uncontrolled input '+'element and remove one of these props. More info: '+'https://fb.me/react-controlled-components',getCurrentFiberOwnerName$3()||'A component',props.type);didWarnValueDefaultValue=true;}}var defaultValue=props.defaultValue;var node=element;node._wrapperState={initialChecked:props.checked!=null?props.checked:props.defaultChecked,initialValue:props.value!=null?props.value:defaultValue,controlled:isControlled(props)};},updateWrapper:function updateWrapper(element,props){var node=element;{var controlled=isControlled(props);if(!node._wrapperState.controlled&&controlled&&!didWarnUncontrolledToControlled){warning$8(false,'A component is changing an uncontrolled input of type %s to be controlled. '+'Input elements should not switch from uncontrolled to controlled (or vice versa). '+'Decide between using a controlled or uncontrolled input '+'element for the lifetime of the component. More info: https://fb.me/react-controlled-components%s',props.type,getCurrentFiberStackAddendum$2());didWarnUncontrolledToControlled=true;}if(node._wrapperState.controlled&&!controlled&&!didWarnControlledToUncontrolled){warning$8(false,'A component is changing a controlled input of type %s to be uncontrolled. '+'Input elements should not switch from controlled to uncontrolled (or vice versa). '+'Decide between using a controlled or uncontrolled input '+'element for the lifetime of the component. More info: https://fb.me/react-controlled-components%s',props.type,getCurrentFiberStackAddendum$2());didWarnControlledToUncontrolled=true;}}var checked=props.checked;if(checked!=null){DOMPropertyOperations_1.setValueForProperty(node,'checked',checked||false);}var value=props.value;if(value!=null){if(value===0&&node.value===''){node.value='0';// Note: IE9 reports a number inputs as 'text', so check props instead. +}else if(props.type==='number'){// Simulate `input.valueAsNumber`. IE9 does not support it +var valueAsNumber=parseFloat(node.value)||0;if(// eslint-disable-next-line +value!=valueAsNumber||// eslint-disable-next-line +value==valueAsNumber&&node.value!=value){// Cast `value` to a string to ensure the value is set correctly. While +// browsers typically do this as necessary, jsdom doesn't. +node.value=''+value;}}else if(node.value!==''+value){// Cast `value` to a string to ensure the value is set correctly. While +// browsers typically do this as necessary, jsdom doesn't. +node.value=''+value;}}else{if(props.value==null&&props.defaultValue!=null){// In Chrome, assigning defaultValue to certain input types triggers input validation. +// For number inputs, the display value loses trailing decimal points. For email inputs, +// Chrome raises "The specified value is not a valid email address". +// +// Here we check to see if the defaultValue has actually changed, avoiding these problems +// when the user is inputting text +// +// https://github.com/facebook/react/issues/7253 +if(node.defaultValue!==''+props.defaultValue){node.defaultValue=''+props.defaultValue;}}if(props.checked==null&&props.defaultChecked!=null){node.defaultChecked=!!props.defaultChecked;}}},postMountWrapper:function postMountWrapper(element,props){var node=element;// Detach value from defaultValue. We won't do anything if we're working on +// submit or reset inputs as those values & defaultValues are linked. They +// are not resetable nodes so this operation doesn't matter and actually +// removes browser-default values (eg "Submit Query") when no value is +// provided. +switch(props.type){case'submit':case'reset':break;case'color':case'date':case'datetime':case'datetime-local':case'month':case'time':case'week':// This fixes the no-show issue on iOS Safari and Android Chrome: +// https://github.com/facebook/react/issues/7233 +node.value='';node.value=node.defaultValue;break;default:node.value=node.value;break;}// Normally, we'd just do `node.checked = node.checked` upon initial mount, less this bug +// this is needed to work around a chrome bug where setting defaultChecked +// will sometimes influence the value of checked (even after detachment). +// Reference: https://bugs.chromium.org/p/chromium/issues/detail?id=608416 +// We need to temporarily unset name to avoid disrupting radio button groups. +var name=node.name;if(name!==''){node.name='';}node.defaultChecked=!node.defaultChecked;node.defaultChecked=!node.defaultChecked;if(name!==''){node.name=name;}},restoreControlledState:function restoreControlledState(element,props){var node=element;ReactDOMInput.updateWrapper(node,props);updateNamedCousins(node,props);}};function updateNamedCousins(rootNode,props){var name=props.name;if(props.type==='radio'&&name!=null){var queryRoot=rootNode;while(queryRoot.parentNode){queryRoot=queryRoot.parentNode;}// If `rootNode.form` was non-null, then we could try `form.elements`, +// but that sometimes behaves strangely in IE8. We could also try using +// `form.getElementsByName`, but that will only return direct children +// and won't include inputs that use the HTML5 `form=` attribute. Since +// the input might not even be in a form. It might not even be in the +// document. Let's just use the local `querySelectorAll` to ensure we don't +// miss anything. +var group=queryRoot.querySelectorAll('input[name='+JSON.stringify(''+name)+'][type="radio"]');for(var i=0;i host component that warns when `selected` is set. + */var ReactDOMOption={validateProps:function validateProps(element,props){// TODO (yungsters): Remove support for `selected` in