https://app.sundaysky.com/client/vendor~index~newNavigation~Accoun…ISystemPromptManager~C~h0mf93xb.B-8UGg7U.js

1
2!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="d8057400-5c49-55c2-98ee-68a8d7930663")}catch(e){}}();
3import { a as __toCommonJS, n as __esmMin, o as __toESM, r as __exportAll, t as __commonJSMin } from "./rolldown-runtime.D1cXj70v.js";
4//#region node_modules/process/browser.js
5var require_browser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
6	var process = module.exports = {};
7	var cachedSetTimeout;
8	var cachedClearTimeout;
9	function defaultSetTimout() {
10		throw new Error("setTimeout has not been defined");
11	}
12	function defaultClearTimeout() {
13		throw new Error("clearTimeout has not been defined");
14	}
15	(function() {
16		try {
17			if (typeof setTimeout === "function") cachedSetTimeout = setTimeout;
18			else cachedSetTimeout = defaultSetTimout;
19		} catch (e) {
20			cachedSetTimeout = defaultSetTimout;
21		}
22		try {
23			if (typeof clearTimeout === "function") cachedClearTimeout = clearTimeout;
24			else cachedClearTimeout = defaultClearTimeout;
25		} catch (e) {
26			cachedClearTimeout = defaultClearTimeout;
27		}
28	})();
29	function runTimeout(fun) {
30		if (cachedSetTimeout === setTimeout) return setTimeout(fun, 0);
31		if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
32			cachedSetTimeout = setTimeout;
33			return setTimeout(fun, 0);
34		}
35		try {
36			return cachedSetTimeout(fun, 0);
37		} catch (e) {
38			try {
39				return cachedSetTimeout.call(null, fun, 0);
40			} catch (e) {
41				return cachedSetTimeout.call(this, fun, 0);
42			}
43		}
44	}
45	function runClearTimeout(marker) {
46		if (cachedClearTimeout === clearTimeout) return clearTimeout(marker);
47		if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
48			cachedClearTimeout = clearTimeout;
49			return clearTimeout(marker);
50		}
51		try {
52			return cachedClearTimeout(marker);
53		} catch (e) {
54			try {
55				return cachedClearTimeout.call(null, marker);
56			} catch (e) {
57				return cachedClearTimeout.call(this, marker);
58			}
59		}
60	}
61	var queue = [];
62	var draining = false;
63	var currentQueue;
64	var queueIndex = -1;
65	function cleanUpNextTick() {
66		if (!draining || !currentQueue) return;
67		draining = false;
68		if (currentQueue.length) queue = currentQueue.concat(queue);
69		else queueIndex = -1;
70		if (queue.length) drainQueue();
71	}
72	function drainQueue() {
73		if (draining) return;
74		var timeout = runTimeout(cleanUpNextTick);
75		draining = true;
76		var len = queue.length;
77		while (len) {
78			currentQueue = queue;
79			queue = [];
80			while (++queueIndex < len) if (currentQueue) currentQueue[queueIndex].run();
81			queueIndex = -1;
82			len = queue.length;
83		}
84		currentQueue = null;
85		draining = false;
86		runClearTimeout(timeout);
87	}
88	process.nextTick = function(fun) {
89		var args = new Array(arguments.length - 1);
90		if (arguments.length > 1) for (var i = 1; i < arguments.length; i++) args[i - 1] = arguments[i];
91		queue.push(new Item(fun, args));
92		if (queue.length === 1 && !draining) runTimeout(drainQueue);
93	};
94	function Item(fun, array) {
95		this.fun = fun;
96		this.array = array;
97	}
98	Item.prototype.run = function() {
99		this.fun.apply(null, this.array);
100	};
101	process.title = "browser";
102	process.browser = true;
103	process.env = {};
104	process.argv = [];
105	process.version = "";
106	process.versions = {};
107	function noop() {}
108	process.on = noop;
109	process.addListener = noop;
110	process.once = noop;
111	process.off = noop;
112	process.removeListener = noop;
113	process.removeAllListeners = noop;
114	process.emit = noop;
115	process.prependListener = noop;
116	process.prependOnceListener = noop;
117	process.listeners = function(name) {
118		return [];
119	};
120	process.binding = function(name) {
121		throw new Error("process.binding is not supported");
122	};
123	process.cwd = function() {
124		return "/";
125	};
126	process.chdir = function(dir) {
127		throw new Error("process.chdir is not supported");
128	};
129	process.umask = function() {
130		return 0;
131	};
132}));
133//#endregion
134//#region node_modules/react/cjs/react.production.min.js
135/**
136* @license React
137* react.production.min.js
138*
139* Copyright (c) Facebook, Inc. and its affiliates.
140*
141* This source code is licensed under the MIT license found in the
142* LICENSE file in the root directory of this source tree.
143*/
144var require_react_production_min = /* @__PURE__ */ __commonJSMin(((exports) => {
145	var l = Symbol.for("react.element");
146	var n = Symbol.for("react.portal");
147	var p = Symbol.for("react.fragment");
148	var q = Symbol.for("react.strict_mode");
149	var r = Symbol.for("react.profiler");
150	var t = Symbol.for("react.provider");
151	var u = Symbol.for("react.context");
152	var v = Symbol.for("react.forward_ref");
153	var w = Symbol.for("react.suspense");
154	var x = Symbol.for("react.memo");
155	var y = Symbol.for("react.lazy");
156	var z = Symbol.iterator;
157	function A(a) {
158		if (null === a || "object" !== typeof a) return null;
159		a = z && a[z] || a["@@iterator"];
160		return "function" === typeof a ? a : null;
161	}
162	var B = {
163		isMounted: function() {
164			return !1;
165		},
166		enqueueForceUpdate: function() {},
167		enqueueReplaceState: function() {},
168		enqueueSetState: function() {}
169	};
170	var C = Object.assign;
171	var D = {};
172	function E(a, b, e) {
173		this.props = a;
174		this.context = b;
175		this.refs = D;
176		this.updater = e || B;
177	}
178	E.prototype.isReactComponent = {};
179	E.prototype.setState = function(a, b) {
180		if ("object" !== typeof a && "function" !== typeof a && null != a) throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");
181		this.updater.enqueueSetState(this, a, b, "setState");
182	};
183	E.prototype.forceUpdate = function(a) {
184		this.updater.enqueueForceUpdate(this, a, "forceUpdate");
185	};
186	function F() {}
187	F.prototype = E.prototype;
188	function G(a, b, e) {
189		this.props = a;
190		this.context = b;
191		this.refs = D;
192		this.updater = e || B;
193	}
194	var H = G.prototype = new F();
195	H.constructor = G;
196	C(H, E.prototype);
197	H.isPureReactComponent = !0;
198	var I = Array.isArray;
199	var J = Object.prototype.hasOwnProperty;
200	var K = { current: null };
201	var L = {
202		key: !0,
203		ref: !0,
204		__self: !0,
205		__source: !0
206	};
207	function M(a, b, e) {
208		var d, c = {}, k = null, h = null;
209		if (null != b) for (d in void 0 !== b.ref && (h = b.ref), void 0 !== b.ke

209y && (k = "" + b.key), b) J.call(b, d) && !L.hasOwnProperty(d) && (c[d] = b[d]);
210		var g = arguments.length - 2;
211		if (1 === g) c.children = e;
212		else if (1 < g) {
213			for (var f = Array(g), m = 0; m < g; m++) f[m] = arguments[m + 2];
214			c.children = f;
215		}
216		if (a && a.defaultProps) for (d in g = a.defaultProps, g) void 0 === c[d] && (c[d] = g[d]);
217		return {
218			$$typeof: l,
219			type: a,
220			key: k,
221			ref: h,
222			props: c,
223			_owner: K.current
224		};
225	}
226	function N(a, b) {
227		return {
228			$$typeof: l,
229			type: a.type,
230			key: b,
231			ref: a.ref,
232			props: a.props,
233			_owner: a._owner
234		};
235	}
236	function O(a) {
237		return "object" === typeof a && null !== a && a.$$typeof === l;
238	}
239	function escape(a) {
240		var b = {
241			"=": "=0",
242			":": "=2"
243		};
244		return "$" + a.replace(/[=:]/g, function(a) {
245			return b[a];
246		});
247	}
248	var P = /\/+/g;
249	function Q(a, b) {
250		return "object" === typeof a && null !== a && null != a.key ? escape("" + a.key) : b.toString(36);
251	}
252	function R(a, b, e, d, c) {
253		var k = typeof a;
254		if ("undefined" === k || "boolean" === k) a = null;
255		var h = !1;
256		if (null === a) h = !0;
257		else switch (k) {
258			case "string":
259			case "number":
260				h = !0;
261				break;
262			case "object": switch (a.$$typeof) {
263				case l:
264				case n: h = !0;
265			}
266		}
267		if (h) return h = a, c = c(h), a = "" === d ? "." + Q(h, 0) : d, I(c) ? (e = "", null != a && (e = a.replace(P, "$&/") + "/"), R(c, b, e, "", function(a) {
268			return a;
269		})) : null != c && (O(c) && (c = N(c, e + (!c.key || h && h.key === c.key ? "" : ("" + c.key).replace(P, "$&/") + "/") + a)), b.push(c)), 1;
270		h = 0;
271		d = "" === d ? "." : d + ":";
272		if (I(a)) for (var g = 0; g < a.length; g++) {
273			k = a[g];
274			var f = d + Q(k, g);
275			h += R(k, b, e, f, c);
276		}
277		else if (f = A(a), "function" === typeof f) for (a = f.call(a), g = 0; !(k = a.next()).done;) k = k.value, f = d + Q(k, g++), h += R(k, b, e, f, c);
278		else if ("object" === k) throw b = String(a), Error("Objects are not valid as a React child (found: " + ("[object Object]" === b ? "object with keys {" + Object.keys(a).join(", ") + "}" : b) + "). If you meant to render a collection of children, use an array instead.");
279		return h;
280	}
281	function S(a, b, e) {
282		if (null == a) return a;
283		var d = [], c = 0;
284		R(a, d, "", "", function(a) {
285			return b.call(e, a, c++);
286		});
287		return d;
288	}
289	function T(a) {
290		if (-1 === a._status) {
291			var b = a._result;
292			b = b();
293			b.then(function(b) {
294				if (0 === a._status || -1 === a._status) a._status = 1, a._result = b;
295			}, function(b) {
296				if (0 === a._status || -1 === a._status) a._status = 2, a._result = b;
297			});
298			-1 === a._status && (a._status = 0, a._result = b);
299		}
300		if (1 === a._status) return a._result.default;
301		throw a._result;
302	}
303	var U = { current: null };
304	var V = { transition: null };
305	var W = {
306		ReactCurrentDispatcher: U,
307		ReactCurrentBatchConfig: V,
308		ReactCurrentOwner: K
309	};
310	function X() {
311		throw Error("act(...) is not supported in production builds of React.");
312	}
313	exports.Children = {
314		map: S,
315		forEach: function(a, b, e) {
316			S(a, function() {
317				b.apply(this, arguments);
318			}, e);
319		},
320		count: function(a) {
321			var b = 0;
322			S(a, function() {
323				b++;
324			});
325			return b;
326		},
327		toArray: function(a) {
328			return S(a, function(a) {
329				return a;
330			}) || [];
331		},
332		only: function(a) {
333			if (!O(a)) throw Error("React.Children.only expected to receive a single React element child.");
334			return a;
335		}
336	};
337	exports.Component = E;
338	exports.Fragment = p;
339	exports.Profiler = r;
340	exports.PureComponent = G;
341	exports.StrictMode = q;
342	exports.Suspense = w;
343	exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = W;
344	exports.act = X;
345	exports.cloneElement = function(a, b, e) {
346		if (null === a || void 0 === a) throw Error("React.cloneElement(...): The argument must be a React element, but you passed " + a + ".");
347		var d = C({}, a.props), c = a.key, k = a.ref, h = a._owner;
348		if (null != b) {
349			void 0 !== b.ref && (k = b.ref, h = K.current);
350			void 0 !== b.key && (c = "" + b.key);
351			if (a.type && a.type.defaultProps) var g = a.type.defaultProps;
352			for (f in b) J.call(b, f) && !L.hasOwnProperty(f) && (d[f] = void 0 === b[f] && void 0 !== g ? g[f] : b[f]);
353		}
354		var f = arguments.length - 2;
355		if (1 === f) d.children = e;
356		else if (1 < f) {
357			g = Array(f);
358			for (var m = 0; m < f; m++) g[m] = arguments[m + 2];
359			d.children = g;
360		}
361		return {
362			$$typeof: l,
363			type: a.type,
364			key: c,
365			ref: k,
366			props: d,
367			_owner: h
368		};
369	};
370	exports.createContext = function(a) {
371		a = {
372			$$typeof: u,
373			_currentValue: a,
374			_currentValue2: a,
375			_threadCount: 0,
376			Provider: null,
377			Consumer: null,
378			_defaultValue: null,
379			_globalName: null
380		};
381		a.Provider = {
382			$$typeof: t,
383			_context: a
384		};
385		return a.Consumer = a;
386	};
387	exports.createElement = M;
388	exports.createFactory = function(a) {
389		var b = M.bind(null, a);
390		b.type = a;
391		return b;
392	};
393	exports.createRef = function() {
394		return { current: null };
395	};
396	exports.forwardRef = function(a) {
397		return {
398			$$typeof: v,
399			render: a
400		};
401	};
402	exports.isValidElement = O;
403	exports.lazy = function(a) {
404		return {
405			$$typeof: y,
406			_payload: {
407				_status: -1,
408				_result: a
409			},
410			_init: T
411		};
412	};
413	exports.memo = function(a, b) {
414		return {
415			$$typeof: x,
416			type: a,

417			compare: void 0 === b ? null : b
418		};
419	};
420	exports.startTransition = function(a) {
421		var b = V.transition;
422		V.transition = {};
423		try {
424			a();
425		} finally {
426			V.transition = b;
427		}
428	};
429	exports.unstable_act = X;
430	exports.useCallback = function(a, b) {
431		return U.current.useCallback(a, b);
432	};
433	exports.useContext = function(a) {
434		return U.current.useContext(a);
435	};
436	exports.useDebugValue = function() {};
437	exports.useDeferredValue = function(a) {
438		return U.current.useDeferredValue(a);
439	};
440	exports.useEffect = function(a, b) {
441		return U.current.useEffect(a, b);
442	};
443	exports.useId = function() {
444		return U.current.useId();
445	};
446	exports.useImperativeHandle = function(a, b, e) {
447		return U.current.useImperativeHandle(a, b, e);
448	};
449	exports.useInsertionEffect = function(a, b) {
450		return U.current.useInsertionEffect(a, b);
451	};
452	exports.useLayoutEffect = function(a, b) {
453		return U.current.useLayoutEffect(a, b);
454	};
455	exports.useMemo = function(a, b) {
456		return U.current.useMemo(a, b);
457	};
458	exports.useReducer = function(a, b, e) {
459		return U.current.useReducer(a, b, e);
460	};
461	exports.useRef = function(a) {
462		return U.current.useRef(a);
463	};
464	exports.useState = function(a) {
465		return U.current.useState(a);
466	};
467	exports.useSyncExternalStore = function(a, b, e) {
468		return U.current.useSyncExternalStore(a, b, e);
469	};
470	exports.useTransition = function() {
471		return U.current.useTransition();
472	};
473	exports.version = "18.3.1";
474}));
475//#endregion
476//#region node_modules/react/cjs/react.development.js
477var require_react_development = /* @__PURE__ */ __commonJSMin(((exports, module) => {
478	/**
479	* @license React
480	* react.development.js
481	*
482	* Copyright (c) Facebook, Inc. and its affiliates.
483	*
484	* This source code is licensed under the MIT license found in the
485	* LICENSE file in the root directory of this source tree.
486	*/
487	if (require_browser().env.NODE_ENV !== "production") (function() {
488		"use strict";
489		if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === "function") __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(/* @__PURE__ */ new Error());
490		var ReactVersion = "18.3.1";
491		var REACT_ELEMENT_TYPE = Symbol.for("react.element");
492		var REACT_PORTAL_TYPE = Symbol.for("react.portal");
493		var REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
494		var REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode");
495		var REACT_PROFILER_TYPE = Symbol.for("react.profiler");
496		var REACT_PROVIDER_TYPE = Symbol.for("react.provider");
497		var REACT_CONTEXT_TYPE = Symbol.for("react.context");
498		var REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref");
499		var REACT_SUSPENSE_TYPE = Symbol.for("react.suspense");
500		var REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list");
501		var REACT_MEMO_TYPE = Symbol.for("react.memo");
502		var REACT_LAZY_TYPE = Symbol.for("react.lazy");
503		var REACT_OFFSCREEN_TYPE = Symbol.for("react.offscreen");
504		var MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
505		var FAUX_ITERATOR_SYMBOL = "@@iterator";
506		function getIteratorFn(maybeIterable) {
507			if (maybeIterable === null || typeof maybeIterable !== "object") return null;
508			var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
509			if (typeof maybeIterator === "function") return maybeIterator;
510			return null;
511		}
512		/**
513		* Keeps track of the current dispatcher.
514		*/
515		var ReactCurrentDispatcher = { 
516		/**
517		* @internal
518		* @type {ReactComponent}
519		*/
520current: null };
521		/**
522		* Keeps track of the current batch's configuration such as how long an update
523		* should suspend for if it needs to.
524		*/
525		var ReactCurrentBatchConfig = { transition: null };
526		var ReactCurrentActQueue = {
527			current: null,
528			isBatchingLegacy: false,
529			didScheduleLegacyUpdate: false
530		};
531		/**
532		* Keeps track of the current owner.
533		*
534		* The current owner is the component who should own any components that are
535		* currently being constructed.
536		*/
537		var ReactCurrentOwner = { 
538		/**
539		* @internal
540		* @type {ReactComponent}
541		*/
542current: null };
543		var ReactDebugCurrentFrame = {};
544		var currentExtraStackFrame = null;
545		function setExtraStackFrame(stack) {
546			currentExtraStackFrame = stack;
547		}
548		ReactDebugCurrentFrame.setExtraStackFrame = function(stack) {
549			currentExtraStackFrame = stack;
550		};
551		ReactDebugCurrentFrame.getCurrentStack = null;
552		ReactDebugCurrentFrame.getStackAddendum = function() {
553			var stack = "";
554			if (currentExtraStackFrame) stack += currentExtraStackFrame;
555			var impl = ReactDebugCurrentFrame.getCurrentStack;
556			if (impl) stack += impl() || "";
557			return stack;
558		};
559		var enableScopeAPI = false;

560		var enableCacheElement = false;
561		var enableTransitionTracing = false;
562		var enableLegacyHidden = false;
563		var enableDebugTracing = false;
564		var ReactSharedInternals = {
565			ReactCurrentDispatcher,
566			ReactCurrentBatchConfig,
567			ReactCurrentOwner
568		};
569		ReactSharedInternals.ReactDebugCurrentFrame = ReactDebugCurrentFrame;
570		ReactSharedInternals.ReactCurrentActQueue = ReactCurrentActQueue;
571		function warn(format) {
572			for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) args[_key - 1] = arguments[_key];
573			printWarning("warn", format, args);
574		}
575		function error(format) {
576			for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) args[_key2 - 1] = arguments[_key2];
577			printWarning("error", format, args);
578		}
579		function printWarning(level, format, args) {
580			var stack = ReactSharedInternals.ReactDebugCurrentFrame.getStackAddendum();
581			if (stack !== "") {
582				format += "%s";
583				args = args.concat([stack]);
584			}
585			var argsWithFormat = args.map(function(item) {
586				return String(item);
587			});
588			argsWithFormat.unshift("Warning: " + format);
589			Function.prototype.apply.call(console[level], console, argsWithFormat);
590		}
591		var didWarnStateUpdateForUnmountedComponent = {};
592		function warnNoop(publicInstance, callerName) {
593			var _constructor = publicInstance.constructor;
594			var componentName = _constructor && (_constructor.displayName || _constructor.name) || "ReactClass";
595			var warningKey = componentName + "." + callerName;
596			if (didWarnStateUpdateForUnmountedComponent[warningKey]) return;
597			error("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);
598			didWarnStateUpdateForUnmountedComponent[warningKey] = true;
599		}
600		/**
601		* This is the abstract API for an update queue.
602		*/
603		var ReactNoopUpdateQueue = {
604			/**
605			* Checks whether or not this composite component is mounted.
606			* @param {ReactClass} publicInstance The instance we want to test.
607			* @return {boolean} True if mounted, false otherwise.
608			* @protected
609			* @final
610			*/
611			isMounted: function(publicInstance) {
612				return false;
613			},
614			/**
615			* Forces an update. This should only be invoked when it is known with
616			* certainty that we are **not** in a DOM transaction.
617			*
618			* You may want to call this when you know that some deeper aspect of the
619			* component's state has changed but `setState` was not called.
620			*
621			* This will not invoke `shouldComponentUpdate`, but it will invoke
622			* `componentWillUpdate` and `componentDidUpdate`.
623			*
624			* @param {ReactClass} publicInstance The instance that should rerender.
625			* @param {?function} callback Called after component is updated.
626			* @param {?string} callerName name of the calling function in the public API.
627			* @internal
628			*/
629			enqueueForceUpdate: function(publicInstance, callback, callerName) {
630				warnNoop(publicInstance, "forceUpdate");
631			},
632			/**
633			* Replaces all of the state. Always use this or `setState` to mutate state.
634			* You should treat `this.state` as immutable.
635			*
636			* There is no guarantee that `this.state` will be immediately updated, so
637			* accessing `this.state` after calling this method may return the old value.
638			*
639			* @param {ReactClass} publicInstance The instance that should rerender.
640			* @param {object} completeState Next state.
641			* @param {?function} callback Called after component is updated.
642			* @param {?string} callerName name of the calling function in the public API.
643			* @internal
644			*/
645			enqueueReplaceState: function(publicInstance, completeState, callback, callerName) {
646				warnNoop(publicInstance, "replaceState");
647			},
648			/**
649			* Sets a subset of the state. This only exists because _pendingState is
650			* internal. This provides a merging strategy that is not available to deep
651			* properties which is confusing. TODO: Expose pendingState or don't use it
652			* during the merge.
653			*
654			* @param {ReactClass} publicInstance The instance that should rerender.
655			* @param {object} partialState Next partial state to be merged with state.
656			* @param {?function} callback Called after component is updated.
657			* @param {?string} Name of the calling function in the public API.
658			* @internal
659			*/
660			enqueueSetState: function(publicInstance, partialState, callback, callerName) {
661				warnNoop(publicInstance, "setState");
662			}
663		};
664		var assign = Object.assign;
665		var emptyObject = {};
666		Object.freeze(emptyObject);
667		/**
668		* Base class helpers for the updating state of a component.
669		*/
670		function Component(props, context, updater) {
671			this.props = props;
672			this.context = context;
673			this.refs = emptyObject;
674			this.updater = updater || ReactNoopUpdateQueue;
675		}
676		Component.prototype.isReactComponent = {};
677		/**
678		* Sets a subset of the state. Always use this to mutate
679		* state. You should treat `this.state` as immutable.
680		*
681		* There is no guarantee that `this.state` will be immediately updated, so
682		* accessing `this.state` after calling this method may return the old value.
683		*
684		* There is no guarantee that calls to `setState` will run synchronously,
685		* as they may eventually be batched together.  You can provide an optional
686		* callback that will be executed when the call to setState is actually
687		* completed.
688		*
689		* When a function is provided to setState, it will be called at some point in
690		* the future (not synchronously). It will be called with the up to date
691		* component arguments (state, props, context). These values can be different
692		* from this.* because your function may be called after receiveProps but before
693		* shouldComponentUpdate, and this new state, props, and context will not yet be
694		* assigned to this.
695		*
696		* @param {object|function} partialState Next partial state or function to
697		*        produce next partial state to be merged with current state.
698		* @param {?function} callback Called after state is updated.
699		* @final
700		* @protected
701		*/
702		Component.prototype.setState = function(partialState, callback) {
703			if (typeof partialState !== "object" && typeof partialState !== "function" && partialState != null) throw new Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");
704			this.updater.enqueueSetState(this, partialState, callback, "setState");
705		};
706		/**
707		* Forces an update. This should only be invoked when it is known with
708		* certainty that we are **not** in a DOM transaction.
709		*
710		* You may want to call this when you know that some deeper aspect of the
711		* component's state has changed but `setState` was not called.
712		*
713		* This will not invoke `shouldComponentUpdate`, but it will invoke
714		* `componentWillUpdate` and `componentDidUpdate`.
715		*
716		* @param {?function} callback Called after update is complete.
717		* @final
718		* @protected
719		*/
720		Component.prototype.forceUpdate = function(callback) {
721			this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
722		};
723		var deprecatedAPIs = {
724			isMounted: ["isMounted", "Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks."],

725			replaceState: ["replaceState", "Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)."]
726		};
727		var defineDeprecationWarning = function(methodName, info) {
728			Object.defineProperty(Component.prototype, methodName, { get: function() {
729				warn("%s(...) is deprecated in plain JavaScript React classes. %s", info[0], info[1]);
730			} });
731		};
732		for (var fnName in deprecatedAPIs) if (deprecatedAPIs.hasOwnProperty(fnName)) defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);
733		function ComponentDummy() {}
734		ComponentDummy.prototype = Component.prototype;
735		/**
736		* Convenience component with default shallow equality check for sCU.
737		*/
738		function PureComponent(props, context, updater) {
739			this.props = props;
740			this.context = context;
741			this.refs = emptyObject;
742			this.updater = updater || ReactNoopUpdateQueue;
743		}
744		var pureComponentPrototype = PureComponent.prototype = new ComponentDummy();
745		pureComponentPrototype.constructor = PureComponent;
746		assign(pureComponentPrototype, Component.prototype);
747		pureComponentPrototype.isPureReactComponent = true;
748		function createRef() {
749			var refObject = { current: null };
750			Object.seal(refObject);
751			return refObject;
752		}
753		var isArrayImpl = Array.isArray;
754		function isArray(a) {
755			return isArrayImpl(a);
756		}
757		function typeName(value) {
758			return typeof Symbol === "function" && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
759		}
760		function willCoercionThrow(value) {
761			try {
762				testStringCoercion(value);
763				return false;
764			} catch (e) {
765				return true;
766			}
767		}
768		function testStringCoercion(value) {
769			return "" + value;
770		}
771		function checkKeyStringCoercion(value) {
772			if (willCoercionThrow(value)) {
773				error("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", typeName(value));
774				return testStringCoercion(value);
775			}
776		}
777		function getWrappedName(outerType, innerType, wrapperName) {
778			var displayName = outerType.displayName;
779			if (displayName) return displayName;
780			var functionName = innerType.displayName || innerType.name || "";
781			return functionName !== "" ? wrapperName + "(" + functionName + ")" : wrapperName;
782		}
783		function getContextName(type) {
784			return type.displayName || "Context";
785		}
786		function getComponentNameFromType(type) {
787			if (type == null) return null;
788			if (typeof type.tag === "number") error("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue.");
789			if (typeof type === "function") return type.displayName || type.name || null;
790			if (typeof type === "string") return type;
791			switch (type) {
792				case REACT_FRAGMENT_TYPE: return "Fragment";
793				case REACT_PORTAL_TYPE: return "Portal";
794				case REACT_PROFILER_TYPE: return "Profiler";
795				case REACT_STRICT_MODE_TYPE: return "StrictMode";
796				case REACT_SUSPENSE_TYPE: return "Suspense";
797				case REACT_SUSPENSE_LIST_TYPE: return "SuspenseList";
798			}
799			if (typeof type === "object") switch (type.$$typeof) {
800				case REACT_CONTEXT_TYPE: return getContextName(type) + ".Consumer";
801				case REACT_PROVIDER_TYPE: return getContextName(type._context) + ".Provider";
802				case REACT_FORWARD_REF_TYPE: return getWrappedName(type, type.render, "ForwardRef");
803				case REACT_MEMO_TYPE:
804					var outerName = type.displayName || null;
805					if (outerName !== null) return outerName;
806					return getComponentNameFromType(type.type) || "Memo";
807				case REACT_LAZY_TYPE:
808					var lazyComponent = type;
809					var payload = lazyComponent._payload;
810					var init = lazyComponent._init;
811					try {
812						return getComponentNameFromType(init(payload));
813					} catch (x) {
814						return null;
815					}
816			}
817			return null;
818		}
819		var hasOwnProperty = Object.prototype.hasOwnProperty;
820		var RESERVED_PROPS = {
821			key: true,
822			ref: true,
823			__self: true,
824			__source: true
825		};
826		var specialPropKeyWarningShown, specialPropRefWarningShown, didWarnAboutStringRefs = {};
827		function hasValidRef(config) {
828			if (hasOwnProperty.call(config, "ref")) {
829				var getter = Object.getOwnPropertyDescriptor(config, "ref").get;
830				if (getter && getter.isReactWarning) return false;

831			}
832			return config.ref !== void 0;
833		}
834		function hasValidKey(config) {
835			if (hasOwnProperty.call(config, "key")) {
836				var getter = Object.getOwnPropertyDescriptor(config, "key").get;
837				if (getter && getter.isReactWarning) return false;
838			}
839			return config.key !== void 0;
840		}
841		function defineKeyPropWarningGetter(props, displayName) {
842			var warnAboutAccessingKey = function() {
843				if (!specialPropKeyWarningShown) {
844					specialPropKeyWarningShown = true;
845					error("%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://reactjs.org/link/special-props)", displayName);
846				}
847			};
848			warnAboutAccessingKey.isReactWarning = true;
849			Object.defineProperty(props, "key", {
850				get: warnAboutAccessingKey,
851				configurable: true
852			});
853		}
854		function defineRefPropWarningGetter(props, displayName) {
855			var warnAboutAccessingRef = function() {
856				if (!specialPropRefWarningShown) {
857					specialPropRefWarningShown = true;
858					error("%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://reactjs.org/link/special-props)", displayName);
859				}
860			};
861			warnAboutAccessingRef.isReactWarning = true;
862			Object.defineProperty(props, "ref", {
863				get: warnAboutAccessingRef,
864				configurable: true
865			});
866		}
867		function warnIfStringRefCannotBeAutoConverted(config) {
868			if (typeof config.ref === "string" && ReactCurrentOwner.current && config.__self && ReactCurrentOwner.current.stateNode !== config.__self) {
869				var componentName = getComponentNameFromType(ReactCurrentOwner.current.type);
870				if (!didWarnAboutStringRefs[componentName]) {
871					error("Component \"%s\" contains the string ref \"%s\". Support for string refs will be removed in a future major release. This case cannot be automatically converted to an arrow function. We ask you to manually fix this case by using useRef() or createRef() instead. Learn more about using refs safely here: https://reactjs.org/link/strict-mode-string-ref", componentName, config.ref);
872					didWarnAboutStringRefs[componentName] = true;
873				}
874			}
875		}
876		/**
877		* Factory method to create a new React element. This no longer adheres to
878		* the class pattern, so do not use new to call it. Also, instanceof check
879		* will not work. Instead test $$typeof field against Symbol.for('react.element') to check
880		* if something is a React Element.
881		*
882		* @param {*} type
883		* @param {*} props
884		* @param {*} key
885		* @param {string|object} ref
886		* @param {*} owner
887		* @param {*} self A *temporary* helper to detect places where `this` is
888		* different from the `owner` when React.createElement is called, so that we
889		* can warn. We want to get rid of owner and replace string `ref`s with arrow
890		* functions, and as long as `this` and owner are the same, there will be no
891		* change in behavior.
892		* @param {*} source An annotation object (added by a transpiler or otherwise)
893		* indicating filename, line number, and/or other information.
894		* @internal
895		*/
896		var ReactElement = function(type, key, ref, self, source, owner, props) {
897			var element = {
898				$$typeof: REACT_ELEMENT_TYPE,
899				type,
900				key,
901				ref,
902				props,
903				_owner: owner
904			};
905			element._store = {};
906			Object.defineProperty(element._store, "validated", {
907				configurable: false,
908				enumerable: false,
909				writable: true,
910				value: false
911			});
912			Object.defineProperty(element, "_self", {
913				configurable: false,
914				enumerable: false,
915				writable: false,
916				value: self
917			});
918			Object.defineProperty(element, "_source", {
919				configurable: false,
920				enumerable: false,
921				writable: false,
922				value: source
923			});
924			if (Object.freeze) {
925				Object.freeze(element.props);
926				Object.freeze(element);
927			}
928			return element;
929		};
930		/**
931		* Create and return a new ReactElement of the given type.
932		* See https://reactjs.org/docs/react-api.html#createelement
933		*/
934		function createElement(type, config, children) {
935			var propName;
936			var props = {};
937			var key = null;
938			var ref = null;
939			var self = null;
940			var source = null;
941			if (config != null) {
942				if (hasValidRef(config)) {
943					ref = config.ref;
944					warnIfStringRefCannotBeAutoConverted(config);
945				}
946				if (hasValidKey(config)) {
947					checkKeyStringCoercion(config.key);
948					key = "" + config.key;
949				}
950				self = config.__self === void 0 ? null : config.__self;
951				source = config.__source === void 0 ? null : config.__source;
952				for (propName in config) if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) props[propName] = config[propName];
953			}
954			var childrenLength = arguments.length - 2;
955			if (childrenLength === 1) props.children = children;
956			else if (childrenLength > 1) {
957				var childArray = Array(childrenLength);
958				for (var i = 0; i < childrenLength; i++) childArray[i] = arguments[i + 2];
959				if (Object.freeze) Object.freeze(childArray);
960				props.children = childArray;
961			}
962			if (type && type.defaultProps) {
963				var defaultProps = type.defaultProps;
964				for (propName in defaultProps) if (props[propName] === void 0) props[propName] = defaultProps[propName];
965			}
966			if (key || ref) {
967				var displayName = typeof type === "function" ? type.displayName || type.name || "Unknown" : type;
968				if (key) defineKeyPropWarningGetter(props, displayName);
969				if (ref) defineRefPropWarningGetter(props, displayName);
970			}
971			return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
972		}
973		function cloneAndReplaceKey(oldElement, newKey) {
974			return ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props);
975		}
976		/**
977		* Clone and return a new ReactElement using element as the starting point.
978		* See https://reactjs.org/docs/react-api.html#cloneelement
979		*/
980		function cloneElement(element, config, children) {
981			if (element === null || element === void 0) throw new Error("React.cloneElement(...): The argument must be a React element, but you passed " + element + ".");
982			var propName;
983			var props = assign({}, element.props);
984			var key = element.key;
985			var ref = element.ref;
986			var self = element._self;
987			var source = element._source;
988			var owner = element._owner;
989			if (config != null) {
990				if (hasValidRef(config)) {
991					ref = config.ref;
992					owner = ReactCurrentOwner.current;
993				}
994				if (hasValidKey(config)) {
995					checkKeyStringCoercion(config.key);
996					key = "" + config.key;
997				}
998				var defaultProps;
999				if (element.type && element.type.defaultProps) defaultProps = element.type.defaultProps;
1000				for (propName in config) if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) if (config[propName] === void 0 && defaultProps !== void 0) props[propName] = defaultProps[propName];
1001				else props[propName] = config[propName];
1002			}
1003			var childrenLength = arguments.length - 2;
1004			if (childrenLength === 1) props.children = children;
1005			else if (childrenLength > 1) {
1006				var childArray = Array(childrenLength);
1007				for (var i = 0; i < childrenLength; i++) childArray[i] = arguments[i + 2];
1008				props.children = childArray;
1009			}
1010			return ReactElement(element.type, key, ref, self, source, owner, props);
1011		}
1012		/**
1013		* Verifies the object is a ReactElement.

1014		* See https://reactjs.org/docs/react-api.html#isvalidelement
1015		* @param {?object} object
1016		* @return {boolean} True if `object` is a ReactElement.
1017		* @final
1018		*/
1019		function isValidElement(object) {
1020			return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
1021		}
1022		var SEPARATOR = ".";
1023		var SUBSEPARATOR = ":";
1024		/**
1025		* Escape and wrap key so it is safe to use as a reactid
1026		*
1027		* @param {string} key to be escaped.
1028		* @return {string} the escaped key.
1029		*/
1030		function escape(key) {
1031			var escapeRegex = /[=:]/g;
1032			var escaperLookup = {
1033				"=": "=0",
1034				":": "=2"
1035			};
1036			return "$" + key.replace(escapeRegex, function(match) {
1037				return escaperLookup[match];
1038			});
1039		}
1040		/**
1041		* TODO: Test that a single child and an array with one item have the same key
1042		* pattern.
1043		*/
1044		var didWarnAboutMaps = false;
1045		var userProvidedKeyEscapeRegex = /\/+/g;
1046		function escapeUserProvidedKey(text) {
1047			return text.replace(userProvidedKeyEscapeRegex, "$&/");
1048		}
1049		/**
1050		* Generate a key string that identifies a element within a set.
1051		*
1052		* @param {*} element A element that could contain a manual key.
1053		* @param {number} index Index that is used if a manual key is not provided.
1054		* @return {string}
1055		*/
1056		function getElementKey(element, index) {
1057			if (typeof element === "object" && element !== null && element.key != null) {
1058				checkKeyStringCoercion(element.key);
1059				return escape("" + element.key);
1060			}
1061			return index.toString(36);
1062		}
1063		function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
1064			var type = typeof children;
1065			if (type === "undefined" || type === "boolean") children = null;
1066			var invokeCallback = false;
1067			if (children === null) invokeCallback = true;
1068			else switch (type) {
1069				case "string":
1070				case "number":
1071					invokeCallback = true;
1072					break;
1073				case "object": switch (children.$$typeof) {
1074					case REACT_ELEMENT_TYPE:
1075					case REACT_PORTAL_TYPE: invokeCallback = true;
1076				}
1077			}
1078			if (invokeCallback) {
1079				var _child = children;
1080				var mappedChild = callback(_child);
1081				var childKey = nameSoFar === "" ? SEPARATOR + getElementKey(_child, 0) : nameSoFar;
1082				if (isArray(mappedChild)) {
1083					var escapedChildKey = "";
1084					if (childKey != null) escapedChildKey = escapeUserProvidedKey(childKey) + "/";
1085					mapIntoArray(mappedChild, array, escapedChildKey, "", function(c) {
1086						return c;
1087					});
1088				} else if (mappedChild != null) {
1089					if (isValidElement(mappedChild)) {
1090						if (mappedChild.key && (!_child || _child.key !== mappedChild.key)) checkKeyStringCoercion(mappedChild.key);
1091						mappedChild = cloneAndReplaceKey(mappedChild, escapedPrefix + (mappedChild.key && (!_child || _child.key !== mappedChild.key) ? escapeUserProvidedKey("" + mappedChild.key) + "/" : "") + childKey);
1092					}
1093					array.push(mappedChild);
1094				}
1095				return 1;
1096			}
1097			var child;
1098			var nextName;
1099			var subtreeCount = 0;

