Smart Forms – when you need more than just a contact form / trunk

Smart Forms – when you need more than just a contact form vtrunk

smart-forms / js / utilities / react / react.js

react.js in Smart Forms – when you need more than just a contact form trunk, at js/utilities/react/react.js

3,155 lines 105.3 KB

Raw Download Zip

1	/** @license React v16.8.3
2	* react.development.js
3	*
4	* Copyright (c) Facebook, Inc. and its affiliates.
5	*
6	* This source code is licensed under the MIT license found in the
7	* LICENSE file in the root directory of this source tree.
8	*/
9
10	'use strict';
11
12	(function (global, factory) {
13	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
14	typeof define === 'function' && define.amd ? define(factory) :
15	(global.React = factory());
16	}(this, (function () { 'use strict';
17
18	// TODO: this is special because it gets imported during build.
19
20	var ReactVersion = '16.8.3';
21
22	// The Symbol used to tag the ReactElement-like types. If there is no native Symbol
23	// nor polyfill, then a plain number is used for performance.
24	var hasSymbol = typeof Symbol === 'function' && Symbol.for;
25
26	var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7;
27	var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for('react.portal') : 0xeaca;
28	var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for('react.fragment') : 0xeacb;
29	var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for('react.strict_mode') : 0xeacc;
30	var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2;
31	var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for('react.provider') : 0xeacd;
32	var REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for('react.context') : 0xeace;
33
34	var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for('react.concurrent_mode') : 0xeacf;
35	var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0;
36	var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for('react.suspense') : 0xead1;
37	var REACT_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3;
38	var REACT_LAZY_TYPE = hasSymbol ? Symbol.for('react.lazy') : 0xead4;
39
40	var MAYBE_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
41	var FAUX_ITERATOR_SYMBOL = '@@iterator';
42
43	function getIteratorFn(maybeIterable) {
44	if (maybeIterable === null \|\| typeof maybeIterable !== 'object') {
45	return null;
46	}
47	var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] \|\| maybeIterable[FAUX_ITERATOR_SYMBOL];
48	if (typeof maybeIterator === 'function') {
49	return maybeIterator;
50	}
51	return null;
52	}
53
54	/*
55	object-assign
56	(c) Sindre Sorhus
57	@license MIT
58	*/
59
60
61	/* eslint-disable no-unused-vars */
62	var getOwnPropertySymbols = Object.getOwnPropertySymbols;
63	var hasOwnProperty = Object.prototype.hasOwnProperty;
64	var propIsEnumerable = Object.prototype.propertyIsEnumerable;
65
66	function toObject(val) {
67	if (val === null \|\| val === undefined) {
68	throw new TypeError('Object.assign cannot be called with null or undefined');
69	}
70
71	return Object(val);
72	}
73
74	function shouldUseNative() {
75	try {
76	if (!Object.assign) {
77	return false;
78	}
79
80	// Detect buggy property enumeration order in older V8 versions.
81
82	// https://bugs.chromium.org/p/v8/issues/detail?id=4118
83	var test1 = new String('abc'); // eslint-disable-line no-new-wrappers
84	test1[5] = 'de';
85	if (Object.getOwnPropertyNames(test1)[0] === '5') {
86	return false;
87	}
88
89	// https://bugs.chromium.org/p/v8/issues/detail?id=3056
90	var test2 = {};
91	for (var i = 0; i < 10; i++) {
92	test2['_' + String.fromCharCode(i)] = i;
93	}
94	var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
95	return test2[n];
96	});
97	if (order2.join('') !== '0123456789') {
98	return false;
99	}
100
101	// https://bugs.chromium.org/p/v8/issues/detail?id=3056
102	var test3 = {};
103	'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
104	test3[letter] = letter;
105	});
106	if (Object.keys(Object.assign({}, test3)).join('') !==
107	'abcdefghijklmnopqrst') {
108	return false;
109	}
110
111	return true;
112	} catch (err) {
113	// We don't expect any of the above to throw, but better to be safe.
114	return false;
115	}
116	}
117
118	var objectAssign = shouldUseNative() ? Object.assign : function (target, source) {
119	var from;
120	var to = toObject(target);
121	var symbols;
122
123	for (var s = 1; s < arguments.length; s++) {
124	from = Object(arguments[s]);
125
126	for (var key in from) {
127	if (hasOwnProperty.call(from, key)) {
128	to[key] = from[key];
129	}
130	}
131
132	if (getOwnPropertySymbols) {
133	symbols = getOwnPropertySymbols(from);
134	for (var i = 0; i < symbols.length; i++) {
135	if (propIsEnumerable.call(from, symbols[i])) {
136	to[symbols[i]] = from[symbols[i]];
137	}
138	}
139	}
140	}
141
142	return to;
143	};
144
145	/**
146	* Use invariant() to assert state which your program assumes to be true.
147	*
148	* Provide sprintf-style format (only %s is supported) and arguments
149	* to provide information about what broke and what you were
150	* expecting.
151	*
152	* The invariant message will be stripped in production, but the invariant
153	* will remain to ensure logic does not differ in production.
154	*/
155
156	var validateFormat = function () {};
157
158	{
159	validateFormat = function (format) {
160	if (format === undefined) {
161	throw new Error('invariant requires an error message argument');
162	}
163	};
164	}
165
166	function invariant(condition, format, a, b, c, d, e, f) {
167	validateFormat(format);
168
169	if (!condition) {
170	var error = void 0;
171	if (format === undefined) {
172	error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');
173	} else {
174	var args = [a, b, c, d, e, f];
175	var argIndex = 0;
176	error = new Error(format.replace(/%s/g, function () {
177	return args[argIndex++];
178	}));
179	error.name = 'Invariant Violation';
180	}
181
182	error.framesToPop = 1; // we don't care about invariant's own frame
183	throw error;
184	}
185	}
186
187	// Relying on the `invariant()` implementation lets us
188	// preserve the format and params in the www builds.
189
190	/**
191	* Forked from fbjs/warning:
192	* https://github.com/facebook/fbjs/blob/e66ba20ad5be433eb54423f2b097d829324d9de6/packages/fbjs/src/__forks__/warning.js
193	*
194	* Only change is we use console.warn instead of console.error,
195	* and do nothing when 'console' is not supported.
196	* This really simplifies the code.
197	* ---
198	* Similar to invariant but only logs a warning if the condition is not met.
199	* This can be used to log issues in development environments in critical
200	* paths. Removing the logging code for production environments will keep the
201	* same logic and follow the same code paths.
202	*/
203
204	var lowPriorityWarning = function () {};
205
206	{
207	var printWarning = function (format) {
208	for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
209	args[_key - 1] = arguments[_key];
210	}
211
212	var argIndex = 0;
213	var message = 'Warning: ' + format.replace(/%s/g, function () {
214	return args[argIndex++];
215	});
216	if (typeof console !== 'undefined') {
217	console.warn(message);
218	}
219	try {
220	// --- Welcome to debugging React ---
221	// This error was thrown as a convenience so that you can use this stack
222	// to find the callsite that caused this warning to fire.
223	throw new Error(message);
224	} catch (x) {}
225	};
226
227	lowPriorityWarning = function (condition, format) {
228	if (format === undefined) {
229	throw new Error('`lowPriorityWarning(condition, format, ...args)` requires a warning ' + 'message argument');
230	}
231	if (!condition) {
232	for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
233	args[_key2 - 2] = arguments[_key2];
234	}
235
236	printWarning.apply(undefined, [format].concat(args));
237	}
238	};
239	}
240
241	var lowPriorityWarning$1 = lowPriorityWarning;
242
243	/**
244	* Similar to invariant but only logs a warning if the condition is not met.
245	* This can be used to log issues in development environments in critical
246	* paths. Removing the logging code for production environments will keep the
247	* same logic and follow the same code paths.
248	*/
249
250	var warningWithoutStack = function () {};
251
252	{
253	warningWithoutStack = function (condition, format) {
254	for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
255	args[_key - 2] = arguments[_key];
256	}
257
258	if (format === undefined) {
259	throw new Error('`warningWithoutStack(condition, format, ...args)` requires a warning ' + 'message argument');
260	}
261	if (args.length > 8) {
262	// Check before the condition to catch violations early.
263	throw new Error('warningWithoutStack() currently supports at most 8 arguments.');
264	}
265	if (condition) {
266	return;
267	}
268	if (typeof console !== 'undefined') {
269	var argsWithFormat = args.map(function (item) {
270	return '' + item;
271	});
272	argsWithFormat.unshift('Warning: ' + format);
273
274	// We intentionally don't use spread (or .apply) directly because it
275	// breaks IE9: https://github.com/facebook/react/issues/13610
276	Function.prototype.apply.call(console.error, console, argsWithFormat);
277	}
278	try {
279	// --- Welcome to debugging React ---
280	// This error was thrown as a convenience so that you can use this stack
281	// to find the callsite that caused this warning to fire.
282	var argIndex = 0;
283	var message = 'Warning: ' + format.replace(/%s/g, function () {
284	return args[argIndex++];
285	});
286	throw new Error(message);
287	} catch (x) {}
288	};
289	}
290
291	var warningWithoutStack$1 = warningWithoutStack;
292
293	var didWarnStateUpdateForUnmountedComponent = {};
294
295	function warnNoop(publicInstance, callerName) {
296	{
297	var _constructor = publicInstance.constructor;
298	var componentName = _constructor && (_constructor.displayName \|\| _constructor.name) \|\| 'ReactClass';
299	var warningKey = componentName + '.' + callerName;
300	if (didWarnStateUpdateForUnmountedComponent[warningKey]) {
301	return;
302	}
303	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);
304	didWarnStateUpdateForUnmountedComponent[warningKey] = true;
305	}
306	}
307
308	/**
309	* This is the abstract API for an update queue.
310	*/
311	var ReactNoopUpdateQueue = {
312	/**
313	* Checks whether or not this composite component is mounted.
314	* @param {ReactClass} publicInstance The instance we want to test.
315	* @return {boolean} True if mounted, false otherwise.
316	* @protected
317	* @final
318	*/
319	isMounted: function (publicInstance) {
320	return false;
321	},
322
323	/**
324	* Forces an update. This should only be invoked when it is known with
325	* certainty that we are not in a DOM transaction.
326	*
327	* You may want to call this when you know that some deeper aspect of the
328	* component's state has changed but `setState` was not called.
329	*
330	* This will not invoke `shouldComponentUpdate`, but it will invoke
331	* `componentWillUpdate` and `componentDidUpdate`.
332	*
333	* @param {ReactClass} publicInstance The instance that should rerender.
334	* @param {?function} callback Called after component is updated.
335	* @param {?string} callerName name of the calling function in the public API.
336	* @internal
337	*/
338	enqueueForceUpdate: function (publicInstance, callback, callerName) {
339	warnNoop(publicInstance, 'forceUpdate');
340	},
341
342	/**
343	* Replaces all of the state. Always use this or `setState` to mutate state.
344	* You should treat `this.state` as immutable.
345	*
346	* There is no guarantee that `this.state` will be immediately updated, so
347	* accessing `this.state` after calling this method may return the old value.
348	*
349	* @param {ReactClass} publicInstance The instance that should rerender.
350	* @param {object} completeState Next state.
351	* @param {?function} callback Called after component is updated.
352	* @param {?string} callerName name of the calling function in the public API.
353	* @internal
354	*/
355	enqueueReplaceState: function (publicInstance, completeState, callback, callerName) {
356	warnNoop(publicInstance, 'replaceState');
357	},
358
359	/**
360	* Sets a subset of the state. This only exists because _pendingState is
361	* internal. This provides a merging strategy that is not available to deep
362	* properties which is confusing. TODO: Expose pendingState or don't use it
363	* during the merge.
364	*
365	* @param {ReactClass} publicInstance The instance that should rerender.
366	* @param {object} partialState Next partial state to be merged with state.
367	* @param {?function} callback Called after component is updated.
368	* @param {?string} Name of the calling function in the public API.
369	* @internal
370	*/
371	enqueueSetState: function (publicInstance, partialState, callback, callerName) {
372	warnNoop(publicInstance, 'setState');
373	}
374	};
375
376	var emptyObject = {};
377	{
378	Object.freeze(emptyObject);
379	}
380
381	/**
382	* Base class helpers for the updating state of a component.
383	*/
384	function Component(props, context, updater) {
385	this.props = props;
386	this.context = context;
387	// If a component has string refs, we will assign a different object later.
388	this.refs = emptyObject;
389	// We initialize the default updater but the real one gets injected by the
390	// renderer.
391	this.updater = updater \|\| ReactNoopUpdateQueue;
392	}
393
394	Component.prototype.isReactComponent = {};
395
396	/**
397	* Sets a subset of the state. Always use this to mutate
398	* state. You should treat `this.state` as immutable.
399	*
400	* There is no guarantee that `this.state` will be immediately updated, so
401	* accessing `this.state` after calling this method may return the old value.
402	*
403	* There is no guarantee that calls to `setState` will run synchronously,
404	* as they may eventually be batched together. You can provide an optional
405	* callback that will be executed when the call to setState is actually
406	* completed.
407	*
408	* When a function is provided to setState, it will be called at some point in
409	* the future (not synchronously). It will be called with the up to date
410	* component arguments (state, props, context). These values can be different
411	* from this.* because your function may be called after receiveProps but before
412	* shouldComponentUpdate, and this new state, props, and context will not yet be
413	* assigned to this.
414	*
415	* @param {object\|function} partialState Next partial state or function to
416	* produce next partial state to be merged with current state.
417	* @param {?function} callback Called after state is updated.
418	* @final
419	* @protected
420	*/
421	Component.prototype.setState = function (partialState, callback) {
422	!(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;
423	this.updater.enqueueSetState(this, partialState, callback, 'setState');
424	};
425
426	/**
427	* Forces an update. This should only be invoked when it is known with
428	* certainty that we are not in a DOM transaction.
429	*
430	* You may want to call this when you know that some deeper aspect of the
431	* component's state has changed but `setState` was not called.
432	*
433	* This will not invoke `shouldComponentUpdate`, but it will invoke
434	* `componentWillUpdate` and `componentDidUpdate`.
435	*
436	* @param {?function} callback Called after update is complete.
437	* @final
438	* @protected
439	*/
440	Component.prototype.forceUpdate = function (callback) {
441	this.updater.enqueueForceUpdate(this, callback, 'forceUpdate');
442	};
443
444	/**
445	* Deprecated APIs. These APIs used to exist on classic React classes but since
446	* we would like to deprecate them, we're not going to move them over to this
447	* modern base class. Instead, we define a getter that warns if it's accessed.
448	*/
449	{
450	var deprecatedAPIs = {
451	isMounted: ['isMounted', 'Instead, make sure to clean up subscriptions and pending requests in ' + 'componentWillUnmount to prevent memory leaks.'],
452	replaceState: ['replaceState', 'Refactor your code to use setState instead (see ' + 'https://github.com/facebook/react/issues/3236).']
453	};
454	var defineDeprecationWarning = function (methodName, info) {
455	Object.defineProperty(Component.prototype, methodName, {
456	get: function () {
457	lowPriorityWarning$1(false, '%s(...) is deprecated in plain JavaScript React classes. %s', info[0], info[1]);
458	return undefined;
459	}
460	});
461	};
462	for (var fnName in deprecatedAPIs) {
463	if (deprecatedAPIs.hasOwnProperty(fnName)) {
464	defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);
465	}
466	}
467	}
468
469	function ComponentDummy() {}
470	ComponentDummy.prototype = Component.prototype;
471
472	/**
473	* Convenience component with default shallow equality check for sCU.
474	*/
475	function PureComponent(props, context, updater) {
476	this.props = props;
477	this.context = context;
478	// If a component has string refs, we will assign a different object later.
479	this.refs = emptyObject;
480	this.updater = updater \|\| ReactNoopUpdateQueue;
481	}
482
483	var pureComponentPrototype = PureComponent.prototype = new ComponentDummy();
484	pureComponentPrototype.constructor = PureComponent;
485	// Avoid an extra prototype jump for these methods.
486	objectAssign(pureComponentPrototype, Component.prototype);
487	pureComponentPrototype.isPureReactComponent = true;
488
489	// an immutable object with a single mutable value
490	function createRef() {
491	var refObject = {
492	current: null
493	};
494	{
495	Object.seal(refObject);
496	}
497	return refObject;
498	}
499
500	var enableSchedulerDebugging = false;
501
502	/* eslint-disable no-var */
503
504	// TODO: Use symbols?
505	var ImmediatePriority = 1;
506	var UserBlockingPriority = 2;
507	var NormalPriority = 3;
508	var LowPriority = 4;
509	var IdlePriority = 5;
510
511	// Max 31 bit integer. The max integer size in V8 for 32-bit systems.
512	// Math.pow(2, 30) - 1
513	// 0b111111111111111111111111111111
514	var maxSigned31BitInt = 1073741823;
515
516	// Times out immediately
517	var IMMEDIATE_PRIORITY_TIMEOUT = -1;
518	// Eventually times out
519	var USER_BLOCKING_PRIORITY = 250;
520	var NORMAL_PRIORITY_TIMEOUT = 5000;
521	var LOW_PRIORITY_TIMEOUT = 10000;
522	// Never times out
523	var IDLE_PRIORITY = maxSigned31BitInt;
524
525	// Callbacks are stored as a circular, doubly linked list.
526	var firstCallbackNode = null;
527
528	var currentDidTimeout = false;
529	// Pausing the scheduler is useful for debugging.
530	var isSchedulerPaused = false;
531
532	var currentPriorityLevel = NormalPriority;
533	var currentEventStartTime = -1;
534	var currentExpirationTime = -1;
535
536	// This is set when a callback is being executed, to prevent re-entrancy.
537	var isExecutingCallback = false;
538
539	var isHostCallbackScheduled = false;
540
541	var hasNativePerformanceNow = typeof performance === 'object' && typeof performance.now === 'function';
542
543	function ensureHostCallbackIsScheduled() {
544	if (isExecutingCallback) {
545	// Don't schedule work yet; wait until the next time we yield.
546	return;
547	}
548	// Schedule the host callback using the earliest expiration in the list.
549	var expirationTime = firstCallbackNode.expirationTime;
550	if (!isHostCallbackScheduled) {
551	isHostCallbackScheduled = true;
552	} else {
553	// Cancel the existing host callback.
554	cancelHostCallback();
555	}
556	requestHostCallback(flushWork, expirationTime);
557	}
558
559	function flushFirstCallback() {
560	var flushedNode = firstCallbackNode;
561
562	// Remove the node from the list before calling the callback. That way the
563	// list is in a consistent state even if the callback throws.
564	var next = firstCallbackNode.next;
565	if (firstCallbackNode === next) {
566	// This is the last callback in the list.
567	firstCallbackNode = null;
568	next = null;
569	} else {
570	var lastCallbackNode = firstCallbackNode.previous;
571	firstCallbackNode = lastCallbackNode.next = next;
572	next.previous = lastCallbackNode;
573	}
574
575	flushedNode.next = flushedNode.previous = null;
576
577	// Now it's safe to call the callback.
578	var callback = flushedNode.callback;
579	var expirationTime = flushedNode.expirationTime;
580	var priorityLevel = flushedNode.priorityLevel;
581	var previousPriorityLevel = currentPriorityLevel;
582	var previousExpirationTime = currentExpirationTime;
583	currentPriorityLevel = priorityLevel;
584	currentExpirationTime = expirationTime;
585	var continuationCallback;
586	try {
587	continuationCallback = callback();
588	} finally {
589	currentPriorityLevel = previousPriorityLevel;
590	currentExpirationTime = previousExpirationTime;
591	}
592
593	// A callback may return a continuation. The continuation should be scheduled
594	// with the same priority and expiration as the just-finished callback.
595	if (typeof continuationCallback === 'function') {
596	var continuationNode = {
597	callback: continuationCallback,
598	priorityLevel: priorityLevel,
599	expirationTime: expirationTime,
600	next: null,
601	previous: null
602	};
603
604	// Insert the new callback into the list, sorted by its expiration. This is
605	// almost the same as the code in `scheduleCallback`, except the callback
606	// is inserted into the list before callbacks of equal expiration instead
607	// of after.
608	if (firstCallbackNode === null) {
609	// This is the first callback in the list.
610	firstCallbackNode = continuationNode.next = continuationNode.previous = continuationNode;
611	} else {
612	var nextAfterContinuation = null;
613	var node = firstCallbackNode;
614	do {
615	if (node.expirationTime >= expirationTime) {
616	// This callback expires at or after the continuation. We will insert
617	// the continuation before this callback.
618	nextAfterContinuation = node;
619	break;
620	}
621	node = node.next;
622	} while (node !== firstCallbackNode);
623
624	if (nextAfterContinuation === null) {
625	// No equal or lower priority callback was found, which means the new
626	// callback is the lowest priority callback in the list.
627	nextAfterContinuation = firstCallbackNode;
628	} else if (nextAfterContinuation === firstCallbackNode) {
629	// The new callback is the highest priority callback in the list.
630	firstCallbackNode = continuationNode;
631	ensureHostCallbackIsScheduled();
632	}
633
634	var previous = nextAfterContinuation.previous;
635	previous.next = nextAfterContinuation.previous = continuationNode;
636	continuationNode.next = nextAfterContinuation;
637	continuationNode.previous = previous;
638	}
639	}
640	}
641
642	function flushImmediateWork() {
643	if (
644	// Confirm we've exited the outer most event handler
645	currentEventStartTime === -1 && firstCallbackNode !== null && firstCallbackNode.priorityLevel === ImmediatePriority) {
646	isExecutingCallback = true;
647	try {
648	do {
649	flushFirstCallback();
650	} while (
651	// Keep flushing until there are no more immediate callbacks
652	firstCallbackNode !== null && firstCallbackNode.priorityLevel === ImmediatePriority);
653	} finally {
654	isExecutingCallback = false;
655	if (firstCallbackNode !== null) {
656	// There's still work remaining. Request another callback.
657	ensureHostCallbackIsScheduled();
658	} else {
659	isHostCallbackScheduled = false;
660	}
661	}
662	}
663	}
664
665	function flushWork(didTimeout) {
666	// Exit right away if we're currently paused
667
668	if (enableSchedulerDebugging && isSchedulerPaused) {
669	return;
670	}
671
672	isExecutingCallback = true;
673	var previousDidTimeout = currentDidTimeout;
674	currentDidTimeout = didTimeout;
675	try {
676	if (didTimeout) {
677	// Flush all the expired callbacks without yielding.
678	while (firstCallbackNode !== null && !(enableSchedulerDebugging && isSchedulerPaused)) {
679	// TODO Wrap in feature flag
680	// Read the current time. Flush all the callbacks that expire at or
681	// earlier than that time. Then read the current time again and repeat.
682	// This optimizes for as few performance.now calls as possible.
683	var currentTime = getCurrentTime();
684	if (firstCallbackNode.expirationTime <= currentTime) {
685	do {
686	flushFirstCallback();
687	} while (firstCallbackNode !== null && firstCallbackNode.expirationTime <= currentTime && !(enableSchedulerDebugging && isSchedulerPaused));
688	continue;
689	}
690	break;
691	}
692	} else {
693	// Keep flushing callbacks until we run out of time in the frame.
694	if (firstCallbackNode !== null) {
695	do {
696	if (enableSchedulerDebugging && isSchedulerPaused) {
697	break;
698	}
699	flushFirstCallback();
700	} while (firstCallbackNode !== null && !shouldYieldToHost());
701	}
702	}
703	} finally {
704	isExecutingCallback = false;
705	currentDidTimeout = previousDidTimeout;
706	if (firstCallbackNode !== null) {
707	// There's still work remaining. Request another callback.
708	ensureHostCallbackIsScheduled();
709	} else {
710	isHostCallbackScheduled = false;
711	}
712	// Before exiting, flush all the immediate work that was scheduled.
713	flushImmediateWork();
714	}
715	}
716
717	function unstable_runWithPriority(priorityLevel, eventHandler) {
718	switch (priorityLevel) {
719	case ImmediatePriority:
720	case UserBlockingPriority:
721	case NormalPriority:
722	case LowPriority:
723	case IdlePriority:
724	break;
725	default:
726	priorityLevel = NormalPriority;
727	}
728
729	var previousPriorityLevel = currentPriorityLevel;
730	var previousEventStartTime = currentEventStartTime;
731	currentPriorityLevel = priorityLevel;
732	currentEventStartTime = getCurrentTime();
733
734	try {
735	return eventHandler();
736	} finally {
737	currentPriorityLevel = previousPriorityLevel;
738	currentEventStartTime = previousEventStartTime;
739
740	// Before exiting, flush all the immediate work that was scheduled.
741	flushImmediateWork();
742	}
743	}
744
745	function unstable_next(eventHandler) {
746	var priorityLevel = void 0;
747	switch (currentPriorityLevel) {
748	case ImmediatePriority:
749	case UserBlockingPriority:
750	case NormalPriority:
751	// Shift down to normal priority
752	priorityLevel = NormalPriority;
753	break;
754	default:
755	// Anything lower than normal priority should remain at the current level.
756	priorityLevel = currentPriorityLevel;
757	break;
758	}
759
760	var previousPriorityLevel = currentPriorityLevel;
761	var previousEventStartTime = currentEventStartTime;
762	currentPriorityLevel = priorityLevel;
763	currentEventStartTime = getCurrentTime();
764
765	try {
766	return eventHandler();
767	} finally {
768	currentPriorityLevel = previousPriorityLevel;
769	currentEventStartTime = previousEventStartTime;
770
771	// Before exiting, flush all the immediate work that was scheduled.
772	flushImmediateWork();
773	}
774	}
775
776	function unstable_wrapCallback(callback) {
777	var parentPriorityLevel = currentPriorityLevel;
778	return function () {
779	// This is a fork of runWithPriority, inlined for performance.
780	var previousPriorityLevel = currentPriorityLevel;
781	var previousEventStartTime = currentEventStartTime;
782	currentPriorityLevel = parentPriorityLevel;
783	currentEventStartTime = getCurrentTime();
784
785	try {
786	return callback.apply(this, arguments);
787	} finally {
788	currentPriorityLevel = previousPriorityLevel;
789	currentEventStartTime = previousEventStartTime;
790	flushImmediateWork();
791	}
792	};
793	}
794
795	function unstable_scheduleCallback(callback, deprecated_options) {
796	var startTime = currentEventStartTime !== -1 ? currentEventStartTime : getCurrentTime();
797
798	var expirationTime;
799	if (typeof deprecated_options === 'object' && deprecated_options !== null && typeof deprecated_options.timeout === 'number') {
800	// FIXME: Remove this branch once we lift expiration times out of React.
801	expirationTime = startTime + deprecated_options.timeout;
802	} else {
803	switch (currentPriorityLevel) {
804	case ImmediatePriority:
805	expirationTime = startTime + IMMEDIATE_PRIORITY_TIMEOUT;
806	break;
807	case UserBlockingPriority:
808	expirationTime = startTime + USER_BLOCKING_PRIORITY;
809	break;
810	case IdlePriority:
811	expirationTime = startTime + IDLE_PRIORITY;
812	break;
813	case LowPriority:
814	expirationTime = startTime + LOW_PRIORITY_TIMEOUT;
815	break;
816	case NormalPriority:
817	default:
818	expirationTime = startTime + NORMAL_PRIORITY_TIMEOUT;
819	}
820	}
821
822	var newNode = {
823	callback: callback,
824	priorityLevel: currentPriorityLevel,
825	expirationTime: expirationTime,
826	next: null,
827	previous: null
828	};
829
830	// Insert the new callback into the list, ordered first by expiration, then
831	// by insertion. So the new callback is inserted any other callback with
832	// equal expiration.
833	if (firstCallbackNode === null) {
834	// This is the first callback in the list.
835	firstCallbackNode = newNode.next = newNode.previous = newNode;
836	ensureHostCallbackIsScheduled();
837	} else {
838	var next = null;
839	var node = firstCallbackNode;
840	do {
841	if (node.expirationTime > expirationTime) {
842	// The new callback expires before this one.
843	next = node;
844	break;
845	}
846	node = node.next;
847	} while (node !== firstCallbackNode);
848
849	if (next === null) {
850	// No callback with a later expiration was found, which means the new
851	// callback has the latest expiration in the list.
852	next = firstCallbackNode;
853	} else if (next === firstCallbackNode) {
854	// The new callback has the earliest expiration in the entire list.
855	firstCallbackNode = newNode;
856	ensureHostCallbackIsScheduled();
857	}
858
859	var previous = next.previous;
860	previous.next = next.previous = newNode;
861	newNode.next = next;
862	newNode.previous = previous;
863	}
864
865	return newNode;
866	}
867
868	function unstable_pauseExecution() {
869	isSchedulerPaused = true;
870	}
871
872	function unstable_continueExecution() {
873	isSchedulerPaused = false;
874	if (firstCallbackNode !== null) {
875	ensureHostCallbackIsScheduled();
876	}
877	}
878
879	function unstable_getFirstCallbackNode() {
880	return firstCallbackNode;
881	}
882
883	function unstable_cancelCallback(callbackNode) {
884	var next = callbackNode.next;
885	if (next === null) {
886	// Already cancelled.
887	return;
888	}
889
890	if (next === callbackNode) {
891	// This is the only scheduled callback. Clear the list.
892	firstCallbackNode = null;
893	} else {
894	// Remove the callback from its position in the list.
895	if (callbackNode === firstCallbackNode) {
896	firstCallbackNode = next;
897	}
898	var previous = callbackNode.previous;
899	previous.next = next;
900	next.previous = previous;
901	}
902
903	callbackNode.next = callbackNode.previous = null;
904	}
905
906	function unstable_getCurrentPriorityLevel() {
907	return currentPriorityLevel;
908	}
909
910	function unstable_shouldYield() {
911	return !currentDidTimeout && (firstCallbackNode !== null && firstCallbackNode.expirationTime < currentExpirationTime \|\| shouldYieldToHost());
912	}
913
914	// The remaining code is essentially a polyfill for requestIdleCallback. It
915	// works by scheduling a requestAnimationFrame, storing the time for the start
916	// of the frame, then scheduling a postMessage which gets scheduled after paint.
917	// Within the postMessage handler do as much work as possible until time + frame
918	// rate. By separating the idle call into a separate event tick we ensure that
919	// layout, paint and other browser work is counted against the available time.
920	// The frame rate is dynamically adjusted.
921
922	// We capture a local reference to any global, in case it gets polyfilled after
923	// this module is initially evaluated. We want to be using a
924	// consistent implementation.
925	var localDate = Date;
926
927	// This initialization code may run even on server environments if a component
928	// just imports ReactDOM (e.g. for findDOMNode). Some environments might not
929	// have setTimeout or clearTimeout. However, we always expect them to be defined
930	// on the client. https://github.com/facebook/react/pull/13088
931	var localSetTimeout = typeof setTimeout === 'function' ? setTimeout : undefined;
932	var localClearTimeout = typeof clearTimeout === 'function' ? clearTimeout : undefined;
933
934	// We don't expect either of these to necessarily be defined, but we will error
935	// later if they are missing on the client.
936	var localRequestAnimationFrame = typeof requestAnimationFrame === 'function' ? requestAnimationFrame : undefined;
937	var localCancelAnimationFrame = typeof cancelAnimationFrame === 'function' ? cancelAnimationFrame : undefined;
938
939	var getCurrentTime;
940
941	// requestAnimationFrame does not run when the tab is in the background. If
942	// we're backgrounded we prefer for that work to happen so that the page
943	// continues to load in the background. So we also schedule a 'setTimeout' as
944	// a fallback.
945	// TODO: Need a better heuristic for backgrounded work.
946	var ANIMATION_FRAME_TIMEOUT = 100;
947	var rAFID;
948	var rAFTimeoutID;
949	var requestAnimationFrameWithTimeout = function (callback) {
950	// schedule rAF and also a setTimeout
951	rAFID = localRequestAnimationFrame(function (timestamp) {
952	// cancel the setTimeout
953	localClearTimeout(rAFTimeoutID);
954	callback(timestamp);
955	});
956	rAFTimeoutID = localSetTimeout(function () {
957	// cancel the requestAnimationFrame
958	localCancelAnimationFrame(rAFID);
959	callback(getCurrentTime());
960	}, ANIMATION_FRAME_TIMEOUT);
961	};
962
963	if (hasNativePerformanceNow) {
964	var Performance = performance;
965	getCurrentTime = function () {
966	return Performance.now();
967	};
968	} else {
969	getCurrentTime = function () {
970	return localDate.now();
971	};
972	}
973
974	var requestHostCallback;
975	var cancelHostCallback;
976	var shouldYieldToHost;
977
978	var globalValue = null;
979	if (typeof window !== 'undefined') {
980	globalValue = window;
981	} else if (typeof global !== 'undefined') {
982	globalValue = global;
983	}
984
985	if (globalValue && globalValue._schedMock) {
986	// Dynamic injection, only for testing purposes.
987	var globalImpl = globalValue._schedMock;
988	requestHostCallback = globalImpl[0];
989	cancelHostCallback = globalImpl[1];
990	shouldYieldToHost = globalImpl[2];
991	getCurrentTime = globalImpl[3];
992	} else if (
993	// If Scheduler runs in a non-DOM environment, it falls back to a naive
994	// implementation using setTimeout.
995	typeof window === 'undefined' \|\|
996	// Check if MessageChannel is supported, too.
997	typeof MessageChannel !== 'function') {
998	// If this accidentally gets imported in a non-browser environment, e.g. JavaScriptCore,
999	// fallback to a naive implementation.
1000	var _callback = null;
1001	var _flushCallback = function (didTimeout) {
1002	if (_callback !== null) {
1003	try {
1004	_callback(didTimeout);
1005	} finally {
1006	_callback = null;
1007	}
1008	}
1009	};
1010	requestHostCallback = function (cb, ms) {
1011	if (_callback !== null) {
1012	// Protect against re-entrancy.
1013	setTimeout(requestHostCallback, 0, cb);
1014	} else {
1015	_callback = cb;
1016	setTimeout(_flushCallback, 0, false);
1017	}
1018	};
1019	cancelHostCallback = function () {
1020	_callback = null;
1021	};
1022	shouldYieldToHost = function () {
1023	return false;
1024	};
1025	} else {
1026	if (typeof console !== 'undefined') {
1027	// TODO: Remove fb.me link
1028	if (typeof localRequestAnimationFrame !== 'function') {
1029	console.error("This browser doesn't support requestAnimationFrame. " + 'Make sure that you load a ' + 'polyfill in older browsers. https://fb.me/react-polyfills');
1030	}
1031	if (typeof localCancelAnimationFrame !== 'function') {
1032	console.error("This browser doesn't support cancelAnimationFrame. " + 'Make sure that you load a ' + 'polyfill in older browsers. https://fb.me/react-polyfills');
1033	}
1034	}
1035
1036	var scheduledHostCallback = null;
1037	var isMessageEventScheduled = false;
1038	var timeoutTime = -1;
1039
1040	var isAnimationFrameScheduled = false;
1041
1042	var isFlushingHostCallback = false;
1043
1044	var frameDeadline = 0;
1045	// We start out assuming that we run at 30fps but then the heuristic tracking
1046	// will adjust this value to a faster fps if we get more frequent animation
1047	// frames.
1048	var previousFrameTime = 33;
1049	var activeFrameTime = 33;
1050
1051	shouldYieldToHost = function () {
1052	return frameDeadline <= getCurrentTime();
1053	};
1054
1055	// We use the postMessage trick to defer idle work until after the repaint.
1056	var channel = new MessageChannel();
1057	var port = channel.port2;
1058	channel.port1.onmessage = function (event) {
1059	isMessageEventScheduled = false;
1060
1061	var prevScheduledCallback = scheduledHostCallback;
1062	var prevTimeoutTime = timeoutTime;
1063	scheduledHostCallback = null;
1064	timeoutTime = -1;
1065
1066	var currentTime = getCurrentTime();
1067
1068	var didTimeout = false;
1069	if (frameDeadline - currentTime <= 0) {
1070	// There's no time left in this idle period. Check if the callback has
1071	// a timeout and whether it's been exceeded.
1072	if (prevTimeoutTime !== -1 && prevTimeoutTime <= currentTime) {
1073	// Exceeded the timeout. Invoke the callback even though there's no
1074	// time left.
1075	didTimeout = true;
1076	} else {
1077	// No timeout.
1078	if (!isAnimationFrameScheduled) {
1079	// Schedule another animation callback so we retry later.
1080	isAnimationFrameScheduled = true;
1081	requestAnimationFrameWithTimeout(animationTick);
1082	}
1083	// Exit without invoking the callback.
1084	scheduledHostCallback = prevScheduledCallback;
1085	timeoutTime = prevTimeoutTime;
1086	return;
1087	}
1088	}
1089
1090	if (prevScheduledCallback !== null) {
1091	isFlushingHostCallback = true;
1092	try {
1093	prevScheduledCallback(didTimeout);
1094	} finally {
1095	isFlushingHostCallback = false;
1096	}
1097	}
1098	};
1099
1100	var animationTick = function (rafTime) {
1101	if (scheduledHostCallback !== null) {
1102	// Eagerly schedule the next animation callback at the beginning of the
1103	// frame. If the scheduler queue is not empty at the end of the frame, it
1104	// will continue flushing inside that callback. If the queue is empty,
1105	// then it will exit immediately. Posting the callback at the start of the
1106	// frame ensures it's fired within the earliest possible frame. If we
1107	// waited until the end of the frame to post the callback, we risk the
1108	// browser skipping a frame and not firing the callback until the frame
1109	// after that.
1110	requestAnimationFrameWithTimeout(animationTick);
1111	} else {
1112	// No pending work. Exit.
1113	isAnimationFrameScheduled = false;
1114	return;
1115	}
1116
1117	var nextFrameTime = rafTime - frameDeadline + activeFrameTime;
1118	if (nextFrameTime < activeFrameTime && previousFrameTime < activeFrameTime) {
1119	if (nextFrameTime < 8) {
1120	// Defensive coding. We don't support higher frame rates than 120hz.
1121	// If the calculated frame time gets lower than 8, it is probably a bug.
1122	nextFrameTime = 8;
1123	}
1124	// If one frame goes long, then the next one can be short to catch up.
1125	// If two frames are short in a row, then that's an indication that we
1126	// actually have a higher frame rate than what we're currently optimizing.
1127	// We adjust our heuristic dynamically accordingly. For example, if we're
1128	// running on 120hz display or 90hz VR display.
1129	// Take the max of the two in case one of them was an anomaly due to
1130	// missed frame deadlines.
1131	activeFrameTime = nextFrameTime < previousFrameTime ? previousFrameTime : nextFrameTime;
1132	} else {
1133	previousFrameTime = nextFrameTime;
1134	}
1135	frameDeadline = rafTime + activeFrameTime;
1136	if (!isMessageEventScheduled) {
1137	isMessageEventScheduled = true;
1138	port.postMessage(undefined);
1139	}
1140	};
1141
1142	requestHostCallback = function (callback, absoluteTimeout) {
1143	scheduledHostCallback = callback;
1144	timeoutTime = absoluteTimeout;
1145	if (isFlushingHostCallback \|\| absoluteTimeout < 0) {
1146	// Don't wait for the next frame. Continue working ASAP, in a new event.
1147	port.postMessage(undefined);
1148	} else if (!isAnimationFrameScheduled) {
1149	// If rAF didn't already schedule one, we need to schedule a frame.
1150	// TODO: If this rAF doesn't materialize because the browser throttles, we
1151	// might want to still have setTimeout trigger rIC as a backup to ensure
1152	// that we keep performing work.
1153	isAnimationFrameScheduled = true;
1154	requestAnimationFrameWithTimeout(animationTick);
1155	}
1156	};
1157
1158	cancelHostCallback = function () {
1159	scheduledHostCallback = null;
1160	isMessageEventScheduled = false;
1161	timeoutTime = -1;
1162	};
1163	}
1164
1165	// Helps identify side effects in begin-phase lifecycle hooks and setState reducers:
1166
1167
1168	// In some cases, StrictMode should also double-render lifecycles.
1169	// This can be confusing for tests though,
1170	// And it can be bad for performance in production.
1171	// This feature flag can be used to control the behavior:
1172
1173
1174	// To preserve the "Pause on caught exceptions" behavior of the debugger, we
1175	// replay the begin phase of a failed component inside invokeGuardedCallback.
1176
1177
1178	// Warn about deprecated, async-unsafe lifecycles; relates to RFC #6:
1179
1180
1181	// Gather advanced timing metrics for Profiler subtrees.
1182
1183
1184	// Trace which interactions trigger each commit.
1185	var enableSchedulerTracing = true;
1186
1187	// Only used in www builds.
1188	// TODO: true? Here it might just be false.
1189
1190	// Only used in www builds.
1191
1192
1193	// Only used in www builds.
1194
1195
1196	// React Fire: prevent the value and checked attributes from syncing
1197	// with their related DOM properties
1198
1199
1200	// These APIs will no longer be "unstable" in the upcoming 16.7 release,
1201	// Control this behavior with a flag to support 16.6 minor releases in the meanwhile.
1202	var enableStableConcurrentModeAPIs = false;
1203
1204	var DEFAULT_THREAD_ID = 0;
1205
1206	// Counters used to generate unique IDs.
1207	var interactionIDCounter = 0;
1208	var threadIDCounter = 0;
1209
1210	// Set of currently traced interactions.
1211	// Interactions "stack"–
1212	// Meaning that newly traced interactions are appended to the previously active set.
1213	// When an interaction goes out of scope, the previous set (if any) is restored.
1214	var interactionsRef = null;
1215
1216	// Listener(s) to notify when interactions begin and end.
1217	var subscriberRef = null;
1218
1219	if (enableSchedulerTracing) {
1220	interactionsRef = {
1221	current: new Set()
1222	};
1223	subscriberRef = {
1224	current: null
1225	};
1226	}
1227
1228	function unstable_clear(callback) {
1229	if (!enableSchedulerTracing) {
1230	return callback();
1231	}
1232
1233	var prevInteractions = interactionsRef.current;
1234	interactionsRef.current = new Set();
1235
1236	try {
1237	return callback();
1238	} finally {
1239	interactionsRef.current = prevInteractions;
1240	}
1241	}
1242
1243	function unstable_getCurrent() {
1244	if (!enableSchedulerTracing) {
1245	return null;
1246	} else {
1247	return interactionsRef.current;
1248	}
1249	}
1250
1251	function unstable_getThreadID() {
1252	return ++threadIDCounter;
1253	}
1254
1255	function unstable_trace(name, timestamp, callback) {
1256	var threadID = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : DEFAULT_THREAD_ID;
1257
1258	if (!enableSchedulerTracing) {
1259	return callback();
1260	}
1261
1262	var interaction = {
1263	__count: 1,
1264	id: interactionIDCounter++,
1265	name: name,
1266	timestamp: timestamp
1267	};
1268
1269	var prevInteractions = interactionsRef.current;
1270
1271	// Traced interactions should stack/accumulate.
1272	// To do that, clone the current interactions.
1273	// The previous set will be restored upon completion.
1274	var interactions = new Set(prevInteractions);
1275	interactions.add(interaction);
1276	interactionsRef.current = interactions;
1277
1278	var subscriber = subscriberRef.current;
1279	var returnValue = void 0;
1280
1281	try {
1282	if (subscriber !== null) {
1283	subscriber.onInteractionTraced(interaction);
1284	}
1285	} finally {
1286	try {
1287	if (subscriber !== null) {
1288	subscriber.onWorkStarted(interactions, threadID);
1289	}
1290	} finally {
1291	try {
1292	returnValue = callback();
1293	} finally {
1294	interactionsRef.current = prevInteractions;
1295
1296	try {
1297	if (subscriber !== null) {
1298	subscriber.onWorkStopped(interactions, threadID);
1299	}
1300	} finally {
1301	interaction.__count--;
1302
1303	// If no async work was scheduled for this interaction,
1304	// Notify subscribers that it's completed.
1305	if (subscriber !== null && interaction.__count === 0) {
1306	subscriber.onInteractionScheduledWorkCompleted(interaction);
1307	}
1308	}
1309	}
1310	}
1311	}
1312
1313	return returnValue;
1314	}
1315
1316	function unstable_wrap(callback) {
1317	var threadID = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : DEFAULT_THREAD_ID;
1318
1319	if (!enableSchedulerTracing) {
1320	return callback;
1321	}
1322
1323	var wrappedInteractions = interactionsRef.current;
1324
1325	var subscriber = subscriberRef.current;
1326	if (subscriber !== null) {
1327	subscriber.onWorkScheduled(wrappedInteractions, threadID);
1328	}
1329
1330	// Update the pending async work count for the current interactions.
1331	// Update after calling subscribers in case of error.
1332	wrappedInteractions.forEach(function (interaction) {
1333	interaction.__count++;
1334	});
1335
1336	var hasRun = false;
1337
1338	function wrapped() {
1339	var prevInteractions = interactionsRef.current;
1340	interactionsRef.current = wrappedInteractions;
1341
1342	subscriber = subscriberRef.current;
1343
1344	try {
1345	var returnValue = void 0;
1346
1347	try {
1348	if (subscriber !== null) {
1349	subscriber.onWorkStarted(wrappedInteractions, threadID);
1350	}
1351	} finally {
1352	try {
1353	returnValue = callback.apply(undefined, arguments);
1354	} finally {
1355	interactionsRef.current = prevInteractions;
1356
1357	if (subscriber !== null) {
1358	subscriber.onWorkStopped(wrappedInteractions, threadID);
1359	}
1360	}
1361	}
1362
1363	return returnValue;
1364	} finally {
1365	if (!hasRun) {
1366	// We only expect a wrapped function to be executed once,
1367	// But in the event that it's executed more than once–
1368	// Only decrement the outstanding interaction counts once.
1369	hasRun = true;
1370
1371	// Update pending async counts for all wrapped interactions.
1372	// If this was the last scheduled async work for any of them,
1373	// Mark them as completed.
1374	wrappedInteractions.forEach(function (interaction) {
1375	interaction.__count--;
1376
1377	if (subscriber !== null && interaction.__count === 0) {
1378	subscriber.onInteractionScheduledWorkCompleted(interaction);
1379	}
1380	});
1381	}
1382	}
1383	}
1384
1385	wrapped.cancel = function cancel() {
1386	subscriber = subscriberRef.current;
1387
1388	try {
1389	if (subscriber !== null) {
1390	subscriber.onWorkCanceled(wrappedInteractions, threadID);
1391	}
1392	} finally {
1393	// Update pending async counts for all wrapped interactions.
1394	// If this was the last scheduled async work for any of them,
1395	// Mark them as completed.
1396	wrappedInteractions.forEach(function (interaction) {
1397	interaction.__count--;
1398
1399	if (subscriber && interaction.__count === 0) {
1400	subscriber.onInteractionScheduledWorkCompleted(interaction);
1401	}
1402	});
1403	}
1404	};
1405
1406	return wrapped;
1407	}
1408
1409	var subscribers = null;
1410	if (enableSchedulerTracing) {
1411	subscribers = new Set();
1412	}
1413
1414	function unstable_subscribe(subscriber) {
1415	if (enableSchedulerTracing) {
1416	subscribers.add(subscriber);
1417
1418	if (subscribers.size === 1) {
1419	subscriberRef.current = {
1420	onInteractionScheduledWorkCompleted: onInteractionScheduledWorkCompleted,
1421	onInteractionTraced: onInteractionTraced,
1422	onWorkCanceled: onWorkCanceled,
1423	onWorkScheduled: onWorkScheduled,
1424	onWorkStarted: onWorkStarted,
1425	onWorkStopped: onWorkStopped
1426	};
1427	}
1428	}
1429	}
1430
1431	function unstable_unsubscribe(subscriber) {
1432	if (enableSchedulerTracing) {
1433	subscribers.delete(subscriber);
1434
1435	if (subscribers.size === 0) {
1436	subscriberRef.current = null;
1437	}
1438	}
1439	}
1440
1441	function onInteractionTraced(interaction) {
1442	var didCatchError = false;
1443	var caughtError = null;
1444
1445	subscribers.forEach(function (subscriber) {
1446	try {
1447	subscriber.onInteractionTraced(interaction);
1448	} catch (error) {
1449	if (!didCatchError) {
1450	didCatchError = true;
1451	caughtError = error;
1452	}
1453	}
1454	});
1455
1456	if (didCatchError) {
1457	throw caughtError;
1458	}
1459	}
1460
1461	function onInteractionScheduledWorkCompleted(interaction) {
1462	var didCatchError = false;
1463	var caughtError = null;
1464
1465	subscribers.forEach(function (subscriber) {
1466	try {
1467	subscriber.onInteractionScheduledWorkCompleted(interaction);
1468	} catch (error) {
1469	if (!didCatchError) {
1470	didCatchError = true;
1471	caughtError = error;
1472	}
1473	}
1474	});
1475
1476	if (didCatchError) {
1477	throw caughtError;
1478	}
1479	}
1480
1481	function onWorkScheduled(interactions, threadID) {
1482	var didCatchError = false;
1483	var caughtError = null;
1484
1485	subscribers.forEach(function (subscriber) {
1486	try {
1487	subscriber.onWorkScheduled(interactions, threadID);
1488	} catch (error) {
1489	if (!didCatchError) {
1490	didCatchError = true;
1491	caughtError = error;
1492	}
1493	}
1494	});
1495
1496	if (didCatchError) {
1497	throw caughtError;
1498	}
1499	}
1500
1501	function onWorkStarted(interactions, threadID) {
1502	var didCatchError = false;
1503	var caughtError = null;
1504
1505	subscribers.forEach(function (subscriber) {
1506	try {
1507	subscriber.onWorkStarted(interactions, threadID);
1508	} catch (error) {
1509	if (!didCatchError) {
1510	didCatchError = true;
1511	caughtError = error;
1512	}
1513	}
1514	});
1515
1516	if (didCatchError) {
1517	throw caughtError;
1518	}
1519	}
1520
1521	function onWorkStopped(interactions, threadID) {
1522	var didCatchError = false;
1523	var caughtError = null;
1524
1525	subscribers.forEach(function (subscriber) {
1526	try {
1527	subscriber.onWorkStopped(interactions, threadID);
1528	} catch (error) {
1529	if (!didCatchError) {
1530	didCatchError = true;
1531	caughtError = error;
1532	}
1533	}
1534	});
1535
1536	if (didCatchError) {
1537	throw caughtError;
1538	}
1539	}
1540
1541	function onWorkCanceled(interactions, threadID) {
1542	var didCatchError = false;
1543	var caughtError = null;
1544
1545	subscribers.forEach(function (subscriber) {
1546	try {
1547	subscriber.onWorkCanceled(interactions, threadID);
1548	} catch (error) {
1549	if (!didCatchError) {
1550	didCatchError = true;
1551	caughtError = error;
1552	}
1553	}
1554	});
1555
1556	if (didCatchError) {
1557	throw caughtError;
1558	}
1559	}
1560
1561	/**
1562	* Keeps track of the current dispatcher.
1563	*/
1564	var ReactCurrentDispatcher = {
1565	/**
1566	* @internal
1567	* @type {ReactComponent}
1568	*/
1569	current: null
1570	};
1571
1572	/**
1573	* Keeps track of the current owner.
1574	*
1575	* The current owner is the component who should own any components that are
1576	* currently being constructed.
1577	*/
1578	var ReactCurrentOwner = {
1579	/**
1580	* @internal
1581	* @type {ReactComponent}
1582	*/
1583	current: null
1584	};
1585
1586	var BEFORE_SLASH_RE = /^(.*)[\\\/]/;
1587
1588	var describeComponentFrame = function (name, source, ownerName) {
1589	var sourceInfo = '';
1590	if (source) {
1591	var path = source.fileName;
1592	var fileName = path.replace(BEFORE_SLASH_RE, '');
1593	{
1594	// In DEV, include code for a common special case:
1595	// prefer "folder/index.js" instead of just "index.js".
1596	if (/^index\./.test(fileName)) {
1597	var match = path.match(BEFORE_SLASH_RE);
1598	if (match) {
1599	var pathBeforeSlash = match[1];
1600	if (pathBeforeSlash) {
1601	var folderName = pathBeforeSlash.replace(BEFORE_SLASH_RE, '');
1602	fileName = folderName + '/' + fileName;
1603	}
1604	}
1605	}
1606	}
1607	sourceInfo = ' (at ' + fileName + ':' + source.lineNumber + ')';
1608	} else if (ownerName) {
1609	sourceInfo = ' (created by ' + ownerName + ')';
1610	}
1611	return '\n in ' + (name \|\| 'Unknown') + sourceInfo;
1612	};
1613
1614	var Resolved = 1;
1615
1616
1617	function refineResolvedLazyComponent(lazyComponent) {
1618	return lazyComponent._status === Resolved ? lazyComponent._result : null;
1619	}
1620
1621	function getWrappedName(outerType, innerType, wrapperName) {
1622	var functionName = innerType.displayName \|\| innerType.name \|\| '';
1623	return outerType.displayName \|\| (functionName !== '' ? wrapperName + '(' + functionName + ')' : wrapperName);
1624	}
1625
1626	function getComponentName(type) {
1627	if (type == null) {
1628	// Host root, text node or just invalid type.
1629	return null;
1630	}
1631	{
1632	if (typeof type.tag === 'number') {
1633	warningWithoutStack$1(false, 'Received an unexpected object in getComponentName(). ' + 'This is likely a bug in React. Please file an issue.');
1634	}
1635	}
1636	if (typeof type === 'function') {
1637	return type.displayName \|\| type.name \|\| null;
1638	}
1639	if (typeof type === 'string') {
1640	return type;
1641	}
1642	switch (type) {
1643	case REACT_CONCURRENT_MODE_TYPE:
1644	return 'ConcurrentMode';
1645	case REACT_FRAGMENT_TYPE:
1646	return 'Fragment';
1647	case REACT_PORTAL_TYPE:
1648	return 'Portal';
1649	case REACT_PROFILER_TYPE:
1650	return 'Profiler';
1651	case REACT_STRICT_MODE_TYPE:
1652	return 'StrictMode';
1653	case REACT_SUSPENSE_TYPE:
1654	return 'Suspense';
1655	}
1656	if (typeof type === 'object') {
1657	switch (type.$$typeof) {
1658	case REACT_CONTEXT_TYPE:
1659	return 'Context.Consumer';
1660	case REACT_PROVIDER_TYPE:
1661	return 'Context.Provider';
1662	case REACT_FORWARD_REF_TYPE:
1663	return getWrappedName(type, type.render, 'ForwardRef');
1664	case REACT_MEMO_TYPE:
1665	return getComponentName(type.type);
1666	case REACT_LAZY_TYPE:
1667	{
1668	var thenable = type;
1669	var resolvedThenable = refineResolvedLazyComponent(thenable);
1670	if (resolvedThenable) {
1671	return getComponentName(resolvedThenable);
1672	}
1673	}
1674	}
1675	}
1676	return null;
1677	}
1678
1679	var ReactDebugCurrentFrame = {};
1680
1681	var currentlyValidatingElement = null;
1682
1683	function setCurrentlyValidatingElement(element) {
1684	{
1685	currentlyValidatingElement = element;
1686	}
1687	}
1688
1689	{
1690	// Stack implementation injected by the current renderer.
1691	ReactDebugCurrentFrame.getCurrentStack = null;
1692
1693	ReactDebugCurrentFrame.getStackAddendum = function () {
1694	var stack = '';
1695
1696	// Add an extra top frame while an element is being validated
1697	if (currentlyValidatingElement) {
1698	var name = getComponentName(currentlyValidatingElement.type);
1699	var owner = currentlyValidatingElement._owner;
1700	stack += describeComponentFrame(name, currentlyValidatingElement._source, owner && getComponentName(owner.type));
1701	}
1702
1703	// Delegate to the injected renderer-specific implementation
1704	var impl = ReactDebugCurrentFrame.getCurrentStack;
1705	if (impl) {
1706	stack += impl() \|\| '';
1707	}
1708
1709	return stack;
1710	};
1711	}
1712
1713	var ReactSharedInternals = {
1714	ReactCurrentDispatcher: ReactCurrentDispatcher,
1715	ReactCurrentOwner: ReactCurrentOwner,
1716	// Used by renderers to avoid bundling object-assign twice in UMD bundles:
1717	assign: objectAssign
1718	};
1719
1720	{
1721	// Re-export the schedule API(s) for UMD bundles.
1722	// This avoids introducing a dependency on a new UMD global in a minor update,
1723	// Since that would be a breaking change (e.g. for all existing CodeSandboxes).
1724	// This re-export is only required for UMD bundles;
1725	// CJS bundles use the shared NPM package.
1726	objectAssign(ReactSharedInternals, {
1727	Scheduler: {
1728	unstable_cancelCallback: unstable_cancelCallback,
1729	unstable_shouldYield: unstable_shouldYield,
1730	unstable_now: getCurrentTime,
1731	unstable_scheduleCallback: unstable_scheduleCallback,
1732	unstable_runWithPriority: unstable_runWithPriority,
1733	unstable_next: unstable_next,
1734	unstable_wrapCallback: unstable_wrapCallback,
1735	unstable_getFirstCallbackNode: unstable_getFirstCallbackNode,
1736	unstable_pauseExecution: unstable_pauseExecution,
1737	unstable_continueExecution: unstable_continueExecution,
1738	unstable_getCurrentPriorityLevel: unstable_getCurrentPriorityLevel,
1739	unstable_IdlePriority: IdlePriority,
1740	unstable_ImmediatePriority: ImmediatePriority,
1741	unstable_LowPriority: LowPriority,
1742	unstable_NormalPriority: NormalPriority,
1743	unstable_UserBlockingPriority: UserBlockingPriority
1744	},
1745	SchedulerTracing: {
1746	__interactionsRef: interactionsRef,
1747	__subscriberRef: subscriberRef,
1748	unstable_clear: unstable_clear,
1749	unstable_getCurrent: unstable_getCurrent,
1750	unstable_getThreadID: unstable_getThreadID,
1751	unstable_subscribe: unstable_subscribe,
1752	unstable_trace: unstable_trace,
1753	unstable_unsubscribe: unstable_unsubscribe,
1754	unstable_wrap: unstable_wrap
1755	}
1756	});
1757	}
1758
1759	{
1760	objectAssign(ReactSharedInternals, {
1761	// These should not be included in production.
1762	ReactDebugCurrentFrame: ReactDebugCurrentFrame,
1763	// Shim for React DOM 16.0.0 which still destructured (but not used) this.
1764	// TODO: remove in React 17.0.
1765	ReactComponentTreeHook: {}
1766	});
1767	}
1768
1769	/**
1770	* Similar to invariant but only logs a warning if the condition is not met.
1771	* This can be used to log issues in development environments in critical
1772	* paths. Removing the logging code for production environments will keep the
1773	* same logic and follow the same code paths.
1774	*/
1775
1776	var warning = warningWithoutStack$1;
1777
1778	{
1779	warning = function (condition, format) {
1780	if (condition) {
1781	return;
1782	}
1783	var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
1784	var stack = ReactDebugCurrentFrame.getStackAddendum();
1785	// eslint-disable-next-line react-internal/warning-and-invariant-args
1786
1787	for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
1788	args[_key - 2] = arguments[_key];
1789	}
1790
1791	warningWithoutStack$1.apply(undefined, [false, format + '%s'].concat(args, [stack]));
1792	};
1793	}
1794
1795	var warning$1 = warning;
1796
1797	var hasOwnProperty$1 = Object.prototype.hasOwnProperty;
1798
1799	var RESERVED_PROPS = {
1800	key: true,
1801	ref: true,
1802	__self: true,
1803	__source: true
1804	};
1805
1806	var specialPropKeyWarningShown = void 0;
1807	var specialPropRefWarningShown = void 0;
1808
1809	function hasValidRef(config) {
1810	{
1811	if (hasOwnProperty$1.call(config, 'ref')) {
1812	var getter = Object.getOwnPropertyDescriptor(config, 'ref').get;
1813	if (getter && getter.isReactWarning) {
1814	return false;
1815	}
1816	}
1817	}
1818	return config.ref !== undefined;
1819	}
1820
1821	function hasValidKey(config) {
1822	{
1823	if (hasOwnProperty$1.call(config, 'key')) {
1824	var getter = Object.getOwnPropertyDescriptor(config, 'key').get;
1825	if (getter && getter.isReactWarning) {
1826	return false;
1827	}
1828	}
1829	}
1830	return config.key !== undefined;
1831	}
1832
1833	function defineKeyPropWarningGetter(props, displayName) {
1834	var warnAboutAccessingKey = function () {
1835	if (!specialPropKeyWarningShown) {
1836	specialPropKeyWarningShown = true;
1837	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);
1838	}
1839	};
1840	warnAboutAccessingKey.isReactWarning = true;
1841	Object.defineProperty(props, 'key', {
1842	get: warnAboutAccessingKey,
1843	configurable: true
1844	});
1845	}
1846
1847	function defineRefPropWarningGetter(props, displayName) {
1848	var warnAboutAccessingRef = function () {
1849	if (!specialPropRefWarningShown) {
1850	specialPropRefWarningShown = true;
1851	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);
1852	}
1853	};
1854	warnAboutAccessingRef.isReactWarning = true;
1855	Object.defineProperty(props, 'ref', {
1856	get: warnAboutAccessingRef,
1857	configurable: true
1858	});
1859	}
1860
1861	/**
1862	* Factory method to create a new React element. This no longer adheres to
1863	* the class pattern, so do not use new to call it. Also, no instanceof check
1864	* will work. Instead test $$typeof field against Symbol.for('react.element') to check
1865	* if something is a React Element.
1866	*
1867	* @param {*} type
1868	* @param {*} key
1869	* @param {string\|object} ref
1870	* @param {} self A temporary* helper to detect places where `this` is
1871	* different from the `owner` when React.createElement is called, so that we
1872	* can warn. We want to get rid of owner and replace string `ref`s with arrow
1873	* functions, and as long as `this` and owner are the same, there will be no
1874	* change in behavior.
1875	* @param {*} source An annotation object (added by a transpiler or otherwise)
1876	* indicating filename, line number, and/or other information.
1877	* @param {*} owner
1878	* @param {*} props
1879	* @internal
1880	*/
1881	var ReactElement = function (type, key, ref, self, source, owner, props) {
1882	var element = {
1883	// This tag allows us to uniquely identify this as a React Element
1884	$$typeof: REACT_ELEMENT_TYPE,
1885
1886	// Built-in properties that belong on the element
1887	type: type,
1888	key: key,
1889	ref: ref,
1890	props: props,
1891
1892	// Record the component responsible for creating this element.
1893	_owner: owner
1894	};
1895
1896	{
1897	// The validation flag is currently mutative. We put it on
1898	// an external backing store so that we can freeze the whole object.
1899	// This can be replaced with a WeakMap once they are implemented in
1900	// commonly used development environments.
1901	element._store = {};
1902
1903	// To make comparing ReactElements easier for testing purposes, we make
1904	// the validation flag non-enumerable (where possible, which should
1905	// include every environment we run tests in), so the test framework
1906	// ignores it.
1907	Object.defineProperty(element._store, 'validated', {
1908	configurable: false,
1909	enumerable: false,
1910	writable: true,
1911	value: false
1912	});
1913	// self and source are DEV only properties.
1914	Object.defineProperty(element, '_self', {
1915	configurable: false,
1916	enumerable: false,
1917	writable: false,
1918	value: self
1919	});
1920	// Two elements created in two different places should be considered
1921	// equal for testing purposes and therefore we hide it from enumeration.
1922	Object.defineProperty(element, '_source', {
1923	configurable: false,
1924	enumerable: false,
1925	writable: false,
1926	value: source
1927	});
1928	if (Object.freeze) {
1929	Object.freeze(element.props);
1930	Object.freeze(element);
1931	}
1932	}
1933
1934	return element;
1935	};
1936
1937	/**
1938	* Create and return a new ReactElement of the given type.
1939	* See https://reactjs.org/docs/react-api.html#createelement
1940	*/
1941	function createElement(type, config, children) {
1942	var propName = void 0;
1943
1944	// Reserved names are extracted
1945	var props = {};
1946
1947	var key = null;
1948	var ref = null;
1949	var self = null;
1950	var source = null;
1951
1952	if (config != null) {
1953	if (hasValidRef(config)) {
1954	ref = config.ref;
1955	}
1956	if (hasValidKey(config)) {
1957	key = '' + config.key;
1958	}
1959
1960	self = config.__self === undefined ? null : config.__self;
1961	source = config.__source === undefined ? null : config.__source;
1962	// Remaining properties are added to a new props object
1963	for (propName in config) {
1964	if (hasOwnProperty$1.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
1965	props[propName] = config[propName];
1966	}
1967	}
1968	}
1969
1970	// Children can be more than one argument, and those are transferred onto
1971	// the newly allocated props object.
1972	var childrenLength = arguments.length - 2;
1973	if (childrenLength === 1) {
1974	props.children = children;
1975	} else if (childrenLength > 1) {
1976	var childArray = Array(childrenLength);
1977	for (var i = 0; i < childrenLength; i++) {
1978	childArray[i] = arguments[i + 2];
1979	}
1980	{
1981	if (Object.freeze) {
1982	Object.freeze(childArray);
1983	}
1984	}
1985	props.children = childArray;
1986	}
1987
1988	// Resolve default props
1989	if (type && type.defaultProps) {
1990	var defaultProps = type.defaultProps;
1991	for (propName in defaultProps) {
1992	if (props[propName] === undefined) {
1993	props[propName] = defaultProps[propName];
1994	}
1995	}
1996	}
1997	{
1998	if (key \|\| ref) {
1999	var displayName = typeof type === 'function' ? type.displayName \|\| type.name \|\| 'Unknown' : type;
2000	if (key) {
2001	defineKeyPropWarningGetter(props, displayName);
2002	}
2003	if (ref) {
2004	defineRefPropWarningGetter(props, displayName);
2005	}
2006	}
2007	}
2008	return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
2009	}
2010
2011	/**
2012	* Return a function that produces ReactElements of a given type.
2013	* See https://reactjs.org/docs/react-api.html#createfactory
2014	*/
2015
2016
2017	function cloneAndReplaceKey(oldElement, newKey) {
2018	var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props);
2019
2020	return newElement;
2021	}
2022
2023	/**
2024	* Clone and return a new ReactElement using element as the starting point.
2025	* See https://reactjs.org/docs/react-api.html#cloneelement
2026	*/
2027	function cloneElement(element, config, children) {
2028	!!(element === null \|\| element === undefined) ? invariant(false, 'React.cloneElement(...): The argument must be a React element, but you passed %s.', element) : void 0;
2029
2030	var propName = void 0;
2031
2032	// Original props are copied
2033	var props = objectAssign({}, element.props);
2034
2035	// Reserved names are extracted
2036	var key = element.key;
2037	var ref = element.ref;
2038	// Self is preserved since the owner is preserved.
2039	var self = element._self;
2040	// Source is preserved since cloneElement is unlikely to be targeted by a
2041	// transpiler, and the original source is probably a better indicator of the
2042	// true owner.
2043	var source = element._source;
2044
2045	// Owner will be preserved, unless ref is overridden
2046	var owner = element._owner;
2047
2048	if (config != null) {
2049	if (hasValidRef(config)) {
2050	// Silently steal the ref from the parent.
2051	ref = config.ref;
2052	owner = ReactCurrentOwner.current;
2053	}
2054	if (hasValidKey(config)) {
2055	key = '' + config.key;
2056	}
2057
2058	// Remaining properties override existing props
2059	var defaultProps = void 0;
2060	if (element.type && element.type.defaultProps) {
2061	defaultProps = element.type.defaultProps;
2062	}
2063	for (propName in config) {
2064	if (hasOwnProperty$1.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
2065	if (config[propName] === undefined && defaultProps !== undefined) {
2066	// Resolve default props
2067	props[propName] = defaultProps[propName];
2068	} else {
2069	props[propName] = config[propName];
2070	}
2071	}
2072	}
2073	}
2074
2075	// Children can be more than one argument, and those are transferred onto
2076	// the newly allocated props object.
2077	var childrenLength = arguments.length - 2;
2078	if (childrenLength === 1) {
2079	props.children = children;
2080	} else if (childrenLength > 1) {
2081	var childArray = Array(childrenLength);
2082	for (var i = 0; i < childrenLength; i++) {
2083	childArray[i] = arguments[i + 2];
2084	}
2085	props.children = childArray;
2086	}
2087
2088	return ReactElement(element.type, key, ref, self, source, owner, props);
2089	}
2090
2091	/**
2092	* Verifies the object is a ReactElement.
2093	* See https://reactjs.org/docs/react-api.html#isvalidelement
2094	* @param {?object} object
2095	* @return {boolean} True if `object` is a ReactElement.
2096	* @final
2097	*/
2098	function isValidElement(object) {
2099	return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
2100	}
2101
2102	var SEPARATOR = '.';
2103	var SUBSEPARATOR = ':';
2104
2105	/**
2106	* Escape and wrap key so it is safe to use as a reactid
2107	*
2108	* @param {string} key to be escaped.
2109	* @return {string} the escaped key.
2110	*/
2111	function escape(key) {
2112	var escapeRegex = /[=:]/g;
2113	var escaperLookup = {
2114	'=': '=0',
2115	':': '=2'
2116	};
2117	var escapedString = ('' + key).replace(escapeRegex, function (match) {
2118	return escaperLookup[match];
2119	});
2120
2121	return '$' + escapedString;
2122	}
2123
2124	/**
2125	* TODO: Test that a single child and an array with one item have the same key
2126	* pattern.
2127	*/
2128
2129	var didWarnAboutMaps = false;
2130
2131	var userProvidedKeyEscapeRegex = /\/+/g;
2132	function escapeUserProvidedKey(text) {
2133	return ('' + text).replace(userProvidedKeyEscapeRegex, '$&/');
2134	}
2135
2136	var POOL_SIZE = 10;
2137	var traverseContextPool = [];
2138	function getPooledTraverseContext(mapResult, keyPrefix, mapFunction, mapContext) {
2139	if (traverseContextPool.length) {
2140	var traverseContext = traverseContextPool.pop();
2141	traverseContext.result = mapResult;
2142	traverseContext.keyPrefix = keyPrefix;
2143	traverseContext.func = mapFunction;
2144	traverseContext.context = mapContext;
2145	traverseContext.count = 0;
2146	return traverseContext;
2147	} else {
2148	return {
2149	result: mapResult,
2150	keyPrefix: keyPrefix,
2151	func: mapFunction,
2152	context: mapContext,
2153	count: 0
2154	};
2155	}
2156	}
2157
2158	function releaseTraverseContext(traverseContext) {
2159	traverseContext.result = null;
2160	traverseContext.keyPrefix = null;
2161	traverseContext.func = null;
2162	traverseContext.context = null;
2163	traverseContext.count = 0;
2164	if (traverseContextPool.length < POOL_SIZE) {
2165	traverseContextPool.push(traverseContext);
2166	}
2167	}
2168
2169	/**
2170	* @param {?*} children Children tree container.
2171	* @param {!string} nameSoFar Name of the key path so far.
2172	* @param {!function} callback Callback to invoke with each child found.
2173	* @param {?*} traverseContext Used to pass information throughout the traversal
2174	* process.
2175	* @return {!number} The number of children in this subtree.
2176	*/
2177	function traverseAllChildrenImpl(children, nameSoFar, callback, traverseContext) {
2178	var type = typeof children;
2179
2180	if (type === 'undefined' \|\| type === 'boolean') {
2181	// All of the above are perceived as null.
2182	children = null;
2183	}
2184
2185	var invokeCallback = false;
2186
2187	if (children === null) {
2188	invokeCallback = true;
2189	} else {
2190	switch (type) {
2191	case 'string':
2192	case 'number':
2193	invokeCallback = true;
2194	break;
2195	case 'object':
2196	switch (children.$$typeof) {
2197	case REACT_ELEMENT_TYPE:
2198	case REACT_PORTAL_TYPE:
2199	invokeCallback = true;
2200	}
2201	}
2202	}
2203
2204	if (invokeCallback) {
2205	callback(traverseContext, children,
2206	// If it's the only child, treat the name as if it was wrapped in an array
2207	// so that it's consistent if the number of children grows.
2208	nameSoFar === '' ? SEPARATOR + getComponentKey(children, 0) : nameSoFar);
2209	return 1;
2210	}
2211
2212	var child = void 0;
2213	var nextName = void 0;
2214	var subtreeCount = 0; // Count of children found in the current subtree.
2215	var nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR;
2216
2217	if (Array.isArray(children)) {
2218	for (var i = 0; i < children.length; i++) {
2219	child = children[i];
2220	nextName = nextNamePrefix + getComponentKey(child, i);
2221	subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);
2222	}
2223	} else {
2224	var iteratorFn = getIteratorFn(children);
2225	if (typeof iteratorFn === 'function') {
2226	{
2227	// Warn about using Maps as children
2228	if (iteratorFn === children.entries) {
2229	!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;
2230	didWarnAboutMaps = true;
2231	}
2232	}
2233
2234	var iterator = iteratorFn.call(children);
2235	var step = void 0;
2236	var ii = 0;
2237	while (!(step = iterator.next()).done) {
2238	child = step.value;
2239	nextName = nextNamePrefix + getComponentKey(child, ii++);
2240	subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);
2241	}
2242	} else if (type === 'object') {
2243	var addendum = '';
2244	{
2245	addendum = ' If you meant to render a collection of children, use an array ' + 'instead.' + ReactDebugCurrentFrame.getStackAddendum();
2246	}
2247	var childrenString = '' + children;
2248	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);
2249	}
2250	}
2251
2252	return subtreeCount;
2253	}
2254
2255	/**
2256	* Traverses children that are typically specified as `props.children`, but
2257	* might also be specified through attributes:
2258	*
2259	* - `traverseAllChildren(this.props.children, ...)`
2260	* - `traverseAllChildren(this.props.leftPanelChildren, ...)`
2261	*
2262	* The `traverseContext` is an optional argument that is passed through the
2263	* entire traversal. It can be used to store accumulations or anything else that
2264	* the callback might find relevant.
2265	*
2266	* @param {?*} children Children tree object.
2267	* @param {!function} callback To invoke upon traversing each child.
2268	* @param {?*} traverseContext Context for traversal.
2269	* @return {!number} The number of children in this subtree.
2270	*/
2271	function traverseAllChildren(children, callback, traverseContext) {
2272	if (children == null) {
2273	return 0;
2274	}
2275
2276	return traverseAllChildrenImpl(children, '', callback, traverseContext);
2277	}
2278
2279	/**
2280	* Generate a key string that identifies a component within a set.
2281	*
2282	* @param {*} component A component that could contain a manual key.
2283	* @param {number} index Index that is used if a manual key is not provided.
2284	* @return {string}
2285	*/
2286	function getComponentKey(component, index) {
2287	// Do some typechecking here since we call this blindly. We want to ensure
2288	// that we don't block potential future ES APIs.
2289	if (typeof component === 'object' && component !== null && component.key != null) {
2290	// Explicit key
2291	return escape(component.key);
2292	}
2293	// Implicit key determined by the index in the set
2294	return index.toString(36);
2295	}
2296
2297	function forEachSingleChild(bookKeeping, child, name) {
2298	var func = bookKeeping.func,
2299	context = bookKeeping.context;
2300
2301	func.call(context, child, bookKeeping.count++);
2302	}
2303
2304	/**
2305	* Iterates through children that are typically specified as `props.children`.
2306	*
2307	* See https://reactjs.org/docs/react-api.html#reactchildrenforeach
2308	*
2309	* The provided forEachFunc(child, index) will be called for each
2310	* leaf child.
2311	*
2312	* @param {?*} children Children tree container.
2313	* @param {function(*, int)} forEachFunc
2314	* @param {*} forEachContext Context for forEachContext.
2315	*/
2316	function forEachChildren(children, forEachFunc, forEachContext) {
2317	if (children == null) {
2318	return children;
2319	}
2320	var traverseContext = getPooledTraverseContext(null, null, forEachFunc, forEachContext);
2321	traverseAllChildren(children, forEachSingleChild, traverseContext);
2322	releaseTraverseContext(traverseContext);
2323	}
2324
2325	function mapSingleChildIntoContext(bookKeeping, child, childKey) {
2326	var result = bookKeeping.result,
2327	keyPrefix = bookKeeping.keyPrefix,
2328	func = bookKeeping.func,
2329	context = bookKeeping.context;
2330
2331
2332	var mappedChild = func.call(context, child, bookKeeping.count++);
2333	if (Array.isArray(mappedChild)) {
2334	mapIntoWithKeyPrefixInternal(mappedChild, result, childKey, function (c) {
2335	return c;
2336	});
2337	} else if (mappedChild != null) {
2338	if (isValidElement(mappedChild)) {
2339	mappedChild = cloneAndReplaceKey(mappedChild,
2340	// Keep both the (mapped) and old keys if they differ, just as
2341	// traverseAllChildren used to do for objects as children
2342	keyPrefix + (mappedChild.key && (!child \|\| child.key !== mappedChild.key) ? escapeUserProvidedKey(mappedChild.key) + '/' : '') + childKey);
2343	}
2344	result.push(mappedChild);
2345	}
2346	}
2347
2348	function mapIntoWithKeyPrefixInternal(children, array, prefix, func, context) {
2349	var escapedPrefix = '';
2350	if (prefix != null) {
2351	escapedPrefix = escapeUserProvidedKey(prefix) + '/';
2352	}
2353	var traverseContext = getPooledTraverseContext(array, escapedPrefix, func, context);
2354	traverseAllChildren(children, mapSingleChildIntoContext, traverseContext);
2355	releaseTraverseContext(traverseContext);
2356	}
2357
2358	/**
2359	* Maps children that are typically specified as `props.children`.
2360	*
2361	* See https://reactjs.org/docs/react-api.html#reactchildrenmap
2362	*
2363	* The provided mapFunction(child, key, index) will be called for each
2364	* leaf child.
2365	*
2366	* @param {?*} children Children tree container.
2367	* @param {function(*, int)} func The map function.
2368	* @param {*} context Context for mapFunction.
2369	* @return {object} Object containing the ordered map of results.
2370	*/
2371	function mapChildren(children, func, context) {
2372	if (children == null) {
2373	return children;
2374	}
2375	var result = [];
2376	mapIntoWithKeyPrefixInternal(children, result, null, func, context);
2377	return result;
2378	}
2379
2380	/**
2381	* Count the number of children that are typically specified as
2382	* `props.children`.
2383	*
2384	* See https://reactjs.org/docs/react-api.html#reactchildrencount
2385	*
2386	* @param {?*} children Children tree container.
2387	* @return {number} The number of children.
2388	*/
2389	function countChildren(children) {
2390	return traverseAllChildren(children, function () {
2391	return null;
2392	}, null);
2393	}
2394
2395	/**
2396	* Flatten a children object (typically specified as `props.children`) and
2397	* return an array with appropriately re-keyed children.
2398	*
2399	* See https://reactjs.org/docs/react-api.html#reactchildrentoarray
2400	*/
2401	function toArray(children) {
2402	var result = [];
2403	mapIntoWithKeyPrefixInternal(children, result, null, function (child) {
2404	return child;
2405	});
2406	return result;
2407	}
2408
2409	/**
2410	* Returns the first child in a collection of children and verifies that there
2411	* is only one child in the collection.
2412	*
2413	* See https://reactjs.org/docs/react-api.html#reactchildrenonly
2414	*
2415	* The current implementation of this function assumes that a single child gets
2416	* passed without a wrapper, but the purpose of this helper function is to
2417	* abstract away the particular structure of children.
2418	*
2419	* @param {?object} children Child collection structure.
2420	* @return {ReactElement} The first and only `ReactElement` contained in the
2421	* structure.
2422	*/
2423	function onlyChild(children) {
2424	!isValidElement(children) ? invariant(false, 'React.Children.only expected to receive a single React element child.') : void 0;
2425	return children;
2426	}
2427
2428	function createContext(defaultValue, calculateChangedBits) {
2429	if (calculateChangedBits === undefined) {
2430	calculateChangedBits = null;
2431	} else {
2432	{
2433	!(calculateChangedBits === null \|\| typeof calculateChangedBits === 'function') ? warningWithoutStack$1(false, 'createContext: Expected the optional second argument to be a ' + 'function. Instead received: %s', calculateChangedBits) : void 0;
2434	}
2435	}
2436
2437	var context = {
2438	$$typeof: REACT_CONTEXT_TYPE,
2439	_calculateChangedBits: calculateChangedBits,
2440	// As a workaround to support multiple concurrent renderers, we categorize
2441	// some renderers as primary and others as secondary. We only expect
2442	// there to be two concurrent renderers at most: React Native (primary) and
2443	// Fabric (secondary); React DOM (primary) and React ART (secondary).
2444	// Secondary renderers store their context values on separate fields.
2445	_currentValue: defaultValue,
2446	_currentValue2: defaultValue,
2447	// Used to track how many concurrent renderers this context currently
2448	// supports within in a single renderer. Such as parallel server rendering.
2449	_threadCount: 0,
2450	// These are circular
2451	Provider: null,
2452	Consumer: null
2453	};
2454
2455	context.Provider = {
2456	$$typeof: REACT_PROVIDER_TYPE,
2457	_context: context
2458	};
2459
2460	var hasWarnedAboutUsingNestedContextConsumers = false;
2461	var hasWarnedAboutUsingConsumerProvider = false;
2462
2463	{
2464	// A separate object, but proxies back to the original context object for
2465	// backwards compatibility. It has a different $$typeof, so we can properly
2466	// warn for the incorrect usage of Context as a Consumer.
2467	var Consumer = {
2468	$$typeof: REACT_CONTEXT_TYPE,
2469	_context: context,
2470	_calculateChangedBits: context._calculateChangedBits
2471	};
2472	// $FlowFixMe: Flow complains about not setting a value, which is intentional here
2473	Object.defineProperties(Consumer, {
2474	Provider: {
2475	get: function () {
2476	if (!hasWarnedAboutUsingConsumerProvider) {
2477	hasWarnedAboutUsingConsumerProvider = true;
2478	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?');
2479	}
2480	return context.Provider;
2481	},
2482	set: function (_Provider) {
2483	context.Provider = _Provider;
2484	}
2485	},
2486	_currentValue: {
2487	get: function () {
2488	return context._currentValue;
2489	},
2490	set: function (_currentValue) {
2491	context._currentValue = _currentValue;
2492	}
2493	},
2494	_currentValue2: {
2495	get: function () {
2496	return context._currentValue2;
2497	},
2498	set: function (_currentValue2) {
2499	context._currentValue2 = _currentValue2;
2500	}
2501	},
2502	_threadCount: {
2503	get: function () {
2504	return context._threadCount;
2505	},
2506	set: function (_threadCount) {
2507	context._threadCount = _threadCount;
2508	}
2509	},
2510	Consumer: {
2511	get: function () {
2512	if (!hasWarnedAboutUsingNestedContextConsumers) {
2513	hasWarnedAboutUsingNestedContextConsumers = true;
2514	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?');
2515	}
2516	return context.Consumer;
2517	}
2518	}
2519	});
2520	// $FlowFixMe: Flow complains about missing properties because it doesn't understand defineProperty
2521	context.Consumer = Consumer;
2522	}
2523
2524	{
2525	context._currentRenderer = null;
2526	context._currentRenderer2 = null;
2527	}
2528
2529	return context;
2530	}
2531
2532	function lazy(ctor) {
2533	var lazyType = {
2534	$$typeof: REACT_LAZY_TYPE,
2535	_ctor: ctor,
2536	// React uses these fields to store the result.
2537	_status: -1,
2538	_result: null
2539	};
2540
2541	{
2542	// In production, this would just set it on the object.
2543	var defaultProps = void 0;
2544	var propTypes = void 0;
2545	Object.defineProperties(lazyType, {
2546	defaultProps: {
2547	configurable: true,
2548	get: function () {
2549	return defaultProps;
2550	},
2551	set: function (newDefaultProps) {
2552	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.');
2553	defaultProps = newDefaultProps;
2554	// Match production behavior more closely:
2555	Object.defineProperty(lazyType, 'defaultProps', {
2556	enumerable: true
2557	});
2558	}
2559	},
2560	propTypes: {
2561	configurable: true,
2562	get: function () {
2563	return propTypes;
2564	},
2565	set: function (newPropTypes) {
2566	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.');
2567	propTypes = newPropTypes;
2568	// Match production behavior more closely:
2569	Object.defineProperty(lazyType, 'propTypes', {
2570	enumerable: true
2571	});
2572	}
2573	}
2574	});
2575	}
2576
2577	return lazyType;
2578	}
2579
2580	function forwardRef(render) {
2581	{
2582	if (render != null && render.$$typeof === REACT_MEMO_TYPE) {
2583	warningWithoutStack$1(false, 'forwardRef requires a render function but received a `memo` ' + 'component. Instead of forwardRef(memo(...)), use ' + 'memo(forwardRef(...)).');
2584	} else if (typeof render !== 'function') {
2585	warningWithoutStack$1(false, 'forwardRef requires a render function but was given %s.', render === null ? 'null' : typeof render);
2586	} else {
2587	!(
2588	// Do not warn for 0 arguments because it could be due to usage of the 'arguments' object
2589	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;
2590	}
2591
2592	if (render != null) {
2593	!(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;
2594	}
2595	}
2596
2597	return {
2598	$$typeof: REACT_FORWARD_REF_TYPE,
2599	render: render
2600	};
2601	}
2602
2603	function isValidElementType(type) {
2604	return typeof type === 'string' \|\| typeof type === 'function' \|\|
2605	// Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
2606	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);
2607	}
2608
2609	function memo(type, compare) {
2610	{
2611	if (!isValidElementType(type)) {
2612	warningWithoutStack$1(false, 'memo: The first argument must be a component. Instead ' + 'received: %s', type === null ? 'null' : typeof type);
2613	}
2614	}
2615	return {
2616	$$typeof: REACT_MEMO_TYPE,
2617	type: type,
2618	compare: compare === undefined ? null : compare
2619	};
2620	}
2621
2622	function resolveDispatcher() {
2623	var dispatcher = ReactCurrentDispatcher.current;
2624	!(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;
2625	return dispatcher;
2626	}
2627
2628	function useContext(Context, unstable_observedBits) {
2629	var dispatcher = resolveDispatcher();
2630	{
2631	!(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;
2632
2633	// TODO: add a more generic warning for invalid values.
2634	if (Context._context !== undefined) {
2635	var realContext = Context._context;
2636	// Don't deduplicate because this legitimately causes bugs
2637	// and nobody should be using this in existing code.
2638	if (realContext.Consumer === Context) {
2639	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?');
2640	} else if (realContext.Provider === Context) {
2641	warning$1(false, 'Calling useContext(Context.Provider) is not supported. ' + 'Did you mean to call useContext(Context) instead?');
2642	}
2643	}
2644	}
2645	return dispatcher.useContext(Context, unstable_observedBits);
2646	}
2647
2648	function useState(initialState) {
2649	var dispatcher = resolveDispatcher();
2650	return dispatcher.useState(initialState);
2651	}
2652
2653	function useReducer(reducer, initialArg, init) {
2654	var dispatcher = resolveDispatcher();
2655	return dispatcher.useReducer(reducer, initialArg, init);
2656	}
2657
2658	function useRef(initialValue) {
2659	var dispatcher = resolveDispatcher();
2660	return dispatcher.useRef(initialValue);
2661	}
2662
2663	function useEffect(create, inputs) {
2664	var dispatcher = resolveDispatcher();
2665	return dispatcher.useEffect(create, inputs);
2666	}
2667
2668	function useLayoutEffect(create, inputs) {
2669	var dispatcher = resolveDispatcher();
2670	return dispatcher.useLayoutEffect(create, inputs);
2671	}
2672
2673	function useCallback(callback, inputs) {
2674	var dispatcher = resolveDispatcher();
2675	return dispatcher.useCallback(callback, inputs);
2676	}
2677
2678	function useMemo(create, inputs) {
2679	var dispatcher = resolveDispatcher();
2680	return dispatcher.useMemo(create, inputs);
2681	}
2682
2683	function useImperativeHandle(ref, create, inputs) {
2684	var dispatcher = resolveDispatcher();
2685	return dispatcher.useImperativeHandle(ref, create, inputs);
2686	}
2687
2688	function useDebugValue(value, formatterFn) {
2689	{
2690	var dispatcher = resolveDispatcher();
2691	return dispatcher.useDebugValue(value, formatterFn);
2692	}
2693	}
2694
2695	/**
2696	* Copyright (c) 2013-present, Facebook, Inc.
2697	*
2698	* This source code is licensed under the MIT license found in the
2699	* LICENSE file in the root directory of this source tree.
2700	*/
2701
2702
2703
2704	var ReactPropTypesSecret$1 = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
2705
2706	var ReactPropTypesSecret_1 = ReactPropTypesSecret$1;
2707
2708	/**
2709	* Copyright (c) 2013-present, Facebook, Inc.
2710	*
2711	* This source code is licensed under the MIT license found in the
2712	* LICENSE file in the root directory of this source tree.
2713	*/
2714
2715
2716
2717	var printWarning$1 = function() {};
2718
2719	{
2720	var ReactPropTypesSecret = ReactPropTypesSecret_1;
2721	var loggedTypeFailures = {};
2722
2723	printWarning$1 = function(text) {
2724	var message = 'Warning: ' + text;
2725	if (typeof console !== 'undefined') {
2726	console.error(message);
2727	}
2728	try {
2729	// --- Welcome to debugging React ---
2730	// This error was thrown as a convenience so that you can use this stack
2731	// to find the callsite that caused this warning to fire.
2732	throw new Error(message);
2733	} catch (x) {}
2734	};
2735	}
2736
2737	/**
2738	* Assert that the values match with the type specs.
2739	* Error messages are memorized and will only be shown once.
2740	*
2741	* @param {object} typeSpecs Map of name to a ReactPropType
2742	* @param {object} values Runtime values that need to be type-checked
2743	* @param {string} location e.g. "prop", "context", "child context"
2744	* @param {string} componentName Name of the component for error messages.
2745	* @param {?Function} getStack Returns the component stack.
2746	* @private
2747	*/
2748	function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
2749	{
2750	for (var typeSpecName in typeSpecs) {
2751	if (typeSpecs.hasOwnProperty(typeSpecName)) {
2752	var error;
2753	// Prop type validation may throw. In case they do, we don't want to
2754	// fail the render phase where it didn't fail before. So we log it.
2755	// After these have been cleaned up, we'll let them throw.
2756	try {
2757	// This is intentionally an invariant that gets caught. It's the same
2758	// behavior as without this statement except with a better message.
2759	if (typeof typeSpecs[typeSpecName] !== 'function') {
2760	var err = Error(
2761	(componentName \|\| 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' +
2762	'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.'
2763	);
2764	err.name = 'Invariant Violation';
2765	throw err;
2766	}
2767	error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
2768	} catch (ex) {
2769	error = ex;
2770	}
2771	if (error && !(error instanceof Error)) {
2772	printWarning$1(
2773	(componentName \|\| 'React class') + ': type specification of ' +
2774	location + ' `' + typeSpecName + '` is invalid; the type checker ' +
2775	'function must return `null` or an `Error` but returned a ' + typeof error + '. ' +
2776	'You may have forgotten to pass an argument to the type checker ' +
2777	'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' +
2778	'shape all require an argument).'
2779	);
2780
2781	}
2782	if (error instanceof Error && !(error.message in loggedTypeFailures)) {
2783	// Only monitor this failure once because there tends to be a lot of the
2784	// same error.
2785	loggedTypeFailures[error.message] = true;
2786
2787	var stack = getStack ? getStack() : '';
2788
2789	printWarning$1(
2790	'Failed ' + location + ' type: ' + error.message + (stack != null ? stack : '')
2791	);
2792	}
2793	}
2794	}
2795	}
2796	}
2797
2798	var checkPropTypes_1 = checkPropTypes;
2799
2800	/**
2801	* ReactElementValidator provides a wrapper around a element factory
2802	* which validates the props passed to the element. This is intended to be
2803	* used only in DEV and could be replaced by a static type checker for languages
2804	* that support it.
2805	*/
2806
2807	var propTypesMisspellWarningShown = void 0;
2808
2809	{
2810	propTypesMisspellWarningShown = false;
2811	}
2812
2813	function getDeclarationErrorAddendum() {
2814	if (ReactCurrentOwner.current) {
2815	var name = getComponentName(ReactCurrentOwner.current.type);
2816	if (name) {
2817	return '\n\nCheck the render method of `' + name + '`.';
2818	}
2819	}
2820	return '';
2821	}
2822
2823	function getSourceInfoErrorAddendum(elementProps) {
2824	if (elementProps !== null && elementProps !== undefined && elementProps.__source !== undefined) {
2825	var source = elementProps.__source;
2826	var fileName = source.fileName.replace(/^.*[\\\/]/, '');
2827	var lineNumber = source.lineNumber;
2828	return '\n\nCheck your code at ' + fileName + ':' + lineNumber + '.';
2829	}
2830	return '';
2831	}
2832
2833	/**
2834	* Warn if there's no key explicitly set on dynamic arrays of children or
2835	* object keys are not valid. This allows us to keep track of children between
2836	* updates.
2837	*/
2838	var ownerHasKeyUseWarning = {};
2839
2840	function getCurrentComponentErrorInfo(parentType) {
2841	var info = getDeclarationErrorAddendum();
2842
2843	if (!info) {
2844	var parentName = typeof parentType === 'string' ? parentType : parentType.displayName \|\| parentType.name;
2845	if (parentName) {
2846	info = '\n\nCheck the top-level render call using <' + parentName + '>.';
2847	}
2848	}
2849	return info;
2850	}
2851
2852	/**
2853	* Warn if the element doesn't have an explicit key assigned to it.
2854	* This element is in an array. The array could grow and shrink or be
2855	* reordered. All children that haven't already been validated are required to
2856	* have a "key" property assigned to it. Error statuses are cached so a warning
2857	* will only be shown once.
2858	*
2859	* @internal
2860	* @param {ReactElement} element Element that requires a key.
2861	* @param {*} parentType element's parent's type.
2862	*/
2863	function validateExplicitKey(element, parentType) {
2864	if (!element._store \|\| element._store.validated \|\| element.key != null) {
2865	return;
2866	}
2867	element._store.validated = true;
2868
2869	var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);
2870	if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {
2871	return;
2872	}
2873	ownerHasKeyUseWarning[currentComponentErrorInfo] = true;
2874
2875	// Usually the current owner is the offender, but if it accepts children as a
2876	// property, it may be the creator of the child that's responsible for
2877	// assigning it a key.
2878	var childOwner = '';
2879	if (element && element._owner && element._owner !== ReactCurrentOwner.current) {
2880	// Give the component that originally created this child.
2881	childOwner = ' It was passed a child from ' + getComponentName(element._owner.type) + '.';
2882	}
2883
2884	setCurrentlyValidatingElement(element);
2885	{
2886	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);
2887	}
2888	setCurrentlyValidatingElement(null);
2889	}
2890
2891	/**
2892	* Ensure that every element either is passed in a static location, in an
2893	* array with an explicit keys property defined, or in an object literal
2894	* with valid key property.
2895	*
2896	* @internal
2897	* @param {ReactNode} node Statically passed child of any type.
2898	* @param {*} parentType node's parent's type.
2899	*/
2900	function validateChildKeys(node, parentType) {
2901	if (typeof node !== 'object') {
2902	return;
2903	}
2904	if (Array.isArray(node)) {
2905	for (var i = 0; i < node.length; i++) {
2906	var child = node[i];
2907	if (isValidElement(child)) {
2908	validateExplicitKey(child, parentType);
2909	}
2910	}
2911	} else if (isValidElement(node)) {
2912	// This element was passed in a valid location.
2913	if (node._store) {
2914	node._store.validated = true;
2915	}
2916	} else if (node) {
2917	var iteratorFn = getIteratorFn(node);
2918	if (typeof iteratorFn === 'function') {
2919	// Entry iterators used to provide implicit keys,
2920	// but now we print a separate warning for them later.
2921	if (iteratorFn !== node.entries) {
2922	var iterator = iteratorFn.call(node);
2923	var step = void 0;
2924	while (!(step = iterator.next()).done) {
2925	if (isValidElement(step.value)) {
2926	validateExplicitKey(step.value, parentType);
2927	}
2928	}
2929	}
2930	}
2931	}
2932	}
2933
2934	/**
2935	* Given an element, validate that its props follow the propTypes definition,
2936	* provided by the type.
2937	*
2938	* @param {ReactElement} element
2939	*/
2940	function validatePropTypes(element) {
2941	var type = element.type;
2942	if (type === null \|\| type === undefined \|\| typeof type === 'string') {
2943	return;
2944	}
2945	var name = getComponentName(type);
2946	var propTypes = void 0;
2947	if (typeof type === 'function') {
2948	propTypes = type.propTypes;
2949	} else if (typeof type === 'object' && (type.$$typeof === REACT_FORWARD_REF_TYPE \|\|
2950	// Note: Memo only checks outer props here.
2951	// Inner props are checked in the reconciler.
2952	type.$$typeof === REACT_MEMO_TYPE)) {
2953	propTypes = type.propTypes;
2954	} else {
2955	return;
2956	}
2957	if (propTypes) {
2958	setCurrentlyValidatingElement(element);
2959	checkPropTypes_1(propTypes, element.props, 'prop', name, ReactDebugCurrentFrame.getStackAddendum);
2960	setCurrentlyValidatingElement(null);
2961	} else if (type.PropTypes !== undefined && !propTypesMisspellWarningShown) {
2962	propTypesMisspellWarningShown = true;
2963	warningWithoutStack$1(false, 'Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?', name \|\| 'Unknown');
2964	}
2965	if (typeof type.getDefaultProps === 'function') {
2966	!type.getDefaultProps.isReactClassApproved ? warningWithoutStack$1(false, 'getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.') : void 0;
2967	}
2968	}
2969
2970	/**
2971	* Given a fragment, validate that it can only be provided with fragment props
2972	* @param {ReactElement} fragment
2973	*/
2974	function validateFragmentProps(fragment) {
2975	setCurrentlyValidatingElement(fragment);
2976
2977	var keys = Object.keys(fragment.props);
2978	for (var i = 0; i < keys.length; i++) {
2979	var key = keys[i];
2980	if (key !== 'children' && key !== 'key') {
2981	warning$1(false, 'Invalid prop `%s` supplied to `React.Fragment`. ' + 'React.Fragment can only have `key` and `children` props.', key);
2982	break;
2983	}
2984	}
2985
2986	if (fragment.ref !== null) {
2987	warning$1(false, 'Invalid attribute `ref` supplied to `React.Fragment`.');
2988	}
2989
2990	setCurrentlyValidatingElement(null);
2991	}
2992
2993	function createElementWithValidation(type, props, children) {
2994	var validType = isValidElementType(type);
2995
2996	// We warn in this case but don't throw. We expect the element creation to
2997	// succeed and there will likely be errors in render.
2998	if (!validType) {
2999	var info = '';
3000	if (type === undefined \|\| typeof type === 'object' && type !== null && Object.keys(type).length === 0) {
3001	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.";
3002	}
3003
3004	var sourceInfo = getSourceInfoErrorAddendum(props);
3005	if (sourceInfo) {
3006	info += sourceInfo;
3007	} else {
3008	info += getDeclarationErrorAddendum();
3009	}
3010
3011	var typeString = void 0;
3012	if (type === null) {
3013	typeString = 'null';
3014	} else if (Array.isArray(type)) {
3015	typeString = 'array';
3016	} else if (type !== undefined && type.$$typeof === REACT_ELEMENT_TYPE) {
3017	typeString = '<' + (getComponentName(type.type) \|\| 'Unknown') + ' />';
3018	info = ' Did you accidentally export a JSX literal instead of a component?';
3019	} else {
3020	typeString = typeof type;
3021	}
3022
3023	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);
3024	}
3025
3026	var element = createElement.apply(this, arguments);
3027
3028	// The result can be nullish if a mock or a custom function is used.
3029	// TODO: Drop this when these are no longer allowed as the type argument.
3030	if (element == null) {
3031	return element;
3032	}
3033
3034	// Skip key warning if the type isn't valid since our key validation logic
3035	// doesn't expect a non-string/function type and can throw confusing errors.
3036	// We don't want exception behavior to differ between dev and prod.
3037	// (Rendering will throw with a helpful message and as soon as the type is
3038	// fixed, the key warnings will appear.)
3039	if (validType) {
3040	for (var i = 2; i < arguments.length; i++) {
3041	validateChildKeys(arguments[i], type);
3042	}
3043	}
3044
3045	if (type === REACT_FRAGMENT_TYPE) {
3046	validateFragmentProps(element);
3047	} else {
3048	validatePropTypes(element);
3049	}
3050
3051	return element;
3052	}
3053
3054	function createFactoryWithValidation(type) {
3055	var validatedFactory = createElementWithValidation.bind(null, type);
3056	validatedFactory.type = type;
3057	// Legacy hook: remove it
3058	{
3059	Object.defineProperty(validatedFactory, 'type', {
3060	enumerable: false,
3061	get: function () {
3062	lowPriorityWarning$1(false, 'Factory.type is deprecated. Access the class directly ' + 'before passing it to createFactory.');
3063	Object.defineProperty(this, 'type', {
3064	value: type
3065	});
3066	return type;
3067	}
3068	});
3069	}
3070
3071	return validatedFactory;
3072	}
3073
3074	function cloneElementWithValidation(element, props, children) {
3075	var newElement = cloneElement.apply(this, arguments);
3076	for (var i = 2; i < arguments.length; i++) {
3077	validateChildKeys(arguments[i], newElement.type);
3078	}
3079	validatePropTypes(newElement);
3080	return newElement;
3081	}
3082
3083	var React = {
3084	Children: {
3085	map: mapChildren,
3086	forEach: forEachChildren,
3087	count: countChildren,
3088	toArray: toArray,
3089	only: onlyChild
3090	},
3091
3092	createRef: createRef,
3093	Component: Component,
3094	PureComponent: PureComponent,
3095
3096	createContext: createContext,
3097	forwardRef: forwardRef,
3098	lazy: lazy,
3099	memo: memo,
3100
3101	useCallback: useCallback,
3102	useContext: useContext,
3103	useEffect: useEffect,
3104	useImperativeHandle: useImperativeHandle,
3105	useDebugValue: useDebugValue,
3106	useLayoutEffect: useLayoutEffect,
3107	useMemo: useMemo,
3108	useReducer: useReducer,
3109	useRef: useRef,
3110	useState: useState,
3111
3112	Fragment: REACT_FRAGMENT_TYPE,
3113	StrictMode: REACT_STRICT_MODE_TYPE,
3114	Suspense: REACT_SUSPENSE_TYPE,
3115
3116	createElement: createElementWithValidation,
3117	cloneElement: cloneElementWithValidation,
3118	createFactory: createFactoryWithValidation,
3119	isValidElement: isValidElement,
3120
3121	version: ReactVersion,
3122
3123	unstable_ConcurrentMode: REACT_CONCURRENT_MODE_TYPE,
3124	unstable_Profiler: REACT_PROFILER_TYPE,
3125
3126	__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: ReactSharedInternals
3127	};
3128
3129	// Note: some APIs are added with feature flags.
3130	// Make sure that stable builds for open source
3131	// don't modify the React object to avoid deopts.
3132	// Also let's not expose their names in stable builds.
3133
3134	if (enableStableConcurrentModeAPIs) {
3135	React.ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
3136	React.Profiler = REACT_PROFILER_TYPE;
3137	React.unstable_ConcurrentMode = undefined;
3138	React.unstable_Profiler = undefined;
3139	}
3140
3141
3142
3143	var React$2 = Object.freeze({
3144	default: React
3145	});
3146
3147	var React$3 = ( React$2 && React ) \|\| React$2;
3148
3149	// TODO: decide on the top-level export form.
3150	// This is hacky but makes it work with both Rollup and Jest.
3151	var react = React$3.default \|\| React$3;
3152
3153	return react;
3154
3155	})));