https://trackingconsent.web.app/assets/index-DEe2ATnP.js

1import { t as __commonJSMin } from "./chunk-D5y7Ud3f.js";
2import { r as importShared } from "./_virtual___federation_fn_import-DqlGb765.js";
3import { t as require_react } from "./react-aMBEKtNJ.js";
4import { t as require_react_dom } from "./react-dom-umwhLlbp.js";
5import { n as require_jsx_runtime, t as App } from "./App-B8rtXnMY.js";
6//#region node_modules/scheduler/cjs/scheduler.production.js
7/**
8* @license React
9* scheduler.production.js
10*
11* Copyright (c) Meta Platforms, Inc. and affiliates.
12*
13* This source code is licensed under the MIT license found in the
14* LICENSE file in the root directory of this source tree.
15*/
16var require_scheduler_production = /* @__PURE__ */ __commonJSMin(((exports) => {
17	function push(heap, node) {
18		var index = heap.length;
19		heap.push(node);
20		a: for (; 0 < index;) {
21			var parentIndex = index - 1 >>> 1, parent = heap[parentIndex];
22			if (0 < compare(parent, node)) heap[parentIndex] = node, heap[index] = parent, index = parentIndex;
23			else break a;
24		}
25	}
26	function peek(heap) {
27		return 0 === heap.length ? null : heap[0];
28	}
29	function pop(heap) {
30		if (0 === heap.length) return null;
31		var first = heap[0], last = heap.pop();
32		if (last !== first) {
33			heap[0] = last;
34			a: for (var index = 0, length = heap.length, halfLength = length >>> 1; index < halfLength;) {
35				var leftIndex = 2 * (index + 1) - 1, left = heap[leftIndex], rightIndex = leftIndex + 1, right = heap[rightIndex];
36				if (0 > compare(left, last)) rightIndex < length && 0 > compare(right, left) ? (heap[index] = right, heap[rightIndex] = last, index = rightIndex) : (heap[index] = left, heap[leftIndex] = last, index = leftIndex);
37				else if (rightIndex < length && 0 > compare(right, last)) heap[index] = right, heap[rightIndex] = last, index = rightIndex;
38				else break a;
39			}
40		}
41		return first;
42	}
43	function compare(a, b) {
44		var diff = a.sortIndex - b.sortIndex;
45		return 0 !== diff ? diff : a.id - b.id;
46	}
47	exports.unstable_now = void 0;
48	if ("object" === typeof performance && "function" === typeof performance.now) {
49		var localPerformance = performance;
50		exports.unstable_now = function() {
51			return localPerformance.now();
52		};
53	} else {
54		var localDate = Date, initialTime = localDate.now();
55		exports.unstable_now = function() {
56			return localDate.now() - initialTime;
57		};
58	}
59	var taskQueue = [], timerQueue = [], taskIdCounter = 1, currentTask = null, currentPriorityLevel = 3, isPerformingWork = !1, isHostCallbackScheduled = !1, isHostTimeoutScheduled = !1, needsPaint = !1, localSetTimeout = "function" === typeof setTimeout ? setTimeout : null, localClearTimeout = "function" === typeof clearTimeout ? clearTimeout : null, localSetImmediate = "undefined" !== typeof setImmediate ? setImmediate : null;
60	function advanceTimers(currentTime) {
61		for (var timer = peek(timerQueue); null !== timer;) {
62			if (null === timer.callback) pop(timerQueue);
63			else if (timer.startTime <= currentTime) pop(timerQueue), timer.sortIndex = timer.expirationTime, push(taskQueue, timer);
64			else break;
65			timer = peek(timerQueue);
66		}
67	}
68	function handleTimeout(currentTime) {
69		isHostTimeoutScheduled = !1;
70		advanceTimers(currentTime);
71		if (!isHostCallbackScheduled) if (null !== peek(taskQueue)) isHostCallbackScheduled = !0, isMessageLoopRunning || (isMessageLoopRunning = !0, schedulePerformWorkUntilDeadline());
72		else {
73			var firstTimer = peek(timerQueue);
74			null !== firstTimer && requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
75		}
76	}
77	var isMessageLoopRunning = !1, taskTimeoutID = -1, frameInterval = 5, startTime = -1;
78	function shouldYieldToHost() {
79		return needsPaint ? !0 : exports.unstable_now() - startTime < frameInterval ? !1 : !0;
80	}
81	function performWorkUntilDeadline() {
82		needsPaint = !1;
83		if (isMessageLoopRunning) {
84			var currentTime = exports.unstable_now();
85			startTime = currentTime;
86			var hasMoreWork = !0;
87			try {
88				a: {
89					isHostCallbackScheduled = !1;
90					isHostTimeoutScheduled && (isHostTimeoutScheduled = !1, localClearTimeout(taskTimeoutID), taskTimeoutID = -1);
91					isPerformingWork = !0;
92					var previousPriorityLevel = currentPriorityLevel;
93					try {
94						b: {
95							advanceTimers(currentTime);
96							for (currentTask = peek(taskQueue); null !== currentTask && !(currentTask.expirationTime > currentTime && shouldYieldToHost());) {
97								var callback = currentTask.callback;
98								if ("function" === typeof callback) {
99									currentTask.callback = null;
100									currentPriorityLevel = currentTask.priorityLevel;
101									var continuationCallback = callback(currentTask.expirationTime <= currentTime);
102									currentTime = exports.unstable_now();
103									if ("function" === typeof continuationCallback) {
104										currentTask.callback = continuationCallback;
105										advanceTimers(currentTime);
106										hasMoreWork = !0;
107										break b;
108									}
109									currentTask === peek(taskQueue) && pop(taskQueue);
110									advanceTimers(currentTime);
111								} else pop(taskQueue);
112								currentTask = peek(taskQueue);
113							}
114							if (null !== currentTask) hasMoreWork = !0;
115							else {
116								var firstTimer = peek(timerQueue);
117								null !== firstTimer && requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
118								hasMoreWork = !1;
119							}
120						}
121						break a;
122					} finally {
123						currentTask = null, currentPriorityLevel = previousPriorityLevel, isPerformingWork = !1;
124					}
125					hasMoreWork = void 0;
126				}
127			} finally {
128				hasMoreWork ? schedulePerformWorkUntilDeadline() : isMessageLoopRunning = !1;
129			}
130		}
131	}
132	var schedulePerformWorkUntilDeadline;
133	if ("function" === typeof localSetImmediate) schedulePerformWorkUntilDeadline = function() {
134		localSetImmediate(performWorkUntilDeadline);
135	};
136	else if ("undefined" !== typeof MessageChannel) {
137		var channel = new MessageChannel(), port = channel.port2;
138		channel.port1.onmessage = performWorkUntilDeadline;
139		schedulePerformWorkUntilDeadline = function() {
140			port.postMessage(null);
141		};
142	} else schedulePerformWorkUntilDeadline = function() {
143		localSetTimeout(performWorkUntilDeadline, 0);
144	};
145	function requestHostTimeout(callback, ms) {
146		taskTimeoutID = localSetTimeout(function() {
147			callback(exports.unstable_now());
148		}, ms);
149	}
150	exports.unstable_IdlePriority = 5;
151	exports.unstable_ImmediatePriority = 1;
152	exports.unstable_LowPriority = 4;
153	exports.unstable_NormalPriority = 3;
154	exports.unstable_Profiling = null;
155	exports.unstable_UserBlockingPriority = 2;
156	exports.unstable_cancelCallback = function(task) {
157		task.callback = null;
158	};
159	exports.unstable_forceFrameRate = function(fps) {
160		0 > fps || 125 < fps ? console.error("forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported") : frameInterval = 0 < fps ? Math.floor(1e3 / fps) : 5;
161	};
162	exports.unstable_getCurrentPriorityLevel = function() {
163		return currentPriorityLevel;
164	};
165	exports.unstable_next = function(eventHandler) {
166		switch (currentPriorityLevel) {
167			case 1:
168			case 2:
169			case 3:
170				var priorityLevel = 3;
171				break;
172			default: priorityLevel = currentPriorityLevel;
173		}
174		var previousPriorityLevel = currentPriorityLevel;
175		currentPriorityLevel = priorityLevel;
176		try {
177			return eventHandler();
178		} finally {
179			currentPriorityLevel = previousPriorityLevel;
180		}
181	};
182	exports.unstable_requestPaint = function() {
183		needsPaint = !0;
184	};
185	exports.unstable_runWithPriority = function(priorityLevel, eventHandler) {
186		switch (priorityLevel) {
187			case 1:
188			case 2:
189			case 3:
190			case 4:
191			case 5: break;
192			default: priorityLevel = 3;
193		}
194		var previousPriorityLevel = currentPriorityLevel;
195		currentPriorityLevel = priorityLevel;
196		try {
197			return eventHandler();
198		} finally {
199			currentPriorityLevel = previousPriorityLevel;
200		}
201	};
202	exports.unstable_scheduleCallback = function(priorityLevel, callback, options) {
203		var currentTime = exports.unstable_now();
204		"object" === typeof options && null !== options ? (options = options.delay, options = "number" === typeof options && 0 < options ? currentTime + options : currentTime) : options = currentTime;
205		switch (priorityLevel) {
206			case 1:
207				var timeout = -1;
208				break;
209			case 2:
210				timeout = 250;
211				break;
212			case 5:
213				timeout = 1073741823;
214				break;
215			case 4:
216				timeout = 1e4;
217				break;
218			default: timeout = 5e3;
219		}
220		timeout = options + timeout;
221		priorityLevel = {
222			id: taskIdCounter++,
223			callback,
224			priorityLevel,
225			startTime: options,
226			expirationTime: timeout,
227			sortIndex: -1
228		};
229		options > currentTime ? (priorityLevel.sortIndex = options, push(timerQueue, priorityLevel), null === peek(taskQueue) && priorityLevel === peek(timerQueue) && (isHostTimeoutScheduled ? (localClearTimeout(taskTimeoutID), taskTimeoutID = -1) : isHostTimeoutScheduled = !0, requestHostTimeout(handleTimeout, options - currentTime))) : (priorityLevel.sortIndex = timeout, push(taskQueue, priorityLevel), isHostCallbackScheduled || isPerformingWork || (isHostCallbackScheduled = !0, isMessageLoopRunning || (isMessageLoopRunning = !0, schedulePerformWorkUntilDeadline())));
230		return priorityLevel;
231	};
232	exports.unstable_shouldYield = shouldYieldToHost;
233	exports.unstable_wrapCallback = function(callback) {
234		var parentPriorityLevel = currentPriorityLevel;
235		return function() {
236			var previousPriorityLevel = currentPriorityLevel;
237			currentPriorityLevel = parentPriorityLevel;
238			try {
239				return callback.apply(this, arguments);
240			} finally {
241				currentPriorityLevel = previousPriorityLevel;
242			}
243		};
244	};
245}));
246//#endregion
247//#region node_modules/scheduler/index.js
248var require_scheduler = /* @__PURE__ */ __commonJSMin(((exports, module) => {
249	module.exports = require_scheduler_production();
250}));
251//#endregion
252//#region node_modules/react-dom/cjs/react-dom-client.production.js
253/**
254* @license React
255* react-dom-client.production.js
256*
257* Copyright (c) Meta Platforms, Inc. and affiliates.
258*
259* This source code is licensed under the MIT license found in the
260* LICENSE file in the root directory of this source tree.
261*/
262var require_react_dom_client_production = /* @__PURE__ */ __commonJSMin(((exports) => {
263	var Scheduler = require_scheduler(), React = require_react(), ReactDOM = require_react_dom();
264	function formatProdErrorMessage(code) {
265		var url = "https://react.dev/errors/" + code;
266		if (1 < arguments.length) {
267			url += "?args[]=" + encodeURIComponent(arguments[1]);
268			for (var i = 2; i < arguments.length; i++) url += "&args[]=" + encodeURIComponent(arguments[i]);
269		}
270		return "Minified React error #" + code + "; visit " + url + " for the full message or use the non-minified dev environment for full errors and additional helpful warnings.";
271	}
272	function isValidContainer(node) {
273		return !(!node || 1 !== node.nodeType && 9 !== node.nodeType && 11 !== node.nodeType);
274	}
275	function getNearestMountedFiber(fiber) {
276		var node = fiber, nearestMounted = fiber;
277		if (fiber.alternate) for (; node.return;) node = node.return;
278		else {
279			fiber = node;
280			do
281				node = fiber, 0 !== (node.flags & 4098) && (nearestMounted = node.return), fiber = node.return;
282			while (fiber);
283		}
284		return 3 === node.tag ? nearestMounted : null;
285	}
286	function getSuspenseInstanceFromFiber(fiber) {
287		if (13 === fiber.tag) {
288			var suspenseState = fiber.memoizedState;
289			null === suspenseState && (fiber = fiber.alternate, null !== fiber && (suspenseState = fiber.memoizedState));
290			if (null !== suspenseState) return suspenseState.dehydrated;
291		}
292		return null;
293	}
294	function getActivityInstanceFromFiber(fiber) {
295		if (31 === fiber.tag) {
296			var activityState = fiber.memoizedState;
297			null === activityState && (fiber = fiber.alternate, null !== fiber && (activityState = fiber.memoizedState));
298			if (null !== activityState) return activityState.dehydrated;
299		}
300		return null;
301	}
302	function assertIsMounted(fiber) {
303		if (getNearestMountedFiber(fiber) !== fiber) throw Error(formatProdErrorMessage(188));
304	}
305	function findCurrentFiberUsingSlowPath(fiber) {
306		var alternate = fiber.alternate;
307		if (!alternate) {
308			alternate = getNearestMountedFiber(fiber);
309			if (null === alternate) throw Error(formatProdErrorMessage(188));
310			return alternate !== fiber ? null : fiber;
311		}
312		for (var a = fiber, b = alternate;;) {
313			var parentA = a.return;
314			if (null === parentA) break;
315			var parentB = parentA.alternate;
316			if (null === parentB) {
317				b = parentA.return;
318				if (null !== b) {
319					a = b;
320					continue;
321				}
322				break;
323			}
324			if (parentA.child === parentB.child) {
325				for (parentB = parentA.child; parentB;) {
326					if (parentB === a) return assertIsMounted(parentA), fiber;
327					if (parentB === b) return assertIsMounted(parentA), alternate;
328					parentB = parentB.sibling;
329				}
330				throw Error(formatProdErrorMessage(188));
331			}

332			if (a.return !== b.return) a = parentA, b = parentB;
333			else {
334				for (var didFindChild = !1, child$0 = parentA.child; child$0;) {
335					if (child$0 === a) {
336						didFindChild = !0;
337						a = parentA;
338						b = parentB;
339						break;
340					}
341					if (child$0 === b) {
342						didFindChild = !0;
343						b = parentA;
344						a = parentB;
345						break;
346					}
347					child$0 = child$0.sibling;
348				}
349				if (!didFindChild) {
350					for (child$0 = parentB.child; child$0;) {
351						if (child$0 === a) {
352							didFindChild = !0;
353							a = parentB;
354							b = parentA;
355							break;
356						}
357						if (child$0 === b) {
358							didFindChild = !0;
359							b = parentB;
360							a = parentA;
361							break;
362						}
363						child$0 = child$0.sibling;
364					}
365					if (!didFindChild) throw Error(formatProdErrorMessage(189));
366				}
367			}
368			if (a.alternate !== b) throw Error(formatProdErrorMessage(190));
369		}
370		if (3 !== a.tag) throw Error(formatProdErrorMessage(188));
371		return a.stateNode.current === a ? fiber : alternate;
372	}
373	function findCurrentHostFiberImpl(node) {
374		var tag = node.tag;
375		if (5 === tag || 26 === tag || 27 === tag || 6 === tag) return node;
376		for (node = node.child; null !== node;) {
377			tag = findCurrentHostFiberImpl(node);
378			if (null !== tag) return tag;
379			node = node.sibling;
380		}
381		return null;
382	}
383	var assign = Object.assign, REACT_LEGACY_ELEMENT_TYPE = Symbol.for("react.element"), REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy");
384	var REACT_ACTIVITY_TYPE = Symbol.for("react.activity");
385	var REACT_MEMO_CACHE_SENTINEL = Symbol.for("react.memo_cache_sentinel");
386	var MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
387	function getIteratorFn(maybeIterable) {
388		if (null === maybeIterable || "object" !== typeof maybeIterable) return null;
389		maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
390		return "function" === typeof maybeIterable ? maybeIterable : null;
391	}
392	var REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference");
393	function getComponentNameFromType(type) {
394		if (null == type) return null;
395		if ("function" === typeof type) return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
396		if ("string" === typeof type) return type;
397		switch (type) {
398			case REACT_FRAGMENT_TYPE: return "Fragment";
399			case REACT_PROFILER_TYPE: return "Profiler";
400			case REACT_STRICT_MODE_TYPE: return "StrictMode";
401			case REACT_SUSPENSE_TYPE: return "Suspense";
402			case REACT_SUSPENSE_LIST_TYPE: return "SuspenseList";
403			case REACT_ACTIVITY_TYPE: return "Activity";
404		}
405		if ("object" === typeof type) switch (type.$$typeof) {
406			case REACT_PORTAL_TYPE: return "Portal";
407			case REACT_CONTEXT_TYPE: return type.displayName || "Context";
408			case REACT_CONSUMER_TYPE: return (type._context.displayName || "Context") + ".Consumer";
409			case REACT_FORWARD_REF_TYPE:
410				var innerType = type.render;
411				type = type.displayName;
412				type || (type = innerType.displayName || innerType.name || "", type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef");
413				return type;
414			case REACT_MEMO_TYPE: return innerType = type.displayName || null, null !== innerType ? innerType : getComponentNameFromType(type.type) || "Memo";
415			case REACT_LAZY_TYPE:
416				innerType = type._payload;
417				type = type._init;
418				try {
419					return getComponentNameFromType(type(innerType));
420				} catch (x) {}
421		}
422		return null;
423	}
424	var isArrayImpl = Array.isArray, ReactSharedInternals = React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, ReactDOMSharedInternals = ReactDOM.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, sharedNotPendingOb

424ject = {
425		pending: !1,
426		data: null,
427		method: null,
428		action: null
429	}, valueStack = [], index = -1;
430	function createCursor(defaultValue) {
431		return { current: defaultValue };
432	}
433	function pop(cursor) {
434		0 > index || (cursor.current = valueStack[index], valueStack[index] = null, index--);
435	}
436	function push(cursor, value) {
437		index++;
438		valueStack[index] = cursor.current;
439		cursor.current = value;
440	}
441	var contextStackCursor = createCursor(null), contextFiberStackCursor = createCursor(null), rootInstanceStackCursor = createCursor(null), hostTransitionProviderCursor = createCursor(null);
442	function pushHostContainer(fiber, nextRootInstance) {
443		push(rootInstanceStackCursor, nextRootInstance);
444		push(contextFiberStackCursor, fiber);
445		push(contextStackCursor, null);
446		switch (nextRootInstance.nodeType) {
447			case 9:
448			case 11:
449				fiber = (fiber = nextRootInstance.documentElement) ? (fiber = fiber.namespaceURI) ? getOwnHostContext(fiber) : 0 : 0;
450				break;
451			default: if (fiber = nextRootInstance.tagName, nextRootInstance = nextRootInstance.namespaceURI) nextRootInstance = getOwnHostContext(nextRootInstance), fiber = getChildHostContextProd(nextRootInstance, fiber);
452			else switch (fiber) {
453				case "svg":
454					fiber = 1;
455					break;
456				case "math":
457					fiber = 2;
458					break;
459				default: fiber = 0;
460			}
461		}
462		pop(contextStackCursor);
463		push(contextStackCursor, fiber);
464	}
465	function popHostContainer() {
466		pop(contextStackCursor);
467		pop(contextFiberStackCursor);
468		pop(rootInstanceStackCursor);
469	}
470	function pushHostContext(fiber) {
471		null !== fiber.memoizedState && push(hostTransitionProviderCursor, fiber);
472		var context = contextStackCursor.current;
473		var JSCompiler_inline_result = getChildHostContextProd(context, fiber.type);
474		context !== JSCompiler_inline_result && (push(contextFiberStackCursor, fiber), push(contextStackCursor, JSCompiler_inline_result));
475	}
476	function popHostContext(fiber) {
477		contextFiberStackCursor.current === fiber && (pop(contextStackCursor), pop(contextFiberStackCursor));
478		hostTransitionProviderCursor.current === fiber && (pop(hostTransitionProviderCursor), HostTransitionContext._currentValue = sharedNotPendingObject);
479	}
480	var prefix, suffix;
481	function describeBuiltInComponentFrame(name) {
482		if (void 0 === prefix) try {
483			throw Error();
484		} catch (x) {
485			var match = x.stack.trim().match(/\n( *(at )?)/);
486			prefix = match && match[1] || "";
487			suffix = -1 < x.stack.indexOf("\n    at") ? " (<anonymous>)" : -1 < x.stack.indexOf("@") ? "@unknown:0:0" : "";
488		}
489		return "\n" + prefix + name + suffix;
490	}
491	var reentry = !1;
492	function describeNativeComponentFrame(fn, construct) {
493		if (!fn || reentry) return "";
494		reentry = !0;
495		var previousPrepareStackTrace = Error.prepareStackTrace;
496		Error.prepareStackTrace = void 0;
497		try {
498			var RunInRootFrame = { DetermineComponentFrameRoot: function() {
499				try {
500					if (construct) {
501						var Fake = function() {
502							throw Error();
503						};
504						Object.defineProperty(Fake.prototype, "props", { set: function() {
505							throw Error();
506						} });
507						if ("object" === typeof Reflect && Reflect.construct) {
508							try {
509								Reflect.construct(Fake, []);
510							} catch (x) {
511								var control = x;
512							}
513							Reflect.construct(fn, [], Fake);
514						} else {
515							try {
516								Fake.call();
517							} catch (x$1) {
518								control = x$1;
519							}
520							fn.call(Fake.prototype);
521						}
522					} else {
523						try {
524							throw Error();
525						} catch (x$2) {
526							control = x$2;
527						}
528						(Fake = fn()) && "function" === typeof Fake.catch && Fake.catch(function() {});
529					}
530				} catch (sample) {
531					if (sample && control && "string" === typeof sample.stack) return [sample.stack, control.stack];
532				}
533				return [null, null];
534			} };
535			RunInRootFrame.DetermineComponentFrameRoot.displayName = "DetermineComponentFrameRoot";
536			var namePropDescriptor = Object.getOwnPropertyDescriptor(RunInRootFrame.DetermineComponentFrameRoot, "name");
537			namePropDescriptor && namePropDescriptor.configurable && Object.defineProperty(RunInRootFrame.DetermineComponentFrameRoot, "name", { value: "DetermineComponentFrameRoot" });
538			var _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(), sampleStack = _RunInRootFrame$Deter[0], controlStack = _RunInRootFrame$Deter[1];
539			if (sampleStack && controlStack) {
540				var sampleLines = sampleStack.split("\n"), controlLines = controlStack.split("\n");
541				for (namePropDescriptor = RunInRootFrame = 0; RunInRootFrame < sampleLines.length && !sampleLines[RunInRootFrame].includes("DetermineComponentFrameRoot");) RunInRootFrame++;
542				for (; namePropDescriptor < controlLines.length && !controlLines[namePropDescriptor].includes("DetermineComponentFrameRoot");) namePropDescriptor++;
543				if (RunInRootFrame === sampleLines.length || namePropDescriptor === controlLines.length) for (RunInRootFrame = sampleLines.length - 1, namePropDescriptor = controlLines.length - 1; 1 <= RunInRootFrame && 0 <= namePropDescriptor && sampleLines[RunInRootFrame] !== controlLines[namePropDescriptor];) namePropDescriptor--;
544				for (; 1 <= RunInRootFrame && 0 <= namePropDescriptor; RunInRootFrame--, namePropDescriptor--) if (sampleLines[RunInRootFrame] !== controlLines[namePropDescriptor]) {
545					if (1 !== RunInRootFrame || 1 !== namePropDescriptor) do
546						if (RunInRootFrame--, namePropDescriptor--, 0 > namePropDescriptor || sampleLines[RunInRootFrame] !== controlLines[namePropDescriptor]) {
547							var frame = "\n" + sampleLines[RunInRootFrame].replace(" at new ", " at ");
548							fn.displayName && frame.includes("<anonymous>") && (frame = frame.replace("<anonymous>", fn.displayName));
549							return frame;
550						}
551					while (1 <= RunInRootFrame && 0 <= namePropDescriptor);
552					break;
553				}
554			}
555		} finally {
556			reentry = !1, Error.prepareStackTrace = previousPrepareStackTrace;
557		}
558		return (previousPrepareStackTrace = fn ? fn.displayName || fn.name : "") ? describeBuiltInComponentFrame(previousPrepareStackTrace) : "";
559	}
560	function describeFiber(fiber, childFiber) {
561		switch (fiber.tag) {
562			case 26:
563			case 27:
564			case 5: return describeBuiltInComponentFrame(fiber.type);
565			case 16: return describeBuiltInComponentFrame("Lazy");
566			case 13: return fiber.child !== childFiber && null !== childFiber ? describeBuiltInComponentFrame("Suspense Fallback") : describeBuiltInComponentFrame("Suspense");
567			case 19: return describeBuiltInComponentFrame("SuspenseList");
568			case 0:
569			case 15: return describeNativeComponentFrame(fiber.type, !1);
570			case 11: return describeNativeComponentFrame(fiber.type.render, !1);
571			case 1: return describeNativeComponentFrame(fiber.type, !0);
572			case 31: return describeBuiltInComponentFrame("Activity");
573			default: return "";
574		}
575	}
576	function getStackByFiberInDevAndProd(workInProgress) {
577		try {
578			var info = "", previous = null;
579			do
580				info += describeFiber(workInProgress, previous), previous = workInProgress, workInProgress = workInProgress.return;
581			while (workInProgress);
582			return info;
583		} catch (x) {
584			return "\nError generating stack: " + x.message + "\n" + x.stack;
585		}
586	}
587	var hasOwnProperty = Object.prototype.hasOwnProperty, scheduleCallback$3 = Scheduler.unstable_scheduleCallback, cancelCallback$1 = Scheduler.unstable_cancelCallback, shouldYield = Scheduler.unstable_shouldYield, requestPaint = Scheduler.unstable_requestPaint, now = Scheduler.unstable_now, getCurrentPriorityLevel = Scheduler.unstable_getCurrentPriorityLevel, ImmediatePriority = Scheduler.unstable_ImmediatePriority, UserBlockingPriority = Scheduler.unstable_UserBlockingPriority, NormalPriority$1 = Scheduler.unstable_NormalPriority, LowPriority = Scheduler.unstable_LowPriority, IdlePriority = Scheduler.unstable_IdlePriority, log$1 = Scheduler.log, unstable_setDisableYieldValue = Scheduler.unstable_setDisableYieldValue, rendererID = null, injectedHook = null;
588	function setIsStrictModeForDevtools(newIsStrictMode) {
589		"function" === typeof log$1 && unstable_setDisableYieldValue(newIsStrictMode);
590		if (injectedHook && "function" === typeof injectedHook.setStrictMode) try {
591			injectedHook.setStrictMode(rendererID, newIsStrictMode);
592		} catch (err) {}
593	}
594	var clz32 = Math.clz32 ? Math.clz32 : clz32Fallback, log = Math.log, LN2 = Math.LN2;
595	function clz32Fallback(x) {
596		x >>>= 0;
597		return 0 === x ? 32 : 31 - (log(x) / LN2 | 0) | 0;
598	}
599	var nextTransitionUpdateLane = 256, nextTransitionDeferredLane = 262144, nextRetryLane = 4194304;
600	function getHighestPriorityLanes(lanes) {
601		var pendingSyncLanes = lanes & 42;
602		if (0 !== pendingSyncLanes) return pendingSyncLanes;
603		switch (lanes & -lanes) {
604			case 1: return 1;
605			case 2: return 2;
606			case 4: return 4;
607			case 8: return 8;
608			case 16: return 16;
609			case 32: return 32;
610			case 64: return 64;
611			case 128: return 128;
612			case 256:
613			case 512:
614			case 1024:
615			case 2048:
616			case 4096:
617			case 8192:
618			case 16384:
619			case 32768:
620			case 65536:
621			case 131072: return lanes & 261888;
622			case 262144:
623			case 524288:
624			case 1048576:
625			case 2097152: return lanes & 3932160;
626			case 4194304:
627			case 8388608:
628			case 16777216:
629			case 33554432: return lanes & 62914560;
630			case 67108864: return 67108864;
631			case 134217728: return 134217728;
632			case 268435456: return 268435456;
633			case 536870912: return 536870912;
634			case 1073741824: return 0;
635			default: return lanes;
636		}
637	}
638	function getNextLanes(root, wipLanes, rootHasPendingCommit) {
639		var pendingLanes = root.pendingLanes;
640		if (0 === pendingLanes) return 0;
641		var nextLanes = 0, suspendedLanes = root.suspendedLanes, pingedLanes = root.pingedLanes;
642		root = root.warmLanes;
643		var nonIdlePendingLanes = pendingLanes & 134217727;
644		0 !== nonIdlePendingLanes ? (pendingLanes = nonIdlePendingLanes & ~suspendedLanes, 0 !== pendingLanes ? nextLanes = getHighestPriorityLanes(pendingLanes) : (pingedLanes &= nonIdlePendingLanes, 0 !== pingedLanes ? nextLanes = getHighestPriorityLanes(pingedLanes) : rootHasPendingCommit || (rootHasPendingCommit = nonIdlePendingLanes & ~root, 0 !== rootHasPendingCommit && (nextLanes = getHighestPriorityLanes(rootHasPendingCommit))))) : (nonIdlePendingLanes = pendingLanes & ~suspendedLanes, 0 !== nonIdlePendingLanes ? nextLanes = getHighestPriorityLanes(nonIdlePendingLanes) : 0 !== pingedLanes ? nextLanes = getHighestPriorityLanes(pingedLanes) : rootHasPendingCommit || (rootHasPendingCommit = pendingLanes & ~root, 0 !== rootHasPendingCommit && (nextLanes = getHighestPriorityLanes(rootHasPendingCommit))));
645		return 0 === nextLanes ? 0 : 0 !== wipLanes && wipLanes !== nextLanes && 0 === (wipLanes & suspendedLanes) && (suspendedLanes = nextLanes & -nextLanes, rootHasPendingCommit = wipLanes & -wipLanes, suspendedLanes >= rootHasPendingCommit || 32 === suspendedLanes && 0 !== (rootHasPendingCommit & 4194048)) ? wipLanes : nextLanes;
646	}
647	function checkIfRootIsPrerendering(root, renderLanes) {
648		return 0 === (root.pendingLanes & ~(root.suspendedLanes & ~root.pingedLanes) & renderLanes);
649	}
650	function computeExpirationTime(lane, currentTime) {
651		switch (lane) {
652			case 1:
653			case 2:
654			case 4:
655			case 8:
656			case 64: return currentTime + 250;
657			case 16:
658			case 32:
659			case 128:
660			case 256:
661			case 512:
662			case 1024:
663			case 2048:
664			case 4096:
665			case 8192:
666			case 16384:
667			case 32768:
668			case 65536:
669			case 131072:
670			case 262144:
671			case 524288:
672			case 1048576:
673			case 2097152: return currentTime + 5e3;
674			case 4194304:
675			case 8388608:
676			case 16777216:
677			case 33554432: return -1;
678			case 67108864:
679			case 134217728:
680			case 268435456:
681			case 536870912:
682			case 1073741824: return -1;
683			default: return -1;
684		}
685	}
686	function claimNextRetryLane() {
687		var lane = nextRetryLane;
688		nextRetryLane <<= 1;
689		0 === (nextRetryLane & 62914560) && (nextRetryLane = 4194304);
690		return lane;
691	}
692	function createLaneMap(initial) {
693		for (var laneMap = [], i = 0; 31 > i; i++) laneMap.push(initial);
694		return laneMap;
695	}
696	function markRootUpdated$1(root, updateLane) {
697		root.pendingLanes |= updateLane;
698		268435456 !== updateLane && (root.suspendedLanes = 0, root.pingedLanes = 0, root.warmLanes = 0);
699	}
700	function markRootFinished(root, finishedLanes, remainingLanes, spawnedLane, updatedLanes, suspendedRetryLanes) {
701		var previouslyPendingLanes = root.pendingLanes;
702		root.pendingLanes = remainingLanes;
703		root.suspendedLanes = 0;
704		root.pingedLanes = 0;
705		root.warmLanes = 0;
706		root.expiredLanes &= remainingLanes;
707		root.entangledLanes &= remainingLanes;
708		root.errorRecoveryDisabledLanes &= remainingLanes;
709		root.shellSuspendCounter = 0;
710		var entanglements = root.entanglements, expirationTimes = root.expirationTimes, hiddenUpdates = root.hiddenUpdates;
711		for (remainingLanes = previouslyPendingLanes & ~remainingLanes; 0 < remainingLanes;) {
712			var index$7 = 31 - clz32(remainingLanes), lane = 1 << index$7;
713			entanglements[index$7] = 0;
714			expirationTimes[index$7] = -1;
715			var hiddenUpdatesForLane = hiddenUpdates[index$7];
716			if (null !== hiddenUpdatesForLane) for (hiddenUpdates[index$7] = null, index$7 = 0; index$7 < hiddenUpdatesForLane.length; index$7++) {
717				var update = hiddenUpdatesForLane[index$7];
718				null !== update && (update.lane &= -536870913);
719			}
720			remainingLanes &= ~lane;
721		}
722		0 !== spawnedLane && markSpawnedDeferredLane(root, spawnedLane, 0);
723		0 !== suspendedRetryLanes && 0 === updatedLanes && 0 !== root.tag && (root.suspendedLanes |= suspendedRetryLanes & ~(previouslyPendingLanes & ~finishedLanes));
724	}
725	function markSpawnedDeferredLane(root, spawnedLane, entangledLanes) {
726		root.pendingLanes |= spawnedLane;
727		root.suspendedLanes &= ~spawnedLane;
728		var spawnedLaneIndex = 31 - clz32(spawnedLane);
729		root.entangledLanes |= spawnedLane;
730		root.entanglements[spawnedLaneIndex] = root.entanglements[spawnedLaneIndex] | 1073741824 | entangledLanes & 261930;
731	}
732	function markRootEntangled(root, entangledLanes) {
733		var rootEntangledLanes = root.entangledLanes |= entangledLanes;
734		for (root = root.entanglements; rootEntangledLanes;) {
735			var index$8 = 31 - clz32(rootEntangledLanes), lane = 1 << index$8;
736			lane & entangledLanes | root[index$8] & entangledLanes && (root[index$8] |= entangledLanes);
737			rootEntangledLanes &= ~lane;
738		}
739	}
740	function getBumpedLaneForHydration(root, renderLanes) {
741		var renderLane = renderLanes & -renderLanes;
742		renderLane = 0 !== (renderLane & 42) ? 1 : getBumpedLaneForHydrationByLane(renderLane);
743		return 0 !== (renderLane & (root.suspendedLanes | renderLanes)) ? 0 : renderLane;
744	}
745	function getBumpedLaneForHydrationByLane(lane) {
746		switch (lane) {
747			case 2:
748				lane = 1;
749				break;
750			case 8:
751				lane = 4;
752				break;
753			case 32:
754				lane = 16;
755				break;
756			case 256:
757			case 512:
758			case 1024:
759			case 2048:
760			case 4096:
761			case 8192:
762			case 16384:
763			case 32768:
764			case 65536:
765			case 131072:
766			case 262144:
767			case 524288:
768			case 1048576:
769			case 2097152:
770			case 4194304:
771			case 8388608:
772			case 16777216:
773			case 33554432:
774				lane = 128;
775				break;
776			case 268435456:
777				lane = 134217728;
778				break;
779			default: lane = 0;
780		}
781		return lane;
782	}
783	function lanesToEventPriority(lanes) {
784		lanes &= -lanes;
785		return 2 < lanes ? 8 < lanes ? 0 !== (lanes & 134217727) ? 32 : 268435456 : 8 : 2;
786	}
787	function resolveUpdatePriority() {
788		var updatePriority = ReactDOMSharedInternals.p;
789		if (0 !== updatePriority) return updatePriority;
790		updatePriority = window.event;
791		return void 0 === updatePriority ? 32 : getEventPriority(updatePriority.type);
792	}
793	function runWithPriority(priority, fn) {
794		var previousPriority = ReactDOMSharedInternals.p;
795		try {
796			return ReactDOMSharedInternals.p = priority, fn();
797		} finally {
798			ReactDOMSharedInternals.p = previousPriority;
799		}
800	}
801	var randomKey = Math.random().toString(36).slice(2), internalInstanceKey = "__reactFiber$" + randomKey, internalPropsKey = "__reactProps$" + randomKey, internalContainerInstanceKey = "__reactContainer$" + randomKey, internalEventHandlersKey = "__reactEvents$" + randomKey, internalEventHandlerListenersKey = "__reactListeners$" + randomKey, internalEventHandlesSetKey = "__reactHandles$" + randomKey, internalRootNodeResourcesKey = "__reactResources$" + randomKey, internalHoistableMarker = "__reactMarker$" + randomKey;
802	function detachDeletedInstance(node) {
803		delete node[internalInstanceKey];
804		delete node[internalPropsKey];
805		delete node[internalEventHandlersKey];
806		delete node[internalEventHandlerListenersKey];
807		delete node[internalEventHandlesSetKey];
808	}
809	function getClosestInstanceFromNode(targetNode) {
810		var targetInst = targetNode[internalInstanceKey];
811		if (targetInst) return targetInst;
812		for (var parentNode = targetNode.parentNode; parentNode;) {
813			if (targetInst = parentNode[internalContainerInstanceKey] || parentNode[internalInstanceKey]) {
814				parentNode = targetInst.alternate;
815				if (null !== targetInst.child || null !== parentNode && null !== parentNode.child) for (targetNode = getParentHydrationBoundary(targetNode); null !== targetNode;) {
816					if (parentNode = targetNode[internalInstanceKey]) return parentNode;
817					targetNode = getParentHydrationBoundary(targetNode);
818				}
819				return targetInst;
820			}
821			targetNode = parentNode;
822			parentNode = targetNode.parentNode;
823		}
824		return null;
825	}
826	function getInstanceFromNode(node) {
827		if (node = node[internalInstanceKey] || node[internalContainerInstanceKey]) {
828			var tag = node.tag;
829			if (5 === tag || 6 === tag || 13 === tag || 31 === tag || 26 === tag || 27 === tag || 3 === tag) return node;
830		}
831		return null;
832	}
833	function getNodeFromInstance(inst) {
834		var tag = inst.tag;
835		if (5 === tag || 26 === tag || 27 === tag || 6 === tag) return inst.stateNode;
836		throw Error(formatProdErrorMessage(33));
837	}
838	function getResourcesFromRoot(root) {
839		var resources = root[internalRootNodeResourcesKey];
840		resources || (resources = root[internalRootNodeResourcesKey] = {
841			hoistableStyles: /* @__PURE__ */ new Map(),
842			hoistableScripts: /* @__PURE__ */ new Map()
843		});
844		return resources;
845	}
846	function markNodeAsHoistable(node) {
847		node[internalHoistableMarker] = !0;
848	}
849	var allNativeEvents = /* @__PURE__ */ new Set(), registrationNameDependencies = {};
850	function registerTwoPhaseEvent(registrationName, dependencies) {
851		registerDirectEvent(registrationName, dependencies);
852		registerDirectEvent(registrationName + "Capture", dependencies);
853	}
854	function registerDirectEvent(registrationName, dependencies) {
855		registrationNameDependencies[registrationName] = dependencies;
856		for (registrationName = 0; registrationName < dependencies.length; registrationName++) allNativeEvents.add(dependencies[registrationName]);
857	}
858	var VALID_ATTRIBUTE_NAME_REGEX = RegExp("^[:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD][:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$"), illegalAttributeNameCache = {}, validatedAttributeNameCache = {};
859	function isAttributeNameSafe(attributeName) {
860		if (hasOwnProperty.call(validatedAttributeNameCache, attributeName)) return !0;
861		if (hasOwnProperty.call(illegalAttributeNameCache, attributeName)) return !1;
862		if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) return validatedAttributeNameCache[attributeName] = !0;
863		illegalAttributeNameCache[attributeName] = !0;
864		return !1;
865	}
866	function setValueForAttribute(node, name, value) {
867		if (isAttributeNameSafe(name)) if (null === value) node.removeAttribute(name);
868		else {
869			switch (typeof value) {
870				case "undefined":
871				case "function":
872				case "symbol":
873					node.removeAttribute(name);
874					return;
875				case "boolean":
876					var prefix$10 = name.toLowerCase().slice(0, 5);
877					if ("data-" !== prefix$10 && "aria-" !== prefix$10) {
878						node.removeAttribute(name);
879						return;
880					}
881			}
882			node.setAttribute(name, "" + value);
883		}
884	}
885	function setValueForKnownAttribute(node, name, value) {
886		if (null === value) node.removeAttribute(name);
887		else {
888			switch (typeof value) {
889				case "undefined":
890				case "function":
891				case "symbol":
892				case "boolean":
893					node.removeAttribute(name);
894					return;
895			}
896			node.setAttribute(name, "" + value);
897		}
898	}
899	function setValueForNamespacedAttribute(node, namespace, name, value) {
900		if (null === value) node.removeAttribute(name);
901		else {
902			switch (typeof value) {
903				case "undefined":
904				case "function":
905				case "symbol":
906				case "boolean":
907					node.removeAttribute(name);
908					return;
909			}
910			node.setAttributeNS(namespace, name, "" + value);
911		}
912	}
913	function getToStringValue(value) {
914		switch (typeof value) {
915			case "bigint":
916			case "boolean":
917			case "number":
918			case "string":
919			case "undefined": return value;
920			case "object": return value;
921			default: return "";
922		}
923	}
924	function isCheckable(elem) {
925		var type = elem.type;
926		return (elem = elem.nodeName) && "input" === elem.toLowerCase() && ("checkbox" === type || "radio" === type);
927	}
928	function trackValueOnNode(node, valueField, currentValue) {
929		var descriptor = Object.getOwnPropertyDescriptor(node.constructor.prototype, valueField);
930		if (!node.hasOwnProperty(valueField) && "undefined" !== typeof descriptor && "function" === typeof descriptor.get && "function" === typeof descriptor.set) {
931			var get = descriptor.get, set = descriptor.set;
932			Object.defineProperty(node, valueField, {
933				configurable: !0,
934				get: function() {
935					return get.call(this);
936				},
937				set: function(value) {
938					currentValue = "" + value;
939					set.call(this, value);
940				}
941			});
942			Object.defineProperty(node, valueField, { enumerable: descriptor.enumerable });
943			return {
944				getValue: function() {
945					return currentValue;
946				},
947				setValue: function(value) {
948					currentValue = "" + value;
949				},
950				stopTracking: function() {
951					node._valueTracker = null;
952					delete node[valueField];
953				}
954			};
955		}
956	}
957	function track(node) {
958		if (!node._valueTracker) {
959			var valueField = isCheckable(node) ? "checked" : "value";
960			node._valueTracker = trackValueOnNode(node, valueField, "" + node[valueField]);
961		}
962	}
963	function updateValueIfChanged(node) {
964		if (!node) return !1;
965		var tracker = node._valueTracker;
966		if (!tracker) return !0;
967		var lastValue = tracker.getValue();
968		var value = "";
969		node && (value = isCheckable(node) ? node.checked ? "true" : "false" : node.value);
970		node = value;
971		return node !== lastValue ? (tracker.setValue(node), !0) : !1;
972	}
973	function getActiveElement(doc) {
974		doc = doc || ("undefined" !== typeof document ? document : void 0);
975		if ("undefined" === typeof doc) return null;
976		try {
977			return doc.activeElement || doc.body;
978		} catch (e) {
979			return doc.body;
980		}
981	}
982	var escapeSelectorAttributeValueInsideDoubleQuotesRegex = /[\n"\\]/g;
983	function escapeSelectorAttributeValueInsideDoubleQuotes(value) {
984		return value.replace(escapeSelectorAttributeValueInsideDoubleQuotesRegex, function(ch) {
985			return "\\" + ch.charCodeAt(0).toString(16) + " ";
986		});
987	}
988	function updateInput(element, value, defaultValue, lastDefaultValue, checked, defaultChecked, type, name) {
989		element.name = "";
990		null != type && "function" !== typeof type && "symbol" !== typeof type && "boolean" !== typeof type ? element.type = type : element.removeAttribute("type");
991		if (null != value) if ("number" === type) {
992			if (0 === value && "" === element.value || element.value != value) element.value = "" + getToStringValue(value);
993		} else element.value !== "" + getToStringValue(value) && (element.value = "" + getToStringValue(value));
994		else "submit" !== type && "reset" !== type || element.removeAttribute("value");
995		null != value ? setDefaultValue(element, type, getToStringValue(value)) : null != defaultValue ? setDefaultValue(element, type, getToStringValue(defaultValue)) : null != lastDefaultValue && element.removeAttribute("value");
996		null == checked && null != defaultChecked && (element.defaultChecked = !!defaultChecked);
997		null != checked && (element.checked = checked && "function" !== typeof checked && "symbol" !== typeof checked);
998		null != name && "function" !== typeof name && "symbol" !== typeof name && "boolean" !== typeof name ? element.name = "" + getToStringValue(name) : element.removeAttribute("name");
999	}
1000	function initInput(element, value, defaultValue, checked, defaultChecked, type, name, isHydrating) {
1001		null != type && "function" !== typeof type && "symbol" !== typeof type && "boolean" !== typeof type && (element.type = type);
1002		if (null != value || null != defaultValue) {
1003			if (!("submit" !== type && "reset" !== type || void 0 !== value && null !== value)) {
1004				track(element);
1005				return;
1006			}
1007			defaultValue = null != defaultValue ? "" + getToStringValue(defaultValue) : "";
1008			value = null != value ? "" + getToStringValue(value) : defaultValue;
1009			isHydrating || value === element.value || (element.value = value);
1010			element.defaultValue = value;
1011		}
1012		checked = null != checked ? checked : defaultChecked;
1013		checked = "function" !== typeof checked && "symbol" !== typeof checked && !!checked;
1014		element.checked = isHydrating ? element.checked : !!checked;
1015		element.defaultChecked = !!checked;
1016		null != name && "function" !== typeof name && "symbol" !== typeof name && "boolean" !== typeof name && (element.name = name);
1017		track(element);
1018	}
1019	function setDefaultValue(node, type, value) {
1020		"number" === type && getActiveElement(node.ownerDocument) === node || node.defaultValue === "" + value || (node.defaultValue = "" + value);
1021	}
1022	function updateOptions(node, multiple, propValue, setDefaultSelected) {
1023		node = node.options;
1024		if (multiple) {
1025			multiple = {};
1026			for (var i = 0; i < propValue.length; i++) multiple["$" + propValue[i]] = !0;
1027			for (propValue = 0; propValue < node.length; propValue++) i = multiple.hasOwnProperty("$" + node[propValue].value), node[propValue].selected !== i && (node[propValue].selected = i), i && setDefaultSelected && (node[propValue].defaultSelected = !0);
1028		} else {
1029			propValue = "" + getToStringValue(propValue);
1030			multiple = null;
1031			for (i = 0; i < node.length; i++) {
1032				if (node[i].value === propValue) {
1033					node[i].selected = !0;
1034					setDefaultSelected && (node[i].defaultSelected = !0);
1035					return;
1036				}
1037				null !== multiple || node[i].disabled || (multiple = node[i]);
1038			}
1039			null !== multiple && (multiple.selected = !0);
1040		}
1041	}
1042	function updateTextarea(element, value, defaultValue) {
1043		if (null != value && (value = "" + getToStringValue(value), value !== element.value && (element.value = value), null == defaultValue)) {
1044			element.defaultValue !== value && (element.defaultValue = value);
1045			return;
1046		}
1047		element.defaultValue = null != defaultValue ? "" + getToStringValue(defaultValue) : "";
1048	}
1049	function initTextarea(element, value, defaultValue, children) {
1050		if (null == value) {
1051			if (null != children) {
1052				if (null != defaultValue) throw Error(formatProdErrorMessage(92));
1053				if (isArrayImpl(children)) {
1054					if (1 < children.length) throw Error(formatProdErrorMessage(93));
1055					children = children[0];
1056				}
1057				defaultValue = children;
1058			}
1059			defaultValue ??= "";
1060			value = defaultValue;
1061		}
1062		defaultValue = getToStringValue(value);
1063		element.defaultValue = defaultValue;
1064		children = element.textContent;
1065		children === defaultValue && "" !== children && null !== children && (element.value = children);
1066		track(element);
1067	}
1068	function setTextContent(node, text) {
1069		if (text) {
1070			var firstChild = node.firstChild;
1071			if (firstChild && firstChild === node.lastChild && 3 === firstChild.nodeType) {
1072				firstChild.nodeValue = text;
1073				return;
1074			}
1075		}
1076		node.textContent = text;
1077	}
1078	var unitlessNumbers = new Set("animationIterationCount aspectRatio borderImageOutset borderImageSlice borderImageWidth boxFlex boxFlexGroup boxOrdinalGroup columnCount columns flex flexGrow flexPositive flexShrink flexNegative flexOrder gridArea gridRow gridRowEnd gridRowSpan gridRowStart gridColumn gridColumnEnd gridColumnSpan gridColumnStart fontWeight lineClamp lineHeight opacity order orphans scale tabSize widows zIndex zoom fillOpacity floodOpacity stopOpacity strokeDasharray strokeDashoffset strokeMiterlimit strokeOpacity strokeWidth MozAnimationIterationCount MozBoxFlex MozBoxFlexGroup MozLineClamp msAnimationIterationCount msFlex msZoom msFlexGrow msFlexNegative msFlexOrder msFlexPositive msFlexShrink msGridColumn msGridColumnSpan msGridRow msGridRowSpan WebkitAnimationIterationCount WebkitBoxFlex WebKitBoxFlexGroup WebkitBoxOrdinalGroup WebkitColumnCount WebkitColumns WebkitFlex WebkitFlexGrow WebkitFlexPositive WebkitFlexShrink WebkitLineClamp".split(" "));
1079	function setValueForStyle(style, styleName, value) {
1080		var isCustomProperty = 0 === styleName.indexOf("--");
1081		null == value || "boolean" === typeof value || "" === value ? isCustomProperty ? style.setProperty(styleName, "") : "float" === styleName ? style.cssFloat = "" : style[styleName] = "" : isCustomProperty ? style.setProperty(styleName, value) : "number" !== typeof value || 0 === value || unitlessNumbers.has(styleName) ? "float" === styleName ? style.cssFloat = value : style[styleName] = ("" + value).trim() : style[styleName] = value + "px";
1082	}
1083	function setValueForStyles(node, styles, prevStyles) {
1084		if (null != styles && "object" !== typeof styles) throw Error(formatProdErrorMessage(62));
1085		node = node.style;
1086		if (null != prevStyles) {
1087			for (var styleName in prevStyles) !prevStyles.hasOwnProperty(styleName) || null != styles && styles.hasOwnProperty(styleName) || (0 === styleName.indexOf("--") ? node.setProperty(styleName, "") : "float" === styleName ? node.cssFloat = "" : node[styleName] = "");
1088			for (var styleName$16 in styles) styleName = styles[styleName$16], styles.hasOwnProperty(styleName$16) && prevStyles[styleName$16] !== styleName && setValueForStyle(node, styleName$16, styleName);
1089		} else for (var styleName$17 in styles) styles.hasOwnProperty(styleName$17) && setValueForStyle(node, styleName$17, styles[styleName$17]);
1090	}
1091	function isCustomElement(tagName) {
1092		if (-1 === tagName.indexOf("-")) return !1;
1093		switch (tagName) {
1094			case "annotation-xml":
1095			case "color-profile":
1096			case "font-face":
1097			case "font-face-src":
1098			case "font-face-uri":
1099			case "font-face-format":
1100			case "font-face-name":
1101			case "missing-glyph": return !1;
1102			default: return !0;
1103		}
1104	}
1105	var aliases = new Map([
1106		["acceptCharset", "accept-charset"],
1107		["htmlFor", "for"],
1108		["httpEquiv", "http-equiv"],
1109		["crossOrigin", "crossorigin"],
1110		["accentHeight", "accent-height"],
1111		["alignmentBaseline", "alignment-baseline"],
1112		["arabicForm", "arabic-form"],
1113		["baselineShift", "baseline-shift"],
1114		["capHeight", "cap-height"],
1115		["clipPath", "clip-path"],
1116		["clipRule", "clip-rule"],
1117		["colorInterpolation", "color-interpolation"],
1118		["colorInterpolationFilters", "color-interpolation-filters"],
1119		["colorProfile", "color-profile"],
1120		["colorRendering", "color-rendering"],
1121		["dominantBaseline", "dominant-baseline"],
1122		["enableBackground", "enable-background"],
1123		["fillOpacity", "fill-opacity"],
1124		["fillRule", "fill-rule"],
1125		["floodColor", "flood-color"],
1126		["floodOpacity", "flood-opacity"],
1127		["fontFamily", "font-family"],
1128		["fontSize", "font-size"],
1129		["fontSizeAdjust", "font-size-adjust"],
1130		["fontStretch", "font-stretch"],
1131		["fontStyle", "font-style"],
1132		["fontVariant", "font-variant"],
1133		["fontWeight", "font-weight"],
1134		["glyphName", "glyph-name"],
1135		["glyphOrientationHorizontal", "glyph-orientation-horizontal"],
1136		["glyphOrientationVertical", "glyph-orientation-vertical"],
1137		["horizAdvX", "horiz-adv-x"],
1138		["horizOriginX", "horiz-origin-x"],
1139		["imageRendering", "image-rendering"],
1140		["letterSpacing", "letter-spacing"],
1141		["lightingColor", "lighting-color"],
1142		["markerEnd", "marker-end"],
1143		["markerMid", "marker-mid"],
1144		["markerStart", "marker-start"],
1145		["overlinePosition", "overline-position"],
1146		["overlineThickness", "overline-thickness"],
1147		["paintOrder", "paint-order"],
1148		["panose-1", "panose-1"],
1149		["pointerEvents", "pointer-events"],
1150		["renderingIntent", "rendering-intent"],
1151		["shapeRendering", "shape-rendering"],
1152		["stopColor", "stop-color"],
1153		["stopOpacity", "stop-opacity"],
1154		["strikethroughPosition", "strikethrough-position"],
1155		["strikethroughThickness", "strikethrough-thickness"],
1156		["strokeDasharray", "stroke-dasharray"],
1157		["strokeDashoffset", "stroke-dashoffset"],
1158		["strokeLinecap", "stroke-linecap"],
1159		["strokeLinejoin", "stroke-linejoin"],
1160		["strokeMiterlimit", "stroke-miterlimit"],
1161		["strokeOpacity", "stroke-opacity"],
1162		["strokeWidth", "stroke-width"],
1163		["textAnchor", "text-anchor"],
1164		["textDecoration", "text-decoration"],
1165		["textRendering", "text-rendering"],
1166		["transformOrigin", "transform-origin"],
1167		["underlinePosition", "underline-position"],
1168		["underlineThickness", "underline-thickness"],
1169		["unicodeBidi", "unicode-bidi"],
1170		["unicodeRange", "unicode-range"],
1171		["unitsPerEm", "units-per-em"],
1172		["vAlphabetic", "v-alphabetic"],
1173		["vHanging", "v-hanging"],
1174		["vIdeographic", "v-ideographic"],
1175		["vMathematical", "v-mathematical"],
1176		["vectorEffect", "vector-effect"],
1177		["vertAdvY", "vert-adv-y"],
1178		["vertOriginX", "vert-origin-x"],
1179		["vertOriginY", "vert-origin-y"],
1180		["wordSpacing", "word-spacing"],
1181		["writingMode", "writing-mode"],
1182		["xmlnsXlink", "xmlns:xlink"],
1183		["xHeight", "x-height"]
1184	]), isJavaScriptProtocol = /^[\u0000-\u001F ]*j[\r\n\t]*a[\r\n\t]*v[\r\n\t]*a[\r\n\t]*s[\r\n\t]*c[\r\n\t]*r[\r\n\t]*i[\r\n\t]*p[\r\n\t]*t[\r\n\t]*:/i;
1185	function sanitizeURL(url) {
1186		return isJavaScriptProtocol.test("" + url) ? "javascript:throw new Error('React has blocked a javascript: URL as a security precaution.')" : url;
1187	}
1188	function noop$1() {}
1189	var currentReplayingEvent = null;
1190	function getEventTarget(nativeEvent) {
1191		nativeEvent = nativeEvent.target || nativeEvent.srcElement || window;
1192		nativeEvent.correspondingUseElement && (nativeEvent = nativeEvent.correspondingUseElement);
1193		return 3 === nativeEvent.nodeType ? nativeEvent.parentNode : nativeEvent;
1194	}
1195	var restoreTarget = null, restoreQueue = null;
1196	function restoreStateOfTarget(target) {
1197		var internalInstance = getInstanceFromNode(target);
1198		if (internalInstance && (target = internalInstance.stateNode)) {
1199			var props = target[internalPropsKey] || null;
1200			a: switch (target = internalInstance.stateNode, internalInstance.type) {
1201				case "input":
1202					updateInput(target, props.value, props.defaultValue, props.defaultValue, props.checked, props.defaultChecked, props.type, props.name);
1203					internalInstance = props.name;
1204					if ("radio" === props.type && null != internalInstance) {
1205						for (props = target; props.parentNode;) props = props.parentNode;
1206						props = props.querySelectorAll("input[name=\"" + escapeSelectorAttributeValueInsideDoubleQuotes("" + internalInstance) + "\"][type=\"radio\"]");
1207						for (internalInstance = 0; internalInstance < props.length; internalInstance++) {
1208							var otherNode = props[internalInstance];
1209							if (otherNode !== target && otherNode.form === target.form) {
1210								var otherProps = otherNode[internalPropsKey] || null;
1211								if (!otherProps) throw Error(formatProdErrorMessage(90));
1212								updateInput(otherNode, otherProps.value, otherProps.defaultValue, otherProps.defaultValue, otherProps.checked, otherProps.defaultChecked, otherProps.type, otherProps.name);
1213							}
1214						}
1215						for (internalInstance = 0; internalInstance < props.length; internalInstance++) otherNode = props[internalInstance], otherNode.form === target.form && updateValueIfChanged(otherNode);
1216					}
1217					break a;
1218				case "textarea":
1219					updateTextarea(target, props.value, props.defaultValue);
1220					break a;
1221				case "select": internalInstance = props.value, null != internalInstance && updateOptions(target, !!props.multiple, internalInstance, !1);
1222			}
1223		}
1224	}
1225	var isInsideEventHandler = !1;
1226	function batchedUpdates$1(fn, a, b) {
1227		if (isInsideEventHandler) return fn(a, b);
1228		isInsideEventHandler = !0;
1229		try {
1230			return fn(a);
1231		} finally {
1232			if (isInsideEventHandler = !1, null !== restoreTarget || null !== restoreQueue) {
1233				if (flushSyncWork$1(), restoreTarget && (a = restoreTarget, fn = restoreQueue, restoreQueue = restoreTarget = null, restoreStateOfTarget(a), fn)) for (a = 0; a < fn.length; a++) restoreStateOfTarget(fn[a]);
1234			}
1235		}
1236	}
1237	function getListener(inst, registrationName) {
1238		var stateNode = inst.stateNode;
1239		if (null === stateNode) return null;
1240		var props = stateNode[internalPropsKey] || null;
1241		if (null === props) return null;
1242		stateNode = props[registrationName];
1243		a: switch (registrationName) {
1244			case "onClick":
1245			case "onClickCapture":
1246			case "onDoubleClick":
1247			case "onDoubleClickCapture":
1248			case "onMouseDown":
1249			case "onMouseDownCapture":
1250			case "onMouseMove":
1251			case "onMouseMoveCapture":
1252			case "onMouseUp":
1253			case "onMouseUpCapture":
1254			case "onMouseEnter":
1255				(props = !props.disabled) || (inst = inst.type, props = !("button" === inst || "input" === inst || "select" === inst || "textarea" === inst));
1256				inst = !props;
1257				break a;
1258			default: inst = !1;
1259		}
1260		if (inst) return null;
1261		if (stateNode && "function" !== typeof stateNode) throw Error(formatProdErrorMessage(231, registrationName, typeof stateNode));
1262		return stateNode;
1263	}
1264	var canUseDOM = !("undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement), passiveBrowserEventsSupported = !1;
1265	if (canUseDOM) try {
1266		var options = {};
1267		Object.defineProperty(options, "passive", { get: function() {
1268			passiveBrowserEventsSupported = !0;
1269		} });
1270		window.addEventListener("test", options, options);
1271		window.removeEventListener("test", options, options);
1272	} catch (e) {
1273		passiveBrowserEventsSupported = !1;
1274	}
1275	var root = null, startText = null, fallbackText = null;
1276	function getData() {
1277		if (fallbackText) return fallbackText;
1278		var start, startValue = startText, startLength = startValue.length, end, endValue = "value" in root ? root.value : root.textContent, endLength = endValue.length;
1279		for (start = 0; start < startLength && startValue[start] === endValue[start]; start++);
1280		var minEnd = startLength - start;
1281		for (end = 1; end <= minEnd && startValue[startLength - end] === endValue[endLength - end]; end++);
1282		return fallbackText = endValue.slice(start, 1 < end ? 1 - end : void 0);
1283	}
1284	function getEventCharCode(nativeEvent) {
1285		var keyCode = nativeEvent.keyCode;
1286		"charCode" in nativeEvent ? (nativeEvent = nativeEvent.charCode, 0 === nativeEvent && 13 === keyCode && (nativeEvent = 13)) : nativeEvent = keyCode;
1287		10 === nativeEvent && (nativeEvent = 13);
1288		return 32 <= nativeEvent || 13 === nativeEvent ? nativeEvent : 0;
1289	}
1290	function functionThatReturnsTrue() {
1291		return !0;
1292	}
1293	function functionThatReturnsFalse() {
1294		return !1;
1295	}
1296	function createSyntheticEvent(Interface) {
1297		function SyntheticBaseEvent(reactName, reactEventType, targetInst, nativeEvent, nativeEventTarget) {
1298			this._reactName = reactName;
1299			this._targetInst = targetInst;
1300			this.type = reactEventType;
1301			this.nativeEvent = nativeEvent;
1302			this.target = nativeEventTarget;
1303			this.currentTarget = null;
1304			for (var propName in Interface) Interface.hasOwnProperty(propName) && (reactName = Interface[propName], this[propName] = reactName ? reactName(nativeEvent) : nativeEvent[propName]);
1305			this.isDefaultPrevented = (null != nativeEvent.defaultPrevented ? nativeEvent.defaultPrevented : !1 === nativeEvent.returnValue) ? functionThatReturnsTrue : functionThatReturnsFalse;
1306			this.isPropagationStopped = functionThatReturnsFalse;
1307			return this;
1308		}
1309		assign(SyntheticBaseEvent.prototype, {
1310			preventDefault: function() {
1311				this.defaultPrevented = !0;
1312				var event = this.nativeEvent;
1313				event && (event.preventDefault ? event.preventDefault() : "unknown" !== typeof event.returnValue && (event.returnValue = !1), this.isDefaultPrevented = functionThatReturnsTrue);
1314			},
1315			stopPropagation: function() {
1316				var event = this.nativeEvent;
1317				event && (event.stopPropagation ? event.stopPropagation() : "unknown" !== typeof event.cancelBubble && (event.cancelBubble = !0), this.isPropagationStopped = functionThatReturnsTrue);
1318			},
1319			persist: function() {},
1320			isPersistent: functionThatReturnsTrue
1321		});
1322		return SyntheticBaseEvent;
1323	}
1324	var EventInterface = {
1325		eventPhase: 0,
1326		bubbles: 0,
1327		cancelable: 0,
1328		timeStamp: function(event) {
1329			return event.timeStamp || Date.now();
1330		},
1331		defaultPrevented: 0,
1332		isTrusted: 0
1333	}, SyntheticEvent = createSyntheticEvent(EventInterface), UIEventInterface = assign({}, EventInterface, {
1334		view: 0,
1335		detail: 0
1336	}), SyntheticUIEvent = createSyntheticEvent(UIEventInterface), lastMovementX, lastMovementY, lastMouseEvent, MouseEventInterface = assign({}, UIEventInterface, {
1337		screenX: 0,
1338		screenY: 0,
1339		clientX: 0,
1340		clientY: 0,
1341		pageX: 0,
1342		pageY: 0,
1343		ctrlKey: 0,
1344		shiftKey: 0,
1345		altKey: 0,
1346		metaKey: 0,
1347		getModifierState: getEventModifierState,
1348		button: 0,
1349		buttons: 0,
1350		relatedTarget: function(event) {
1351			return void 0 === event.relatedTarget ? event.fromElement === event.srcElement ? event.toElement : event.fromElement : event.relatedTarget;
1352		},
1353		movementX: function(event) {
1354			if ("movementX" in event) return event.movementX;
1355			event !== lastMouseEvent && (lastMouseEvent && "mousemove" === event.type ? (lastMovementX = event.screenX - lastMouseEvent.screenX, lastMovementY = event.screenY - lastMouseEvent.screenY) : lastMovementY = lastMovementX = 0, lastMouseEvent = event);
1356			return lastMovementX;
1357		},
1358		movementY: function(event) {
1359			return "movementY" in event ? event.movementY : lastMovementY;
1360		}
1361	}), SyntheticMouseEvent = createSyntheticEvent(MouseEventInterface), SyntheticDragEvent = createSyntheticEvent(assign({}, MouseEventInterface, { dataTransfer: 0 })), SyntheticFocusEvent = createSyntheticEvent(assign({}, UIEventInterface, { relatedTarget: 0 })), SyntheticAnimationEvent = createSyntheticEvent(assign({}, EventInterface, {
1362		animationName: 0,
1363		elapsedTime: 0,
1364		pseudoElement: 0
1365	})), SyntheticClipboardEvent = createSyntheticEvent(assign({}, EventInterface, { clipboardData: function(event) {
1366		return "clipboardData" in event ? event.clipboardData : window.clipboardData;
1367	} })), SyntheticCompositionEvent = createSyntheticEvent(assign({}, EventInterface, { data: 0 })), normalizeKey = {
1368		Esc: "Escape",
1369		Spacebar: " ",
1370		Left: "ArrowLeft",
1371		Up: "ArrowUp",
1372		Right: "ArrowRight",
1373		Down: "ArrowDown",
1374		Del: "Delete",
1375		Win: "OS",
1376		Menu: "ContextMenu",
1377		Apps: "ContextMenu",
1378		Scroll: "ScrollLock",
1379		MozPrintableKey: "Unidentified"
1380	}, translateToKey = {
1381		8: "Backspace",
1382		9: "Tab",
1383		12: "Clear",
1384		13: "Enter",
1385		16: "Shift",
1386		17: "Control",
1387		18: "Alt",
1388		19: "Pause",
1389		20: "CapsLock",
1390		27: "Escape",
1391		32: " ",
1392		33: "PageUp",
1393		34: "PageDown",
1394		35: "End",
1395		36: "Home",
1396		37: "ArrowLeft",
1397		38: "ArrowUp",
1398		39: "ArrowRight",
1399		40: "ArrowDown",
1400		45: "Insert",
1401		46: "Delete",
1402		112: "F1",
1403		113: "F2",
1404		114: "F3",
1405		115: "F4",
1406		116: "F5",
1407		117: "F6",
1408		118: "F7",
1409		119: "F8",
1410		120: "F9",
1411		121: "F10",
1412		122: "F11",
1413		123: "F12",
1414		144: "NumLock",
1415		145: "ScrollLock",
1416		224: "Meta"
1417	}, modifierKeyToProp = {
1418		Alt: "altKey",
1419		Control: "ctrlKey",
1420		Meta: "metaKey",
1421		Shift: "shiftKey"
1422	};
1423	function modifierStateGetter(keyArg) {
1424		var nativeEvent = this.nativeEvent;
1425		return nativeEvent.getModifierState ? nativeEvent.getModifierState(keyArg) : (keyArg = modifierKeyToProp[keyArg]) ? !!nativeEvent[keyArg] : !1;
1426	}
1427	function getEventModifierState() {
1428		return modifierStateGetter;
1429	}
1430	var SyntheticKeyboardEvent = createSyntheticEvent(assign({}, UIEventInterface, {
1431		key: function(nativeEvent) {
1432			if (nativeEvent.key) {
1433				var key = normalizeKey[nativeEvent.key] || nativeEvent.key;
1434				if ("Unidentified" !== key) return key;
1435			}
1436			return "keypress" === nativeEvent.type ? (nativeEvent = getEventCharCode(nativeEvent), 13 === nativeEvent ? "Enter" : String.fromCharCode(nativeEvent)) : "keydown" === nativeEvent.type || "keyup" === nativeEvent.type ? translateToKey[nativeEvent.keyCode] || "Unidentified" : "";
1437		},
1438		code: 0,
1439		location: 0,
1440		ctrlKey: 0,
1441		shiftKey: 0,
1442		altKey: 0,
1443		metaKey: 0,
1444		repeat: 0,
1445		locale: 0,
1446		getModifierState: getEventModifierState,
1447		charCode: function(event) {
1448			return "keypress" === event.type ? getEventCharCode(event) : 0;
1449		},
1450		keyCode: function(event) {
1451			return "keydown" === event.type || "keyup" === event.type ? event.keyCode : 0;
1452		},
1453		which: function(event) {
1454			return "keypress" === event.type ? getEventCharCode(event) : "keydown" === event.type || "keyup" === event.type ? event.keyCode : 0;
1455		}
1456	})), SyntheticPointerEvent = createSyntheticEvent(assign({}, MouseEventInterface, {
1457		pointerId: 0,
1458		width: 0,
1459		height: 0,
1460		pressure: 0,
1461		tangentialPressure: 0,
1462		tiltX: 0,
1463		tiltY: 0,
1464		twist: 0,
1465		pointerType: 0,
1466		isPrimary: 0
1467	})), SyntheticTouchEvent = createSyntheticEvent(assign({}, UIEventInterface, {
1468		touches: 0,
1469		targetTouches: 0,
1470		changedTouches: 0,
1471		altKey: 0,
1472		metaKey: 0,
1473		ctrlKey: 0,
1474		shiftKey: 0,
1475		getModifierState: getEventModifierState
1476	})), SyntheticTransitionEvent = createSyntheticEvent(assign({}, EventInterface, {
1477		propertyName: 0,
1478		elapsedTime: 0,
1479		pseudoElement: 0
1480	})), SyntheticWheelEvent = createSyntheticEvent(assign({}, MouseEventInterface, {
1481		deltaX: function(event) {
1482			return "deltaX" in event ? event.deltaX : "wheelDeltaX" in event ? -event.wheelDeltaX : 0;
1483		},
1484		deltaY: function(event) {
1485			return "deltaY" in event ? event.deltaY : "wheelDeltaY" in event ? -event.wheelDeltaY : "wheelDelta" in event ? -event.wheelDelta : 0;
1486		},
1487		deltaZ: 0,
1488		deltaMode: 0
1489	})), SyntheticToggleEvent = createSyntheticEvent(assign({}, EventInterface, {
1490		newState: 0,
1491		oldState: 0
1492	})), END_KEYCODES = [
1493		9,
1494		13,
1495		27,
1496		32
1497	], canUseCompositionEvent = canUseDOM && "CompositionEvent" in window, documentMode = null;
1498	canUseDOM && "documentMode" in document && (documentMode = document.documentMode);
1499	var canUseTextInputEvent = canUseDOM && "TextEvent" in window && !documentMode, useFallbackCompositionData = canUseDOM && (!canUseCompositionEvent || documentMode && 8 < documentMode && 11 >= documentMode), SPACEBAR_CHAR = String.fromCharCode(32), hasSpaceKeypress = !1;
1500	function isFallbackCompositionEnd(domEventName, nativeEvent) {
1501		switch (domEventName) {
1502			case "keyup": return -1 !== END_KEYCODES.indexOf(nativeEvent.keyCode);
1503			case "keydown": return 229 !== nativeEvent.keyCode;
1504			case "keypress":
1505			case "mousedown":
1506			case "focusout": return !0;
1507			default: return !1;
1508		}
1509	}
1510	function getDataFromCustomEvent(nativeEvent) {
1511		nativeEvent = nativeEvent.detail;
1512		return "object" === typeof nativeEvent && "data" in nativeEvent ? nativeEvent.data : null;
1513	}
1514	var isComposing = !1;
1515	function getNativeBeforeInputChars(domEventName, nativeEvent) {
1516		switch (domEventName) {
1517			case "compositionend": return getDataFromCustomEvent(nativeEvent);
1518			case "keypress":
1519				if (32 !== nativeEvent.which) return null;
1520				hasSpaceKeypress = !0;
1521				return SPACEBAR_CHAR;
1522			case "textInput": return domEventName = nativeEvent.data, domEventName === SPACEBAR_CHAR && hasSpaceKeypress ? null : domEventName;
1523			default: return null;
1524		}
1525	}
1526	function getFallbackBeforeInputChars(domEventName, nativeEvent) {
1527		if (isComposing) return "compositionend" === domEventName || !canUseCompositionEvent && isFallbackCompositionEnd(domEventName, nativeEvent) ? (domEventName = getData(), fallbackText = startText = root = null, isComposing = !1, domEventName) : null;
1528		switch (domEventName) {
1529			case "paste": return null;
1530			case "keypress":
1531				if (!(nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) || nativeEvent.ctrlKey && nativeEvent.altKey) {
1532					if (nativeEvent.char && 1 < nativeEvent.char.length) return nativeEvent.char;
1533					if (nativeEvent.which) return String.fromCharCode(nativeEvent.which);
1534				}
1535				return null;
1536			case "compositionend": return useFallbackCompositionData && "ko" !== nativeEvent.locale ? null : nativeEvent.data;
1537			default: return null;
1538		}
1539	}
1540	var supportedInputTypes = {
1541		color: !0,
1542		date: !0,
1543		datetime: !0,
1544		"datetime-local": !0,
1545		email: !0,
1546		month: !0,
1547		number: !0,
1548		password: !0,
1549		range: !0,
1550		search: !0,
1551		tel: !0,
1552		text: !0,
1553		time: !0,
1554		url: !0,
1555		week: !0
1556	};
1557	function isTextInputElement(elem) {
1558		var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
1559		return "input" === nodeName ? !!supportedInputTypes[elem.type] : "textarea" === nodeName ? !0 : !1;
1560	}

1561	function createAndAccumulateChangeEvent(dispatchQueue, inst, nativeEvent, target) {
1562		restoreTarget ? restoreQueue ? restoreQueue.push(target) : restoreQueue = [target] : restoreTarget = target;
1563		inst = accumulateTwoPhaseListeners(inst, "onChange");
1564		0 < inst.length && (nativeEvent = new SyntheticEvent("onChange", "change", null, nativeEvent, target), dispatchQueue.push({
1565			event: nativeEvent,
1566			listeners: inst
1567		}));
1568	}
1569	var activeElement$1 = null, activeElementInst$1 = null;
1570	function runEventInBatch(dispatchQueue) {
1571		processDispatchQueue(dispatchQueue, 0);
1572	}
1573	function getInstIfValueChanged(targetInst) {
1574		if (updateValueIfChanged(getNodeFromInstance(targetInst))) return targetInst;
1575	}
1576	function getTargetInstForChangeEvent(domEventName, targetInst) {
1577		if ("change" === domEventName) return targetInst;
1578	}
1579	var isInputEventSupported = !1;
1580	if (canUseDOM) {
1581		var JSCompiler_inline_result$jscomp$286;
1582		if (canUseDOM) {
1583			var isSupported$jscomp$inline_427 = "oninput" in document;
1584			if (!isSupported$jscomp$inline_427) {
1585				var element$jscomp$inline_428 = document.createElement("div");
1586				element$jscomp$inline_428.setAttribute("oninput", "return;");
1587				isSupported$jscomp$inline_427 = "function" === typeof element$jscomp$inline_428.oninput;
1588			}
1589			JSCompiler_inline_result$jscomp$286 = isSupported$jscomp$inline_427;
1590		} else JSCompiler_inline_result$jscomp$286 = !1;
1591		isInputEventSupported = JSCompiler_inline_result$jscomp$286 && (!document.documentMode || 9 < document.documentMode);
1592	}
1593	function stopWatchingForValueChange() {
1594		activeElement$1 && (activeElement$1.detachEvent("onpropertychange", handlePropertyChange), activeElementInst$1 = activeElement$1 = null);
1595	}
1596	function handlePropertyChange(nativeEvent) {
1597		if ("value" === nativeEvent.propertyName && getInstIfValueChanged(activeElementInst$1)) {
1598			var dispatchQueue = [];
1599			createAndAccumulateChangeEvent(dispatchQueue, activeElementInst$1, nativeEvent, getEventTarget(nativeEvent));
1600			batchedUpdates$1(runEventInBatch, dispatchQueue);
1601		}
1602	}
1603	function handleEventsForInputEventPolyfill(domEventName, target, targetInst) {
1604		"focusin" === domEventName ? (stopWatchingForValueChange(), activeElement$1 = target, activeElementInst$1 = targetInst, activeElement$1.attachEvent("onpropertychange", handlePropertyChange)) : "focusout" === domEventName && stopWatchingForValueChange();
1605	}
1606	function getTargetInstForInputEventPolyfill(domEventName) {
1607		if ("selectionchange" === domEventName || "keyup" === domEventName || "keydown" === domEventName) return getInstIfValueChanged(activeElementInst$1);
1608	}
1609	function getTargetInstForClickEvent(domEventName, targetInst) {
1610		if ("click" === domEventName) return getInstIfValueChanged(targetInst);
1611	}
1612	function getTargetInstForInputOrChangeEvent(domEventName, targetInst) {
1613		if ("input" === domEventName || "change" === domEventName) return getInstIfValueChanged(targetInst);
1614	}
1615	function is(x, y) {
1616		return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
1617	}
1618	var objectIs = "function" === typeof Object.is ? Object.is : is;
1619	function shallowEqual(objA, objB) {
1620		if (objectIs(objA, objB)) return !0;
1621		if ("object" !== typeof objA || null === objA || "object" !== typeof objB || null === objB) return !1;
1622		var keysA = Object.keys(objA), keysB = Object.keys(objB);
1623		if (keysA.length !== keysB.length) return !1;
1624		for (keysB = 0; keysB < keysA.length; keysB++) {
1625			var currentKey = keysA[keysB];
1626			if (!hasOwnProperty.call(objB, currentKey) || !objectIs(objA[currentKey], objB[currentKey])) return !1;
1627		}
1628		return !0;
1629	}
1630	function getLeafNode(node) {
1631		for (; node && node.firstChild;) node = node.firstChild;
1632		return node;
1633	}
1634	function getNodeForCharacterOffset(root, offset) {
1635		var node = getLeafNode(root);
1636		root = 0;
1637		for (var nodeEnd; node;) {
1638			if (3 === node.nodeType) {
1639				nodeEnd = root + node.textContent.length;
1640				if (root <= offset && nodeEnd >= offset) return {
1641					node,
1642					offset: offset - root
1643				};
1644				root = nodeEnd;
1645			}
1646			a: {
1647				for (; node;) {
1648					if (node.nextSibling) {
1649						node = node.nextSibling;
1650						break a;
1651					}
1652					node = node.parentNode;
1653				}
1654				node = void 0;
1655			}
1656			node = getLeafNode(node);
1657		}
1658	}

1659	function containsNode(outerNode, innerNode) {
1660		return outerNode && innerNode ? outerNode === innerNode ? !0 : outerNode && 3 === outerNode.nodeType ? !1 : innerNode && 3 === innerNode.nodeType ? containsNode(outerNode, innerNode.parentNode) : "contains" in outerNode ? outerNode.contains(innerNode) : outerNode.compareDocumentPosition ? !!(outerNode.compareDocumentPosition(innerNode) & 16) : !1 : !1;
1661	}
1662	function getActiveElementDeep(containerInfo) {
1663		containerInfo = null != containerInfo && null != containerInfo.ownerDocument && null != containerInfo.ownerDocument.defaultView ? containerInfo.ownerDocument.defaultView : window;
1664		for (var element = getActiveElement(containerInfo.document); element instanceof containerInfo.HTMLIFrameElement;) {
1665			try {
1666				var JSCompiler_inline_result = "string" === typeof element.contentWindow.location.href;
1667			} catch (err) {
1668				JSCompiler_inline_result = !1;
1669			}
1670			if (JSCompiler_inline_result) containerInfo = element.contentWindow;
1671			else break;
1672			element = getActiveElement(containerInfo.document);
1673		}
1674		return element;
1675	}
1676	function hasSelectionCapabilities(elem) {
1677		var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
1678		return nodeName && ("input" === nodeName && ("text" === elem.type || "search" === elem.type || "tel" === elem.type || "url" === elem.type || "password" === elem.type) || "textarea" === nodeName || "true" === elem.contentEditable);
1679	}
1680	var skipSelectionChangeEvent = canUseDOM && "documentMode" in document && 11 >= document.documentMode, activeElement = null, activeElementInst = null, lastSelection = null, mouseDown = !1;
1681	function constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget) {
1682		var doc = nativeEventTarget.window === nativeEventTarget ? nativeEventTarget.document : 9 === nativeEventTarget.nodeType ? nativeEventTarget : nativeEventTarget.ownerDocument;
1683		mouseDown || null == activeElement || activeElement !== getActiveElement(doc) || (doc = activeElement, "selectionStart" in doc && hasSelectionCapabilities(doc) ? doc = {
1684			start: doc.selectionStart,
1685			end: doc.selectionEnd
1686		} : (doc = (doc.ownerDocument && doc.ownerDocument.defaultView || window).getSelection(), doc = {
1687			anchorNode: doc.anchorNode,
1688			anchorOffset: doc.anchorOffset,
1689			focusNode: doc.focusNode,
1690			focusOffset: doc.focusOffset
1691		}), lastSelection && shallowEqual(lastSelection, doc) || (lastSelection = doc, doc = accumulateTwoPhaseListeners(activeElementInst, "onSelect"), 0 < doc.length && (nativeEvent = new SyntheticEvent("onSelect", "select", null, nativeEvent, nativeEventTarget), dispatchQueue.push({
1692			event: nativeEvent,
1693			listeners: doc
1694		}), nativeEvent.target = activeElement)));
1695	}
1696	function makePrefixMap(styleProp, eventName) {
1697		var prefixes = {};
1698		prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();
1699		prefixes["Webkit" + styleProp] = "webkit" + eventName;
1700		prefixes["Moz" + styleProp] = "moz" + eventName;
1701		return prefixes;
1702	}
1703	var vendorPrefixes = {
1704		animationend: makePrefixMap("Animation", "AnimationEnd"),
1705		animationiteration: makePrefixMap("Animation", "AnimationIteration"),
1706		animationstart: makePrefixMap("Animation", "AnimationStart"),
1707		transitionrun: makePrefixMap("Transition", "TransitionRun"),
1708		transitionstart: makePrefixMap("Transition", "TransitionStart"),
1709		transitioncancel: makePrefixMap("Transition", "TransitionCancel"),
1710		transitionend: makePrefixMap("Transition", "TransitionEnd")
1711	}, prefixedEventNames = {}, style = {};
1712	canUseDOM && (style = document.createElement("div").style, "AnimationEvent" in window || (delete vendorPrefixes.animationend.animation, delete vendorPrefixes.animationiteration.animation, delete vendorPrefixes.animationstart.animation), "TransitionEvent" in window || delete vendorPrefixes.transitionend.transition);
1713	function getVendorPrefixedEventName(eventName) {
1714		if (prefixedEventNames[eventName]) return prefixedEventNames[eventName];
1715		if (!vendorPrefixes[eventName]) return eventName;
1716		var prefixMap = vendorPrefixes[eventName], styleProp;
1717		for (styleProp in prefixMap) if (prefixMap.hasOwnProperty(styleProp) && styleProp in style) return prefixedEventNames[eventName] = prefixMap[styleProp];
1718		return eventName;
1719	}
1720	var ANIMATION_END = getVendorPrefixedEventName("animationend"), ANIMATION_ITERATION = getVendorPrefixedEventName("animationiteration"), ANIMATION_START = getVendorPrefixedEventName("animationstart"), TRANSITION_RUN = getVendorPrefixedEventName("transitionrun"), TRANSITION_START = getVendorPrefixedEventName("transitionstart"), TRANSITION_CANCEL = getVendorPrefixedEventName("transitioncancel"), TRANSITION_END = getVendorPrefixedEventName("transitionend"), topLevelEventsToReactNames = /* @__PURE__ */ new Map(), simpleEventPluginEvents = "abort auxClick beforeToggle cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel".split(" ");
1721	simpleEventPluginEvents.push("scrollEnd");
1722	function registerSimpleEvent(domEventName, reactName) {
1723		topLevelEventsToReactNames.set(domEventName, reactName);
1724		registerTwoPhaseEvent(reactName, [domEventName]);
1725	}
1726	var reportGlobalError = "function" === typeof reportError ? reportError : function(error) {
1727		if ("object" === typeof window && "function" === typeof window.ErrorEvent) {
1728			var event = new window.ErrorEvent("error", {
1729				bubbles: !0,
1730				cancelable: !0,
1731				message: "object" === typeof error && null !== error && "string" === typeof error.message ? String(error.message) : String(error),
1732				error
1733			});
1734			if (!window.dispatchEvent(event)) return;
1735		} else if ("object" === typeof process && "function" === typeof process.emit) {
1736			process.emit("uncaughtException", error);
1737			return;
1738		}
1739		console.error(error);
1740	}, concurrentQueues = [], concurrentQueuesIndex = 0, concurrentlyUpdatedLanes = 0;
1741	function finishQueueingConcurrentUpdates() {
1742		for (var endIndex = concurrentQueuesIndex, i = concurrentlyUpdatedLanes = concurrentQueuesIndex = 0; i < endIndex;) {
1743			var fiber = concurrentQueues[i];
1744			concurrentQueues[i++] = null;
1745			var queue = concurrentQueues[i];
1746			concurrentQueues[i++] = null;
1747			var update = concurrentQueues[i];
1748			concurrentQueues[i++] = null;
1749			var lane = concurrentQueues[i];
1750			concurrentQueues[i++] = null;
1751			if (null !== queue && null !== update) {
1752				var pending = queue.pending;
1753				null === pending ? update.next = update : (update.next = pending.next, pending.next = update);
1754				queue.pending = update;
1755			}
1756			0 !== lane && markUpdateLaneFromFiberToRoot(fiber, update, lane);
1757		}
1758	}
1759	function enqueueUpdate$1(fiber, queue, update, lane) {
1760		concurrentQueues[concurrentQueuesIndex++] = fiber;
1761		concurrentQueues[concurrentQueuesIndex++] = queue;
1762		concurrentQueues[concurrentQueuesIndex++] = update;
1763		concurrentQueues[concurrentQueuesIndex++] = lane;
1764		concurrentlyUpdatedLanes |= lane;
1765		fiber.lanes |= lane;
1766		fiber = fiber.alternate;
1767		null !== fiber && (fiber.lanes |= lane);
1768	}
1769	function enqueueConcurrentHookUpdate(fiber, queue, update, lane) {
1770		enqueueUpdate$1(fiber, queue, update, lane);
1771		return getRootForUpdatedFiber(fiber);
1772	}
1773	function enqueueConcurrentRenderForLane(fiber, lane) {
1774		enqueueUpdate$1(fiber, null, null, lane);
1775		return getRootForUpdatedFiber(fiber);
1776	}
1777	function markUpdateLaneFromFiberToRoot(sourceFiber, update, lane) {
1778		sourceFiber.lanes |= lane;
1779		var alternate = sourceFiber.alternate;
1780		null !== alternate && (alternate.lanes |= lane);
1781		for (var isHidden = !1, parent = sourceFiber.return; null !== parent;) parent.childLanes |= lane, alternate = parent.alternate, null !== alternate && (alternate.childLanes |= lane), 22 === parent.tag && (sourceFiber = parent.stateNode, null === sourceFiber || sourceFiber._visibility & 1 || (isHidden = !0)), sourceFiber = parent, parent = parent.return;
1782		return 3 === sourceFiber.tag ? (parent = sourceFiber.stateNode, isHidden && null !== update && (isHidden = 31 - clz32(lane), sourceFiber = parent.hiddenUpdates, alternate = sourceFiber[isHidden], null === alternate ? sourceFiber[isHidden] = [update] : alternate.push(update), update.lane = lane | 536870912), parent) : null;
1783	}
1784	function getRootForUpdatedFiber(sourceFiber) {
1785		if (50 < nestedUpdateCount) throw nestedUpdateCount = 0, rootWithNestedUpdates = null, Error(formatProdErrorMessage(185));
1786		for (var parent = sourceFiber.return; null !== parent;) sourceFiber = parent, parent = sourceFiber.return;
1787		return 3 === sourceFiber.tag ? sourceFiber.stateNode : null;
1788	}
1789	var emptyContextObject = {};
1790	function FiberNode(tag, pendingProps, key, mode) {
1791		this.tag = tag;
1792		this.key = key;
1793		this.sibling = this.child = this.return = this.stateNode = this.type = this.elementType = null;
1794		this.index = 0;
1795		this.refCleanup = this.ref = null;
1796		this.pendingProps = pendingProps;
1797		this.dependencies = this.memoizedState = this.updateQueue = this.memoizedProps = null;
1798		this.mode = mode;
1799		this.subtreeFlags = this.flags = 0;
1800		this.deletions = null;
1801		this.childLanes = this.lanes = 0;
1802		this.alternate = null;
1803	}
1804	function createFiberImplClass(tag, pendingProps, key, mode) {
1805		return new FiberNode(tag, pendingProps, key, mode);
1806	}
1807	function shouldConstruct(Component) {
1808		Component = Component.prototype;
1809		return !(!Component || !Component.isReactComponent);
1810	}
1811	function createWorkInProgress(current, pendingProps) {
1812		var workInProgress = current.alternate;
1813		null === workInProgress ? (workInProgress = createFiberImplClass(current.tag, pendingProps, current.key, current.mode), workInProgress.elementType = current.elementType, workInProgress.type = current.type, workInProgress.stateNode = current.stateNode, workInProgress.alternate = current, current.alternate = workInProgress) : (workInProgress.pendingProps = pendingProps, workInProgress.type = current.type, workInProgress.flags = 0, workInProgress.subtreeFlags = 0, workInProgress.deletions = null);
1814		workInProgress.flags = current.flags & 65011712;
1815		workInProgress.childLanes = current.childLanes;
1816		workInProgress.lanes = current.lanes;
1817		workInProgress.child = current.child;
1818		workInProgress.memoizedProps = current.memoizedProps;
1819		workInProgress.memoizedState = current.memoizedState;
1820		workInProgress.updateQueue = current.updateQueue;
1821		pendingProps = current.dependencies;
1822		workInProgress.dependencies = null === pendingProps ? null : {
1823			lanes: pendingProps.lanes,
1824			firstContext: pendingProps.firstContext
1825		};
1826		workInProgress.sibling = current.sibling;
1827		workInProgress.index = current.index;
1828		workInProgress.ref = current.ref;
1829		workInProgress.refCleanup = current.refCleanup;
1830		return workInProgress;
1831	}
1832	function resetWorkInProgress(workInProgress, renderLanes) {
1833		workInProgress.flags &= 65011714;
1834		var current = workInProgress.alternate;
1835		null === current ? (workInProgress.childLanes = 0, workInProgress.lanes = renderLanes, workInProgress.child = null, workInProgress.subtreeFlags = 0, workInProgress.memoizedProps = null, workInProgress.memoizedState = null, workInProgress.updateQueue = null, workInProgress.dependencies = null, workInProgress.stateNode = null) : (workInProgress.childLanes = current.childLanes, workInProgress.lanes = current.lanes, workInProgress.child = current.child, workInProgress.subtreeFlags = 0, workInProgress.deletions = null, workInProgress.memoizedProps = current.memoizedProps, workInProgress.memoizedState = current.memoizedState, workInProgress.updateQueue = current.updateQueue, workInProgress.type = current.type, renderLanes = current.dependencies, workInProgress.dependencies = null === renderLanes ? null : {
1836			lanes: renderLanes.lanes,
1837			firstContext: renderLanes.firstContext
1838		});
1839		return workInProgress;
1840	}
1841	function createFiberFromTypeAndProps(type, key, pendingProps, owner, mode, lanes) {
1842		var fiberTag = 0;
1843		owner = type;
1844		if ("function" === typeof type) shouldConstruct(type) && (fiberTag = 1);
1845		else if ("string" === typeof type) fiberTag = isHostHoistableType(type, pendingProps, contextStackCursor.current) ? 26 : "html" === type || "head" === type || "body" === type ? 27 : 5;
1846		else a: switch (type) {
1847			case REACT_ACTIVITY_TYPE: return type = createFiberImplClass(31, pendingProps, key, mode), type.elementType = REACT_ACTIVITY_TYPE, type.lanes = lanes, type;
1848			case REACT_FRAGMENT_TYPE: return createFiberFromFragment(pendingProps.children, mode, lanes, key);
1849			case REACT_STRICT_MODE_TYPE:
1850				fiberTag = 8;
1851				mode |= 24;
1852				break;
1853			case REACT_PROFILER_TYPE: return type = createFiberImplClass(12, pendingProps, key, mode | 2), type.elementType = REACT_PROFILER_TYPE, type.lanes = lanes, type;
1854			case REACT_SUSPENSE_TYPE: return type = createFiberImplClass(13, pendingProps, key, mode), type.elementType = REACT_SUSPENSE_TYPE, type.lanes = lanes, type;
1855			case REACT_SUSPENSE_LIST_TYPE: return type = createFiberImplClass(19, pendingProps, key, mode), type.elementType = REACT_SUSPENSE_LIST_TYPE, type.lanes = lanes, type;
1856			default:
1857				if ("object" === typeof type && null !== type) switch (type.$$typeof) {
1858					case REACT_CONTEXT_TYPE:
1859						fiberTag = 10;
1860						break a;
1861					case REACT_CONSUMER_TYPE:
1862						fiberTag = 9;
1863						break a;
1864					case REACT_FORWARD_REF_TYPE:
1865						fiberTag = 11;
1866						break a;
1867					case REACT_MEMO_TYPE:
1868						fiberTag = 14;
1869						break a;
1870					case REACT_LAZY_TYPE:
1871						fiberTag = 16;
1872						owner = null;
1873						break a;
1874				}
1875				fiberTag = 29;
1876				pendingProps = Error(formatProdErrorMessage(130, null === type ? "null" : typeof type, ""));
1877				owner = null;
1878		}
1879		key = createFiberImplClass(fiberTag, pendingProps, key, mode);
1880		key.elementType = type;
1881		key.type = owner;
1882		key.lanes = lanes;
1883		return key;
1884	}
1885	function createFiberFromFragment(elements, mode, lanes, key) {
1886		elements = createFiberImplClass(7, elements, key, mode);
1887		elements.lanes = lanes;
1888		return elements;
1889	}
1890	function createFiberFromText(content, mode, lanes) {
1891		content = createFiberImplClass(6, content, null, mode);
1892		content.lanes = lanes;
1893		return content;
1894	}
1895	function createFiberFromDehydratedFragment(dehydratedNode) {
1896		var fiber = createFiberImplClass(18, null, null, 0);
1897		fiber.stateNode = dehydratedNode;
1898		return fiber;
1899	}
1900	function createFiberFromPortal(portal, mode, lanes) {
1901		mode = createFiberImplClass(4, null !== portal.children ? portal.children : [], portal.key, mode);
1902		mode.lanes = lanes;
1903		mode.stateNode = {
1904			containerInfo: portal.containerInfo,
1905			pendingChildren: null,
1906			implementation: portal.implementation
1907		};
1908		return mode;
1909	}
1910	var CapturedStacks = /* @__PURE__ */ new WeakMap();
1911	function createCapturedValueAtFiber(value, source) {
1912		if ("object" === typeof value && null !== value) {
1913			var existing = CapturedStacks.get(value);
1914			if (void 0 !== existing) return existing;
1915			source = {
1916				value,
1917				source,
1918				stack: getStackByFiberInDevAndProd(source)
1919			};
1920			CapturedStacks.set(value, source);
1921			return source;
1922		}
1923		return {
1924			value,
1925			source,
1926			stack: getStackByFiberInDevAndProd(source)
1927		};
1928	}
1929	var forkStack = [], forkStackIndex = 0, treeForkProvider = null, treeForkCount = 0, idStack = [], idStackIndex = 0, treeContextProvider = null, treeContextId = 1, treeContextOverflow = "";
1930	function pushTreeFork(workInProgress, totalChildren) {
1931		forkStack[forkStackIndex++] = treeForkCount;
1932		forkStack[forkStackIndex++] = treeForkProvider;
1933		treeForkProvider = workInProgress;
1934		treeForkCount = totalChildren;
1935	}
1936	function pushTreeId(workInProgress, totalChildren, index) {
1937		idStack[idStackIndex++] = treeContextId;
1938		idStack[idStackIndex++] = treeContextOverflow;
1939		idStack[idStackIndex++] = treeContextProvider;
1940		treeContextProvider = workInProgress;
1941		var baseIdWithLeadingBit = treeContextId;
1942		workInProgress = treeContextOverflow;
1943		var baseLength = 32 - clz32(baseIdWithLeadingBit) - 1;
1944		baseIdWithLeadingBit &= ~(1 << baseLength);
1945		index += 1;
1946		var length = 32 - clz32(totalChildren) + baseLength;
1947		if (30 < length) {
1948			var numberOfOverflowBits = baseLength - baseLength % 5;
1949			length = (baseIdWithLeadingBit & (1 << numberOfOverflowBits) - 1).toString(32);
1950			baseIdWithLeadingBit >>= numberOfOverflowBits;
1951			baseLength -= numberOfOverflowBits;
1952			treeContextId = 1 << 32 - clz32(totalChildren) + baseLength | index << baseLength | baseIdWithLeadingBit;
1953			treeContextOverflow = length + workInProgress;
1954		} else treeContextId = 1 << length | index << baseLength | baseIdWithLeadingBit, treeContextOverflow = workInProgress;
1955	}
1956	function pushMaterializedTreeId(workInProgress) {
1957		null !== workInProgress.return && (pushTreeFork(workInProgress, 1), pushTreeId(workInProgress, 1, 0));
1958	}
1959	function popTreeContext(workInProgress) {
1960		for (; workInProgress === treeForkProvider;) treeForkProvider = forkStack[--forkStackIndex], forkStack[forkStackIndex] = null, treeForkCount = forkStack[--forkStackIndex], forkStack[forkStackIndex] = null;
1961		for (; workInProgress === treeContextProvider;) treeContextProvider = idStack[--idStackIndex], idStack[idStackIndex] = null, treeContextOverflow = idStack[--idStackIndex], idStack[idStackIndex] = null, treeContextId = idStack[--idStackIndex], idStack[idStackIndex] = null;
1962	}
1963	function restoreSuspendedTreeContext(workInProgress, suspendedContext) {
1964		idStack[idStackIndex++] = treeContextId;
1965		idStack[idStackIndex++] = treeContextOverflow;
1966		idStack[idStackIndex++] = treeContextProvider;
1967		treeContextId = suspendedContext.id;
1968		treeContextOverflow = suspendedContext.overflow;
1969		treeContextProvider = workInProgress;
1970	}
1971	var hydrationParentFiber = null, nextHydratableInstance = null, isHydrating = !1, hydrationErrors = null, rootOrSingletonContext = !1, HydrationMismatchException = Error(formatProdErrorMessage(519));
1972	function throwOnHydrationMismatch(fiber) {
1973		queueHydrationError(createCapturedValueAtFiber(Error(formatProdErrorMessage(418, 1 < arguments.length && void 0 !== arguments[1] && arguments[1] ? "text" : "HTML", "")), fiber));
1974		throw HydrationMismatchException;
1975	}
1976	function prepareToHydrateHostInstance(fiber) {
1977		var instance = fiber.stateNode, type = fiber.type, props = fiber.memoizedProps;
1978		instance[internalInstanceKey] = fiber;
1979		instance[internalPropsKey] = props;
1980		switch (type) {
1981			case "dialog":
1982				listenToNonDelegatedEvent("cancel", instance);
1983				listenToNonDelegatedEvent("close", instance);
1984				break;
1985			case "iframe":
1986			case "object":
1987			case "embed":
1988				listenToNonDelegatedEvent("load", instance);
1989				break;
1990			case "video":
1991			case "audio":
1992				for (type = 0; type < mediaEventTypes.length; type++) listenToNonDelegatedEvent(mediaEventTypes[type], instance);
1993				break;
1994			case "source":
1995				listenToNonDelegatedEvent("error", instance);
1996				break;
1997			case "img":
1998			case "image":
1999			case "link":
2000				listenToNonDelegatedEvent("error", instance);
2001				listenToNonDelegatedEvent("load", instance);
2002				break;
2003			case "details":
2004				listenToNonDelegatedEvent("toggle", instance);
2005				break;
2006			case "input":
2007				listenToNonDelegatedEvent("invalid", instance);
2008				initInput(instance, props.value, props.defaultValue, props.checked, props.defaultChecked, props.type, props.name, !0);
2009				break;
2010			case "select":
2011				listenToNonDelegatedEvent("invalid", instance);
2012				break;
2013			case "textarea": listenToNonDelegatedEvent("invalid", instance), initTextarea(instance, props.value, props.defaultValue, props.children);
2014		}
2015		type = props.children;
2016		"string" !== typeof type && "number" !== typeof type && "bigint" !== typeof type || instance.textContent === "" + type || !0 === props.suppressHydrationWarning || checkForUnmatchedText(instance.textContent, type) ? (null != props.popover && (listenToNonDelegatedEvent("beforetoggle", instance), listenToNonDelegatedEvent("toggle", instance)), null != props.onScroll && listenToNonDelegatedEvent("scroll", instance), null != props.onScrollEnd && listenToNonDelegatedEvent("scrollend", instance), null != props.onClick && (instance.onclick = noop$1), instance = !0) : instance = !1;
2017		instance || throwOnHydrationMismatch(fiber, !0);
2018	}
2019	function popToNextHostParent(fiber) {
2020		for (hydrationParentFiber = fiber.return; hydrationParentFiber;) switch (hydrationParentFiber.tag) {
2021			case 5:
2022			case 31:
2023			case 13:
2024				rootOrSingletonContext = !1;
2025				return;
2026			case 27:
2027			case 3:
2028				rootOrSingletonContext = !0;
2029				return;
2030			default: hydrationParentFiber = hydrationParentFiber.return;
2031		}
2032	}
2033	function popHydrationState(fiber) {
2034		if (fiber !== hydrationParentFiber) return !1;
2035		if (!isHydrating) return popToNextHostParent(fiber), isHydrating = !0, !1;
2036		var tag = fiber.tag, JSCompiler_temp;
2037		if (JSCompiler_temp = 3 !== tag && 27 !== tag) {
2038			if (JSCompiler_temp = 5 === tag) JSCompiler_temp = fiber.type, JSCompiler_temp = !("form" !== JSCompiler_temp && "button" !== JSCompiler_temp) || shouldSetTextContent(fiber.type, fiber.memoizedProps);
2039			JSCompiler_temp = !JSCompiler_temp;
2040		}
2041		JSCompiler_temp && nextHydratableInstance && throwOnHydrationMismatch(fiber);
2042		popToNextHostParent(fiber);
2043		if (13 === tag) {
2044			fiber = fiber.memoizedState;
2045			fiber = null !== fiber ? fiber.dehydrated : null;
2046			if (!fiber) throw Error(formatProdErrorMessage(317));
2047			nextHydratableInstance = getNextHydratableInstanceAfterHydrationBoundary(fiber);
2048		} else if (31 === tag) {
2049			fiber = fiber.memoizedState;
2050			fiber = null !== fiber ? fiber.dehydrated : null;
2051			if (!fiber) throw Error(formatProdErrorMessage(317));
2052			nextHydratableInstance = getNextHydratableInstanceAfterHydrationBoundary(fiber);
2053		} else 27 === tag ? (tag = nextHydratableInstance, isSingletonScope(fiber.type) ? (fiber = previousHydratableOnEnteringScopedSingleton, previousHydratableOnEnteringScopedSingleton = null, nextHydratableInstance = fiber) : nextHydratableInstance = tag) : nextHydratableInstance = hydrationParentFiber ? getNextHydratable(fiber.stateNode.nextSibling) : null;
2054		return !0;
2055	}
2056	function resetHydrationState() {
2057		nextHydratableInstance = hydrationParentFiber = null;
2058		isHydrating = !1;
2059	}
2060	function upgradeHydrationErrorsToRecoverable() {
2061		var queuedErrors = hydrationErrors;
2062		null !== queuedErrors && (null === workInProgressRootRecoverableErrors ? workInProgressRootRecoverableErrors = queuedErrors : workInProgressRootRecoverableErrors.push.apply(workInProgressRootRecoverableErrors, queuedErrors), hydrationErrors = null);
2063		return queuedErrors;
2064	}
2065	function queueHydrationError(error) {
2066		null === hydrationErrors ? hydrationErrors = [error] : hydrationErrors.push(error);
2067	}
2068	var valueCursor = createCursor(null), currentlyRenderingFiber$1 = null, lastContextDependency = null;
2069	function pushProvider(providerFiber, context, nextValue) {
2070		push(valueCursor, context._currentValue);
2071		context._currentValue = nextValue;
2072	}
2073	function popProvider(context) {
2074		context._currentValue = valueCursor.current;
2075		pop(valueCursor);
2076	}
2077	function scheduleContextWorkOnParentPath(parent, renderLanes, propagationRoot) {
2078		for (; null !== parent;) {
2079			var alternate = parent.alternate;
2080			(parent.childLanes & renderLanes) !== renderLanes ? (parent.childLanes |= renderLanes, null !== alternate && (alternate.childLanes |= renderLanes)) : null !== alternate && (alternate.childLanes & renderLanes) !== renderLanes && (alternate.childLanes |= renderLanes);
2081			if (parent === propagationRoot) break;
2082			parent = parent.return;
2083		}
2084	}
2085	function propagateContextChanges(workInProgress, contexts, renderLanes, forcePropagateEntireTree) {
2086		var fiber = workInProgress.child;
2087		null !== fiber && (fiber.return = workInProgress);
2088		for (; null !== fiber;) {
2089			var list = fiber.dependencies;
2090			if (null !== list) {
2091				var nextFiber = fiber.child;
2092				list = list.firstContext;
2093				a: for (; null !== list;) {
2094					var dependency = list;
2095					list = fiber;
2096					for (var i = 0; i < contexts.length; i++) if (dependency.context === contexts[i]) {
2097						list.lanes |= renderLanes;
2098						dependency = list.alternate;
2099						null !== dependency && (dependency.lanes |= renderLanes);
2100						scheduleContextWorkOnParentPath(list.return, renderLanes, workInProgress);
2101						forcePropagateEntireTree || (nextFiber = null);
2102						break a;
2103					}
2104					list = dependency.next;
2105				}
2106			} else if (18 === fiber.tag) {
2107				nextFiber = fiber.return;
2108				if (null === nextFiber) throw Error(formatProdErrorMessage(341));
2109				nextFiber.lanes |= renderLanes;
2110				list = nextFiber.alternate;
2111				null !== list && (list.lanes |= renderLanes);
2112				scheduleContextWorkOnParentPath(nextFiber, renderLanes, workInProgress);
2113				nextFiber = null;
2114			} else nextFiber = fiber.child;
2115			if (null !== nextFiber) nextFiber.return = fiber;
2116			else for (nextFiber = fiber; null !== nextFiber;) {
2117				if (nextFiber === workInProgress) {
2118					nextFiber = null;
2119					break;
2120				}
2121				fiber = nextFiber.sibling;
2122				if (null !== fiber) {
2123					fiber.return = nextFiber.return;
2124					nextFiber = fiber;
2125					break;
2126				}
2127				nextFiber = nextFiber.return;
2128			}
2129			fiber = nextFiber;
2130		}
2131	}
2132	function propagateParentContextChanges(current, workInProgress, renderLanes, forcePropagateEntireTree) {
2133		current = null;
2134		for (var parent = workInProgress, isInsidePropagationBailout = !1; null !== parent;) {
2135			if (!isInsidePropagationBailout) {
2136				if (0 !== (parent.flags & 524288)) isInsidePropagationBailout = !0;
2137				else if (0 !== (parent.flags & 262144)) break;
2138			}
2139			if (10 === parent.tag) {
2140				var currentParent = parent.alternate;
2141				if (null === currentParent) throw Error(formatProdErrorMessage(387));
2142				currentParent = currentParent.memoizedProps;
2143				if (null !== currentParent) {
2144					var context = parent.type;
2145					objectIs(parent.pendingProps.value, currentParent.value) || (null !== current ? current.push(context) : current = [context]);
2146				}
2147			} else if (parent === hostTransitionProviderCursor.current) {
2148				currentParent = parent.alternate;
2149				if (null === currentParent) throw Error(formatProdErrorMessage(387));
2150				currentParent.memoizedState.memoizedState !== parent.memoizedState.memoizedState && (null !== current ? current.push(HostTransitionContext) : current = [HostTransitionContext]);
2151			}
2152			parent = parent.return;
2153		}
2154		null !== current && propagateContextChanges(workInProgress, current, renderLanes, forcePropagateEntireTree);
2155		workInProgress.flags |= 262144;
2156	}
2157	function checkIfContextChanged(currentDependencies) {
2158		for (currentDependencies = currentDependencies.firstContext; null !== currentDependencies;) {
2159			if (!objectIs(currentDependencies.context._currentValue, currentDependencies.memoizedValue)) return !0;
2160			currentDependencies = currentDependencies.next;
2161		}
2162		return !1;
2163	}
2164	function prepareToReadContext(workInProgress) {
2165		currentlyRenderingFiber$1 = workInProgress;
2166		lastContextDependency = null;
2167		workInProgress = workInProgress.dependencies;
2168		null !== workInProgress && (workInProgress.firstContext = null);
2169	}
2170	function readContext(context) {
2171		return readContextForConsumer(currentlyRenderingFiber$1, context);
2172	}
2173	function readContextDuringReconciliation(consumer, context) {
2174		null === currentlyRenderingFiber$1 && prepareToReadContext(consumer);
2175		return readContextForConsumer(consumer, context);
2176	}
2177	function readContextForConsumer(consumer, context) {
2178		var value = context._currentValue;
2179		context = {
2180			context,
2181			memoizedValue: value,
2182			next: null
2183		};
2184		if (null === lastContextDependency) {
2185			if (null === consumer) throw Error(formatProdErrorMessage(308));
2186			lastContextDependency = context;
2187			consumer.dependencies = {
2188				lanes: 0,
2189				firstContext: context
2190			};
2191			consumer.flags |= 524288;
2192		} else lastContextDependency = lastContextDependency.next = context;
2193		return value;
2194	}
2195	var AbortControllerLocal = "undefined" !== typeof AbortController ? AbortController : function() {
2196		var listeners = [], signal = this.signal = {
2197			aborted: !1,
2198			addEventListener: function(type, listener) {
2199				listeners.push(listener);
2200			}
2201		};
2202		this.abort = function() {
2203			signal.aborted = !0;
2204			listeners.forEach(function(listener) {
2205				return listener();
2206			});
2207		};
2208	}, scheduleCallback$2 = Scheduler.unstable_scheduleCallback, NormalPriority = Scheduler.unstable_NormalPriority, CacheContext = {
2209		$$typeof: REACT_CONTEXT_TYPE,
2210		Consumer: null,
2211		Provider: null,
2212		_currentValue: null,
2213		_currentValue2: null,
2214		_threadCount: 0
2215	};
2216	function createCache() {
2217		return {
2218			controller: new AbortControllerLocal(),
2219			data: /* @__PURE__ */ new Map(),
2220			refCount: 0
2221		};
2222	}
2223	function releaseCache(cache) {
2224		cache.refCount--;
2225		0 === cache.refCount && scheduleCallback$2(NormalPriority, function() {
2226			cache.controller.abort();
2227		});
2228	}
2229	var currentEntangledListeners = null, currentEntangledPendingCount = 0, currentEntangledLane = 0, currentEntangledActionThenable = null;
2230	function entangleAsyncAction(transition, thenable) {
2231		if (null === currentEntangledListeners) {
2232			var entangledListeners = currentEntangledListeners = [];
2233			currentEntangledPendingCount = 0;
2234			currentEntangledLane = requestTransitionLane();
2235			currentEntangledActionThenable = {
2236				status: "pending",
2237				value: void 0,
2238				then: function(resolve) {
2239					entangledListeners.push(resolve);
2240				}
2241			};
2242		}
2243		currentEntangledPendingCount++;
2244		thenable.then(pingEngtangledActionScope, pingEngtangledActionScope);
2245		return thenable;
2246	}
2247	function pingEngtangledActionScope() {
2248		if (0 === --currentEntangledPendingCount && null !== currentEntangledListeners) {
2249			null !== currentEntangledActionThenable && (currentEntangledActionThenable.status = "fulfilled");
2250			var listeners = currentEntangledListeners;
2251			currentEntangledListeners = null;
2252			currentEntangledLane = 0;
2253			currentEntangledActionThenable = null;
2254			for (var i = 0; i < listeners.length; i++) (0, listeners[i])();
2255		}
2256	}
2257	function chainThenableValue(thenable, result) {
2258		var listeners = [], thenableWithOverride = {
2259			status: "pending",
2260			value: null,
2261			reason: null,
2262			then: function(resolve) {
2263				listeners.push(resolve);
2264			}
2265		};
2266		thenable.then(function() {
2267			thenableWithOverride.status = "fulfilled";
2268			thenableWithOverride.value = result;
2269			for (var i = 0; i < listeners.length; i++) (0, listeners[i])(result);
2270		}, function(error) {
2271			thenableWithOverride.status = "rejected";
2272			thenableWithOverride.reason = error;
2273			for (error = 0; error < listeners.length; error++) (0, listeners[error])(void 0);
2274		});
2275		return thenableWithOverride;
2276	}
2277	var prevOnStartTransitionFinish = ReactSharedInternals.S;
2278	ReactSharedInternals.S = function(transition, returnValue) {
2279		globalMostRecentTransitionTime = now();
2280		"object" === typeof returnValue && null !== returnValue && "function" === typeof returnValue.then && entangleAsyncAction(transition, returnValue);
2281		null !== prevOnStartTransitionFinish && prevOnStartTransitionFinish(transition, returnValue);
2282	};
2283	var resumedCache = createCursor(null);
2284	function peekCacheFromPool() {
2285		var cacheResumedFromPreviousRender = resumedCache.current;
2286		return null !== cacheResumedFromPreviousRender ? cacheResumedFromPreviousRender : workInProgressRoot.pooledCache;
2287	}
2288	function pushTransition(offscreenWorkInProgress, prevCachePool) {
2289		null === prevCachePool ? push(resumedCache, resumedCache.current) : push(resumedCache, prevCachePool.pool);
2290	}
2291	function getSuspendedCache() {
2292		var cacheFromPool = peekCacheFromPool();
2293		return null === cacheFromPool ? null : {
2294			parent: CacheContext._currentValue,
2295			pool: cacheFromPool
2296		};
2297	}
2298	var SuspenseException = Error(formatProdErrorMessage(460)), SuspenseyCommitException = Error(formatProdErrorMessage(474)), SuspenseActionException = Error(formatProdErrorMessage(542)), noopSuspenseyCommitThenable = { then: function() {} };
2299	function isThenableResolved(thenable) {
2300		thenable = thenable.status;
2301		return "fulfilled" === thenable || "rejected" === thenable;
2302	}
2303	function trackUsedThenable(thenableState, thenable, index) {
2304		index = thenableState[index];
2305		void 0 === index ? thenableState.push(thenable) : index !== thenable && (thenable.then(noop$1, noop$1), thenable = index);
2306		switch (thenable.status) {
2307			case "fulfilled": return thenable.value;
2308			case "rejected": throw thenableState = thenable.reason, checkIfUseWrappedInAsyncCatch(thenableState), thenableState;
2309			default:
2310				if ("string" === typeof thenable.status) thenable.then(noop$1, noop$1);
2311				else {
2312					thenableState = workInProgressRoot;
2313					if (null !== thenableState && 100 < thenableState.shellSuspendCounter) throw Error(formatProdErrorMessage(482));
2314					thenableState = thenable;
2315					thenableState.status = "pending";
2316					thenableState.then(function(fulfilledValue) {
2317						if ("pending" === thenable.status) {
2318							var fulfilledThenable = thenable;
2319							fulfilledThenable.status = "fulfilled";
2320							fulfilledThenable.value = fulfilledValue;
2321						}
2322					}, function(error) {
2323						if ("pending" === thenable.status) {
2324							var rejectedThenable = thenable;
2325							rejectedThenable.status = "rejected";
2326							rejectedThenable.reason = error;
2327						}
2328					});
2329				}
2330				switch (thenable.status) {
2331					case "fulfilled": return thenable.value;
2332					case "rejected": throw thenableState = thenable.reason, checkIfUseWrappedInAsyncCatch(thenableState), thenableState;
2333				}
2334				suspendedThenable = thenable;
2335				throw SuspenseException;
2336		}
2337	}
2338	function resolveLazy(lazyType) {
2339		try {
2340			var init = lazyType._init;
2341			return init(lazyType._payload);
2342		} catch (x) {
2343			if (null !== x && "object" === typeof x && "function" === typeof x.then) throw suspendedThenable = x, SuspenseException;
2344			throw x;
2345		}
2346	}
2347	var suspendedThenable = null;
2348	function getSuspendedThenable() {
2349		if (null === suspendedThenable) throw Error(formatProdErrorMessage(459));
2350		var thenable = suspendedThenable;
2351		suspendedThenable = null;
2352		return thenable;
2353	}
2354	function checkIfUseWrappedInAsyncCatch(rejectedReason) {
2355		if (rejectedReason === SuspenseException || rejectedReason === SuspenseActionException) throw Error(formatProdErrorMessage(483));
2356	}
2357	var thenableState$1 = null, thenableIndexCounter$1 = 0;
2358	function unwrapThenable(thenable) {
2359		var index = thenableIndexCounter$1;
2360		thenableIndexCounter$1 += 1;
2361		null === thenableState$1 && (thenableState$1 = []);
2362		return trackUsedThenable(thenableState$1, thenable, index);
2363	}
2364	function coerceRef(workInProgress, element) {
2365		element = element.props.ref;
2366		workInProgress.ref = void 0 !== element ? element : null;
2367	}
2368	function throwOnInvalidObjectTypeImpl(returnFiber, newChild) {
2369		if (newChild.$$typeof === REACT_LEGACY_ELEMENT_TYPE) throw Error(formatProdErrorMessage(525));
2370		returnFiber = Object.prototype.toString.call(newChild);
2371		throw Error(formatProdErrorMessage(31, "[object Object]" === returnFiber ? "object with keys {" + Object.keys(newChild).join(", ") + "}" : returnFiber));
2372	}
2373	function createChildReconciler(shouldTrackSideEffects) {
2374		function deleteChild(returnFiber, childToDelete) {
2375			if (shouldTrackSideEffects) {
2376				var deletions = returnFiber.deletions;
2377				null === deletions ? (returnFiber.deletions = [childToDelete], returnFiber.flags |= 16) : deletions.push(childToDelete);
2378			}
2379		}
2380		function deleteRemainingChildren(returnFiber, currentFirstChild) {
2381			if (!shouldTrackSideEffects) return null;
2382			for (; null !== currentFirstChild;) deleteChild(returnFiber, currentFirstChild), currentFirstChild = currentFirstChild.sibling;
2383			return null;
2384		}
2385		function mapRemainingChildren(currentFirstChild) {
2386			for (var existingChildren = /* @__PURE__ */ new Map(); null !== currentFirstChild;) null !== currentFirstChild.key ? existingChildren.set(currentFirstChild.key, currentFirstChild) : existingChildren.set(currentFirstChild.index, currentFirstChild), currentFirstChild = currentFirstChild.sibling;
2387			return existingChildren;
2388		}
2389		function useFiber(fiber, pendingProps) {
2390			fiber = createWorkInProgress(fiber, pendingProps);
2391			fiber.index = 0;
2392			fiber.sibling = null;
2393			return fiber;
2394		}
2395		function placeChild(newFiber, lastPlacedIndex, newIndex) {
2396			newFiber.index = newIndex;
2397			if (!shouldTrackSideEffects) return newFiber.flags |= 1048576, lastPlacedIndex;
2398			newIndex = newFiber.alternate;
2399			if (null !== newIndex) return newIndex = newIndex.index, newIndex < lastPlacedIndex ? (newFiber.flags |= 67108866, lastPlacedIndex) : newIndex;
2400			newFiber.flags |= 67108866;
2401			return lastPlacedIndex;
2402		}
2403		function placeSingleChild(newFiber) {
2404			shouldTrackSideEffects && null === newFiber.alternate && (newFiber.flags |= 67108866);
2405			return newFiber;
2406		}
2407		function updateTextNode(returnFiber, current, textContent, lanes) {
2408			if (null === current || 6 !== current.tag) return current = createFiberFromText(textContent, returnFiber.mode, lanes), current.return = returnFiber, current;
2409			current = useFiber(current, textContent);
2410			current.return = returnFiber;
2411			return current;
2412		}
2413		function updateElement(returnFiber, current, element, lanes) {
2414			var elementType = element.type;
2415			if (elementType === REACT_FRAGMENT_TYPE) return updateFragment(returnFiber, current, element.props.children, lanes, element.key);
2416			if (null !== current && (current.elementType === elementType || "object" === typeof elementType && null !== elementType && elementType.$$typeof === REACT_LAZY_TYPE && resolveLazy(elementType) === current.type)) return current = useFiber(current, element.props), coerceRef(current, element), current.return = returnFiber, current;
2417			current = createFiberFromTypeAndProps(element.type, element.key, element.props, null, returnFiber.mode, lanes);
2418			coerceRef(current, element);
2419			current.return = returnFiber;
2420			return current;
2421		}
2422		function updatePortal(returnFiber, current, portal, lanes) {
2423			if (null === current || 4 !== current.tag || current.stateNode.containerInfo !== portal.containerInfo || current.stateNode.implementation !== portal.implementation) return current = createFiberFromPortal(portal, returnFiber.mode, lanes), current.return = returnFiber, current;
2424			current = useFiber(current, portal.children || []);
2425			current.return = returnFiber;
2426			return current;
2427		}
2428		function updateFragment(returnFiber, current, fragment, lanes, key) {
2429			if (null === current || 7 !== current.tag) return current = createFiberFromFragment(fragment, returnFiber.mode, lanes, key), current.return = returnFiber, current;
2430			current = useFiber(current, fragment);
2431			current.return = returnFiber;
2432			return current;
2433		}
2434		function createChild(returnFiber, newChild, lanes) {
2435			if ("string" === typeof newChild && "" !== newChild || "number" === typeof newChild || "bigint" === typeof newChild) return newChild = createFiberFromText("" + newChild, returnFiber.mode, lanes), newChild.return = returnFiber, newChild;
2436			if ("object" === typeof newChild && null !== newChild) {
2437				switch (newChild.$$typeof) {
2438					case REACT_ELEMENT_TYPE: return lanes = createFiberFromTypeAndProps(newChild.type, newChild.key, newChild.props, null, returnFiber.mode, lanes), coerceRef(lanes, newChild), lanes.return = returnFiber, lanes;
2439					case REACT_PORTAL_TYPE: return newChild = createFiberFromPortal(newChild, returnFiber.mode, lanes), newChild.return = returnFiber, newChild;
2440					case REACT_LAZY_TYPE: return newChild = resolveLazy(newChild), createChild(returnFiber, newChild, lanes);
2441				}
2442				if (isArrayImpl(newChild) || getIteratorFn(newChild)) return newChild = createFiberFromFragment(newChild, returnFiber.mode, lanes, null), newChild.return = returnFiber, newChild;
2443				if ("function" === typeof newChild.then) return createChild(returnFiber, unwrapThenable(newChild), lanes);
2444				if (newChild.$$typeof === REACT_CONTEXT_TYPE) return createChild(returnFiber, readContextDuringReconciliation(returnFiber, newChild), lanes);
2445				throwOnInvalidObjectTypeImpl(returnFiber, newChild);
2446			}
2447			return null;
2448		}
2449		function updateSlot(returnFiber, oldFiber, newChild, lanes) {
2450			var key = null !== oldFiber ? oldFiber.key : null;
2451			if ("string" === typeof newChild && "" !== newChild || "number" === typeof newChild || "bigint" === typeof newChild) return null !== key ? null : updateTextNode(returnFiber, oldFiber, "" + newChild, lanes);
2452			if ("object" === typeof newChild && null !== newChild) {
2453				switch (newChild.$$typeof) {
2454					case REACT_ELEMENT_TYPE: return newChild.key === key ? updateElement(returnFiber, oldFiber, newChild, lanes) : null;
2455					case REACT_PORTAL_TYPE: return newChild.key === key ? updatePortal(returnFiber, oldFiber, newChild, lanes) : null;
2456					case REACT_LAZY_TYPE: return newChild = resolveLazy(newChild), updateSlot(returnFiber, oldFiber, newChild, lanes);
2457				}
2458				if (isArrayImpl(newChild) || getIteratorFn(newChild)) return null !== key ? null : updateFragment(returnFiber, oldFiber, newChild, lanes, null);
2459				if ("function" === typeof newChild.then) return updateSlot(returnFiber, oldFiber, unwrapThenable(newChild), lanes);
2460				if (newChild.$$typeof === REACT_CONTEXT_TYPE) return updateSlot(returnFiber, oldFiber, readContextDuringReconciliation(returnFiber, newChild), lanes);
2461				throwOnInvalidObjectTypeImpl(returnFiber, newChild);
2462			}
2463			return null;
2464		}
2465		function updateFromMap(existingChildren, returnFiber, newIdx, newChild, lanes) {
2466			if ("string" === typeof newChild && "" !== newChild || "number" === typeof newChild || "bigint" === typeof newChild) return existingChildren = existingChildren.get(newIdx) || null, updateTextNode(returnFiber, existingChildren, "" + newChild, lanes);
2467			if ("object" === typeof newChild && null !== newChild) {
2468				switch (newChild.$$typeof) {
2469					case REACT_ELEMENT_TYPE: return existingChildren = existingChildren.get(null === newChild.key ? newIdx : newChild.key) || null, updateElement(returnFiber, existingChildren, newChild, lanes);
2470					case REACT_PORTAL_TYPE: return existingChildren = existingChildren.get(null === newChild.key ? newIdx : newChild.key) || null, updatePortal(returnFiber, existingChildren, newChild, lanes);
2471					case REACT_LAZY_TYPE: return newChild = resolveLazy(newChild), updateFromMap(existingChildren, returnFiber, newIdx, newChild, lanes);
2472				}
2473				if (isArrayImpl(newChild) || getIteratorFn(newChild)) return existingChildren = existingChildren.get(newIdx) || null, updateFragment(returnFiber, existingChildren, newChild, lanes, null);
2474				if ("function" === typeof newChild.then) return updateFromMap(existingChildren, returnFiber, newIdx, unwrapThenable(newChild), lanes);
2475				if (newChild.$$typeof === REACT_CONTEXT_TYPE) return updateFromMap(existingChildren, returnFiber, newIdx, readContextDuringReconciliation(returnFiber, newChild), lanes);
2476				throwOnInvalidObjectTypeImpl(returnFiber, newChild);
2477			}
2478			return null;
2479		}
2480		function reconcileChildrenArray(returnFiber, currentFirstChild, newChildren, lanes) {
2481			for (var resultingFirstChild = null, previousNewFiber = null, oldFiber = currentFirstChild, newIdx = currentFirstChild = 0, nextOldFiber = null; null !== oldFiber && newIdx < newChildren.length; newIdx++) {
2482				oldFiber.index > newIdx ? (nextOldFiber = oldFiber, oldFiber = null) : nextOldFiber = oldFiber.sibling;
2483				var newFiber = updateSlot(returnFiber, oldFiber, newChildren[newIdx], lanes);
2484				if (null === newFiber) {
2485					null === oldFiber && (oldFiber = nextOldFiber);
2486					break;
2487				}
2488				shouldTrackSideEffects && oldFiber && null === newFiber.alternate && deleteChild(returnFiber, oldFiber);
2489				currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
2490				null === previousNewFiber ? resultingFirstChild = newFiber : previousNewFiber.sibling = newFiber;
2491				previousNewFiber = newFiber;
2492				oldFiber = nextOldFiber;
2493			}
2494			if (newIdx === newChildren.length) return deleteRemainingChildren(returnFiber, oldFiber), isHydrating && pushTreeFork(returnFiber, newIdx), resultingFirstChild;
2495			if (null === oldFiber) {
2496				for (; newIdx < newChildren.length; newIdx++) oldFiber = createChild(returnFiber, newChildren[newIdx], lanes), null !== oldFiber && (currentFirstChild = placeChild(oldFiber, currentFirstChild, newIdx), null === previousNewFiber ? resultingFirstChild = oldFiber : previousNewFiber.sibling = oldFiber, previousNewFiber = oldFiber);
2497				isHydrating && pushTreeFork(returnFiber, newIdx);
2498				return resultingFirstChild;
2499			}
2500			for (oldFiber = mapRemainingChildren(oldFiber); newIdx < newChildren.length; newIdx++) nextOldFiber = updateFromMap(oldFiber, returnFiber, newIdx, newChildren[newIdx], lanes), null !== nextOldFiber && (shouldTrackSideEffects && null !== nextOldFiber.alternate && oldFiber.delete(null === nextOldFiber.key ? newIdx : nextOldFiber.key), currentFirstChild = placeChild(nextOldFiber, currentFirstChild, newIdx), null === previousNewFiber ? resultingFirstChild = nextOldFiber : previousNewFiber.sibling = nextOldFiber, previousNewFiber = nextOldFiber);
2501			shouldTrackSideEffects && oldFiber.forEach(function(child) {
2502				return deleteChild(returnFiber, child);
2503			});
2504			isHydrating && pushTreeFork(returnFiber, newIdx);
2505			return resultingFirstChild;
2506		}
2507		function reconcileChildrenIterator(returnFiber, currentFirstChild, newChildren, lanes) {
2508			if (null == newChildren) throw Error(formatProdErrorMessage(151));
2509			for (var resultingFirstChild = null, previousNewFiber = null, oldFiber = currentFirstChild, newIdx = currentFirstChild = 0, nextOldFiber = null, step = newChildren.next(); null !== oldFiber && !step.done; newIdx++, step = newChildren.next()) {
2510				oldFiber.index > newIdx ? (nextOldFiber = oldFiber, oldFiber = null) : nextOldFiber = oldFiber.sibling;
2511				var newFiber = updateSlot(returnFiber, oldFiber, step.value, lanes);
2512				if (null === newFiber) {
2513					null === oldFiber && (oldFiber = nextOldFiber);
2514					break;
2515				}
2516				shouldTrackSideEffects && oldFiber && null === newFiber.alternate && deleteChild(returnFiber, oldFiber);
2517				currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
2518				null === previousNewFiber ? resultingFirstChild = newFiber : previousNewFiber.sibling = newFiber;
2519				previousNewFiber = newFiber;
2520				oldFiber = nextOldFiber;
2521			}
2522			if (step.done) return deleteRemainingChildren(returnFiber, oldFiber), isHydrating && pushTreeFork(returnFiber, newIdx), resultingFirstChild;
2523			if (null === oldFiber) {
2524				for (; !step.done; newIdx++, step = newChildren.next()) step = createChild(returnFiber, step.value, lanes), null !== step && (currentFirstChild = placeChild(step, currentFirstChild, newIdx), null === previousNewFiber ? resultingFirstChild = step : previousNewFiber.sibling = step, previousNewFiber = step);
2525				isHydrating && pushTreeFork(returnFiber, newIdx);
2526				return resultingFirstChild;
2527			}
2528			for (oldFiber = mapRemainingChildren(oldFiber); !step.done; newIdx++, step = newChildren.next()) step = updateFromMap(oldFiber, returnFiber, newIdx, step.value, lanes), null !== step && (shouldTrackSideEffects && null !== step.alternate && oldFiber.delete(null === step.key ? newIdx : step.key), currentFirstChild = placeChild(step, currentFirstChild, newIdx), null === previousNewFiber ? resultingFirstChild = step : previousNewFiber.sibling = step, previousNewFiber = step);
2529			shouldTrackSideEffects && oldFiber.forEach(function(child) {
2530				return deleteChild(returnFiber, child);
2531			});
2532			isHydrating && pushTreeFork(returnFiber, newIdx);
2533			return resultingFirstChild;
2534		}
2535		function reconcileChildFibersImpl(returnFiber, currentFirstChild, newChild, lanes) {
2536			"object" === typeof newChild && null !== newChild && newChild.type === REACT_FRAGMENT_TYPE && null === newChild.key && (newChild = newChild.props.children);
2537			if ("object" === typeof newChild && null !== newChild) {
2538				switch (newChild.$$typeof) {
2539					case REACT_ELEMENT_TYPE:
2540						a: {
2541							for (var key = newChild.key; null !== currentFirstChild;) {
2542								if (currentFirstChild.key === key) {
2543									key = newChild.type;
2544									if (key === REACT_FRAGMENT_TYPE) {
2545										if (7 === currentFirstChild.tag) {
2546											deleteRemainingChildren(returnFiber, currentFirstChild.sibling);
2547											lanes = useFiber(currentFirstChild, newChild.props.children);
2548											lanes.return = returnFiber;
2549											returnFiber = lanes;
2550											break a;
2551										}
2552									} else if (currentFirstChild.elementType === key || "object" === typeof key && null !== key && key.$$typeof === REACT_LAZY_TYPE && resolveLazy(key) === currentFirstChild.type) {
2553										deleteRemainingChildren(returnFiber, currentFirstChild.sibling);
2554										lanes = useFiber(currentFirstChild, newChild.props);
2555										coerceRef(lanes, newChild);
2556										lanes.return = returnFiber;
2557										returnFiber = lanes;
2558										break a;
2559									}
2560									deleteRemainingChildren(returnFiber, currentFirstChild);
2561									break;
2562								} else deleteChild(returnFiber, currentFirstChild);
2563								currentFirstChild = currentFirstChild.sibling;
2564							}
2565							newChild.type === REACT_FRAGMENT_TYPE ? (lanes = createFiberFromFragment(newChild.props.children, returnFiber.mode, lanes, newChild.key), lanes.return = returnFiber, returnFiber = lanes) : (lanes = createFiberFromTypeAndProps(newChild.type, newChild.key, newChild.props, null, returnFiber.mode, lanes), coerceRef(lanes, newChild), lanes.return = returnFiber, returnFiber = lanes);
2566						}
2567						return placeSingleChild(returnFiber);
2568					case REACT_PORTAL_TYPE:
2569						a: {
2570							for (key = newChild.key; null !== currentFirstChild;) {
2571								if (currentFirstChild.key === key) if (4 === currentFirstChild.tag && currentFirstChild.stateNode.containerInfo === newChild.containerInfo && currentFirstChild.stateNode.implementation === newChild.implementation) {
2572									deleteRemainingChildren(returnFiber, currentFirstChild.sibling);
2573									lanes = useFiber(currentFirstChild, newChild.children || []);
2574									lanes.return = returnFiber;
2575									returnFiber = lanes;
2576									break a;
2577								} else {
2578									deleteRemainingChildren(returnFiber, currentFirstChild);
2579									break;
2580								}
2581								else deleteChild(returnFiber, currentFirstChild);
2582								currentFirstChild = currentFirstChild.sibling;
2583							}
2584							lanes = createFiberFromPortal(newChild, returnFiber.mode, lanes);
2585							lanes.return = returnFiber;
2586							returnFiber = lanes;
2587						}
2588						return placeSingleChild(returnFiber);
2589					case REACT_LAZY_TYPE: return newChild = resolveLazy(newChild), reconcileChildFibersImpl(returnFiber, currentFirstChild, newChild, lanes);
2590				}
2591				if (isArrayImpl(newChild)) return reconcileChildrenArray(returnFiber, currentFirstChild, newChild, lanes);
2592				if (getIteratorFn(newChild)) {
2593					key = getIteratorFn(newChild);
2594					if ("function" !== typeof key) throw Error(formatProdErrorMessage(150));
2595					newChild = key.call(newChild);
2596					return reconcileChildrenIterator(returnFiber, currentFirstChild, newChild, lanes);
2597				}
2598				if ("function" === typeof newChild.then) return reconcileChildFibersImpl(returnFiber, currentFirstChild, unwrapThenable(newChild), lanes);
2599				if (newChild.$$typeof === REACT_CONTEXT_TYPE) return reconcileChildFibersImpl(returnFiber, currentFirstChild, readContextDuringReconciliation(returnFiber, newChild), lanes);
2600				throwOnInvalidObjectTypeImpl(returnFiber, newChild);
2601			}
2602			return "string" === typeof newChild && "" !== newChild || "number" === typeof newChild || "bigint" === typeof newChild ? (newChild = "" + newChild, null !== currentFirstChild && 6 === currentFirstChild.tag ? (deleteRemainingChildren(returnFiber, currentFirstChild.sibling), lanes = useFiber(currentFirstChild, newChild), lanes.return = returnFiber, returnFiber = lanes) : (deleteRemainingChildren(returnFiber, currentFirstChild), lanes = createFiberFromText(newChild, returnFiber.mode, lanes), lanes.return = returnFiber, returnFiber = lanes), placeSingleChild(returnFiber)) : deleteRemainingChildren(returnFiber, currentFirstChild);
2603		}
2604		return function(returnFiber, currentFirstChild, newChild, lanes) {
2605			try {
2606				thenableIndexCounter$1 = 0;
2607				var firstChildFiber = reconcileChildFibersImpl(returnFiber, currentFirstChild, newChild, lanes);
2608				thenableState$1 = null;
2609				return firstChildFiber;
2610			} catch (x) {
2611				if (x === SuspenseException || x === SuspenseActionException) throw x;
2612				var fiber = createFiberImplClass(29, x, null, returnFiber.mode);
2613				fiber.lanes = lanes;
2614				fiber.return = returnFiber;
2615				return fiber;
2616			}
2617		};
2618	}
2619	var reconcileChildFibers = createChildReconciler(!0), mountChildFibers = createChildReconciler(!1), hasForceUpdate = !1;
2620	function initializeUpdateQueue(fiber) {
2621		fiber.updateQueue = {
2622			baseState: fiber.memoizedState,
2623			firstBaseUpdate: null,
2624			lastBaseUpdate: null,
2625			shared: {
2626				pending: null,
2627				lanes: 0,
2628				hiddenCallbacks: null
2629			},
2630			callbacks: null
2631		};
2632	}
2633	function cloneUpdateQueue(current, workInProgress) {
2634		current = current.updateQueue;
2635		workInProgress.updateQueue === current && (workInProgress.updateQueue = {
2636			baseState: current.baseState,
2637			firstBaseUpdate: current.firstBaseUpdate,
2638			lastBaseUpdate: current.lastBaseUpdate,
2639			shared: current.shared,
2640			callbacks: null
2641		});
2642	}
2643	function createUpdate(lane) {
2644		return {
2645			lane,
2646			tag: 0,
2647			payload: null,
2648			callback: null,
2649			next: null
2650		};
2651	}
2652	function enqueueUpdate(fiber, update, lane) {
2653		var updateQueue = fiber.updateQueue;
2654		if (null === updateQueue) return null;
2655		updateQueue = updateQueue.shared;
2656		if (0 !== (executionContext & 2)) {
2657			var pending = updateQueue.pending;
2658			null === pending ? update.next = update : (update.next = pending.next, pending.next = update);
2659			updateQueue.pending = update;
2660			update = getRootForUpdatedFiber(fiber);
2661			markUpdateLaneFromFiberToRoot(fiber, null, lane);
2662			return update;
2663		}
2664		enqueueUpdate$1(fiber, updateQueue, update, lane);
2665		return getRootForUpdatedFiber(fiber);
2666	}
2667	function entangleTransitions(root, fiber, lane) {
2668		fiber = fiber.updateQueue;
2669		if (null !== fiber && (fiber = fiber.shared, 0 !== (lane & 4194048))) {
2670			var queueLanes = fiber.lanes;
2671			queueLanes &= root.pendingLanes;
2672			lane |= queueLanes;
2673			fiber.lanes = lane;
2674			markRootEntangled(root, lane);
2675		}
2676	}
2677	function enqueueCapturedUpdate(workInProgress, capturedUpdate) {
2678		var queue = workInProgress.updateQueue, current = workInProgress.alternate;
2679		if (null !== current && (current = current.updateQueue, queue === current)) {
2680			var newFirst = null, newLast = null;
2681			queue = queue.firstBaseUpdate;
2682			if (null !== queue) {
2683				do {
2684					var clone = {
2685						lane: queue.lane,
2686						tag: queue.tag,
2687						payload: queue.payload,
2688						callback: null,
2689						next: null
2690					};
2691					null === newLast ? newFirst = newLast = clone : newLast = newLast.next = clone;
2692					queue = queue.next;
2693				} while (null !== queue);
2694				null === newLast ? newFirst = newLast = capturedUpdate : newLast = newLast.next = capturedUpdate;
2695			} else newFirst = newLast = capturedUpdate;
2696			queue = {
2697				baseState: current.baseState,
2698				firstBaseUpdate: newFirst,
2699				lastBaseUpdate: newLast,
2700				shared: current.shared,
2701				callbacks: current.callbacks
2702			};
2703			workInProgress.updateQueue = queue;
2704			return;
2705		}
2706		workInProgress = queue.lastBaseUpdate;
2707		null === workInProgress ? queue.firstBaseUpdate = capturedUpdate : workInProgress.next = capturedUpdate;
2708		queue.lastBaseUpdate = capturedUpdate;
2709	}
2710	var didReadFromEntangledAsyncAction = !1;
2711	function suspendIfUpdateReadFromEntangledAsyncAction() {
2712		if (didReadFromEntangledAsyncAction) {
2713			var entangledActionThenable = currentEntangledActionThenable;
2714			if (null !== entangledActionThenable) throw entangledActionThenable;
2715		}
2716	}
2717	function processUpdateQueue(workInProgress$jscomp$0, props, instance$jscomp$0, renderLanes) {
2718		didReadFromEntangledAsyncAction = !1;
2719		var queue = workInProgress$jscomp$0.updateQueue;
2720		hasForceUpdate = !1;
2721		var firstBaseUpdate = queue.firstBaseUpdate, lastBaseUpdate = queue.lastBaseUpdate, pendingQueue = queue.shared.pending;
2722		if (null !== pendingQueue) {
2723			queue.shared.pending = null;
2724			var lastPendingUpdate = pendingQueue, firstPendingUpdate = lastPendingUpdate.next;
2725			lastPendingUpdate.next = null;
2726			null === lastBaseUpdate ? firstBaseUpdate = firstPendingUpdate : lastBaseUpdate.next = firstPendingUpdate;
2727			lastBaseUpdate = lastPendingUpdate;
2728			var current = workInProgress$jscomp$0.alternate;
2729			null !== current && (current = current.updateQueue, pendingQueue = current.lastBaseUpdate, pendingQueue !== lastBaseUpdate && (null === pendingQueue ? current.firstBaseUpdate = firstPendingUpdate : pendingQueue.next = firstPendingUpdate, current.lastBaseUpdate = lastPendingUpdate));
2730		}
2731		if (null !== firstBaseUpdate) {
2732			var newState = queue.baseState;
2733			lastBaseUpdate = 0;
2734			current = firstPendingUpdate = lastPendingUpdate = null;
2735			pendingQueue = firstBaseUpdate;
2736			do {
2737				var updateLane = pendingQueue.lane & -536870913, isHiddenUpdate = updateLane !== pendingQueue.lane;
2738				if (isHiddenUpdate ? (workInProgressRootRenderLanes & updateLane) === updateLane : (renderLanes & updateLane) === updateLane) {
2739					0 !== updateLane && updateLane === currentEntangledLane && (didReadFromEntangledAsyncAction = !0);
2740					null !== current && (current = current.next = {
2741						lane: 0,
2742						tag: pendingQueue.tag,
2743						payload: pendingQueue.payload,
2744						callback: null,
2745						next: null
2746					});
2747					a: {
2748						var workInProgress = workInProgress$jscomp$0, update = pendingQueue;
2749						updateLane = props;
2750						var instance = instance$jscomp$0;
2751						switch (update.tag) {
2752							case 1:
2753								workInProgress = update.payload;
2754								if ("function" === typeof workInProgress) {
2755									newState = workInProgress.call(instance, newState, updateLane);
2756									break a;
2757								}
2758								newState = workInProgress;
2759								break a;
2760							case 3: workInProgress.flags = workInProgress.flags & -65537 | 128;
2761							case 0:
2762								workInProgress = update.payload;
2763								updateLane = "function" === typeof workInProgress ? workInProgress.call(instance, newState, updateLane) : workInProgress;
2764								if (null === updateLane || void 0 === updateLane) break a;
2765								newState = assign({}, newState, updateLane);
2766								break a;
2767							case 2: hasForceUpdate = !0;
2768						}
2769					}
2770					updateLane = pendingQueue.callback;
2771					null !== updateLane && (workInProgress$jscomp$0.flags |= 64, isHiddenUpdate && (workInProgress$jscomp$0.flags |= 8192), isHiddenUpdate = queue.callbacks, null === isHiddenUpdate ? queue.callbacks = [updateLane] : isHiddenUpdate.push(updateLane));
2772				} else isHiddenUpdate = {
2773					lane: updateLane,
2774					tag: pendingQueue.tag,
2775					payload: pendingQueue.payload,
2776					callback: pendingQueue.callback,
2777					next: null
2778				}, null === current ? (firstPendingUpdate = current = isHiddenUpdate, lastPendingUpdate = newState) : current = current.next = isHiddenUpdate, lastBaseUpdate |= updateLane;
2779				pendingQueue = pendingQueue.next;
2780				if (null === pendingQueue) if (pendingQueue = queue.shared.pending, null === pendingQueue) break;
2781				else isHiddenUpdate = pendingQueue, pendingQueue = isHiddenUpdate.next, isHiddenUpdate.next = null, queue.lastBaseUpdate = isHiddenUpdate, queue.shared.pending = null;
2782			} while (1);
2783			null === current && (lastPendingUpdate = newState);
2784			queue.baseState = lastPendingUpdate;
2785			queue.firstBaseUpdate = firstPendingUpdate;
2786			queue.lastBaseUpdate = current;
2787			null === firstBaseUpdate && (queue.shared.lanes = 0);
2788			workInProgressRootSkippedLanes |= lastBaseUpdate;
2789			workInProgress$jscomp$0.lanes = lastBaseUpdate;
2790			workInProgress$jscomp$0.memoizedState = newState;
2791		}
2792	}
2793	function callCallback(callback, context) {
2794		if ("function" !== typeof callback) throw Error(formatProdErrorMessage(191, callback));
2795		callback.call(context);
2796	}
2797	function commitCallbacks(updateQueue, context) {
2798		var callbacks = updateQueue.callbacks;
2799		if (null !== callbacks) for (updateQueue.callbacks = null, updateQueue = 0; updateQueue < callbacks.length; updateQueue++) callCallback(callbacks[updateQueue], context);
2800	}
2801	var currentTreeHiddenStackCursor = createCursor(null), prevEntangledRenderLanesCursor = createCursor(0);
2802	function pushHiddenContext(fiber, context) {
2803		fiber = entangledRenderLanes;
2804		push(prevEntangledRenderLanesCursor, fiber);
2805		push(currentTreeHiddenStackCursor, context);
2806		entangledRenderLanes = fiber | context.baseLanes;
2807	}
2808	function reuseHiddenContextOnStack() {
2809		push(prevEntangledRenderLanesCursor, entangledRenderLanes);
2810		push(currentTreeHiddenStackCursor, currentTreeHiddenStackCursor.current);
2811	}
2812	function popHiddenContext() {
2813		entangledRenderLanes = prevEntangledRenderLanesCursor.current;
2814		pop(currentTreeHiddenStackCursor);
2815		pop(prevEntangledRenderLanesCursor);
2816	}
2817	var suspenseHandlerStackCursor = createCursor(null), shellBoundary = null;
2818	function pushPrimaryTreeSuspenseHandler(handler) {
2819		var current = handler.alternate;
2820		push(suspenseStackCursor, suspenseStackCursor.current & 1);
2821		push(suspenseHandlerStackCursor, handler);
2822		null === shellBoundary && (null === current || null !== currentTreeHiddenStackCursor.current ? shellBoundary = handler : null !== current.memoizedState && (shellBoundary = handler));
2823	}
2824	function pushDehydratedActivitySuspenseHandler(fiber) {
2825		push(suspenseStackCursor, suspenseStackCursor.current);
2826		push(suspenseHandlerStackCursor, fiber);
2827		null === shellBoundary && (shellBoundary = fiber);
2828	}
2829	function pushOffscreenSuspenseHandler(fiber) {
2830		22 === fiber.tag ? (push(suspenseStackCursor, suspenseStackCursor.current), push(suspenseHandlerStackCursor, fiber), null === shellBoundary && (shellBoundary = fiber)) : reuseSuspenseHandlerOnStack(fiber);
2831	}
2832	function reuseSuspenseHandlerOnStack() {
2833		push(suspenseStackCursor, suspenseStackCursor.current);
2834		push(suspenseHandlerStackCursor, suspenseHandlerStackCursor.current);
2835	}
2836	function popSuspenseHandler(fiber) {
2837		pop(suspenseHandlerStackCursor);
2838		shellBoundary === fiber && (shellBoundary = null);
2839		pop(suspenseStackCursor);
2840	}
2841	var suspenseStackCursor = createCursor(0);
2842	function findFirstSuspended(row) {
2843		for (var node = row; null !== node;) {
2844			if (13 === node.tag) {
2845				var state = node.memoizedState;
2846				if (null !== state && (state = state.dehydrated, null === state || isSuspenseInstancePending(state) || isSuspenseInstanceFallback(state))) return node;
2847			} else if (19 === node.tag && ("forwards" === node.memoizedProps.revealOrder || "backwards" === node.memoizedProps.revealOrder || "unstable_legacy-backwards" === node.memoizedProps.revealOrder || "together" === node.memoizedProps.revealOrder)) {
2848				if (0 !== (node.flags & 128)) return node;
2849			} else if (null !== node.child) {
2850				node.child.return = node;
2851				node = node.child;
2852				continue;
2853			}
2854			if (node === row) break;
2855			for (; null === node.sibling;) {
2856				if (null === node.return || node.return === row) return null;
2857				node = node.return;
2858			}
2859			node.sibling.return = node.return;
2860			node = node.sibling;
2861		}
2862		return null;
2863	}
2864	var renderLanes = 0, currentlyRenderingFiber = null, currentHook = null, workInProgressHook = null, didScheduleRenderPhaseUpdate = !1, didScheduleRenderPhaseUpdateDuringThisPass = !1, shouldDoubleInvokeUserFnsInHooksDEV = !1, localIdCounter = 0, thenableIndexCounter = 0, thenableState = null, globalClientIdCounter = 0;
2865	function throwInvalidHookError() {
2866		throw Error(formatProdErrorMessage(321));
2867	}
2868	function areHookInputsEqual(nextDeps, prevDeps) {
2869		if (null === prevDeps) return !1;
2870		for (var i = 0; i < prevDeps.length && i < nextDeps.length; i++) if (!objectIs(nextDeps[i], prevDeps[i])) return !1;
2871		return !0;
2872	}
2873	function renderWithHooks(current, workInProgress, Component, props, secondArg, nextRenderLanes) {
2874		renderLanes = nextRenderLanes;
2875		currentlyRenderingFiber = workInProgress;
2876		workInProgress.memoizedState = null;
2877		workInProgress.updateQueue = null;
2878		workInProgress.lanes = 0;
2879		ReactSharedInternals.H = null === current || null === current.memoizedState ? HooksDispatcherOnMount : HooksDispatcherOnUpdate;
2880		shouldDoubleInvokeUserFnsInHooksDEV = !1;
2881		nextRenderLanes = Component(props, secondArg);
2882		shouldDoubleInvokeUserFnsInHooksDEV = !1;
2883		didScheduleRenderPhaseUpdateDuringThisPass && (nextRenderLanes = renderWithHooksAgain(workInProgress, Component, props, secondArg));
2884		finishRenderingHooks(current);
2885		return nextRenderLanes;
2886	}
2887	function finishRenderingHooks(current) {
2888		ReactSharedInternals.H = ContextOnlyDispatcher;
2889		var didRenderTooFewHooks = null !== currentHook && null !== currentHook.next;
2890		renderLanes = 0;
2891		workInProgressHook = currentHook = currentlyRenderingFiber = null;
2892		didScheduleRenderPhaseUpdate = !1;
2893		thenableIndexCounter = 0;
2894		thenableState = null;
2895		if (didRenderTooFewHooks) throw Error(formatProdErrorMessage(300));
2896		null === current || didReceiveUpdate || (current = current.dependencies, null !== current && checkIfContextChanged(current) && (didReceiveUpdate = !0));
2897	}
2898	function renderWithHooksAgain(workInProgress, Component, props, secondArg) {
2899		currentlyRenderingFiber = workInProgress;
2900		var numberOfReRenders = 0;
2901		do {
2902			didScheduleRenderPhaseUpdateDuringThisPass && (thenableState = null);
2903			thenableIndexCounter = 0;
2904			didScheduleRenderPhaseUpdateDuringThisPass = !1;
2905			if (25 <= numberOfReRenders) throw Error(formatProdErrorMessage(301));
2906			numberOfReRenders += 1;
2907			workInProgressHook = currentHook = null;
2908			if (null != workInProgress.updateQueue) {
2909				var children = workInProgress.updateQueue;
2910				children.lastEffect = null;
2911				children.events = null;
2912				children.stores = null;
2913				null != children.memoCache && (children.memoCache.index = 0);
2914			}
2915			ReactSharedInternals.H = HooksDispatcherOnRerender;
2916			children = Component(props, secondArg);
2917		} while (didScheduleRenderPhaseUpdateDuringThisPass);
2918		return children;
2919	}
2920	function TransitionAwareHostComponent() {
2921		var dispatcher = ReactSharedInternals.H, maybeThenable = dispatcher.useState()[0];
2922		maybeThenable = "function" === typeof maybeThenable.then ? useThenable(maybeThenable) : maybeThenable;
2923		dispatcher = dispatcher.useState()[0];
2924		(null !== currentHook ? currentHook.memoizedState : null) !== dispatcher && (currentlyRenderingFiber.flags |= 1024);
2925		return maybeThenable;
2926	}
2927	function checkDidRenderIdHook() {
2928		var didRenderIdHook = 0 !== localIdCounter;
2929		localIdCounter = 0;
2930		return didRenderIdHook;
2931	}
2932	function bailoutHooks(current, workInProgress, lanes) {
2933		workInProgress.updateQueue = current.updateQueue;
2934		workInProgress.flags &= -2053;
2935		current.lanes &= ~lanes;
2936	}
2937	function resetHooksOnUnwind(workInProgress) {
2938		if (didScheduleRenderPhaseUpdate) {
2939			for (workInProgress = workInProgress.memoizedState; null !== workInProgress;) {
2940				var queue = workInProgress.queue;
2941				null !== queue && (queue.pending = null);
2942				workInProgress = workInProgress.next;
2943			}
2944			didScheduleRenderPhaseUpdate = !1;
2945		}
2946		renderLanes = 0;
2947		workInProgressHook = currentHook = currentlyRenderingFiber = null;
2948		didScheduleRenderPhaseUpdateDuringThisPass = !1;
2949		thenableIndexCounter = localIdCounter = 0;
2950		thenableState = null;
2951	}
2952	function mountWorkInProgressHook() {
2953		var hook = {
2954			memoizedState: null,
2955			baseState: null,
2956			baseQueue: null,
2957			queue: null,
2958			next: null
2959		};
2960		null === workInProgressHook ? currentlyRenderingFiber.memoizedState = workInProgressHook = hook : workInProgressHook = workInProgressHook.next = hook;
2961		return workInProgressHook;
2962	}
2963	function updateWorkInProgressHook() {
2964		if (null === currentHook) {
2965			var nextCurrentHook = currentlyRenderingFiber.alternate;
2966			nextCurrentHook = null !== nextCurrentHook ? nextCurrentHook.memoizedState : null;
2967		} else nextCurrentHook = currentHook.next;
2968		var nextWorkInProgressHook = null === workInProgressHook ? currentlyRenderingFiber.memoizedState : workInProgressHook.next;
2969		if (null !== nextWorkInProgressHook) workInProgressHook = nextWorkInProgressHook, currentHook = nextCurrentHook;
2970		else {
2971			if (null === nextCurrentHook) {
2972				if (null === currentlyRenderingFiber.alternate) throw Error(formatProdErrorMessage(467));
2973				throw Error(formatProdErrorMessage(310));
2974			}
2975			currentHook = nextCurrentHook;
2976			nextCurrentHook = {
2977				memoizedState: currentHook.memoizedState,
2978				baseState: currentHook.baseState,
2979				baseQueue: currentHook.baseQueue,
2980				queue: currentHook.queue,
2981				next: null
2982			};
2983			null === workInProgressHook ? currentlyRenderingFiber.memoizedState = workInProgressHook = nextCurrentHook : workInProgressHook = workInProgressHook.next = nextCurrentHook;
2984		}
2985		return workInProgressHook;
2986	}
2987	function createFunctionComponentUpdateQueue() {
2988		return {
2989			lastEffect: null,
2990			events: null,
2991			stores: null,
2992			memoCache: null
2993		};
2994	}
2995	function useThenable(thenable) {
2996		var index = thenableIndexCounter;
2997		thenableIndexCounter += 1;
2998		null === thenableState && (thenableState = []);
2999		thenable = trackUsedThenable(thenableState, thenable, index);
3000		index = currentlyRenderingFiber;
3001		null === (null === workInProgressHook ? index.memoizedState : workInProgressHook.next) && (index = index.alternate, ReactSharedInternals.H = null === index || null === index.memoizedState ? HooksDispatcherOnMount : HooksDispatcherOnUpdate);
3002		return thenable;
3003	}
3004	function use(usable) {
3005		if (null !== usable && "object" === typeof usable) {
3006			if ("function" === typeof usable.then) return useThenable(usable);
3007			if (usable.$$typeof === REACT_CONTEXT_TYPE) return readContext(usable);
3008		}
3009		throw Error(formatProdErrorMessage(438, String(usable)));
3010	}
3011	function useMemoCache(size) {
3012		var memoCache = null, updateQueue = currentlyRenderingFiber.updateQueue;
3013		null !== updateQueue && (memoCache = updateQueue.memoCache);
3014		if (null == memoCache) {
3015			var current = currentlyRenderingFiber.alternate;
3016			null !== current && (current = current.updateQueue, null !== current && (current = current.memoCache, null != current && (memoCache = {
3017				data: current.data.map(function(array) {
3018					return array.slice();
3019				}),
3020				index: 0
3021			})));
3022		}
3023		memoCache ??= {
3024			data: [],
3025			index: 0
3026		};
3027		null === updateQueue && (updateQueue = createFunctionComponentUpdateQueue(), currentlyRenderingFiber.updateQueue = updateQueue);
3028		updateQueue.memoCache = memoCache;
3029		updateQueue = memoCache.data[memoCache.index];
3030		if (void 0 === updateQueue) for (updateQueue = memoCache.data[memoCache.index] = Array(size), current = 0; current < size; current++) updateQueue[current] = REACT_MEMO_CACHE_SENTINEL;
3031		memoCache.index++;
3032		return updateQueue;
3033	}
3034	function basicStateReducer(state, action) {
3035		return "function" === typeof action ? action(state) : action;
3036	}
3037	function updateReducer(reducer) {
3038		return updateReducerImpl(updateWorkInProgressHook(), currentHook, reducer);
3039	}
3040	function updateReducerImpl(hook, current, reducer) {
3041		var queue = hook.queue;
3042		if (null === queue) throw Error(formatProdErrorMessage(311));
3043		queue.lastRenderedReducer = reducer;
3044		var baseQueue = hook.baseQueue, pendingQueue = queue.pending;
3045		if (null !== pendingQueue) {
3046			if (null !== baseQueue) {
3047				var baseFirst = baseQueue.next;
3048				baseQueue.next = pendingQueue.next;
3049				pendingQueue.next = baseFirst;
3050			}
3051			current.baseQueue = baseQueue = pendingQueue;
3052			queue.pending = null;
3053		}
3054		pendingQueue = hook.baseState;
3055		if (null === baseQueue) hook.memoizedState = pendingQueue;
3056		else {
3057			current = baseQueue.next;
3058			var newBaseQueueFirst = baseFirst = null, newBaseQueueLast = null, update = current, didReadFromEntangledAsyncAction$60 = !1;
3059			do {
3060				var updateLane = update.lane & -536870913;
3061				if (updateLane !== update.lane ? (workInProgressRootRenderLanes & updateLane) === updateLane : (renderLanes & updateLane) === updateLane) {
3062					var revertLane = update.revertLane;
3063					if (0 === revertLane) null !== newBaseQueueLast && (newBaseQueueLast = newBaseQueueLast.next = {
3064						lane: 0,
3065						revertLane: 0,
3066						gesture: null,
3067						action: update.action,
3068						hasEagerState: update.hasEagerState,
3069						eagerState: update.eagerState,
3070						next: null
3071					}), updateLane === currentEntangledLane && (didReadFromEntangledAsyncAction$60 = !0);
3072					else if ((renderLanes & revertLane) === revertLane) {
3073						update = update.next;
3074						revertLane === currentEntangledLane && (didReadFromEntangledAsyncAction$60 = !0);
3075						continue;
3076					} else updateLane = {
3077						lane: 0,
3078						revertLane: update.revertLane,
3079						gesture: null,
3080						action: update.action,
3081						hasEagerState: update.hasEagerState,
3082						eagerState: update.eagerState,
3083						next: null
3084					}, null === newBaseQueueLast ? (newBaseQueueFirst = newBaseQueueLast = updateLane, baseFirst = pendingQueue) : newBaseQueueLast = newBaseQueueLast.next = updateLane, currentlyRenderingFiber.lanes |= revertLane, workInProgressRootSkippedLanes |= revertLane;
3085					updateLane = update.action;
3086					shouldDoubleInvokeUserFnsInHooksDEV && reducer(pendingQueue, updateLane);
3087					pendingQueue = update.hasEagerState ? update.eagerState : reducer(pendingQueue, updateLane);
3088				} else revertLane = {
3089					lane: updateLane,
3090					revertLane: update.revertLane,
3091					gesture: update.gesture,
3092					action: update.action,
3093					hasEagerState: update.hasEagerState,
3094					eagerState: update.eagerState,
3095					next: null
3096				}, null === newBaseQueueLast ? (newBaseQueueFirst = newBaseQueueLast = revertLane, baseFirst = pendingQueue) : newBaseQueueLast = newBaseQueueLast.next = revertLane, currentlyRenderingFiber.lanes |= updateLane, workInProgressRootSkippedLanes |= updateLane;
3097				update = update.next;
3098			} while (null !== update && update !== current);
3099			null === newBaseQueueLast ? baseFirst = pendingQueue : newBaseQueueLast.next = newBaseQueueFirst;
3100			if (!objectIs(pendingQueue, hook.memoizedState) && (didReceiveUpdate = !0, didReadFromEntangledAsyncAction$60 && (reducer = currentEntangledActionThenable, null !== reducer))) throw reducer;
3101			hook.memoizedState = pendingQueue;
3102			hook.baseState = baseFirst;
3103			hook.baseQueue = newBaseQueueLast;
3104			queue.lastRenderedState = pendingQueue;
3105		}
3106		null === baseQueue && (queue.lanes = 0);
3107		return [hook.memoizedState, queue.dispatch];
3108	}
3109	function rerenderReducer(reducer) {
3110		var hook = updateWorkInProgressHook(), queue = hook.queue;
3111		if (null === queue) throw Error(formatProdErrorMessage(311));
3112		queue.lastRenderedReducer = reducer;
3113		var dispatch = queue.dispatch, lastRenderPhaseUpdate = queue.pending, newState = hook.memoizedState;
3114		if (null !== lastRenderPhaseUpdate) {
3115			queue.pending = null;
3116			var update = lastRenderPhaseUpdate = lastRenderPhaseUpdate.next;
3117			do
3118				newState = reducer(newState, update.action), update = update.next;
3119			while (update !== lastRenderPhaseUpdate);
3120			objectIs(newState, hook.memoizedState) || (didReceiveUpdate = !0);
3121			hook.memoizedState = newState;
3122			null === hook.baseQueue && (hook.baseState = newState);
3123			queue.lastRenderedState = newState;
3124		}
3125		return [newState, dispatch];
3126	}
3127	function updateSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
3128		var fiber = currentlyRenderingFiber, hook = updateWorkInProgressHook(), isHydrating$jscomp$0 = isHydrating;
3129		if (isHydrating$jscomp$0) {
3130			if (void 0 === getServerSnapshot) throw Error(formatProdErrorMessage(407));
3131			getServerSnapshot = getServerSnapshot();
3132		} else getServerSnapshot = getSnapshot();
3133		var snapshotChanged = !objectIs((currentHook || hook).memoizedState, getServerSnapshot);
3134		snapshotChanged && (hook.memoizedState = getServerSnapshot, didReceiveUpdate = !0);
3135		hook = hook.queue;
3136		updateEffect(subscribeToStore.bind(null, fiber, hook, subscribe), [subscribe]);
3137		if (hook.getSnapshot !== getSnapshot || snapshotChanged || null !== workInProgressHook && workInProgressHook.memoizedState.tag & 1) {
3138			fiber.flags |= 2048;
3139			pushSimpleEffect(9, { destroy: void 0 }, updateStoreInstance.bind(null, fiber, hook, getServerSnapshot, getSnapshot), null);
3140			if (null === workInProgressRoot) throw Error(formatProdErrorMessage(349));
3141			isHydrating$jscomp$0 || 0 !== (renderLanes & 127) || pushStoreConsistencyCheck(fiber, getSnapshot, getServerSnapshot);
3142		}
3143		return getServerSnapshot;
3144	}
3145	function pushStoreConsistencyCheck(fiber, getSnapshot, renderedSnapshot) {
3146		fiber.flags |= 16384;
3147		fiber = {
3148			getSnapshot,
3149			value: renderedSnapshot
3150		};
3151		getSnapshot = currentlyRenderingFiber.updateQueue;
3152		null === getSnapshot ? (getSnapshot = createFunctionComponentUpdateQueue(), currentlyRenderingFiber.updateQueue = getSnapshot, getSnapshot.stores = [fiber]) : (renderedSnapshot = getSnapshot.stores, null === renderedSnapshot ? getSnapshot.stores = [fiber] : renderedSnapshot.push(fiber));
3153	}
3154	function updateStoreInstance(fiber, inst, nextSnapshot, getSnapshot) {
3155		inst.value = nextSnapshot;
3156		inst.getSnapshot = getSnapshot;
3157		checkIfSnapshotChanged(inst) && forceStoreRerender(fiber);
3158	}
3159	function subscribeToStore(fiber, inst, subscribe) {
3160		return subscribe(function() {
3161			checkIfSnapshotChanged(inst) && forceStoreRerender(fiber);
3162		});
3163	}
3164	function checkIfSnapshotChanged(inst) {
3165		var latestGetSnapshot = inst.getSnapshot;
3166		inst = inst.value;
3167		try {
3168			var nextValue = latestGetSnapshot();
3169			return !objectIs(inst, nextValue);
3170		} catch (error) {
3171			return !0;
3172		}
3173	}
3174	function forceStoreRerender(fiber) {
3175		var root = enqueueConcurrentRenderForLane(fiber, 2);
3176		null !== root && scheduleUpdateOnFiber(root, fiber, 2);
3177	}
3178	function mountStateImpl(initialState) {
3179		var hook = mountWorkInProgressHook();
3180		if ("function" === typeof initialState) {
3181			var initialStateInitializer = initialState;
3182			initialState = initialStateInitializer();
3183			if (shouldDoubleInvokeUserFnsInHooksDEV) {
3184				setIsStrictModeForDevtools(!0);
3185				try {
3186					initialStateInitializer();
3187				} finally {
3188					setIsStrictModeForDevtools(!1);
3189				}
3190			}
3191		}
3192		hook.memoizedState = hook.baseState = initialState;
3193		hook.queue = {
3194			pending: null,
3195			lanes: 0,
3196			dispatch: null,
3197			lastRenderedReducer: basicStateReducer,
3198			lastRenderedState: initialState
3199		};
3200		return hook;
3201	}
3202	function updateOptimisticImpl(hook, current, passthrough, reducer) {
3203		hook.baseState = passthrough;
3204		return updateReducerImpl(hook, currentHook, "function" === typeof reducer ? reducer : basicStateReducer);
3205	}
3206	function dispatchActionState(fiber, actionQueue, setPendingState, setState, payload) {
3207		if (isRenderPhaseUpdate(fiber)) throw Error(formatProdErrorMessage(485));
3208		fiber = actionQueue.action;
3209		if (null !== fiber) {
3210			var actionNode = {
3211				payload,
3212				action: fiber,
3213				next: null,
3214				isTransition: !0,
3215				status: "pending",
3216				value: null,
3217				reason: null,
3218				listeners: [],
3219				then: function(listener) {
3220					actionNode.listeners.push(listener);
3221				}
3222			};
3223			null !== ReactSharedInternals.T ? setPendingState(!0) : actionNode.isTransition = !1;
3224			setState(actionNode);
3225			setPendingState = actionQueue.pending;
3226			null === setPendingState ? (actionNode.next = actionQueue.pending = actionNode, runActionStateAction(actionQueue, actionNode)) : (actionNode.next = setPendingState.next, actionQueue.pending = setPendingState.next = actionNode);
3227		}
3228	}
3229	function runActionStateAction(actionQueue, node) {
3230		var action = node.action, payload = node.payload, prevState = actionQueue.state;
3231		if (node.isTransition) {
3232			var prevTransition = ReactSharedInternals.T, currentTransition = {};
3233			ReactSharedInternals.T = currentTransition;
3234			try {
3235				var returnValue = action(prevState, payload), onStartTransitionFinish = ReactSharedInternals.S;
3236				null !== onStartTransitionFinish && onStartTransitionFinish(currentTransition, returnValue);
3237				handleActionReturnValue(actionQueue, node, returnValue);
3238			} catch (error) {
3239				onActionError(actionQueue, node, error);
3240			} finally {
3241				null !== prevTransition && null !== currentTransition.types && (prevTransition.types = currentTransition.types), ReactSharedInternals.T = prevTransition;
3242			}
3243		} else try {
3244			prevTransition = action(prevState, payload), handleActionReturnValue(actionQueue, node, prevTransition);
3245		} catch (error$66) {
3246			onActionError(actionQueue, node, error$66);
3247		}
3248	}
3249	function handleActionReturnValue(actionQueue, node, returnValue) {
3250		null !== returnValue && "object" === typeof returnValue && "function" === typeof returnValue.then ? returnValue.then(function(nextState) {
3251			onActionSuccess(actionQueue, node, nextState);
3252		}, function(error) {
3253			return onActionError(actionQueue, node, error);
3254		}) : onActionSuccess(actionQueue, node, returnValue);
3255	}
3256	function onActionSuccess(actionQueue, actionNode, nextState) {
3257		actionNode.status = "fulfilled";
3258		actionNode.value = nextState;
3259		notifyActionListeners(actionNode);
3260		actionQueue.state = nextState;
3261		actionNode = actionQueue.pending;
3262		null !== actionNode && (nextState = actionNode.next, nextState === actionNode ? actionQueue.pending = null : (nextState = nextState.next, actionNode.next = nextState, runActionStateAction(actionQueue, nextState)));
3263	}
3264	function onActionError(actionQueue, actionNode, error) {
3265		var last = actionQueue.pending;
3266		actionQueue.pending = null;
3267		if (null !== last) {
3268			last = last.next;
3269			do
3270				actionNode.status = "rejected", actionNode.reason = error, notifyActionListeners(actionNode), actionNode = actionNode.next;
3271			while (actionNode !== last);
3272		}
3273		actionQueue.action = null;
3274	}
3275	function notifyActionListeners(actionNode) {
3276		actionNode = actionNode.listeners;
3277		for (var i = 0; i < actionNode.length; i++) (0, actionNode[i])();
3278	}
3279	function actionStateReducer(oldState, newState) {
3280		return newState;
3281	}
3282	function mountActionState(action, initialStateProp) {
3283		if (isHydrating) {
3284			var ssrFormState = workInProgressRoot.formState;
3285			if (null !== ssrFormState) {
3286				a: {
3287					var JSCompiler_inline_result = currentlyRenderingFiber;
3288					if (isHydrating) {
3289						if (nextHydratableInstance) {
3290							b: {
3291								var JSCompiler_inline_result$jscomp$0 = nextHydratableInstance;
3292								for (var inRootOrSingleton = rootOrSingletonContext; 8 !== JSCompiler_inline_result$jscomp$0.nodeType;) {
3293									if (!inRootOrSingleton) {
3294										JSCompiler_inline_result$jscomp$0 = null;
3295										break b;
3296									}
3297									JSCompiler_inline_result$jscomp$0 = getNextHydratable(JSCompiler_inline_result$jscomp$0.nextSibling);
3298									if (null === JSCompiler_inline_result$jscomp$0) {
3299										JSCompiler_inline_result$jscomp$0 = null;
3300										break b;
3301									}
3302								}
3303								inRootOrSingleton = JSCompiler_inline_result$jscomp$0.data;
3304								JSCompiler_inline_result$jscomp$0 = "F!" === inRootOrSingleton || "F" === inRootOrSingleton ? JSCompiler_inline_result$jscomp$0 : null;
3305							}
3306							if (JSCompiler_inline_result$jscomp$0) {
3307								nextHydratableInstance = getNextHydratable(JSCompiler_inline_result$jscomp$0.nextSibling);
3308								JSCompiler_inline_result = "F!" === JSCompiler_inline_result$jscomp$0.data;
3309								break a;
3310							}
3311						}
3312						throwOnHydrationMismatch(JSCompiler_inline_result);
3313					}
3314					JSCompiler_inline_result = !1;
3315				}
3316				JSCompiler_inline_result && (initialStateProp = ssrFormState[0]);
3317			}
3318		}
3319		ssrFormState = mountWorkInProgressHook();
3320		ssrFormState.memoizedState = ssrFormState.baseState = initialStateProp;
3321		JSCompiler_inline_result = {
3322			pending: null,
3323			lanes: 0,
3324			dispatch: null,
3325			lastRenderedReducer: actionStateReducer,
3326			lastRenderedState: initialStateProp
3327		};
3328		ssrFormState.queue = JSCompiler_inline_result;
3329		ssrFormState = dispatchSetState.bind(null, currentlyRenderingFiber, JSCompiler_inline_result);
3330		JSCompiler_inline_result.dispatch = ssrFormState;
3331		JSCompiler_inline_result = mountStateImpl(!1);
3332		inRootOrSingleton = dispatchOptimisticSetState.bind(null, currentlyRenderingFiber, !1, JSCompiler_inline_result.queue);
3333		JSCompiler_inline_result = mountWorkInProgressHook();
3334		JSCompiler_inline_result$jscomp$0 = {
3335			state: initialStateProp,
3336			dispatch: null,
3337			action,
3338			pending: null
3339		};
3340		JSCompiler_inline_result.queue = JSCompiler_inline_result$jscomp$0;
3341		ssrFormState = dispatchActionState.bind(null, currentlyRenderingFiber, JSCompiler_inline_result$jscomp$0, inRootOrSingleton, ssrFormState);
3342		JSCompiler_inline_result$jscomp$0.dispatch = ssrFormState;
3343		JSCompiler_inline_result.memoizedState = action;
3344		return [
3345			initialStateProp,
3346			ssrFormState,
3347			!1
3348		];
3349	}
3350	function updateActionState(action) {
3351		return updateActionStateImpl(updateWorkInProgressHook(), currentHook, action);
3352	}
3353	function updateActionStateImpl(stateHook, currentStateHook, action) {
3354		currentStateHook = updateReducerImpl(stateHook, currentStateHook, actionStateReducer)[0];
3355		stateHook = updateReducer(basicStateReducer)[0];
3356		if ("object" === typeof currentStateHook && null !== currentStateHook && "function" === typeof currentStateHook.then) try {
3357			var state = useThenable(currentStateHook);
3358		} catch (x) {
3359			if (x === SuspenseException) throw SuspenseActionException;
3360			throw x;
3361		}
3362		else state = currentStateHook;
3363		currentStateHook = updateWorkInProgressHook();
3364		var actionQueue = currentStateHook.queue, dispatch = actionQueue.dispatch;
3365		action !== currentStateHook.memoizedState && (currentlyRenderingFiber.flags |= 2048, pushSimpleEffect(9, { destroy: void 0 }, actionStateActionEffect.bind(null, actionQueue, action), null));
3366		return [
3367			state,
3368			dispatch,
3369			stateHook
3370		];
3371	}
3372	function actionStateActionEffect(actionQueue, action) {
3373		actionQueue.action = action;
3374	}
3375	function rerenderActionState(action) {
3376		var stateHook = updateWorkInProgressHook(), currentStateHook = currentHook;
3377		if (null !== currentStateHook) return updateActionStateImpl(stateHook, currentStateHook, action);
3378		updateWorkInProgressHook();
3379		stateHook = stateHook.memoizedState;
3380		currentStateHook = updateWorkInProgressHook();
3381		var dispatch = currentStateHook.queue.dispatch;
3382		currentStateHook.memoizedState = action;
3383		return [
3384			stateHook,
3385			dispatch,
3386			!1
3387		];
3388	}
3389	function pushSimpleEffect(tag, inst, create, deps) {
3390		tag = {
3391			tag,
3392			create,
3393			deps,
3394			inst,
3395			next: null
3396		};
3397		inst = currentlyRenderingFiber.updateQueue;
3398		null === inst && (inst = createFunctionComponentUpdateQueue(), currentlyRenderingFiber.updateQueue = inst);
3399		create = inst.lastEffect;
3400		null === create ? inst.lastEffect = tag.next = tag : (deps = create.next, create.next = tag, tag.next = deps, inst.lastEffect = tag);
3401		return tag;
3402	}
3403	function updateRef() {
3404		return updateWorkInProgressHook().memoizedState;
3405	}
3406	function mountEffectImpl(fiberFlags, hookFlags, create, deps) {
3407		var hook = mountWorkInProgressHook();
3408		currentlyRenderingFiber.flags |= fiberFlags;
3409		hook.memoizedState = pushSimpleEffect(1 | hookFlags, { destroy: void 0 }, create, void 0 === deps ? null : deps);
3410	}
3411	function updateEffectImpl(fiberFlags, hookFlags, create, deps) {
3412		var hook = updateWorkInProgressHook();
3413		deps = void 0 === deps ? null : deps;
3414		var inst = hook.memoizedState.inst;
3415		null !== currentHook && null !== deps && areHookInputsEqual(deps, currentHook.memoizedState.deps) ? hook.memoizedState = pushSimpleEffect(hookFlags, inst, create, deps) : (currentlyRenderingFiber.flags |= fiberFlags, hook.memoizedState = pushSimpleEffect(1 | hookFlags, inst, create, deps));
3416	}
3417	function mountEffect(create, deps) {
3418		mountEffectImpl(8390656, 8, create, deps);
3419	}
3420	function updateEffect(create, deps) {
3421		updateEffectImpl(2048, 8, create, deps);
3422	}
3423	function useEffectEventImpl(payload) {
3424		currentlyRenderingFiber.flags |= 4;
3425		var componentUpdateQueue = currentlyRenderingFiber.updateQueue;
3426		if (null === componentUpdateQueue) componentUpdateQueue = createFunctionComponentUpdateQueue(), currentlyRenderingFiber.updateQueue = componentUpdateQueue, componentUpdateQueue.events = [payload];
3427		else {
3428			var events = componentUpdateQueue.events;
3429			null === events ? componentUpdateQueue.events = [payload] : events.push(payload);
3430		}
3431	}
3432	function updateEvent(callback) {
3433		var ref = updateWorkInProgressHook().memoizedState;
3434		useEffectEventImpl({
3435			ref,
3436			nextImpl: callback
3437		});
3438		return function() {
3439			if (0 !== (executionContext & 2)) throw Error(formatProdErrorMessage(440));
3440			return ref.impl.apply(void 0, arguments);
3441		};
3442	}
3443	function updateInsertionEffect(create, deps) {
3444		return updateEffectImpl(4, 2, create, deps);
3445	}
3446	function updateLayoutEffect(create, deps) {
3447		return updateEffectImpl(4, 4, create, deps);
3448	}
3449	function imperativeHandleEffect(create, ref) {
3450		if ("function" === typeof ref) {
3451			create = create();
3452			var refCleanup = ref(create);
3453			return function() {
3454				"function" === typeof refCleanup ? refCleanup() : ref(null);
3455			};
3456		}
3457		if (null !== ref && void 0 !== ref) return create = create(), ref.current = create, function() {
3458			ref.current = null;
3459		};
3460	}
3461	function updateImperativeHandle(ref, create, deps) {
3462		deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
3463		updateEffectImpl(4, 4, imperativeHandleEffect.bind(null, create, ref), deps);
3464	}
3465	function mountDebugValue() {}
3466	function updateCallback(callback, deps) {
3467		var hook = updateWorkInProgressHook();
3468		deps = void 0 === deps ? null : deps;
3469		var prevState = hook.memoizedState;
3470		if (null !== deps && areHookInputsEqual(deps, prevState[1])) return prevState[0];
3471		hook.memoizedState = [callback, deps];
3472		return callback;
3473	}
3474	function updateMemo(nextCreate, deps) {
3475		var hook = updateWorkInProgressHook();
3476		deps = void 0 === deps ? null : deps;
3477		var prevState = hook.memoizedState;
3478		if (null !== deps && areHookInputsEqual(deps, prevState[1])) return prevState[0];
3479		prevState = nextCreate();
3480		if (shouldDoubleInvokeUserFnsInHooksDEV) {
3481			setIsStrictModeForDevtools(!0);
3482			try {
3483				nextCreate();
3484			} finally {
3485				setIsStrictModeForDevtools(!1);
3486			}
3487		}
3488		hook.memoizedState = [prevState, deps];
3489		return prevState;
3490	}
3491	function mountDeferredValueImpl(hook, value, initialValue) {
3492		if (void 0 === initialValue || 0 !== (renderLanes & 1073741824) && 0 === (workInProgressRootRenderLanes & 261930)) return hook.memoizedState = value;
3493		hook.memoizedState = initialValue;
3494		hook = requestDeferredLane();
3495		currentlyRenderingFiber.lanes |= hook;
3496		workInProgressRootSkippedLanes |= hook;
3497		return initialValue;
3498	}
3499	function updateDeferredValueImpl(hook, prevValue, value, initialValue) {
3500		if (objectIs(value, prevValue)) return value;
3501		if (null !== currentTreeHiddenStackCursor.current) return hook = mountDeferredValueImpl(hook, value, initialValue), objectIs(hook, prevValue) || (didReceiveUpdate = !0), hook;
3502		if (0 === (renderLanes & 42) || 0 !== (renderLanes & 1073741824) && 0 === (workInProgressRootRenderLanes & 261930)) return didReceiveUpdate = !0, hook.memoizedState = value;
3503		hook = requestDeferredLane();
3504		currentlyRenderingFiber.lanes |= hook;
3505		workInProgressRootSkippedLanes |= hook;
3506		return prevValue;
3507	}
3508	function startTransition(fiber, queue, pendingState, finishedState, callback) {
3509		var previousPriority = ReactDOMSharedInternals.p;
3510		ReactDOMSharedInternals.p = 0 !== previousPriority && 8 > previousPriority ? previousPriority : 8;
3511		var prevTransition = ReactSharedInternals.T, currentTransition = {};
3512		ReactSharedInternals.T = currentTransition;
3513		dispatchOptimisticSetState(fiber, !1, queue, pendingState);
3514		try {
3515			var returnValue = callback(), onStartTransitionFinish = ReactSharedInternals.S;
3516			null !== onStartTransitionFinish && onStartTransitionFinish(currentTransition, returnValue);
3517			if (null !== returnValue && "object" === typeof returnValue && "function" === typeof returnValue.then) dispatchSetStateInternal(fiber, queue, chainThenableValue(returnValue, finishedState), requestUpdateLane(fiber));
3518			else dispatchSetStateInternal(fiber, queue, finishedState, requestUpdateLane(fiber));
3519		} catch (error) {
3520			dispatchSetStateInternal(fiber, queue, {
3521				then: function() {},
3522				status: "rejected",
3523				reason: error
3524			}, requestUpdateLane());
3525		} finally {
3526			ReactDOMSharedInternals.p = previousPriority, null !== prevTransition && null !== currentTransition.types && (prevTransition.types = currentTransition.types), ReactSharedInternals.T = prevTransition;
3527		}
3528	}
3529	function noop() {}
3530	function startHostTransition(formFiber, pendingState, action, formData) {
3531		if (5 !== formFiber.tag) throw Error(formatProdErrorMessage(476));
3532		var queue = ensureFormComponentIsStateful(formFiber).queue;
3533		startTransition(formFiber, queue, pendingState, sharedNotPendingObject, null === action ? noop : function() {
3534			requestFormReset$1(formFiber);
3535			return action(formData);
3536		});
3537	}
3538	function ensureFormComponentIsStateful(formFiber) {
3539		var existingStateHook = formFiber.memoizedState;
3540		if (null !== existingStateHook) return existingStateHook;
3541		existingStateHook = {
3542			memoizedState: sharedNotPendingObject,
3543			baseState: sharedNotPendingObject,
3544			baseQueue: null,
3545			queue: {
3546				pending: null,
3547				lanes: 0,
3548				dispatch: null,
3549				lastRenderedReducer: basicStateReducer,
3550				lastRenderedState: sharedNotPendingObject
3551			},
3552			next: null
3553		};
3554		var initialResetState = {};
3555		existingStateHook.next = {
3556			memoizedState: initialResetState,
3557			baseState: initialResetState,
3558			baseQueue: null,
3559			queue: {
3560				pending: null,
3561				lanes: 0,
3562				dispatch: null,
3563				lastRenderedReducer: basicStateReducer,
3564				lastRenderedState: initialResetState
3565			},
3566			next: null
3567		};
3568		formFiber.memoizedState = existingStateHook;
3569		formFiber = formFiber.alternate;
3570		null !== formFiber && (formFiber.memoizedState = existingStateHook);
3571		return existingStateHook;
3572	}
3573	function requestFormReset$1(formFiber) {
3574		var stateHook = ensureFormComponentIsStateful(formFiber);
3575		null === stateHook.next && (stateHook = formFiber.alternate.memoizedState);
3576		dispatchSetStateInternal(formFiber, stateHook.next.queue, {}, requestUpdateLane());
3577	}
3578	function useHostTransitionStatus() {
3579		return readContext(HostTransitionContext);
3580	}
3581	function updateId() {
3582		return updateWorkInProgressHook().memoizedState;
3583	}
3584	function updateRefresh() {
3585		return updateWorkInProgressHook().memoizedState;
3586	}
3587	function refreshCache(fiber) {
3588		for (var provider = fiber.return; null !== provider;) {
3589			switch (provider.tag) {
3590				case 24:
3591				case 3:
3592					var lane = requestUpdateLane();
3593					fiber = createUpdate(lane);
3594					var root$69 = enqueueUpdate(provider, fiber, lane);
3595					null !== root$69 && (scheduleUpdateOnFiber(root$69, provider, lane), entangleTransitions(root$69, provider, lane));
3596					provider = { cache: createCache() };
3597					fiber.payload = provider;
3598					return;
3599			}
3600			provider = provider.return;
3601		}
3602	}
3603	function dispatchReducerAction(fiber, queue, action) {
3604		var lane = requestUpdateLane();
3605		action = {
3606			lane,
3607			revertLane: 0,
3608			gesture: null,
3609			action,
3610			hasEagerState: !1,
3611			eagerState: null,
3612			next: null
3613		};
3614		isRenderPhaseUpdate(fiber) ? enqueueRenderPhaseUpdate(queue, action) : (action = enqueueConcurrentHookUpdate(fiber, queue, action, lane), null !== action && (scheduleUpdateOnFiber(action, fiber, lane), entangleTransitionUpdate(action, queue, lane)));
3615	}
3616	function dispatchSetState(fiber, queue, action) {
3617		dispatchSetStateInternal(fiber, queue, action, requestUpdateLane());
3618	}
3619	function dispatchSetStateInternal(fiber, queue, action, lane) {
3620		var update = {
3621			lane,
3622			revertLane: 0,
3623			gesture: null,
3624			action,
3625			hasEagerState: !1,
3626			eagerState: null,
3627			next: null
3628		};
3629		if (isRenderPhaseUpdate(fiber)) enqueueRenderPhaseUpdate(queue, update);
3630		else {
3631			var alternate = fiber.alternate;
3632			if (0 === fiber.lanes && (null === alternate || 0 === alternate.lanes) && (alternate = queue.lastRenderedReducer, null !== alternate)) try {
3633				var currentState = queue.lastRenderedState, eagerState = alternate(currentState, action);
3634				update.hasEagerState = !0;
3635				update.eagerState = eagerState;
3636				if (objectIs(eagerState, currentState)) return enqueueUpdate$1(fiber, queue, update, 0), null === workInProgressRoot && finishQueueingConcurrentUpdates(), !1;
3637			} catch (error) {}