1100			var nextNamePrefix = nameSoFar === "" ? SEPARATOR : nameSoFar + SUBSEPARATOR;
1101			if (isArray(children)) for (var i = 0; i < children.length; i++) {
1102				child = children[i];
1103				nextName = nextNamePrefix + getElementKey(child, i);
1104				subtreeCount += mapIntoArray(child, array, escapedPrefix, nextName, callback);
1105			}
1106			else {
1107				var iteratorFn = getIteratorFn(children);
1108				if (typeof iteratorFn === "function") {
1109					var iterableChildren = children;
1110					if (iteratorFn === iterableChildren.entries) {
1111						if (!didWarnAboutMaps) warn("Using Maps as children is not supported. Use an array of keyed ReactElements instead.");
1112						didWarnAboutMaps = true;
1113					}
1114					var iterator = iteratorFn.call(iterableChildren);
1115					var step;
1116					var ii = 0;
1117					while (!(step = iterator.next()).done) {
1118						child = step.value;
1119						nextName = nextNamePrefix + getElementKey(child, ii++);
1120						subtreeCount += mapIntoArray(child, array, escapedPrefix, nextName, callback);
1121					}
1122				} else if (type === "object") {
1123					var childrenString = String(children);
1124					throw new Error("Objects are not valid as a React child (found: " + (childrenString === "[object Object]" ? "object with keys {" + Object.keys(children).join(", ") + "}" : childrenString) + "). If you meant to render a collection of children, use an array instead.");
1125				}
1126			}
1127			return subtreeCount;
1128		}
1129		/**
1130		* Maps children that are typically specified as `props.children`.
1131		*
1132		* See https://reactjs.org/docs/react-api.html#reactchildrenmap
1133		*
1134		* The provided mapFunction(child, index) will be called for each
1135		* leaf child.
1136		*
1137		* @param {?*} children Children tree container.
1138		* @param {function(*, int)} func The map function.
1139		* @param {*} context Context for mapFunction.
1140		* @return {object} Object containing the ordered map of results.
1141		*/
1142		function mapChildren(children, func, context) {
1143			if (children == null) return children;
1144			var result = [];
1145			var count = 0;
1146			mapIntoArray(children, result, "", "", function(child) {
1147				return func.call(context, child, count++);
1148			});
1149			return result;
1150		}
1151		/**
1152		* Count the number of children that are typically specified as
1153		* `props.children`.
1154		*
1155		* See https://reactjs.org/docs/react-api.html#reactchildrencount
1156		*
1157		* @param {?*} children Children tree container.
1158		* @return {number} The number of children.
1159		*/
1160		function countChildren(children) {
1161			var n = 0;
1162			mapChildren(children, function() {
1163				n++;
1164			});
1165			return n;
1166		}
1167		/**
1168		* Iterates through children that are typically specified as `props.children`.
1169		*
1170		* See https://reactjs.org/docs/react-api.html#reactchildrenforeach
1171		*
1172		* The provided forEachFunc(child, index) will be called for each
1173		* leaf child.
1174		*
1175		* @param {?*} children Children tree container.
1176		* @param {function(*, int)} forEachFunc
1177		* @param {*} forEachContext Context for forEachContext.
1178		*/
1179		function forEachChildren(children, forEachFunc, forEachContext) {
1180			mapChildren(children, function() {
1181				forEachFunc.apply(this, arguments);
1182			}, forEachContext);
1183		}
1184		/**
1185		* Flatten a children object (typically specified as `props.children`) and
1186		* return an array with appropriately re-keyed children.
1187		*
1188		* See https://reactjs.org/docs/react-api.html#reactchildrentoarray
1189		*/
1190		function toArray(children) {
1191			return mapChildren(children, function(child) {
1192				return child;
1193			}) || [];
1194		}
1195		/**
1196		* Returns the first child in a collection of children and verifies that there
1197		* is only one child in the collection.
1198		*
1199		* See https://reactjs.org/docs/react-api.html#reactchildrenonly
1200		*
1201		* The current implementation of this function assumes that a single child gets
1202		* passed without a wrapper, but the purpose of this helper function is to
1203		* abstract away the particular structure of children.
1204		*
1205		* @param {?object} children Child collection structure.
1206		* @return {ReactElement} The first and only `ReactElement` contained in the
1207		* structure.
1208		*/
1209		function onlyChild(children) {
1210			if (!isValidElement(children)) throw new Error("React.Children.only expected to receive a single React element child.");
1211			return children;
1212		}
1213		function createContext(defaultValue) {
1214			var context = {
1215				$$typeof: REACT_CONTEXT_TYPE,
1216				_currentValue: defaultValue,
1217				_currentValue2: defaultValue,
1218				_threadCount: 0,
1219				Provider: null,
1220				Consumer: null,
1221				_defaultValue: null,
1222				_globalName: null
1223			};
1224			context.Provider = {
1225				$$typeof: REACT_PROVIDER_TYPE,
1226				_context: context
1227			};
1228			var hasWarnedAboutUsingNestedContextConsumers = false;

1229			var hasWarnedAboutUsingConsumerProvider = false;
1230			var hasWarnedAboutDisplayNameOnConsumer = false;
1231			var Consumer = {
1232				$$typeof: REACT_CONTEXT_TYPE,
1233				_context: context
1234			};
1235			Object.defineProperties(Consumer, {
1236				Provider: {
1237					get: function() {
1238						if (!hasWarnedAboutUsingConsumerProvider) {
1239							hasWarnedAboutUsingConsumerProvider = true;
1240							error("Rendering <Context.Consumer.Provider> is not supported and will be removed in a future major release. Did you mean to render <Context.Provider> instead?");
1241						}
1242						return context.Provider;
1243					},
1244					set: function(_Provider) {
1245						context.Provider = _Provider;
1246					}
1247				},
1248				_currentValue: {
1249					get: function() {
1250						return context._currentValue;
1251					},
1252					set: function(_currentValue) {
1253						context._currentValue = _currentValue;
1254					}
1255				},
1256				_currentValue2: {
1257					get: function() {
1258						return context._currentValue2;
1259					},
1260					set: function(_currentValue2) {
1261						context._currentValue2 = _currentValue2;
1262					}
1263				},
1264				_threadCount: {
1265					get: function() {
1266						return context._threadCount;
1267					},
1268					set: function(_threadCount) {
1269						context._threadCount = _threadCount;
1270					}
1271				},
1272				Consumer: { get: function() {
1273					if (!hasWarnedAboutUsingNestedContextConsumers) {
1274						hasWarnedAboutUsingNestedContextConsumers = true;
1275						error("Rendering <Context.Consumer.Consumer> is not supported and will be removed in a future major release. Did you mean to render <Context.Consumer> instead?");
1276					}
1277					return context.Consumer;
1278				} },
1279				displayName: {
1280					get: function() {
1281						return context.displayName;
1282					},
1283					set: function(displayName) {
1284						if (!hasWarnedAboutDisplayNameOnConsumer) {
1285							warn("Setting `displayName` on Context.Consumer has no effect. You should set it directly on the context with Context.displayName = '%s'.", displayName);
1286							hasWarnedAboutDisplayNameOnConsumer = true;
1287						}
1288					}
1289				}
1290			});
1291			context.Consumer = Consumer;
1292			context._currentRenderer = null;
1293			context._currentRenderer2 = null;
1294			return context;
1295		}
1296		var Uninitialized = -1;
1297		var Pending = 0;
1298		var Resolved = 1;
1299		var Rejected = 2;
1300		function lazyInitializer(payload) {
1301			if (payload._status === Uninitialized) {
1302				var ctor = payload._result;
1303				var thenable = ctor();
1304				thenable.then(function(moduleObject) {
1305					if (payload._status === Pending || payload._status === Uninitialized) {
1306						var resolved = payload;
1307						resolved._status = Resolved;
1308						resolved._result = moduleObject;
1309					}
1310				}, function(error) {
1311					if (payload._status === Pending || payload._status === Uninitialized) {
1312						var rejected = payload;
1313						rejected._status = Rejected;
1314						rejected._result = error;
1315					}
1316				});
1317				if (payload._status === Uninitialized) {
1318					var pending = payload;
1319					pending._status = Pending;
1320					pending._result = thenable;
1321				}
1322			}
1323			if (payload._status === Resolved) {
1324				var moduleObject = payload._result;
1325				if (moduleObject === void 0) error("lazy: Expected the result of a dynamic import() call. Instead received: %s\n\nYour code should look like: \n  const MyComponent = lazy(() => import('./MyComponent'))\n\nDid you accidentally put curly braces around the import?", moduleObject);
1326				if (!("default" in moduleObject)) error("lazy: Expected the result of a dynamic import() call. Instead received: %s\n\nYour code should look like: \n  const MyComponent = lazy(() => import('./MyComponent'))", moduleObject);
1327				return moduleObject.default;
1328			} else throw payload._result;
1329		}
1330		function lazy(ctor) {
1331			var lazyType = {
1332				$$typeof: REACT_LAZY_TYPE,
1333				_payload: {
1334					_status: Uninitialized,
1335					_result: ctor
1336				},
1337				_init: lazyInitializer
1338			};
1339			var defaultProps;
1340			var propTypes;
1341			Object.defineProperties(lazyType, {
1342				defaultProps: {
1343					configurable: true,
1344					get: function() {
1345						return defaultProps;
1346					},
1347					set: function(newDefaultProps) {
1348						error("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.");
1349						defaultProps = newDefaultProps;
1350						Object.defineProperty(lazyType, "defaultProps", { enumerable: true });
1351					}
1352				},
1353				propTypes: {
1354					configurable: true,
1355					get: function() {

1356						return propTypes;
1357					},
1358					set: function(newPropTypes) {
1359						error("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.");
1360						propTypes = newPropTypes;
1361						Object.defineProperty(lazyType, "propTypes", { enumerable: true });
1362					}
1363				}
1364			});
1365			return lazyType;
1366		}
1367		function forwardRef(render) {
1368			if (render != null && render.$$typeof === REACT_MEMO_TYPE) error("forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...)).");
1369			else if (typeof render !== "function") error("forwardRef requires a render function but was given %s.", render === null ? "null" : typeof render);
1370			else if (render.length !== 0 && render.length !== 2) error("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.");
1371			if (render != null) {
1372				if (render.defaultProps != null || render.propTypes != null) error("forwardRef render functions do not support propTypes or defaultProps. Did you accidentally pass a React component?");
1373			}
1374			var elementType = {
1375				$$typeof: REACT_FORWARD_REF_TYPE,
1376				render
1377			};
1378			var ownName;
1379			Object.defineProperty(elementType, "displayName", {
1380				enumerable: false,
1381				configurable: true,
1382				get: function() {
1383					return ownName;
1384				},
1385				set: function(name) {
1386					ownName = name;
1387					if (!render.name && !render.displayName) render.displayName = name;
1388				}
1389			});
1390			return elementType;
1391		}
1392		var REACT_MODULE_REFERENCE = Symbol.for("react.module.reference");
1393		function isValidElementType(type) {
1394			if (typeof type === "string" || typeof type === "function") return true;
1395			if (type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || enableDebugTracing || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || enableLegacyHidden || type === REACT_OFFSCREEN_TYPE || enableScopeAPI || enableCacheElement || enableTransitionTracing) return true;
1396			if (typeof type === "object" && type !== null) {
1397				if (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 || type.$$typeof === REACT_MODULE_REFERENCE || type.getModuleId !== void 0) return true;
1398			}
1399			return false;
1400		}
1401		function memo(type, compare) {
1402			if (!isValidElementType(type)) error("memo: The first argument must be a component. Instead received: %s", type === null ? "null" : typeof type);
1403			var elementType = {
1404				$$typeof: REACT_MEMO_TYPE,
1405				type,
1406				compare: compare === void 0 ? null : compare
1407			};
1408			var ownName;
1409			Object.defineProperty(elementType, "displayName", {
1410				enumerable: false,
1411				configurable: true,
1412				get: function() {
1413					return ownName;
1414				},
1415				set: function(name) {
1416					ownName = name;
1417					if (!type.name && !type.displayName) type.displayName = name;
1418				}
1419			});
1420			return elementType;
1421		}
1422		function resolveDispatcher() {
1423			var dispatcher = ReactCurrentDispatcher.current;
1424			if (dispatcher === null) error("Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:\n1. You might have mismatching versions of React and the renderer (such as React DOM)\n2. You might be breaking the Rules of Hooks\n3. You might have more than one copy of React in the same app\nSee https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.");
1425			return dispatcher;
1426		}
1427		function useContext(Context) {
1428			var dispatcher = resolveDispatcher();
1429			if (Context._context !== void 0) {
1430				var realContext = Context._context;
1431				if (realContext.Consumer === Context) error("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?");
1432				else if (realContext.Provider === Context) error("Calling useContext(Context.Provider) is not supported. Did you mean to call useContext(Context) instead?");
1433			}

1434			return dispatcher.useContext(Context);
1435		}
1436		function useState(initialState) {
1437			return resolveDispatcher().useState(initialState);
1438		}
1439		function useReducer(reducer, initialArg, init) {
1440			return resolveDispatcher().useReducer(reducer, initialArg, init);
1441		}
1442		function useRef(initialValue) {
1443			return resolveDispatcher().useRef(initialValue);
1444		}
1445		function useEffect(create, deps) {
1446			return resolveDispatcher().useEffect(create, deps);
1447		}
1448		function useInsertionEffect(create, deps) {
1449			return resolveDispatcher().useInsertionEffect(create, deps);
1450		}
1451		function useLayoutEffect(create, deps) {
1452			return resolveDispatcher().useLayoutEffect(create, deps);
1453		}
1454		function useCallback(callback, deps) {
1455			return resolveDispatcher().useCallback(callback, deps);
1456		}
1457		function useMemo(create, deps) {
1458			return resolveDispatcher().useMemo(create, deps);
1459		}
1460		function useImperativeHandle(ref, create, deps) {
1461			return resolveDispatcher().useImperativeHandle(ref, create, deps);
1462		}
1463		function useDebugValue(value, formatterFn) {
1464			return resolveDispatcher().useDebugValue(value, formatterFn);
1465		}
1466		function useTransition() {
1467			return resolveDispatcher().useTransition();
1468		}
1469		function useDeferredValue(value) {
1470			return resolveDispatcher().useDeferredValue(value);
1471		}
1472		function useId() {
1473			return resolveDispatcher().useId();
1474		}
1475		function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
1476			return resolveDispatcher().useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
1477		}
1478		var disabledDepth = 0;
1479		var prevLog;
1480		var prevInfo;
1481		var prevWarn;
1482		var prevError;
1483		var prevGroup;
1484		var prevGroupCollapsed;
1485		var prevGroupEnd;
1486		function disabledLog() {}
1487		disabledLog.__reactDisabledLog = true;
1488		function disableLogs() {
1489			if (disabledDepth === 0) {
1490				prevLog = console.log;
1491				prevInfo = console.info;
1492				prevWarn = console.warn;
1493				prevError = console.error;
1494				prevGroup = console.group;
1495				prevGroupCollapsed = console.groupCollapsed;
1496				prevGroupEnd = console.groupEnd;
1497				var props = {
1498					configurable: true,
1499					enumerable: true,
1500					value: disabledLog,
1501					writable: true
1502				};
1503				Object.defineProperties(console, {
1504					info: props,
1505					log: props,
1506					warn: props,
1507					error: props,
1508					group: props,
1509					groupCollapsed: props,
1510					groupEnd: props
1511				});
1512			}
1513			disabledDepth++;
1514		}
1515		function reenableLogs() {
1516			disabledDepth--;
1517			if (disabledDepth === 0) {
1518				var props = {
1519					configurable: true,
1520					enumerable: true,
1521					writable: true
1522				};
1523				Object.defineProperties(console, {
1524					log: assign({}, props, { value: prevLog }),
1525					info: assign({}, props, { value: prevInfo }),
1526					warn: assign({}, props, { value: prevWarn }),
1527					error: assign({}, props, { value: prevError }),
1528					group: assign({}, props, { value: prevGroup }),
1529					groupCollapsed: assign({}, props, { value: prevGroupCollapsed }),
1530					groupEnd: assign({}, props, { value: prevGroupEnd })
1531				});
1532			}
1533			if (disabledDepth < 0) error("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
1534		}
1535		var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher;
1536		var prefix;
1537		function describeBuiltInComponentFrame(name, source, ownerFn) {
1538			if (prefix === void 0) try {
1539				throw Error();
1540			} catch (x) {
1541				var match = x.stack.trim().match(/\n( *(at )?)/);
1542				prefix = match && match[1] || "";
1543			}
1544			return "\n" + prefix + name;
1545		}
1546		var reentry = false;
1547		var componentFrameCache = new (typeof WeakMap === "function" ? WeakMap : Map)();
1548		function describeNativeComponentFrame(fn, construct) {
1549			if (!fn || reentry) return "";
1550			var frame = componentFrameCache.get(fn);
1551			if (frame !== void 0) return frame;
1552			var control;
1553			reentry = true;
1554			var previousPrepareStackTrace = Error.prepareStackTrace;
1555			Error.prepareStackTrace = void 0;
1556			var previousDispatcher = ReactCurrentDispatcher$1.current;
1557			ReactCurrentDispatcher$1.current = null;
1558			disableLogs();
1559			try {
1560				if (construct) {
1561					var Fake = function() {
1562						throw Error();
1563					};
1564					Object.defineProperty(Fake.prototype, "props", { set: function() {
1565						throw Error();
1566					} });
1567					if (typeof Reflect === "object" && Reflect.construct) {
1568						try {
1569							Reflect.construct(Fake, []);
1570						} catch (x) {
1571							control = x;
1572						}
1573						Reflect.construct(fn, [], Fake);
1574					} else {
1575						try {
1576							Fake.call();
1577						} catch (x) {
1578							control = x;
1579						}
1580						fn.call(Fake.prototype);
1581					}
1582				} else {
1583					try {
1584						throw Error();
1585					} catch (x) {
1586						control = x;
1587					}
1588					fn();
1589				}
1590			} catch (sample) {

1591				if (sample && control && typeof sample.stack === "string") {
1592					var sampleLines = sample.stack.split("\n");
1593					var controlLines = control.stack.split("\n");
1594					var s = sampleLines.length - 1;
1595					var c = controlLines.length - 1;
1596					while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) c--;
1597					for (; s >= 1 && c >= 0; s--, c--) if (sampleLines[s] !== controlLines[c]) {
1598						if (s !== 1 || c !== 1) do {
1599							s--;
1600							c--;
1601							if (c < 0 || sampleLines[s] !== controlLines[c]) {
1602								var _frame = "\n" + sampleLines[s].replace(" at new ", " at ");
1603								if (fn.displayName && _frame.includes("<anonymous>")) _frame = _frame.replace("<anonymous>", fn.displayName);
1604								if (typeof fn === "function") componentFrameCache.set(fn, _frame);
1605								return _frame;
1606							}
1607						} while (s >= 1 && c >= 0);
1608						break;
1609					}
1610				}
1611			} finally {
1612				reentry = false;
1613				ReactCurrentDispatcher$1.current = previousDispatcher;
1614				reenableLogs();
1615				Error.prepareStackTrace = previousPrepareStackTrace;
1616			}
1617			var name = fn ? fn.displayName || fn.name : "";
1618			var syntheticFrame = name ? describeBuiltInComponentFrame(name) : "";
1619			if (typeof fn === "function") componentFrameCache.set(fn, syntheticFrame);
1620			return syntheticFrame;
1621		}
1622		function describeFunctionComponentFrame(fn, source, ownerFn) {
1623			return describeNativeComponentFrame(fn, false);
1624		}
1625		function shouldConstruct(Component) {
1626			var prototype = Component.prototype;
1627			return !!(prototype && prototype.isReactComponent);
1628		}
1629		function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) {
1630			if (type == null) return "";
1631			if (typeof type === "function") return describeNativeComponentFrame(type, shouldConstruct(type));
1632			if (typeof type === "string") return describeBuiltInComponentFrame(type);
1633			switch (type) {
1634				case REACT_SUSPENSE_TYPE: return describeBuiltInComponentFrame("Suspense");
1635				case REACT_SUSPENSE_LIST_TYPE: return describeBuiltInComponentFrame("SuspenseList");
1636			}
1637			if (typeof type === "object") switch (type.$$typeof) {
1638				case REACT_FORWARD_REF_TYPE: return describeFunctionComponentFrame(type.render);
1639				case REACT_MEMO_TYPE: return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn);
1640				case REACT_LAZY_TYPE:
1641					var lazyComponent = type;
1642					var payload = lazyComponent._payload;
1643					var init = lazyComponent._init;
1644					try {
1645						return describeUnknownElementTypeFrameInDEV(init(payload), source, ownerFn);
1646					} catch (x) {}
1647			}
1648			return "";
1649		}
1650		var loggedTypeFailures = {};
1651		var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;
1652		function setCurrentlyValidatingElement(element) {
1653			if (element) {
1654				var owner = element._owner;
1655				var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
1656				ReactDebugCurrentFrame$1.setExtraStackFrame(stack);
1657			} else ReactDebugCurrentFrame$1.setExtraStackFrame(null);
1658		}
1659		function checkPropTypes(typeSpecs, values, location, componentName, element) {
1660			var has = Function.call.bind(hasOwnProperty);
1661			for (var typeSpecName in typeSpecs) if (has(typeSpecs, typeSpecName)) {
1662				var error$1 = void 0;
1663				try {
1664					if (typeof typeSpecs[typeSpecName] !== "function") {
1665						var err = Error((componentName || "React class") + ": " + location + " type `" + typeSpecName + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof typeSpecs[typeSpecName] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
1666						err.name = "Invariant Violation";
1667						throw err;
1668					}
1669					error$1 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
1670				} catch (ex) {
1671					error$1 = ex;
1672				}
1673				if (error$1 && !(error$1 instanceof Error)) {
1674					setCurrentlyValidatingElement(element);
1675					error("%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", componentName || "React class", location, typeSpecName, typeof error$1);
1676					setCurrentlyValidatingElement(null);
1677				}
1678				if (error$1 instanceof Error && !(error$1.message in loggedTypeFailures)) {
1679					loggedTypeFailures[error$1.message] = true;
1680					setCurrentlyValidatingElement(element);
1681					error("Failed %s type: %s", location, error$1.message);
1682					setCurrentlyValidatingElement(null);
1683				}
1684			}
1685		}
1686		function setCurrentlyValidatingElement$1(element) {
1687			if (element) {
1688				var owner = element._owner;
1689				setExtraStackFrame(describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null));
1690			} else setExtraStackFrame(null);
1691		}
1692		var propTypesMisspellWarningShown = false;

