https://washywash.com/node_modules/.vite/deps/react-dom_client.js?v=42030f97

1import { t as __commonJSMin } from "/node_modules/.vite/deps/chunk-C-Qwzh9l.js?v=42030f97";
2import { t as require_react } from "/node_modules/.vite/deps/react.js?v=42030f97";
3import { t as require_react_dom } from "/node_modules/.vite/deps/react-dom.js?v=42030f97";
4//#region node_modules/scheduler/cjs/scheduler.development.js
5/**
6* @license React
7* scheduler.development.js
8*
9* Copyright (c) Meta Platforms, Inc. and affiliates.
10*
11* This source code is licensed under the MIT license found in the
12* LICENSE file in the root directory of this source tree.
13*/
14var require_scheduler_development = /* @__PURE__ */ __commonJSMin(((exports) => {
15	(function() {
16		function performWorkUntilDeadline() {
17			needsPaint = !1;
18			if (isMessageLoopRunning) {
19				var currentTime = exports.unstable_now();
20				startTime = currentTime;
21				var hasMoreWork = !0;
22				try {
23					a: {
24						isHostCallbackScheduled = !1;
25						isHostTimeoutScheduled && (isHostTimeoutScheduled = !1, localClearTimeout(taskTimeoutID), taskTimeoutID = -1);
26						isPerformingWork = !0;
27						var previousPriorityLevel = currentPriorityLevel;
28						try {
29							b: {
30								advanceTimers(currentTime);
31								for (currentTask = peek(taskQueue); null !== currentTask && !(currentTask.expirationTime > currentTime && shouldYieldToHost());) {
32									var callback = currentTask.callback;
33									if ("function" === typeof callback) {
34										currentTask.callback = null;
35										currentPriorityLevel = currentTask.priorityLevel;
36										var continuationCallback = callback(currentTask.expirationTime <= currentTime);
37										currentTime = exports.unstable_now();
38										if ("function" === typeof continuationCallback) {
39											currentTask.callback = continuationCallback;
40											advanceTimers(currentTime);
41											hasMoreWork = !0;
42											break b;
43										}
44										currentTask === peek(taskQueue) && pop(taskQueue);
45										advanceTimers(currentTime);
46									} else pop(taskQueue);
47									currentTask = peek(taskQueue);
48								}
49								if (null !== currentTask) hasMoreWork = !0;
50								else {
51									var firstTimer = peek(timerQueue);
52									null !== firstTimer && requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
53									hasMoreWork = !1;
54								}
55							}
56							break a;
57						} finally {
58							currentTask = null, currentPriorityLevel = previousPriorityLevel, isPerformingWork = !1;
59						}
60						hasMoreWork = void 0;
61					}
62				} finally {
63					hasMoreWork ? schedulePerformWorkUntilDeadline() : isMessageLoopRunning = !1;
64				}
65			}
66		}
67		function push(heap, node) {
68			var index = heap.length;
69			heap.push(node);
70			a: for (; 0 < index;) {
71				var parentIndex = index - 1 >>> 1, parent = heap[parentIndex];
72				if (0 < compare(parent, node)) heap[parentIndex] = node, heap[index] = parent, index = parentIndex;
73				else break a;
74			}
75		}
76		function peek(heap) {
77			return 0 === heap.length ? null : heap[0];
78		}
79		function pop(heap) {
80			if (0 === heap.length) return null;
81			var first = heap[0], last = heap.pop();
82			if (last !== first) {
83				heap[0] = last;
84				a: for (var index = 0, length = heap.length, halfLength = length >>> 1; index < halfLength;) {
85					var leftIndex = 2 * (index + 1) - 1, left = heap[leftIndex], rightIndex = leftIndex + 1, right = heap[rightIndex];
86					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);
87					else if (rightIndex < length && 0 > compare(right, last)) heap[index] = right, heap[rightIndex] = last, index = rightIndex;
88					else break a;
89				}
90			}
91			return first;
92		}
93		function compare(a, b) {
94			var diff = a.sortIndex - b.sortIndex;
95			return 0 !== diff ? diff : a.id - b.id;
96		}
97		function advanceTimers(currentTime) {
98			for (var timer = peek(timerQueue); null !== timer;) {
99				if (null === timer.callback) pop(timerQueue);
100				else if (timer.startTime <= currentTime) pop(timerQueue), timer.sortIndex = timer.expirationTime, push(taskQueue, timer);
101				else break;
102				timer = peek(timerQueue);
103			}
104		}
105		function handleTimeout(currentTime) {
106			isHostTimeoutScheduled = !1;
107			advanceTimers(currentTime);
108			if (!isHostCallbackScheduled) if (null !== peek(taskQueue)) isHostCallbackScheduled = !0, isMessageLoopRunning || (isMessageLoopRunning = !0, schedulePerformWorkUntilDeadline());
109			else {
110				var firstTimer = peek(timerQueue);
111				null !== firstTimer && requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
112			}
113		}
114		function shouldYieldToHost() {
115			return needsPaint ? !0 : exports.unstable_now() - startTime < frameInterval ? !1 : !0;
116		}
117		function requestHostTimeout(callback, ms) {
118			taskTimeoutID = localSetTimeout(function() {
119				callback(exports.unstable_now());
120			}, ms);
121		}
122		"undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
123		exports.unstable_now = void 0;
124		if ("object" === typeof performance && "function" === typeof performance.now) {
125			var localPerformance = performance;
126			exports.unstable_now = function() {
127				return localPerformance.now();
128			};
129		} else {
130			var localDate = Date, initialTime = localDate.now();
131			exports.unstable_now = function() {
132				return localDate.now() - initialTime;
133			};
134		}
135		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, isMessageLoopRunning = !1, taskTimeoutID = -1, frameInterval = 5, startTime = -1;
136		if ("function" === typeof localSetImmediate) var schedulePerformWorkUntilDeadline = function() {
137			localSetImmediate(performWorkUntilDeadline);
138		};
139		else if ("undefined" !== typeof MessageChannel) {
140			var channel = new MessageChannel(), port = channel.port2;
141			channel.port1.onmessage = performWorkUntilDeadline;
142			schedulePerformWorkUntilDeadline = function() {
143				port.postMessage(null);
144			};
145		} else schedulePerformWorkUntilDeadline = function() {
146			localSetTimeout(performWorkUntilDeadline, 0);
147		};
148		exports.unstable_IdlePriority = 5;
149		exports.unstable_ImmediatePriority = 1;
150		exports.unstable_LowPriority = 4;
151		exports.unstable_NormalPriority = 3;
152		exports.unstable_Profiling = null;
153		exports.unstable_UserBlockingPriority = 2;
154		exports.unstable_cancelCallback = function(task) {
155			task.callback = null;
156		};
157		exports.unstable_forceFrameRate = function(fps) {
158			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;
159		};
160		exports.unstable_getCurrentPriorityLevel = function() {
161			return currentPriorityLevel;
162		};
163		exports.unstable_next = function(eventHandler) {
164			switch (currentPriorityLevel) {
165				case 1:
166				case 2:
167				case 3:
168					var priorityLevel = 3;
169					break;
170				default: priorityLevel = currentPriorityLevel;
171			}
172			var previousPriorityLevel = currentPriorityLevel;
173			currentPriorityLevel = priorityLevel;
174			try {
175				return eventHandler();
176			} finally {
177				currentPriorityLevel = previousPriorityLevel;
178			}
179		};
180		exports.unstable_requestPaint = function() {
181			needsPaint = !0;
182		};
183		exports.unstable_runWithPriority = function(priorityLevel, eventHandler) {
184			switch (priorityLevel) {
185				case 1:
186				case 2:
187				case 3:

188				case 4:
189				case 5: break;
190				default: priorityLevel = 3;
191			}
192			var previousPriorityLevel = currentPriorityLevel;
193			currentPriorityLevel = priorityLevel;
194			try {
195				return eventHandler();
196			} finally {
197				currentPriorityLevel = previousPriorityLevel;
198			}
199		};
200		exports.unstable_scheduleCallback = function(priorityLevel, callback, options) {
201			var currentTime = exports.unstable_now();
202			"object" === typeof options && null !== options ? (options = options.delay, options = "number" === typeof options && 0 < options ? currentTime + options : currentTime) : options = currentTime;
203			switch (priorityLevel) {
204				case 1:
205					var timeout = -1;
206					break;
207				case 2:
208					timeout = 250;
209					break;
210				case 5:
211					timeout = 1073741823;
212					break;
213				case 4:
214					timeout = 1e4;
215					break;
216				default: timeout = 5e3;
217			}
218			timeout = options + timeout;
219			priorityLevel = {
220				id: taskIdCounter++,
221				callback,
222				priorityLevel,
223				startTime: options,
224				expirationTime: timeout,
225				sortIndex: -1
226			};
227			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())));
228			return priorityLevel;
229		};
230		exports.unstable_shouldYield = shouldYieldToHost;
231		exports.unstable_wrapCallback = function(callback) {
232			var parentPriorityLevel = currentPriorityLevel;
233			return function() {
234				var previousPriorityLevel = currentPriorityLevel;
235				currentPriorityLevel = parentPriorityLevel;
236				try {
237					return callback.apply(this, arguments);
238				} finally {
239					currentPriorityLevel = previousPriorityLevel;
240				}
241			};
242		};
243		"undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
244	})();
245}));
246//#endregion
247//#region node_modules/scheduler/index.js
248var require_scheduler = /* @__PURE__ */ __commonJSMin(((exports, module) => {
249	module.exports = require_scheduler_development();
250}));
251//#endregion
252//#region node_modules/react-dom/cjs/react-dom-client.development.js
253/**
254* @license React
255* react-dom-client.development.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_development = /* @__PURE__ */ __commonJSMin(((exports) => {
263	(function() {
264		function findHook(fiber, id) {
265			for (fiber = fiber.memoizedState; null !== fiber && 0 < id;) fiber = fiber.next, id--;
266			return fiber;
267		}
268		function copyWithSetImpl(obj, path, index, value) {
269			if (index >= path.length) return value;
270			var key = path[index], updated = isArrayImpl(obj) ? obj.slice() : assign({}, obj);
271			updated[key] = copyWithSetImpl(obj[key], path, index + 1, value);
272			return updated;
273		}
274		function copyWithRename(obj, oldPath, newPath) {
275			if (oldPath.length !== newPath.length) console.warn("copyWithRename() expects paths of the same length");
276			else {
277				for (var i = 0; i < newPath.length - 1; i++) if (oldPath[i] !== newPath[i]) {
278					console.warn("copyWithRename() expects paths to be the same except for the deepest key");
279					return;
280				}
281				return copyWithRenameImpl(obj, oldPath, newPath, 0);
282			}
283		}
284		function copyWithRenameImpl(obj, oldPath, newPath, index) {
285			var oldKey = oldPath[index], updated = isArrayImpl(obj) ? obj.slice() : assign({}, obj);
286			index + 1 === oldPath.length ? (updated[newPath[index]] = updated[oldKey], isArrayImpl(updated) ? updated.splice(oldKey, 1) : delete updated[oldKey]) : updated[oldKey] = copyWithRenameImpl(obj[oldKey], oldPath, newPath, index + 1);
287			return updated;
288		}
289		function copyWithDeleteImpl(obj, path, index) {
290			var key = path[index], updated = isArrayImpl(obj) ? obj.slice() : assign({}, obj);
291			if (index + 1 === path.length) return isArrayImpl(updated) ? updated.splice(key, 1) : delete updated[key], updated;
292			updated[key] = copyWithDeleteImpl(obj[key], path, index + 1);
293			return updated;
294		}
295		function shouldSuspendImpl() {
296			return !1;
297		}
298		function shouldErrorImpl() {
299			return null;
300		}

301		function warnInvalidHookAccess() {
302			console.error("Do not call Hooks inside useEffect(...), useMemo(...), or other built-in Hooks. You can only call Hooks at the top level of your React function. For more information, see https://react.dev/link/rules-of-hooks");
303		}
304		function warnInvalidContextAccess() {
305			console.error("Context can only be read while React is rendering. In classes, you can read it in the render method or getDerivedStateFromProps. In function components, you can read it directly in the function body, but not inside Hooks like useReducer() or useMemo().");
306		}
307		function noop() {}
308		function warnForMissingKey() {}
309		function setToSortedString(set) {
310			var array = [];
311			set.forEach(function(value) {
312				array.push(value);
313			});
314			return array.sort().join(", ");
315		}
316		function createFiber(tag, pendingProps, key, mode) {
317			return new FiberNode(tag, pendingProps, key, mode);
318		}
319		function scheduleRoot(root, element) {
320			root.context === emptyContextObject && (updateContainerImpl(root.current, 2, element, root, null, null), flushSyncWork$1());
321		}
322		function scheduleRefresh(root, update) {
323			if (null !== resolveFamily) {
324				var staleFamilies = update.staleFamilies;
325				update = update.updatedFamilies;
326				flushPendingEffects();
327				scheduleFibersWithFamiliesRecursively(root.current, update, staleFamilies);
328				flushSyncWork$1();
329			}
330		}
331		function setRefreshHandler(handler) {
332			resolveFamily = handler;
333		}
334		function isValidContainer(node) {
335			return !(!node || 1 !== node.nodeType && 9 !== node.nodeType && 11 !== node.nodeType);
336		}
337		function getNearestMountedFiber(fiber) {
338			var node = fiber, nearestMounted = fiber;
339			if (fiber.alternate) for (; node.return;) node = node.return;
340			else {
341				fiber = node;
342				do
343					node = fiber, 0 !== (node.flags & 4098) && (nearestMounted = node.return), fiber = node.return;
344				while (fiber);
345			}
346			return 3 === node.tag ? nearestMounted : null;
347		}
348		function getSuspenseInstanceFromFiber(fiber) {
349			if (13 === fiber.tag) {
350				var suspenseState = fiber.memoizedState;
351				null === suspenseState && (fiber = fiber.alternate, null !== fiber && (suspenseState = fiber.memoizedState));
352				if (null !== suspenseState) return suspenseState.dehydrated;
353			}
354			return null;
355		}
356		function getActivityInstanceFromFiber(fiber) {
357			if (31 === fiber.tag) {
358				var activityState = fiber.memoizedState;
359				null === activityState && (fiber = fiber.alternate, null !== fiber && (activityState = fiber.memoizedState));
360				if (null !== activityState) return activityState.dehydrated;
361			}
362			return null;
363		}
364		function assertIsMounted(fiber) {
365			if (getNearestMountedFiber(fiber) !== fiber) throw Error("Unable to find node on an unmounted component.");
366		}
367		function findCurrentFiberUsingSlowPath(fiber) {
368			var alternate = fiber.alternate;
369			if (!alternate) {
370				alternate = getNearestMountedFiber(fiber);
371				if (null === alternate) throw Error("Unable to find node on an unmounted component.");
372				return alternate !== fiber ? null : fiber;
373			}
374			for (var a = fiber, b = alternate;;) {
375				var parentA = a.return;
376				if (null === parentA) break;
377				var parentB = parentA.alternate;
378				if (null === parentB) {
379					b = parentA.return;
380					if (null !== b) {
381						a = b;
382						continue;
383					}
384					break;
385				}
386				if (parentA.child === parentB.child) {
387					for (parentB = parentA.child; parentB;) {
388						if (parentB === a) return assertIsMounted(parentA), fiber;
389						if (parentB === b) return assertIsMounted(parentA), alternate;
390						parentB = parentB.sibling;
391					}
392					throw Error("Unable to find node on an unmounted component.");
393				}
394				if (a.return !== b.return) a = parentA, b = parentB;
395				else {
396					for (var didFindChild = !1, _child = parentA.child; _child;) {
397						if (_child === a) {
398							didFindChild = !0;
399							a = parentA;
400							b = parentB;
401							break;
402						}
403						if (_child === b) {
404							didFindChild = !0;
405							b = parentA;
406							a = parentB;
407							break;
408						}
409						_child = _child.sibling;
410					}
411					if (!didFindChild) {
412						for (_child = parentB.child; _child;) {
413							if (_child === a) {
414								didFindChild = !0;
415								a = parentB;
416								b = parentA;
417								break;
418							}
419							if (_child === b) {
420								didFindChild = !0;
421								b = parentB;
422								a = parentA;
423								break;
424							}
425							_child = _child.sibling;
426						}
427						if (!didFindChild) throw Error("Child was not found in either parent set. This indicates a bug in React related to the return pointer. Please file an issue.");
428					}
429				}
430				if (a.alternate !== b) throw Error("Return fibers should always be each others' alternates. This error is likely caused by a bug in React. Please file an issue.");
431			}
432			if (3 !== a.tag) throw Error("Unable to find node on an unmounted component.");
433			return a.stateNode.current === a ? fiber : alternate;
434		}
435		function findCurrentHostFiberImpl(node) {
436			var tag = node.tag;
437			if (5 === tag || 26 === tag || 27 === tag || 6 === tag) return node;
438			for (node = node.child; null !== node;) {
439				tag = findCurrentHostFiberImpl(node);
440				if (null !== tag) return tag;
441				node = node.sibling;
442			}
443			return null;
444		}
445		function getIteratorFn(maybeIterable) {
446			if (null === maybeIterable || "object" !== typeof maybeIterable) return null;
447			maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
448			return "function" === typeof maybeIterable ? maybeIterable : null;
449		}
450		function getComponentNameFromType(type) {
451			if (null == type) return null;
452			if ("function" === typeof type) return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
453			if ("string" === typeof type) return type;
454			switch (type) {
455				case REACT_FRAGMENT_TYPE: return "Fragment";
456				case REACT_PROFILER_TYPE: return "Profiler";
457				case REACT_STRICT_MODE_TYPE: return "StrictMode";
458				case REACT_SUSPENSE_TYPE: return "Suspense";
459				case REACT_SUSPENSE_LIST_TYPE: return "SuspenseList";
460				case REACT_ACTIVITY_TYPE: return "Activity";
461			}
462			if ("object" === typeof type) switch ("number" === typeof type.tag && console.error("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), type.$$typeof) {
463				case REACT_PORTAL_TYPE: return "Portal";
464				case REACT_CONTEXT_TYPE: return type.displayName || "Context";
465				case REACT_CONSUMER_TYPE: return (type._context.displayName || "Context") + ".Consumer";
466				case REACT_FORWARD_REF_TYPE:
467					var innerType = type.render;
468					type = type.displayName;
469					type || (type = innerType.displayName || innerType.name || "", type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef");
470					return type;
471				case REACT_MEMO_TYPE: return innerType = type.displayName || null, null !== innerType ? innerType : getComponentNameFromType(type.type) || "Memo";
472				case REACT_LAZY_TYPE:
473					innerType = type._payload;
474					type = type._init;
475					try {
476						return getComponentNameFromType(type(innerType));
477					} catch (x) {}
478			}
479			return null;
480		}
481		function getComponentNameFromOwner(owner) {
482			return "number" === typeof owner.tag ? getComponentNameFromFiber(owner) : "string" === typeof owner.name ? owner.name : null;
483		}
484		function getComponentNameFromFiber(fiber) {
485			var type = fiber.type;
486			switch (fiber.tag) {
487				case 31: return "Activity";
488				case 24: return "Cache";
489				case 9: return (type._context.displayName || "Context") + ".Consumer";
490				case 10: return type.displayName || "Context";
491				case 18: return "DehydratedFragment";
492				case 11: return fiber = type.render, fiber = fiber.displayName || fiber.name || "", type.displayName || ("" !== fiber ? "ForwardRef(" + fiber + ")" : "ForwardRef");
493				case 7: return "Fragment";
494				case 26:
495				case 27:
496				case 5: return type;
497				case 4: return "Portal";
498				case 3: return "Root";
499				case 6: return "Text";
500				case 16: return getComponentNameFromType(type);
501				case 8: return type === REACT_STRICT_MODE_TYPE ? "StrictMode" : "Mode";
502				case 22: return "Offscreen";
503				case 12: return "Profiler";
504				case 21: return "Scope";
505				case 13: return "Suspense";
506				case 19: return "SuspenseList";
507				case 25: return "TracingMarker";
508				case 1:
509				case 0:
510				case 14:
511				case 15:
512					if ("function" === typeof type) return type.displayName || type.name || null;
513					if ("string" === typeof type) return type;
514					break;
515				case 29:
516					type = fiber._debugInfo;
517					if (null != type) {
518						for (var i = type.length - 1; 0 <= i; i--) if ("string" === typeof type[i].name) return type[i].name;
519					}
520					if (null !== fiber.return) return getComponentNameFromFiber(fiber.return);
521			}
522			return null;
523		}
524		function createCursor(defaultValue) {
525			return { current: defaultValue };
526		}
527		function pop(cursor, fiber) {
528			0 > index$jscomp$0 ? console.error("Unexpected pop.") : (fiber !== fiberStack[index$jscomp$0] && console.error("Unexpected Fiber popped."), cursor.current = valueStack[index$jscomp$0], valueStack[index$jscomp$0] = null, fiberStack[index$jscomp$0] = null, index$jscomp$0--);
529		}
530		function push(cursor, value, fiber) {
531			index$jscomp$0++;
532			valueStack[index$jscomp$0] = cursor.current;
533			fiberStack[index$jscomp$0] = fiber;
534			cursor.current = value;
535		}
536		function requiredContext(c) {
537			null === c && console.error("Expected host context to exist. This error is likely caused by a bug in React. Please file an issue.");
538			return c;
539		}
540		function pushHostContainer(fiber, nextRootInstance) {
541			push(rootInstanceStackCursor, nextRootInstance, fiber);
542			push(contextFiberStackCursor, fiber, fiber);
543			push(contextStackCursor, null, fiber);
544			var nextRootContext = nextRootInstance.nodeType;
545			switch (nextRootContext) {
546				case 9:
547				case 11:
548					nextRootContext = 9 === nextRootContext ? "#document" : "#fragment";
549					nextRootInstance = (nextRootInstance = nextRootInstance.documentElement) ? (nextRootInstance = nextRootInstance.namespaceURI) ? getOwnHostContext(nextRootInstance) : HostContextNamespaceNone : HostContextNamespaceNone;
550					break;
551				default: if (nextRootContext = nextRootInstance.tagName, nextRootInstance = nextRootInstance.namespaceURI) nextRootInstance = getOwnHostContext(nextRootInstance), nextRootInstance = getChildHostContextProd(nextRootInstance, nextRootContext);
552				else switch (nextRootContext) {
553					case "svg":
554						nextRootInstance = HostContextNamespaceSvg;
555						break;
556					case "math":
557						nextRootInstance = HostContextNamespaceMath;
558						break;
559					default: nextRootInstance = HostContextNamespaceNone;
560				}
561			}
562			nextRootContext = nextRootContext.toLowerCase();
563			nextRootContext = updatedAncestorInfoDev(null, nextRootContext);
564			nextRootContext = {
565				context: nextRootInstance,
566				ancestorInfo: nextRootContext
567			};
568			pop(contextStackCursor, fiber);
569			push(contextStackCursor, nextRootContext, fiber);
570		}
571		function popHostContainer(fiber) {
572			pop(contextStackCursor, fiber);
573			pop(contextFiberStackCursor, fiber);
574			pop(rootInstanceStackCursor, fiber);
575		}
576		function getHostContext() {
577			return requiredContext(contextStackCursor.current);
578		}
579		function pushHostContext(fiber) {
580			null !== fiber.memoizedState && push(hostTransitionProviderCursor, fiber, fiber);
581			var context = requiredContext(contextStackCursor.current);
582			var type = fiber.type;
583			var nextContext = getChildHostContextProd(context.context, type);
584			type = updatedAncestorInfoDev(context.ancestorInfo, type);
585			nextContext = {
586				context: nextContext,
587				ancestorInfo: type
588			};
589			context !== nextContext && (push(contextFiberStackCursor, fiber, fiber), push(contextStackCursor, nextContext, fiber));
590		}
591		function popHostContext(fiber) {
592			contextFiberStackCursor.current === fiber && (pop(contextStackCursor, fiber), pop(contextFiberStackCursor, fiber));
593			hostTransitionProviderCursor.current === fiber && (pop(hostTransitionProviderCursor, fiber), HostTransitionContext._currentValue = NotPendingTransition);
594		}
595		function disabledLog() {}
596		function disableLogs() {
597			if (0 === disabledDepth) {
598				prevLog = console.log;
599				prevInfo = console.info;
600				prevWarn = console.warn;
601				prevError = console.error;
602				prevGroup = console.group;
603				prevGroupCollapsed = console.groupCollapsed;
604				prevGroupEnd = console.groupEnd;
605				var props = {
606					configurable: !0,
607					enumerable: !0,
608					value: disabledLog,
609					writable: !0
610				};
611				Object.defineProperties(console, {
612					info: props,
613					log: props,
614					warn: props,
615					error: props,
616					group: props,
617					groupCollapsed: props,
618					groupEnd: props
619				});
620			}
621			disabledDepth++;
622		}
623		function reenableLogs() {
624			disabledDepth--;
625			if (0 === disabledDepth) {
626				var props = {
627					configurable: !0,
628					enumerable: !0,
629					writable: !0
630				};
631				Object.defineProperties(console, {
632					log: assign({}, props, { value: prevLog }),
633					info: assign({}, props, { value: prevInfo }),
634					warn: assign({}, props, { value: prevWarn }),
635					error: assign({}, props, { value: prevError }),
636					group: assign({}, props, { value: prevGroup }),
637					groupCollapsed: assign({}, props, { value: prevGroupCollapsed }),
638					groupEnd: assign({}, props, { value: prevGroupEnd })
639				});
640			}
641			0 > disabledDepth && console.error("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
642		}
643		function formatOwnerStack(error) {
644			var prevPrepareStackTrace = Error.prepareStackTrace;
645			Error.prepareStackTrace = void 0;
646			error = error.stack;
647			Error.prepareStackTrace = prevPrepareStackTrace;
648			error.startsWith("Error: react-stack-top-frame\n") && (error = error.slice(29));
649			prevPrepareStackTrace = error.indexOf("\n");
650			-1 !== prevPrepareStackTrace && (error = error.slice(prevPrepareStackTrace + 1));
651			prevPrepareStackTrace = error.indexOf("react_stack_bottom_frame");
652			-1 !== prevPrepareStackTrace && (prevPrepareStackTrace = error.lastIndexOf("\n", prevPrepareStackTrace));
653			if (-1 !== prevPrepareStackTrace) error = error.slice(0, prevPrepareStackTrace);
654			else return "";
655			return error;
656		}
657		function describeBuiltInComponentFrame(name) {
658			if (void 0 === prefix) try {
659				throw Error();
660			} catch (x) {
661				var match = x.stack.trim().match(/\n( *(at )?)/);
662				prefix = match && match[1] || "";
663				suffix = -1 < x.stack.indexOf("\n    at") ? " (<anonymous>)" : -1 < x.stack.indexOf("@") ? "@unknown:0:0" : "";
664			}
665			return "\n" + prefix + name + suffix;
666		}
667		function describeNativeComponentFrame(fn, construct) {
668			if (!fn || reentry) return "";
669			var frame = componentFrameCache.get(fn);
670			if (void 0 !== frame) return frame;
671			reentry = !0;
672			frame = Error.prepareStackTrace;
673			Error.prepareStackTrace = void 0;
674			var previousDispatcher = null;
675			previousDispatcher = ReactSharedInternals.H;
676			ReactSharedInternals.H = null;
677			disableLogs();
678			try {
679				var RunInRootFrame = { DetermineComponentFrameRoot: function() {
680					try {
681						if (construct) {
682							var Fake = function() {
683								throw Error();
684							};
685							Object.defineProperty(Fake.prototype, "props", { set: function() {
686								throw Error();
687							} });
688							if ("object" === typeof Reflect && Reflect.construct) {
689								try {
690									Reflect.construct(Fake, []);
691								} catch (x) {
692									var control = x;
693								}
694								Reflect.construct(fn, [], Fake);
695							} else {
696								try {
697									Fake.call();
698								} catch (x$0) {
699									control = x$0;
700								}
701								fn.call(Fake.prototype);
702							}
703						} else {
704							try {
705								throw Error();
706							} catch (x$1) {
707								control = x$1;
708							}
709							(Fake = fn()) && "function" === typeof Fake.catch && Fake.catch(function() {});
710						}
711					} catch (sample) {
712						if (sample && control && "string" === typeof sample.stack) return [sample.stack, control.stack];
713					}
714					return [null, null];
715				} };
716				RunInRootFrame.DetermineComponentFrameRoot.displayName = "DetermineComponentFrameRoot";
717				var namePropDescriptor = Object.getOwnPropertyDescriptor(RunInRootFrame.DetermineComponentFrameRoot, "name");
718				namePropDescriptor && namePropDescriptor.configurable && Object.defineProperty(RunInRootFrame.DetermineComponentFrameRoot, "name", { value: "DetermineComponentFrameRoot" });
719				var _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(), sampleStack = _RunInRootFrame$Deter[0], controlStack = _RunInRootFrame$Deter[1];
720				if (sampleStack && controlStack) {
721					var sampleLines = sampleStack.split("\n"), controlLines = controlStack.split("\n");
722					for (_RunInRootFrame$Deter = namePropDescriptor = 0; namePropDescriptor < sampleLines.length && !sampleLines[namePropDescriptor].includes("DetermineComponentFrameRoot");) namePropDescriptor++;
723					for (; _RunInRootFrame$Deter < controlLines.length && !controlLines[_RunInRootFrame$Deter].includes("DetermineComponentFrameRoot");) _RunInRootFrame$Deter++;
724					if (namePropDescriptor === sampleLines.length || _RunInRootFrame$Deter === controlLines.length) for (namePropDescriptor = sampleLines.length - 1, _RunInRootFrame$Deter = controlLines.length - 1; 1 <= namePropDescriptor && 0 <= _RunInRootFrame$Deter && sampleLines[namePropDescriptor] !== controlLines[_RunInRootFrame$Deter];) _RunInRootFrame$Deter--;
725					for (; 1 <= namePropDescriptor && 0 <= _RunInRootFrame$Deter; namePropDescriptor--, _RunInRootFrame$Deter--) if (sampleLines[namePropDescriptor] !== controlLines[_RunInRootFrame$Deter]) {
726						if (1 !== namePropDescriptor || 1 !== _RunInRootFrame$Deter) do
727							if (namePropDescriptor--, _RunInRootFrame$Deter--, 0 > _RunInRootFrame$Deter || sampleLines[namePropDescriptor] !== controlLines[_RunInRootFrame$Deter]) {
728								var _frame = "\n" + sampleLines[namePropDescriptor].replace(" at new ", " at ");
729								fn.displayName && _frame.includes("<anonymous>") && (_frame = _frame.replace("<anonymous>", fn.displayName));
730								"function" === typeof fn && componentFrameCache.set(fn, _frame);
731								return _frame;
732							}
733						while (1 <= namePropDescriptor && 0 <= _RunInRootFrame$Deter);
734						break;
735					}
736				}
737			} finally {
738				reentry = !1, ReactSharedInternals.H = previousDispatcher, reenableLogs(), Error.prepareStackTrace = frame;
739			}
740			sampleLines = (sampleLines = fn ? fn.displayName || fn.name : "") ? describeBuiltInComponentFrame(sampleLines) : "";
741			"function" === typeof fn && componentFrameCache.set(fn, sampleLines);
742			return sampleLines;
743		}
744		function describeFiber(fiber, childFiber) {
745			switch (fiber.tag) {
746				case 26:
747				case 27:
748				case 5: return describeBuiltInComponentFrame(fiber.type);
749				case 16: return describeBuiltInComponentFrame("Lazy");
750				case 13: return fiber.child !== childFiber && null !== childFiber ? describeBuiltInComponentFrame("Suspense Fallback") : describeBuiltInComponentFrame("Suspense");
751				case 19: return describeBuiltInComponentFrame("SuspenseList");
752				case 0:
753				case 15: return describeNativeComponentFrame(fiber.type, !1);
754				case 11: return describeNativeComponentFrame(fiber.type.render, !1);
755				case 1: return describeNativeComponentFrame(fiber.type, !0);
756				case 31: return describeBuiltInComponentFrame("Activity");
757				default: return "";
758			}
759		}
760		function getStackByFiberInDevAndProd(workInProgress) {
761			try {
762				var info = "", previous = null;
763				do {
764					info += describeFiber(workInProgress, previous);
765					var debugInfo = workInProgress._debugInfo;
766					if (debugInfo) for (var i = debugInfo.length - 1; 0 <= i; i--) {
767						var entry = debugInfo[i];
768						if ("string" === typeof entry.name) {
769							var JSCompiler_temp_const = info;
770							a: {
771								var name = entry.name, env = entry.env, location = entry.debugLocation;
772								if (null != location) {
773									var childStack = formatOwnerStack(location), idx = childStack.lastIndexOf("\n"), lastLine = -1 === idx ? childStack : childStack.slice(idx + 1);
774									if (-1 !== lastLine.indexOf(name)) {
775										var JSCompiler_inline_result = "\n" + lastLine;
776										break a;
777									}
778								}
779								JSCompiler_inline_result = describeBuiltInComponentFrame(name + (env ? " [" + env + "]" : ""));
780							}
781							info = JSCompiler_temp_const + JSCompiler_inline_result;
782						}
783					}
784					previous = workInProgress;
785					workInProgress = workInProgress.return;
786				} while (workInProgress);
787				return info;
788			} catch (x) {
789				return "\nError generating stack: " + x.message + "\n" + x.stack;
790			}
791		}
792		function describeFunctionComponentFrameWithoutLineNumber(fn) {
793			return (fn = fn ? fn.displayName || fn.name : "") ? describeBuiltInComponentFrame(fn) : "";
794		}
795		function getCurrentFiberOwnerNameInDevOrNull() {
796			if (null === current) return null;
797			var owner = current._debugOwner;
798			return null != owner ? getComponentNameFromOwner(owner) : null;
799		}
800		function getCurrentFiberStackInDev() {
801			if (null === current) return "";
802			var workInProgress = current;
803			try {
804				var info = "";
805				6 === workInProgress.tag && (workInProgress = workInProgress.return);
806				switch (workInProgress.tag) {
807					case 26:
808					case 27:
809					case 5:
810						info += describeBuiltInComponentFrame(workInProgress.type);
811						break;
812					case 13:
813						info += describeBuiltInComponentFrame("Suspense");
814						break;
815					case 19:
816						info += describeBuiltInComponentFrame("SuspenseList");
817						break;
818					case 31:
819						info += describeBuiltInComponentFrame("Activity");
820						break;
821					case 30:
822					case 0:
823					case 15:
824					case 1:
825						workInProgress._debugOwner || "" !== info || (info += describeFunctionComponentFrameWithoutLineNumber(workInProgress.type));
826						break;
827					case 11: workInProgress._debugOwner || "" !== info || (info += describeFunctionComponentFrameWithoutLineNumber(workInProgress.type.render));
828				}
829				for (; workInProgress;) if ("number" === typeof workInProgress.tag) {
830					var fiber = workInProgress;
831					workInProgress = fiber._debugOwner;
832					var debugStack = fiber._debugStack;
833					if (workInProgress && debugStack) {
834						var formattedStack = formatOwnerStack(debugStack);
835						"" !== formattedStack && (info += "\n" + formattedStack);
836					}
837				} else if (null != workInProgress.debugStack) {
838					var ownerStack = workInProgress.debugStack;
839					(workInProgress = workInProgress.owner) && ownerStack && (info += "\n" + formatOwnerStack(ownerStack));
840				} else break;
841				var JSCompiler_inline_result = info;
842			} catch (x) {
843				JSCompiler_inline_result = "\nError generating stack: " + x.message + "\n" + x.stack;
844			}
845			return JSCompiler_inline_result;
846		}
847		function runWithFiberInDEV(fiber, callback, arg0, arg1, arg2, arg3, arg4) {
848			var previousFiber = current;
849			setCurrentFiber(fiber);
850			try {
851				return null !== fiber && fiber._debugTask ? fiber._debugTask.run(callback.bind(null, arg0, arg1, arg2, arg3, arg4)) : callback(arg0, arg1, arg2, arg3, arg4);
852			} finally {
853				setCurrentFiber(previousFiber);
854			}
855			throw Error("runWithFiberInDEV should never be called in production. This is a bug in React.");
856		}
857		function setCurrentFiber(fiber) {
858			ReactSharedInternals.getCurrentStack = null === fiber ? null : getCurrentFiberStackInDev;
859			isRendering = !1;
860			current = fiber;
861		}
862		function typeName(value) {
863			return "function" === typeof Symbol && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
864		}
865		function willCoercionThrow(value) {
866			try {
867				return testStringCoercion(value), !1;
868			} catch (e) {
869				return !0;
870			}
871		}
872		function testStringCoercion(value) {
873			return "" + value;
874		}
875		function checkAttributeStringCoercion(value, attributeName) {
876			if (willCoercionThrow(value)) return console.error("The provided `%s` attribute is an unsupported type %s. This value must be coerced to a string before using it here.", attributeName, typeName(value)), testStringCoercion(value);
877		}
878		function checkCSSPropertyStringCoercion(value, propName) {
879			if (willCoercionThrow(value)) return console.error("The provided `%s` CSS property is an unsupported type %s. This value must be coerced to a string before using it here.", propName, typeName(value)), testStringCoercion(value);
880		}
881		function checkFormFieldValueStringCoercion(value) {
882			if (willCoercionThrow(value)) return console.error("Form field values (value, checked, defaultValue, or defaultChecked props) must be strings, not %s. This value must be coerced to a string before using it here.", typeName(value)), testStringCoercion(value);
883		}
884		function injectInternals(internals) {
885			if ("undefined" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__) return !1;
886			var hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
887			if (hook.isDisabled) return !0;
888			if (!hook.supportsFiber) return console.error("The installed version of React DevTools is too old and will not work with the current version of React. Please update React DevTools. https://react.dev/link/react-devtools"), !0;
889			try {
890				rendererID = hook.inject(internals), injectedHook = hook;
891			} catch (err) {
892				console.error("React instrumentation encountered an error: %o.", err);
893			}
894			return hook.checkDCE ? !0 : !1;
895		}
896		function setIsStrictModeForDevtools(newIsStrictMode) {
897			"function" === typeof log$1 && unstable_setDisableYieldValue(newIsStrictMode);
898			if (injectedHook && "function" === typeof injectedHook.setStrictMode) try {
899				injectedHook.setStrictMode(rendererID, newIsStrictMode);
900			} catch (err) {
901				hasLoggedError || (hasLoggedError = !0, console.error("React instrumentation encountered an error: %o", err));
902			}
903		}
904		function clz32Fallback(x) {
905			x >>>= 0;
906			return 0 === x ? 32 : 31 - (log(x) / LN2 | 0) | 0;
907		}
908		function getHighestPriorityLanes(lanes) {
909			var pendingSyncLanes = lanes & 42;

910			if (0 !== pendingSyncLanes) return pendingSyncLanes;
911			switch (lanes & -lanes) {
912				case 1: return 1;
913				case 2: return 2;
914				case 4: return 4;
915				case 8: return 8;
916				case 16: return 16;
917				case 32: return 32;
918				case 64: return 64;
919				case 128: return 128;
920				case 256:
921				case 512:
922				case 1024:
923				case 2048:
924				case 4096:
925				case 8192:
926				case 16384:
927				case 32768:
928				case 65536:
929				case 131072: return lanes & 261888;
930				case 262144:
931				case 524288:
932				case 1048576:
933				case 2097152: return lanes & 3932160;
934				case 4194304:
935				case 8388608:
936				case 16777216:
937				case 33554432: return lanes & 62914560;
938				case 67108864: return 67108864;
939				case 134217728: return 134217728;
940				case 268435456: return 268435456;
941				case 536870912: return 536870912;
942				case 1073741824: return 0;
943				default: return console.error("Should have found matching lanes. This is a bug in React."), lanes;
944			}
945		}
946		function getNextLanes(root, wipLanes, rootHasPendingCommit) {
947			var pendingLanes = root.pendingLanes;
948			if (0 === pendingLanes) return 0;
949			var nextLanes = 0, suspendedLanes = root.suspendedLanes, pingedLanes = root.pingedLanes;
950			root = root.warmLanes;
951			var nonIdlePendingLanes = pendingLanes & 134217727;
952			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))));
953			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;
954		}
955		function checkIfRootIsPrerendering(root, renderLanes) {
956			return 0 === (root.pendingLanes & ~(root.suspendedLanes & ~root.pingedLanes) & renderLanes);
957		}
958		function computeExpirationTime(lane, currentTime) {
959			switch (lane) {
960				case 1:
961				case 2:
962				case 4:
963				case 8:
964				case 64: return currentTime + 250;
965				case 16:
966				case 32:
967				case 128:
968				case 256:
969				case 512:
970				case 1024:
971				case 2048:
972				case 4096:
973				case 8192:
974				case 16384:
975				case 32768:
976				case 65536:
977				case 131072:
978				case 262144:
979				case 524288:
980				case 1048576:
981				case 2097152: return currentTime + 5e3;
982				case 4194304:
983				case 8388608:
984				case 16777216:
985				case 33554432: return -1;
986				case 67108864:
987				case 134217728:
988				case 268435456:
989				case 536870912:
990				case 1073741824: return -1;
991				default: return console.error("Should have found matching lanes. This is a bug in React."), -1;
992			}
993		}
994		function claimNextRetryLane() {
995			var lane = nextRetryLane;
996			nextRetryLane <<= 1;
997			0 === (nextRetryLane & 62914560) && (nextRetryLane = 4194304);
998			return lane;
999		}
1000		function createLaneMap(initial) {
1001			for (var laneMap = [], i = 0; 31 > i; i++) laneMap.push(initial);
1002			return laneMap;
1003		}
1004		function markRootUpdated$1(root, updateLane) {
1005			root.pendingLanes |= updateLane;
1006			268435456 !== updateLane && (root.suspendedLanes = 0, root.pingedLanes = 0, root.warmLanes = 0);
1007		}
1008		function markRootFinished(root, finishedLanes, remainingLanes, spawnedLane, updatedLanes, suspendedRetryLanes) {
1009			var previouslyPendingLanes = root.pendingLanes;
1010			root.pendingLanes = remainingLanes;
1011			root.suspendedLanes = 0;
1012			root.pingedLanes = 0;
1013			root.warmLanes = 0;
1014			root.expiredLanes &= remainingLanes;
1015			root.entangledLanes &= remainingLanes;
1016			root.errorRecoveryDisabledLanes &= remainingLanes;
1017			root.shellSuspendCounter = 0;
1018			var entanglements = root.entanglements, expirationTimes = root.expirationTimes, hiddenUpdates = root.hiddenUpdates;
1019			for (remainingLanes = previouslyPendingLanes & ~remainingLanes; 0 < remainingLanes;) {
1020				var index = 31 - clz32(remainingLanes), lane = 1 << index;
1021				entanglements[index] = 0;
1022				expirationTimes[index] = -1;
1023				var hiddenUpdatesForLane = hiddenUpdates[index];
1024				if (null !== hiddenUpdatesForLane) for (hiddenUpdates[index] = null, index = 0; index < hiddenUpdatesForLane.length; index++) {
1025					var update = hiddenUpdatesForLane[index];
1026					null !== update && (update.lane &= -536870913);
1027				}
1028				remainingLanes &= ~lane;
1029			}
1030			0 !== spawnedLane && markSpawnedDeferredLane(root, spawnedLane, 0);
1031			0 !== suspendedRetryLanes && 0 === updatedLanes && 0 !== root.tag && (root.suspendedLanes |= suspendedRetryLanes & ~(previouslyPendingLanes & ~finishedLanes));
1032		}
1033		function markSpawnedDeferredLane(root, spawnedLane, entangledLanes) {
1034			root.pendingLanes |= spawnedLane;
1035			root.suspendedLanes &= ~spawnedLane;
1036			var spawnedLaneIndex = 31 - clz32(spawnedLane);
1037			root.entangledLanes |= spawnedLane;
1038			root.entanglements[spawnedLaneIndex] = root.entanglements[spawnedLaneIndex] | 1073741824 | entangledLanes & 261930;
1039		}
1040		function markRootEntangled(root, entangledLanes) {
1041			var rootEntangledLanes = root.entangledLanes |= entangledLanes;
1042			for (root = root.entanglements; rootEntangledLanes;) {
1043				var index = 31 - clz32(rootEntangledLanes), lane = 1 << index;
1044				lane & entangledLanes | root[index] & entangledLanes && (root[index] |= entangledLanes);
1045				rootEntangledLanes &= ~lane;
1046			}
1047		}
1048		function getBumpedLaneForHydration(root, renderLanes) {
1049			var renderLane = renderLanes & -renderLanes;
1050			renderLane = 0 !== (renderLane & 42) ? 1 : getBumpedLaneForHydrationByLane(renderLane);
1051			return 0 !== (renderLane & (root.suspendedLanes | renderLanes)) ? 0 : renderLane;
1052		}
1053		function getBumpedLaneForHydrationByLane(lane) {
1054			switch (lane) {
1055				case 2:
1056					lane = 1;
1057					break;
1058				case 8:
1059					lane = 4;
1060					break;
1061				case 32:
1062					lane = 16;
1063					break;
1064				case 256:
1065				case 512:

1066				case 1024:
1067				case 2048:
1068				case 4096:
1069				case 8192:
1070				case 16384:
1071				case 32768:
1072				case 65536:
1073				case 131072:
1074				case 262144:
1075				case 524288:
1076				case 1048576:
1077				case 2097152:
1078				case 4194304:
1079				case 8388608:
1080				case 16777216:
1081				case 33554432:
1082					lane = 128;
1083					break;
1084				case 268435456:
1085					lane = 134217728;
1086					break;
1087				default: lane = 0;
1088			}
1089			return lane;
1090		}
1091		function addFiberToLanesMap(root, fiber, lanes) {
1092			if (isDevToolsPresent) for (root = root.pendingUpdatersLaneMap; 0 < lanes;) {
1093				var index = 31 - clz32(lanes), lane = 1 << index;
1094				root[index].add(fiber);
1095				lanes &= ~lane;
1096			}
1097		}
1098		function movePendingFibersToMemoized(root, lanes) {
1099			if (isDevToolsPresent) for (var pendingUpdatersLaneMap = root.pendingUpdatersLaneMap, memoizedUpdaters = root.memoizedUpdaters; 0 < lanes;) {
1100				var index = 31 - clz32(lanes);
1101				root = 1 << index;
1102				index = pendingUpdatersLaneMap[index];
1103				0 < index.size && (index.forEach(function(fiber) {
1104					var alternate = fiber.alternate;
1105					null !== alternate && memoizedUpdaters.has(alternate) || memoizedUpdaters.add(fiber);
1106				}), index.clear());
1107				lanes &= ~root;
1108			}
1109		}
1110		function lanesToEventPriority(lanes) {
1111			lanes &= -lanes;
1112			return 0 !== DiscreteEventPriority && DiscreteEventPriority < lanes ? 0 !== ContinuousEventPriority && ContinuousEventPriority < lanes ? 0 !== (lanes & 134217727) ? DefaultEventPriority : IdleEventPriority : ContinuousEventPriority : DiscreteEventPriority;
1113		}
1114		function resolveUpdatePriority() {
1115			var updatePriority = ReactDOMSharedInternals.p;
1116			if (0 !== updatePriority) return updatePriority;
1117			updatePriority = window.event;
1118			return void 0 === updatePriority ? DefaultEventPriority : getEventPriority(updatePriority.type);
1119		}
1120		function runWithPriority(priority, fn) {
1121			var previousPriority = ReactDOMSharedInternals.p;
1122			try {
1123				return ReactDOMSharedInternals.p = priority, fn();
1124			} finally {
1125				ReactDOMSharedInternals.p = previousPriority;
1126			}
1127		}
1128		function detachDeletedInstance(node) {
1129			delete node[internalInstanceKey];
1130			delete node[internalPropsKey];
1131			delete node[internalEventHandlersKey];
1132			delete node[internalEventHandlerListenersKey];
1133			delete node[internalEventHandlesSetKey];
1134		}
1135		function getClosestInstanceFromNode(targetNode) {
1136			var targetInst = targetNode[internalInstanceKey];
1137			if (targetInst) return targetInst;
1138			for (var parentNode = targetNode.parentNode; parentNode;) {
1139				if (targetInst = parentNode[internalContainerInstanceKey] || parentNode[internalInstanceKey]) {
1140					parentNode = targetInst.alternate;
1141					if (null !== targetInst.child || null !== parentNode && null !== parentNode.child) for (targetNode = getParentHydrationBoundary(targetNode); null !== targetNode;) {
1142						if (parentNode = targetNode[internalInstanceKey]) return parentNode;
1143						targetNode = getParentHydrationBoundary(targetNode);
1144					}
1145					return targetInst;
1146				}
1147				targetNode = parentNode;
1148				parentNode = targetNode.parentNode;
1149			}
1150			return null;
1151		}
1152		function getInstanceFromNode(node) {
1153			if (node = node[internalInstanceKey] || node[internalContainerInstanceKey]) {
1154				var tag = node.tag;
1155				if (5 === tag || 6 === tag || 13 === tag || 31 === tag || 26 === tag || 27 === tag || 3 === tag) return node;
1156			}
1157			return null;
1158		}
1159		function getNodeFromInstance(inst) {
1160			var tag = inst.tag;
1161			if (5 === tag || 26 === tag || 27 === tag || 6 === tag) return inst.stateNode;
1162			throw Error("getNodeFromInstance: Invalid argument.");
1163		}
1164		function getResourcesFromRoot(root) {
1165			var resources = root[internalRootNodeResourcesKey];
1166			resources || (resources = root[internalRootNodeResourcesKey] = {
1167				hoistableStyles: /* @__PURE__ */ new Map(),
1168				hoistableScripts: /* @__PURE__ */ new Map()
1169			});
1170			return resources;
1171		}
1172		function markNodeAsHoistable(node) {
1173			node[internalHoistableMarker] = !0;
1174		}
1175		function registerTwoPhaseEvent(registrationName, dependencies) {
1176			registerDirectEvent(registrationName, dependencies);
1177			registerDirectEvent(registrationName + "Capture", dependencies);
1178		}
1179		function registerDirectEvent(registrationName, dependencies) {
1180			registrationNameDependencies[registrationName] && console.error("EventRegistry: More than one plugin attempted to publish the same registration name, `%s`.", registrationName);
1181			registrationNameDependencies[registrationName] = dependencies;
1182			var lowerCasedName = registrationName.toLowerCase();
1183			possibleRegistrationNames[lowerCasedName] = registrationName;
1184			"onDoubleClick" === registrationName && (possibleRegistrationNames.ondblclick = registrationName);
1185			for (registrationName = 0; registrationName < dependencies.length; registrationName++) allNativeEvents.add(dependencies[registrationName]);
1186		}
1187		function checkControlledValueProps(tagName, props) {
1188			hasReadOnlyValue[props.type] || props.onChange || props.onInput || props.readOnly || props.disabled || null == props.value || ("select" === tagName ? console.error("You provided a `value` prop to a form field without an `onChange` handler. This will render a read-only field. If the field should be mutable use `defaultValue`. Otherwise, set `onChange`.") : console.error("You provided a `value` prop to a form field without an `onChange` handler. This will render a read-only field. If the field should be mutable use `defaultValue`. Otherwise, set either `onChange` or `readOnly`."));
1189			props.onChange || props.readOnly || props.disabled || null == props.checked || console.error("You provided a `checked` prop to a form field without an `onChange` handler. This will render a read-only field. If the field should be mutable use `defaultChecked`. Otherwise, set either `onChange` or `readOnly`.");
1190		}
1191		function isAttributeNameSafe(attributeName) {
1192			if (hasOwnProperty.call(validatedAttributeNameCache, attributeName)) return !0;
1193			if (hasOwnProperty.call(illegalAttributeNameCache, attributeName)) return !1;
1194			if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) return validatedAttributeNameCache[attributeName] = !0;
1195			illegalAttributeNameCache[attributeName] = !0;
1196			console.error("Invalid attribute name: `%s`", attributeName);
1197			return !1;
1198		}
1199		function getValueForAttributeOnCustomComponent(node, name, expected) {
1200			if (isAttributeNameSafe(name)) {
1201				if (!node.hasAttribute(name)) {
1202					switch (typeof expected) {
1203						case "symbol":
1204						case "object": return expected;
1205						case "function": return expected;
1206						case "boolean": if (!1 === expected) return expected;
1207					}
1208					return void 0 === expected ? void 0 : null;
1209				}
1210				node = node.getAttribute(name);
1211				if ("" === node && !0 === expected) return !0;
1212				checkAttributeStringCoercion(expected, name);
1213				return node === "" + expected ? expected : node;
1214			}
1215		}
1216		function setValueForAttribute(node, name, value) {
1217			if (isAttributeNameSafe(name)) if (null === value) node.removeAttribute(name);
1218			else {
1219				switch (typeof value) {
1220					case "undefined":
1221					case "function":
1222					case "symbol":
1223						node.removeAttribute(name);
1224						return;
1225					case "boolean":
1226						var prefix = name.toLowerCase().slice(0, 5);
1227						if ("data-" !== prefix && "aria-" !== prefix) {
1228							node.removeAttribute(name);
1229							return;
1230						}
1231				}
1232				checkAttributeStringCoercion(value, name);
1233				node.setAttribute(name, "" + value);
1234			}
1235		}
1236		function setValueForKnownAttribute(node, name, value) {
1237			if (null === value) node.removeAttribute(name);
1238			else {
1239				switch (typeof value) {
1240					case "undefined":
1241					case "function":
1242					case "symbol":
1243					case "boolean":
1244						node.removeAttribute(name);
1245						return;
1246				}
1247				checkAttributeStringCoercion(value, name);
1248				node.setAttribute(name, "" + value);
1249			}
1250		}
1251		function setValueForNamespacedAttribute(node, namespace, name, value) {
1252			if (null === value) node.removeAttribute(name);
1253			else {
1254				switch (typeof value) {
1255					case "undefined":
1256					case "function":
1257					case "symbol":
1258					case "boolean":
1259						node.removeAttribute(name);
1260						return;
1261				}
1262				checkAttributeStringCoercion(value, name);
1263				node.setAttributeNS(namespace, name, "" + value);
1264			}
1265		}
1266		function getToStringValue(value) {
1267			switch (typeof value) {
1268				case "bigint":
1269				case "boolean":
1270				case "number":
1271				case "string":
1272				case "undefined": return value;
1273				case "object": return checkFormFieldValueStringCoercion(value), value;
1274				default: return "";
1275			}
1276		}
1277		function isCheckable(elem) {
1278			var type = elem.type;
1279			return (elem = elem.nodeName) && "input" === elem.toLowerCase() && ("checkbox" === type || "radio" === type);
1280		}
1281		function trackValueOnNode(node, valueField, currentValue) {
1282			var descriptor = Object.getOwnPropertyDescriptor(node.constructor.prototype, valueField);
1283			if (!node.hasOwnProperty(valueField) && "undefined" !== typeof descriptor && "function" === typeof descriptor.get && "function" === typeof descriptor.set) {
1284				var get = descriptor.get, set = descriptor.set;
1285				Object.defineProperty(node, valueField, {
1286					configurable: !0,
1287					get: function() {
1288						return get.call(this);
1289					},
1290					set: function(value) {
1291						checkFormFieldValueStringCoercion(value);
1292						currentValue = "" + value;
1293						set.call(this, value);
1294					}
1295				});
1296				Object.defineProperty(node, valueField, { enumerable: descriptor.enumerable });
1297				return {
1298					getValue: function() {
1299						return currentValue;
1300					},
1301					setValue: function(value) {
1302						checkFormFieldValueStringCoercion(value);
1303						currentValue = "" + value;
1304					},
1305					stopTracking: function() {
1306						node._valueTracker = null;
1307						delete node[valueField];
1308					}
1309				};
1310			}
1311		}
1312		function track(node) {
1313			if (!node._valueTracker) {
1314				var valueField = isCheckable(node) ? "checked" : "value";
1315				node._valueTracker = trackValueOnNode(node, valueField, "" + node[valueField]);
1316			}
1317		}
1318		function updateValueIfChanged(node) {
1319			if (!node) return !1;
1320			var tracker = node._valueTracker;
1321			if (!tracker) return !0;
1322			var lastValue = tracker.getValue();
1323			var value = "";
1324			node && (value = isCheckable(node) ? node.checked ? "true" : "false" : node.value);
1325			node = value;
1326			return node !== lastValue ? (tracker.setValue(node), !0) : !1;
1327		}
1328		function getActiveElement(doc) {
1329			doc = doc || ("undefined" !== typeof document ? document : void 0);
1330			if ("undefined" === typeof doc) return null;
1331			try {
1332				return doc.activeElement || doc.body;
1333			} catch (e) {
1334				return doc.body;
1335			}
1336		}
1337		function escapeSelectorAttributeValueInsideDoubleQuotes(value) {
1338			return value.replace(escapeSelectorAttributeValueInsideDoubleQuotesRegex, function(ch) {

1381h(props.children, function(child) {
1382				null == child || "string" === typeof child || "number" === typeof child || "bigint" === typeof child || didWarnInvalidChild || (didWarnInvalidChild = !0, console.error("Cannot infer the option value of complex children. Pass a `value` prop or use a plain string as children to <option>."));
1383			}) : null == props.dangerouslySetInnerHTML || didWarnInvalidInnerHTML || (didWarnInvalidInnerHTML = !0, console.error("Pass a `value` prop if you set dangerouslyInnerHTML so React knows which value should be selected.")));
1384			null == props.selected || didWarnSelectedSetOnOption || (console.error("Use the `defaultValue` or `value` props on <select> instead of setting `selected` on <option>."), didWarnSelectedSetOnOption = !0);
1385		}
1386		function getDeclarationErrorAddendum() {
1387			var ownerName = getCurrentFiberOwnerNameInDevOrNull();
1388			return ownerName ? "\n\nCheck the render method of `" + ownerName + "`." : "";
1389		}
1390		function updateOptions(node, multiple, propValue, setDefaultSelected) {
1391			node = node.options;
1392			if (multiple) {
1393				multiple = {};
1394				for (var i = 0; i < propValue.length; i++) multiple["$" + propValue[i]] = !0;
1395				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);
1396			} else {
1397				propValue = "" + getToStringValue(propValue);
1398				multiple = null;
1399				for (i = 0; i < node.length; i++) {
1400					if (node[i].value === propValue) {
1401						node[i].selected = !0;
1402						setDefaultSelected && (node[i].defaultSelected = !0);
1403						return;
1404					}
1405					null !== multiple || node[i].disabled || (multiple = node[i]);
1406				}
1407				null !== multiple && (multiple.selected = !0);
1408			}
1409		}
1410		function validateSelectProps(element, props) {
1411			for (element = 0; element < valuePropNames.length; element++) {
1412				var propName = valuePropNames[element];
1413				if (null != props[propName]) {
1414					var propNameIsArray = isArrayImpl(props[propName]);
1415					props.multiple && !propNameIsArray ? console.error("The `%s` prop supplied to <select> must be an array if `multiple` is true.%s", propName, getDeclarationErrorAddendum()) : !props.multiple && propNameIsArray && console.error("The `%s` prop supplied to <select> must be a scalar value if `multiple` is false.%s", propName, getDeclarationErrorAddendum());
1416				}
1417			}
1418			void 0 === props.value || void 0 === props.defaultValue || didWarnValueDefaultValue || (console.error("Select elements must be either controlled or uncontrolled (specify either the value prop, or the defaultValue prop, but not both). Decide between using a controlled or uncontrolled select element and remove one of these props. More info: https://react.dev/link/controlled-components"), didWarnValueDefaultValue = !0);
1419		}
1420		function validateTextareaProps(element, props) {
1421			void 0 === props.value || void 0 === props.defaultValue || didWarnValDefaultVal || (console.error("%s contains a textarea with both value and defaultValue props. Textarea elements must be either controlled or uncontrolled (specify either the value prop, or the defaultValue prop, but not both). Decide between using a controlled or uncontrolled textarea and remove one of these props. More info: https://react.dev/link/controlled-components", getCurrentFiberOwnerNameInDevOrNull() || "A component"), didWarnValDefaultVal = !0);
1422			null != props.children && null == props.value && console.error("Use the `defaultValue` or `value` props instead of setting children on <textarea>.");
1423		}
1424		function updateTextarea(element, value, defaultValue) {
1425			if (null != value && (value = "" + getToStringValue(value), value !== element.value && (element.value = value), null == defaultValue)) {
1426				element.defaultValue !== value && (element.defaultValue = value);
1427				return;
1428			}
1429			element.defaultValue = null != defaultValue ? "" + getToStringValue(defaultValue) : "";
1430		}
1431		function initTextarea(element, value, defaultValue, children) {
1432			if (null == value) {
1433				if (null != children) {
1434					if (null != defaultValue) throw Error("If you supply `defaultValue` on a <textarea>, do not pass children.");
1435					if (isArrayImpl(children)) {
1436						if (1 < children.length) throw Error("<textarea> can only have at most one child.");
1437						children = children[0];
1438					}
1439					defaultValue = children;
1440				}
1441				defaultValue ??= "";
1442				value = defaultValue;
1443			}
1444			defaultValue = getToStringValue(value);
1445			element.defaultValue = defaultValue;
1446			children = element.textContent;
1447			children === defaultValue && "" !== children && null !== children && (element.value = children);
1448			track(element);
1449		}
1450		function findNotableNode(node, indent) {
1451			return void 0 === node.serverProps && 0 === node.serverTail.length && 1 === node.children.length && 3 < node.distanceFromLeaf && node.distanceFromLeaf > 15 - indent ? findNotableNode(node.children[0], indent) : node;
1452		}
1453		function indentation(indent) {
1454			return "  " + "  ".repeat(indent);
1455		}
1456		function added(indent) {
1457			return "+ " + "  ".repeat(indent);
1458		}
1459		function removed(indent) {
1460			return "- " + "  ".repeat(indent);
1461		}
1462		function describeFiberType(fiber) {
1463			switch (fiber.tag) {
1464				case 26:
1465				case 27:
1466				case 5: return fiber.type;
1467				case 16: return "Lazy";
1468				case 31: return "Activity";
1469				case 13: return "Suspense";
1470				case 19: return "SuspenseList";
1471				case 0:
1472				case 15: return fiber = fiber.type, fiber.displayName || fiber.name || null;
1473				case 11: return fiber = fiber.type.render, fiber.displayName || fiber.name || null;
1474				case 1: return fiber = fiber.type, fiber.displayName || fiber.name || null;
1475				default: return null;
1476			}
1477		}
1478		function describeTextNode(content, maxLength) {
1479			return needsEscaping.test(content) ? (content = JSON.stringify(content), content.length > maxLength - 2 ? 8 > maxLength ? "{\"...\"}" : "{" + content.slice(0, maxLength - 7) + "...\"}" : "{" + content + "}") : content.length > maxLength ? 5 > maxLength ? "{\"...\"}" : content.slice(0, maxLength - 3) + "..." : content;
1480		}
1481		function describeTextDiff(clientText, serverProps, indent) {
1482			var maxLength = 120 - 2 * indent;
1483			if (null === serverProps) return added(indent) + describeTextNode(clientText, maxLength) + "\n";
1484			if ("string" === typeof serverProps) {
1485				for (var firstDiff = 0; firstDiff < serverProps.length && firstDiff < clientText.length && serverProps.charCodeAt(firstDiff) === clientText.charCodeAt(firstDiff); firstDiff++);
1486				firstDiff > maxLength - 8 && 10 < firstDiff && (clientText = "..." + clientText.slice(firstDiff - 8), serverProps = "..." + serverProps.slice(firstDiff - 8));
1487				return added(indent) + describeTextNode(clientText, maxLength) + "\n" + removed(indent) + describeTextNode(serverProps, maxLength) + "\n";
1488			}
1489			return indentation(indent) + describeTextNode(clientText, maxLength) + "\n";
1490		}
1491		function objectName(object) {
1492			return Object.prototype.toString.call(object).replace(/^\[object (.*)\]$/, function(m, p0) {
1493				return p0;
1494			});
1495		}
1496		function describeValue(value, maxLength) {
1497			switch (typeof value) {
1498				case "string": return value = JSON.stringify(value), value.length > maxLength ? 5 > maxLength ? "\"...\"" : value.slice(0, maxLength - 4) + "...\"" : value;
1499				case "object":
1500					if (null === value) return "null";
1501					if (isArrayImpl(value)) return "[...]";
1502					if (value.$$typeof === REACT_ELEMENT_TYPE) return (maxLength = getComponentNameFromType(value.type)) ? "<" + maxLength + ">" : "<...>";
1503					var name = objectName(value);
1504					if ("Object" === name) {
1505						name = "";
1506						maxLength -= 2;
1507						for (var propName in value) if (value.hasOwnProperty(propName)) {
1508							var jsonPropName = JSON.stringify(propName);
1509							jsonPropName !== "\"" + propName + "\"" && (propName = jsonPropName);
1510							maxLength -= propName.length - 2;
1511							jsonPropName = describeValue(value[propName], 15 > maxLength ? maxLength : 15);
1512							maxLength -= jsonPropName.length;
1513							if (0 > maxLength) {
1514								name += "" === name ? "..." : ", ...";
1515								break;
1516							}
1517							name += ("" === name ? "" : ",") + propName + ":" + jsonPropName;
1518						}
1519						return "{" + name + "}";
1520					}
1521					return name;
1522				case "function": return (maxLength = value.displayName || value.name) ? "function " + maxLength : "function";
1523				default: return String(value);
1524			}
1525		}
1526		function describePropValue(value, maxLength) {
1527			return "string" !== typeof value || needsEscaping.test(value) ? "{" + describeValue(value, maxLength - 2) + "}" : value.length > maxLength - 2 ? 5 > maxLength ? "\"...\"" : "\"" + value.slice(0, maxLength - 5) + "...\"" : "\"" + value + "\"";
1528		}
1529		function describeExpandedElement(type, props, rowPrefix) {
1530			var remainingRowLength = 120 - rowPrefix.length - type.length, properties = [], propName;
1531			for (propName in props) if (props.hasOwnProperty(propName) && "children" !== propName) {
1532				var propValue = describePropValue(props[propName], 120 - rowPrefix.length - propName.length - 1);
1533				remainingRowLength -= propName.length + propValue.length + 2;
1534				properties.push(propName + "=" + propValue);
1535			}
1536			return 0 === properties.length ? rowPrefix + "<" + type + ">\n" : 0 < remainingRowLength ? rowPrefix + "<" + type + " " + properties.join(" ") + ">\n" : rowPrefix + "<" + type + "\n" + rowPrefix + "  " + properties.join("\n" + rowPrefix + "  ") + "\n" + rowPrefix + ">\n";
1537		}
1538		function describePropertiesDiff(clientObject, serverObject, indent) {
1539			var properties = "", remainingServerProperties = assign({}, serverObject), propName;
1540			for (propName in clientObject) if (clientObject.hasOwnProperty(propName)) {
1541				delete remainingServerProperties[propName];
1542				var maxLength = 120 - 2 * indent - propName.length - 2, clientPropValue = describeValue(clientObject[propName], maxLength);
1543				serverObject.hasOwnProperty(propName) ? (maxLength = describeValue(serverObject[propName], maxLength), properties += added(indent) + propName + ": " + clientPropValue + "\n", properties += removed(indent) + propName + ": " + maxLength + "\n") : properties += added(indent) + propName + ": " + clientPropValue + "\n";
1544			}
1545			for (var _propName in remainingServerProperties) remainingServerProperties.hasOwnProperty(_propName) && (clientObject = describeValue(remainingServerProperties[_propName], 120 - 2 * indent - _propName.length - 2), properties += removed(indent) + _propName + ": " + clientObject + "\n");
1546			return properties;
1547		}
1548		function describeElementDiff(type, clientProps, serverProps, indent) {
1549			var content = "", serverPropNames = /* @__PURE__ */ new Map();
1550			for (propName$jscomp$0 in serverProps) serverProps.hasOwnProperty(propName$jscomp$0) && serverPropNames.set(propName$jscomp$0.toLowerCase(), propName$jscomp$0);
1551			if (1 === serverPropNames.size && serverPropNames.has("children")) content += describeExpandedElement(type, clientProps, indentation(indent));
1552			else {
1553				for (var _propName2 in clientProps) if (clientProps.hasOwnProperty(_propName2) && "children" !== _propName2) {
1554					var maxLength$jscomp$0 = 120 - 2 * (indent + 1) - _propName2.length - 1, serverPropName = serverPropNames.get(_propName2.toLowerCase());
1555					if (void 0 !== serverPropName) {
1556						serverPropNames.delete(_propName2.toLowerCase());
1557						var propName$jscomp$0 = clientProps[_propName2];
1558						serverPropName = serverProps[serverPropName];
1559						var clientPropValue = describePropValue(propName$jscomp$0, maxLength$jscomp$0);
1560						maxLength$jscomp$0 = describePropValue(serverPropName, maxLength$jscomp$0);
1561						"object" === typeof propName$jscomp$0 && null !== propName$jscomp$0 && "object" === typeof serverPropName && null !== serverPropName && "Object" === objectName(propName$jscomp$0) && "Object" === objectName(serverPropName) && (2 < Object.keys(propName$jscomp$0).length || 2 < Object.keys(serverPropName).length || -1 < clientPropValue.indexOf("...") || -1 < maxLength$jscomp$0.indexOf("...")) ? content += indentation(indent + 1) + _propName2 + "={{\n" + describePropertiesDiff(propName$jscomp$0, serverPropName, indent + 2) + indentation(indent + 1) + "}}\n" : (content += added(indent + 1) + _propName2 + "=" + clientPropValue + "\n", content += removed(indent + 1) + _propName2 + "=" + maxLength$jscomp$0 + "\n");
1562					} else content += indentation(indent + 1) + _propName2 + "=" + describePropValue(clientProps[_propName2], maxLength$jscomp$0) + "\n";
1563				}

2059				case "onClickCapture":
2060				case "onDoubleClick":
2061				case "onDoubleClickCapture":
2062				case "onMouseDown":
2063				case "onMouseDownCapture":
2064				case "onMouseMove":
2065				case "onMouseMoveCapture":
2066				case "onMouseUp":
2067				case "onMouseUpCapture":
2068				case "onMouseEnter":
2069					(props = !props.disabled) || (inst = inst.type, props = !("button" === inst || "input" === inst || "select" === inst || "textarea" === inst));
2070					inst = !props;
2071					break a;
2072				default: inst = !1;
2073			}
2074			if (inst) return null;
2075			if (stateNode && "function" !== typeof stateNode) throw Error("Expected `" + registrationName + "` listener to be a function, instead got a value of `" + typeof stateNode + "` type.");
2076			return stateNode;
2077		}
2078		function getData() {
2079			if (fallbackText) return fallbackText;
2080			var start, startValue = startText, startLength = startValue.length, end, endValue = "value" in root ? root.value : root.textContent, endLength = endValue.length;
2081			for (start = 0; start < startLength && startValue[start] === endValue[start]; start++);
2082			var minEnd = startLength - start;
2083			for (end = 1; end <= minEnd && startValue[startLength - end] === endValue[endLength - end]; end++);
2084			return fallbackText = endValue.slice(start, 1 < end ? 1 - end : void 0);
2085		}
2086		function getEventCharCode(nativeEvent) {
2087			var keyCode = nativeEvent.keyCode;
2088			"charCode" in nativeEvent ? (nativeEvent = nativeEvent.charCode, 0 === nativeEvent && 13 === keyCode && (nativeEvent = 13)) : nativeEvent = keyCode;
2089			10 === nativeEvent && (nativeEvent = 13);
2090			return 32 <= nativeEvent || 13 === nativeEvent ? nativeEvent : 0;
2091		}
2092		function functionThatReturnsTrue() {
2093			return !0;
2094		}
2095		function functionThatReturnsFalse() {
2096			return !1;
2097		}
2098		function createSyntheticEvent(Interface) {
2099			function SyntheticBaseEvent(reactName, reactEventType, targetInst, nativeEvent, nativeEventTarget) {
2100				this._reactName = reactName;
2101				this._targetInst = targetInst;
2102				this.type = reactEventType;
2103				this.nativeEvent = nativeEvent;
2104				this.target = nativeEventTarget;
2105				this.currentTarget = null;
2106				for (var propName in Interface) Interface.hasOwnProperty(propName) && (reactName = Interface[propName], this[propName] = reactName ? reactName(nativeEvent) : nativeEvent[propName]);
2107				this.isDefaultPrevented = (null != nativeEvent.defaultPrevented ? nativeEvent.defaultPrevented : !1 === nativeEvent.returnValue) ? functionThatReturnsTrue : functionThatReturnsFalse;
2108				this.isPropagationStopped = functionThatReturnsFalse;
2109				return this;
2110			}
2111			assign(SyntheticBaseEvent.prototype, {
2112				preventDefault: function() {
2113					this.defaultPrevented = !0;
2114					var event = this.nativeEvent;
2115					event && (event.preventDefault ? event.preventDefault() : "unknown" !== typeof event.returnValue && (event.returnValue = !1), this.isDefaultPrevented = functionThatReturnsTrue);
2116				},
2117				stopPropagation: function() {
2118					var event = this.nativeEvent;
2119					event && (event.stopPropagation ? event.stopPropagation() : "unknown" !== typeof event.cancelBubble && (event.cancelBubble = !0), this.isPropagationStopped = functionThatReturnsTrue);
2120				},
2121				persist: function() {},
2122				isPersistent: functionThatReturnsTrue
2123			});
2124			return SyntheticBaseEvent;
2125		}
2126		function modifierStateGetter(keyArg) {
2127			var nativeEvent = this.nativeEvent;
2128			return nativeEvent.getModifierState ? nativeEvent.getModifierState(keyArg) : (keyArg = modifierKeyToProp[keyArg]) ? !!nativeEvent[keyArg] : !1;
2129		}
2130		function getEventModifierState() {
2131			return modifierStateGetter;
2132		}
2133		function isFallbackCompositionEnd(domEventName, nativeEvent) {
2134			switch (domEventName) {
2135				case "keyup": return -1 !== END_KEYCODES.indexOf(nativeEvent.keyCode);
2136				case "keydown": return nativeEvent.keyCode !== START_KEYCODE;
2137				case "keypress":
2138				case "mousedown":
2139				case "focusout": return !0;
2140				default: return !1;
2141			}
2142		}
2143		function getDataFromCustomEvent(nativeEvent) {
2144			nativeEvent = nativeEvent.detail;
2145			return "object" === typeof nativeEvent && "data" in nativeEvent ? nativeEvent.data : null;
2146		}
2147		function getNativeBeforeInputChars(domEventName, nativeEvent) {
2148			switch (domEventName) {
2149				case "compositionend": return getDataFromCustomEvent(nativeEvent);
2150				case "keypress":
2151					if (nativeEvent.which !== SPACEBAR_CODE) return null;
2152					hasSpaceKeypress = !0;
2153					return SPACEBAR_CHAR;
2154				case "textInput": return domEventName = nativeEvent.data, domEventName === SPACEBAR_CHAR && hasSpaceKeypress ? null : domEventName;
2155				default: return null;
2156			}
2157		}
2158		function getFallbackBeforeInputChars(domEventName, nativeEvent) {
2159			if (isComposing) return "compositionend" === domEventName || !canUseCompositionEvent && isFallbackCompositionEnd(domEventName, nativeEvent) ? (domEventName = getData(), fallbackText = startText = root = null, isComposing = !1, domEventName) : null;
2160			switch (domEventName) {
2161				case "paste": return null;
2162				case "keypress":
2163					if (!(nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) || nativeEvent.ctrlKey && nativeEvent.altKey) {
2164						if (nativeEvent.char && 1 < nativeEvent.char.length) return nativeEvent.char;
2165						if (nativeEvent.which) return String.fromCharCode(nativeEvent.which);
2166					}
2167					return null;
2168				case "compositionend": return useFallbackCompositionData && "ko" !== nativeEvent.locale ? null : nativeEvent.data;
2169				default: return null;
2170			}
2171		}
2172		function isTextInputElement(elem) {
2173			var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
2174			return "input" === nodeName ? !!supportedInputTypes[elem.type] : "textarea" === nodeName ? !0 : !1;
2175		}
2176		function isEventSupported(eventNameSuffix) {
2177			if (!canUseDOM) return !1;
2178			eventNameSuffix = "on" + eventNameSuffix;
2179			var isSupported = eventNameSuffix in document;
2180			isSupported || (isSupported = document.createElement("div"), isSupported.setAttribute(eventNameSuffix, "return;"), isSupported = "function" === typeof isSupported[eventNameSuffix]);
2181			return isSupported;
2182		}

2183		function createAndAccumulateChangeEvent(dispatchQueue, inst, nativeEvent, target) {
2184			restoreTarget ? restoreQueue ? restoreQueue.push(target) : restoreQueue = [target] : restoreTarget = target;
2185			inst = accumulateTwoPhaseListeners(inst, "onChange");
2186			0 < inst.length && (nativeEvent = new SyntheticEvent("onChange", "change", null, nativeEvent, target), dispatchQueue.push({
2187				event: nativeEvent,
2188				listeners: inst
2189			}));
2190		}
2191		function runEventInBatch(dispatchQueue) {
2192			processDispatchQueue(dispatchQueue, 0);
2193		}
2194		function getInstIfValueChanged(targetInst) {
2195			if (updateValueIfChanged(getNodeFromInstance(targetInst))) return targetInst;
2196		}
2197		function getTargetInstForChangeEvent(domEventName, targetInst) {
2198			if ("change" === domEventName) return targetInst;
2199		}
2200		function stopWatchingForValueChange() {
2201			activeElement$1 && (activeElement$1.detachEvent("onpropertychange", handlePropertyChange), activeElementInst$1 = activeElement$1 = null);
2202		}
2203		function handlePropertyChange(nativeEvent) {
2204			if ("value" === nativeEvent.propertyName && getInstIfValueChanged(activeElementInst$1)) {
2205				var dispatchQueue = [];
2206				createAndAccumulateChangeEvent(dispatchQueue, activeElementInst$1, nativeEvent, getEventTarget(nativeEvent));
2207				batchedUpdates$1(runEventInBatch, dispatchQueue);
2208			}
2209		}
2210		function handleEventsForInputEventPolyfill(domEventName, target, targetInst) {
2211			"focusin" === domEventName ? (stopWatchingForValueChange(), activeElement$1 = target, activeElementInst$1 = targetInst, activeElement$1.attachEvent("onpropertychange", handlePropertyChange)) : "focusout" === domEventName && stopWatchingForValueChange();
2212		}
2213		function getTargetInstForInputEventPolyfill(domEventName) {
2214			if ("selectionchange" === domEventName || "keyup" === domEventName || "keydown" === domEventName) return getInstIfValueChanged(activeElementInst$1);
2215		}
2216		function getTargetInstForClickEvent(domEventName, targetInst) {
2217			if ("click" === domEventName) return getInstIfValueChanged(targetInst);
2218		}
2219		function getTargetInstForInputOrChangeEvent(domEventName, targetInst) {
2220			if ("input" === domEventName || "change" === domEventName) return getInstIfValueChanged(targetInst);
2221		}
2222		function is(x, y) {
2223			return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
2224		}
2225		function shallowEqual(objA, objB) {
2226			if (objectIs(objA, objB)) return !0;
2227			if ("object" !== typeof objA || null === objA || "object" !== typeof objB || null === objB) return !1;
2228			var keysA = Object.keys(objA), keysB = Object.keys(objB);
2229			if (keysA.length !== keysB.length) return !1;
2230			for (keysB = 0; keysB < keysA.length; keysB++) {
2231				var currentKey = keysA[keysB];
2232				if (!hasOwnProperty.call(objB, currentKey) || !objectIs(objA[currentKey], objB[currentKey])) return !1;
2233			}
2234			return !0;
2235		}
2236		function getLeafNode(node) {
2237			for (; node && node.firstChild;) node = node.firstChild;
2238			return node;
2239		}
2240		function getNodeForCharacterOffset(root, offset) {
2241			var node = getLeafNode(root);
2242			root = 0;
2243			for (var nodeEnd; node;) {
2244				if (3 === node.nodeType) {
2245					nodeEnd = root + node.textContent.length;
2246					if (root <= offset && nodeEnd >= offset) return {
2247						node,
2248						offset: offset - root
2249					};
2250					root = nodeEnd;
2251				}
2252				a: {
2253					for (; node;) {
2254						if (node.nextSibling) {
2255							node = node.nextSibling;
2256							break a;
2257						}
2258						node = node.parentNode;
2259					}
2260					node = void 0;
2261				}
2262				node = getLeafNode(node);
2263			}
2264		}
2265		function containsNode(outerNode, innerNode) {
2266			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;
2267		}
2268		function getActiveElementDeep(containerInfo) {
2269			containerInfo = null != containerInfo && null != containerInfo.ownerDocument && null != containerInfo.ownerDocument.defaultView ? containerInfo.ownerDocument.defaultView : window;
2270			for (var element = getActiveElement(containerInfo.document); element instanceof containerInfo.HTMLIFrameElement;) {
2271				try {
2272					var JSCompiler_inline_result = "string" === typeof element.contentWindow.location.href;
2273				} catch (err) {
2274					JSCompiler_inline_result = !1;
2275				}
2276				if (JSCompiler_inline_result) containerInfo = element.contentWindow;
2277				else break;
2278				element = getActiveElement(containerInfo.document);
2279			}
2280			return element;
2281		}
2282		function hasSelectionCapabilities(elem) {
2283			var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
2284			return nodeName && ("input" === nodeName && ("text" === elem.type || "search" === elem.type || "tel" === elem.type || "url" === elem.type || "password" === elem.type) || "textarea" === nodeName || "true" === elem.contentEditable);
2285		}

2286		function constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget) {
2287			var doc = nativeEventTarget.window === nativeEventTarget ? nativeEventTarget.document : 9 === nativeEventTarget.nodeType ? nativeEventTarget : nativeEventTarget.ownerDocument;
2288			mouseDown || null == activeElement || activeElement !== getActiveElement(doc) || (doc = activeElement, "selectionStart" in doc && hasSelectionCapabilities(doc) ? doc = {
2289				start: doc.selectionStart,
2290				end: doc.selectionEnd
2291			} : (doc = (doc.ownerDocument && doc.ownerDocument.defaultView || window).getSelection(), doc = {
2292				anchorNode: doc.anchorNode,
2293				anchorOffset: doc.anchorOffset,
2294				focusNode: doc.focusNode,
2295				focusOffset: doc.focusOffset
2296			}), lastSelection && shallowEqual(lastSelection, doc) || (lastSelection = doc, doc = accumulateTwoPhaseListeners(activeElementInst, "onSelect"), 0 < doc.length && (nativeEvent = new SyntheticEvent("onSelect", "select", null, nativeEvent, nativeEventTarget), dispatchQueue.push({
2297				event: nativeEvent,
2298				listeners: doc
2299			}), nativeEvent.target = activeElement)));
2300		}
2301		function makePrefixMap(styleProp, eventName) {
2302			var prefixes = {};
2303			prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();
2304			prefixes["Webkit" + styleProp] = "webkit" + eventName;
2305			prefixes["Moz" + styleProp] = "moz" + eventName;
2306			return prefixes;
2307		}
2308		function getVendorPrefixedEventName(eventName) {
2309			if (prefixedEventNames[eventName]) return prefixedEventNames[eventName];
2310			if (!vendorPrefixes[eventName]) return eventName;
2311			var prefixMap = vendorPrefixes[eventName], styleProp;
2312			for (styleProp in prefixMap) if (prefixMap.hasOwnProperty(styleProp) && styleProp in style) return prefixedEventNames[eventName] = prefixMap[styleProp];
2313			return eventName;
2314		}
2315		function registerSimpleEvent(domEventName, reactName) {
2316			topLevelEventsToReactNames.set(domEventName, reactName);
2317			registerTwoPhaseEvent(reactName, [domEventName]);
2318		}
2319		function getArrayKind(array) {
2320			for (var kind = EMPTY_ARRAY, i = 0; i < array.length; i++) {
2321				var value = array[i];
2322				if ("object" === typeof value && null !== value) if (isArrayImpl(value) && 2 === value.length && "string" === typeof value[0]) {
2323					if (kind !== EMPTY_ARRAY && kind !== ENTRIES_ARRAY) return COMPLEX_ARRAY;
2324					kind = ENTRIES_ARRAY;
2325				} else return COMPLEX_ARRAY;
2326				else {
2327					if ("function" === typeof value || "string" === typeof value && 50 < value.length || kind !== EMPTY_ARRAY && kind !== PRIMITIVE_ARRAY) return COMPLEX_ARRAY;
2328					kind = PRIMITIVE_ARRAY;
2329				}
2330			}
2331			return kind;
2332		}
2333		function addObjectToProperties(object, properties, indent, prefix) {
2334			for (var key in object) hasOwnProperty.call(object, key) && "_" !== key[0] && addValueToProperties(key, object[key], properties, indent, prefix);
2335		}
2336		function addValueToProperties(propertyName, value, properties, indent, prefix) {
2337			switch (typeof value) {
2338				case "object": if (null === value) {
2339					value = "null";
2340					break;
2341				} else {
2342					if (value.$$typeof === REACT_ELEMENT_TYPE) {
2343						var typeName = getComponentNameFromType(value.type) || "…", key = value.key;
2344						value = value.props;
2345						var propsKeys = Object.keys(value), propsLength = propsKeys.length;
2346						if (null == key && 0 === propsLength) {
2347							value = "<" + typeName + " />";
2348							break;
2349						}
2350						if (3 > indent || 1 === propsLength && "children" === propsKeys[0] && null == key) {
2351							value = "<" + typeName + " … />";
2352							break;
2353						}
2354						properties.push([prefix + "\xA0\xA0".repeat(indent) + propertyName, "<" + typeName]);
2355						null !== key && addValueToProperties("key", key, properties, indent + 1, prefix);
2356						propertyName = !1;
2357						for (var propKey in value) "children" === propKey ? null != value.children && (!isArrayImpl(value.children) || 0 < value.children.length) && (propertyName = !0) : hasOwnProperty.call(value, propKey) && "_" !== propKey[0] && addValueToProperties(propKey, value[propKey], properties, indent + 1, prefix);
2358						properties.push(["", propertyName ? ">…</" + typeName + ">" : "/>"]);
2359						return;
2360					}
2361					typeName = Object.prototype.toString.call(value);
2362					typeName = typeName.slice(8, typeName.length - 1);
2363					if ("Array" === typeName) {
2364						if (propKey = getArrayKind(value), propKey === PRIMITIVE_ARRAY || propKey === EMPTY_ARRAY) {
2365							value = JSON.stringify(value);
2366							break;
2367						} else if (propKey === ENTRIES_ARRAY) {
2368							properties.push([prefix + "\xA0\xA0".repeat(indent) + propertyName, ""]);
2369							for (propertyName = 0; propertyName < value.length; propertyName++) typeName = value[propertyName], addValueToProperties(typeName[0], typeName[1], properties, indent + 1, prefix);
2370							return;
2371						}
2372					}
2373					if ("Promise" === typeName) {
2374						if ("fulfilled" === value.status) {
2375							if (typeName = properties.length, addValueToProperties(propertyName, value.value, properties, indent, prefix), properties.length > typeName) {
2376								properties = properties[typeName];
2377								properties[1] = "Promise<" + (properties[1] || "Object") + ">";
2378								return;
2379							}
2380						} else if ("rejected" === value.status && (typeName = properties.length, addValueToProperties(propertyName, value.reason, properties, indent, prefix), properties.length > typeName)) {
2381							properties = properties[typeName];
2382							properties[1] = "Rejected Promise<" + properties[1] + ">";
2383							return;
2384						}
2385						properties.push(["\xA0\xA0".repeat(indent) + propertyName, "Promise"]);
2386						return;
2387					}
2388					"Object" === typeName && (propKey = Object.getPrototypeOf(value)) && "function" === typeof propKey.constructor && (typeName = propKey.constructor.name);
2389					properties.push([prefix + "\xA0\xA0".repeat(indent) + propertyName, "Object" === typeName ? 3 > indent ? "" : "…" : typeName]);
2390					3 > indent && addObjectToProperties(value, properties, indent + 1, prefix);
2391					return;
2392				}
2393				case "function":
2394					value = "" === value.name ? "() => {}" : value.name + "() {}";
2395					break;
2396				case "string":
2397					value = value === OMITTED_PROP_ERROR ? "…" : JSON.stringify(value);
2398					break;
2399				case "undefined":
2400					value = "undefined";
2401					break;
2402				case "boolean":
2403					value = value ? "true" : "false";
2404					break;
2405				default: value = String(value);
2406			}
2407			properties.push([prefix + "\xA0\xA0".repeat(indent) + propertyName, value]);
2408		}
2409		function addObjectDiffToProperties(prev, next, properties, indent) {
2410			var isDeeplyEqual = !0;
2411			for (key in prev) key in next || (properties.push([REMOVED + "\xA0\xA0".repeat(indent) + key, "…"]), isDeeplyEqual = !1);
2412			for (var _key in next) if (_key in prev) {
2413				var key = prev[_key];
2414				var nextValue = next[_key];
2415				if (key !== nextValue) {
2416					if (0 === indent && "children" === _key) isDeeplyEqual = "\xA0\xA0".repeat(indent) + _key, properties.push([REMOVED + isDeeplyEqual, "…"], [ADDED + isDeeplyEqual, "…"]);
2417					else {
2418						if (!(3 <= indent)) {
2419							if ("object" === typeof key && "object" === typeof nextValue && null !== key && null !== nextValue && key.$$typeof === nextValue.$$typeof) if (nextValue.$$typeof === REACT_ELEMENT_TYPE) {
2420								if (key.type === nextValue.type && key.key === nextValue.key) {
2421									key = getComponentNameFromType(nextValue.type) || "…";
2422									isDeeplyEqual = "\xA0\xA0".repeat(indent) + _key;
2423									key = "<" + key + " … />";
2424									properties.push([REMOVED + isDeeplyEqual, key], [ADDED + isDeeplyEqual, key]);
2425									isDeeplyEqual = !1;
2426									continue;
2427								}
2428							} else {
2429								var prevKind = Object.prototype.toString.call(key), nextKind = Object.prototype.toString.call(nextValue);
2430								if (prevKind === nextKind && ("[object Object]" === nextKind || "[object Array]" === nextKind)) {
2431									prevKind = [UNCHANGED + "\xA0\xA0".repeat(indent) + _key, "[object Array]" === nextKind ? "Array" : ""];
2432									properties.push(prevKind);
2433									nextKind = properties.length;
2434									addObjectDiffToProperties(key, nextValue, properties, indent + 1) ? nextKind === properties.length && (prevKind[1] = "Referentially unequal but deeply equal objects. Consider memoization.") : isDeeplyEqual = !1;
2435									continue;
2436								}
2437							}
2438							else if ("function" === typeof key && "function" === typeof nextValue && key.name === nextValue.name && key.length === nextValue.length && (prevKind = Function.prototype.toString.call(key), nextKind = Function.prototype.toString.call(nextValue), prevKind === nextKind)) {
2439								key = "" === nextValue.name ? "() => {}" : nextValue.name + "() {}";
2440								properties.push([UNCHANGED + "\xA0\xA0".repeat(indent) + _key, key + " Referentially unequal function closure. Consider memoization."]);
2441								continue;
2442							}
2443						}
2444						addValueToProperties(_key, key, properties, indent, REMOVED);
2445						addValueToProperties(_key, nextValue, properties, indent, ADDED);
2446					}
2447					isDeeplyEqual = !1;
2448				}
2449			} else properties.push([ADDED + "\xA0\xA0".repeat(indent) + _key, "…"]), isDeeplyEqual = !1;
2450			return isDeeplyEqual;
2451		}
2452		function setCurrentTrackFromLanes(lanes) {
2453			currentTrack = lanes & 63 ? "Blocking" : lanes & 64 ? "Gesture" : lanes & 4194176 ? "Transition" : lanes & 62914560 ? "Suspense" : lanes & 2080374784 ? "Idle" : "Other";
2454		}
2455		function logComponentTrigger(fiber, startTime, endTime, trigger) {
2456			supportsUserTiming && (reusableComponentOptions.start = startTime, reusableComponentOptions.end = endTime, reusableComponentDevToolDetails.color = "warning", reusableComponentDevToolDetails.tooltipText = trigger, reusableComponentDevToolDetails.properties = null, (fiber = fiber._debugTask) ? fiber.run(performance.measure.bind(performance, trigger, reusableComponentOptions)) : performance.measure(trigger, reusableComponentOptions));
2457		}
2458		function logComponentReappeared(fiber, startTime, endTime) {
2459			logComponentTrigger(fiber, startTime, endTime, "Reconnect");
2460		}
2461		function logComponentRender(fiber, startTime, endTime, wasHydrated, committedLanes) {
2462			var name = getComponentNameFromFiber(fiber);
2463			if (null !== name && supportsUserTiming) {
2464				var alternate = fiber.alternate, selfTime = fiber.actualDuration;
2465				if (null === alternate || alternate.child !== fiber.child) for (var child = fiber.child; null !== child; child = child.sibling) selfTime -= child.actualDuration;
2466				wasHydrated = .5 > selfTime ? wasHydrated ? "tertiary-light" : "primary-light" : 10 > selfTime ? wasHydrated ? "tertiary" : "primary" : 100 > selfTime ? wasHydrated ? "tertiary-dark" : "primary-dark" : "error";
2467				var props = fiber.memoizedProps;
2468				selfTime = fiber._debugTask;
2469				null !== props && null !== alternate && alternate.memoizedProps !== props ? (child = [resuableChangedPropsEntry], props = addObjectDiffToProperties(alternate.memoizedProps, props, child, 0), 1 < child.length && (props && !alreadyWarnedForDeepEquality && 0 === (alternate.lanes & committedLanes) && 100 < fiber.actualDuration ? (alreadyWarnedForDeepEquality = !0, child[0] = reusableDeeplyEqualPropsEntry, reusableComponentDevToolDetails.color = "warning", reusableComponentDevToolDetails.tooltipText = DEEP_EQUALITY_WARNING) : (reusableComponentDevToolDetails.color = wasHydrated, reusableComponentDevToolDetails.tooltipText = name), reusableComponentDevToolDetails.properties = child, reusableComponentOptions.start = startTime, reusableComponentOptions.end = endTime, null != selfTime ? selfTime.run(performance.measure.bind(performance, "​" + name, reusableComponentOptions)) : performance.measure("​" + name, reusableComponentOptions))) : null != selfTime ? selfTime.run(console.timeStamp.bind(console, name, startTime, endTime, COMPONENTS_TRACK, void 0, wasHydrated)) : console.timeStamp(name, startTime, endTime, COMPONENTS_TRACK, void 0, wasHydrated);
2470			}
2471		}
2472		function logComponentErrored(fiber, startTime, endTime, errors) {
2473			if (supportsUserTiming) {
2474				var name = getComponentNameFromFiber(fiber);
2475				if (null !== name) {
2476					for (var debugTask = null, properties = [], i = 0; i < errors.length; i++) {
2477						var capturedValue = errors[i];
2478						null == debugTask && null !== capturedValue.source && (debugTask = capturedValue.source._debugTask);
2479						capturedValue = capturedValue.value;
2480						properties.push(["Error", "object" === typeof capturedValue && null !== capturedValue && "string" === typeof capturedValue.message ? String(capturedValue.message) : String(capturedValue)]);
2481					}
2482					null !== fiber.key && addValueToProperties("key", fiber.key, properties, 0, "");
2483					null !== fiber.memoizedProps && addObjectToProperties(fiber.memoizedProps, properties, 0, "");
2484					debugTask ??= fiber._debugTask;
2485					fiber = {
2486						start: startTime,
2487						end: endTime,
2488						detail: { devtools: {
2489							color: "error",
2490							track: COMPONENTS_TRACK,
2491							tooltipText: 13 === fiber.tag ? "Hydration failed" : "Error boundary caught an error",
2492							properties
2493						} }
2494					};
2495					debugTask ? debugTask.run(performance.measure.bind(performance, "​" + name, fiber)) : performance.measure("​" + name, fiber);
2496				}
2497			}
2498		}
2499		function logComponentEffect(fiber, startTime, endTime, selfTime, errors) {
2500			if (null !== errors) {
2501				if (supportsUserTiming) {
2502					var name = getComponentNameFromFiber(fiber);
2503					if (null !== name) {
2504						selfTime = [];
2505						for (var i = 0; i < errors.length; i++) {
2506							var error = errors[i].value;
2507							selfTime.push(["Error", "object" === typeof error && null !== error && "string" === typeof error.message ? String(error.message) : String(error)]);
2508						}
2509						null !== fiber.key && addValueToProperties("key", fiber.key, selfTime, 0, "");
2510						null !== fiber.memoizedProps && addObjectToProperties(fiber.memoizedProps, selfTime, 0, "");
2511						startTime = {
2512							start: startTime,
2513							end: endTime,
2514							detail: { devtools: {
2515								color: "error",
2516								track: COMPONENTS_TRACK,
2517								tooltipText: "A lifecycle or effect errored",
2518								properties: selfTime
2519							} }
2520						};
2521						(fiber = fiber._debugTask) ? fiber.run(performance.measure.bind(performance, "​" + name, startTime)) : performance.measure("​" + name, startTime);
2522					}
2523				}
2524			} else name = getComponentNameFromFiber(fiber), null !== name && supportsUserTiming && (errors = 1 > selfTime ? "secondary-light" : 100 > selfTime ? "secondary" : 500 > selfTime ? "secondary-dark" : "error", (fiber = fiber._debugTask) ? fiber.run(console.timeStamp.bind(console, name, startTime, endTime, COMPONENTS_TRACK, void 0, errors)) : console.timeStamp(name, startTime, endTime, COMPONENTS_TRACK, void 0, errors));
2525		}
2526		function logRenderPhase(startTime, endTime, lanes, debugTask) {
2527			if (supportsUserTiming && !(endTime <= startTime)) {
2528				var color = (lanes & 738197653) === lanes ? "tertiary-dark" : "primary-dark";
2529				lanes = (lanes & 536870912) === lanes ? "Prepared" : (lanes & 201326741) === lanes ? "Hydrated" : "Render";
2530				debugTask ? debugTask.run(console.timeStamp.bind(console, lanes, startTime, endTime, currentTrack, LANES_TRACK_GROUP, color)) : console.timeStamp(lanes, startTime, endTime, currentTrack, LANES_TRACK_GROUP, color);
2531			}
2532		}
2533		function logSuspendedRenderPhase(startTime, endTime, lanes, debugTask) {
2534			!supportsUserTiming || endTime <= startTime || (lanes = (lanes & 738197653) === lanes ? "tertiary-dark" : "primary-dark", debugTask ? debugTask.run(console.timeStamp.bind(console, "Prewarm", startTime, endTime, currentTrack, LANES_TRACK_GROUP, lanes)) : console.timeStamp("Prewarm", startTime, endTime, currentTrack, LANES_TRACK_GROUP, lanes));
2535		}
2536		function logSuspendedWithDelayPhase(startTime, endTime, lanes, debugTask) {
2537			!supportsUserTiming || endTime <= startTime || (lanes = (lanes & 738197653) === lanes ? "tertiary-dark" : "primary-dark", debugTask ? debugTask.run(console.timeStamp.bind(console, "Suspended", startTime, endTime, currentTrack, LANES_TRACK_GROUP, lanes)) : console.timeStamp("Suspended", startTime, endTime, currentTrack, LANES_TRACK_GROUP, lanes));
2538		}
2539		function logRecoveredRenderPhase(startTime, endTime, lanes, recoverableErrors, hydrationFailed, debugTask) {
2540			if (supportsUserTiming && !(endTime <= startTime)) {
2541				lanes = [];
2542				for (var i = 0; i < recoverableErrors.length; i++) {
2543					var error = recoverableErrors[i].value;
2544					lanes.push(["Recoverable Error", "object" === typeof error && null !== error && "string" === typeof error.message ? String(error.message) : String(error)]);
2545				}
2546				startTime = {
2547					start: startTime,
2548					end: endTime,
2549					detail: { devtools: {
2550						color: "primary-dark",
2551						track: currentTrack,
2552						trackGroup: LANES_TRACK_GROUP,
2553						tooltipText: hydrationFailed ? "Hydration Failed" : "Recovered after Error",
2554						properties: lanes
2555					} }
2556				};
2557				debugTask ? debugTask.run(performance.measure.bind(performance, "Recovered", startTime)) : performance.measure("Recovered", startTime);
2558			}
2559		}
2560		function logErroredRenderPhase(startTime, endTime, lanes, debugTask) {
2561			!supportsUserTiming || endTime <= startTime || (debugTask ? debugTask.run(console.timeStamp.bind(console, "Errored", startTime, endTime, currentTrack, LANES_TRACK_GROUP, "error")) : console.timeStamp("Errored", startTime, endTime, currentTrack, LANES_TRACK_GROUP, "error"));
2562		}
2563		function logSuspendedCommitPhase(startTime, endTime, reason, debugTask) {
2564			!supportsUserTiming || endTime <= startTime || (debugTask ? debugTask.run(console.timeStamp.bind(console, reason, startTime, endTime, currentTrack, LANES_TRACK_GROUP, "secondary-light")) : console.timeStamp(reason, startTime, endTime, currentTrack, LANES_TRACK_GROUP, "secondary-light"));
2565		}
2566		function logCommitErrored(startTime, endTime, errors, passive, debugTask) {