enmi-conf.org: comparison wp/wp-includes/js/dist/vendor/react.js

Mercurial Mercurial > enmi-conf.org / comparison

summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help

wp/wp-includes/js/dist/vendor/react.js

changeset 9	177826044cd9
child 16	a86126ab1dd4

equal deleted inserted replaced

-:c7c34916027a
+:177826044cd9
+/** @license React v16.8.4
+* react.development.js
+*
+* Copyright (c) Facebook, Inc. and its affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+'use strict';
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+	typeof define === 'function' && define.amd ? define(factory) :
+	(global.React = factory());
+}(this, (function () { 'use strict';
+// TODO: this is special because it gets imported during build.
+var ReactVersion = '16.8.4';
+// The Symbol used to tag the ReactElement-like types. If there is no native Symbol
+// nor polyfill, then a plain number is used for performance.
+var hasSymbol = typeof Symbol === 'function' && Symbol.for;
+var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7;
+var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for('react.portal') : 0xeaca;
+var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for('react.fragment') : 0xeacb;
+var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for('react.strict_mode') : 0xeacc;
+var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2;
+var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for('react.provider') : 0xeacd;
+var REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for('react.context') : 0xeace;
+var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for('react.concurrent_mode') : 0xeacf;
+var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0;
+var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for('react.suspense') : 0xead1;
+var REACT_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3;
+var REACT_LAZY_TYPE = hasSymbol ? Symbol.for('react.lazy') : 0xead4;
+var MAYBE_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
+var FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+if (maybeIterable === null || typeof maybeIterable !== 'object') {
+return null;
+}
+var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+if (typeof maybeIterator === 'function') {
+return maybeIterator;
+}
+return null;
+}
+/*
+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;
+	}
+}
+var objectAssign = 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;
+};
+/**
+* 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 = function (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 = void 0;
+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;
+}
+}
+// Relying on the `invariant()` implementation lets us
+// preserve the format and params in the www builds.
+/**
+* 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 () {};
+{
+var printWarning = function (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 (condition, format) {
+if (format === undefined) {
+throw new Error('`lowPriorityWarning(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;
+/**
+* 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 warningWithoutStack = function () {};
+{
+warningWithoutStack = function (condition, format) {
+for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+args[_key - 2] = arguments[_key];
+}
+if (format === undefined) {
+throw new Error('`warningWithoutStack(condition, format, ...args)` requires a warning ' + 'message argument');
+}
+if (args.length > 8) {
+// Check before the condition to catch violations early.
+throw new Error('warningWithoutStack() currently supports at most 8 arguments.');
+}
+if (condition) {
+return;
+}
+if (typeof console !== 'undefined') {
+var argsWithFormat = args.map(function (item) {
+return '' + item;
+});
+argsWithFormat.unshift('Warning: ' + format);
+// We intentionally don't use spread (or .apply) directly because it
+// breaks IE9: https://github.com/facebook/react/issues/13610
+Function.prototype.apply.call(console.error, console, argsWithFormat);
+}
+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.
+var argIndex = 0;
+var message = 'Warning: ' + format.replace(/%s/g, function () {
+return args[argIndex++];
+});
+throw new Error(message);
+} catch (x) {}
+};
+}
+var warningWithoutStack$1 = warningWithoutStack;
+var didWarnStateUpdateForUnmountedComponent = {};
+function warnNoop(publicInstance, callerName) {
+{
+var _constructor = publicInstance.constructor;
+var componentName = _constructor && (_constructor.displayName || _constructor.name) || 'ReactClass';
+var warningKey = componentName + '.' + callerName;
+if (didWarnStateUpdateForUnmountedComponent[warningKey]) {
+return;
+}
+warningWithoutStack$1(false, "Can't call %s on a component that is not yet mounted. " + 'This is a no-op, but it might indicate a bug in your application. ' + 'Instead, assign to `this.state` directly or define a `state = {};` ' + 'class property with the desired state in the %s component.', callerName, componentName);
+didWarnStateUpdateForUnmountedComponent[warningKey] = true;
+}
+}
+/**
+* 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 (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 (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 (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 (publicInstance, partialState, callback, callerName) {
+warnNoop(publicInstance, 'setState');
+}
+};
+var emptyObject = {};
+{
+Object.freeze(emptyObject);
+}
+/**
+* Base class helpers for the updating state of a component.
+*/
+function Component(props, context, updater) {
+this.props = props;
+this.context = context;
+// If a component has string refs, we will assign a different object later.
+this.refs = emptyObject;
+// We initialize the default updater but the real one gets injected by the
+// renderer.
+this.updater = updater || ReactNoopUpdateQueue;
+}
+Component.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
+*/
+Component.prototype.setState = function (partialState, callback) {
+!(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
+*/
+Component.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 (methodName, info) {
+Object.defineProperty(Component.prototype, methodName, {
+get: function () {
+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]);
+}
+}
+}
+function ComponentDummy() {}
+ComponentDummy.prototype = Component.prototype;
+/**
+* Convenience component with default shallow equality check for sCU.
+*/
+function PureComponent(props, context, updater) {
+this.props = props;
+this.context = context;
+// If a component has string refs, we will assign a different object later.
+this.refs = emptyObject;
+this.updater = updater || ReactNoopUpdateQueue;
+}
+var pureComponentPrototype = PureComponent.prototype = new ComponentDummy();
+pureComponentPrototype.constructor = PureComponent;
+// Avoid an extra prototype jump for these methods.
+objectAssign(pureComponentPrototype, Component.prototype);
+pureComponentPrototype.isPureReactComponent = true;
+// an immutable object with a single mutable value
+function createRef() {
+var refObject = {
+current: null
+};
+{
+Object.seal(refObject);
+}
+return refObject;
+}
+var enableSchedulerDebugging = false;
+/* eslint-disable no-var */
+// TODO: Use symbols?
+var ImmediatePriority = 1;
+var UserBlockingPriority = 2;
+var NormalPriority = 3;
+var LowPriority = 4;
+var IdlePriority = 5;
+// Max 31 bit integer. The max integer size in V8 for 32-bit systems.
+// Math.pow(2, 30) - 1
+// 0b111111111111111111111111111111
+var maxSigned31BitInt = 1073741823;
+// Times out immediately
+var IMMEDIATE_PRIORITY_TIMEOUT = -1;
+// Eventually times out
+var USER_BLOCKING_PRIORITY = 250;
+var NORMAL_PRIORITY_TIMEOUT = 5000;
+var LOW_PRIORITY_TIMEOUT = 10000;
+// Never times out
+var IDLE_PRIORITY = maxSigned31BitInt;
+// Callbacks are stored as a circular, doubly linked list.
+var firstCallbackNode = null;
+var currentDidTimeout = false;
+// Pausing the scheduler is useful for debugging.
+var isSchedulerPaused = false;
+var currentPriorityLevel = NormalPriority;
+var currentEventStartTime = -1;
+var currentExpirationTime = -1;
+// This is set when a callback is being executed, to prevent re-entrancy.
+var isExecutingCallback = false;
+var isHostCallbackScheduled = false;
+var hasNativePerformanceNow = typeof performance === 'object' && typeof performance.now === 'function';
+function ensureHostCallbackIsScheduled() {
+if (isExecutingCallback) {
+// Don't schedule work yet; wait until the next time we yield.
+return;
+}
+// Schedule the host callback using the earliest expiration in the list.
+var expirationTime = firstCallbackNode.expirationTime;
+if (!isHostCallbackScheduled) {
+isHostCallbackScheduled = true;
+} else {
+// Cancel the existing host callback.
+cancelHostCallback();
+}
+requestHostCallback(flushWork, expirationTime);
+}
+function flushFirstCallback() {
+var flushedNode = firstCallbackNode;
+// Remove the node from the list before calling the callback. That way the
+// list is in a consistent state even if the callback throws.
+var next = firstCallbackNode.next;
+if (firstCallbackNode === next) {
+// This is the last callback in the list.
+firstCallbackNode = null;
+next = null;
+} else {
+var lastCallbackNode = firstCallbackNode.previous;
+firstCallbackNode = lastCallbackNode.next = next;
+next.previous = lastCallbackNode;
+}
+flushedNode.next = flushedNode.previous = null;
+// Now it's safe to call the callback.
+var callback = flushedNode.callback;
+var expirationTime = flushedNode.expirationTime;
+var priorityLevel = flushedNode.priorityLevel;
+var previousPriorityLevel = currentPriorityLevel;
+var previousExpirationTime = currentExpirationTime;
+currentPriorityLevel = priorityLevel;
+currentExpirationTime = expirationTime;
+var continuationCallback;
+try {
+continuationCallback = callback();
+} finally {
+currentPriorityLevel = previousPriorityLevel;
+currentExpirationTime = previousExpirationTime;
+}
+// A callback may return a continuation. The continuation should be scheduled
+// with the same priority and expiration as the just-finished callback.
+if (typeof continuationCallback === 'function') {
+var continuationNode = {
+callback: continuationCallback,
+priorityLevel: priorityLevel,
+expirationTime: expirationTime,
+next: null,
+previous: null
+};
+// Insert the new callback into the list, sorted by its expiration. This is
+// almost the same as the code in `scheduleCallback`, except the callback
+// is inserted into the list *before* callbacks of equal expiration instead
+// of after.
+if (firstCallbackNode === null) {
+// This is the first callback in the list.
+firstCallbackNode = continuationNode.next = continuationNode.previous = continuationNode;
+} else {
+var nextAfterContinuation = null;
+var node = firstCallbackNode;
+do {
+if (node.expirationTime >= expirationTime) {
+// This callback expires at or after the continuation. We will insert
+// the continuation *before* this callback.
+nextAfterContinuation = node;
+break;
+}
+node = node.next;
+} while (node !== firstCallbackNode);
+if (nextAfterContinuation === null) {
+// No equal or lower priority callback was found, which means the new
+// callback is the lowest priority callback in the list.
+nextAfterContinuation = firstCallbackNode;
+} else if (nextAfterContinuation === firstCallbackNode) {
+// The new callback is the highest priority callback in the list.
+firstCallbackNode = continuationNode;
+ensureHostCallbackIsScheduled();
+}
+var previous = nextAfterContinuation.previous;
+previous.next = nextAfterContinuation.previous = continuationNode;
+continuationNode.next = nextAfterContinuation;
+continuationNode.previous = previous;
+}
+}
+}
+function flushImmediateWork() {
+if (
+// Confirm we've exited the outer most event handler
+currentEventStartTime === -1 && firstCallbackNode !== null && firstCallbackNode.priorityLevel === ImmediatePriority) {
+isExecutingCallback = true;
+try {
+do {
+flushFirstCallback();
+} while (
+// Keep flushing until there are no more immediate callbacks
+firstCallbackNode !== null && firstCallbackNode.priorityLevel === ImmediatePriority);
+} finally {
+isExecutingCallback = false;
+if (firstCallbackNode !== null) {
+// There's still work remaining. Request another callback.
+ensureHostCallbackIsScheduled();
+} else {
+isHostCallbackScheduled = false;
+}
+}
+}
+}
+function flushWork(didTimeout) {
+// Exit right away if we're currently paused
+if (enableSchedulerDebugging && isSchedulerPaused) {
+return;
+}
+isExecutingCallback = true;
+var previousDidTimeout = currentDidTimeout;
+currentDidTimeout = didTimeout;
+try {
+if (didTimeout) {
+// Flush all the expired callbacks without yielding.
+while (firstCallbackNode !== null && !(enableSchedulerDebugging && isSchedulerPaused)) {
+// TODO Wrap in feature flag
+// Read the current time. Flush all the callbacks that expire at or
+// earlier than that time. Then read the current time again and repeat.
+// This optimizes for as few performance.now calls as possible.
+var currentTime = getCurrentTime();
+if (firstCallbackNode.expirationTime <= currentTime) {
+do {
+flushFirstCallback();
+} while (firstCallbackNode !== null && firstCallbackNode.expirationTime <= currentTime && !(enableSchedulerDebugging && isSchedulerPaused));
+continue;
+}
+break;
+}
+} else {
+// Keep flushing callbacks until we run out of time in the frame.
+if (firstCallbackNode !== null) {
+do {
+if (enableSchedulerDebugging && isSchedulerPaused) {
+break;
+}
+flushFirstCallback();
+} while (firstCallbackNode !== null && !shouldYieldToHost());
+}
+}
+} finally {
+isExecutingCallback = false;
+currentDidTimeout = previousDidTimeout;
+if (firstCallbackNode !== null) {
+// There's still work remaining. Request another callback.
+ensureHostCallbackIsScheduled();
+} else {
+isHostCallbackScheduled = false;
+}
+// Before exiting, flush all the immediate work that was scheduled.
+flushImmediateWork();
+}
+}
+function unstable_runWithPriority(priorityLevel, eventHandler) {
+switch (priorityLevel) {
+case ImmediatePriority:
+case UserBlockingPriority:
+case NormalPriority:
+case LowPriority:
+case IdlePriority:
+break;
+default:
+priorityLevel = NormalPriority;
+}
+var previousPriorityLevel = currentPriorityLevel;
+var previousEventStartTime = currentEventStartTime;
+currentPriorityLevel = priorityLevel;
+currentEventStartTime = getCurrentTime();
+try {
+return eventHandler();
+} finally {
+currentPriorityLevel = previousPriorityLevel;
+currentEventStartTime = previousEventStartTime;
+// Before exiting, flush all the immediate work that was scheduled.
+flushImmediateWork();
+}
+}
+function unstable_next(eventHandler) {
+var priorityLevel = void 0;
+switch (currentPriorityLevel) {
+case ImmediatePriority:
+case UserBlockingPriority:
+case NormalPriority:
+// Shift down to normal priority
+priorityLevel = NormalPriority;
+break;
+default:
+// Anything lower than normal priority should remain at the current level.
+priorityLevel = currentPriorityLevel;
+break;
+}
+var previousPriorityLevel = currentPriorityLevel;
+var previousEventStartTime = currentEventStartTime;
+currentPriorityLevel = priorityLevel;
+currentEventStartTime = getCurrentTime();
+try {
+return eventHandler();
+} finally {
+currentPriorityLevel = previousPriorityLevel;
+currentEventStartTime = previousEventStartTime;
+// Before exiting, flush all the immediate work that was scheduled.
+flushImmediateWork();
+}
+}
+function unstable_wrapCallback(callback) {
+var parentPriorityLevel = currentPriorityLevel;
+return function () {
+// This is a fork of runWithPriority, inlined for performance.
+var previousPriorityLevel = currentPriorityLevel;
+var previousEventStartTime = currentEventStartTime;
+currentPriorityLevel = parentPriorityLevel;
+currentEventStartTime = getCurrentTime();
+try {
+return callback.apply(this, arguments);
+} finally {
+currentPriorityLevel = previousPriorityLevel;
+currentEventStartTime = previousEventStartTime;
+flushImmediateWork();
+}
+};
+}
+function unstable_scheduleCallback(callback, deprecated_options) {
+var startTime = currentEventStartTime !== -1 ? currentEventStartTime : getCurrentTime();
+var expirationTime;
+if (typeof deprecated_options === 'object' && deprecated_options !== null && typeof deprecated_options.timeout === 'number') {
+// FIXME: Remove this branch once we lift expiration times out of React.
+expirationTime = startTime + deprecated_options.timeout;
+} else {
+switch (currentPriorityLevel) {
+case ImmediatePriority:
+expirationTime = startTime + IMMEDIATE_PRIORITY_TIMEOUT;
+break;
+case UserBlockingPriority:
+expirationTime = startTime + USER_BLOCKING_PRIORITY;
+break;
+case IdlePriority:
+expirationTime = startTime + IDLE_PRIORITY;
+break;
+case LowPriority:
+expirationTime = startTime + LOW_PRIORITY_TIMEOUT;
+break;
+case NormalPriority:
+default:
+expirationTime = startTime + NORMAL_PRIORITY_TIMEOUT;
+}
+}
+var newNode = {
+callback: callback,
+priorityLevel: currentPriorityLevel,
+expirationTime: expirationTime,
+next: null,
+previous: null
+};
+// Insert the new callback into the list, ordered first by expiration, then
+// by insertion. So the new callback is inserted any other callback with
+// equal expiration.
+if (firstCallbackNode === null) {
+// This is the first callback in the list.
+firstCallbackNode = newNode.next = newNode.previous = newNode;
+ensureHostCallbackIsScheduled();
+} else {
+var next = null;
+var node = firstCallbackNode;
+do {
+if (node.expirationTime > expirationTime) {
+// The new callback expires before this one.
+next = node;
+break;
+}
+node = node.next;
+} while (node !== firstCallbackNode);
+if (next === null) {
+// No callback with a later expiration was found, which means the new
+// callback has the latest expiration in the list.
+next = firstCallbackNode;
+} else if (next === firstCallbackNode) {
+// The new callback has the earliest expiration in the entire list.
+firstCallbackNode = newNode;
+ensureHostCallbackIsScheduled();
+}
+var previous = next.previous;
+previous.next = next.previous = newNode;
+newNode.next = next;
+newNode.previous = previous;
+}
+return newNode;
+}
+function unstable_pauseExecution() {
+isSchedulerPaused = true;
+}
+function unstable_continueExecution() {
+isSchedulerPaused = false;
+if (firstCallbackNode !== null) {
+ensureHostCallbackIsScheduled();
+}
+}
+function unstable_getFirstCallbackNode() {
+return firstCallbackNode;
+}
+function unstable_cancelCallback(callbackNode) {
+var next = callbackNode.next;
+if (next === null) {
+// Already cancelled.
+return;
+}
+if (next === callbackNode) {
+// This is the only scheduled callback. Clear the list.
+firstCallbackNode = null;
+} else {
+// Remove the callback from its position in the list.
+if (callbackNode === firstCallbackNode) {
+firstCallbackNode = next;
+}
+var previous = callbackNode.previous;
+previous.next = next;
+next.previous = previous;
+}
+callbackNode.next = callbackNode.previous = null;
+}
+function unstable_getCurrentPriorityLevel() {
+return currentPriorityLevel;
+}
+function unstable_shouldYield() {
+return !currentDidTimeout && (firstCallbackNode !== null && firstCallbackNode.expirationTime < currentExpirationTime || shouldYieldToHost());
+}
+// The remaining code is essentially a polyfill for requestIdleCallback. It
+// works by scheduling a requestAnimationFrame, storing the time for the start
+// of the frame, then scheduling a postMessage which gets scheduled after paint.
+// Within the postMessage handler do as much work as possible until time + frame
+// rate. By separating the idle call into a separate event tick we ensure that
+// layout, paint and other browser work is counted against the available time.
+// The frame rate is dynamically adjusted.
+// We capture a local reference to any global, in case it gets polyfilled after
+// this module is initially evaluated. We want to be using a
+// consistent implementation.
+var localDate = Date;
+// This initialization code may run even on server environments if a component
+// just imports ReactDOM (e.g. for findDOMNode). Some environments might not
+// have setTimeout or clearTimeout. However, we always expect them to be defined
+// on the client. https://github.com/facebook/react/pull/13088
+var localSetTimeout = typeof setTimeout === 'function' ? setTimeout : undefined;
+var localClearTimeout = typeof clearTimeout === 'function' ? clearTimeout : undefined;
+// We don't expect either of these to necessarily be defined, but we will error
+// later if they are missing on the client.
+var localRequestAnimationFrame = typeof requestAnimationFrame === 'function' ? requestAnimationFrame : undefined;
+var localCancelAnimationFrame = typeof cancelAnimationFrame === 'function' ? cancelAnimationFrame : undefined;
+var getCurrentTime;
+// requestAnimationFrame does not run when the tab is in the background. If
+// we're backgrounded we prefer for that work to happen so that the page
+// continues to load in the background. So we also schedule a 'setTimeout' as
+// a fallback.
+// TODO: Need a better heuristic for backgrounded work.
+var ANIMATION_FRAME_TIMEOUT = 100;
+var rAFID;
+var rAFTimeoutID;
+var requestAnimationFrameWithTimeout = function (callback) {
+// schedule rAF and also a setTimeout
+rAFID = localRequestAnimationFrame(function (timestamp) {
+// cancel the setTimeout
+localClearTimeout(rAFTimeoutID);
+callback(timestamp);
+});
+rAFTimeoutID = localSetTimeout(function () {
+// cancel the requestAnimationFrame
+localCancelAnimationFrame(rAFID);
+callback(getCurrentTime());
+}, ANIMATION_FRAME_TIMEOUT);
+};
+if (hasNativePerformanceNow) {
+var Performance = performance;
+getCurrentTime = function () {
+return Performance.now();
+};
+} else {
+getCurrentTime = function () {
+return localDate.now();
+};
+}
+var requestHostCallback;
+var cancelHostCallback;
+var shouldYieldToHost;
+var globalValue = null;
+if (typeof window !== 'undefined') {
+globalValue = window;
+} else if (typeof global !== 'undefined') {
+globalValue = global;
+}
+if (globalValue && globalValue._schedMock) {
+// Dynamic injection, only for testing purposes.
+var globalImpl = globalValue._schedMock;
+requestHostCallback = globalImpl[0];
+cancelHostCallback = globalImpl[1];
+shouldYieldToHost = globalImpl[2];
+getCurrentTime = globalImpl[3];
+} else if (
+// If Scheduler runs in a non-DOM environment, it falls back to a naive
+// implementation using setTimeout.
+typeof window === 'undefined' ||
+// Check if MessageChannel is supported, too.
+typeof MessageChannel !== 'function') {
+// If this accidentally gets imported in a non-browser environment, e.g. JavaScriptCore,
+// fallback to a naive implementation.
+var _callback = null;
+var _flushCallback = function (didTimeout) {
+if (_callback !== null) {
+try {
+_callback(didTimeout);
+} finally {
+_callback = null;
+}
+}
+};
+requestHostCallback = function (cb, ms) {
+if (_callback !== null) {
+// Protect against re-entrancy.
+setTimeout(requestHostCallback, 0, cb);
+} else {
+_callback = cb;
+setTimeout(_flushCallback, 0, false);
+}
+};
+cancelHostCallback = function () {
+_callback = null;
+};
+shouldYieldToHost = function () {
+return false;
+};
+} else {
+if (typeof console !== 'undefined') {
+// TODO: Remove fb.me link
+if (typeof localRequestAnimationFrame !== 'function') {
+console.error("This browser doesn't support requestAnimationFrame. " + 'Make sure that you load a ' + 'polyfill in older browsers. https://fb.me/react-polyfills');
+}
+if (typeof localCancelAnimationFrame !== 'function') {
+console.error("This browser doesn't support cancelAnimationFrame. " + 'Make sure that you load a ' + 'polyfill in older browsers. https://fb.me/react-polyfills');
+}
+}
+var scheduledHostCallback = null;
+var isMessageEventScheduled = false;
+var timeoutTime = -1;
+var isAnimationFrameScheduled = false;
+var isFlushingHostCallback = false;
+var frameDeadline = 0;
+// We start out assuming that we run at 30fps but then the heuristic tracking
+// will adjust this value to a faster fps if we get more frequent animation
+// frames.
+var previousFrameTime = 33;
+var activeFrameTime = 33;
+shouldYieldToHost = function () {
+return frameDeadline <= getCurrentTime();
+};
+// We use the postMessage trick to defer idle work until after the repaint.
+var channel = new MessageChannel();
+var port = channel.port2;
+channel.port1.onmessage = function (event) {
+isMessageEventScheduled = false;
+var prevScheduledCallback = scheduledHostCallback;
+var prevTimeoutTime = timeoutTime;
+scheduledHostCallback = null;
+timeoutTime = -1;
+var currentTime = getCurrentTime();
+var didTimeout = false;
+if (frameDeadline - currentTime <= 0) {
+// There's no time left in this idle period. Check if the callback has
+// a timeout and whether it's been exceeded.
+if (prevTimeoutTime !== -1 && prevTimeoutTime <= currentTime) {
+// Exceeded the timeout. Invoke the callback even though there's no
+// time left.
+didTimeout = true;
+} else {
+// No timeout.
+if (!isAnimationFrameScheduled) {
+// Schedule another animation callback so we retry later.
+isAnimationFrameScheduled = true;
+requestAnimationFrameWithTimeout(animationTick);
+}
+// Exit without invoking the callback.
+scheduledHostCallback = prevScheduledCallback;
+timeoutTime = prevTimeoutTime;
+return;
+}
+}
+if (prevScheduledCallback !== null) {
+isFlushingHostCallback = true;
+try {
+prevScheduledCallback(didTimeout);
+} finally {
+isFlushingHostCallback = false;
+}
+}
+};
+var animationTick = function (rafTime) {
+if (scheduledHostCallback !== null) {
+// Eagerly schedule the next animation callback at the beginning of the
+// frame. If the scheduler queue is not empty at the end of the frame, it
+// will continue flushing inside that callback. If the queue *is* empty,
+// then it will exit immediately. Posting the callback at the start of the
+// frame ensures it's fired within the earliest possible frame. If we
+// waited until the end of the frame to post the callback, we risk the
+// browser skipping a frame and not firing the callback until the frame
+// after that.
+requestAnimationFrameWithTimeout(animationTick);
+} else {
+// No pending work. Exit.
+isAnimationFrameScheduled = false;
+return;
+}
+var nextFrameTime = rafTime - frameDeadline + activeFrameTime;
+if (nextFrameTime < activeFrameTime && previousFrameTime < activeFrameTime) {
+if (nextFrameTime < 8) {
+// Defensive coding. We don't support higher frame rates than 120hz.
+// If the calculated frame time gets lower than 8, it is probably a bug.
+nextFrameTime = 8;
+}
+// If one frame goes long, then the next one can be short to catch up.
+// If two frames are short in a row, then that's an indication that we
+// actually have a higher frame rate than what we're currently optimizing.
+// We adjust our heuristic dynamically accordingly. For example, if we're
+// running on 120hz display or 90hz VR display.
+// Take the max of the two in case one of them was an anomaly due to
+// missed frame deadlines.
+activeFrameTime = nextFrameTime < previousFrameTime ? previousFrameTime : nextFrameTime;
+} else {
+previousFrameTime = nextFrameTime;
+}
+frameDeadline = rafTime + activeFrameTime;
+if (!isMessageEventScheduled) {
+isMessageEventScheduled = true;
+port.postMessage(undefined);
+}
+};
+requestHostCallback = function (callback, absoluteTimeout) {
+scheduledHostCallback = callback;
+timeoutTime = absoluteTimeout;
+if (isFlushingHostCallback || absoluteTimeout < 0) {
+// Don't wait for the next frame. Continue working ASAP, in a new event.
+port.postMessage(undefined);
+} else if (!isAnimationFrameScheduled) {
+// If rAF didn't already schedule one, we need to schedule a frame.
+// TODO: If this rAF doesn't materialize because the browser throttles, we
+// might want to still have setTimeout trigger rIC as a backup to ensure
+// that we keep performing work.
+isAnimationFrameScheduled = true;
+requestAnimationFrameWithTimeout(animationTick);
+}
+};
+cancelHostCallback = function () {
+scheduledHostCallback = null;
+isMessageEventScheduled = false;
+timeoutTime = -1;
+};
+}
+// Helps identify side effects in begin-phase lifecycle hooks and setState reducers:
+// In some cases, StrictMode should also double-render lifecycles.
+// This can be confusing for tests though,
+// And it can be bad for performance in production.
+// This feature flag can be used to control the behavior:
+// To preserve the "Pause on caught exceptions" behavior of the debugger, we
+// replay the begin phase of a failed component inside invokeGuardedCallback.
+// Warn about deprecated, async-unsafe lifecycles; relates to RFC #6:
+// Gather advanced timing metrics for Profiler subtrees.
+// Trace which interactions trigger each commit.
+var enableSchedulerTracing = true;
+// Only used in www builds.
+// TODO: true? Here it might just be false.
+// Only used in www builds.
+// Only used in www builds.
+// React Fire: prevent the value and checked attributes from syncing
+// with their related DOM properties
+// These APIs will no longer be "unstable" in the upcoming 16.7 release,
+// Control this behavior with a flag to support 16.6 minor releases in the meanwhile.
+var enableStableConcurrentModeAPIs = false;
+var DEFAULT_THREAD_ID = 0;
+// Counters used to generate unique IDs.
+var interactionIDCounter = 0;
+var threadIDCounter = 0;
+// Set of currently traced interactions.
+// Interactions "stack"–
+// Meaning that newly traced interactions are appended to the previously active set.
+// When an interaction goes out of scope, the previous set (if any) is restored.
+var interactionsRef = null;
+// Listener(s) to notify when interactions begin and end.
+var subscriberRef = null;
+if (enableSchedulerTracing) {
+interactionsRef = {
+current: new Set()
+};
+subscriberRef = {
+current: null
+};
+}
+function unstable_clear(callback) {
+if (!enableSchedulerTracing) {
+return callback();
+}
+var prevInteractions = interactionsRef.current;
+interactionsRef.current = new Set();
+try {
+return callback();
+} finally {
+interactionsRef.current = prevInteractions;
+}
+}
+function unstable_getCurrent() {
+if (!enableSchedulerTracing) {
+return null;
+} else {
+return interactionsRef.current;
+}
+}
+function unstable_getThreadID() {
+return ++threadIDCounter;
+}
+function unstable_trace(name, timestamp, callback) {
+var threadID = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : DEFAULT_THREAD_ID;
+if (!enableSchedulerTracing) {
+return callback();
+}
+var interaction = {
+__count: 1,
+id: interactionIDCounter++,
+name: name,
+timestamp: timestamp
+};
+var prevInteractions = interactionsRef.current;
+// Traced interactions should stack/accumulate.
+// To do that, clone the current interactions.
+// The previous set will be restored upon completion.
+var interactions = new Set(prevInteractions);
+interactions.add(interaction);
+interactionsRef.current = interactions;
+var subscriber = subscriberRef.current;
+var returnValue = void 0;
+try {
+if (subscriber !== null) {
+subscriber.onInteractionTraced(interaction);
+}
+} finally {
+try {
+if (subscriber !== null) {
+subscriber.onWorkStarted(interactions, threadID);
+}
+} finally {
+try {
+returnValue = callback();
+} finally {
+interactionsRef.current = prevInteractions;
+try {
+if (subscriber !== null) {
+subscriber.onWorkStopped(interactions, threadID);
+}
+} finally {
+interaction.__count--;
+// If no async work was scheduled for this interaction,
+// Notify subscribers that it's completed.
+if (subscriber !== null && interaction.__count === 0) {
+subscriber.onInteractionScheduledWorkCompleted(interaction);
+}
+}
+}
+}
+}
+return returnValue;
+}
+function unstable_wrap(callback) {
+var threadID = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : DEFAULT_THREAD_ID;
+if (!enableSchedulerTracing) {
+return callback;
+}
+var wrappedInteractions = interactionsRef.current;
+var subscriber = subscriberRef.current;
+if (subscriber !== null) {
+subscriber.onWorkScheduled(wrappedInteractions, threadID);
+}
+// Update the pending async work count for the current interactions.
+// Update after calling subscribers in case of error.
+wrappedInteractions.forEach(function (interaction) {
+interaction.__count++;
+});
+var hasRun = false;
+function wrapped() {
+var prevInteractions = interactionsRef.current;
+interactionsRef.current = wrappedInteractions;
+subscriber = subscriberRef.current;
+try {
+var returnValue = void 0;
+try {
+if (subscriber !== null) {
+subscriber.onWorkStarted(wrappedInteractions, threadID);
+}
+} finally {
+try {
+returnValue = callback.apply(undefined, arguments);
+} finally {
+interactionsRef.current = prevInteractions;
+if (subscriber !== null) {
+subscriber.onWorkStopped(wrappedInteractions, threadID);
+}
+}
+}
+return returnValue;
+} finally {
+if (!hasRun) {
+// We only expect a wrapped function to be executed once,
+// But in the event that it's executed more than once–
+// Only decrement the outstanding interaction counts once.
+hasRun = true;
+// Update pending async counts for all wrapped interactions.
+// If this was the last scheduled async work for any of them,
+// Mark them as completed.
+wrappedInteractions.forEach(function (interaction) {
+interaction.__count--;
+if (subscriber !== null && interaction.__count === 0) {
+subscriber.onInteractionScheduledWorkCompleted(interaction);
+}
+});
+}
+}
+}
+wrapped.cancel = function cancel() {
+subscriber = subscriberRef.current;
+try {
+if (subscriber !== null) {
+subscriber.onWorkCanceled(wrappedInteractions, threadID);
+}
+} finally {
+// Update pending async counts for all wrapped interactions.
+// If this was the last scheduled async work for any of them,
+// Mark them as completed.
+wrappedInteractions.forEach(function (interaction) {
+interaction.__count--;
+if (subscriber && interaction.__count === 0) {
+subscriber.onInteractionScheduledWorkCompleted(interaction);
+}
+});
+}
+};
+return wrapped;
+}
+var subscribers = null;
+if (enableSchedulerTracing) {
+subscribers = new Set();
+}
+function unstable_subscribe(subscriber) {
+if (enableSchedulerTracing) {
+subscribers.add(subscriber);
+if (subscribers.size === 1) {
+subscriberRef.current = {
+onInteractionScheduledWorkCompleted: onInteractionScheduledWorkCompleted,
+onInteractionTraced: onInteractionTraced,
+onWorkCanceled: onWorkCanceled,
+onWorkScheduled: onWorkScheduled,
+onWorkStarted: onWorkStarted,
+onWorkStopped: onWorkStopped
+};
+}
+}
+}
+function unstable_unsubscribe(subscriber) {
+if (enableSchedulerTracing) {
+subscribers.delete(subscriber);
+if (subscribers.size === 0) {
+subscriberRef.current = null;
+}
+}
+}
+function onInteractionTraced(interaction) {
+var didCatchError = false;
+var caughtError = null;
+subscribers.forEach(function (subscriber) {
+try {
+subscriber.onInteractionTraced(interaction);
+} catch (error) {
+if (!didCatchError) {
+didCatchError = true;
+caughtError = error;
+}
+}
+});
+if (didCatchError) {
+throw caughtError;
+}
+}
+function onInteractionScheduledWorkCompleted(interaction) {
+var didCatchError = false;
+var caughtError = null;
+subscribers.forEach(function (subscriber) {
+try {
+subscriber.onInteractionScheduledWorkCompleted(interaction);
+} catch (error) {
+if (!didCatchError) {
+didCatchError = true;
+caughtError = error;
+}
+}
+});
+if (didCatchError) {
+throw caughtError;
+}
+}
+function onWorkScheduled(interactions, threadID) {
+var didCatchError = false;
+var caughtError = null;
+subscribers.forEach(function (subscriber) {
+try {
+subscriber.onWorkScheduled(interactions, threadID);
+} catch (error) {
+if (!didCatchError) {
+didCatchError = true;
+caughtError = error;
+}
+}
+});
+if (didCatchError) {
+throw caughtError;
+}
+}
+function onWorkStarted(interactions, threadID) {
+var didCatchError = false;
+var caughtError = null;
+subscribers.forEach(function (subscriber) {
+try {
+subscriber.onWorkStarted(interactions, threadID);
+} catch (error) {
+if (!didCatchError) {
+didCatchError = true;
+caughtError = error;
+}
+}
+});
+if (didCatchError) {
+throw caughtError;
+}
+}
+function onWorkStopped(interactions, threadID) {
+var didCatchError = false;
+var caughtError = null;
+subscribers.forEach(function (subscriber) {
+try {
+subscriber.onWorkStopped(interactions, threadID);
+} catch (error) {
+if (!didCatchError) {
+didCatchError = true;
+caughtError = error;
+}
+}
+});
+if (didCatchError) {
+throw caughtError;
+}
+}
+function onWorkCanceled(interactions, threadID) {
+var didCatchError = false;
+var caughtError = null;
+subscribers.forEach(function (subscriber) {
+try {
+subscriber.onWorkCanceled(interactions, threadID);
+} catch (error) {
+if (!didCatchError) {
+didCatchError = true;
+caughtError = error;
+}
+}
+});
+if (didCatchError) {
+throw caughtError;
+}
+}
+/**
+* Keeps track of the current dispatcher.
+*/
+var ReactCurrentDispatcher = {
+/**
+* @internal
+* @type {ReactComponent}
+*/
+current: null
+};
+/**
+* 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 BEFORE_SLASH_RE = /^(.*)[\\\/]/;
+var describeComponentFrame = function (name, source, ownerName) {
+var sourceInfo = '';
+if (source) {
+var path = source.fileName;
+var fileName = path.replace(BEFORE_SLASH_RE, '');
+{
+// In DEV, include code for a common special case:
+// prefer "folder/index.js" instead of just "index.js".
+if (/^index\./.test(fileName)) {
+var match = path.match(BEFORE_SLASH_RE);
+if (match) {
+var pathBeforeSlash = match[1];
+if (pathBeforeSlash) {
+var folderName = pathBeforeSlash.replace(BEFORE_SLASH_RE, '');
+fileName = folderName + '/' + fileName;
+}
+}
+}
+}
+sourceInfo = ' (at ' + fileName + ':' + source.lineNumber + ')';
+} else if (ownerName) {
+sourceInfo = ' (created by ' + ownerName + ')';
+}
+return '\n    in ' + (name || 'Unknown') + sourceInfo;
+};
+var Resolved = 1;
+function refineResolvedLazyComponent(lazyComponent) {
+return lazyComponent._status === Resolved ? lazyComponent._result : null;
+}
+function getWrappedName(outerType, innerType, wrapperName) {
+var functionName = innerType.displayName || innerType.name || '';
+return outerType.displayName || (functionName !== '' ? wrapperName + '(' + functionName + ')' : wrapperName);
+}
+function getComponentName(type) {
+if (type == null) {
+// Host root, text node or just invalid type.
+return null;
+}
+{
+if (typeof type.tag === 'number') {
+warningWithoutStack$1(false, 'Received an unexpected object in getComponentName(). ' + 'This is likely a bug in React. Please file an issue.');
+}
+}
+if (typeof type === 'function') {
+return type.displayName || type.name || null;
+}
+if (typeof type === 'string') {
+return type;
+}
+switch (type) {
+case REACT_CONCURRENT_MODE_TYPE:
+return 'ConcurrentMode';
+case REACT_FRAGMENT_TYPE:
+return 'Fragment';
+case REACT_PORTAL_TYPE:
+return 'Portal';
+case REACT_PROFILER_TYPE:
+return 'Profiler';
+case REACT_STRICT_MODE_TYPE:
+return 'StrictMode';
+case REACT_SUSPENSE_TYPE:
+return 'Suspense';
+}
+if (typeof type === 'object') {
+switch (type.$$typeof) {
+case REACT_CONTEXT_TYPE:
+return 'Context.Consumer';
+case REACT_PROVIDER_TYPE:
+return 'Context.Provider';
+case REACT_FORWARD_REF_TYPE:
+return getWrappedName(type, type.render, 'ForwardRef');
+case REACT_MEMO_TYPE:
+return getComponentName(type.type);
+case REACT_LAZY_TYPE:
+{
+var thenable = type;
+var resolvedThenable = refineResolvedLazyComponent(thenable);
+if (resolvedThenable) {
+return getComponentName(resolvedThenable);
+}
+}
+}
+}
+return null;
+}
+var ReactDebugCurrentFrame = {};
+var currentlyValidatingElement = null;
+function setCurrentlyValidatingElement(element) {
+{
+currentlyValidatingElement = element;
+}
+}
+{
+// Stack implementation injected by the current renderer.
+ReactDebugCurrentFrame.getCurrentStack = null;
+ReactDebugCurrentFrame.getStackAddendum = function () {
+var stack = '';
+// Add an extra top frame while an element is being validated
+if (currentlyValidatingElement) {
+var name = getComponentName(currentlyValidatingElement.type);
+var owner = currentlyValidatingElement._owner;
+stack += describeComponentFrame(name, currentlyValidatingElement._source, owner && getComponentName(owner.type));
+}
+// Delegate to the injected renderer-specific implementation
+var impl = ReactDebugCurrentFrame.getCurrentStack;
+if (impl) {
+stack += impl() || '';
+}
+return stack;
+};
+}
+var ReactSharedInternals = {
+ReactCurrentDispatcher: ReactCurrentDispatcher,
+ReactCurrentOwner: ReactCurrentOwner,
+// Used by renderers to avoid bundling object-assign twice in UMD bundles:
+assign: objectAssign
+};
+{
+// Re-export the schedule API(s) for UMD bundles.
+// This avoids introducing a dependency on a new UMD global in a minor update,
+// Since that would be a breaking change (e.g. for all existing CodeSandboxes).
+// This re-export is only required for UMD bundles;
+// CJS bundles use the shared NPM package.
+objectAssign(ReactSharedInternals, {
+Scheduler: {
+unstable_cancelCallback: unstable_cancelCallback,
+unstable_shouldYield: unstable_shouldYield,
+unstable_now: getCurrentTime,
+unstable_scheduleCallback: unstable_scheduleCallback,
+unstable_runWithPriority: unstable_runWithPriority,
+unstable_next: unstable_next,
+unstable_wrapCallback: unstable_wrapCallback,
+unstable_getFirstCallbackNode: unstable_getFirstCallbackNode,
+unstable_pauseExecution: unstable_pauseExecution,
+unstable_continueExecution: unstable_continueExecution,
+unstable_getCurrentPriorityLevel: unstable_getCurrentPriorityLevel,
+unstable_IdlePriority: IdlePriority,
+unstable_ImmediatePriority: ImmediatePriority,
+unstable_LowPriority: LowPriority,
+unstable_NormalPriority: NormalPriority,
+unstable_UserBlockingPriority: UserBlockingPriority
+},
+SchedulerTracing: {
+__interactionsRef: interactionsRef,
+__subscriberRef: subscriberRef,
+unstable_clear: unstable_clear,
+unstable_getCurrent: unstable_getCurrent,
+unstable_getThreadID: unstable_getThreadID,
+unstable_subscribe: unstable_subscribe,
+unstable_trace: unstable_trace,
+unstable_unsubscribe: unstable_unsubscribe,
+unstable_wrap: unstable_wrap
+}
+});
+}
+{
+objectAssign(ReactSharedInternals, {
+// These should not be included in production.
+ReactDebugCurrentFrame: ReactDebugCurrentFrame,
+// Shim for React DOM 16.0.0 which still destructured (but not used) this.
+// TODO: remove in React 17.0.
+ReactComponentTreeHook: {}
+});
+}
+/**
+* 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 = warningWithoutStack$1;
+{
+warning = function (condition, format) {
+if (condition) {
+return;
+}
+var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+var stack = ReactDebugCurrentFrame.getStackAddendum();
+// eslint-disable-next-line react-internal/warning-and-invariant-args
+for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+args[_key - 2] = arguments[_key];
+}
+warningWithoutStack$1.apply(undefined, [false, format + '%s'].concat(args, [stack]));
+};
+}
+var warning$1 = warning;
+var hasOwnProperty$1 = Object.prototype.hasOwnProperty;
+var RESERVED_PROPS = {
+key: true,
+ref: true,
+__self: true,
+__source: true
+};
+var specialPropKeyWarningShown = void 0;
+var specialPropRefWarningShown = void 0;
+function hasValidRef(config) {
+{
+if (hasOwnProperty$1.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$1.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 () {
+if (!specialPropKeyWarningShown) {
+specialPropKeyWarningShown = true;
+warningWithoutStack$1(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 () {
+if (!specialPropRefWarningShown) {
+specialPropRefWarningShown = true;
+warningWithoutStack$1(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 (type, key, ref, self, source, owner, props) {
+var element = {
+// This tag allows us to uniquely identify this as a React Element
+$$typeof: REACT_ELEMENT_TYPE,
+// 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://reactjs.org/docs/react-api.html#createelement
+*/
+function createElement(type, config, children) {
+var propName = void 0;
+// 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$1.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) {
+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.current, props);
+}
+/**
+* Return a function that produces ReactElements of a given type.
+* See https://reactjs.org/docs/react-api.html#createfactory
+*/
+function cloneAndReplaceKey(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://reactjs.org/docs/react-api.html#cloneelement
+*/
+function cloneElement(element, config, children) {
+!!(element === null || element === undefined) ? invariant(false, 'React.cloneElement(...): The argument must be a React element, but you passed %s.', element) : void 0;
+var propName = void 0;
+// Original props are copied
+var props = objectAssign({}, 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.current;
+}
+if (hasValidKey(config)) {
+key = '' + config.key;
+}
+// Remaining properties override existing props
+var defaultProps = void 0;
+if (element.type && element.type.defaultProps) {
+defaultProps = element.type.defaultProps;
+}
+for (propName in config) {
+if (hasOwnProperty$1.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://reactjs.org/docs/react-api.html#isvalidelement
+* @param {?object} object
+* @return {boolean} True if `object` is a ReactElement.
+* @final
+*/
+function isValidElement(object) {
+return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+}
+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;
+if (type === 'undefined' || type === 'boolean') {
+// All of the above are perceived as null.
+children = null;
+}
+var invokeCallback = false;
+if (children === null) {
+invokeCallback = true;
+} else {
+switch (type) {
+case 'string':
+case 'number':
+invokeCallback = true;
+break;
+case 'object':
+switch (children.$$typeof) {
+case REACT_ELEMENT_TYPE:
+case REACT_PORTAL_TYPE:
+invokeCallback = true;
+}
+}
+}
+if (invokeCallback) {
+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 = void 0;
+var nextName = void 0;
+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 = getIteratorFn(children);
+if (typeof iteratorFn === 'function') {
+{
+// Warn about using Maps as children
+if (iteratorFn === children.entries) {
+!didWarnAboutMaps ? warning$1(false, 'Using Maps as children is unsupported and will likely yield ' + 'unexpected results. Convert it to a sequence/iterable of keyed ' + 'ReactElements instead.') : void 0;
+didWarnAboutMaps = true;
+}
+}
+var iterator = iteratorFn.call(children);
+var step = void 0;
+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.' + ReactDebugCurrentFrame.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 === '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://reactjs.org/docs/react-api.html#reactchildrenforeach
+*
+* 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, function (c) {
+return c;
+});
+} else if (mappedChild != null) {
+if (isValidElement(mappedChild)) {
+mappedChild = 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://reactjs.org/docs/react-api.html#reactchildrenmap
+*
+* 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://reactjs.org/docs/react-api.html#reactchildrencount
+*
+* @param {?*} children Children tree container.
+* @return {number} The number of children.
+*/
+function countChildren(children) {
+return traverseAllChildren(children, function () {
+return null;
+}, null);
+}
+/**
+* Flatten a children object (typically specified as `props.children`) and
+* return an array with appropriately re-keyed children.
+*
+* See https://reactjs.org/docs/react-api.html#reactchildrentoarray
+*/
+function toArray(children) {
+var result = [];
+mapIntoWithKeyPrefixInternal(children, result, null, function (child) {
+return child;
+});
+return result;
+}
+/**
+* Returns the first child in a collection of children and verifies that there
+* is only one child in the collection.
+*
+* See https://reactjs.org/docs/react-api.html#reactchildrenonly
+*
+* 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) {
+!isValidElement(children) ? invariant(false, 'React.Children.only expected to receive a single React element child.') : void 0;
+return children;
+}
+function createContext(defaultValue, calculateChangedBits) {
+if (calculateChangedBits === undefined) {
+calculateChangedBits = null;
+} else {
+{
+!(calculateChangedBits === null || typeof calculateChangedBits === 'function') ? warningWithoutStack$1(false, 'createContext: Expected the optional second argument to be a ' + 'function. Instead received: %s', calculateChangedBits) : void 0;
+}
+}
+var context = {
+$$typeof: REACT_CONTEXT_TYPE,
+_calculateChangedBits: calculateChangedBits,
+// As a workaround to support multiple concurrent renderers, we categorize
+// some renderers as primary and others as secondary. We only expect
+// there to be two concurrent renderers at most: React Native (primary) and
+// Fabric (secondary); React DOM (primary) and React ART (secondary).
+// Secondary renderers store their context values on separate fields.
+_currentValue: defaultValue,
+_currentValue2: defaultValue,
+// Used to track how many concurrent renderers this context currently
+// supports within in a single renderer. Such as parallel server rendering.
+_threadCount: 0,
+// These are circular
+Provider: null,
+Consumer: null
+};
+context.Provider = {
+$$typeof: REACT_PROVIDER_TYPE,
+_context: context
+};
+var hasWarnedAboutUsingNestedContextConsumers = false;
+var hasWarnedAboutUsingConsumerProvider = false;
+{
+// A separate object, but proxies back to the original context object for
+// backwards compatibility. It has a different $$typeof, so we can properly
+// warn for the incorrect usage of Context as a Consumer.
+var Consumer = {
+$$typeof: REACT_CONTEXT_TYPE,
+_context: context,
+_calculateChangedBits: context._calculateChangedBits
+};
+// $FlowFixMe: Flow complains about not setting a value, which is intentional here
+Object.defineProperties(Consumer, {
+Provider: {
+get: function () {
+if (!hasWarnedAboutUsingConsumerProvider) {
+hasWarnedAboutUsingConsumerProvider = true;
+warning$1(false, 'Rendering <Context.Consumer.Provider> is not supported and will be removed in ' + 'a future major release. Did you mean to render <Context.Provider> instead?');
+}
+return context.Provider;
+},
+set: function (_Provider) {
+context.Provider = _Provider;
+}
+},
+_currentValue: {
+get: function () {
+return context._currentValue;
+},
+set: function (_currentValue) {
+context._currentValue = _currentValue;
+}
+},
+_currentValue2: {
+get: function () {
+return context._currentValue2;
+},
+set: function (_currentValue2) {
+context._currentValue2 = _currentValue2;
+}
+},
+_threadCount: {
+get: function () {
+return context._threadCount;
+},
+set: function (_threadCount) {
+context._threadCount = _threadCount;
+}
+},
+Consumer: {
+get: function () {
+if (!hasWarnedAboutUsingNestedContextConsumers) {
+hasWarnedAboutUsingNestedContextConsumers = true;
+warning$1(false, 'Rendering <Context.Consumer.Consumer> is not supported and will be removed in ' + 'a future major release. Did you mean to render <Context.Consumer> instead?');
+}
+return context.Consumer;
+}
+}
+});
+// $FlowFixMe: Flow complains about missing properties because it doesn't understand defineProperty
+context.Consumer = Consumer;
+}
+{
+context._currentRenderer = null;
+context._currentRenderer2 = null;
+}
+return context;
+}
+function lazy(ctor) {
+var lazyType = {
+$$typeof: REACT_LAZY_TYPE,
+_ctor: ctor,
+// React uses these fields to store the result.
+_status: -1,
+_result: null
+};
+{
+// In production, this would just set it on the object.
+var defaultProps = void 0;
+var propTypes = void 0;
+Object.defineProperties(lazyType, {
+defaultProps: {
+configurable: true,
+get: function () {
+return defaultProps;
+},
+set: function (newDefaultProps) {
+warning$1(false, 'React.lazy(...): It is not supported to assign `defaultProps` to ' + 'a lazy component import. Either specify them where the component ' + 'is defined, or create a wrapping component around it.');
+defaultProps = newDefaultProps;
+// Match production behavior more closely:
+Object.defineProperty(lazyType, 'defaultProps', {
+enumerable: true
+});
+}
+},
+propTypes: {
+configurable: true,
+get: function () {
+return propTypes;
+},
+set: function (newPropTypes) {
+warning$1(false, 'React.lazy(...): It is not supported to assign `propTypes` to ' + 'a lazy component import. Either specify them where the component ' + 'is defined, or create a wrapping component around it.');
+propTypes = newPropTypes;
+// Match production behavior more closely:
+Object.defineProperty(lazyType, 'propTypes', {
+enumerable: true
+});
+}
+}
+});
+}
+return lazyType;
+}
+function forwardRef(render) {
+{
+if (render != null && render.$$typeof === REACT_MEMO_TYPE) {
+warningWithoutStack$1(false, 'forwardRef requires a render function but received a `memo` ' + 'component. Instead of forwardRef(memo(...)), use ' + 'memo(forwardRef(...)).');
+} else if (typeof render !== 'function') {
+warningWithoutStack$1(false, 'forwardRef requires a render function but was given %s.', render === null ? 'null' : typeof render);
+} else {
+!(
+// Do not warn for 0 arguments because it could be due to usage of the 'arguments' object
+render.length === 0 || render.length === 2) ? warningWithoutStack$1(false, 'forwardRef render functions accept exactly two parameters: props and ref. %s', render.length === 1 ? 'Did you forget to use the ref parameter?' : 'Any additional parameter will be undefined.') : void 0;
+}
+if (render != null) {
+!(render.defaultProps == null && render.propTypes == null) ? warningWithoutStack$1(false, 'forwardRef render functions do not support propTypes or defaultProps. ' + 'Did you accidentally pass a React component?') : void 0;
+}
+}
+return {
+$$typeof: REACT_FORWARD_REF_TYPE,
+render: render
+};
+}
+function isValidElementType(type) {
+return typeof type === 'string' || typeof type === 'function' ||
+// Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
+type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE);
+}
+function memo(type, compare) {
+{
+if (!isValidElementType(type)) {
+warningWithoutStack$1(false, 'memo: The first argument must be a component. Instead ' + 'received: %s', type === null ? 'null' : typeof type);
+}
+}
+return {
+$$typeof: REACT_MEMO_TYPE,
+type: type,
+compare: compare === undefined ? null : compare
+};
+}
+function resolveDispatcher() {
+var dispatcher = ReactCurrentDispatcher.current;
+!(dispatcher !== null) ? invariant(false, 'Hooks can only be called inside the body of a function component. (https://fb.me/react-invalid-hook-call)') : void 0;
+return dispatcher;
+}
+function useContext(Context, unstable_observedBits) {
+var dispatcher = resolveDispatcher();
+{
+!(unstable_observedBits === undefined) ? warning$1(false, 'useContext() second argument is reserved for future ' + 'use in React. Passing it is not supported. ' + 'You passed: %s.%s', unstable_observedBits, typeof unstable_observedBits === 'number' && Array.isArray(arguments[2]) ? '\n\nDid you call array.map(useContext)? ' + 'Calling Hooks inside a loop is not supported. ' + 'Learn more at https://fb.me/rules-of-hooks' : '') : void 0;
+// TODO: add a more generic warning for invalid values.
+if (Context._context !== undefined) {
+var realContext = Context._context;
+// Don't deduplicate because this legitimately causes bugs
+// and nobody should be using this in existing code.
+if (realContext.Consumer === Context) {
+warning$1(false, 'Calling useContext(Context.Consumer) is not supported, may cause bugs, and will be ' + 'removed in a future major release. Did you mean to call useContext(Context) instead?');
+} else if (realContext.Provider === Context) {
+warning$1(false, 'Calling useContext(Context.Provider) is not supported. ' + 'Did you mean to call useContext(Context) instead?');
+}
+}
+}
+return dispatcher.useContext(Context, unstable_observedBits);
+}
+function useState(initialState) {
+var dispatcher = resolveDispatcher();
+return dispatcher.useState(initialState);
+}
+function useReducer(reducer, initialArg, init) {
+var dispatcher = resolveDispatcher();
+return dispatcher.useReducer(reducer, initialArg, init);
+}
+function useRef(initialValue) {
+var dispatcher = resolveDispatcher();
+return dispatcher.useRef(initialValue);
+}
+function useEffect(create, inputs) {
+var dispatcher = resolveDispatcher();
+return dispatcher.useEffect(create, inputs);
+}
+function useLayoutEffect(create, inputs) {
+var dispatcher = resolveDispatcher();
+return dispatcher.useLayoutEffect(create, inputs);
+}
+function useCallback(callback, inputs) {
+var dispatcher = resolveDispatcher();
+return dispatcher.useCallback(callback, inputs);
+}
+function useMemo(create, inputs) {
+var dispatcher = resolveDispatcher();
+return dispatcher.useMemo(create, inputs);
+}
+function useImperativeHandle(ref, create, inputs) {
+var dispatcher = resolveDispatcher();
+return dispatcher.useImperativeHandle(ref, create, inputs);
+}
+function useDebugValue(value, formatterFn) {
+{
+var dispatcher = resolveDispatcher();
+return dispatcher.useDebugValue(value, formatterFn);
+}
+}
+/**
+* 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$1 = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
+var ReactPropTypesSecret_1 = ReactPropTypesSecret$1;
+/**
+* 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 printWarning$1 = function() {};
+{
+var ReactPropTypesSecret = ReactPropTypesSecret_1;
+var loggedTypeFailures = {};
+printWarning$1 = function(text) {
+var message = 'Warning: ' + text;
+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) {}
+};
+}
+/**
+* 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) {
+{
+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.
+if (typeof typeSpecs[typeSpecName] !== 'function') {
+var err = Error(
+(componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' +
+'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.'
+);
+err.name = 'Invariant Violation';
+throw err;
+}
+error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
+} catch (ex) {
+error = ex;
+}
+if (error && !(error instanceof Error)) {
+printWarning$1(
+(componentName || 'React class') + ': type specification of ' +
+location + ' `' + typeSpecName + '` is invalid; the type checker ' +
+'function must return `null` or an `Error` but returned a ' + typeof error + '. ' +
+'You may have forgotten to pass an argument to the type checker ' +
+'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' +
+'shape all require an argument).'
+);
+}
+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() : '';
+printWarning$1(
+'Failed ' + location + ' type: ' + error.message + (stack != null ? stack : '')
+);
+}
+}
+}
+}
+}
+var checkPropTypes_1 = checkPropTypes;
+/**
+* ReactElementValidator provides a wrapper around a element factory
+* which validates the props passed to the element. This is intended to be
+* used only in DEV and could be replaced by a static type checker for languages
+* that support it.
+*/
+var propTypesMisspellWarningShown = void 0;
+{
+propTypesMisspellWarningShown = false;
+}
+function getDeclarationErrorAddendum() {
+if (ReactCurrentOwner.current) {
+var name = getComponentName(ReactCurrentOwner.current.type);
+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.current) {
+// Give the component that originally created this child.
+childOwner = ' It was passed a child from ' + getComponentName(element._owner.type) + '.';
+}
+setCurrentlyValidatingElement(element);
+{
+warning$1(false, 'Each child in a list should have a unique "key" prop.' + '%s%s See https://fb.me/react-warning-keys for more information.', currentComponentErrorInfo, childOwner);
+}
+setCurrentlyValidatingElement(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 !== 'object') {
+return;
+}
+if (Array.isArray(node)) {
+for (var i = 0; i < node.length; i++) {
+var child = node[i];
+if (isValidElement(child)) {
+validateExplicitKey(child, parentType);
+}
+}
+} else if (isValidElement(node)) {
+// This element was passed in a valid location.
+if (node._store) {
+node._store.validated = true;
+}
+} else if (node) {
+var iteratorFn = getIteratorFn(node);
+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 = void 0;
+while (!(step = iterator.next()).done) {
+if (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 type = element.type;
+if (type === null || type === undefined || typeof type === 'string') {
+return;
+}
+var name = getComponentName(type);
+var propTypes = void 0;
+if (typeof type === 'function') {
+propTypes = type.propTypes;
+} else if (typeof type === 'object' && (type.$$typeof === REACT_FORWARD_REF_TYPE ||
+// Note: Memo only checks outer props here.
+// Inner props are checked in the reconciler.
+type.$$typeof === REACT_MEMO_TYPE)) {
+propTypes = type.propTypes;
+} else {
+return;
+}
+if (propTypes) {
+setCurrentlyValidatingElement(element);
+checkPropTypes_1(propTypes, element.props, 'prop', name, ReactDebugCurrentFrame.getStackAddendum);
+setCurrentlyValidatingElement(null);
+} else if (type.PropTypes !== undefined && !propTypesMisspellWarningShown) {
+propTypesMisspellWarningShown = true;
+warningWithoutStack$1(false, 'Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?', name || 'Unknown');
+}
+if (typeof type.getDefaultProps === 'function') {
+!type.getDefaultProps.isReactClassApproved ? warningWithoutStack$1(false, 'getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.') : void 0;
+}
+}
+/**
+* Given a fragment, validate that it can only be provided with fragment props
+* @param {ReactElement} fragment
+*/
+function validateFragmentProps(fragment) {
+setCurrentlyValidatingElement(fragment);
+var keys = Object.keys(fragment.props);
+for (var i = 0; i < keys.length; i++) {
+var key = keys[i];
+if (key !== 'children' && key !== 'key') {
+warning$1(false, 'Invalid prop `%s` supplied to `React.Fragment`. ' + 'React.Fragment can only have `key` and `children` props.', key);
+break;
+}
+}
+if (fragment.ref !== null) {
+warning$1(false, 'Invalid attribute `ref` supplied to `React.Fragment`.');
+}
+setCurrentlyValidatingElement(null);
+}
+function createElementWithValidation(type, props, children) {
+var validType = isValidElementType(type);
+// 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 === 'object' && type !== null && Object.keys(type).length === 0) {
+info += ' You likely forgot to export your component from the file ' + "it's defined in, or you might have mixed up default and named imports.";
+}
+var sourceInfo = getSourceInfoErrorAddendum(props);
+if (sourceInfo) {
+info += sourceInfo;
+} else {
+info += getDeclarationErrorAddendum();
+}
+var typeString = void 0;
+if (type === null) {
+typeString = 'null';
+} else if (Array.isArray(type)) {
+typeString = 'array';
+} else if (type !== undefined && type.$$typeof === REACT_ELEMENT_TYPE) {
+typeString = '<' + (getComponentName(type.type) || 'Unknown') + ' />';
+info = ' Did you accidentally export a JSX literal instead of a component?';
+} else {
+typeString = typeof type;
+}
+warning$1(false, 'React.createElement: type is invalid -- expected a string (for ' + 'built-in components) or a class/function (for composite ' + 'components) but got: %s.%s', typeString, info);
+}
+var element = 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);
+}
+}
+if (type === REACT_FRAGMENT_TYPE) {
+validateFragmentProps(element);
+} else {
+validatePropTypes(element);
+}
+return element;
+}
+function createFactoryWithValidation(type) {
+var validatedFactory = createElementWithValidation.bind(null, type);
+validatedFactory.type = type;
+// Legacy hook: remove it
+{
+Object.defineProperty(validatedFactory, 'type', {
+enumerable: false,
+get: function () {
+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;
+}
+function cloneElementWithValidation(element, props, children) {
+var newElement = cloneElement.apply(this, arguments);
+for (var i = 2; i < arguments.length; i++) {
+validateChildKeys(arguments[i], newElement.type);
+}
+validatePropTypes(newElement);
+return newElement;
+}
+var React = {
+Children: {
+map: mapChildren,
+forEach: forEachChildren,
+count: countChildren,
+toArray: toArray,
+only: onlyChild
+},
+createRef: createRef,
+Component: Component,
+PureComponent: PureComponent,
+createContext: createContext,
+forwardRef: forwardRef,
+lazy: lazy,
+memo: memo,
+useCallback: useCallback,
+useContext: useContext,
+useEffect: useEffect,
+useImperativeHandle: useImperativeHandle,
+useDebugValue: useDebugValue,
+useLayoutEffect: useLayoutEffect,
+useMemo: useMemo,
+useReducer: useReducer,
+useRef: useRef,
+useState: useState,
+Fragment: REACT_FRAGMENT_TYPE,
+StrictMode: REACT_STRICT_MODE_TYPE,
+Suspense: REACT_SUSPENSE_TYPE,
+createElement: createElementWithValidation,
+cloneElement: cloneElementWithValidation,
+createFactory: createFactoryWithValidation,
+isValidElement: isValidElement,
+version: ReactVersion,
+unstable_ConcurrentMode: REACT_CONCURRENT_MODE_TYPE,
+unstable_Profiler: REACT_PROFILER_TYPE,
+__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: ReactSharedInternals
+};
+// Note: some APIs are added with feature flags.
+// Make sure that stable builds for open source
+// don't modify the React object to avoid deopts.
+// Also let's not expose their names in stable builds.
+if (enableStableConcurrentModeAPIs) {
+React.ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
+React.Profiler = REACT_PROFILER_TYPE;
+React.unstable_ConcurrentMode = undefined;
+React.unstable_Profiler = undefined;
+}
+var React$2 = Object.freeze({
+	default: React
+});
+var React$3 = ( React$2 && React ) || React$2;
+// TODO: decide on the top-level export form.
+// This is hacky but makes it work with both Rollup and Jest.
+var react = React$3.default || React$3;
+return react;
+})));

enmi-conf.org