1693		function getDeclarationErrorAddendum() {
1694			if (ReactCurrentOwner.current) {
1695				var name = getComponentNameFromType(ReactCurrentOwner.current.type);
1696				if (name) return "\n\nCheck the render method of `" + name + "`.";
1697			}
1698			return "";
1699		}
1700		function getSourceInfoErrorAddendum(source) {
1701			if (source !== void 0) {
1702				var fileName = source.fileName.replace(/^.*[\\\/]/, "");
1703				var lineNumber = source.lineNumber;
1704				return "\n\nCheck your code at " + fileName + ":" + lineNumber + ".";
1705			}
1706			return "";
1707		}
1708		function getSourceInfoErrorAddendumForProps(elementProps) {
1709			if (elementProps !== null && elementProps !== void 0) return getSourceInfoErrorAddendum(elementProps.__source);
1710			return "";
1711		}
1712		/**
1713		* Warn if there's no key explicitly set on dynamic arrays of children or
1714		* object keys are not valid. This allows us to keep track of children between
1715		* updates.
1716		*/
1717		var ownerHasKeyUseWarning = {};
1718		function getCurrentComponentErrorInfo(parentType) {
1719			var info = getDeclarationErrorAddendum();
1720			if (!info) {
1721				var parentName = typeof parentType === "string" ? parentType : parentType.displayName || parentType.name;
1722				if (parentName) info = "\n\nCheck the top-level render call using <" + parentName + ">.";
1723			}
1724			return info;
1725		}
1726		/**
1727		* Warn if the element doesn't have an explicit key assigned to it.
1728		* This element is in an array. The array could grow and shrink or be
1729		* reordered. All children that haven't already been validated are required to
1730		* have a "key" property assigned to it. Error statuses are cached so a warning
1731		* will only be shown once.
1732		*
1733		* @internal
1734		* @param {ReactElement} element Element that requires a key.
1735		* @param {*} parentType element's parent's type.
1736		*/
1737		function validateExplicitKey(element, parentType) {
1738			if (!element._store || element._store.validated || element.key != null) return;
1739			element._store.validated = true;
1740			var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);
1741			if (ownerHasKeyUseWarning[currentComponentErrorInfo]) return;
1742			ownerHasKeyUseWarning[currentComponentErrorInfo] = true;
1743			var childOwner = "";
1744			if (element && element._owner && element._owner !== ReactCurrentOwner.current) childOwner = " It was passed a child from " + getComponentNameFromType(element._owner.type) + ".";
1745			setCurrentlyValidatingElement$1(element);
1746			error("Each child in a list should have a unique \"key\" prop.%s%s See https://reactjs.org/link/warning-keys for more information.", currentComponentErrorInfo, childOwner);
1747			setCurrentlyValidatingElement$1(null);
1748		}
1749		/**
1750		* Ensure that every element either is passed in a static location, in an
1751		* array with an explicit keys property defined, or in an object literal
1752		* with valid key property.
1753		*
1754		* @internal
1755		* @param {ReactNode} node Statically passed child of any type.
1756		* @param {*} parentType node's parent's type.
1757		*/
1758		function validateChildKeys(node, parentType) {
1759			if (typeof node !== "object") return;
1760			if (isArray(node)) for (var i = 0; i < node.length; i++) {
1761				var child = node[i];
1762				if (isValidElement(child)) validateExplicitKey(child, parentType);
1763			}
1764			else if (isValidElement(node)) {
1765				if (node._store) node._store.validated = true;
1766			} else if (node) {
1767				var iteratorFn = getIteratorFn(node);
1768				if (typeof iteratorFn === "function") {
1769					if (iteratorFn !== node.entries) {
1770						var iterator = iteratorFn.call(node);
1771						var step;
1772						while (!(step = iterator.next()).done) if (isValidElement(step.value)) validateExplicitKey(step.value, parentType);
1773					}
1774				}
1775			}
1776		}
1777		/**
1778		* Given an element, validate that its props follow the propTypes definition,
1779		* provided by the type.
1780		*
1781		* @param {ReactElement} element
1782		*/
1783		function validatePropTypes(element) {
1784			var type = element.type;
1785			if (type === null || type === void 0 || typeof type === "string") return;
1786			var propTypes;
1787			if (typeof type === "function") propTypes = type.propTypes;
1788			else if (typeof type === "object" && (type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_MEMO_TYPE)) propT

1788ypes = type.propTypes;
1789			else return;
1790			if (propTypes) {
1791				var name = getComponentNameFromType(type);
1792				checkPropTypes(propTypes, element.props, "prop", name, element);
1793			} else if (type.PropTypes !== void 0 && !propTypesMisspellWarningShown) {
1794				propTypesMisspellWarningShown = true;
1795				error("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", getComponentNameFromType(type) || "Unknown");
1796			}
1797			if (typeof type.getDefaultProps === "function" && !type.getDefaultProps.isReactClassApproved) error("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
1798		}
1799		/**
1800		* Given a fragment, validate that it can only be provided with fragment props
1801		* @param {ReactElement} fragment
1802		*/
1803		function validateFragmentProps(fragment) {
1804			var keys = Object.keys(fragment.props);
1805			for (var i = 0; i < keys.length; i++) {
1806				var key = keys[i];
1807				if (key !== "children" && key !== "key") {
1808					setCurrentlyValidatingElement$1(fragment);
1809					error("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", key);
1810					setCurrentlyValidatingElement$1(null);
1811					break;
1812				}
1813			}
1814			if (fragment.ref !== null) {
1815				setCurrentlyValidatingElement$1(fragment);
1816				error("Invalid attribute `ref` supplied to `React.Fragment`.");
1817				setCurrentlyValidatingElement$1(null);
1818			}
1819		}
1820		function createElementWithValidation(type, props, children) {
1821			var validType = isValidElementType(type);
1822			if (!validType) {
1823				var info = "";
1824				if (type === void 0 || typeof type === "object" && type !== null && Object.keys(type).length === 0) info += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.";
1825				var sourceInfo = getSourceInfoErrorAddendumForProps(props);
1826				if (sourceInfo) info += sourceInfo;
1827				else info += getDeclarationErrorAddendum();
1828				var typeString;
1829				if (type === null) typeString = "null";
1830				else if (isArray(type)) typeString = "array";
1831				else if (type !== void 0 && type.$$typeof === REACT_ELEMENT_TYPE) {
1832					typeString = "<" + (getComponentNameFromType(type.type) || "Unknown") + " />";
1833					info = " Did you accidentally export a JSX literal instead of a component?";
1834				} else typeString = typeof type;
1835				error("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);
1836			}
1837			var element = createElement.apply(this, arguments);
1838			if (element == null) return element;
1839			if (validType) for (var i = 2; i < arguments.length; i++) validateChildKeys(arguments[i], type);
1840			if (type === REACT_FRAGMENT_TYPE) validateFragmentProps(element);
1841			else validatePropTypes(element);
1842			return element;
1843		}
1844		var didWarnAboutDeprecatedCreateFactory = false;
1845		function createFactoryWithValidation(type) {
1846			var validatedFactory = createElementWithValidation.bind(null, type);
1847			validatedFactory.type = type;
1848			if (!didWarnAboutDeprecatedCreateFactory) {
1849				didWarnAboutDeprecatedCreateFactory = true;
1850				warn("React.createFactory() is deprecated and will be removed in a future major release. Consider using JSX or use React.createElement() directly instead.");
1851			}
1852			Object.defineProperty(validatedFactory, "type", {
1853				enumerable: false,
1854				get: function() {
1855					warn("Factory.type is deprecated. Access the class directly before passing it to createFactory.");
1856					Object.defineProperty(this, "type", { value: type });
1857					return type;
1858				}
1859			});
1860			return validatedFactory;
1861		}
1862		function cloneElementWithValidation(element, props, children) {
1863			var newElement = cloneElement.apply(this, arguments);
1864			for (var i = 2; i < arguments.length; i++) validateChildKeys(arguments[i], newElement.type);
1865			validatePropTypes(newElement);
1866			return newElement;
1867		}
1868		function startTransition(scope, options) {
1869			var prevTransition = ReactCurrentBatchConfig.transition;
1870			ReactCurrentBatchConfig.transition = {};
1871			var currentTransition = ReactCurrentBatchConfig.transition;
1872			ReactCurrentBatchConfig.transition._updatedFibers = /* @__PURE__ */ new Set();
1873			try {
1874				scope();
1875			} finally {
1876				ReactCurrentBatchConfig.transition = prevTransition;
1877				if (prevTransition === null && currentTransition._updatedFibers) {
1878					if (currentTransition._updatedFibers.size > 10) warn("Detected a large number of updates inside startTransition. If this is due to a subscription please re-write it to use React provided hooks. Otherwise concurrent mode guarantees are off the table.");
1879					currentTransition._updatedFibers.clear();
1880				}
1881			}
1882		}
1883		var didWarnAboutMessageChannel = false;

1884		var enqueueTaskImpl = null;
1885		function enqueueTask(task) {
1886			if (enqueueTaskImpl === null) try {
1887				var requireString = ("require" + Math.random()).slice(0, 7);
1888				enqueueTaskImpl = (module && module[requireString]).call(module, "timers").setImmediate;
1889			} catch (_err) {
1890				enqueueTaskImpl = function(callback) {
1891					if (didWarnAboutMessageChannel === false) {
1892						didWarnAboutMessageChannel = true;
1893						if (typeof MessageChannel === "undefined") error("This browser does not have a MessageChannel implementation, so enqueuing tasks via await act(async () => ...) will fail. Please file an issue at https://github.com/facebook/react/issues if you encounter this warning.");
1894					}
1895					var channel = new MessageChannel();
1896					channel.port1.onmessage = callback;
1897					channel.port2.postMessage(void 0);
1898				};
1899			}
1900			return enqueueTaskImpl(task);
1901		}
1902		var actScopeDepth = 0;
1903		var didWarnNoAwaitAct = false;
1904		function act(callback) {
1905			var prevActScopeDepth = actScopeDepth;
1906			actScopeDepth++;
1907			if (ReactCurrentActQueue.current === null) ReactCurrentActQueue.current = [];
1908			var prevIsBatchingLegacy = ReactCurrentActQueue.isBatchingLegacy;
1909			var result;
1910			try {
1911				ReactCurrentActQueue.isBatchingLegacy = true;
1912				result = callback();
1913				if (!prevIsBatchingLegacy && ReactCurrentActQueue.didScheduleLegacyUpdate) {
1914					var queue = ReactCurrentActQueue.current;
1915					if (queue !== null) {
1916						ReactCurrentActQueue.didScheduleLegacyUpdate = false;
1917						flushActQueue(queue);
1918					}
1919				}
1920			} catch (error) {
1921				popActScope(prevActScopeDepth);
1922				throw error;
1923			} finally {
1924				ReactCurrentActQueue.isBatchingLegacy = prevIsBatchingLegacy;
1925			}
1926			if (result !== null && typeof result === "object" && typeof result.then === "function") {
1927				var thenableResult = result;
1928				var wasAwaited = false;
1929				var thenable = { then: function(resolve, reject) {
1930					wasAwaited = true;
1931					thenableResult.then(function(returnValue) {
1932						popActScope(prevActScopeDepth);
1933						if (actScopeDepth === 0) recursivelyFlushAsyncActWork(returnValue, resolve, reject);
1934						else resolve(returnValue);
1935					}, function(error) {
1936						popActScope(prevActScopeDepth);
1937						reject(error);
1938					});
1939				} };
1940				if (!didWarnNoAwaitAct && typeof Promise !== "undefined") Promise.resolve().then(function() {}).then(function() {
1941					if (!wasAwaited) {
1942						didWarnNoAwaitAct = true;
1943						error("You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);");
1944					}
1945				});
1946				return thenable;
1947			} else {
1948				var returnValue = result;
1949				popActScope(prevActScopeDepth);
1950				if (actScopeDepth === 0) {
1951					var _queue = ReactCurrentActQueue.current;
1952					if (_queue !== null) {
1953						flushActQueue(_queue);
1954						ReactCurrentActQueue.current = null;
1955					}
1956					return { then: function(resolve, reject) {
1957						if (ReactCurrentActQueue.current === null) {
1958							ReactCurrentActQueue.current = [];
1959							recursivelyFlushAsyncActWork(returnValue, resolve, reject);
1960						} else resolve(returnValue);
1961					} };
1962				} else return { then: function(resolve, reject) {
1963					resolve(returnValue);
1964				} };
1965			}
1966		}
1967		function popActScope(prevActScopeDepth) {
1968			if (prevActScopeDepth !== actScopeDepth - 1) error("You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. ");
1969			actScopeDepth = prevActScopeDepth;
1970		}
1971		function recursivelyFlushAsyncActWork(returnValue, resolve, reject) {
1972			var queue = ReactCurrentActQueue.current;
1973			if (queue !== null) try {
1974				flushActQueue(queue);
1975				enqueueTask(function() {
1976					if (queue.length === 0) {
1977						ReactCurrentActQueue.current = null;
1978						resolve(returnValue);
1979					} else recursivelyFlushAsyncActWork(returnValue, resolve, reject);
1980				});
1981			} catch (error) {
1982				reject(error);
1983			}
1984			else resolve(returnValue);
1985		}
1986		var isFlushing = false;
1987		function flushActQueue(queue) {
1988			if (!isFlushing) {
1989				isFlushing = true;
1990				var i = 0;

1991				try {
1992					for (; i < queue.length; i++) {
1993						var callback = queue[i];
1994						do
1995							callback = callback(true);
1996						while (callback !== null);
1997					}
1998					queue.length = 0;
1999				} catch (error) {
2000					queue = queue.slice(i + 1);
2001					throw error;
2002				} finally {
2003					isFlushing = false;
2004				}
2005			}
2006		}
2007		var createElement$1 = createElementWithValidation;
2008		var cloneElement$1 = cloneElementWithValidation;
2009		var createFactory = createFactoryWithValidation;
2010		exports.Children = {
2011			map: mapChildren,
2012			forEach: forEachChildren,
2013			count: countChildren,
2014			toArray,
2015			only: onlyChild
2016		};
2017		exports.Component = Component;
2018		exports.Fragment = REACT_FRAGMENT_TYPE;
2019		exports.Profiler = REACT_PROFILER_TYPE;
2020		exports.PureComponent = PureComponent;
2021		exports.StrictMode = REACT_STRICT_MODE_TYPE;
2022		exports.Suspense = REACT_SUSPENSE_TYPE;
2023		exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = ReactSharedInternals;
2024		exports.act = act;
2025		exports.cloneElement = cloneElement$1;
2026		exports.createContext = createContext;
2027		exports.createElement = createElement$1;
2028		exports.createFactory = createFactory;
2029		exports.createRef = createRef;
2030		exports.forwardRef = forwardRef;
2031		exports.isValidElement = isValidElement;
2032		exports.lazy = lazy;
2033		exports.memo = memo;
2034		exports.startTransition = startTransition;
2035		exports.unstable_act = act;
2036		exports.useCallback = useCallback;
2037		exports.useContext = useContext;
2038		exports.useDebugValue = useDebugValue;
2039		exports.useDeferredValue = useDeferredValue;
2040		exports.useEffect = useEffect;
2041		exports.useId = useId;
2042		exports.useImperativeHandle = useImperativeHandle;
2043		exports.useInsertionEffect = useInsertionEffect;
2044		exports.useLayoutEffect = useLayoutEffect;
2045		exports.useMemo = useMemo;
2046		exports.useReducer = useReducer;
2047		exports.useRef = useRef;
2048		exports.useState = useState;
2049		exports.useSyncExternalStore = useSyncExternalStore;
2050		exports.useTransition = useTransition;
2051		exports.version = ReactVersion;
2052		if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop === "function") __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(/* @__PURE__ */ new Error());
2053	})();
2054}));
2055//#endregion
2056//#region node_modules/react/index.js
2057var require_react = /* @__PURE__ */ __commonJSMin(((exports, module) => {
2058	if (require_browser().env.NODE_ENV === "production") module.exports = require_react_production_min();
2059	else module.exports = require_react_development();
2060}));
2061//#endregion
2062//#region node_modules/scheduler/cjs/scheduler.production.min.js
2063/**
2064* @license React
2065* scheduler.production.min.js
2066*
2067* Copyright (c) Facebook, Inc. and its affiliates.
2068*
2069* This source code is licensed under the MIT license found in the
2070* LICENSE file in the root directory of this source tree.
2071*/
2072var require_scheduler_production_min = /* @__PURE__ */ __commonJSMin(((exports) => {
2073	function f(a, b) {
2074		var c = a.length;
2075		a.push(b);
2076		a: for (; 0 < c;) {
2077			var d = c - 1 >>> 1, e = a[d];
2078			if (0 < g(e, b)) a[d] = b, a[c] = e, c = d;
2079			else break a;
2080		}
2081	}
2082	function h(a) {
2083		return 0 === a.length ? null : a[0];
2084	}
2085	function k(a) {
2086		if (0 === a.length) return null;
2087		var b = a[0], c = a.pop();
2088		if (c !== b) {
2089			a[0] = c;
2090			a: for (var d = 0, e = a.length, w = e >>> 1; d < w;) {
2091				var m = 2 * (d + 1) - 1, C = a[m], n = m + 1, x = a[n];
2092				if (0 > g(C, c)) n < e && 0 > g(x, C) ? (a[d] = x, a[n] = c, d = n) : (a[d] = C, a[m] = c, d = m);
2093				else if (n < e && 0 > g(x, c)) a[d] = x, a[n] = c, d = n;
2094				else break a;
2095			}
2096		}
2097		return b;
2098	}
2099	function g(a, b) {
2100		var c = a.sortIndex - b.sortIndex;
2101		return 0 !== c ? c : a.id - b.id;
2102	}
2103	if ("object" === typeof performance && "function" === typeof performance.now) {
2104		var l = performance;
2105		exports.unstable_now = function() {
2106			return l.now();
2107		};
2108	} else {
2109		var p = Date, q = p.now();
2110		exports.unstable_now = function() {
2111			return p.now() - q;
2112		};
2113	}
2114	var r = [];
2115	var t = [];
2116	var u = 1;
2117	var v = null;
2118	var y = 3;
2119	var z = !1;
2120	var A = !1;
2121	var B = !1;
2122	var D = "function" === typeof setTimeout ? setTimeout : null;
2123	var E = "function" === typeof clearTimeout ? clearTimeout : null;
2124	var F = "undefined" !== typeof setImmediate ? setImmediate : null;
2125	"undefined" !== typeof navigator && void 0 !== navigator.scheduling && void 0 !== navigator.scheduling.isInputPending && navigator.scheduling.isInputPending.bind(navigator.scheduling);
2126	function G(a) {
2127		for (var b = h(t); null !== b;) {
2128			if (null === b.callback) k(t);
2129			else if (b.startTime <= a) k(t), b.sortIndex = b.expirationTime, f(r, b);
2130			else break;
2131			b = h(t);
2132		}
2133	}
2134	function H(a) {
2135		B = !1;
2136		G(a);
2137		if (!A) if (null !== h(r)) A = !0, I(J);
2138		else {
2139			var b = h(t);
2140			null !== b && K(H, b.startTime - a);
2141		}
2142	}
2143	function J(a, b) {
2144		A = !1;
2145		B && (B = !1, E(L), L = -1);
2146		z = !0;
2147		var c = y;
2148		try {
2149			G(b);
2150			for (v = h(r); null !== v && (!(v.expirationTime > b) || a && !M());) {
2151				var d = v.callback;
2152				if ("function" === typeof d) {
2153					v.callback = null;
2154					y = v.priorityLevel;
2155					var e = d(v.expirationTime <= b);
2156					b = exports.unstable_now();
2157					"function" === typeof e ? v.callback = e : v === h(r) && k(r);
2158					G(b);
2159				} else k(r);
2160				v = h(r);
2161			}
2162			if (null !== v) var w = !0;
2163			else {
2164				var m = h(t);
2165				null !== m && K(H, m.startTime - b);
2166				w = !1;
2167			}
2168			return w;
2169		} finally {
2170			v = null, y = c, z = !1;
2171		}
2172	}
2173	var N = !1;
2174	var O = null;
2175	var L = -1;
2176	var P = 5;
2177	var Q = -1;
2178	function M() {
2179		return exports.unstable_now() - Q < P ? !1 : !0;
2180	}
2181	function R() {
2182		if (null !== O) {
2183			var a = exports.unstable_now();
2184			Q = a;
2185			var b = !0;
2186			try {
2187				b = O(!0, a);
2188			} finally {
2189				b ? S() : (N = !1, O = null);
2190			}
2191		} else N = !1;
2192	}
2193	var S;
2194	if ("function" === typeof F) S = function() {
2195		F(R);
2196	};
2197	else if ("undefined" !== typeof MessageChannel) {
2198		var T = new MessageChannel(), U = T.port2;
2199		T.port1.onmessage = R;
2200		S = function() {
2201			U.postMessage(null);
2202		};
2203	} else S = function() {
2204		D(R, 0);
2205	};
2206	function I(a) {
2207		O = a;
2208		N || (N = !0, S());
2209	}
2210	function K(a, b) {
2211		L = D(function() {
2212			a(exports.unstable_now());
2213		}, b);
2214	}
2215	exports.unstable_IdlePriority = 5;
2216	exports.unstable_ImmediatePriority = 1;
2217	exports.unstable_LowPriority = 4;

2218	exports.unstable_NormalPriority = 3;
2219	exports.unstable_Profiling = null;
2220	exports.unstable_UserBlockingPriority = 2;
2221	exports.unstable_cancelCallback = function(a) {
2222		a.callback = null;
2223	};
2224	exports.unstable_continueExecution = function() {
2225		A || z || (A = !0, I(J));
2226	};
2227	exports.unstable_forceFrameRate = function(a) {
2228		0 > a || 125 < a ? console.error("forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported") : P = 0 < a ? Math.floor(1e3 / a) : 5;
2229	};
2230	exports.unstable_getCurrentPriorityLevel = function() {
2231		return y;
2232	};
2233	exports.unstable_getFirstCallbackNode = function() {
2234		return h(r);
2235	};
2236	exports.unstable_next = function(a) {
2237		switch (y) {
2238			case 1:
2239			case 2:
2240			case 3:
2241				var b = 3;
2242				break;
2243			default: b = y;
2244		}
2245		var c = y;
2246		y = b;
2247		try {
2248			return a();
2249		} finally {
2250			y = c;
2251		}
2252	};
2253	exports.unstable_pauseExecution = function() {};
2254	exports.unstable_requestPaint = function() {};
2255	exports.unstable_runWithPriority = function(a, b) {
2256		switch (a) {
2257			case 1:
2258			case 2:
2259			case 3:
2260			case 4:
2261			case 5: break;
2262			default: a = 3;
2263		}
2264		var c = y;
2265		y = a;
2266		try {
2267			return b();
2268		} finally {
2269			y = c;
2270		}
2271	};
2272	exports.unstable_scheduleCallback = function(a, b, c) {
2273		var d = exports.unstable_now();
2274		"object" === typeof c && null !== c ? (c = c.delay, c = "number" === typeof c && 0 < c ? d + c : d) : c = d;
2275		switch (a) {
2276			case 1:
2277				var e = -1;
2278				break;
2279			case 2:
2280				e = 250;
2281				break;
2282			case 5:
2283				e = 1073741823;
2284				break;
2285			case 4:
2286				e = 1e4;
2287				break;
2288			default: e = 5e3;
2289		}
2290		e = c + e;
2291		a = {
2292			id: u++,
2293			callback: b,
2294			priorityLevel: a,
2295			startTime: c,
2296			expirationTime: e,
2297			sortIndex: -1
2298		};
2299		c > d ? (a.sortIndex = c, f(t, a), null === h(r) && a === h(t) && (B ? (E(L), L = -1) : B = !0, K(H, c - d))) : (a.sortIndex = e, f(r, a), A || z || (A = !0, I(J)));
2300		return a;
2301	};
2302	exports.unstable_shouldYield = M;
2303	exports.unstable_wrapCallback = function(a) {
2304		var b = y;
2305		return function() {
2306			var c = y;
2307			y = b;
2308			try {
2309				return a.apply(this, arguments);
2310			} finally {
2311				y = c;
2312			}
2313		};
2314	};
2315}));
2316//#endregion
2317//#region node_modules/scheduler/cjs/scheduler.development.js
2318var require_scheduler_development = /* @__PURE__ */ __commonJSMin(((exports) => {
2319	/**
2320	* @license React
2321	* scheduler.development.js
2322	*
2323	* Copyright (c) Facebook, Inc. and its affiliates.
2324	*
2325	* This source code is licensed under the MIT license found in the
2326	* LICENSE file in the root directory of this source tree.
2327	*/
2328	if (require_browser().env.NODE_ENV !== "production") (function() {
2329		"use strict";
2330		if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart === "function") __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(/* @__PURE__ */ new Error());
2331		var enableSchedulerDebugging = false;
2332		var enableProfiling = false;
2333		var frameYieldMs = 5;
2334		function push(heap, node) {
2335			var index = heap.length;
2336			heap.push(node);
2337			siftUp(heap, node, index);
2338		}
2339		function peek(heap) {
2340			return heap.length === 0 ? null : heap[0];
2341		}
2342		function pop(heap) {
2343			if (heap.length === 0) return null;
2344			var first = heap[0];
2345			var last = heap.pop();
2346			if (last !== first) {
2347				heap[0] = last;
2348				siftDown(heap, last, 0);
2349			}
2350			return first;
2351		}
2352		function siftUp(heap, node, i) {
2353			var index = i;
2354			while (index > 0) {
2355				var parentIndex = index - 1 >>> 1;
2356				var parent = heap[parentIndex];
2357				if (compare(parent, node) > 0) {
2358					heap[parentIndex] = node;
2359					heap[index] = parent;
2360					index = parentIndex;
2361				} else return;
2362			}
2363		}
2364		function siftDown(heap, node, i) {
2365			var index = i;
2366			var length = heap.length;
2367			var halfLength = length >>> 1;
2368			while (index < halfLength) {
2369				var leftIndex = (index + 1) * 2 - 1;
2370				var left = heap[leftIndex];
2371				var rightIndex = leftIndex + 1;
2372				var right = heap[rightIndex];
2373				if (compare(left, node) < 0) if (rightIndex < length && compare(right, left) < 0) {
2374					heap[index] = right;
2375					heap[rightIndex] = node;
2376					index = rightIndex;
2377				} else {
2378					heap[index] = left;
2379					heap[leftIndex] = node;
2380					index = leftIndex;
2381				}
2382				else if (rightIndex < length && compare(right, node) < 0) {
2383					heap[index] = right;
2384					heap[rightIndex] = node;
2385					index = rightIndex;
2386				} else return;
2387			}
2388		}
2389		function compare(a, b) {
2390			var diff = a.sortIndex - b.sortIndex;
2391			return diff !== 0 ? diff : a.id - b.id;
2392		}
2393		var ImmediatePriority = 1;
2394		var UserBlockingPriority = 2;
2395		var NormalPriority = 3;
2396		var LowPriority = 4;
2397		var IdlePriority = 5;
2398		if (typeof performance === "object" && typeof performance.now === "function") {
2399			var localPerformance = performance;
2400			exports.unstable_now = function() {
2401				return localPerformance.now();
2402			};
2403		} else {
2404			var localDate = Date;
2405			var initialTime = localDate.now();
2406			exports.unstable_now = function() {
2407				return localDate.now() - initialTime;
2408			};
2409		}
2410		var maxSigned31BitInt = 1073741823;
2411		var IMMEDIATE_PRIORITY_TIMEOUT = -1;
2412		var USER_BLOCKING_PRIORITY_TIMEOUT = 250;
2413		var NORMAL_PRIORITY_TIMEOUT = 5e3;
2414		var LOW_PRIORITY_TIMEOUT = 1e4;
2415		var IDLE_PRIORITY_TIMEOUT = maxSigned31BitInt;
2416		var taskQueue = [];
2417		var timerQueue = [];
2418		var taskIdCounter = 1;
2419		var currentTask = null;
2420		var currentPriorityLevel = NormalPriority;
2421		var isPerformingWork = false;

2422		var isHostCallbackScheduled = false;
2423		var isHostTimeoutScheduled = false;
2424		var localSetTimeout = typeof setTimeout === "function" ? setTimeout : null;
2425		var localClearTimeout = typeof clearTimeout === "function" ? clearTimeout : null;
2426		var localSetImmediate = typeof setImmediate !== "undefined" ? setImmediate : null;
2427		typeof navigator !== "undefined" && navigator.scheduling !== void 0 && navigator.scheduling.isInputPending !== void 0 && navigator.scheduling.isInputPending.bind(navigator.scheduling);
2428		function advanceTimers(currentTime) {
2429			var timer = peek(timerQueue);
2430			while (timer !== null) {
2431				if (timer.callback === null) pop(timerQueue);
2432				else if (timer.startTime <= currentTime) {
2433					pop(timerQueue);
2434					timer.sortIndex = timer.expirationTime;
2435					push(taskQueue, timer);
2436				} else return;
2437				timer = peek(timerQueue);
2438			}
2439		}
2440		function handleTimeout(currentTime) {
2441			isHostTimeoutScheduled = false;
2442			advanceTimers(currentTime);
2443			if (!isHostCallbackScheduled) if (peek(taskQueue) !== null) {
2444				isHostCallbackScheduled = true;
2445				requestHostCallback(flushWork);
2446			} else {
2447				var firstTimer = peek(timerQueue);
2448				if (firstTimer !== null) requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
2449			}
2450		}
2451		function flushWork(hasTimeRemaining, initialTime) {
2452			isHostCallbackScheduled = false;
2453			if (isHostTimeoutScheduled) {
2454				isHostTimeoutScheduled = false;
2455				cancelHostTimeout();
2456			}
2457			isPerformingWork = true;
2458			var previousPriorityLevel = currentPriorityLevel;
2459			try {
2460				if (enableProfiling) try {
2461					return workLoop(hasTimeRemaining, initialTime);
2462				} catch (error) {
2463					if (currentTask !== null) {
2464						exports.unstable_now();
2465						currentTask.isQueued = false;
2466					}
2467					throw error;
2468				}
2469				else return workLoop(hasTimeRemaining, initialTime);
2470			} finally {
2471				currentTask = null;
2472				currentPriorityLevel = previousPriorityLevel;
2473				isPerformingWork = false;
2474			}
2475		}
2476		function workLoop(hasTimeRemaining, initialTime) {
2477			var currentTime = initialTime;
2478			advanceTimers(currentTime);
2479			currentTask = peek(taskQueue);
2480			while (currentTask !== null && !enableSchedulerDebugging) {
2481				if (currentTask.expirationTime > currentTime && (!hasTimeRemaining || shouldYieldToHost())) break;
2482				var callback = currentTask.callback;
2483				if (typeof callback === "function") {
2484					currentTask.callback = null;
2485					currentPriorityLevel = currentTask.priorityLevel;
2486					var continuationCallback = callback(currentTask.expirationTime <= currentTime);
2487					currentTime = exports.unstable_now();
2488					if (typeof continuationCallback === "function") currentTask.callback = continuationCallback;
2489					else if (currentTask === peek(taskQueue)) pop(taskQueue);
2490					advanceTimers(currentTime);
2491				} else pop(taskQueue);
2492				currentTask = peek(taskQueue);
2493			}
2494			if (currentTask !== null) return true;
2495			else {
2496				var firstTimer = peek(timerQueue);
2497				if (firstTimer !== null) requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
2498				return false;
2499			}
2500		}
2501		function unstable_runWithPriority(priorityLevel, eventHandler) {
2502			switch (priorityLevel) {
2503				case ImmediatePriority:
2504				case UserBlockingPriority:
2505				case NormalPriority:
2506				case LowPriority:
2507				case IdlePriority: break;
2508				default: priorityLevel = NormalPriority;
2509			}
2510			var previousPriorityLevel = currentPriorityLevel;
2511			currentPriorityLevel = priorityLevel;
2512			try {
2513				return eventHandler();
2514			} finally {
2515				currentPriorityLevel = previousPriorityLevel;
2516			}
2517		}
2518		function unstable_next(eventHandler) {
2519			var priorityLevel;
2520			switch (currentPriorityLevel) {
2521				case ImmediatePriority:
2522				case UserBlockingPriority:
2523				case NormalPriority:
2524					priorityLevel = NormalPriority;
2525					break;
2526				default:
2527					priorityLevel = currentPriorityLevel;
2528					break;
2529			}
2530			var previousPriorityLevel = currentPriorityLevel;
2531			currentPriorityLevel = priorityLevel;
2532			try {
2533				return eventHandler();
2534			} finally {
2535				currentPriorityLevel = previousPriorityLevel;
2536			}
2537		}
2538		function unstable_wrapCallback(callback) {
2539			var parentPriorityLevel = currentPriorityLevel;
2540			return function() {
2541				var previousPriorityLevel = currentPriorityLevel;
2542				currentPriorityLevel = parentPriorityLevel;
2543				try {
2544					return callback.apply(this, arguments);
2545				} finally {
2546					currentPriorityLevel = previousPriorityLevel;
2547				}
2548			};
2549		}
2550		function unstable_scheduleCallback(priorityLevel, callback, options) {
2551			var currentTime = exports.unstable_now();
2552			var startTime;
2553			if (typeof options === "object" && options !== null) {

2554				var delay = options.delay;
2555				if (typeof delay === "number" && delay > 0) startTime = currentTime + delay;
2556				else startTime = currentTime;
2557			} else startTime = currentTime;
2558			var timeout;
2559			switch (priorityLevel) {
2560				case ImmediatePriority:
2561					timeout = IMMEDIATE_PRIORITY_TIMEOUT;
2562					break;
2563				case UserBlockingPriority:
2564					timeout = USER_BLOCKING_PRIORITY_TIMEOUT;
2565					break;
2566				case IdlePriority:
2567					timeout = IDLE_PRIORITY_TIMEOUT;
2568					break;
2569				case LowPriority:
2570					timeout = LOW_PRIORITY_TIMEOUT;
2571					break;
2572				case NormalPriority:
2573				default:
2574					timeout = NORMAL_PRIORITY_TIMEOUT;
2575					break;
2576			}
2577			var expirationTime = startTime + timeout;
2578			var newTask = {
2579				id: taskIdCounter++,
2580				callback,
2581				priorityLevel,
2582				startTime,
2583				expirationTime,
2584				sortIndex: -1
2585			};
2586			if (startTime > currentTime) {
2587				newTask.sortIndex = startTime;
2588				push(timerQueue, newTask);
2589				if (peek(taskQueue) === null && newTask === peek(timerQueue)) {
2590					if (isHostTimeoutScheduled) cancelHostTimeout();
2591					else isHostTimeoutScheduled = true;
2592					requestHostTimeout(handleTimeout, startTime - currentTime);
2593				}
2594			} else {
2595				newTask.sortIndex = expirationTime;
2596				push(taskQueue, newTask);
2597				if (!isHostCallbackScheduled && !isPerformingWork) {
2598					isHostCallbackScheduled = true;
2599					requestHostCallback(flushWork);
2600				}
2601			}
2602			return newTask;
2603		}
2604		function unstable_pauseExecution() {}
2605		function unstable_continueExecution() {
2606			if (!isHostCallbackScheduled && !isPerformingWork) {
2607				isHostCallbackScheduled = true;
2608				requestHostCallback(flushWork);
2609			}
2610		}
2611		function unstable_getFirstCallbackNode() {
2612			return peek(taskQueue);
2613		}
2614		function unstable_cancelCallback(task) {
2615			task.callback = null;
2616		}
2617		function unstable_getCurrentPriorityLevel() {
2618			return currentPriorityLevel;
2619		}
2620		var isMessageLoopRunning = false;
2621		var scheduledHostCallback = null;
2622		var taskTimeoutID = -1;
2623		var frameInterval = frameYieldMs;
2624		var startTime = -1;
2625		function shouldYieldToHost() {
2626			if (exports.unstable_now() - startTime < frameInterval) return false;
2627			return true;
2628		}
2629		function requestPaint() {}
2630		function forceFrameRate(fps) {
2631			if (fps < 0 || fps > 125) {
2632				console["error"]("forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported");
2633				return;
2634			}
2635			if (fps > 0) frameInterval = Math.floor(1e3 / fps);
2636			else frameInterval = frameYieldMs;
2637		}
2638		var performWorkUntilDeadline = function() {
2639			if (scheduledHostCallback !== null) {
2640				var currentTime = exports.unstable_now();
2641				startTime = currentTime;
2642				var hasTimeRemaining = true;
2643				var hasMoreWork = true;
2644				try {
2645					hasMoreWork = scheduledHostCallback(hasTimeRemaining, currentTime);
2646				} finally {
2647					if (hasMoreWork) schedulePerformWorkUntilDeadline();
2648					else {
2649						isMessageLoopRunning = false;
2650						scheduledHostCallback = null;
2651					}
2652				}
2653			} else isMessageLoopRunning = false;
2654		};
2655		var schedulePerformWorkUntilDeadline;
2656		if (typeof localSetImmediate === "function") schedulePerformWorkUntilDeadline = function() {
2657			localSetImmediate(performWorkUntilDeadline);
2658		};
2659		else if (typeof MessageChannel !== "undefined") {
2660			var channel = new MessageChannel();
2661			var port = channel.port2;
2662			channel.port1.onmessage = performWorkUntilDeadline;
2663			schedulePerformWorkUntilDeadline = function() {
2664				port.postMessage(null);
2665			};
2666		} else schedulePerformWorkUntilDeadline = function() {
2667			localSetTimeout(performWorkUntilDeadline, 0);
2668		};
2669		function requestHostCallback(callback) {
2670			scheduledHostCallback = callback;
2671			if (!isMessageLoopRunning) {
2672				isMessageLoopRunning = true;
2673				schedulePerformWorkUntilDeadline();
2674			}
2675		}
2676		function requestHostTimeout(callback, ms) {
2677			taskTimeoutID = localSetTimeout(function() {
2678				callback(exports.unstable_now());
2679			}, ms);
2680		}
2681		function cancelHostTimeout() {
2682			localClearTimeout(taskTimeoutID);
2683			taskTimeoutID = -1;
2684		}
2685		var unstable_requestPaint = requestPaint;
2686		var unstable_Profiling = null;
2687		exports.unstable_IdlePriority = IdlePriority;
2688		exports.unstable_ImmediatePriority = ImmediatePriority;
2689		exports.unstable_LowPriority = LowPriority;
2690		exports.unstable_NormalPriority = NormalPriority;
2691		exports.unstable_Profiling = unstable_Profiling;
2692		exports.unstable_UserBlockingPriority = UserBlockingPriority;
2693		exports.unstable_cancelCallback = unstable_cancelCallback;
2694		exports.unstable_continueExecution = unstable_continueExecution;
2695		exports.unstable_forceFrameRate = forceFrameRate;
2696		exports.unstable_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel;
2697		exports.unstable_getFirstCallbackNode = unstable_getFirstCallbackNode;
2698		exports.unstable_next = unstable_next;
2699		exports.unstable_pauseExecution = unstable_pauseExecution;
2700		exports.unstable_requestPaint = unstable_requestPaint;
2701		exports.unstable_runWithPriority = unstable_runWithPriority;
2702		exports.unstable_scheduleCallback = unstable_scheduleCallback;
2703		exports.unstable_shouldYield = shouldYieldToHost;
2704		exports.unstable_wrapCallback = unstable_wrapCallback;
2705		if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop === "function") __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(/* @__PURE__ */ new Error());
2706	})();
2707}));
2708//#endregion
2709//#region node_modules/scheduler/index.js
2710var require_scheduler = /* @__PURE__ */ __commonJSMin(((exports, module) => {
2711	if (require_browser().env.NODE_ENV === "production") module.exports = require_scheduler_production_min();
2712	else module.exports = require_scheduler_development();
2713}));
2714//#endregion
2715//#region node_modules/react-dom/cjs/react-dom.production.min.js
2716/**
2717* @license React
2718* react-dom.production.min.js
2719*
2720* Copyright (c) Facebook, Inc. and its affiliates.
2721*
2722* This source code is licensed under the MIT license found in the
2723* LICENSE file in the root directory of this source tree.
2724*/
2725var require_react_dom_production_min = /* @__PURE__ */ __commonJSMin(((exports) => {
2726	var aa = require_react();
2727	var ca = require_scheduler();
2728	function p(a) {
2729		for (var b = "https://reactjs.org/docs/error-decoder.html?invariant=" + a, c = 1; c < arguments.length;