https://gsm79.ru/node_modules/.vite/deps/react-dom_client.js?v=26563ed1

11// node_modules/.pnpm/[email protected]/node_modules/scheduler/cjs/scheduler.development.js
12var require_scheduler_development = __commonJS({
13  "node_modules/.pnpm/[email protected]/node_modules/scheduler/cjs/scheduler.development.js"(exports) {
14    "use strict";
15    (function() {
16      function performWorkUntilDeadline() {
17        needsPaint = false;
18        if (isMessageLoopRunning) {
19          var currentTime = exports.unstable_now();
20          startTime = currentTime;
21          var hasMoreWork = true;
22          try {
23            a: {
24              isHostCallbackScheduled = false;
25              isHostTimeoutScheduled && (isHostTimeoutScheduled = false, localClearTimeout(taskTimeoutID), taskTimeoutID = -1);
26              isPerformingWork = true;
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(
37                        currentTask.expirationTime <= currentTime
38                      );
39                      currentTime = exports.unstable_now();
40                      if ("function" === typeof continuationCallback) {
41                        currentTask.callback = continuationCallback;
42                        advanceTimers(currentTime);
43                        hasMoreWork = true;
44                        break b;
45                      }
46                      currentTask === peek(taskQueue) && pop(taskQueue);
47                      advanceTimers(currentTime);
48                    } else pop(taskQueue);
49                    currentTask = peek(taskQueue);
50                  }
51                  if (null !== currentTask) hasMoreWork = true;
52                  else {
53                    var firstTimer = peek(timerQueue);
54                    null !== firstTimer && requestHostTimeout(
55                      handleTimeout,
56                      firstTimer.startTime - currentTime
57                    );
58                    hasMoreWork = false;
59                  }
60                }
61                break a;
62              } finally {
63                currentTask = null, currentPriorityLevel = previousPriorityLevel, isPerformingWork = false;
64              }
65              hasMoreWork = void 0;
66            }
67          } finally {
68            hasMoreWork ? schedulePerformWorkUntilDeadline() : isMessageLoopRunning = false;
69          }
70        }
71      }
72      function push(heap, node) {
73        var index = heap.length;
74        heap.push(node);
75        a: for (; 0 < index; ) {
76          var parentIndex = index - 1 >>> 1, parent = heap[parentIndex];
77          if (0 < compare(parent, node))
78            heap[parentIndex] = node, heap[index] = parent, index = parentIndex;
79          else break a;
80        }
81      }
82      function peek(heap) {
83        return 0 === heap.length ? null : heap[0];
84      }
85      function pop(heap) {
86        if (0 === heap.length) return null;
87        var first = heap[0], last = heap.pop();
88        if (last !== first) {
89          heap[0] = last;
90          a: for (var index = 0, length = heap.length, halfLength = length >>> 1; index < halfLength; ) {
91            var leftIndex = 2 * (index + 1) - 1, left = heap[leftIndex], rightIndex = leftIndex + 1, right = heap[rightIndex];
92            if (0 > compare(left, last))
93              rightIndex < length && 0 > compare(right, left) ? (heap[index] = right, heap[rightIndex] = last, index = rightIndex) : (heap[index] = left, heap[leftIndex] = last, index = leftIndex);
94            else if (rightIndex < length && 0 > compare(right, last))
95              heap[index] = right, heap[rightIndex] = last, index = rightIndex;
96            else break a;
97          }
98        }
99        return first;
100      }
101      function compare(a, b) {
102        var diff = a.sortIndex - b.sortIndex;
103        return 0 !== diff ? diff : a.id - b.id;
104      }
105      function advanceTimers(currentTime) {
106        for (var timer = peek(timerQueue); null !== timer; ) {
107          if (null === timer.callback) pop(timerQueue);
108          else if (timer.startTime <= currentTime)
109            pop(timerQueue), timer.sortIndex = timer.expirationTime, push(taskQueue, timer);
110          else break;
111          timer = peek(timerQueue);
112        }
113      }
114      function handleTimeout(currentTime) {
115        isHostTimeoutScheduled = false;
116        advanceTimers(currentTime);
117        if (!isHostCallbackScheduled)
118          if (null !== peek(taskQueue))
119            isHostCallbackScheduled = true, isMessageLoopRunning || (isMessageLoopRunning = true, schedulePerformWorkUntilDeadline());
120          else {
121            var firstTimer = peek(timerQueue);
122            null !== firstTimer && requestHostTimeout(
123              handleTimeout,
124              firstTimer.startTime - currentTime
125            );
126          }
127      }
128      function shouldYieldToHost() {
129        return needsPaint ? true : exports.unstable_now() - startTime < frameInterval ? false : true;
130      }
131      function requestHostTimeout(callback, ms) {
132        taskTimeoutID = localSetTimeout(function() {
133          callback(exports.unstable_now());
134        }, ms);
135      }
136      "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
137      exports.unstable_now = void 0;
138      if ("object" === typeof performance && "function" === typeof performance.now) {
139        var localPerformance = performance;
140        exports.unstable_now = function() {
141          return localPerformance.now();
142        };
143      } else {
144        var localDate = Date, initialTime = localDate.now();
145        exports.unstable_now = function() {
146          return localDate.now() - initialTime;
147        };
148      }
149      var taskQueue = [], timerQueue = [], taskIdCounter = 1, currentTask = null, currentPriorityLevel = 3, isPerformingWork = false, isHostCallbackScheduled = false, isHostTimeoutScheduled = false, needsPaint = false, localSetTimeout = "function" === typeof setTimeout ? setTimeout : null, localClearTimeout = "function" === typeof clearTimeout ? clearTimeout : null, localSetImmediate = "undefined" !== typeof setImmediate ? setImmediate : null, isMessageLoopRunning = false, taskTimeoutID = -1, frameInterval = 5, startTime = -1;
150      if ("function" === typeof localSetImmediate)
151        var schedulePerformWorkUntilDeadline = function() {
152          localSetImmediate(performWorkUntilDeadline);
153        };
154      else if ("undefined" !== typeof MessageChannel) {
155        var channel = new MessageChannel(), port = channel.port2;
156        channel.port1.onmessage = performWorkUntilDeadline;
157        schedulePerformWorkUntilDeadline = function() {
158          port.postMessage(null);
159        };
160      } else
161        schedulePerformWorkUntilDeadline = function() {
162          localSetTimeout(performWorkUntilDeadline, 0);
163        };
164      exports.unstable_IdlePriority = 5;
165      exports.unstable_ImmediatePriority = 1;
166      exports.unstable_LowPriority = 4;
167      exports.unstable_NormalPriority = 3;
168      exports.unstable_Profiling = null;
169      exports.unstable_UserBlockingPriority = 2;
170      exports.unstable_cancelCallback = function(task) {
171        task.callback = null;
172      };
173      exports.unstable_forceFrameRate = function(fps) {
174        0 > fps || 125 < fps ? console.error(
175          "forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported"
176        ) : frameInterval = 0 < fps ? Math.floor(1e3 / fps) : 5;
177      };
178      exports.unstable_getCurrentPriorityLevel = function() {
179        return currentPriorityLevel;
180      };
181      exports.unstable_next = function(eventHandler) {
182        switch (currentPriorityLevel) {
183          case 1:
184          case 2:
185          case 3:
186            var priorityLevel = 3;
187            break;
188          default:
189            priorityLevel = currentPriorityLevel;
190        }
191        var previousPriorityLevel = currentPriorityLevel;
192        currentPriorityLevel = priorityLevel;
193        try {
194          return eventHandler();
195        } finally {
196          currentPriorityLevel = previousPriorityLevel;
197        }
198      };
199      exports.unstable_requestPaint = function() {
200        needsPaint = true;
201      };
202      exports.unstable_runWithPriority = function(priorityLevel, eventHandler) {
203        switch (priorityLevel) {
204          case 1:
205          case 2:
206          case 3:
207          case 4:
208          case 5:
209            break;
210          default:
211            priorityLevel = 3;
212        }
213        var previousPriorityLevel = currentPriorityLevel;
214        currentPriorityLevel = priorityLevel;
215        try {
216          return eventHandler();
217        } finally {
218          currentPriorityLevel = previousPriorityLevel;
219        }
220      };
221      exports.unstable_scheduleCallback = function(priorityLevel, callback, options) {
222        var currentTime = exports.unstable_now();
223        "object" === typeof options && null !== options ? (options = options.delay, options = "number" === typeof options && 0 < options ? currentTime + options : currentTime) : options = currentTime;
224        switch (priorityLevel) {
225          case 1:
226            var timeout = -1;
227            break;
228          case 2:
229            timeout = 250;
230            break;
231          case 5:
232            timeout = 1073741823;
233            break;
234          case 4:
235            timeout = 1e4;
236            break;
237          default:
238            timeout = 5e3;
239        }
240        timeout = options + timeout;
241        priorityLevel = {
242          id: taskIdCounter++,
243          callback,
244          priorityLevel,
245          startTime: options,
246          expirationTime: timeout,
247          sortIndex: -1
248        };
249        options > currentTime ? (priorityLevel.sortIndex = options, push(timerQueue, priorityLevel), null === peek(taskQueue) && priorityLevel === peek(timerQueue) && (isHostTimeoutScheduled ? (localClearTimeout(taskTimeoutID), taskTimeoutID = -1) : isHostTimeoutScheduled = true, requestHostTimeout(handleTimeout, options - currentTime))) : (priorityLevel.sortIndex = timeout, push(taskQueue, priorityLevel), isHostCallbackScheduled || isPerformingWork || (isHostCallbackScheduled = true, isMessageLoopRunning || (isMessageLoopRunning = true, schedulePerformWorkUntilDeadline())));
250        return priorityLevel;
251      };
252      exports.unstable_shouldYield = shouldYieldToHost;
253      exports.unstable_wrapCallback = function(callback) {
254        var parentPriorityLevel = currentPriorityLevel;
255        return function() {
256          var previousPriorityLevel = currentPriorityLevel;
257          currentPriorityLevel = parentPriorityLevel;
258          try {
259            return callback.apply(this, arguments);
260          } finally {
261            currentPriorityLevel = previousPriorityLevel;
262          }
263        };
264      };
265      "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
266    })();
267  }
268});
269

270// node_modules/.pnpm/[email protected]/node_modules/scheduler/index.js
271var require_scheduler = __commonJS({
272  "node_modules/.pnpm/[email protected]/node_modules/scheduler/index.js"(exports, module) {
273    "use strict";
274    if (false) {
275      module.exports = null;
276    } else {
277      module.exports = require_scheduler_development();
278    }
279  }
280});
281

282// node_modules/.pnpm/[email protected][email protected]/node_modules/react-dom/cjs/react-dom-client.development.js
283var require_react_dom_client_development = __commonJS({
284  "node_modules/.pnpm/[email protected][email protected]/node_modules/react-dom/cjs/react-dom-client.development.js"(exports) {
285    "use strict";
286    (function() {
287      function findHook(fiber, id) {
288        for (fiber = fiber.memoizedState; null !== fiber && 0 < id; )
289          fiber = fiber.next, id--;
290        return fiber;
291      }
292      function copyWithSetImpl(obj, path, index, value) {
293        if (index >= path.length) return value;
294        var key = path[index], updated = isArrayImpl(obj) ? obj.slice() : assign({}, obj);
295        updated[key] = copyWithSetImpl(obj[key], path, index + 1, value);
296        return updated;
297      }
298      function copyWithRename(obj, oldPath, newPath) {
299        if (oldPath.length !== newPath.length)
300          console.warn("copyWithRename() expects paths of the same length");
301        else {
302          for (var i = 0; i < newPath.length - 1; i++)
303            if (oldPath[i] !== newPath[i]) {
304              console.warn(
305                "copyWithRename() expects paths to be the same except for the deepest key"
306              );
307              return;
308            }
309          return copyWithRenameImpl(obj, oldPath, newPath, 0);
310        }
311      }
312      function copyWithRenameImpl(obj, oldPath, newPath, index) {
313        var oldKey = oldPath[index], updated = isArrayImpl(obj) ? obj.slice() : assign({}, obj);
314        index + 1 === oldPath.length ? (updated[newPath[index]] = updated[oldKey], isArrayImpl(updated) ? updated.splice(oldKey, 1) : delete updated[oldKey]) : updated[oldKey] = copyWithRenameImpl(
315          obj[oldKey],
316          oldPath,
317          newPath,
318          index + 1
319        );
320        return updated;
321      }
322      function copyWithDeleteImpl(obj, path, index) {
323        var key = path[index], updated = isArrayImpl(obj) ? obj.slice() : assign({}, obj);
324        if (index + 1 === path.length)
325          return isArrayImpl(updated) ? updated.splice(key, 1) : delete updated[key], updated;
326        updated[key] = copyWithDeleteImpl(obj[key], path, index + 1);
327        return updated;
328      }
329      function shouldSuspendImpl() {
330        return false;
331      }
332      function shouldErrorImpl() {
333        return null;
334      }
335      function warnInvalidHookAccess() {
336        console.error(
337          "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"
338        );
339      }
340      function warnInvalidContextAccess() {
341        console.error(
342          "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()."
343        );
344      }
345      function noop() {
346      }
347      function warnForMissingKey() {
348      }
349      function setToSortedString(set) {
350        var array = [];
351        set.forEach(function(value) {
352          array.push(value);
353        });
354        return array.sort().join(", ");
355      }
356      function createFiber(tag, pendingProps, key, mode) {
357        return new FiberNode(tag, pendingProps, key, mode);
358      }
359      function scheduleRoot(root2, element) {
360        root2.context === emptyContextObject && (updateContainerImpl(root2.current, 2, element, root2, null, null), flushSyncWork$1());
361      }
362      function scheduleRefresh(root2, update) {
363        if (null !== resolveFamily) {
364          var staleFamilies = update.staleFamilies;
365          update = update.updatedFamilies;
366          flushPendingEffects();
367          scheduleFibersWithFamiliesRecursively(
368            root2.current,
369            update,
370            staleFamilies
371          );
372          flushSyncWork$1();
373        }
374      }
375      function setRefreshHandler(handler) {
376        resolveFamily = handler;
377      }
378      function isValidContainer(node) {
379        return !(!node || 1 !== node.nodeType && 9 !== node.nodeType && 11 !== node.nodeType);
380      }
381      function getNearestMountedFiber(fiber) {
382        var node = fiber, nearestMounted = fiber;
383        if (fiber.alternate) for (; node.return; ) node = node.return;
384        else {
385          fiber = node;
386          do
387            node = fiber, 0 !== (node.flags & 4098) && (nearestMounted = node.return), fiber = node.return;
388          while (fiber);
389        }
390        return 3 === node.tag ? nearestMounted : null;
391      }
392      function getSuspenseInstanceFromFiber(fiber) {
393        if (13 === fiber.tag) {
394          var suspenseState = fiber.memoizedState;
395          null === suspenseState && (fiber = fiber.alternate, null !== fiber && (suspenseState = fiber.memoizedState));
396          if (null !== suspenseState) return suspenseState.dehydrated;
397        }
398        return null;
399      }
400      function getActivityInstanceFromFiber(fiber) {
401        if (31 === fiber.tag) {
402          var activityState = fiber.memoizedState;
403          null === activityState && (fiber = fiber.alternate, null !== fiber && (activityState = fiber.memoizedState));
404          if (null !== activityState) return activityState.dehydrated;
405        }
406        return null;
407      }
408      function assertIsMounted(fiber) {
409        if (getNearestMountedFiber(fiber) !== fiber)
410          throw Error("Unable to find node on an unmounted component.");
411      }
412      function findCurrentFiberUsingSlowPath(fiber) {
413        var alternate = fiber.alternate;
414        if (!alternate) {
415          alternate = getNearestMountedFiber(fiber);
416          if (null === alternate)
417            throw Error("Unable to find node on an unmounted component.");
418          return alternate !== fiber ? null : fiber;
419        }
420        for (var a = fiber, b = alternate; ; ) {
421          var parentA = a.return;
422          if (null === parentA) break;
423          var parentB = parentA.alternate;
424          if (null === parentB) {
425            b = parentA.return;
426            if (null !== b) {
427              a = b;
428              continue;
429            }
430            break;
431          }
432          if (parentA.child === parentB.child) {
433            for (parentB = parentA.child; parentB; ) {
434              if (parentB === a) return assertIsMounted(parentA), fiber;
435              if (parentB === b) return assertIsMounted(parentA), alternate;
436              parentB = parentB.sibling;
437            }
438            throw Error("Unable to find node on an unmounted component.");
439          }
440          if (a.return !== b.return) a = parentA, b = parentB;
441          else {
442            for (var didFindChild = false, _child = parentA.child; _child; ) {
443              if (_child === a) {
444                didFindChild = true;
445                a = parentA;
446                b = parentB;
447                break;
448              }
449              if (_child === b) {
450                didFindChild = true;
451                b = parentA;
452                a = parentB;
453                break;
454              }
455              _child = _child.sibling;
456            }
457            if (!didFindChild) {
458              for (_child = parentB.child; _child; ) {
459                if (_child === a) {
460                  didFindChild = true;
461                  a = parentB;
462                  b = parentA;
463                  break;
464                }
465                if (_child === b) {
466                  didFindChild = true;
467                  b = parentB;
468                  a = parentA;
469                  break;
470                }
471                _child = _child.sibling;
472              }
473              if (!didFindChild)
474                throw Error(
475                  "Child was not found in either parent set. This indicates a bug in React related to the return pointer. Please file an issue."
476                );
477            }
478          }
479          if (a.alternate !== b)
480            throw Error(
481              "Return fibers should always be each others' alternates. This error is likely caused by a bug in React. Please file an issue."
482            );
483        }
484        if (3 !== a.tag)
485          throw Error("Unable to find node on an unmounted component.");
486        return a.stateNode.current === a ? fiber : alternate;
487      }
488      function findCurrentHostFiberImpl(node) {
489        var tag = node.tag;
490        if (5 === tag || 26 === tag || 27 === tag || 6 === tag) return node;
491        for (node = node.child; null !== node; ) {
492          tag = findCurrentHostFiberImpl(node);
493          if (null !== tag) return tag;
494          node = node.sibling;
495        }
496        return null;
497      }
498      function getIteratorFn(maybeIterable) {
499        if (null === maybeIterable || "object" !== typeof maybeIterable)
500          return null;
501        maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
502        return "function" === typeof maybeIterable ? maybeIterable : null;
503      }
504      function getComponentNameFromType(type) {
505        if (null == type) return null;
506        if ("function" === typeof type)
507          return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
508        if ("string" === typeof type) return type;
509        switch (type) {
510          case REACT_FRAGMENT_TYPE:
511            return "Fragment";
512          case REACT_PROFILER_TYPE:
513            return "Profiler";
514          case REACT_STRICT_MODE_TYPE:
515            return "StrictMode";
516          case REACT_SUSPENSE_TYPE:
517            return "Suspense";
518          case REACT_SUSPENSE_LIST_TYPE:
519            return "SuspenseList";
520          case REACT_ACTIVITY_TYPE:
521            return "Activity";
522        }
523        if ("object" === typeof type)
524          switch ("number" === typeof type.tag && console.error(
525            "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
526          ), type.$$typeof) {
527            case REACT_PORTAL_TYPE:
528              return "Portal";
529            case REACT_CONTEXT_TYPE:
530              return type.displayName || "Context";
531            case REACT_CONSUMER_TYPE:
532              return (type._context.displayName || "Context") + ".Consumer";
533            case REACT_FORWARD_REF_TYPE:
534              var innerType = type.render;
535              type = type.displayName;
536              type || (type = innerType.displayName || innerType.name || "", type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef");
537              return type;
538            case REACT_MEMO_TYPE:
539              return innerType = type.displayName || null, null !== innerType ? innerType : getComponentNameFromType(type.type) || "Memo";
540            case REACT_LAZY_TYPE:
541              innerType = type._payload;
542              type = type._init;
543              try {
544                return getComponentNameFromType(type(innerType));
545              } catch (x) {
546              }
547          }
548        return null;
549      }
550      function getComponentNameFromOwner(owner) {
551        return "number" === typeof owner.tag ? getComponentNameFromFiber(owner) : "string" === typeof owner.name ? owner.name : null;
552      }
553      function getComponentNameFromFiber(fiber) {
554        var type = fiber.type;
555        switch (fiber.tag) {
556          case 31:
557            return "Activity";
558          case 24:
559            return "Cache";
560          case 9:
561            return (type._context.displayName || "Context") + ".Consumer";
562          case 10:
563            return type.displayName || "Context";
564          case 18:
565            return "DehydratedFragment";
566          case 11:
567            return fiber = type.render, fiber = fiber.displayName || fiber.name || "", type.displayName || ("" !== fiber ? "ForwardRef(" + fiber + ")" : "ForwardRef");
568          case 7:
569            return "Fragment";
570          case 26:
571          case 27:
572          case 5:
573            return type;
574          case 4:
575            return "Portal";
576          case 3:
577            return "Root";
578          case 6:
579            return "Text";
580          case 16:
581            return getComponentNameFromType(type);
582          case 8:
583            return type === REACT_STRICT_MODE_TYPE ? "StrictMode" : "Mode";
584          case 22:
585            return "Offscreen";
586          case 12:
587            return "Profiler";
588          case 21:
589            return "Scope";
590          case 13:
591            return "Suspense";
592          case 19:
593            return "SuspenseList";
594          case 25:
595            return "TracingMarker";
596          case 1:
597          case 0:
598          case 14:
599          case 15:
600            if ("function" === typeof type)
601              return type.displayName || type.name || null;
602            if ("string" === typeof type) return type;
603            break;
604          case 29:
605            type = fiber._debugInfo;
606            if (null != type) {
607              for (var i = type.length - 1; 0 <= i; i--)
608                if ("string" === typeof type[i].name) return type[i].name;
609            }
610            if (null !== fiber.return)
611              return getComponentNameFromFiber(fiber.return);
612        }
613        return null;
614      }
615      function createCursor(defaultValue) {
616        return { current: defaultValue };
617      }
618      function pop(cursor, fiber) {
619        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--);
620      }
621      function push(cursor, value, fiber) {
622        index$jscomp$0++;
623        valueStack[index$jscomp$0] = cursor.current;
624        fiberStack[index$jscomp$0] = fiber;
625        cursor.current = value;
626      }
627      function requiredContext(c) {
628        null === c && console.error(
629          "Expected host context to exist. This error is likely caused by a bug in React. Please file an issue."
630        );
631        return c;
632      }
633      function pushHostContainer(fiber, nextRootInstance) {
634        push(rootInstanceStackCursor, nextRootInstance, fiber);
635        push(contextFiberStackCursor, fiber, fiber);
636        push(contextStackCursor, null, fiber);
637        var nextRootContext = nextRootInstance.nodeType;
638        switch (nextRootContext) {
639          case 9:
640          case 11:
641            nextRootContext = 9 === nextRootContext ? "#document" : "#fragment";
642            nextRootInstance = (nextRootInstance = nextRootInstance.documentElement) ? (nextRootInstance = nextRootInstance.namespaceURI) ? getOwnHostContext(nextRootInstance) : HostContextNamespaceNone : HostContextNamespaceNone;
643            break;
644          default:
645            if (nextRootContext = nextRootInstance.tagName, nextRootInstance = nextRootInstance.namespaceURI)
646              nextRootInstance = getOwnHostContext(nextRootInstance), nextRootInstance = getChildHostContextProd(
647                nextRootInstance,
648                nextRootContext
649              );
650            else
651              switch (nextRootContext) {
652                case "svg":
653                  nextRootInstance = HostContextNamespaceSvg;
654                  break;
655                case "math":
656                  nextRootInstance = HostContextNamespaceMath;
657                  break;
658                default:
659                  nextRootInstance = HostContextNamespaceNone;
660              }
661        }
662        nextRootContext = nextRootContext.toLowerCase();
663        nextRootContext = updatedAncestorInfoDev(null, nextRootContext);
664        nextRootContext = {
665          context: nextRootInstance,
666          ancestorInfo: nextRootContext
667        };
668        pop(contextStackCursor, fiber);
669        push(contextStackCursor, nextRootContext, fiber);
670      }
671      function popHostContainer(fiber) {
672        pop(contextStackCursor, fiber);
673        pop(contextFiberStackCursor, fiber);
674        pop(rootInstanceStackCursor, fiber);
675      }
676      function getHostContext() {
677        return requiredContext(contextStackCursor.current);
678      }
679      function pushHostContext(fiber) {
680        null !== fiber.memoizedState && push(hostTransitionProviderCursor, fiber, fiber);
681        var context = requiredContext(contextStackCursor.current);
682        var type = fiber.type;
683        var nextContext = getChildHostContextProd(context.context, type);
684        type = updatedAncestorInfoDev(context.ancestorInfo, type);
685        nextContext = { context: nextContext, ancestorInfo: type };
686        context !== nextContext && (push(contextFiberStackCursor, fiber, fiber), push(contextStackCursor, nextContext, fiber));
687      }
688      function popHostContext(fiber) {
689        contextFiberStackCursor.current === fiber && (pop(contextStackCursor, fiber), pop(contextFiberStackCursor, fiber));
690        hostTransitionProviderCursor.current === fiber && (pop(hostTransitionProviderCursor, fiber), HostTransitionContext._currentValue = NotPendingTransition);
691      }
692      function disabledLog() {
693      }
694      function disableLogs() {
695        if (0 === disabledDepth) {
696          prevLog = console.log;
697          prevInfo = console.info;
698          prevWarn = console.warn;
699          prevError = console.error;
700          prevGroup = console.group;
701          prevGroupCollapsed = console.groupCollapsed;
702          prevGroupEnd = console.groupEnd;
703          var props = {
704            configurable: true,
705            enumerable: true,
706            value: disabledLog,
707            writable: true
708          };
709          Object.defineProperties(console, {
710            info: props,
711            log: props,
712            warn: props,
713            error: props,
714            group: props,
715            groupCollapsed: props,
716            groupEnd: props
717          });
718        }
719        disabledDepth++;
720      }
721      function reenableLogs() {
722        disabledDepth--;
723        if (0 === disabledDepth) {
724          var props = { configurable: true, enumerable: true, writable: true };
725          Object.defineProperties(console, {
726            log: assign({}, props, { value: prevLog }),
727            info: assign({}, props, { value: prevInfo }),
728            warn: assign({}, props, { value: prevWarn }),
729            error: assign({}, props, { value: prevError }),
730            group: assign({}, props, { value: prevGroup }),
731            groupCollapsed: assign({}, props, { value: prevGroupCollapsed }),
732            groupEnd: assign({}, props, { value: prevGroupEnd })
733          });
734        }
735        0 > disabledDepth && console.error(
736          "disabledDepth fell below zero. This is a bug in React. Please file an issue."
737        );
738      }
739      function formatOwnerStack(error) {
740        var prevPrepareStackTrace = Error.prepareStackTrace;
741        Error.prepareStackTrace = void 0;
742        error = error.stack;
743        Error.prepareStackTrace = prevPrepareStackTrace;
744        error.startsWith("Error: react-stack-top-frame\n") && (error = error.slice(29));
745        prevPrepareStackTrace = error.indexOf("\n");
746        -1 !== prevPrepareStackTrace && (error = error.slice(prevPrepareStackTrace + 1));
747        prevPrepareStackTrace = error.indexOf("react_stack_bottom_frame");
748        -1 !== prevPrepareStackTrace && (prevPrepareStackTrace = error.lastIndexOf(
749          "\n",
750          prevPrepareStackTrace
751        ));
752        if (-1 !== prevPrepareStackTrace)
753          error = error.slice(0, prevPrepareStackTrace);
754        else return "";
755        return error;
756      }
757      function describeBuiltInComponentFrame(name) {
758        if (void 0 === prefix)
759          try {
760            throw Error();
761          } catch (x) {
762            var match = x.stack.trim().match(/\n( *(at )?)/);
763            prefix = match && match[1] || "";
764            suffix = -1 < x.stack.indexOf("\n    at") ? " (<anonymous>)" : -1 < x.stack.indexOf("@") ? "@unknown:0:0" : "";
765          }
766        return "\n" + prefix + name + suffix;
767      }
768      function describeNativeComponentFrame(fn, construct) {
769        if (!fn || reentry) return "";
770        var frame = componentFrameCache.get(fn);
771        if (void 0 !== frame) return frame;
772        reentry = true;
773        frame = Error.prepareStackTrace;
774        Error.prepareStackTrace = void 0;
775        var previousDispatcher2 = null;
776        previousDispatcher2 = ReactSharedInternals.H;
777        ReactSharedInternals.H = null;
778        disableLogs();
779        try {
780          var RunInRootFrame = {
781            DetermineComponentFrameRoot: function() {
782              try {
783                if (construct) {
784                  var Fake = function() {
785                    throw Error();
786                  };
787                  Object.defineProperty(Fake.prototype, "props", {
788                    set: function() {
789                      throw Error();
790                    }
791                  });
792                  if ("object" === typeof Reflect && Reflect.construct) {
793                    try {
794                      Reflect.construct(Fake, []);
795                    } catch (x) {
796                      var control = x;
797                    }
798                    Reflect.construct(fn, [], Fake);
799                  } else {
800                    try {
801                      Fake.call();
802                    } catch (x$0) {
803                      control = x$0;
804                    }
805                    fn.call(Fake.prototype);
806                  }
807                } else {
808                  try {
809                    throw Error();
810                  } catch (x$1) {
811                    control = x$1;
812                  }
813                  (Fake = fn()) && "function" === typeof Fake.catch && Fake.catch(function() {
814                  });
815                }
816              } catch (sample) {
817                if (sample && control && "string" === typeof sample.stack)
818                  return [sample.stack, control.stack];
819              }
820              return [null, null];
821            }
822          };
823          RunInRootFrame.DetermineComponentFrameRoot.displayName = "DetermineComponentFrameRoot";
824          var namePropDescriptor = Object.getOwnPropertyDescriptor(
825            RunInRootFrame.DetermineComponentFrameRoot,
826            "name"
827          );
828          namePropDescriptor && namePropDescriptor.configurable && Object.defineProperty(
829            RunInRootFrame.DetermineComponentFrameRoot,
830            "name",
831            { value: "DetermineComponentFrameRoot" }
832          );
833          var _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(), sampleStack = _RunInRootFrame$Deter[0], controlStack = _RunInRootFrame$Deter[1];
834          if (sampleStack && controlStack) {
835            var sampleLines = sampleStack.split("\n"), controlLines = controlStack.split("\n");
836            for (_RunInRootFrame$Deter = namePropDescriptor = 0; namePropDescriptor < sampleLines.length && !sampleLines[namePropDescriptor].includes(
837              "DetermineComponentFrameRoot"
838            ); )
839              namePropDescriptor++;
840            for (; _RunInRootFrame$Deter < controlLines.length && !controlLines[_RunInRootFrame$Deter].includes(
841              "DetermineComponentFrameRoot"
842            ); )
843              _RunInRootFrame$Deter++;
844            if (namePropDescriptor === sampleLines.length || _RunInRootFrame$Deter === controlLines.length)
845              for (namePropDescriptor = sampleLines.length - 1, _RunInRootFrame$Deter = controlLines.length - 1; 1 <= namePropDescriptor && 0 <= _RunInRootFrame$Deter && sampleLines[namePropDescriptor] !== controlLines[_RunInRootFrame$Deter]; )
846                _RunInRootFrame$Deter--;
847            for (; 1 <= namePropDescriptor && 0 <= _RunInRootFrame$Deter; namePropDescriptor--, _RunInRootFrame$Deter--)
848              if (sampleLines[namePropDescriptor] !== controlLines[_RunInRootFrame$Deter]) {
849                if (1 !== namePropDescriptor || 1 !== _RunInRootFrame$Deter) {
850                  do
851                    if (namePropDescriptor--, _RunInRootFrame$Deter--, 0 > _RunInRootFrame$Deter || sampleLines[namePropDescriptor] !== controlLines[_RunInRootFrame$Deter]) {
852                      var _frame = "\n" + sampleLines[namePropDescriptor].replace(
853                        " at new ",
854                        " at "
855                      );
856                      fn.displayName && _frame.includes("<anonymous>") && (_frame = _frame.replace("<anonymous>", fn.displayName));
857                      "function" === typeof fn && componentFrameCache.set(fn, _frame);
858                      return _frame;
859                    }
860                  while (1 <= namePropDescriptor && 0 <= _RunInRootFrame$Deter);
861                }
862                break;
863              }
864          }
865        } finally {
866          reentry = false, ReactSharedInternals.H = previousDispatcher2, reenableLogs(), Error.prepareStackTrace = frame;
867        }
868        sampleLines = (sampleLines = fn ? fn.displayName || fn.name : "") ? describeBuiltInComponentFrame(sampleLines) : "";
869        "function" === typeof fn && componentFrameCache.set(fn, sampleLines);
870        return sampleLines;
871      }
872      function describeFiber(fiber, childFiber) {
873        switch (fiber.tag) {
874          case 26:
875          case 27:
876          case 5:
877            return describeBuiltInComponentFrame(fiber.type);
878          case 16:
879            return describeBuiltInComponentFrame("Lazy");
880          case 13:
881            return fiber.child !== childFiber && null !== childFiber ? describeBuiltInComponentFrame("Suspense Fallback") : describeBuiltInComponentFrame("Suspense");
882          case 19:
883            return describeBuiltInComponentFrame("SuspenseList");
884          case 0:
885          case 15:
886            return describeNativeComponentFrame(fiber.type, false);
887          case 11:
888            return describeNativeComponentFrame(fiber.type.render, false);
889          case 1:
890            return describeNativeComponentFrame(fiber.type, true);
891          case 31:
892            return describeBuiltInComponentFrame("Activity");
893          default:
894            return "";
895        }
896      }
897      function getStackByFiberInDevAndProd(workInProgress2) {
898        try {
899          var info = "", previous = null;
900          do {
901            info += describeFiber(workInProgress2, previous);
902            var debugInfo = workInProgress2._debugInfo;
903            if (debugInfo)
904              for (var i = debugInfo.length - 1; 0 <= i; i--) {
905                var entry = debugInfo[i];
906                if ("string" === typeof entry.name) {
907                  var JSCompiler_temp_const = info;
908                  a: {
909                    var name = entry.name, env = entry.env, location = entry.debugLocation;
910                    if (null != location) {
911                      var childStack = formatOwnerStack(location), idx = childStack.lastIndexOf("\n"), lastLine = -1 === idx ? childStack : childStack.slice(idx + 1);
912                      if (-1 !== lastLine.indexOf(name)) {
913                        var JSCompiler_inline_result = "\n" + lastLine;
914                        break a;
915                      }
916                    }
917                    JSCompiler_inline_result = describeBuiltInComponentFrame(
918                      name + (env ? " [" + env + "]" : "")
919                    );
920                  }
921                  info = JSCompiler_temp_const + JSCompiler_inline_result;
922                }
923              }
924            previous = workInProgress2;
925            workInProgress2 = workInProgress2.return;
926          } while (workInProgress2);
927          return info;
928        } catch (x) {
929          return "\nError generating stack: " + x.message + "\n" + x.stack;
930        }
931      }
932      function describeFunctionComponentFrameWithoutLineNumber(fn) {
933        return (fn = fn ? fn.displayName || fn.name : "") ? describeBuiltInComponentFrame(fn) : "";
934      }
935      function getCurrentFiberOwnerNameInDevOrNull() {
936        if (null === current) return null;
937        var owner = current._debugOwner;
938        return null != owner ? getComponentNameFromOwner(owner) : null;
939      }
940      function getCurrentFiberStackInDev() {
941        if (null === current) return "";
942        var workInProgress2 = current;
943        try {
944          var info = "";
945          6 === workInProgress2.tag && (workInProgress2 = workInProgress2.return);
946          switch (workInProgress2.tag) {
947            case 26:
948            case 27:
949            case 5:
950              info += describeBuiltInComponentFrame(workInProgress2.type);
951              break;
952            case 13:
953              info += describeBuiltInComponentFrame("Suspense");
954              break;
955            case 19:
956              info += describeBuiltInComponentFrame("SuspenseList");
957              break;
958            case 31:
959              info += describeBuiltInComponentFrame("Activity");
960              break;
961            case 30:
962            case 0:
963            case 15:
964            case 1:
965              workInProgress2._debugOwner || "" !== info || (info += describeFunctionComponentFrameWithoutLineNumber(
966                workInProgress2.type
967              ));
968              break;
969            case 11:
970              workInProgress2._debugOwner || "" !== info || (info += describeFunctionComponentFrameWithoutLineNumber(
971                workInProgress2.type.render
972              ));
973          }
974          for (; workInProgress2; )
975            if ("number" === typeof workInProgress2.tag) {
976              var fiber = workInProgress2;
977              workInProgress2 = fiber._debugOwner;
978              var debugStack = fiber._debugStack;
979              if (workInProgress2 && debugStack) {
980                var formattedStack = formatOwnerStack(debugStack);
981                "" !== formattedStack && (info += "\n" + formattedStack);
982              }
983            } else if (null != workInProgress2.debugStack) {
984              var ownerStack = workInProgress2.debugStack;
985              (workInProgress2 = workInProgress2.owner) && ownerStack && (info += "\n" + formatOwnerStack(ownerStack));
986            } else break;
987          var JSCompiler_inline_result = info;
988        } catch (x) {
989          JSCompiler_inline_result = "\nError generating stack: " + x.message + "\n" + x.stack;
990        }
991        return JSCompiler_inline_result;
992      }
993      function runWithFiberInDEV(fiber, callback, arg0, arg1, arg2, arg3, arg4) {
994        var previousFiber = current;
995        setCurrentFiber(fiber);
996        try {
997          return null !== fiber && fiber._debugTask ? fiber._debugTask.run(
998            callback.bind(null, arg0, arg1, arg2, arg3, arg4)
999          ) : callback(arg0, arg1, arg2, arg3, arg4);
1000        } finally {
1001          setCurrentFiber(previousFiber);
1002        }
1003        throw Error(
1004          "runWithFiberInDEV should never be called in production. This is a bug in React."
1005        );
1006      }
1007      function setCurrentFiber(fiber) {
1008        ReactSharedInternals.getCurrentStack = null === fiber ? null : getCurrentFiberStackInDev;
1009        isRendering = false;
1010        current = fiber;
1011      }
1012      function typeName(value) {
1013        return "function" === typeof Symbol && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
1014      }
1015      function willCoercionThrow(value) {
1016        try {
1017          return testStringCoercion(value), false;
1018        } catch (e) {
1019          return true;
1020        }
1021      }
1022      function testStringCoercion(value) {
1023        return "" + value;
1024      }
1025      function checkAttributeStringCoercion(value, attributeName) {
1026        if (willCoercionThrow(value))
1027          return console.error(
1028            "The provided `%s` attribute is an unsupported type %s. This value must be coerced to a string before using it here.",
1029            attributeName,
1030            typeName(value)
1031          ), testStringCoercion(value);
1032      }
1033      function checkCSSPropertyStringCoercion(value, propName) {
1034        if (willCoercionThrow(value))
1035          return console.error(
1036            "The provided `%s` CSS property is an unsupported type %s. This value must be coerced to a string before using it here.",
1037            propName,
1038            typeName(value)
1039          ), testStringCoercion(value);
1040      }
1041      function checkFormFieldValueStringCoercion(value) {
1042        if (willCoercionThrow(value))
1043          return console.error(
1044            "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.",
1045            typeName(value)
1046          ), testStringCoercion(value);
1047      }
1048      function injectInternals(internals) {
1049        if ("undefined" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__) return false;
1050        var hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
1051        if (hook.isDisabled) return true;
1052        if (!hook.supportsFiber)
1053          return console.error(
1054            "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"
1055          ), true;
1056        try {
1057          rendererID = hook.inject(internals), injectedHook = hook;
1058        } catch (err) {
1059          console.error("React instrumentation encountered an error: %o.", err);
1060        }
1061        return hook.checkDCE ? true : false;
1062      }
1063      function setIsStrictModeForDevtools(newIsStrictMode) {
1064        "function" === typeof log$1 && unstable_setDisableYieldValue(newIsStrictMode);
1065        if (injectedHook && "function" === typeof injectedHook.setStrictMode)
1066          try {
1067            injectedHook.setStrictMode(rendererID, newIsStrictMode);
1068          } catch (err) {
1069            hasLoggedError || (hasLoggedError = true, console.error(
1070              "React instrumentation encountered an error: %o",
1071              err
1072            ));
1073          }
1074      }
1075      function clz32Fallback(x) {
1076        x >>>= 0;
1077        return 0 === x ? 32 : 31 - (log(x) / LN2 | 0) | 0;
1078      }
1079      function getHighestPriorityLanes(lanes) {
1080        var pendingSyncLanes = lanes & 42;
1081        if (0 !== pendingSyncLanes) return pendingSyncLanes;
1082        switch (lanes & -lanes) {
1083          case 1:
1084            return 1;
1085          case 2:
1086            return 2;
1087          case 4:
1088            return 4;
1089          case 8:
1090            return 8;
1091          case 16:
1092            return 16;
1093          case 32:
1094            return 32;
1095          case 64:
1096            return 64;
1097          case 128:
1098            return 128;
1099          case 256:
1100          case 512:
1101          case 1024:
1102          case 2048:
1103          case 4096:
1104          case 8192:
1105          case 16384:
1106          case 32768:
1107          case 65536:
1108          case 131072:
1109            return lanes & 261888;
1110          case 262144:
1111          case 524288:
1112          case 1048576:
1113          case 2097152:
1114            return lanes & 3932160;
1115          case 4194304:
1116          case 8388608:
1117          case 16777216:
1118          case 33554432:
1119            return lanes & 62914560;
1120          case 67108864:
1121            return 67108864;
1122          case 134217728:
1123            return 134217728;
1124          case 268435456:
1125            return 268435456;
1126          case 536870912:
1127            return 536870912;
1128          case 1073741824:
1129            return 0;
1130          default:
1131            return console.error(
1132              "Should have found matching lanes. This is a bug in React."
1133            ), lanes;
1134        }
1135      }
1136      function getNextLanes(root2, wipLanes, rootHasPendingCommit) {
1137        var pendingLanes = root2.pendingLanes;
1138        if (0 === pendingLanes) return 0;
1139        var nextLanes = 0, suspendedLanes = root2.suspendedLanes, pingedLanes = root2.pingedLanes;
1140        root2 = root2.warmLanes;
1141        var nonIdlePendingLanes = pendingLanes & 134217727;
1142        0 !== nonIdlePendingLanes ? (pendingLanes = nonIdlePendingLanes & ~suspendedLanes, 0 !== pendingLanes ? nextLanes = getHighestPriorityLanes(pendingLanes) : (pingedLanes &= nonIdlePendingLanes, 0 !== pingedLanes ? nextLanes = getHighestPriorityLanes(pingedLanes) : rootHasPendingCommit || (rootHasPendingCommit = nonIdlePendingLanes & ~root2, 0 !== rootHasPendingCommit && (nextLanes = getHighestPriorityLanes(rootHasPendingCommit))))) : (nonIdlePendingLanes = pendingLanes & ~suspendedLanes, 0 !== nonIdlePendingLanes ? nextLanes = getHighestPriorityLanes(nonIdlePendingLanes) : 0 !== pingedLanes ? nextLanes = getHighestPriorityLanes(pingedLanes) : rootHasPendingCommit || (rootHasPendingCommit = pendingLanes & ~root2, 0 !== rootHasPendingCommit && (nextLanes = getHighestPriorityLanes(rootHasPendingCommit))));
1143        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;
1144      }
1145      function checkIfRootIsPrerendering(root2, renderLanes2) {
1146        return 0 === (root2.pendingLanes & ~(root2.suspendedLanes & ~root2.pingedLanes) & renderLanes2);
1147      }
1148      function computeExpirationTime(lane, currentTime) {
1149        switch (lane) {
1150          case 1:
1151          case 2:
1152          case 4:
1153          case 8:
1154          case 64:
1155            return currentTime + 250;
1156          case 16:
1157          case 32:
1158          case 128:
1159          case 256:
1160          case 512:
1161          case 1024:
1162          case 2048:
1163          case 4096:
1164          case 8192:
1165          case 16384:
1166          case 32768:
1167          case 65536:
1168          case 131072:
1169          case 262144:
1170          case 524288:
1171          case 1048576:
1172          case 2097152:
1173            return currentTime + 5e3;
1174          case 4194304:
1175          case 8388608:
1176          case 16777216:
1177          case 33554432:
1178            return -1;
1179          case 67108864:
1180          case 134217728:
1181          case 268435456:
1182          case 536870912:
1183          case 1073741824:
1184            return -1;
1185          default:
1186            return console.error(
1187              "Should have found matching lanes. This is a bug in React."
1188            ), -1;
1189        }
1190      }
1191      function claimNextRetryLane() {
1192        var lane = nextRetryLane;
1193        nextRetryLane <<= 1;
1194        0 === (nextRetryLane & 62914560) && (nextRetryLane = 4194304);
1195        return lane;
1196      }
1197      function createLaneMap(initial) {
1198        for (var laneMap = [], i = 0; 31 > i; i++) laneMap.push(initial);
1199        return laneMap;
1200      }
1201      function markRootUpdated$1(root2, updateLane) {
1202        root2.pendingLanes |= updateLane;
1203        268435456 !== updateLane && (root2.suspendedLanes = 0, root2.pingedLanes = 0, root2.warmLanes = 0);
1204      }
1205      function markRootFinished(root2, finishedLanes, remainingLanes, spawnedLane, updatedLanes, suspendedRetryLanes) {
1206        var previouslyPendingLanes = root2.pendingLanes;
1207        root2.pendingLanes = remainingLanes;
1208        root2.suspendedLanes = 0;
1209        root2.pingedLanes = 0;
1210        root2.warmLanes = 0;
1211        root2.expiredLanes &= remainingLanes;
1212        root2.entangledLanes &= remainingLanes;
1213        root2.errorRecoveryDisabledLanes &= remainingLanes;
1214        root2.shellSuspendCounter = 0;
1215        var entanglements = root2.entanglements, expirationTimes = root2.expirationTimes, hiddenUpdates = root2.hiddenUpdates;
1216        for (remainingLanes = previouslyPendingLanes & ~remainingLanes; 0 < remainingLanes; ) {
1217          var index = 31 - clz32(remainingLanes), lane = 1 << index;
1218          entanglements[index] = 0;
1219          expirationTimes[index] = -1;
1220          var hiddenUpdatesForLane = hiddenUpdates[index];
1221          if (null !== hiddenUpdatesForLane)
1222            for (hiddenUpdates[index] = null, index = 0; index < hiddenUpdatesForLane.length; index++) {
1223              var update = hiddenUpdatesForLane[index];
1224              null !== update && (update.lane &= -536870913);
1225            }
1226          remainingLanes &= ~lane;
1227        }
1228        0 !== spawnedLane && markSpawnedDeferredLane(root2, spawnedLane, 0);
1229        0 !== suspendedRetryLanes && 0 === updatedLanes && 0 !== root2.tag && (root2.suspendedLanes |= suspendedRetryLanes & ~(previouslyPendingLanes & ~finishedLanes));
1230      }
1231      function markSpawnedDeferredLane(root2, spawnedLane, entangledLanes) {
1232        root2.pendingLanes |= spawnedLane;
1233        root2.suspendedLanes &= ~spawnedLane;
1234        var spawnedLaneIndex = 31 - clz32(spawnedLane);
1235        root2.entangledLanes |= spawnedLane;
1236        root2.entanglements[spawnedLaneIndex] = root2.entanglements[spawnedLaneIndex] | 1073741824 | entangledLanes & 261930;
1237      }
1238      function markRootEntangled(root2, entangledLanes) {
1239        var rootEntangledLanes = root2.entangledLanes |= entangledLanes;
1240        for (root2 = root2.entanglements; rootEntangledLanes; ) {
1241          var index = 31 - clz32(rootEntangledLanes), lane = 1 << index;
1242          lane & entangledLanes | root2[index] & entangledLanes && (root2[index] |= entangledLanes);
1243          rootEntangledLanes &= ~lane;
1244        }
1245      }
1246      function getBumpedLaneForHydration(root2, renderLanes2) {
1247        var renderLane = renderLanes2 & -renderLanes2;
1248        renderLane = 0 !== (renderLane & 42) ? 1 : getBumpedLaneForHydrationByLane(renderLane);
1249        return 0 !== (renderLane & (root2.suspendedLanes | renderLanes2)) ? 0 : renderLane;
1250      }
1251      function getBumpedLaneForHydrationByLane(lane) {
1252        switch (lane) {
1253          case 2:
1254            lane = 1;
1255            break;
1256          case 8:
1257            lane = 4;
1258            break;
1259          case 32:
1260            lane = 16;
1261            break;
1262          case 256:
1263          case 512:
1264          case 1024:
1265          case 2048:
1266          case 4096:
1267          case 8192:
1268          case 16384:
1269          case 32768:
1270          case 65536:
1271          case 131072:
1272          case 262144:
1273          case 524288:
1274          case 1048576:
1275          case 2097152:
1276          case 4194304:
1277          case 8388608:
1278          case 16777216:
1279          case 33554432:
1280            lane = 128;
1281            break;
1282          case 268435456:
1283            lane = 134217728;
1284            break;
1285          default:
1286            lane = 0;
1287        }
1288        return lane;
1289      }
1290      function addFiberToLanesMap(root2, fiber, lanes) {
1291        if (isDevToolsPresent)
1292          for (root2 = root2.pendingUpdatersLaneMap; 0 < lanes; ) {
1293            var index = 31 - clz32(lanes), lane = 1 << index;
1294            root2[index].add(fiber);
1295            lanes &= ~lane;
1296          }
1297      }
1298      function movePendingFibersToMemoized(root2, lanes) {
1299        if (isDevToolsPresent)
1300          for (var pendingUpdatersLaneMap = root2.pendingUpdatersLaneMap, memoizedUpdaters = root2.memoizedUpdaters; 0 < lanes; ) {
1301            var index = 31 - clz32(lanes);
1302            root2 = 1 << index;
1303            index = pendingUpdatersLaneMap[index];
1304            0 < index.size && (index.forEach(function(fiber) {
1305              var alternate = fiber.alternate;
1306              null !== alternate && memoizedUpdaters.has(alternate) || memoizedUpdaters.add(fiber);
1307            }), index.clear());
1308            lanes &= ~root2;
1309          }
1310      }
1311      function lanesToEventPriority(lanes) {
1312        lanes &= -lanes;
1313        return 0 !== DiscreteEventPriority && DiscreteEventPriority < lanes ? 0 !== ContinuousEventPriority && ContinuousEventPriority < lanes ? 0 !== (lanes & 134217727) ? DefaultEventPriority : IdleEventPriority : ContinuousEventPriority : DiscreteEventPriority;
1314      }
1315      function resolveUpdatePriority() {
1316        var updatePriority = ReactDOMSharedInternals.p;
1317        if (0 !== updatePriority) return updatePriority;
1318        updatePriority = window.event;
1319        return void 0 === updatePriority ? DefaultEventPriority : getEventPriority(updatePriority.type);
1320      }
1321      function runWithPriority(priority, fn) {
1322        var previousPriority = ReactDOMSharedInternals.p;
1323        try {
1324          return ReactDOMSharedInternals.p = priority, fn();
1325        } finally {
1326          ReactDOMSharedInternals.p = previousPriority;
1327        }
1328      }
1329      function detachDeletedInstance(node) {
1330        delete node[internalInstanceKey];
1331        delete node[internalPropsKey];
1332        delete node[internalEventHandlersKey];
1333        delete node[internalEventHandlerListenersKey];
1334        delete node[internalEventHandlesSetKey];
1335      }
1336      function getClosestInstanceFromNode(targetNode) {
1337        var targetInst = targetNode[internalInstanceKey];
1338        if (targetInst) return targetInst;
1339        for (var parentNode = targetNode.parentNode; parentNode; ) {
1340          if (targetInst = parentNode[internalContainerInstanceKey] || parentNode[internalInstanceKey]) {
1341            parentNode = targetInst.alternate;
1342            if (null !== targetInst.child || null !== parentNode && null !== parentNode.child)
1343              for (targetNode = getParentHydrationBoundary(targetNode); null !== targetNode; ) {
1344                if (parentNode = targetNode[internalInstanceKey])
1345                  return parentNode;
1346                targetNode = getParentHydrationBoundary(targetNode);
1347              }
1348            return targetInst;
1349          }
1350          targetNode = parentNode;
1351          parentNode = targetNode.parentNode;
1352        }
1353        return null;
1354      }
1355      function getInstanceFromNode(node) {
1356        if (node = node[internalInstanceKey] || node[internalContainerInstanceKey]) {
1357          var tag = node.tag;
1358          if (5 === tag || 6 === tag || 13 === tag || 31 === tag || 26 === tag || 27 === tag || 3 === tag)
1359            return node;
1360        }
1361        return null;
1362      }
1363      function getNodeFromInstance(inst) {
1364        var tag = inst.tag;
1365        if (5 === tag || 26 === tag || 27 === tag || 6 === tag)
1366          return inst.stateNode;
1367        throw Error("getNodeFromInstance: Invalid argument.");
1368      }
1369      function getResourcesFromRoot(root2) {
1370        var resources = root2[internalRootNodeResourcesKey];
1371        resources || (resources = root2[internalRootNodeResourcesKey] = { hoistableStyles: /* @__PURE__ */ new Map(), hoistableScripts: /* @__PURE__ */ new Map() });
1372        return resources;
1373      }
1374      function markNodeAsHoistable(node) {
1375        node[internalHoistableMarker] = true;
1376      }
1377      function registerTwoPhaseEvent(registrationName, dependencies) {
1378        registerDirectEvent(registrationName, dependencies);
1379        registerDirectEvent(registrationName + "Capture", dependencies);
1380      }
1381      function registerDirectEvent(registrationName, dependencies) {
1382        registrationNameDependencies[registrationName] && console.error(
1383          "EventRegistry: More than one plugin attempted to publish the same registration name, `%s`.",
1384          registrationName
1385        );
1386        registrationNameDependencies[registrationName] = dependencies;
1387        var lowerCasedName = registrationName.toLowerCase();
1388        possibleRegistrationNames[lowerCasedName] = registrationName;
1389        "onDoubleClick" === registrationName && (possibleRegistrationNames.ondblclick = registrationName);
1390        for (registrationName = 0; registrationName < dependencies.length; registrationName++)
1391          allNativeEvents.add(dependencies[registrationName]);
1392      }
1393      function checkControlledValueProps(tagName, props) {
1394        hasReadOnlyValue[props.type] || props.onChange || props.onInput || props.readOnly || props.disabled || null == props.value || ("select" === tagName ? console.error(
1395          "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`."
1396        ) : console.error(
1397          "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`."
1398        ));
1399        props.onChange || props.readOnly || props.disabled || null == props.checked || console.error(
1400          "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`."
1401        );
1402      }
1403      function isAttributeNameSafe(attributeName) {
1404        if (hasOwnProperty.call(validatedAttributeNameCache, attributeName))
1405          return true;
1406        if (hasOwnProperty.call(illegalAttributeNameCache, attributeName))
1407          return false;
1408        if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName))
1409          return validatedAttributeNameCache[attributeName] = true;
1410        illegalAttributeNameCache[attributeName] = true;
1411        console.error("Invalid attribute name: `%s`", attributeName);
1412        return false;
1413      }
1414      function getValueForAttributeOnCustomComponent(node, name, expected) {
1415        if (isAttributeNameSafe(name)) {
1416          if (!node.hasAttribute(name)) {
1417            switch (typeof expected) {
1418              case "symbol":
1419              case "object":
1420                return expected;
1421              case "function":
1422                return expected;
1423              case "boolean":
1424                if (false === expected) return expected;
1425            }
1426            return void 0 === expected ? void 0 : null;
1427          }
1428          node = node.getAttribute(name);
1429          if ("" === node && true === expected) return true;
1430          checkAttributeStringCoercion(expected, name);
1431          return node === "" + expected ? expected : node;
1432        }
1433      }
1434      function setValueForAttribute(node, name, value) {
1435        if (isAttributeNameSafe(name))
1436          if (null === value) node.removeAttribute(name);
1437          else {
1438            switch (typeof value) {
1439              case "undefined":
1440              case "function":
1441              case "symbol":
1442                node.removeAttribute(name);
1443                return;
1444              case "boolean":
1445                var prefix2 = name.toLowerCase().slice(0, 5);
1446                if ("data-" !== prefix2 && "aria-" !== prefix2) {
1447                  node.removeAttribute(name);
1448                  return;
1449                }
1450            }
1451            checkAttributeStringCoercion(value, name);
1452            node.setAttribute(name, "" + value);
1453          }
1454      }
1455      function setValueForKnownAttribute(node, name, value) {
1456        if (null === value) node.removeAttribute(name);
1457        else {
1458          switch (typeof value) {
1459            case "undefined":
1460            case "function":
1461            case "symbol":
1462            case "boolean":
1463              node.removeAttribute(name);
1464              return;
1465          }
1466          checkAttributeStringCoercion(value, name);
1467          node.setAttribute(name, "" + value);
1468        }
1469      }
1470      function setValueForNamespacedAttribute(node, namespace, name, value) {
1471        if (null === value) node.removeAttribute(name);
1472        else {
1473          switch (typeof value) {
1474            case "undefined":
1475            case "function":
1476            case "symbol":
1477            case "boolean":
1478              node.removeAttribute(name);
1479              return;
1480          }
1481          checkAttributeStringCoercion(value, name);
1482          node.setAttributeNS(namespace, name, "" + value);
1483        }
1484      }
1485      function getToStringValue(value) {
1486        switch (typeof value) {
1487          case "bigint":
1488          case "boolean":
1489          case "number":
1490          case "string":
1491          case "undefined":
1492            return value;
1493          case "object":
1494            return checkFormFieldValueStringCoercion(value), value;
1495          default:
1496            return "";
1497        }
1498      }
1499      function isCheckable(elem) {
1500        var type = elem.type;
1501        return (elem = elem.nodeName) && "input" === elem.toLowerCase() && ("checkbox" === type || "radio" === type);
1502      }
1503      function trackValueOnNode(node, valueField, currentValue) {
1504        var descriptor = Object.getOwnPropertyDescriptor(
1505          node.constructor.prototype,
1506          valueField
1507        );
1508        if (!node.hasOwnProperty(valueField) && "undefined" !== typeof descriptor && "function" === typeof descriptor.get && "function" === typeof descriptor.set) {
1509          var get = descriptor.get, set = descriptor.set;
1510          Object.defineProperty(node, valueField, {
1511            configurable: true,
1512            get: function() {
1513              return get.call(this);
1514            },
1515            set: function(value) {
1516              checkFormFieldValueStringCoercion(value);
1517              currentValue = "" + value;
1518              set.call(this, value);
1519            }
1520          });
1521          Object.defineProperty(node, valueField, {
1522            enumerable: descriptor.enumerable
1523          });
1524          return {
1525            getValue: function() {
1526              return currentValue;
1527            },
1528            setValue: function(value) {
1529              checkFormFieldValueStringCoercion(value);
1530              currentValue = "" + value;
1531            },
1532            stopTracking: function() {
1533              node._valueTracker = null;
1534              delete node[valueField];
1535            }
1536          };
1537        }
1538      }
1539      function track(node) {
1540        if (!node._valueTracker) {
1541          var valueField = isCheckable(node) ? "checked" : "value";
1542          node._valueTracker = trackValueOnNode(
1543            node,
1544            valueField,
1545            "" + node[valueField]
1546          );
1547        }
1548      }
1549      function updateValueIfChanged(node) {
1550        if (!node) return false;
1551        var tracker = node._valueTracker;
1552        if (!tracker) return true;
1553        var lastValue = tracker.getValue();
1554        var value = "";
1555        node && (value = isCheckable(node) ? node.checked ? "true" : "false" : node.value);
1556        node = value;
1557        return node !== lastValue ? (tracker.setValue(node), true) : false;
1558      }
1559      function getActiveElement(doc) {
1560        doc = doc || ("undefined" !== typeof document ? document : void 0);
1561        if ("undefined" === typeof doc) return null;
1562        try {
1563          return doc.activeElement || doc.body;
1564        } catch (e) {
1565          return doc.body;
1566        }
1567      }
1568      function escapeSelectorAttributeValueInsideDoubleQuotes(value) {
1569        return value.replace(
1570          escapeSelectorAttributeValueInsideDoubleQuotesRegex,
1571          function(ch) {
1572            return "\\" + ch.charCodeAt(0).toString(16) + " ";
1573          }
1574        );
1575      }
1576      function validateInputProps(element, props) {
1577        void 0 === props.checked || void 0 === props.defaultChecked || didWarnCheckedDefaultChecked || (console.error(
1578          "%s contains an input of type %s with both checked and defaultChecked props. Input elements must be either controlled or uncontrolled (specify either the checked prop, or the defaultChecked prop, but not both). Decide between using a controlled or uncontrolled input element and remove one of these props. More info: https://react.dev/link/controlled-components",
1579          getCurrentFiberOwnerNameInDevOrNull() || "A component",
1580          props.type
1581        ), didWarnCheckedDefaultChecked = true);
1582        void 0 === props.value || void 0 === props.defaultValue || didWarnValueDefaultValue$1 || (console.error(
1583          "%s contains an input of type %s with both value and defaultValue props. Input 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 input element and remove one of these props. More info: https://react.dev/link/controlled-components",
1584          getCurrentFiberOwnerNameInDevOrNull() || "A component",
1585          props.type
1586        ), didWarnValueDefaultValue$1 = true);
1587      }
1588      function updateInput(element, value, defaultValue, lastDefaultValue, checked, defaultChecked, type, name) {
1589        element.name = "";
1590        null != type && "function" !== typeof type && "symbol" !== typeof type && "boolean" !== typeof type ? (checkAttributeStringCoercion(type, "type"), element.type = type) : element.removeAttribute("type");
1591        if (null != value)
1592          if ("number" === type) {
1593            if (0 === value && "" === element.value || element.value != value)
1594              element.value = "" + getToStringValue(value);
1595          } else
1596            element.value !== "" + getToStringValue(value) && (element.value = "" + getToStringValue(value));
1597        else
1598          "submit" !== type && "reset" !== type || element.removeAttribute("value");
1599        null != value ? setDefaultValue(element, type, getToStringValue(value)) : null != defaultValue ? setDefaultValue(element, type, getToStringValue(defaultValue)) : null != lastDefaultValue && element.removeAttribute("value");
1600        null == checked && null != defaultChecked && (element.defaultChecked = !!defaultChecked);
1601        null != checked && (element.checked = checked && "function" !== typeof checked && "symbol" !== typeof checked);
1602        null != name && "function" !== typeof name && "symbol" !== typeof name && "boolean" !== typeof name ? (checkAttributeStringCoercion(name, "name"), element.name = "" + getToStringValue(name)) : element.removeAttribute("name");
1603      }
1604      function initInput(element, value, defaultValue, checked, defaultChecked, type, name, isHydrating2) {
1605        null != type && "function" !== typeof type && "symbol" !== typeof type && "boolean" !== typeof type && (checkAttributeStringCoercion(type, "type"), element.type = type);
1606        if (null != value || null != defaultValue) {
1607          if (!("submit" !== type && "reset" !== type || void 0 !== value && null !== value)) {
1608            track(element);
1609            return;
1610          }
1611          defaultValue = null != defaultValue ? "" + getToStringValue(defaultValue) : "";
1612          value = null != value ? "" + getToStringValue(value) : defaultValue;
1613          isHydrating2 || value === element.value || (element.value = value);
1614          element.defaultValue = value;
1615        }
1616        checked = null != checked ? checked : defaultChecked;
1617        checked = "function" !== typeof checked && "symbol" !== typeof checked && !!checked;
1618        element.checked = isHydrating2 ? element.checked : !!checked;
1619        element.defaultChecked = !!checked;
1620        null != name && "function" !== typeof name && "symbol" !== typeof name && "boolean" !== typeof name && (checkAttributeStringCoercion(name, "name"), element.name = name);
1621        track(element);
1622      }
1623      function setDefaultValue(node, type, value) {
1624        "number" === type && getActiveElement(node.ownerDocument) === node || node.defaultValue === "" + value || (node.defaultValue = "" + value);
1625      }
1626      function validateOptionProps(element, props) {
1627        null == props.value && ("object" === typeof props.children && null !== props.children ? React.Children.forEach(props.children, function(child) {
1628          null == child || "string" === typeof child || "number" === typeof child || "bigint" === typeof child || didWarnInvalidChild || (didWarnInvalidChild = true, console.error(
1629            "Cannot infer the option value of complex children. Pass a `value` prop or use a plain string as children to <option>."
1630          ));
1631        }) : null == props.dangerouslySetInnerHTML || didWarnInvalidInnerHTML || (didWarnInvalidInnerHTML = true, console.error(
1632          "Pass a `value` prop if you set dangerouslyInnerHTML so React knows which value should be selected."
1633        )));
1634        null == props.selected || didWarnSelectedSetOnOption || (console.error(
1635          "Use the `defaultValue` or `value` props on <select> instead of setting `selected` on <option>."
1636        ), didWarnSelectedSetOnOption = true);
1637      }
1638      function getDeclarationErrorAddendum() {
1639        var ownerName = getCurrentFiberOwnerNameInDevOrNull();
1640        return ownerName ? "\n\nCheck the render method of `" + ownerName + "`." : "";
1641      }
1642      function updateOptions(node, multiple, propValue, setDefaultSelected) {
1643        node = node.options;
1644        if (multiple) {
1645          multiple = {};
1646          for (var i = 0; i < propValue.length; i++)
1647            multiple["$" + propValue[i]] = true;
1648          for (propValue = 0; propValue < node.length; propValue++)
1649            i = multiple.hasOwnProperty("$" + node[propValue].value), node[propValue].selected !== i && (node[propValue].selected = i), i && setDefaultSelected && (node[propValue].defaultSelected = true);
1650        } else {
1651          propValue = "" + getToStringValue(propValue);
1652          multiple = null;
1653          for (i = 0; i < node.length; i++) {
1654            if (node[i].value === propValue) {
1655              node[i].selected = true;
1656              setDefaultSelected && (node[i].defaultSelected = true);
1657              return;
1658            }
1659            null !== multiple || node[i].disabled || (multiple = node[i]);
1660          }
1661          null !== multiple && (multiple.selected = true);
1662        }
1663      }
1664      function validateSelectProps(element, props) {
1665        for (element = 0; element < valuePropNames.length; element++) {
1666          var propName = valuePropNames[element];
1667          if (null != props[propName]) {
1668            var propNameIsArray = isArrayImpl(props[propName]);
1669            props.multiple && !propNameIsArray ? console.error(
1670              "The `%s` prop supplied to <select> must be an array if `multiple` is true.%s",
1671              propName,
1672              getDeclarationErrorAddendum()
1673            ) : !props.multiple && propNameIsArray && console.error(
1674              "The `%s` prop supplied to <select> must be a scalar value if `multiple` is false.%s",
1675              propName,
1676              getDeclarationErrorAddendum()
1677            );
1678          }
1679        }
1680        void 0 === props.value || void 0 === props.defaultValue || didWarnValueDefaultValue || (console.error(
1681          "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"
1682        ), didWarnValueDefaultValue = true);
1683      }
1684      function validateTextareaProps(element, props) {
1685        void 0 === props.value || void 0 === props.defaultValue || didWarnValDefaultVal || (console.error(
1686          "%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",
1687          getCurrentFiberOwnerNameInDevOrNull() || "A component"
1688        ), didWarnValDefaultVal = true);
1689        null != props.children && null == props.value && console.error(
1690          "Use the `defaultValue` or `value` props instead of setting children on <textarea>."
1691        );
1692      }
1693      function updateTextarea(element, value, defaultValue) {
1694        if (null != value && (value = "" + getToStringValue(value), value !== element.value && (element.value = value), null == defaultValue)) {
1695          element.defaultValue !== value && (element.defaultValue = value);
1696          return;
1697        }
1698        element.defaultValue = null != defaultValue ? "" + getToStringValue(defaultValue) : "";
1699      }
1700      function initTextarea(element, value, defaultValue, children) {
1701        if (null == value) {
1702          if (null != children) {
1703            if (null != defaultValue)
1704              throw Error(
1705                "If you supply `defaultValue` on a <textarea>, do not pass children."
1706              );
1707            if (isArrayImpl(children)) {
1708              if (1 < children.length)
1709                throw Error("<textarea> can only have at most one child.");
1710              children = children[0];
1711            }
1712            defaultValue = children;
1713          }
1714          null == defaultValue && (defaultValue = "");
1715          value = defaultValue;
1716        }
1717        defaultValue = getToStringValue(value);
1718        element.defaultValue = defaultValue;
1719        children = element.textContent;
1720        children === defaultValue && "" !== children && null !== children && (element.value = children);
1721        track(element);
1722      }
1723      function findNotableNode(node, indent) {
1724        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;
1725      }
1726      function indentation(indent) {
1727        return "  " + "  ".repeat(indent);
1728      }
1729      function added(indent) {
1730        return "+ " + "  ".repeat(indent);
1731      }
1732      function removed(indent) {
1733        return "- " + "  ".repeat(indent);
1734      }
1735      function describeFiberType(fiber) {
1736        switch (fiber.tag) {
1737          case 26:
1738          case 27:
1739          case 5:
1740            return fiber.type;
1741          case 16:
1742            return "Lazy";
1743          case 31:
1744            return "Activity";
1745          case 13:
1746            return "Suspense";
1747          case 19:
1748            return "SuspenseList";
1749          case 0:
1750          case 15:
1751            return fiber = fiber.type, fiber.displayName || fiber.name || null;
1752          case 11:
1753            return fiber = fiber.type.render, fiber.displayName || fiber.name || null;
1754          case 1:
1755            return fiber = fiber.type, fiber.displayName || fiber.name || null;
1756          default:
1757            return null;
1758        }
1759      }
1760      function describeTextNode(content, maxLength) {
1761        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;
1762      }
1763      function describeTextDiff(clientText, serverProps, indent) {
1764        var maxLength = 120 - 2 * indent;
1765        if (null === serverProps)
1766          return added(indent) + describeTextNode(clientText, maxLength) + "\n";
1767        if ("string" === typeof serverProps) {
1768          for (var firstDiff = 0; firstDiff < serverProps.length && firstDiff < clientText.length && serverProps.charCodeAt(firstDiff) === clientText.charCodeAt(firstDiff); firstDiff++) ;
1769          firstDiff > maxLength - 8 && 10 < firstDiff && (clientText = "..." + clientText.slice(firstDiff - 8), serverProps = "..." + serverProps.slice(firstDiff - 8));
1770          return added(indent) + describeTextNode(clientText, maxLength) + "\n" + removed(indent) + describeTextNode(serverProps, maxLength) + "\n";
1771        }
1772        return indentation(indent) + describeTextNode(clientText, maxLength) + "\n";
1773      }
1774      function objectName(object) {
1775        return Object.prototype.toString.call(object).replace(/^\[object (.*)\]$/, function(m, p0) {
1776          return p0;
1777        });
1778      }
1779      function describeValue(value, maxLength) {
1780        switch (typeof value) {
1781          case "string":
1782            return value = JSON.stringify(value), value.length > maxLength ? 5 > maxLength ? '"..."' : value.slice(0, maxLength - 4) + '..."' : value;
1783          case "object":
1784            if (null === value) return "null";
1785            if (isArrayImpl(value)) return "[...]";
1786            if (value.$$typeof === REACT_ELEMENT_TYPE)
1787              return (maxLength = getComponentNameFromType(value.type)) ? "<" + maxLength + ">" : "<...>";
1788            var name = objectName(value);
1789            if ("Object" === name) {
1790              name = "";
1791              maxLength -= 2;
1792              for (var propName in value)
1793                if (value.hasOwnProperty(propName)) {
1794                  var jsonPropName = JSON.stringify(propName);
1795                  jsonPropName !== '"' + propName + '"' && (propName = jsonPropName);
1796                  maxLength -= propName.length - 2;
1797                  jsonPropName = describeValue(
1798                    value[propName],
1799                    15 > maxLength ? maxLength : 15
1800                  );
1801                  maxLength -= jsonPropName.length;
1802                  if (0 > maxLength) {
1803                    name += "" === name ? "..." : ", ...";
1804                    break;
1805                  }
1806                  name += ("" === name ? "" : ",") + propName + ":" + jsonPropName;
1807                }
1808              return "{" + name + "}";
1809            }
1810            return name;
1811          case "function":
1812            return (maxLength = value.displayName || value.name) ? "function " + maxLength : "function";
1813          default:
1814            return String(value);
1815        }
1816      }
1817      function describePropValue(value, maxLength) {
1818        return "string" !== typeof value || needsEscaping.test(value) ? "{" + describeValue(value, maxLength - 2) + "}" : value.length > maxLength - 2 ? 5 > maxLength ? '"..."' : '"' + value.slice(0, maxLength - 5) + '..."' : '"' + value + '"';
1819      }
1820      function describeExpandedElement(type, props, rowPrefix) {
1821        var remainingRowLength = 120 - rowPrefix.length - type.length, properties = [], propName;
1822        for (propName in props)
1823          if (props.hasOwnProperty(propName) && "children" !== propName) {
1824            var propValue = describePropValue(
1825              props[propName],
1826              120 - rowPrefix.length - propName.length - 1
1827            );
1828            remainingRowLength -= propName.length + propValue.length + 2;
1829            properties.push(propName + "=" + propValue);
1830          }
1831        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";
1832      }
1833      function describePropertiesDiff(clientObject, serverObject, indent) {
1834        var properties = "", remainingServerProperties = assign({}, serverObject), propName;
1835        for (propName in clientObject)
1836          if (clientObject.hasOwnProperty(propName)) {
1837            delete remainingServerProperties[propName];
1838            var maxLength = 120 - 2 * indent - propName.length - 2, clientPropValue = describeValue(clientObject[propName], maxLength);
1839            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";
1840          }
1841        for (var _propName in remainingServerProperties)
1842          remainingServerProperties.hasOwnProperty(_propName) && (clientObject = describeValue(
1843            remainingServerProperties[_propName],
1844            120 - 2 * indent - _propName.length - 2
1845          ), properties += removed(indent) + _propName + ": " + clientObject + "\n");
1846        return properties;
1847      }
1848      function describeElementDiff(type, clientProps, serverProps, indent) {
1849        var content = "", serverPropNames = /* @__PURE__ */ new Map();
1850        for (propName$jscomp$0 in serverProps)
1851          serverProps.hasOwnProperty(propName$jscomp$0) && serverPropNames.set(
1852            propName$jscomp$0.toLowerCase(),
1853            propName$jscomp$0
1854          );
1855        if (1 === serverPropNames.size && serverPropNames.has("children"))
1856          content += describeExpandedElement(
1857            type,
1858            clientProps,
1859            indentation(indent)
1860          );
1861        else {
1862          for (var _propName2 in clientProps)
1863            if (clientProps.hasOwnProperty(_propName2) && "children" !== _propName2) {
1864              var maxLength$jscomp$0 = 120 - 2 * (indent + 1) - _propName2.length - 1, serverPropName = serverPropNames.get(_propName2.toLowerCase());
1865              if (void 0 !== serverPropName) {
1866                serverPropNames.delete(_propName2.toLowerCase());
1867                var propName$jscomp$0 = clientProps[_propName2];
1868                serverPropName = serverProps[serverPropName];
1869                var clientPropValue = describePropValue(
1870                  propName$jscomp$0,
1871                  maxLength$jscomp$0
1872                );
1873                maxLength$jscomp$0 = describePropValue(
1874                  serverPropName,
1875                  maxLength$jscomp$0
1876                );
1877                "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(
1878                  propName$jscomp$0,
1879                  serverPropName,
1880                  indent + 2
1881                ) + indentation(indent + 1) + "}}\n" : (content += added(indent + 1) + _propName2 + "=" + clientPropValue + "\n", content += removed(indent + 1) + _propName2 + "=" + maxLength$jscomp$0 + "\n");
1882              } else
1883                content += indentation(indent + 1) + _propName2 + "=" + describePropValue(clientProps[_propName2], maxLength$jscomp$0) + "\n";
1884            }
1885          serverPropNames.forEach(function(propName) {
1886            if ("children" !== propName) {
1887              var maxLength = 120 - 2 * (indent + 1) - propName.length - 1;
1888              content += removed(indent + 1) + propName + "=" + describePropValue(serverProps[propName], maxLength) + "\n";
1889            }
1890          });
1891          content = "" === content ? indentation(indent) + "<" + type + ">\n" : indentation(indent) + "<" + type + "\n" + content + indentation(indent) + ">\n";
1892        }
1893        type = serverProps.children;
1894        clientProps = clientProps.children;
1895        if ("string" === typeof type || "number" === typeof type || "bigint" === typeof type) {
1896          serverPropNames = "";
1897          if ("string" === typeof clientProps || "number" === typeof clientProps || "bigint" === typeof clientProps)
1898            serverPropNames = "" + clientProps;
1899          content += describeTextDiff(serverPropNames, "" + type, indent + 1);
1900        } else if ("string" === typeof clientProps || "number" === typeof clientProps || "bigint" === typeof clientProps)
1901          content = null == type ? content + describeTextDiff("" + clientProps, null, indent + 1) : content + describeTextDiff("" + clientProps, void 0, indent + 1);
1902        return content;
1903      }
1904      function describeSiblingFiber(fiber, indent) {
1905        var type = describeFiberType(fiber);
1906        if (null === type) {
1907          type = "";
1908          for (fiber = fiber.child; fiber; )
1909            type += describeSiblingFiber(fiber, indent), fiber = fiber.sibling;
1910          return type;
1911        }
1912        return indentation(indent) + "<" + type + ">\n";
1913      }
1914      function describeNode(node, indent) {
1915        var skipToNode = findNotableNode(node, indent);
1916        if (skipToNode !== node && (1 !== node.children.length || node.children[0] !== skipToNode))
1917          return indentation(indent) + "...\n" + describeNode(skipToNode, indent + 1);
1918        skipToNode = "";
1919        var debugInfo = node.fiber._debugInfo;
1920        if (debugInfo)
1921          for (var i = 0; i < debugInfo.length; i++) {
1922            var serverComponentName = debugInfo[i].name;
1923            "string" === typeof serverComponentName && (skipToNode += indentation(indent) + "<" + serverComponentName + ">\n", indent++);
1924          }
1925        debugInfo = "";
1926        i = node.fiber.pendingProps;
1927        if (6 === node.fiber.tag)
1928          debugInfo = describeTextDiff(i, node.serverProps, indent), indent++;
1929        else if (serverComponentName = describeFiberType(node.fiber), null !== serverComponentName)
1930          if (void 0 === node.serverProps) {
1931            debugInfo = indent;
1932            var maxLength = 120 - 2 * debugInfo - serverComponentName.length - 2, content = "";
1933            for (propName in i)
1934              if (i.hasOwnProperty(propName) && "children" !== propName) {
1935                var propValue = describePropValue(i[propName], 15);
1936                maxLength -= propName.length + propValue.length + 2;
1937                if (0 > maxLength) {
1938                  content += " ...";
1939                  break;
1940                }
1941                content += " " + propName + "=" + propValue;
1942              }
1943            debugInfo = indentation(debugInfo) + "<" + serverComponentName + content + ">\n";
1944            indent++;
1945          } else
1946            null === node.serverProps ? (debugInfo = describeExpandedElement(
1947              serverComponentName,
1948              i,
1949              added(indent)
1950            ), indent++) : "string" === typeof node.serverProps ? console.error(
1951              "Should not have matched a non HostText fiber to a Text node. This is a bug in React."
1952            ) : (debugInfo = describeElementDiff(
1953              serverComponentName,
1954              i,
1955              node.serverProps,
1956              indent
1957            ), indent++);
1958        var propName = "";
1959        i = node.fiber.child;
1960        for (serverComponentName = 0; i && serverComponentName < node.children.length; )
1961          maxLength = node.children[serverComponentName], maxLength.fiber === i ? (propName += describeNode(maxLength, indent), serverComponentName++) : propName += describeSiblingFiber(i, indent), i = i.sibling;
1962        i && 0 < node.children.length && (propName += indentation(indent) + "...\n");
1963        i = node.serverTail;
1964        null === node.serverProps && indent--;
1965        for (node = 0; node < i.length; node++)
1966          serverComponentName = i[node], propName = "string" === typeof serverComponentName ? propName + (removed(indent) + describeTextNode(serverComponentName, 120 - 2 * indent) + "\n") : propName + describeExpandedElement(
1967            serverComponentName.type,
1968            serverComponentName.props,
1969            removed(indent)
1970          );
1971        return skipToNode + debugInfo + propName;
1972      }
1973      function describeDiff(rootNode) {
1974        try {
1975          return "\n\n" + describeNode(rootNode, 0);
1976        } catch (x) {
1977          return "";
1978        }
1979      }
1980      function describeAncestors(ancestor, child, props) {
1981        for (var fiber = child, node = null, distanceFromLeaf = 0; fiber; )
1982          fiber === ancestor && (distanceFromLeaf = 0), node = {
1983            fiber,
1984            children: null !== node ? [node] : [],
1985            serverProps: fiber === child ? props : fiber === ancestor ? null : void 0,
1986            serverTail: [],
1987            distanceFromLeaf
1988          }, distanceFromLeaf++, fiber = fiber.return;
1989        return null !== node ? describeDiff(node).replaceAll(/^[+-]/gm, ">") : "";
1990      }
1991      function updatedAncestorInfoDev(oldInfo, tag) {
1992        var ancestorInfo = assign({}, oldInfo || emptyAncestorInfoDev), info = { tag };
1993        -1 !== inScopeTags.indexOf(tag) && (ancestorInfo.aTagInScope = null, ancestorInfo.buttonTagInScope = null, ancestorInfo.nobrTagInScope = null);
1994        -1 !== buttonScopeTags.indexOf(tag) && (ancestorInfo.pTagInButtonScope = null);
1995        -1 !== specialTags.indexOf(tag) && "address" !== tag && "div" !== tag && "p" !== tag && (ancestorInfo.listItemTagAutoclosing = null, ancestorInfo.dlItemTagAutoclosing = null);
1996        ancestorInfo.current = info;
1997        "form" === tag && (ancestorInfo.formTag = info);
1998        "a" === tag && (ancestorInfo.aTagInScope = info);
1999        "button" === tag && (ancestorInfo.buttonTagInScope = info);
2000        "nobr" === tag && (ancestorInfo.nobrTagInScope = info);
2001        "p" === tag && (ancestorInfo.pTagInButtonScope = info);
2002        "li" === tag && (ancestorInfo.listItemTagAutoclosing = info);
2003        if ("dd" === tag || "dt" === tag)
2004          ancestorInfo.dlItemTagAutoclosing = info;
2005        "#document" === tag || "html" === tag ? ancestorInfo.containerTagInScope = null : ancestorInfo.containerTagInScope || (ancestorInfo.containerTagInScope = info);
2006        null !== oldInfo || "#document" !== tag && "html" !== tag && "body" !== tag ? true === ancestorInfo.implicitRootScope && (ancestorInfo.implicitRootScope = false) : ancestorInfo.implicitRootScope = true;
2007        return ancestorInfo;
2008      }
2009      function isTagValidWithParent(tag, parentTag, implicitRootScope) {
2010        switch (parentTag) {
2011          case "select":
2012            return "hr" === tag || "option" === tag || "optgroup" === tag || "script" === tag || "template" === tag || "#text" === tag;
2013          case "optgroup":
2014            return "option" === tag || "#text" === tag;
2015          case "option":
2016            return "#text" === tag;
2017          case "tr":
2018            return "th" === tag || "td" === tag || "style" === tag || "script" === tag || "template" === tag;
2019          case "tbody":
2020          case "thead":
2021          case "tfoot":
2022            return "tr" === tag || "style" === tag || "script" === tag || "template" === tag;
2023          case "colgroup":
2024            return "col" === tag || "template" === tag;
2025          case "table":
2026            return "caption" === tag || "colgroup" === tag || "tbody" === tag || "tfoot" === tag || "thead" === tag || "style" === tag || "script" === tag || "template" === tag;
2027          case "head":
2028            return "base" === tag || "basefont" === tag || "bgsound" === tag || "link" === tag || "meta" === tag || "title" === tag || "noscript" === tag || "noframes" === tag || "style" === tag || "script" === tag || "template" === tag;
2029          case "html":
2030            if (implicitRootScope) break;
2031            return "head" === tag || "body" === tag || "frameset" === tag;
2032          case "frameset":
2033            return "frame" === tag;
2034          case "#document":
2035            if (!implicitRootScope) return "html" === tag;
2036        }
2037        switch (tag) {
2038          case "h1":
2039          case "h2":
2040          case "h3":
2041          case "h4":
2042          case "h5":
2043          case "h6":
2044            return "h1" !== parentTag && "h2" !== parentTag && "h3" !== parentTag && "h4" !== parentTag && "h5" !== parentTag && "h6" !== parentTag;
2045          case "rp":
2046          case "rt":
2047            return -1 === impliedEndTags.indexOf(parentTag);
2048          case "caption":
2049          case "col":
2050          case "colgroup":
2051          case "frameset":
2052          case "frame":
2053          case "tbody":
2054          case "td":
2055          case "tfoot":
2056          case "th":
2057          case "thead":
2058          case "tr":
2059            return null == parentTag;
2060          case "head":
2061            return implicitRootScope || null === parentTag;
2062          case "html":
2063            return implicitRootScope && "#document" === parentTag || null === parentTag;
2064          case "body":
2065            return implicitRootScope && ("#document" === parentTag || "html" === parentTag) || null === parentTag;
2066        }
2067        return true;
2068      }
2069      function findInvalidAncestorForTag(tag, ancestorInfo) {
2070        switch (tag) {
2071          case "address":
2072          case "article":
2073          case "aside":
2074          case "blockquote":
2075          case "center":
2076          case "details":
2077          case "dialog":
2078          case "dir":
2079          case "div":
2080          case "dl":
2081          case "fieldset":
2082          case "figcaption":
2083          case "figure":
2084          case "footer":
2085          case "header":
2086          case "hgroup":
2087          case "main":
2088          case "menu":
2089          case "nav":
2090          case "ol":
2091          case "p":
2092          case "section":
2093          case "summary":
2094          case "ul":
2095          case "pre":
2096          case "listing":
2097          case "table":
2098          case "hr":
2099          case "xmp":
2100          case "h1":
2101          case "h2":
2102          case "h3":
2103          case "h4":
2104          case "h5":
2105          case "h6":
2106            return ancestorInfo.pTagInButtonScope;
2107          case "form":
2108            return ancestorInfo.formTag || ancestorInfo.pTagInButtonScope;
2109          case "li":
2110            return ancestorInfo.listItemTagAutoclosing;
2111          case "dd":
2112          case "dt":
2113            return ancestorInfo.dlItemTagAutoclosing;
2114          case "button":
2115            return ancestorInfo.buttonTagInScope;
2116          case "a":
2117            return ancestorInfo.aTagInScope;
2118          case "nobr":
2119            return ancestorInfo.nobrTagInScope;
2120        }
2121        return null;
2122      }
2123      function findAncestor(parent, tagName) {
2124        for (; parent; ) {
2125          switch (parent.tag) {
2126            case 5:
2127            case 26:
2128            case 27:
2129              if (parent.type === tagName) return parent;
2130          }
2131          parent = parent.return;
2132        }
2133        return null;
2134      }
2135      function validateDOMNesting(childTag, ancestorInfo) {
2136        ancestorInfo = ancestorInfo || emptyAncestorInfoDev;
2137        var parentInfo = ancestorInfo.current;
2138        ancestorInfo = (parentInfo = isTagValidWithParent(
2139          childTag,
2140          parentInfo && parentInfo.tag,
2141          ancestorInfo.implicitRootScope
2142        ) ? null : parentInfo) ? null : findInvalidAncestorForTag(childTag, ancestorInfo);
2143        ancestorInfo = parentInfo || ancestorInfo;
2144        if (!ancestorInfo) return true;
2145        var ancestorTag = ancestorInfo.tag;
2146        ancestorInfo = String(!!parentInfo) + "|" + childTag + "|" + ancestorTag;
2147        if (didWarn[ancestorInfo]) return false;
2148        didWarn[ancestorInfo] = true;
2149        var ancestor = (ancestorInfo = current) ? findAncestor(ancestorInfo.return, ancestorTag) : null, ancestorDescription = null !== ancestorInfo && null !== ancestor ? describeAncestors(ancestor, ancestorInfo, null) : "", tagDisplayName = "<" + childTag + ">";
2150        parentInfo ? (parentInfo = "", "table" === ancestorTag && "tr" === childTag && (parentInfo += " Add a <tbody>, <thead> or <tfoot> to your code to match the DOM tree generated by the browser."), console.error(
2151          "In HTML, %s cannot be a child of <%s>.%s\nThis will cause a hydration error.%s",
2152          tagDisplayName,
2153          ancestorTag,
2154          parentInfo,
2155          ancestorDescription
2156        )) : console.error(
2157          "In HTML, %s cannot be a descendant of <%s>.\nThis will cause a hydration error.%s",
2158          tagDisplayName,
2159          ancestorTag,
2160          ancestorDescription
2161        );
2162        ancestorInfo && (childTag = ancestorInfo.return, null === ancestor || null === childTag || ancestor === childTag && childTag._debugOwner === ancestorInfo._debugOwner || runWithFiberInDEV(ancestor, function() {
2163          console.error(
2164            "<%s> cannot contain a nested %s.\nSee this log for the ancestor stack trace.",
2165            ancestorTag,
2166            tagDisplayName
2167          );
2168        }));
2169        return false;
2170      }
2171      function validateTextNesting(childText, parentTag, implicitRootScope) {
2172        if (implicitRootScope || isTagValidWithParent("#text", parentTag, false))
2173          return true;
2174        implicitRootScope = "#text|" + parentTag;
2175        if (didWarn[implicitRootScope]) return false;
2176        didWarn[implicitRootScope] = true;
2177        var ancestor = (implicitRootScope = current) ? findAncestor(implicitRootScope, parentTag) : null;
2178        implicitRootScope = null !== implicitRootScope && null !== ancestor ? describeAncestors(
2179          ancestor,
2180          implicitRootScope,
2181          6 !== implicitRootScope.tag ? { children: null } : null
2182        ) : "";
2183        /\S/.test(childText) ? console.error(
2184          "In HTML, text nodes cannot be a child of <%s>.\nThis will cause a hydration error.%s",
2185          parentTag,
2186          implicitRootScope
2187        ) : console.error(
2188          "In HTML, whitespace text nodes cannot be a child of <%s>. Make sure you don't have any extra whitespace between tags on each line of your source code.\nThis will cause a hydration error.%s",
2189          parentTag,
2190          implicitRootScope
2191        );
2192        return false;
2193      }
2194      function setTextContent(node, text) {
2195        if (text) {
2196          var firstChild = node.firstChild;
2197          if (firstChild && firstChild === node.lastChild && 3 === firstChild.nodeType) {
2198            firstChild.nodeValue = text;
2199            return;
2200          }
2201        }
2202        node.textContent = text;
2203      }
2204      function camelize(string) {
2205        return string.replace(hyphenPattern, function(_, character) {
2206          return character.toUpperCase();
2207        });
2208      }
2209      function setValueForStyle(style2, styleName, value) {
2210        var isCustomProperty = 0 === styleName.indexOf("--");
2211        isCustomProperty || (-1 < styleName.indexOf("-") ? warnedStyleNames.hasOwnProperty(styleName) && warnedStyleNames[styleName] || (warnedStyleNames[styleName] = true, console.error(
2212          "Unsupported style property %s. Did you mean %s?",
2213          styleName,
2214          camelize(styleName.replace(msPattern, "ms-"))
2215        )) : badVendoredStyleNamePattern.test(styleName) ? warnedStyleNames.hasOwnProperty(styleName) && warnedStyleNames[styleName] || (warnedStyleNames[styleName] = true, console.error(
2216          "Unsupported vendor-prefixed style property %s. Did you mean %s?",
2217          styleName,
2218          styleName.charAt(0).toUpperCase() + styleName.slice(1)
2219        )) : !badStyleValueWithSemicolonPattern.test(value) || warnedStyleValues.hasOwnProperty(value) && warnedStyleValues[value] || (warnedStyleValues[value] = true, console.error(
2220          `Style property values shouldn't contain a semicolon. Try "%s: %s" instead.`,
2221          styleName,
2222          value.replace(badStyleValueWithSemicolonPattern, "")
2223        )), "number" === typeof value && (isNaN(value) ? warnedForNaNValue || (warnedForNaNValue = true, console.error(
2224          "`NaN` is an invalid value for the `%s` css style property.",
2225          styleName
2226        )) : isFinite(value) || warnedForInfinityValue || (warnedForInfinityValue = true, console.error(
2227          "`Infinity` is an invalid value for the `%s` css style property.",
2228          styleName
2229        ))));
2230        null == value || "boolean" === typeof value || "" === value ? isCustomProperty ? style2.setProperty(styleName, "") : "float" === styleName ? style2.cssFloat = "" : style2[styleName] = "" : isCustomProperty ? style2.setProperty(styleName, value) : "number" !== typeof value || 0 === value || unitlessNumbers.has(styleName) ? "float" === styleName ? style2.cssFloat = value : (checkCSSPropertyStringCoercion(value, styleName), style2[styleName] = ("" + value).trim()) : style2[styleName] = value + "px";
2231      }
2232      function setValueForStyles(node, styles, prevStyles) {
2233        if (null != styles && "object" !== typeof styles)
2234          throw Error(
2235            "The `style` prop expects a mapping from style properties to values, not a string. For example, style={{marginRight: spacing + 'em'}} when using JSX."
2236          );
2237        styles && Object.freeze(styles);
2238        node = node.style;
2239        if (null != prevStyles) {
2240          if (styles) {
2241            var expandedUpdates = {};
2242            if (prevStyles) {
2243              for (var key in prevStyles)
2244                if (prevStyles.hasOwnProperty(key) && !styles.hasOwnProperty(key))
2245                  for (var longhands = shorthandToLonghand[key] || [key], i = 0; i < longhands.length; i++)
2246                    expandedUpdates[longhands[i]] = key;
2247            }
2248            for (var _key in styles)
2249              if (styles.hasOwnProperty(_key) && (!prevStyles || prevStyles[_key] !== styles[_key]))
2250                for (key = shorthandToLonghand[_key] || [_key], longhands = 0; longhands < key.length; longhands++)
2251                  expandedUpdates[key[longhands]] = _key;
2252            _key = {};
2253            for (var key$jscomp$0 in styles)
2254              for (key = shorthandToLonghand[key$jscomp$0] || [key$jscomp$0], longhands = 0; longhands < key.length; longhands++)
2255                _key[key[longhands]] = key$jscomp$0;
2256            key$jscomp$0 = {};
2257            for (var _key2 in expandedUpdates)
2258              if (key = expandedUpdates[_key2], (longhands = _key[_key2]) && key !== longhands && (i = key + "," + longhands, !key$jscomp$0[i])) {
2259                key$jscomp$0[i] = true;
2260                i = console;
2261                var value = styles[key];
2262                i.error.call(
2263                  i,
2264                  "%s a style property during rerender (%s) when a conflicting property is set (%s) can lead to styling bugs. To avoid this, don't mix shorthand and non-shorthand properties for the same value; instead, replace the shorthand with separate values.",
2265                  null == value || "boolean" === typeof value || "" === value ? "Removing" : "Updating",
2266                  key,
2267                  longhands
2268                );
2269              }
2270          }
2271          for (var styleName in prevStyles)
2272            !prevStyles.hasOwnProperty(styleName) || null != styles && styles.hasOwnProperty(styleName) || (0 === styleName.indexOf("--") ? node.setProperty(styleName, "") : "float" === styleName ? node.cssFloat = "" : node[styleName] = "");
2273          for (var _styleName in styles)
2274            _key2 = styles[_styleName], styles.hasOwnProperty(_styleName) && prevStyles[_styleName] !== _key2 && setValueForStyle(node, _styleName, _key2);
2275        } else
2276          for (expandedUpdates in styles)
2277            styles.hasOwnProperty(expandedUpdates) && setValueForStyle(node, expandedUpdates, styles[expandedUpdates]);
2278      }
2279      function isCustomElement(tagName) {
2280        if (-1 === tagName.indexOf("-")) return false;
2281        switch (tagName) {
2282          case "annotation-xml":
2283          case "color-profile":
2284          case "font-face":
2285          case "font-face-src":
2286          case "font-face-uri":
2287          case "font-face-format":
2288          case "font-face-name":
2289          case "missing-glyph":
2290            return false;
2291          default:
2292            return true;
2293        }
2294      }
2295      function getAttributeAlias(name) {
2296        return aliases.get(name) || name;
2297      }
2298      function validateProperty$1(tagName, name) {
2299        if (hasOwnProperty.call(warnedProperties$1, name) && warnedProperties$1[name])
2300          return true;
2301        if (rARIACamel$1.test(name)) {
2302          tagName = "aria-" + name.slice(4).toLowerCase();
2303          tagName = ariaProperties.hasOwnProperty(tagName) ? tagName : null;
2304          if (null == tagName)
2305            return console.error(
2306              "Invalid ARIA attribute `%s`. ARIA attributes follow the pattern aria-* and must be lowercase.",
2307              name
2308            ), warnedProperties$1[name] = true;
2309          if (name !== tagName)
2310            return console.error(
2311              "Invalid ARIA attribute `%s`. Did you mean `%s`?",
2312              name,
2313              tagName
2314            ), warnedProperties$1[name] = true;
2315        }
2316        if (rARIA$1.test(name)) {
2317          tagName = name.toLowerCase();
2318          tagName = ariaProperties.hasOwnProperty(tagName) ? tagName : null;
2319          if (null == tagName) return warnedProperties$1[name] = true, false;
2320          name !== tagName && (console.error(
2321            "Unknown ARIA attribute `%s`. Did you mean `%s`?",
2322            name,
2323            tagName
2324          ), warnedProperties$1[name] = true);
2325        }
2326        return true;
2327      }
2328      function validateProperties$2(type, props) {
2329        var invalidProps = [], key;
2330        for (key in props)
2331          validateProperty$1(type, key) || invalidProps.push(key);
2332        props = invalidProps.map(function(prop) {
2333          return "`" + prop + "`";
2334        }).join(", ");
2335        1 === invalidProps.length ? console.error(
2336          "Invalid aria prop %s on <%s> tag. For details, see https://react.dev/link/invalid-aria-props",
2337          props,
2338          type
2339        ) : 1 < invalidProps.length && console.error(
2340          "Invalid aria props %s on <%s> tag. For details, see https://react.dev/link/invalid-aria-props",
2341          props,
2342          type
2343        );
2344      }
2345      function validateProperty(tagName, name, value, eventRegistry) {
2346        if (hasOwnProperty.call(warnedProperties, name) && warnedProperties[name])
2347          return true;
2348        var lowerCasedName = name.toLowerCase();
2349        if ("onfocusin" === lowerCasedName || "onfocusout" === lowerCasedName)
2350          return console.error(
2351            "React uses onFocus and onBlur instead of onFocusIn and onFocusOut. All React events are normalized to bubble, so onFocusIn and onFocusOut are not needed/supported by React."
2352          ), warnedProperties[name] = true;
2353        if ("function" === typeof value && ("form" === tagName && "action" === name || "input" === tagName && "formAction" === name || "button" === tagName && "formAction" === name))
2354          return true;
2355        if (null != eventRegistry) {
2356          tagName = eventRegistry.possibleRegistrationNames;
2357          if (eventRegistry.registrationNameDependencies.hasOwnProperty(name))
2358            return true;
2359          eventRegistry = tagName.hasOwnProperty(lowerCasedName) ? tagName[lowerCasedName] : null;
2360          if (null != eventRegistry)
2361            return console.error(
2362              "Invalid event handler property `%s`. Did you mean `%s`?",
2363              name,
2364              eventRegistry
2365            ), warnedProperties[name] = true;
2366          if (EVENT_NAME_REGEX.test(name))
2367            return console.error(
2368              "Unknown event handler property `%s`. It will be ignored.",
2369              name
2370            ), warnedProperties[name] = true;
2371        } else if (EVENT_NAME_REGEX.test(name))
2372          return INVALID_EVENT_NAME_REGEX.test(name) && console.error(
2373            "Invalid event handler property `%s`. React events use the camelCase naming convention, for example `onClick`.",
2374            name
2375          ), warnedProperties[name] = true;
2376        if (rARIA.test(name) || rARIACamel.test(name)) return true;
2377        if ("innerhtml" === lowerCasedName)
2378          return console.error(
2379            "Directly setting property `innerHTML` is not permitted. For more information, lookup documentation on `dangerouslySetInnerHTML`."
2380          ), warnedProperties[name] = true;
2381        if ("aria" === lowerCasedName)
2382          return console.error(
2383            "The `aria` attribute is reserved for future use in React. Pass individual `aria-` attributes instead."
2384          ), warnedProperties[name] = true;
2385        if ("is" === lowerCasedName && null !== value && void 0 !== value && "string" !== typeof value)
2386          return console.error(
2387            "Received a `%s` for a string attribute `is`. If this is expected, cast the value to a string.",
2388            typeof value
2389          ), warnedProperties[name] = true;
2390        if ("number" === typeof value && isNaN(value))
2391          return console.error(
2392            "Received NaN for the `%s` attribute. If this is expected, cast the value to a string.",
2393            name
2394          ), warnedProperties[name] = true;
2395        if (possibleStandardNames.hasOwnProperty(lowerCasedName)) {
2396          if (lowerCasedName = possibleStandardNames[lowerCasedName], lowerCasedName !== name)
2397            return console.error(
2398              "Invalid DOM property `%s`. Did you mean `%s`?",
2399              name,
2400              lowerCasedName
2401            ), warnedProperties[name] = true;
2402        } else if (name !== lowerCasedName)
2403          return console.error(
2404            "React does not recognize the `%s` prop on a DOM element. If you intentionally want it to appear in the DOM as a custom attribute, spell it as lowercase `%s` instead. If you accidentally passed it from a parent component, remove it from the DOM element.",
2405            name,
2406            lowerCasedName
2407          ), warnedProperties[name] = true;
2408        switch (name) {
2409          case "dangerouslySetInnerHTML":
2410          case "children":
2411          case "style":
2412          case "suppressContentEditableWarning":
2413          case "suppressHydrationWarning":
2414          case "defaultValue":
2415          case "defaultChecked":
2416          case "innerHTML":
2417          case "ref":
2418            return true;
2419          case "innerText":
2420          case "textContent":
2421            return true;
2422        }
2423        switch (typeof value) {
2424          case "boolean":
2425            switch (name) {
2426              case "autoFocus":
2427              case "checked":
2428              case "multiple":
2429              case "muted":
2430              case "selected":
2431              case "contentEditable":
2432              case "spellCheck":
2433              case "draggable":
2434              case "value":
2435              case "autoReverse":
2436              case "externalResourcesRequired":
2437              case "focusable":
2438              case "preserveAlpha":
2439              case "allowFullScreen":
2440              case "async":
2441              case "autoPlay":
2442              case "controls":
2443              case "default":
2444              case "defer":
2445              case "disabled":
2446              case "disablePictureInPicture":
2447              case "disableRemotePlayback":
2448              case "formNoValidate":
2449              case "hidden":
2450              case "loop":
2451              case "noModule":
2452              case "noValidate":
2453              case "open":
2454              case "playsInline":
2455              case "readOnly":
2456              case "required":
2457              case "reversed":
2458              case "scoped":
2459              case "seamless":
2460              case "itemScope":
2461              case "capture":
2462              case "download":
2463              case "inert":
2464                return true;
2465              default:
2466                lowerCasedName = name.toLowerCase().slice(0, 5);
2467                if ("data-" === lowerCasedName || "aria-" === lowerCasedName)
2468                  return true;
2469                value ? console.error(
2470                  'Received `%s` for a non-boolean attribute `%s`.\n\nIf you want to write it to the DOM, pass a string instead: %s="%s" or %s={value.toString()}.',
2471                  value,
2472                  name,
2473                  name,
2474                  value,
2475                  name
2476                ) : console.error(
2477                  'Received `%s` for a non-boolean attribute `%s`.\n\nIf you want to write it to the DOM, pass a string instead: %s="%s" or %s={value.toString()}.\n\nIf you used to conditionally omit it with %s={condition && value}, pass %s={condition ? value : undefined} instead.',
2478                  value,
2479                  name,
2480                  name,
2481                  value,
2482                  name,
2483                  name,
2484                  name
2485                );
2486                return warnedProperties[name] = true;
2487            }
2488          case "function":
2489          case "symbol":
2490            return warnedProperties[name] = true, false;
2491          case "string":
2492            if ("false" === value || "true" === value) {
2493              switch (name) {
2494                case "checked":
2495                case "selected":
2496                case "multiple":
2497                case "muted":
2498                case "allowFullScreen":
2499                case "async":
2500                case "autoPlay":
2501                case "controls":
2502                case "default":
2503                case "defer":
2504                case "disabled":
2505                case "disablePictureInPicture":
2506                case "disableRemotePlayback":
2507                case "formNoValidate":
2508                case "hidden":
2509                case "loop":
2510                case "noModule":
2511                case "noValidate":
2512                case "open":
2513                case "playsInline":
2514                case "readOnly":
2515                case "required":
2516                case "reversed":
2517                case "scoped":
2518                case "seamless":
2519                case "itemScope":
2520                case "inert":
2521                  break;
2522                default:
2523                  return true;
2524              }
2525              console.error(
2526                "Received the string `%s` for the boolean attribute `%s`. %s Did you mean %s={%s}?",
2527                value,
2528                name,
2529                "false" === value ? "The browser will interpret it as a truthy value." : 'Although this works, it will not work as expected if you pass the string "false".',
2530                name,
2531                value
2532              );
2533              warnedProperties[name] = true;
2534            }
2535        }
2536        return true;
2537      }
2538      function warnUnknownProperties(type, props, eventRegistry) {
2539        var unknownProps = [], key;
2540        for (key in props)
2541          validateProperty(type, key, props[key], eventRegistry) || unknownProps.push(key);
2542        props = unknownProps.map(function(prop) {
2543          return "`" + prop + "`";
2544        }).join(", ");
2545        1 === unknownProps.length ? console.error(
2546          "Invalid value for prop %s on <%s> tag. Either remove it from the element, or pass a string or number value to keep it in the DOM. For details, see https://react.dev/link/attribute-behavior ",
2547          props,
2548          type
2549        ) : 1 < unknownProps.length && console.error(
2550          "Invalid values for props %s on <%s> tag. Either remove them from the element, or pass a string or number value to keep them in the DOM. For details, see https://react.dev/link/attribute-behavior ",
2551          props,
2552          type
2553        );
2554      }
2555      function sanitizeURL(url) {
2556        return isJavaScriptProtocol.test("" + url) ? "javascript:throw new Error('React has blocked a javascript: URL as a security precaution.')" : url;
2557      }
2558      function noop$1() {
2559      }
2560      function getEventTarget(nativeEvent) {
2561        nativeEvent = nativeEvent.target || nativeEvent.srcElement || window;
2562        nativeEvent.correspondingUseElement && (nativeEvent = nativeEvent.correspondingUseElement);
2563        return 3 === nativeEvent.nodeType ? nativeEvent.parentNode : nativeEvent;
2564      }
2565      function restoreStateOfTarget(target) {
2566        var internalInstance = getInstanceFromNode(target);
2567        if (internalInstance && (target = internalInstance.stateNode)) {
2568          var props = target[internalPropsKey] || null;
2569          a: switch (target = internalInstance.stateNode, internalInstance.type) {
2570            case "input":
2571              updateInput(
2572                target,
2573                props.value,
2574                props.defaultValue,
2575                props.defaultValue,
2576                props.checked,
2577                props.defaultChecked,
2578                props.type,
2579                props.name
2580              );
2581              internalInstance = props.name;
2582              if ("radio" === props.type && null != internalInstance) {
2583                for (props = target; props.parentNode; ) props = props.parentNode;
2584                checkAttributeStringCoercion(internalInstance, "name");
2585                props = props.querySelectorAll(
2586                  'input[name="' + escapeSelectorAttributeValueInsideDoubleQuotes(
2587                    "" + internalInstance
2588                  ) + '"][type="radio"]'
2589                );
2590                for (internalInstance = 0; internalInstance < props.length; internalInstance++) {
2591                  var otherNode = props[internalInstance];
2592                  if (otherNode !== target && otherNode.form === target.form) {
2593                    var otherProps = otherNode[internalPropsKey] || null;
2594                    if (!otherProps)
2595                      throw Error(
2596                        "ReactDOMInput: Mixing React and non-React radio inputs with the same `name` is not supported."
2597                      );
2598                    updateInput(
2599                      otherNode,
2600                      otherProps.value,
2601                      otherProps.defaultValue,
2602                      otherProps.defaultValue,
2603                      otherProps.checked,
2604                      otherProps.defaultChecked,
2605                      otherProps.type,
2606                      otherProps.name
2607                    );
2608                  }
2609                }
2610                for (internalInstance = 0; internalInstance < props.length; internalInstance++)
2611                  otherNode = props[internalInstance], otherNode.form === target.form && updateValueIfChanged(otherNode);
2612              }
2613              break a;
2614            case "textarea":
2615              updateTextarea(target, props.value, props.defaultValue);
2616              break a;
2617            case "select":
2618              internalInstance = props.value, null != internalInstance && updateOptions(target, !!props.multiple, internalInstance, false);
2619          }
2620        }
2621      }
2622      function batchedUpdates$1(fn, a, b) {
2623        if (isInsideEventHandler) return fn(a, b);
2624        isInsideEventHandler = true;
2625        try {
2626          var JSCompiler_inline_result = fn(a);
2627          return JSCompiler_inline_result;
2628        } finally {
2629          if (isInsideEventHandler = false, null !== restoreTarget || null !== restoreQueue) {
2630            if (flushSyncWork$1(), restoreTarget && (a = restoreTarget, fn = restoreQueue, restoreQueue = restoreTarget = null, restoreStateOfTarget(a), fn))
2631              for (a = 0; a < fn.length; a++) restoreStateOfTarget(fn[a]);
2632          }
2633        }
2634      }
2635      function getListener(inst, registrationName) {
2636        var stateNode = inst.stateNode;
2637        if (null === stateNode) return null;
2638        var props = stateNode[internalPropsKey] || null;
2639        if (null === props) return null;
2640        stateNode = props[registrationName];
2641        a: switch (registrationName) {
2642          case "onClick":
2643          case "onClickCapture":
2644          case "onDoubleClick":
2645          case "onDoubleClickCapture":
2646          case "onMouseDown":
2647          case "onMouseDownCapture":
2648          case "onMouseMove":
2649          case "onMouseMoveCapture":
2650          case "onMouseUp":
2651          case "onMouseUpCapture":
2652          case "onMouseEnter":
2653            (props = !props.disabled) || (inst = inst.type, props = !("button" === inst || "input" === inst || "select" === inst || "textarea" === inst));
2654            inst = !props;
2655            break a;
2656          default:
2657            inst = false;
2658        }
2659        if (inst) return null;
2660        if (stateNode && "function" !== typeof stateNode)
2661          throw Error(
2662            "Expected `" + registrationName + "` listener to be a function, instead got a value of `" + typeof stateNode + "` type."
2663          );
2664        return stateNode;
2665      }
2666      function getData() {
2667        if (fallbackText) return fallbackText;
2668        var start, startValue = startText, startLength = startValue.length, end, endValue = "value" in root ? root.value : root.textContent, endLength = endValue.length;
2669        for (start = 0; start < startLength && startValue[start] === endValue[start]; start++) ;
2670        var minEnd = startLength - start;
2671        for (end = 1; end <= minEnd && startValue[startLength - end] === endValue[endLength - end]; end++) ;
2672        return fallbackText = endValue.slice(start, 1 < end ? 1 - end : void 0);
2673      }
2674      function getEventCharCode(nativeEvent) {
2675        var keyCode = nativeEvent.keyCode;
2676        "charCode" in nativeEvent ? (nativeEvent = nativeEvent.charCode, 0 === nativeEvent && 13 === keyCode && (nativeEvent = 13)) : nativeEvent = keyCode;
2677        10 === nativeEvent && (nativeEvent = 13);
2678        return 32 <= nativeEvent || 13 === nativeEvent ? nativeEvent : 0;
2679      }
2680      function functionThatReturnsTrue() {
2681        return true;
2682      }
2683      function functionThatReturnsFalse() {
2684        return false;
2685      }
2686      function createSyntheticEvent(Interface) {
2687        function SyntheticBaseEvent(reactName, reactEventType, targetInst, nativeEvent, nativeEventTarget) {
2688          this._reactName = reactName;
2689          this._targetInst = targetInst;
2690          this.type = reactEventType;
2691          this.nativeEvent = nativeEvent;
2692          this.target = nativeEventTarget;
2693          this.currentTarget = null;
2694          for (var propName in Interface)
2695            Interface.hasOwnProperty(propName) && (reactName = Interface[propName], this[propName] = reactName ? reactName(nativeEvent) : nativeEvent[propName]);
2696          this.isDefaultPrevented = (null != nativeEvent.defaultPrevented ? nativeEvent.defaultPrevented : false === nativeEvent.returnValue) ? functionThatReturnsTrue : functionThatReturnsFalse;
2697          this.isPropagationStopped = functionThatReturnsFalse;
2698          return this;
2699        }
2700        assign(SyntheticBaseEvent.prototype, {
2701          preventDefault: function() {
2702            this.defaultPrevented = true;
2703            var event = this.nativeEvent;
2704            event && (event.preventDefault ? event.preventDefault() : "unknown" !== typeof event.returnValue && (event.returnValue = false), this.isDefaultPrevented = functionThatReturnsTrue);
2705          },
2706          stopPropagation: function() {
2707            var event = this.nativeEvent;
2708            event && (event.stopPropagation ? event.stopPropagation() : "unknown" !== typeof event.cancelBubble && (event.cancelBubble = true), this.isPropagationStopped = functionThatReturnsTrue);
2709          },
2710          persist: function() {
2711          },
2712          isPersistent: functionThatReturnsTrue
2713        });
2714        return SyntheticBaseEvent;
2715      }
2716      function modifierStateGetter(keyArg) {
2717        var nativeEvent = this.nativeEvent;
2718        return nativeEvent.getModifierState ? nativeEvent.getModifierState(keyArg) : (keyArg = modifierKeyToProp[keyArg]) ? !!nativeEvent[keyArg] : false;
2719      }
2720      function getEventModifierState() {
2721        return modifierStateGetter;
2722      }
2723      function isFallbackCompositionEnd(domEventName, nativeEvent) {
2724        switch (domEventName) {
2725          case "keyup":
2726            return -1 !== END_KEYCODES.indexOf(nativeEvent.keyCode);
2727          case "keydown":
2728            return nativeEvent.keyCode !== START_KEYCODE;
2729          case "keypress":
2730          case "mousedown":
2731          case "focusout":
2732            return true;
2733          default:
2734            return false;
2735        }
2736      }
2737      function getDataFromCustomEvent(nativeEvent) {
2738        nativeEvent = nativeEvent.detail;
2739        return "object" === typeof nativeEvent && "data" in nativeEvent ? nativeEvent.data : null;
2740      }
2741      function getNativeBeforeInputChars(domEventName, nativeEvent) {
2742        switch (domEventName) {
2743          case "compositionend":
2744            return getDataFromCustomEvent(nativeEvent);
2745          case "keypress":
2746            if (nativeEvent.which !== SPACEBAR_CODE) return null;
2747            hasSpaceKeypress = true;
2748            return SPACEBAR_CHAR;
2749          case "textInput":
2750            return domEventName = nativeEvent.data, domEventName === SPACEBAR_CHAR && hasSpaceKeypress ? null : domEventName;
2751          default:
2752            return null;
2753        }
2754      }
2755      function getFallbackBeforeInputChars(domEventName, nativeEvent) {
2756        if (isComposing)
2757          return "compositionend" === domEventName || !canUseCompositionEvent && isFallbackCompositionEnd(domEventName, nativeEvent) ? (domEventName = getData(), fallbackText = startText = root = null, isComposing = false, domEventName) : null;
2758        switch (domEventName) {
2759          case "paste":
2760            return null;
2761          case "keypress":
2762            if (!(nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) || nativeEvent.ctrlKey && nativeEvent.altKey) {
2763              if (nativeEvent.char && 1 < nativeEvent.char.length)
2764                return nativeEvent.char;
2765              if (nativeEvent.which)
2766                return String.fromCharCode(nativeEvent.which);
2767            }
2768            return null;
2769          case "compositionend":
2770            return useFallbackCompositionData && "ko" !== nativeEvent.locale ? null : nativeEvent.data;
2771          default:
2772            return null;
2773        }
2774      }
2775      function isTextInputElement(elem) {
2776        var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
2777        return "input" === nodeName ? !!supportedInputTypes[elem.type] : "textarea" === nodeName ? true : false;
2778      }
2779      function isEventSupported(eventNameSuffix) {
2780        if (!canUseDOM) return false;
2781        eventNameSuffix = "on" + eventNameSuffix;
2782        var isSupported = eventNameSuffix in document;
2783        isSupported || (isSupported = document.createElement("div"), isSupported.setAttribute(eventNameSuffix, "return;"), isSupported = "function" === typeof isSupported[eventNameSuffix]);
2784        return isSupported;
2785      }
2786      function createAndAccumulateChangeEvent(dispatchQueue, inst, nativeEvent, target) {
2787        restoreTarget ? restoreQueue ? restoreQueue.push(target) : restoreQueue = [target] : restoreTarget = target;
2788        inst = accumulateTwoPhaseListeners(inst, "onChange");
2789        0 < inst.length && (nativeEvent = new SyntheticEvent(
2790          "onChange",
2791          "change",
2792          null,
2793          nativeEvent,
2794          target
2795        ), dispatchQueue.push({ event: nativeEvent, listeners: inst }));
2796      }
2797      function runEventInBatch(dispatchQueue) {
2798        processDispatchQueue(dispatchQueue, 0);
2799      }
2800      function getInstIfValueChanged(targetInst) {
2801        var targetNode = getNodeFromInstance(targetInst);
2802        if (updateValueIfChanged(targetNode)) return targetInst;
2803      }
2804      function getTargetInstForChangeEvent(domEventName, targetInst) {
2805        if ("change" === domEventName) return targetInst;
2806      }
2807      function stopWatchingForValueChange() {
2808        activeElement$1 && (activeElement$1.detachEvent("onpropertychange", handlePropertyChange), activeElementInst$1 = activeElement$1 = null);
2809      }
2810      function handlePropertyChange(nativeEvent) {
2811        if ("value" === nativeEvent.propertyName && getInstIfValueChanged(activeElementInst$1)) {
2812          var dispatchQueue = [];
2813          createAndAccumulateChangeEvent(
2814            dispatchQueue,
2815            activeElementInst$1,
2816            nativeEvent,
2817            getEventTarget(nativeEvent)
2818          );
2819          batchedUpdates$1(runEventInBatch, dispatchQueue);
2820        }
2821      }
2822      function handleEventsForInputEventPolyfill(domEventName, target, targetInst) {
2823        "focusin" === domEventName ? (stopWatchingForValueChange(), activeElement$1 = target, activeElementInst$1 = targetInst, activeElement$1.attachEvent("onpropertychange", handlePropertyChange)) : "focusout" === domEventName && stopWatchingForValueChange();
2824      }
2825      function getTargetInstForInputEventPolyfill(domEventName) {
2826        if ("selectionchange" === domEventName || "keyup" === domEventName || "keydown" === domEventName)
2827          return getInstIfValueChanged(activeElementInst$1);
2828      }
2829      function getTargetInstForClickEvent(domEventName, targetInst) {
2830        if ("click" === domEventName) return getInstIfValueChanged(targetInst);
2831      }
2832      function getTargetInstForInputOrChangeEvent(domEventName, targetInst) {
2833        if ("input" === domEventName || "change" === domEventName)
2834          return getInstIfValueChanged(targetInst);
2835      }
2836      function is(x, y) {
2837        return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
2838      }
2839      function shallowEqual(objA, objB) {
2840        if (objectIs(objA, objB)) return true;
2841        if ("object" !== typeof objA || null === objA || "object" !== typeof objB || null === objB)
2842          return false;
2843        var keysA = Object.keys(objA), keysB = Object.keys(objB);
2844        if (keysA.length !== keysB.length) return false;
2845        for (keysB = 0; keysB < keysA.length; keysB++) {
2846          var currentKey = keysA[keysB];
2847          if (!hasOwnProperty.call(objB, currentKey) || !objectIs(objA[currentKey], objB[currentKey]))
2848            return false;
2849        }
2850        return true;
2851      }
2852      function getLeafNode(node) {
2853        for (; node && node.firstChild; ) node = node.firstChild;
2854        return node;
2855      }
2856      function getNodeForCharacterOffset(root2, offset) {
2857        var node = getLeafNode(root2);
2858        root2 = 0;
2859        for (var nodeEnd; node; ) {
2860          if (3 === node.nodeType) {
2861            nodeEnd = root2 + node.textContent.length;
2862            if (root2 <= offset && nodeEnd >= offset)
2863              return { node, offset: offset - root2 };
2864            root2 = nodeEnd;
2865          }
2866          a: {
2867            for (; node; ) {
2868              if (node.nextSibling) {
2869                node = node.nextSibling;
2870                break a;
2871              }
2872              node = node.parentNode;
2873            }
2874            node = void 0;
2875          }
2876          node = getLeafNode(node);
2877        }
2878      }
2879      function containsNode(outerNode, innerNode) {
2880        return outerNode && innerNode ? outerNode === innerNode ? true : outerNode && 3 === outerNode.nodeType ? false : innerNode && 3 === innerNode.nodeType ? containsNode(outerNode, innerNode.parentNode) : "contains" in outerNode ? outerNode.contains(innerNode) : outerNode.compareDocumentPosition ? !!(outerNode.compareDocumentPosition(innerNode) & 16) : false : false;
2881      }
2882      function getActiveElementDeep(containerInfo) {
2883        containerInfo = null != containerInfo && null != containerInfo.ownerDocument && null != containerInfo.ownerDocument.defaultView ? containerInfo.ownerDocument.defaultView : window;
2884        for (var element = getActiveElement(containerInfo.document); element instanceof containerInfo.HTMLIFrameElement; ) {
2885          try {
2886            var JSCompiler_inline_result = "string" === typeof element.contentWindow.location.href;
2887          } catch (err) {
2888            JSCompiler_inline_result = false;
2889          }
2890          if (JSCompiler_inline_result) containerInfo = element.contentWindow;
2891          else break;
2892          element = getActiveElement(containerInfo.document);
2893        }
2894        return element;
2895      }
2896      function hasSelectionCapabilities(elem) {
2897        var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
2898        return nodeName && ("input" === nodeName && ("text" === elem.type || "search" === elem.type || "tel" === elem.type || "url" === elem.type || "password" === elem.type) || "textarea" === nodeName || "true" === elem.contentEditable);
2899      }
2900      function constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget) {
2901        var doc = nativeEventTarget.window === nativeEventTarget ? nativeEventTarget.document : 9 === nativeEventTarget.nodeType ? nativeEventTarget : nativeEventTarget.ownerDocument;
2902        mouseDown || null == activeElement || activeElement !== getActiveElement(doc) || (doc = activeElement, "selectionStart" in doc && hasSelectionCapabilities(doc) ? doc = { start: doc.selectionStart, end: doc.selectionEnd } : (doc = (doc.ownerDocument && doc.ownerDocument.defaultView || window).getSelection(), doc = {
2903          anchorNode: doc.anchorNode,
2904          anchorOffset: doc.anchorOffset,
2905          focusNode: doc.focusNode,
2906          focusOffset: doc.focusOffset
2907        }), lastSelection && shallowEqual(lastSelection, doc) || (lastSelection = doc, doc = accumulateTwoPhaseListeners(activeElementInst, "onSelect"), 0 < doc.length && (nativeEvent = new SyntheticEvent(
2908          "onSelect",
2909          "select",
2910          null,
2911          nativeEvent,
2912          nativeEventTarget
2913        ), dispatchQueue.push({ event: nativeEvent, listeners: doc }), nativeEvent.target = activeElement)));
2914      }
2915      function makePrefixMap(styleProp, eventName) {
2916        var prefixes = {};
2917        prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();
2918        prefixes["Webkit" + styleProp] = "webkit" + eventName;
2919        prefixes["Moz" + styleProp] = "moz" + eventName;
2920        return prefixes;
2921      }
2922      function getVendorPrefixedEventName(eventName) {
2923        if (prefixedEventNames[eventName]) return prefixedEventNames[eventName];
2924        if (!vendorPrefixes[eventName]) return eventName;
2925        var prefixMap = vendorPrefixes[eventName], styleProp;
2926        for (styleProp in prefixMap)
2927          if (prefixMap.hasOwnProperty(styleProp) && styleProp in style)
2928            return prefixedEventNames[eventName] = prefixMap[styleProp];
2929        return eventName;
2930      }
2931      function registerSimpleEvent(domEventName, reactName) {
2932        topLevelEventsToReactNames.set(domEventName, reactName);
2933        registerTwoPhaseEvent(reactName, [domEventName]);
2934      }
2935      function getArrayKind(array) {
2936        for (var kind = EMPTY_ARRAY, i = 0; i < array.length; i++) {
2937          var value = array[i];
2938          if ("object" === typeof value && null !== value)
2939            if (isArrayImpl(value) && 2 === value.length && "string" === typeof value[0]) {
2940              if (kind !== EMPTY_ARRAY && kind !== ENTRIES_ARRAY)
2941                return COMPLEX_ARRAY;
2942              kind = ENTRIES_ARRAY;
2943            } else return COMPLEX_ARRAY;
2944          else {
2945            if ("function" === typeof value || "string" === typeof value && 50 < value.length || kind !== EMPTY_ARRAY && kind !== PRIMITIVE_ARRAY)
2946              return COMPLEX_ARRAY;
2947            kind = PRIMITIVE_ARRAY;
2948          }
2949        }
2950        return kind;
2951      }
2952      function addObjectToProperties(object, properties, indent, prefix2) {
2953        for (var key in object)
2954          hasOwnProperty.call(object, key) && "_" !== key[0] && addValueToProperties(key, object[key], properties, indent, prefix2);
2955      }
2956      function addValueToProperties(propertyName, value, properties, indent, prefix2) {
2957        switch (typeof value) {
2958          case "object":
2959            if (null === value) {
2960              value = "null";
2961              break;
2962            } else {
2963              if (value.$$typeof === REACT_ELEMENT_TYPE) {
2964                var typeName2 = getComponentNameFromType(value.type) || "…", key = value.key;
2965                value = value.props;
2966                var propsKeys = Object.keys(value), propsLength = propsKeys.length;
2967                if (null == key && 0 === propsLength) {
2968                  value = "<" + typeName2 + " />";
2969                  break;
2970                }
2971                if (3 > indent || 1 === propsLength && "children" === propsKeys[0] && null == key) {
2972                  value = "<" + typeName2 + " … />";
2973                  break;
2974                }
2975                properties.push([
2976                  prefix2 + "  ".repeat(indent) + propertyName,
2977                  "<" + typeName2
2978                ]);
2979                null !== key && addValueToProperties(
2980                  "key",
2981                  key,
2982                  properties,
2983                  indent + 1,
2984                  prefix2
2985                );
2986                propertyName = false;
2987                for (var propKey in value)
2988                  "children" === propKey ? null != value.children && (!isArrayImpl(value.children) || 0 < value.children.length) && (propertyName = true) : hasOwnProperty.call(value, propKey) && "_" !== propKey[0] && addValueToProperties(
2989                    propKey,
2990                    value[propKey],
2991                    properties,
2992                    indent + 1,
2993                    prefix2
2994                  );
2995                properties.push([
2996                  "",
2997                  propertyName ? ">…</" + typeName2 + ">" : "/>"
2998                ]);
2999                return;
3000              }
3001              typeName2 = Object.prototype.toString.call(value);
3002              typeName2 = typeName2.slice(8, typeName2.length - 1);
3003              if ("Array" === typeName2) {
3004                if (propKey = getArrayKind(value), propKey === PRIMITIVE_ARRAY || propKey === EMPTY_ARRAY) {
3005                  value = JSON.stringify(value);
3006                  break;
3007                } else if (propKey === ENTRIES_ARRAY) {
3008                  properties.push([
3009                    prefix2 + "  ".repeat(indent) + propertyName,
3010                    ""
3011                  ]);
3012                  for (propertyName = 0; propertyName < value.length; propertyName++)
3013                    typeName2 = value[propertyName], addValueToProperties(
3014                      typeName2[0],
3015                      typeName2[1],
3016                      properties,
3017                      indent + 1,
3018                      prefix2
3019                    );
3020                  return;
3021                }
3022              }
3023              if ("Promise" === typeName2) {
3024                if ("fulfilled" === value.status) {
3025                  if (typeName2 = properties.length, addValueToProperties(
3026                    propertyName,
3027                    value.value,
3028                    properties,
3029                    indent,
3030                    prefix2
3031                  ), properties.length > typeName2) {
3032                    properties = properties[typeName2];
3033                    properties[1] = "Promise<" + (properties[1] || "Object") + ">";
3034                    return;
3035                  }
3036                } else if ("rejected" === value.status && (typeName2 = properties.length, addValueToProperties(
3037                  propertyName,
3038                  value.reason,
3039                  properties,
3040                  indent,
3041                  prefix2
3042                ), properties.length > typeName2)) {
3043                  properties = properties[typeName2];
3044                  properties[1] = "Rejected Promise<" + properties[1] + ">";
3045                  return;
3046                }
3047                properties.push([
3048                  "  ".repeat(indent) + propertyName,
3049                  "Promise"
3050                ]);
3051                return;
3052              }
3053              "Object" === typeName2 && (propKey = Object.getPrototypeOf(value)) && "function" === typeof propKey.constructor && (typeName2 = propKey.constructor.name);
3054              properties.push([
3055                prefix2 + "  ".repeat(indent) + propertyName,
3056                "Object" === typeName2 ? 3 > indent ? "" : "…" : typeName2
3057              ]);
3058              3 > indent && addObjectToProperties(value, properties, indent + 1, prefix2);
3059              return;
3060            }
3061          case "function":
3062            value = "" === value.name ? "() => {}" : value.name + "() {}";
3063            break;
3064          case "string":
3065            value = value === OMITTED_PROP_ERROR ? "…" : JSON.stringify(value);
3066            break;
3067          case "undefined":
3068            value = "undefined";
3069            break;
3070          case "boolean":
3071            value = value ? "true" : "false";
3072            break;
3073          default:
3074            value = String(value);
3075        }
3076        properties.push([
3077          prefix2 + "  ".repeat(indent) + propertyName,
3078          value
3079        ]);
3080      }
3081      function addObjectDiffToProperties(prev, next, properties, indent) {
3082        var isDeeplyEqual = true;
3083        for (key in prev)
3084          key in next || (properties.push([
3085            REMOVED + "  ".repeat(indent) + key,
3086            "…"
3087          ]), isDeeplyEqual = false);
3088        for (var _key in next)
3089          if (_key in prev) {
3090            var key = prev[_key];
3091            var nextValue = next[_key];
3092            if (key !== nextValue) {
3093              if (0 === indent && "children" === _key)
3094                isDeeplyEqual = "  ".repeat(indent) + _key, properties.push(
3095                  [REMOVED + isDeeplyEqual, "…"],
3096                  [ADDED + isDeeplyEqual, "…"]
3097                );
3098              else {
3099                if (!(3 <= indent)) {
3100                  if ("object" === typeof key && "object" === typeof nextValue && null !== key && null !== nextValue && key.$$typeof === nextValue.$$typeof)
3101                    if (nextValue.$$typeof === REACT_ELEMENT_TYPE) {
3102                      if (key.type === nextValue.type && key.key === nextValue.key) {
3103                        key = getComponentNameFromType(nextValue.type) || "…";
3104                        isDeeplyEqual = "  ".repeat(indent) + _key;
3105                        key = "<" + key + " … />";
3106                        properties.push(
3107                          [REMOVED + isDeeplyEqual, key],
3108                          [ADDED + isDeeplyEqual, key]
3109                        );
3110                        isDeeplyEqual = false;
3111                        continue;
3112                      }
3113                    } else {
3114                      var prevKind = Object.prototype.toString.call(key), nextKind = Object.prototype.toString.call(nextValue);
3115                      if (prevKind === nextKind && ("[object Object]" === nextKind || "[object Array]" === nextKind)) {
3116                        prevKind = [
3117                          UNCHANGED + "  ".repeat(indent) + _key,
3118                          "[object Array]" === nextKind ? "Array" : ""
3119                        ];
3120                        properties.push(prevKind);
3121                        nextKind = properties.length;
3122                        addObjectDiffToProperties(
3123                          key,
3124                          nextValue,
3125                          properties,
3126                          indent + 1
3127                        ) ? nextKind === properties.length && (prevKind[1] = "Referentially unequal but deeply equal objects. Consider memoization.") : isDeeplyEqual = false;
3128                        continue;
3129                      }
3130                    }
3131                  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)) {
3132                    key = "" === nextValue.name ? "() => {}" : nextValue.name + "() {}";
3133                    properties.push([
3134                      UNCHANGED + "  ".repeat(indent) + _key,
3135                      key + " Referentially unequal function closure. Consider memoization."
3136                    ]);
3137                    continue;
3138                  }
3139                }
3140                addValueToProperties(_key, key, properties, indent, REMOVED);
3141                addValueToProperties(_key, nextValue, properties, indent, ADDED);
3142              }
3143              isDeeplyEqual = false;
3144            }
3145          } else
3146            properties.push([
3147              ADDED + "  ".repeat(indent) + _key,
3148              "…"
3149            ]), isDeeplyEqual = false;
3150        return isDeeplyEqual;
3151      }
3152      function setCurrentTrackFromLanes(lanes) {
3153        currentTrack = lanes & 63 ? "Blocking" : lanes & 64 ? "Gesture" : lanes & 4194176 ? "Transition" : lanes & 62914560 ? "Suspense" : lanes & 2080374784 ? "Idle" : "Other";
3154      }
3155      function logComponentTrigger(fiber, startTime, endTime, trigger) {
3156        supportsUserTiming && (reusableComponentOptions.start = startTime, reusableComponentOptions.end = endTime, reusableComponentDevToolDetails.color = "warning", reusableComponentDevToolDetails.tooltipText = trigger, reusableComponentDevToolDetails.properties = null, (fiber = fiber._debugTask) ? fiber.run(
3157          performance.measure.bind(
3158            performance,
3159            trigger,
3160            reusableComponentOptions
3161          )
3162        ) : performance.measure(trigger, reusableComponentOptions));
3163      }
3164      function logComponentReappeared(fiber, startTime, endTime) {
3165        logComponentTrigger(fiber, startTime, endTime, "Reconnect");
3166      }
3167      function logComponentRender(fiber, startTime, endTime, wasHydrated, committedLanes) {
3168        var name = getComponentNameFromFiber(fiber);
3169        if (null !== name && supportsUserTiming) {
3170          var alternate = fiber.alternate, selfTime = fiber.actualDuration;
3171          if (null === alternate || alternate.child !== fiber.child)
3172            for (var child = fiber.child; null !== child; child = child.sibling)
3173              selfTime -= child.actualDuration;
3174          wasHydrated = 0.5 > selfTime ? wasHydrated ? "tertiary-light" : "primary-light" : 10 > selfTime ? wasHydrated ? "tertiary" : "primary" : 100 > selfTime ? wasHydrated ? "tertiary-dark" : "primary-dark" : "error";
3175          var props = fiber.memoizedProps;
3176          selfTime = fiber._debugTask;
3177          null !== props && null !== alternate && alternate.memoizedProps !== props ? (child = [resuableChangedPropsEntry], props = addObjectDiffToProperties(
3178            alternate.memoizedProps,
3179            props,
3180            child,
3181            0
3182          ), 1 < child.length && (props && !alreadyWarnedForDeepEquality && 0 === (alternate.lanes & committedLanes) && 100 < fiber.actualDuration ? (alreadyWarnedForDeepEquality = true, 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(
3183            performance.measure.bind(
3184              performance,
3185              "​" + name,
3186              reusableComponentOptions
3187            )
3188          ) : performance.measure(
3189            "​" + name,
3190            reusableComponentOptions
3191          ))) : null != selfTime ? selfTime.run(
3192            console.timeStamp.bind(
3193              console,
3194              name,
3195              startTime,
3196              endTime,
3197              COMPONENTS_TRACK,
3198              void 0,
3199              wasHydrated
3200            )
3201          ) : console.timeStamp(
3202            name,
3203            startTime,
3204            endTime,
3205            COMPONENTS_TRACK,
3206            void 0,
3207            wasHydrated
3208          );
3209        }
3210      }
3211      function logComponentErrored(fiber, startTime, endTime, errors) {
3212        if (supportsUserTiming) {
3213          var name = getComponentNameFromFiber(fiber);
3214          if (null !== name) {
3215            for (var debugTask = null, properties = [], i = 0; i < errors.length; i++) {
3216              var capturedValue = errors[i];
3217              null == debugTask && null !== capturedValue.source && (debugTask = capturedValue.source._debugTask);
3218              capturedValue = capturedValue.value;
3219              properties.push([
3220                "Error",
3221                "object" === typeof capturedValue && null !== capturedValue && "string" === typeof capturedValue.message ? String(capturedValue.message) : String(capturedValue)
3222              ]);
3223            }
3224            null !== fiber.key && addValueToProperties("key", fiber.key, properties, 0, "");
3225            null !== fiber.memoizedProps && addObjectToProperties(fiber.memoizedProps, properties, 0, "");
3226            null == debugTask && (debugTask = fiber._debugTask);
3227            fiber = {
3228              start: startTime,
3229              end: endTime,
3230              detail: {
3231                devtools: {
3232                  color: "error",
3233                  track: COMPONENTS_TRACK,
3234                  tooltipText: 13 === fiber.tag ? "Hydration failed" : "Error boundary caught an error",
3235                  properties
3236                }
3237              }
3238            };
3239            debugTask ? debugTask.run(
3240              performance.measure.bind(performance, "​" + name, fiber)
3241            ) : performance.measure("​" + name, fiber);
3242          }
3243        }
3244      }
3245      function logComponentEffect(fiber, startTime, endTime, selfTime, errors) {
3246        if (null !== errors) {
3247          if (supportsUserTiming) {
3248            var name = getComponentNameFromFiber(fiber);
3249            if (null !== name) {
3250              selfTime = [];
3251              for (var i = 0; i < errors.length; i++) {
3252                var error = errors[i].value;
3253                selfTime.push([
3254                  "Error",
3255                  "object" === typeof error && null !== error && "string" === typeof error.message ? String(error.message) : String(error)
3256                ]);
3257              }
3258              null !== fiber.key && addValueToProperties("key", fiber.key, selfTime, 0, "");
3259              null !== fiber.memoizedProps && addObjectToProperties(fiber.memoizedProps, selfTime, 0, "");
3260              startTime = {
3261                start: startTime,
3262                end: endTime,
3263                detail: {
3264                  devtools: {
3265                    color: "error",
3266                    track: COMPONENTS_TRACK,
3267                    tooltipText: "A lifecycle or effect errored",
3268                    properties: selfTime
3269                  }
3270                }
3271              };
3272              (fiber = fiber._debugTask) ? fiber.run(
3273                performance.measure.bind(
3274                  performance,
3275                  "​" + name,
3276                  startTime
3277                )
3278              ) : performance.measure("​" + name, startTime);
3279            }
3280          }
3281        } else
3282          name = getComponentNameFromFiber(fiber), null !== name && supportsUserTiming && (errors = 1 > selfTime ? "secondary-light" : 100 > selfTime ? "secondary" : 500 > selfTime ? "secondary-dark" : "error", (fiber = fiber._debugTask) ? fiber.run(
3283            console.timeStamp.bind(
3284              console,
3285              name,
3286              startTime,
3287              endTime,
3288              COMPONENTS_TRACK,
3289              void 0,
3290              errors
3291            )
3292          ) : console.timeStamp(
3293            name,
3294            startTime,
3295            endTime,
3296            COMPONENTS_TRACK,
3297            void 0,
3298            errors
3299          ));
3300      }
3301      function logRenderPhase(startTime, endTime, lanes, debugTask) {
3302        if (supportsUserTiming && !(endTime <= startTime)) {
3303          var color = (lanes & 738197653) === lanes ? "tertiary-dark" : "primary-dark";
3304          lanes = (lanes & 536870912) === lanes ? "Prepared" : (lanes & 201326741) === lanes ? "Hydrated" : "Render";
3305          debugTask ? debugTask.run(
3306            console.timeStamp.bind(
3307              console,
3308              lanes,
3309              startTime,
3310              endTime,
3311              currentTrack,
3312              LANES_TRACK_GROUP,
3313              color
3314            )
3315          ) : console.timeStamp(
3316            lanes,
3317            startTime,
3318            endTime,
3319            currentTrack,
3320            LANES_TRACK_GROUP,
3321            color
3322          );
3323        }
3324      }
3325      function logSuspendedRenderPhase(startTime, endTime, lanes, debugTask) {
3326        !supportsUserTiming || endTime <= startTime || (lanes = (lanes & 738197653) === lanes ? "tertiary-dark" : "primary-dark", debugTask ? debugTask.run(
3327          console.timeStamp.bind(
3328            console,
3329            "Prewarm",
3330            startTime,
3331            endTime,
3332            currentTrack,
3333            LANES_TRACK_GROUP,
3334            lanes
3335          )
3336        ) : console.timeStamp(
3337          "Prewarm",
3338          startTime,
3339          endTime,
3340          currentTrack,
3341          LANES_TRACK_GROUP,
3342          lanes
3343        ));
3344      }
3345      function logSuspendedWithDelayPhase(startTime, endTime, lanes, debugTask) {
3346        !supportsUserTiming || endTime <= startTime || (lanes = (lanes & 738197653) === lanes ? "tertiary-dark" : "primary-dark", debugTask ? debugTask.run(
3347          console.timeStamp.bind(
3348            console,
3349            "Suspended",
3350            startTime,
3351            endTime,
3352            currentTrack,
3353            LANES_TRACK_GROUP,
3354            lanes
3355          )
3356        ) : console.timeStamp(
3357          "Suspended",
3358          startTime,
3359          endTime,
3360          currentTrack,
3361          LANES_TRACK_GROUP,
3362          lanes
3363        ));
3364      }
3365      function logRecoveredRenderPhase(startTime, endTime, lanes, recoverableErrors, hydrationFailed, debugTask) {
3366        if (supportsUserTiming && !(endTime <= startTime)) {
3367          lanes = [];
3368          for (var i = 0; i < recoverableErrors.length; i++) {
3369            var error = recoverableErrors[i].value;
3370            lanes.push([
3371              "Recoverable Error",
3372              "object" === typeof error && null !== error && "string" === typeof error.message ? String(error.message) : String(error)
3373            ]);
3374          }
3375          startTime = {
3376            start: startTime,
3377            end: endTime,
3378            detail: {
3379              devtools: {
3380                color: "primary-dark",
3381                track: currentTrack,
3382                trackGroup: LANES_TRACK_GROUP,
3383                tooltipText: hydrationFailed ? "Hydration Failed" : "Recovered after Error",
3384                properties: lanes
3385              }
3386            }
3387          };
3388          debugTask ? debugTask.run(
3389            performance.measure.bind(performance, "Recovered", startTime)
3390          ) : performance.measure("Recovered", startTime);
3391        }
3392      }
3393      function logErroredRenderPhase(startTime, endTime, lanes, debugTask) {
3394        !supportsUserTiming || endTime <= startTime || (debugTask ? debugTask.run(
3395          console.timeStamp.bind(
3396            console,
3397            "Errored",
3398            startTime,
3399            endTime,
3400            currentTrack,
3401            LANES_TRACK_GROUP,
3402            "error"
3403          )
3404        ) : console.timeStamp(
3405          "Errored",
3406          startTime,
3407          endTime,
3408          currentTrack,
3409          LANES_TRACK_GROUP,
3410          "error"
3411        ));
3412      }
3413      function logSuspendedCommitPhase(startTime, endTime, reason, debugTask) {
3414        !supportsUserTiming || endTime <= startTime || (debugTask ? debugTask.run(
3415          console.timeStamp.bind(
3416            console,
3417            reason,
3418            startTime,
3419            endTime,
3420            currentTrack,
3421            LANES_TRACK_GROUP,
3422            "secondary-light"
3423          )
3424        ) : console.timeStamp(
3425          reason,
3426          startTime,
3427          endTime,
3428          currentTrack,
3429          LANES_TRACK_GROUP,
3430          "secondary-light"
3431        ));
3432      }
3433      function logCommitErrored(startTime, endTime, errors, passive, debugTask) {
3434        if (supportsUserTiming && !(endTime <= startTime)) {
3435          for (var properties = [], i = 0; i < errors.length; i++) {
3436            var error = errors[i].value;
3437            properties.push([
3438              "Error",
3439              "object" === typeof error && null !== error && "string" === typeof error.message ? String(error.message) : String(error)
3440            ]);
3441          }
3442          startTime = {
3443            start: startTime,
3444            end: endTime,
3445            detail: {
3446              devtools: {
3447                color: "error",
3448                track: currentTrack,
3449                trackGroup: LANES_TRACK_GROUP,
3450                tooltipText: passive ? "Remaining Effects Errored" : "Commit Errored",
3451                properties
3452              }
3453            }
3454          };
3455          debugTask ? debugTask.run(
3456            performance.measure.bind(performance, "Errored", startTime)
3457          ) : performance.measure("Errored", startTime);
3458        }
3459      }
3460      function logAnimatingPhase(startTime, endTime, debugTask) {
3461        !supportsUserTiming || endTime <= startTime || (debugTask ? debugTask.run(
3462          console.timeStamp.bind(
3463            console,
3464            "Animating",
3465            startTime,
3466            endTime,
3467            currentTrack,
3468            LANES_TRACK_GROUP,
3469            "secondary-dark"
3470          )
3471        ) : console.timeStamp(
3472          "Animating",
3473          startTime,
3474          endTime,
3475          currentTrack,
3476          LANES_TRACK_GROUP,
3477          "secondary-dark"
3478        ));
3479      }
3480      function finishQueueingConcurrentUpdates() {
3481        for (var endIndex = concurrentQueuesIndex, i = concurrentlyUpdatedLanes = concurrentQueuesIndex = 0; i < endIndex; ) {
3482          var fiber = concurrentQueues[i];
3483          concurrentQueues[i++] = null;
3484          var queue = concurrentQueues[i];
3485          concurrentQueues[i++] = null;
3486          var update = concurrentQueues[i];
3487          concurrentQueues[i++] = null;
3488          var lane = concurrentQueues[i];
3489          concurrentQueues[i++] = null;
3490          if (null !== queue && null !== update) {
3491            var pending = queue.pending;
3492            null === pending ? update.next = update : (update.next = pending.next, pending.next = update);
3493            queue.pending = update;
3494          }
3495          0 !== lane && markUpdateLaneFromFiberToRoot(fiber, update, lane);
3496        }
3497      }
3498      function enqueueUpdate$1(fiber, queue, update, lane) {
3499        concurrentQueues[concurrentQueuesIndex++] = fiber;
3500        concurrentQueues[concurrentQueuesIndex++] = queue;
3501        concurrentQueues[concurrentQueuesIndex++] = update;
3502        concurrentQueues[concurrentQueuesIndex++] = lane;
3503        concurrentlyUpdatedLanes |= lane;
3504        fiber.lanes |= lane;
3505        fiber = fiber.alternate;
3506        null !== fiber && (fiber.lanes |= lane);
3507      }
3508      function enqueueConcurrentHookUpdate(fiber, queue, update, lane) {
3509        enqueueUpdate$1(fiber, queue, update, lane);
3510        return getRootForUpdatedFiber(fiber);
3511      }
3512      function enqueueConcurrentRenderForLane(fiber, lane) {
3513        enqueueUpdate$1(fiber, null, null, lane);
3514        return getRootForUpdatedFiber(fiber);
3515      }
3516      function markUpdateLaneFromFiberToRoot(sourceFiber, update, lane) {
3517        sourceFiber.lanes |= lane;
3518        var alternate = sourceFiber.alternate;
3519        null !== alternate && (alternate.lanes |= lane);
3520        for (var isHidden = false, parent = sourceFiber.return; null !== parent; )
3521          parent.childLanes |= lane, alternate = parent.alternate, null !== alternate && (alternate.childLanes |= lane), 22 === parent.tag && (sourceFiber = parent.stateNode, null === sourceFiber || sourceFiber._visibility & OffscreenVisible || (isHidden = true)), sourceFiber = parent, parent = parent.return;
3522        return 3 === sourceFiber.tag ? (parent = sourceFiber.stateNode, isHidden && null !== update && (isHidden = 31 - clz32(lane), sourceFiber = parent.hiddenUpdates, alternate = sourceFiber[isHidden], null === alternate ? sourceFiber[isHidden] = [update] : alternate.push(update), update.lane = lane | 536870912), parent) : null;
3523      }
3524      function getRootForUpdatedFiber(sourceFiber) {
3525        if (nestedUpdateCount > NESTED_UPDATE_LIMIT)
3526          throw nestedPassiveUpdateCount = nestedUpdateCount = 0, rootWithPassiveNestedUpdates = rootWithNestedUpdates = null, Error(
3527            "Maximum update depth exceeded. This can happen when a component repeatedly calls setState inside componentWillUpdate or componentDidUpdate. React limits the number of nested updates to prevent infinite loops."
3528          );
3529        nestedPassiveUpdateCount > NESTED_PASSIVE_UPDATE_LIMIT && (nestedPassiveUpdateCount = 0, rootWithPassiveNestedUpdates = null, console.error(
3530          "Maximum update depth exceeded. This can happen when a component calls setState inside useEffect, but useEffect either doesn't have a dependency array, or one of the dependencies changes on every render."
3531        ));
3532        null === sourceFiber.alternate && 0 !== (sourceFiber.flags & 4098) && warnAboutUpdateOnNotYetMountedFiberInDEV(sourceFiber);
3533        for (var node = sourceFiber, parent = node.return; null !== parent; )
3534          null === node.alternate && 0 !== (node.flags & 4098) && warnAboutUpdateOnNotYetMountedFiberInDEV(sourceFiber), node = parent, parent = node.return;
3535        return 3 === node.tag ? node.stateNode : null;
3536      }
3537      function resolveFunctionForHotReloading(type) {
3538        if (null === resolveFamily) return type;
3539        var family = resolveFamily(type);
3540        return void 0 === family ? type : family.current;
3541      }
3542      function resolveForwardRefForHotReloading(type) {
3543        if (null === resolveFamily) return type;
3544        var family = resolveFamily(type);
3545        return void 0 === family ? null !== type && void 0 !== type && "function" === typeof type.render && (family = resolveFunctionForHotReloading(type.render), type.render !== family) ? (family = { $$typeof: REACT_FORWARD_REF_TYPE, render: family }, void 0 !== type.displayName && (family.displayName = type.displayName), family) : type : family.current;
3546      }
3547      function isCompatibleFamilyForHotReloading(fiber, element) {
3548        if (null === resolveFamily) return false;
3549        var prevType = fiber.elementType;
3550        element = element.type;
3551        var needsCompareFamilies = false, $$typeofNextType = "object" === typeof element && null !== element ? element.$$typeof : null;
3552        switch (fiber.tag) {
3553          case 1:
3554            "function" === typeof element && (needsCompareFamilies = true);
3555            break;
3556          case 0:
3557            "function" === typeof element ? needsCompareFamilies = true : $$typeofNextType === REACT_LAZY_TYPE && (needsCompareFamilies = true);
3558            break;
3559          case 11:
3560            $$typeofNextType === REACT_FORWARD_REF_TYPE ? needsCompareFamilies = true : $$typeofNextType === REACT_LAZY_TYPE && (needsCompareFamilies = true);
3561            break;
3562          case 14:
3563          case 15:
3564            $$typeofNextType === REACT_MEMO_TYPE ? needsCompareFamilies = true : $$typeofNextType === REACT_LAZY_TYPE && (needsCompareFamilies = true);
3565            break;
3566          default:
3567            return false;
3568        }
3569        return needsCompareFamilies && (fiber = resolveFamily(prevType), void 0 !== fiber && fiber === resolveFamily(element)) ? true : false;
3570      }
3571      function markFailedErrorBoundaryForHotReloading(fiber) {
3572        null !== resolveFamily && "function" === typeof WeakSet && (null === failedBoundaries && (failedBoundaries = /* @__PURE__ */ new WeakSet()), failedBoundaries.add(fiber));
3573      }
3574      function scheduleFibersWithFamiliesRecursively(fiber, updatedFamilies, staleFamilies) {
3575        do {
3576          var _fiber = fiber, alternate = _fiber.alternate, child = _fiber.child, sibling = _fiber.sibling, tag = _fiber.tag;
3577          _fiber = _fiber.type;
3578          var candidateType = null;
3579          switch (tag) {
3580            case 0:
3581            case 15:
3582            case 1:
3583              candidateType = _fiber;
3584              break;
3585            case 11:
3586              candidateType = _fiber.render;
3587          }
3588          if (null === resolveFamily)
3589            throw Error("Expected resolveFamily to be set during hot reload.");
3590          var needsRender = false;
3591          _fiber = false;
3592          null !== candidateType && (candidateType = resolveFamily(candidateType), void 0 !== candidateType && (staleFamilies.has(candidateType) ? _fiber = true : updatedFamilies.has(candidateType) && (1 === tag ? _fiber = true : needsRender = true)));
3593          null !== failedBoundaries && (failedBoundaries.has(fiber) || null !== alternate && failedBoundaries.has(alternate)) && (_fiber = true);
3594          _fiber && (fiber._debugNeedsRemount = true);
3595          if (_fiber || needsRender)
3596            alternate = enqueueConcurrentRenderForLane(fiber, 2), null !== alternate && scheduleUpdateOnFiber(alternate, fiber, 2);
3597          null === child || _fiber || scheduleFibersWithFamiliesRecursively(
3598            child,
3599            updatedFamilies,
3600            staleFamilies
3601          );
3602          if (null === sibling) break;
3603          fiber = sibling;
3604        } while (1);
3605      }
3606      function FiberNode(tag, pendingProps, key, mode) {
3607        this.tag = tag;
3608        this.key = key;
3609        this.sibling = this.child = this.return = this.stateNode = this.type = this.elementType = null;
3610        this.index = 0;
3611        this.refCleanup = this.ref = null;
3612        this.pendingProps = pendingProps;
3613        this.dependencies = this.memoizedState = this.updateQueue = this.memoizedProps = null;
3614        this.mode = mode;
3615        this.subtreeFlags = this.flags = 0;
3616        this.deletions = null;
3617        this.childLanes = this.lanes = 0;
3618        this.alternate = null;
3619        this.actualDuration = -0;
3620        this.actualStartTime = -1.1;
3621        this.treeBaseDuration = this.selfBaseDuration = -0;
3622        this._debugTask = this._debugStack = this._debugOwner = this._debugInfo = null;
3623        this._debugNeedsRemount = false;
3624        this._debugHookTypes = null;
3625        hasBadMapPolyfill || "function" !== typeof Object.preventExtensions || Object.preventExtensions(this);
3626      }
3627      function shouldConstruct(Component) {
3628        Component = Component.prototype;
3629        return !(!Component || !Component.isReactComponent);
3630      }
3631      function createWorkInProgress(current2, pendingProps) {
3632        var workInProgress2 = current2.alternate;
3633        null === workInProgress2 ? (workInProgress2 = createFiber(
3634          current2.tag,
3635          pendingProps,
3636          current2.key,
3637          current2.mode
3638        ), workInProgress2.elementType = current2.elementType, workInProgress2.type = current2.type, workInProgress2.stateNode = current2.stateNode, workInProgress2._debugOwner = current2._debugOwner, workInProgress2._debugStack = current2._debugStack, workInProgress2._debugTask = current2._debugTask, workInProgress2._debugHookTypes = current2._debugHookTypes, workInProgress2.alternate = current2, current2.alternate = workInProgress2) : (workInProgress2.pendingProps = pendingProps, workInProgress2.type = current2.type, workInProgress2.flags = 0, workInProgress2.subtreeFlags = 0, workInProgress2.deletions = null, workInProgress2.actualDuration = -0, workInProgress2.actualStartTime = -1.1);
3639        workInProgress2.flags = current2.flags & 65011712;
3640        workInProgress2.childLanes = current2.childLanes;
3641        workInProgress2.lanes = current2.lanes;
3642        workInProgress2.child = current2.child;
3643        workInProgress2.memoizedProps = current2.memoizedProps;
3644        workInProgress2.memoizedState = current2.memoizedState;
3645        workInProgress2.updateQueue = current2.updateQueue;
3646        pendingProps = current2.dependencies;
3647        workInProgress2.dependencies = null === pendingProps ? null : {
3648          lanes: pendingProps.lanes,
3649          firstContext: pendingProps.firstContext,
3650          _debugThenableState: pendingProps._debugThenableState
3651        };
3652        workInProgress2.sibling = current2.sibling;
3653        workInProgress2.index = current2.index;
3654        workInProgress2.ref = current2.ref;
3655        workInProgress2.refCleanup = current2.refCleanup;
3656        workInProgress2.selfBaseDuration = current2.selfBaseDuration;
3657        workInProgress2.treeBaseDuration = current2.treeBaseDuration;
3658        workInProgress2._debugInfo = current2._debugInfo;
3659        workInProgress2._debugNeedsRemount = current2._debugNeedsRemount;
3660        switch (workInProgress2.tag) {
3661          case 0:
3662          case 15:
3663            workInProgress2.type = resolveFunctionForHotReloading(current2.type);
3664            break;
3665          case 1:
3666            workInProgress2.type = resolveFunctionForHotReloading(current2.type);
3667            break;
3668          case 11:
3669            workInProgress2.type = resolveForwardRefForHotReloading(current2.type);
3670        }
3671        return workInProgress2;
3672      }
3673      function resetWorkInProgress(workInProgress2, renderLanes2) {
3674        workInProgress2.flags &= 65011714;
3675        var current2 = workInProgress2.alternate;
3676        null === current2 ? (workInProgress2.childLanes = 0, workInProgress2.lanes = renderLanes2, workInProgress2.child = null, workInProgress2.subtreeFlags = 0, workInProgress2.memoizedProps = null, workInProgress2.memoizedState = null, workInProgress2.updateQueue = null, workInProgress2.dependencies = null, workInProgress2.stateNode = null, workInProgress2.selfBaseDuration = 0, workInProgress2.treeBaseDuration = 0) : (workInProgress2.childLanes = current2.childLanes, workInProgress2.lanes = current2.lanes, workInProgress2.child = current2.child, workInProgress2.subtreeFlags = 0, workInProgress2.deletions = null, workInProgress2.memoizedProps = current2.memoizedProps, workInProgress2.memoizedState = current2.memoizedState, workInProgress2.updateQueue = current2.updateQueue, workInProgress2.type = current2.type, renderLanes2 = current2.dependencies, workInProgress2.dependencies = null === renderLanes2 ? null : {
3677          lanes: renderLanes2.lanes,
3678          firstContext: renderLanes2.firstContext,
3679          _debugThenableState: renderLanes2._debugThenableState
3680        }, workInProgress2.selfBaseDuration = current2.selfBaseDuration, workInProgress2.treeBaseDuration = current2.treeBaseDuration);
3681        return workInProgress2;
3682      }
3683      function createFiberFromTypeAndProps(type, key, pendingProps, owner, mode, lanes) {
3684        var fiberTag = 0, resolvedType = type;
3685        if ("function" === typeof type)
3686          shouldConstruct(type) && (fiberTag = 1), resolvedType = resolveFunctionForHotReloading(resolvedType);
3687        else if ("string" === typeof type)
3688          fiberTag = getHostContext(), fiberTag = isHostHoistableType(type, pendingProps, fiberTag) ? 26 : "html" === type || "head" === type || "body" === type ? 27 : 5;
3689        else
3690          a: switch (type) {
3691            case REACT_ACTIVITY_TYPE:
3692              return key = createFiber(31, pendingProps, key, mode), key.elementType = REACT_ACTIVITY_TYPE, key.lanes = lanes, key;
3693            case REACT_FRAGMENT_TYPE:
3694              return createFiberFromFragment(
3695                pendingProps.children,
3696                mode,
3697                lanes,
3698                key
3699              );
3700            case REACT_STRICT_MODE_TYPE:
3701              fiberTag = 8;
3702              mode |= StrictLegacyMode;
3703              mode |= StrictEffectsMode;
3704              break;
3705            case REACT_PROFILER_TYPE:
3706              return type = pendingProps, owner = mode, "string" !== typeof type.id && console.error(
3707                'Profiler must specify an "id" of type `string` as a prop. Received the type `%s` instead.',
3708                typeof type.id
3709              ), key = createFiber(12, type, key, owner | ProfileMode), key.elementType = REACT_PROFILER_TYPE, key.lanes = lanes, key.stateNode = { effectDuration: 0, passiveEffectDuration: 0 }, key;
3710            case REACT_SUSPENSE_TYPE:
3711              return key = createFiber(13, pendingProps, key, mode), key.elementType = REACT_SUSPENSE_TYPE, key.lanes = lanes, key;
3712            case REACT_SUSPENSE_LIST_TYPE:
3713              return key = createFiber(19, pendingProps, key, mode), key.elementType = REACT_SUSPENSE_LIST_TYPE, key.lanes = lanes, key;
3714            default:
3715              if ("object" === typeof type && null !== type)
3716                switch (type.$$typeof) {
3717                  case REACT_CONTEXT_TYPE:
3718                    fiberTag = 10;
3719                    break a;
3720                  case REACT_CONSUMER_TYPE:
3721                    fiberTag = 9;
3722                    break a;
3723                  case REACT_FORWARD_REF_TYPE:
3724                    fiberTag = 11;
3725                    resolvedType = resolveForwardRefForHotReloading(resolvedType);
3726                    break a;
3727                  case REACT_MEMO_TYPE:
3728                    fiberTag = 14;
3729                    break a;
3730                  case REACT_LAZY_TYPE:
3731                    fiberTag = 16;
3732                    resolvedType = null;
3733                    break a;
3734                }
3735              resolvedType = "";
3736              if (void 0 === type || "object" === typeof type && null !== type && 0 === Object.keys(type).length)
3737                resolvedType += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.";
3738              null === type ? pendingProps = "null" : isArrayImpl(type) ? pendingProps = "array" : void 0 !== type && type.$$typeof === REACT_ELEMENT_TYPE ? (pendingProps = "<" + (getComponentNameFromType(type.type) || "Unknown") + " />", resolvedType = " Did you accidentally export a JSX literal instead of a component?") : pendingProps = typeof type;
3739              (fiberTag = owner ? getComponentNameFromOwner(owner) : null) && (resolvedType += "\n\nCheck the render method of `" + fiberTag + "`.");
3740              fiberTag = 29;
3741              pendingProps = Error(
3742                "Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: " + (pendingProps + "." + resolvedType)
3743              );
3744              resolvedType = null;
3745          }
3746        key = createFiber(fiberTag, pendingProps, key, mode);
3747        key.elementType = type;
3748        key.type = resolvedType;
3749        key.lanes = lanes;
3750        key._debugOwner = owner;
3751        return key;
3752      }
3753      function createFiberFromElement(element, mode, lanes) {
3754        mode = createFiberFromTypeAndProps(
3755          element.type,
3756          element.key,
3757          element.props,
3758          element._owner,
3759          mode,
3760          lanes
3761        );
3762        mode._debugOwner = element._owner;
3763        mode._debugStack = element._debugStack;
3764        mode._debugTask = element._debugTask;
3765        return mode;
3766      }
3767      function createFiberFromFragment(elements, mode, lanes, key) {
3768        elements = createFiber(7, elements, key, mode);
3769        elements.lanes = lanes;
3770        return elements;
3771      }
3772      function createFiberFromText(content, mode, lanes) {
3773        content = createFiber(6, content, null, mode);
3774        content.lanes = lanes;
3775        return content;
3776      }
3777      function createFiberFromDehydratedFragment(dehydratedNode) {
3778        var fiber = createFiber(18, null, null, NoMode);
3779        fiber.stateNode = dehydratedNode;
3780        return fiber;
3781      }
3782      function createFiberFromPortal(portal, mode, lanes) {
3783        mode = createFiber(
3784          4,
3785          null !== portal.children ? portal.children : [],
3786          portal.key,
3787          mode
3788        );
3789        mode.lanes = lanes;
3790        mode.stateNode = {
3791          containerInfo: portal.containerInfo,
3792          pendingChildren: null,
3793          implementation: portal.implementation
3794        };
3795        return mode;
3796      }
3797      function createCapturedValueAtFiber(value, source) {
3798        if ("object" === typeof value && null !== value) {
3799          var existing = CapturedStacks.get(value);
3800          if (void 0 !== existing) return existing;
3801          source = {
3802            value,
3803            source,
3804            stack: getStackByFiberInDevAndProd(source)
3805          };
3806          CapturedStacks.set(value, source);
3807          return source;
3808        }
3809        return {
3810          value,
3811          source,
3812          stack: getStackByFiberInDevAndProd(source)
3813        };
3814      }
3815      function pushTreeFork(workInProgress2, totalChildren) {
3816        warnIfNotHydrating();
3817        forkStack[forkStackIndex++] = treeForkCount;
3818        forkStack[forkStackIndex++] = treeForkProvider;
3819        treeForkProvider = workInProgress2;
3820        treeForkCount = totalChildren;
3821      }
3822      function pushTreeId(workInProgress2, totalChildren, index) {
3823        warnIfNotHydrating();
3824        idStack[idStackIndex++] = treeContextId;
3825        idStack[idStackIndex++] = treeContextOverflow;
3826        idStack[idStackIndex++] = treeContextProvider;
3827        treeContextProvider = workInProgress2;
3828        var baseIdWithLeadingBit = treeContextId;
3829        workInProgress2 = treeContextOverflow;
3830        var baseLength = 32 - clz32(baseIdWithLeadingBit) - 1;
3831        baseIdWithLeadingBit &= ~(1 << baseLength);
3832        index += 1;
3833        var length = 32 - clz32(totalChildren) + baseLength;
3834        if (30 < length) {
3835          var numberOfOverflowBits = baseLength - baseLength % 5;
3836          length = (baseIdWithLeadingBit & (1 << numberOfOverflowBits) - 1).toString(32);
3837          baseIdWithLeadingBit >>= numberOfOverflowBits;
3838          baseLength -= numberOfOverflowBits;
3839          treeContextId = 1 << 32 - clz32(totalChildren) + baseLength | index << baseLength | baseIdWithLeadingBit;
3840          treeContextOverflow = length + workInProgress2;
3841        } else
3842          treeContextId = 1 << length | index << baseLength | baseIdWithLeadingBit, treeContextOverflow = workInProgress2;
3843      }
3844      function pushMaterializedTreeId(workInProgress2) {
3845        warnIfNotHydrating();
3846        null !== workInProgress2.return && (pushTreeFork(workInProgress2, 1), pushTreeId(workInProgress2, 1, 0));
3847      }
3848      function popTreeContext(workInProgress2) {
3849        for (; workInProgress2 === treeForkProvider; )
3850          treeForkProvider = forkStack[--forkStackIndex], forkStack[forkStackIndex] = null, treeForkCount = forkStack[--forkStackIndex], forkStack[forkStackIndex] = null;
3851        for (; workInProgress2 === treeContextProvider; )
3852          treeContextProvider = idStack[--idStackIndex], idStack[idStackIndex] = null, treeContextOverflow = idStack[--idStackIndex], idStack[idStackIndex] = null, treeContextId = idStack[--idStackIndex], idStack[idStackIndex] = null;
3853      }
3854      function getSuspendedTreeContext() {
3855        warnIfNotHydrating();
3856        return null !== treeContextProvider ? { id: treeContextId, overflow: treeContextOverflow } : null;
3857      }
3858      function restoreSuspendedTreeContext(workInProgress2, suspendedContext) {
3859        warnIfNotHydrating();
3860        idStack[idStackIndex++] = treeContextId;
3861        idStack[idStackIndex++] = treeContextOverflow;
3862        idStack[idStackIndex++] = treeContextProvider;
3863        treeContextId = suspendedContext.id;
3864        treeContextOverflow = suspendedContext.overflow;
3865        treeContextProvider = workInProgress2;
3866      }
3867      function warnIfNotHydrating() {
3868        isHydrating || console.error(
3869          "Expected to be hydrating. This is a bug in React. Please file an issue."
3870        );
3871      }
3872      function buildHydrationDiffNode(fiber, distanceFromLeaf) {
3873        if (null === fiber.return) {
3874          if (null === hydrationDiffRootDEV)
3875            hydrationDiffRootDEV = {
3876              fiber,
3877              children: [],
3878              serverProps: void 0,
3879              serverTail: [],
3880              distanceFromLeaf
3881            };
3882          else {
3883            if (hydrationDiffRootDEV.fiber !== fiber)
3884              throw Error(
3885                "Saw multiple hydration diff roots in a pass. This is a bug in React."
3886              );
3887            hydrationDiffRootDEV.distanceFromLeaf > distanceFromLeaf && (hydrationDiffRootDEV.distanceFromLeaf = distanceFromLeaf);
3888          }
3889          return hydrationDiffRootDEV;
3890        }
3891        var siblings = buildHydrationDiffNode(
3892          fiber.return,
3893          distanceFromLeaf + 1
3894        ).children;
3895        if (0 < siblings.length && siblings[siblings.length - 1].fiber === fiber)
3896          return siblings = siblings[siblings.length - 1], siblings.distanceFromLeaf > distanceFromLeaf && (siblings.distanceFromLeaf = distanceFromLeaf), siblings;
3897        distanceFromLeaf = {
3898          fiber,
3899          children: [],
3900          serverProps: void 0,
3901          serverTail: [],
3902          distanceFromLeaf
3903        };
3904        siblings.push(distanceFromLeaf);
3905        return distanceFromLeaf;
3906      }
3907      function warnIfHydrating() {
3908        isHydrating && console.error(
3909          "We should not be hydrating here. This is a bug in React. Please file a bug."
3910        );
3911      }
3912      function warnNonHydratedInstance(fiber, rejectedCandidate) {
3913        didSuspendOrErrorDEV || (fiber = buildHydrationDiffNode(fiber, 0), fiber.serverProps = null, null !== rejectedCandidate && (rejectedCandidate = describeHydratableInstanceForDevWarnings(rejectedCandidate), fiber.serverTail.push(rejectedCandidate)));
3914      }
3915      function throwOnHydrationMismatch(fiber) {
3916        var fromText = 1 < arguments.length && void 0 !== arguments[1] ? arguments[1] : false, diff = "", diffRoot = hydrationDiffRootDEV;
3917        null !== diffRoot && (hydrationDiffRootDEV = null, diff = describeDiff(diffRoot));
3918        queueHydrationError(
3919          createCapturedValueAtFiber(
3920            Error(
3921              "Hydration failed because the server rendered " + (fromText ? "text" : "HTML") + " didn't match the client. As a result this tree will be regenerated on the client. This can happen if a SSR-ed Client Component used:\n\n- A server/client branch `if (typeof window !== 'undefined')`.\n- Variable input such as `Date.now()` or `Math.random()` which changes each time it's called.\n- Date formatting in a user's locale which doesn't match the server.\n- External changing data without sending a snapshot of it along with the HTML.\n- Invalid HTML tag nesting.\n\nIt can also happen if the client has a browser extension installed which messes with the HTML before React loaded.\n\nhttps://react.dev/link/hydration-mismatch" + diff
3922            ),
3923            fiber
3924          )
3925        );
3926        throw HydrationMismatchException;
3927      }
3928      function prepareToHydrateHostInstance(fiber) {
3929        var didHydrate = fiber.stateNode;
3930        var type = fiber.type, props = fiber.memoizedProps;
3931        didHydrate[internalInstanceKey] = fiber;
3932        didHydrate[internalPropsKey] = props;
3933        validatePropertiesInDevelopment(type, props);
3934        switch (type) {
3935          case "dialog":
3936            listenToNonDelegatedEvent("cancel", didHydrate);
3937            listenToNonDelegatedEvent("close", didHydrate);
3938            break;
3939          case "iframe":
3940          case "object":
3941          case "embed":
3942            listenToNonDelegatedEvent("load", didHydrate);
3943            break;
3944          case "video":
3945          case "audio":
3946            for (type = 0; type < mediaEventTypes.length; type++)
3947              listenToNonDelegatedEvent(mediaEventTypes[type], didHydrate);
3948            break;
3949          case "source":
3950            listenToNonDelegatedEvent("error", didHydrate);
3951            break;
3952          case "img":
3953          case "image":
3954          case "link":
3955            listenToNonDelegatedEvent("error", didHydrate);
3956            listenToNonDelegatedEvent("load", didHydrate);
3957            break;
3958          case "details":
3959            listenToNonDelegatedEvent("toggle", didHydrate);
3960            break;
3961          case "input":
3962            checkControlledValueProps("input", props);
3963            listenToNonDelegatedEvent("invalid", didHydrate);
3964            validateInputProps(didHydrate, props);
3965            initInput(
3966              didHydrate,
3967              props.value,
3968              props.defaultValue,
3969              props.checked,
3970              props.defaultChecked,
3971              props.type,
3972              props.name,
3973              true
3974            );
3975            break;
3976          case "option":
3977            validateOptionProps(didHydrate, props);
3978            break;
3979          case "select":
3980            checkControlledValueProps("select", props);
3981            listenToNonDelegatedEvent("invalid", didHydrate);
3982            validateSelectProps(didHydrate, props);
3983            break;
3984          case "textarea":
3985            checkControlledValueProps("textarea", props), listenToNonDelegatedEvent("invalid", didHydrate), validateTextareaProps(didHydrate, props), initTextarea(
3986              didHydrate,
3987              props.value,
3988              props.defaultValue,
3989              props.children
3990            );
3991        }
3992        type = props.children;
3993        "string" !== typeof type && "number" !== typeof type && "bigint" !== typeof type || didHydrate.textContent === "" + type || true === props.suppressHydrationWarning || checkForUnmatchedText(didHydrate.textContent, type) ? (null != props.popover && (listenToNonDelegatedEvent("beforetoggle", didHydrate), listenToNonDelegatedEvent("toggle", didHydrate)), null != props.onScroll && listenToNonDelegatedEvent("scroll", didHydrate), null != props.onScrollEnd && listenToNonDelegatedEvent("scrollend", didHydrate), null != props.onClick && (didHydrate.onclick = noop$1), didHydrate = true) : didHydrate = false;
3994        didHydrate || throwOnHydrationMismatch(fiber, true);
3995      }
3996      function popToNextHostParent(fiber) {
3997        for (hydrationParentFiber = fiber.return; hydrationParentFiber; )
3998          switch (hydrationParentFiber.tag) {
3999            case 5:
4000            case 31:
4001            case 13:
4002              rootOrSingletonContext = false;
4003              return;
4004            case 27:
4005            case 3:
4006              rootOrSingletonContext = true;
4007              return;
4008            default:
4009              hydrationParentFiber = hydrationParentFiber.return;
4010          }
4011      }
4012      function popHydrationState(fiber) {
4013        if (fiber !== hydrationParentFiber) return false;
4014        if (!isHydrating)
4015          return popToNextHostParent(fiber), isHydrating = true, false;
4016        var tag = fiber.tag, JSCompiler_temp;
4017        if (JSCompiler_temp = 3 !== tag && 27 !== tag) {
4018          if (JSCompiler_temp = 5 === tag)
4019            JSCompiler_temp = fiber.type, JSCompiler_temp = !("form" !== JSCompiler_temp && "button" !== JSCompiler_temp) || shouldSetTextContent(fiber.type, fiber.memoizedProps);
4020          JSCompiler_temp = !JSCompiler_temp;
4021        }
4022        if (JSCompiler_temp && nextHydratableInstance) {
4023          for (JSCompiler_temp = nextHydratableInstance; JSCompiler_temp; ) {
4024            var diffNode = buildHydrationDiffNode(fiber, 0), description = describeHydratableInstanceForDevWarnings(JSCompiler_temp);
4025            diffNode.serverTail.push(description);
4026            JSCompiler_temp = "Suspense" === description.type ? getNextHydratableInstanceAfterHydrationBoundary(JSCompiler_temp) : getNextHydratable(JSCompiler_temp.nextSibling);
4027          }
4028          throwOnHydrationMismatch(fiber);
4029        }
4030        popToNextHostParent(fiber);
4031        if (13 === tag) {
4032          fiber = fiber.memoizedState;
4033          fiber = null !== fiber ? fiber.dehydrated : null;
4034          if (!fiber)
4035            throw Error(
4036              "Expected to have a hydrated suspense instance. This error is likely caused by a bug in React. Please file an issue."
4037            );
4038          nextHydratableInstance = getNextHydratableInstanceAfterHydrationBoundary(fiber);
4039        } else if (31 === tag) {
4040          fiber = fiber.memoizedState;
4041          fiber = null !== fiber ? fiber.dehydrated : null;
4042          if (!fiber)
4043            throw Error(
4044              "Expected to have a hydrated suspense instance. This error is likely caused by a bug in React. Please file an issue."
4045            );
4046          nextHydratableInstance = getNextHydratableInstanceAfterHydrationBoundary(fiber);
4047        } else
4048          27 === tag ? (tag = nextHydratableInstance, isSingletonScope(fiber.type) ? (fiber = previousHydratableOnEnteringScopedSingleton, previousHydratableOnEnteringScopedSingleton = null, nextHydratableInstance = fiber) : nextHydratableInstance = tag) : nextHydratableInstance = hydrationParentFiber ? getNextHydratable(fiber.stateNode.nextSibling) : null;
4049        return true;
4050      }
4051      function resetHydrationState() {
4052        nextHydratableInstance = hydrationParentFiber = null;
4053        didSuspendOrErrorDEV = isHydrating = false;
4054      }
4055      function upgradeHydrationErrorsToRecoverable() {
4056        var queuedErrors = hydrationErrors;
4057        null !== queuedErrors && (null === workInProgressRootRecoverableErrors ? workInProgressRootRecoverableErrors = queuedErrors : workInProgressRootRecoverableErrors.push.apply(
4058          workInProgressRootRecoverableErrors,
4059          queuedErrors
4060        ), hydrationErrors = null);
4061        return queuedErrors;
4062      }
4063      function queueHydrationError(error) {
4064        null === hydrationErrors ? hydrationErrors = [error] : hydrationErrors.push(error);
4065      }
4066      function emitPendingHydrationWarnings() {
4067        var diffRoot = hydrationDiffRootDEV;
4068        if (null !== diffRoot) {
4069          hydrationDiffRootDEV = null;
4070          for (var diff = describeDiff(diffRoot); 0 < diffRoot.children.length; )
4071            diffRoot = diffRoot.children[0];
4072          runWithFiberInDEV(diffRoot.fiber, function() {
4073            console.error(
4074              "A tree hydrated but some attributes of the server rendered HTML didn't match the client properties. This won't be patched up. This can happen if a SSR-ed Client Component used:\n\n- A server/client branch `if (typeof window !== 'undefined')`.\n- Variable input such as `Date.now()` or `Math.random()` which changes each time it's called.\n- Date formatting in a user's locale which doesn't match the server.\n- External changing data without sending a snapshot of it along with the HTML.\n- Invalid HTML tag nesting.\n\nIt can also happen if the client has a browser extension installed which messes with the HTML before React loaded.\n\n%s%s",
4075              "https://react.dev/link/hydration-mismatch",
4076              diff
4077            );
4078          });
4079        }
4080      }
4081      function resetContextDependencies() {
4082        lastContextDependency = currentlyRenderingFiber$1 = null;
4083        isDisallowedContextReadInDEV = false;
4084      }
4085      function pushProvider(providerFiber, context, nextValue) {
4086        push(valueCursor, context._currentValue, providerFiber);
4087        context._currentValue = nextValue;
4088        push(rendererCursorDEV, context._currentRenderer, providerFiber);
4089        void 0 !== context._currentRenderer && null !== context._currentRenderer && context._currentRenderer !== rendererSigil && console.error(
4090          "Detected multiple renderers concurrently rendering the same context provider. This is currently unsupported."
4091        );
4092        context._currentRenderer = rendererSigil;
4093      }
4094      function popProvider(context, providerFiber) {
4095        context._currentValue = valueCursor.current;
4096        var currentRenderer = rendererCursorDEV.current;
4097        pop(rendererCursorDEV, providerFiber);
4098        context._currentRenderer = currentRenderer;
4099        pop(valueCursor, providerFiber);
4100      }
4101      function scheduleContextWorkOnParentPath(parent, renderLanes2, propagationRoot) {
4102        for (; null !== parent; ) {
4103          var alternate = parent.alternate;
4104          (parent.childLanes & renderLanes2) !== renderLanes2 ? (parent.childLanes |= renderLanes2, null !== alternate && (alternate.childLanes |= renderLanes2)) : null !== alternate && (alternate.childLanes & renderLanes2) !== renderLanes2 && (alternate.childLanes |= renderLanes2);
4105          if (parent === propagationRoot) break;
4106          parent = parent.return;
4107        }
4108        parent !== propagationRoot && console.error(
4109          "Expected to find the propagation root when scheduling context work. This error is likely caused by a bug in React. Please file an issue."
4110        );
4111      }
4112      function propagateContextChanges(workInProgress2, contexts, renderLanes2, forcePropagateEntireTree) {
4113        var fiber = workInProgress2.child;
4114        null !== fiber && (fiber.return = workInProgress2);
4115        for (; null !== fiber; ) {
4116          var list = fiber.dependencies;
4117          if (null !== list) {
4118            var nextFiber = fiber.child;
4119            list = list.firstContext;
4120            a: for (; null !== list; ) {
4121              var dependency = list;
4122              list = fiber;
4123              for (var i = 0; i < contexts.length; i++)
4124                if (dependency.context === contexts[i]) {
4125                  list.lanes |= renderLanes2;
4126                  dependency = list.alternate;
4127                  null !== dependency && (dependency.lanes |= renderLanes2);
4128                  scheduleContextWorkOnParentPath(
4129                    list.return,
4130                    renderLanes2,
4131                    workInProgress2
4132                  );
4133                  forcePropagateEntireTree || (nextFiber = null);
4134                  break a;
4135                }
4136              list = dependency.next;
4137            }
4138          } else if (18 === fiber.tag) {
4139            nextFiber = fiber.return;
4140            if (null === nextFiber)
4141              throw Error(
4142                "We just came from a parent so we must have had a parent. This is a bug in React."
4143              );
4144            nextFiber.lanes |= renderLanes2;
4145            list = nextFiber.alternate;
4146            null !== list && (list.lanes |= renderLanes2);
4147            scheduleContextWorkOnParentPath(
4148              nextFiber,
4149              renderLanes2,
4150              workInProgress2
4151            );
4152            nextFiber = null;
4153          } else nextFiber = fiber.child;
4154          if (null !== nextFiber) nextFiber.return = fiber;
4155          else
4156            for (nextFiber = fiber; null !== nextFiber; ) {
4157              if (nextFiber === workInProgress2) {
4158                nextFiber = null;
4159                break;
4160              }
4161              fiber = nextFiber.sibling;
4162              if (null !== fiber) {
4163                fiber.return = nextFiber.return;
4164                nextFiber = fiber;
4165                break;
4166              }
4167              nextFiber = nextFiber.return;
4168            }
4169          fiber = nextFiber;
4170        }
4171      }
4172      function propagateParentContextChanges(current2, workInProgress2, renderLanes2, forcePropagateEntireTree) {
4173        current2 = null;
4174        for (var parent = workInProgress2, isInsidePropagationBailout = false; null !== parent; ) {
4175          if (!isInsidePropagationBailout) {
4176            if (0 !== (parent.flags & 524288)) isInsidePropagationBailout = true;
4177            else if (0 !== (parent.flags & 262144)) break;
4178          }
4179          if (10 === parent.tag) {
4180            var currentParent = parent.alternate;
4181            if (null === currentParent)
4182              throw Error("Should have a current fiber. This is a bug in React.");
4183            currentParent = currentParent.memoizedProps;
4184            if (null !== currentParent) {
4185              var context = parent.type;
4186              objectIs(parent.pendingProps.value, currentParent.value) || (null !== current2 ? current2.push(context) : current2 = [context]);
4187            }
4188          } else if (parent === hostTransitionProviderCursor.current) {
4189            currentParent = parent.alternate;
4190            if (null === currentParent)
4191              throw Error("Should have a current fiber. This is a bug in React.");
4192            currentParent.memoizedState.memoizedState !== parent.memoizedState.memoizedState && (null !== current2 ? current2.push(HostTransitionContext) : current2 = [HostTransitionContext]);
4193          }
4194          parent = parent.return;
4195        }
4196        null !== current2 && propagateContextChanges(
4197          workInProgress2,
4198          current2,
4199          renderLanes2,
4200          forcePropagateEntireTree
4201        );
4202        workInProgress2.flags |= 262144;
4203      }
4204      function checkIfContextChanged(currentDependencies) {
4205        for (currentDependencies = currentDependencies.firstContext; null !== currentDependencies; ) {
4206          if (!objectIs(
4207            currentDependencies.context._currentValue,
4208            currentDependencies.memoizedValue
4209          ))
4210            return true;
4211          currentDependencies = currentDependencies.next;
4212        }
4213        return false;
4214      }
4215      function prepareToReadContext(workInProgress2) {
4216        currentlyRenderingFiber$1 = workInProgress2;
4217        lastContextDependency = null;
4218        workInProgress2 = workInProgress2.dependencies;
4219        null !== workInProgress2 && (workInProgress2.firstContext = null);
4220      }
4221      function readContext(context) {
4222        isDisallowedContextReadInDEV && console.error(
4223          "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()."
4224        );
4225        return readContextForConsumer(currentlyRenderingFiber$1, context);
4226      }
4227      function readContextDuringReconciliation(consumer, context) {
4228        null === currentlyRenderingFiber$1 && prepareToReadContext(consumer);
4229        return readContextForConsumer(consumer, context);
4230      }
4231      function readContextForConsumer(consumer, context) {
4232        var value = context._currentValue;
4233        context = { context, memoizedValue: value, next: null };
4234        if (null === lastContextDependency) {
4235          if (null === consumer)
4236            throw Error(
4237              "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()."
4238            );
4239          lastContextDependency = context;
4240          consumer.dependencies = {
4241            lanes: 0,
4242            firstContext: context,
4243            _debugThenableState: null
4244          };
4245          consumer.flags |= 524288;
4246        } else lastContextDependency = lastContextDependency.next = context;
4247        return value;
4248      }
4249      function createCache() {
4250        return {
4251          controller: new AbortControllerLocal(),
4252          data: /* @__PURE__ */ new Map(),
4253          refCount: 0
4254        };
4255      }
4256      function retainCache(cache) {
4257        cache.controller.signal.aborted && console.warn(
4258          "A cache instance was retained after it was already freed. This likely indicates a bug in React."
4259        );
4260        cache.refCount++;
4261      }
4262      function releaseCache(cache) {
4263        cache.refCount--;
4264        0 > cache.refCount && console.warn(
4265          "A cache instance was released after it was already freed. This likely indicates a bug in React."
4266        );
4267        0 === cache.refCount && scheduleCallback$2(NormalPriority, function() {
4268          cache.controller.abort();
4269        });
4270      }
4271      function startUpdateTimerByLane(lane, method, fiber) {
4272        if (0 !== (lane & 127))
4273          0 > blockingUpdateTime && (blockingUpdateTime = now(), blockingUpdateTask = createTask(method), blockingUpdateMethodName = method, null != fiber && (blockingUpdateComponentName = getComponentNameFromFiber(fiber)), (executionContext & (RenderContext | CommitContext)) !== NoContext && (componentEffectSpawnedUpdate = true, blockingUpdateType = SPAWNED_UPDATE), lane = resolveEventTimeStamp(), method = resolveEventType(), lane !== blockingEventRepeatTime || method !== blockingEventType ? blockingEventRepeatTime = -1.1 : null !== method && (blockingUpdateType = SPAWNED_UPDATE), blockingEventTime = lane, blockingEventType = method);
4274        else if (0 !== (lane & 4194048) && 0 > transitionUpdateTime && (transitionUpdateTime = now(), transitionUpdateTask = createTask(method), transitionUpdateMethodName = method, null != fiber && (transitionUpdateComponentName = getComponentNameFromFiber(fiber)), 0 > transitionStartTime)) {
4275          lane = resolveEventTimeStamp();
4276          method = resolveEventType();
4277          if (lane !== transitionEventRepeatTime || method !== transitionEventType)
4278            transitionEventRepeatTime = -1.1;
4279          transitionEventTime = lane;
4280          transitionEventType = method;
4281        }
4282      }
4283      function startHostActionTimer(fiber) {
4284        if (0 > blockingUpdateTime) {
4285          blockingUpdateTime = now();
4286          blockingUpdateTask = null != fiber._debugTask ? fiber._debugTask : null;
4287          (executionContext & (RenderContext | CommitContext)) !== NoContext && (blockingUpdateType = SPAWNED_UPDATE);
4288          var newEventTime = resolveEventTimeStamp(), newEventType = resolveEventType();
4289          newEventTime !== blockingEventRepeatTime || newEventType !== blockingEventType ? blockingEventRepeatTime = -1.1 : null !== newEventType && (blockingUpdateType = SPAWNED_UPDATE);
4290          blockingEventTime = newEventTime;
4291          blockingEventType = newEventType;
4292        }
4293        if (0 > transitionUpdateTime && (transitionUpdateTime = now(), transitionUpdateTask = null != fiber._debugTask ? fiber._debugTask : null, 0 > transitionStartTime)) {
4294          fiber = resolveEventTimeStamp();
4295          newEventTime = resolveEventType();
4296          if (fiber !== transitionEventRepeatTime || newEventTime !== transitionEventType)
4297            transitionEventRepeatTime = -1.1;
4298          transitionEventTime = fiber;
4299          transitionEventType = newEventTime;
4300        }
4301      }
4302      function pushNestedEffectDurations() {
4303        var prevEffectDuration = profilerEffectDuration;
4304        profilerEffectDuration = 0;
4305        return prevEffectDuration;
4306      }
4307      function popNestedEffectDurations(prevEffectDuration) {
4308        var elapsedTime = profilerEffectDuration;
4309        profilerEffectDuration = prevEffectDuration;
4310        return elapsedTime;
4311      }
4312      function bubbleNestedEffectDurations(prevEffectDuration) {
4313        var elapsedTime = profilerEffectDuration;
4314        profilerEffectDuration += prevEffectDuration;
4315        return elapsedTime;
4316      }
4317      function resetComponentEffectTimers() {
4318        componentEffectEndTime = componentEffectStartTime = -1.1;
4319      }
4320      function pushComponentEffectStart() {
4321        var prevEffectStart = componentEffectStartTime;
4322        componentEffectStartTime = -1.1;
4323        return prevEffectStart;
4324      }
4325      function popComponentEffectStart(prevEffectStart) {
4326        0 <= prevEffectStart && (componentEffectStartTime = prevEffectStart);
4327      }
4328      function pushComponentEffectDuration() {
4329        var prevEffectDuration = componentEffectDuration;
4330        componentEffectDuration = -0;
4331        return prevEffectDuration;
4332      }
4333      function popComponentEffectDuration(prevEffectDuration) {
4334        0 <= prevEffectDuration && (componentEffectDuration = prevEffectDuration);
4335      }
4336      function pushComponentEffectErrors() {
4337        var prevErrors = componentEffectErrors;
4338        componentEffectErrors = null;
4339        return prevErrors;
4340      }
4341      function pushComponentEffectDidSpawnUpdate() {
4342        var prev = componentEffectSpawnedUpdate;
4343        componentEffectSpawnedUpdate = false;
4344        return prev;
4345      }
4346      function startProfilerTimer(fiber) {
4347        profilerStartTime = now();
4348        0 > fiber.actualStartTime && (fiber.actualStartTime = profilerStartTime);
4349      }
4350      function stopProfilerTimerIfRunningAndRecordDuration(fiber) {
4351        if (0 <= profilerStartTime) {
4352          var elapsedTime = now() - profilerStartTime;
4353          fiber.actualDuration += elapsedTime;
4354          fiber.selfBaseDuration = elapsedTime;
4355          profilerStartTime = -1;
4356        }
4357      }
4358      function stopProfilerTimerIfRunningAndRecordIncompleteDuration(fiber) {
4359        if (0 <= profilerStartTime) {
4360          var elapsedTime = now() - profilerStartTime;
4361          fiber.actualDuration += elapsedTime;
4362          profilerStartTime = -1;
4363        }
4364      }
4365      function recordEffectDuration() {
4366        if (0 <= profilerStartTime) {
4367          var endTime = now(), elapsedTime = endTime - profilerStartTime;
4368          profilerStartTime = -1;
4369          profilerEffectDuration += elapsedTime;
4370          componentEffectDuration += elapsedTime;
4371          componentEffectEndTime = endTime;
4372        }
4373      }
4374      function recordEffectError(errorInfo) {
4375        null === componentEffectErrors && (componentEffectErrors = []);
4376        componentEffectErrors.push(errorInfo);
4377        null === commitErrors && (commitErrors = []);
4378        commitErrors.push(errorInfo);
4379      }
4380      function startEffectTimer() {
4381        profilerStartTime = now();
4382        0 > componentEffectStartTime && (componentEffectStartTime = profilerStartTime);
4383      }
4384      function transferActualDuration(fiber) {
4385        for (var child = fiber.child; child; )
4386          fiber.actualDuration += child.actualDuration, child = child.sibling;
4387      }
4388      function entangleAsyncAction(transition, thenable) {
4389        if (null === currentEntangledListeners) {
4390          var entangledListeners = currentEntangledListeners = [];
4391          currentEntangledPendingCount = 0;
4392          currentEntangledLane = requestTransitionLane();
4393          currentEntangledActionThenable = {
4394            status: "pending",
4395            value: void 0,
4396            then: function(resolve) {
4397              entangledListeners.push(resolve);
4398            }
4399          };
4400        }
4401        currentEntangledPendingCount++;
4402        thenable.then(pingEngtangledActionScope, pingEngtangledActionScope);
4403        return thenable;
4404      }
4405      function pingEngtangledActionScope() {
4406        if (0 === --currentEntangledPendingCount && (-1 < transitionUpdateTime || (transitionStartTime = -1.1), null !== currentEntangledListeners)) {
4407          null !== currentEntangledActionThenable && (currentEntangledActionThenable.status = "fulfilled");
4408          var listeners = currentEntangledListeners;
4409          currentEntangledListeners = null;
4410          currentEntangledLane = 0;
4411          currentEntangledActionThenable = null;
4412          for (var i = 0; i < listeners.length; i++) (0, listeners[i])();
4413        }
4414      }
4415      function chainThenableValue(thenable, result) {
4416        var listeners = [], thenableWithOverride = {
4417          status: "pending",
4418          value: null,
4419          reason: null,
4420          then: function(resolve) {
4421            listeners.push(resolve);
4422          }
4423        };
4424        thenable.then(
4425          function() {
4426            thenableWithOverride.status = "fulfilled";
4427            thenableWithOverride.value = result;
4428            for (var i = 0; i < listeners.length; i++) (0, listeners[i])(result);
4429          },
4430          function(error) {
4431            thenableWithOverride.status = "rejected";
4432            thenableWithOverride.reason = error;
4433            for (error = 0; error < listeners.length; error++)
4434              (0, listeners[error])(void 0);
4435          }
4436        );
4437        return thenableWithOverride;
4438      }
4439      function peekCacheFromPool() {
4440        var cacheResumedFromPreviousRender = resumedCache.current;
4441        return null !== cacheResumedFromPreviousRender ? cacheResumedFromPreviousRender : workInProgressRoot.pooledCache;
4442      }
4443      function pushTransition(offscreenWorkInProgress, prevCachePool) {
4444        null === prevCachePool ? push(resumedCache, resumedCache.current, offscreenWorkInProgress) : push(resumedCache, prevCachePool.pool, offscreenWorkInProgress);
4445      }
4446      function getSuspendedCache() {
4447        var cacheFromPool = peekCacheFromPool();
4448        return null === cacheFromPool ? null : { parent: CacheContext._currentValue, pool: cacheFromPool };
4449      }
4450      function createThenableState() {
4451        return { didWarnAboutUncachedPromise: false, thenables: [] };
4452      }
4453      function isThenableResolved(thenable) {
4454        thenable = thenable.status;
4455        return "fulfilled" === thenable || "rejected" === thenable;
4456      }
4457      function trackUsedThenable(thenableState2, thenable, index) {
4458        null !== ReactSharedInternals.actQueue && (ReactSharedInternals.didUsePromise = true);
4459        var trackedThenables = thenableState2.thenables;
4460        index = trackedThenables[index];
4461        void 0 === index ? trackedThenables.push(thenable) : index !== thenable && (thenableState2.didWarnAboutUncachedPromise || (thenableState2.didWarnAboutUncachedPromise = true, console.error(
4462          "A component was suspended by an uncached promise. Creating promises inside a Client Component or hook is not yet supported, except via a Suspense-compatible library or framework."
4463        )), thenable.then(noop$1, noop$1), thenable = index);
4464        if (void 0 === thenable._debugInfo) {
4465          thenableState2 = performance.now();
4466          trackedThenables = thenable.displayName;
4467          var ioInfo = {
4468            name: "string" === typeof trackedThenables ? trackedThenables : "Promise",
4469            start: thenableState2,
4470            end: thenableState2,
4471            value: thenable
4472          };
4473          thenable._debugInfo = [{ awaited: ioInfo }];
4474          "fulfilled" !== thenable.status && "rejected" !== thenable.status && (thenableState2 = function() {
4475            ioInfo.end = performance.now();
4476          }, thenable.then(thenableState2, thenableState2));
4477        }
4478        switch (thenable.status) {
4479          case "fulfilled":
4480            return thenable.value;
4481          case "rejected":
4482            throw thenableState2 = thenable.reason, checkIfUseWrappedInAsyncCatch(thenableState2), thenableState2;
4483          default:
4484            if ("string" === typeof thenable.status)
4485              thenable.then(noop$1, noop$1);
4486            else {
4487              thenableState2 = workInProgressRoot;
4488              if (null !== thenableState2 && 100 < thenableState2.shellSuspendCounter)
4489                throw Error(
4490                  "An unknown Component is an async Client Component. Only Server Components can be async at the moment. This error is often caused by accidentally adding `'use client'` to a module that was originally written for the server."
4491                );
4492              thenableState2 = thenable;
4493              thenableState2.status = "pending";
4494              thenableState2.then(
4495                function(fulfilledValue) {
4496                  if ("pending" === thenable.status) {
4497                    var fulfilledThenable = thenable;
4498                    fulfilledThenable.status = "fulfilled";
4499                    fulfilledThenable.value = fulfilledValue;
4500                  }
4501                },
4502                function(error) {
4503                  if ("pending" === thenable.status) {
4504                    var rejectedThenable = thenable;
4505                    rejectedThenable.status = "rejected";
4506                    rejectedThenable.reason = error;
4507                  }
4508                }
4509              );
4510            }
4511            switch (thenable.status) {
4512              case "fulfilled":
4513                return thenable.value;
4514              case "rejected":
4515                throw thenableState2 = thenable.reason, checkIfUseWrappedInAsyncCatch(thenableState2), thenableState2;
4516            }
4517            suspendedThenable = thenable;
4518            needsToResetSuspendedThenableDEV = true;
4519            throw SuspenseException;
4520        }
4521      }
4522      function resolveLazy(lazyType) {
4523        try {
4524          return callLazyInitInDEV(lazyType);
4525        } catch (x) {
4526          if (null !== x && "object" === typeof x && "function" === typeof x.then)
4527            throw suspendedThenable = x, needsToResetSuspendedThenableDEV = true, SuspenseException;
4528          throw x;
4529        }
4530      }
4531      function getSuspendedThenable() {
4532        if (null === suspendedThenable)
4533          throw Error(
4534            "Expected a suspended thenable. This is a bug in React. Please file an issue."
4535          );
4536        var thenable = suspendedThenable;
4537        suspendedThenable = null;
4538        needsToResetSuspendedThenableDEV = false;
4539        return thenable;
4540      }
4541      function checkIfUseWrappedInAsyncCatch(rejectedReason) {
4542        if (rejectedReason === SuspenseException || rejectedReason === SuspenseActionException)
4543          throw Error(
4544            "Hooks are not supported inside an async component. This error is often caused by accidentally adding `'use client'` to a module that was originally written for the server."
4545          );
4546      }
4547      function pushDebugInfo(debugInfo) {
4548        var previousDebugInfo = currentDebugInfo;
4549        null != debugInfo && (currentDebugInfo = null === previousDebugInfo ? debugInfo : previousDebugInfo.concat(debugInfo));
4550        return previousDebugInfo;
4551      }
4552      function getCurrentDebugTask() {
4553        var debugInfo = currentDebugInfo;
4554        if (null != debugInfo) {
4555          for (var i = debugInfo.length - 1; 0 <= i; i--)
4556            if (null != debugInfo[i].name) {
4557              var debugTask = debugInfo[i].debugTask;
4558              if (null != debugTask) return debugTask;
4559            }
4560        }
4561        return null;
4562      }
4563      function validateFragmentProps(element, fiber, returnFiber) {
4564        for (var keys = Object.keys(element.props), i = 0; i < keys.length; i++) {
4565          var key = keys[i];
4566          if ("children" !== key && "key" !== key) {
4567            null === fiber && (fiber = createFiberFromElement(element, returnFiber.mode, 0), fiber._debugInfo = currentDebugInfo, fiber.return = returnFiber);
4568            runWithFiberInDEV(
4569              fiber,
4570              function(erroredKey) {
4571                console.error(
4572                  "Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.",
4573                  erroredKey
4574                );
4575              },
4576              key
4577            );
4578            break;
4579          }
4580        }
4581      }
4582      function unwrapThenable(thenable) {
4583        var index = thenableIndexCounter$1;
4584        thenableIndexCounter$1 += 1;
4585        null === thenableState$1 && (thenableState$1 = createThenableState());
4586        return trackUsedThenable(thenableState$1, thenable, index);
4587      }
4588      function coerceRef(workInProgress2, element) {
4589        element = element.props.ref;
4590        workInProgress2.ref = void 0 !== element ? element : null;
4591      }
4592      function throwOnInvalidObjectTypeImpl(returnFiber, newChild) {
4593        if (newChild.$$typeof === REACT_LEGACY_ELEMENT_TYPE)
4594          throw Error(
4595            'A React Element from an older version of React was rendered. This is not supported. It can happen if:\n- Multiple copies of the "react" package is used.\n- A library pre-bundled an old copy of "react" or "react/jsx-runtime".\n- A compiler tries to "inline" JSX instead of using the runtime.'
4596          );
4597        returnFiber = Object.prototype.toString.call(newChild);
4598        throw Error(
4599          "Objects are not valid as a React child (found: " + ("[object Object]" === returnFiber ? "object with keys {" + Object.keys(newChild).join(", ") + "}" : returnFiber) + "). If you meant to render a collection of children, use an array instead."
4600        );
4601      }
4602      function throwOnInvalidObjectType(returnFiber, newChild) {
4603        var debugTask = getCurrentDebugTask();
4604        null !== debugTask ? debugTask.run(
4605          throwOnInvalidObjectTypeImpl.bind(null, returnFiber, newChild)
4606        ) : throwOnInvalidObjectTypeImpl(returnFiber, newChild);
4607      }
4608      function warnOnFunctionTypeImpl(returnFiber, invalidChild) {
4609        var parentName = getComponentNameFromFiber(returnFiber) || "Component";
4610        ownerHasFunctionTypeWarning[parentName] || (ownerHasFunctionTypeWarning[parentName] = true, invalidChild = invalidChild.displayName || invalidChild.name || "Component", 3 === returnFiber.tag ? console.error(
4611          "Functions are not valid as a React child. This may happen if you return %s instead of <%s /> from render. Or maybe you meant to call this function rather than return it.\n  root.render(%s)",
4612          invalidChild,
4613          invalidChild,
4614          invalidChild
4615        ) : console.error(
4616          "Functions are not valid as a React child. This may happen if you return %s instead of <%s /> from render. Or maybe you meant to call this function rather than return it.\n  <%s>{%s}</%s>",
4617          invalidChild,
4618          invalidChild,
4619          parentName,
4620          invalidChild,
4621          parentName
4622        ));
4623      }
4624      function warnOnFunctionType(returnFiber, invalidChild) {
4625        var debugTask = getCurrentDebugTask();
4626        null !== debugTask ? debugTask.run(
4627          warnOnFunctionTypeImpl.bind(null, returnFiber, invalidChild)
4628        ) : warnOnFunctionTypeImpl(returnFiber, invalidChild);
4629      }
4630      function warnOnSymbolTypeImpl(returnFiber, invalidChild) {
4631        var parentName = getComponentNameFromFiber(returnFiber) || "Component";
4632        ownerHasSymbolTypeWarning[parentName] || (ownerHasSymbolTypeWarning[parentName] = true, invalidChild = String(invalidChild), 3 === returnFiber.tag ? console.error(
4633          "Symbols are not valid as a React child.\n  root.render(%s)",
4634          invalidChild
4635        ) : console.error(
4636          "Symbols are not valid as a React child.\n  <%s>%s</%s>",
4637          parentName,
4638          invalidChild,
4639          parentName
4640        ));
4641      }
4642      function warnOnSymbolType(returnFiber, invalidChild) {
4643        var debugTask = getCurrentDebugTask();
4644        null !== debugTask ? debugTask.run(
4645          warnOnSymbolTypeImpl.bind(null, returnFiber, invalidChild)
4646        ) : warnOnSymbolTypeImpl(returnFiber, invalidChild);
4647      }
4648      function createChildReconciler(shouldTrackSideEffects) {
4649        function deleteChild(returnFiber, childToDelete) {
4650          if (shouldTrackSideEffects) {
4651            var deletions = returnFiber.deletions;
4652            null === deletions ? (returnFiber.deletions = [childToDelete], returnFiber.flags |= 16) : deletions.push(childToDelete);
4653          }
4654        }
4655        function deleteRemainingChildren(returnFiber, currentFirstChild) {
4656          if (!shouldTrackSideEffects) return null;
4657          for (; null !== currentFirstChild; )
4658            deleteChild(returnFiber, currentFirstChild), currentFirstChild = currentFirstChild.sibling;
4659          return null;
4660        }
4661        function mapRemainingChildren(currentFirstChild) {
4662          for (var existingChildren = /* @__PURE__ */ new Map(); null !== currentFirstChild; )
4663            null !== currentFirstChild.key ? existingChildren.set(currentFirstChild.key, currentFirstChild) : existingChildren.set(currentFirstChild.index, currentFirstChild), currentFirstChild = currentFirstChild.sibling;
4664          return existingChildren;
4665        }
4666        function useFiber(fiber, pendingProps) {
4667          fiber = createWorkInProgress(fiber, pendingProps);
4668          fiber.index = 0;
4669          fiber.sibling = null;
4670          return fiber;
4671        }
4672        function placeChild(newFiber, lastPlacedIndex, newIndex) {
4673          newFiber.index = newIndex;
4674          if (!shouldTrackSideEffects)
4675            return newFiber.flags |= 1048576, lastPlacedIndex;
4676          newIndex = newFiber.alternate;
4677          if (null !== newIndex)
4678            return newIndex = newIndex.index, newIndex < lastPlacedIndex ? (newFiber.flags |= 67108866, lastPlacedIndex) : newIndex;
4679          newFiber.flags |= 67108866;
4680          return lastPlacedIndex;
4681        }
4682        function placeSingleChild(newFiber) {
4683          shouldTrackSideEffects && null === newFiber.alternate && (newFiber.flags |= 67108866);
4684          return newFiber;
4685        }
4686        function updateTextNode(returnFiber, current2, textContent, lanes) {
4687          if (null === current2 || 6 !== current2.tag)
4688            return current2 = createFiberFromText(
4689              textContent,
4690              returnFiber.mode,
4691              lanes
4692            ), current2.return = returnFiber, current2._debugOwner = returnFiber, current2._debugTask = returnFiber._debugTask, current2._debugInfo = currentDebugInfo, current2;
4693          current2 = useFiber(current2, textContent);
4694          current2.return = returnFiber;
4695          current2._debugInfo = currentDebugInfo;
4696          return current2;
4697        }
4698        function updateElement(returnFiber, current2, element, lanes) {
4699          var elementType = element.type;
4700          if (elementType === REACT_FRAGMENT_TYPE)
4701            return current2 = updateFragment(
4702              returnFiber,
4703              current2,
4704              element.props.children,
4705              lanes,
4706              element.key
4707            ), validateFragmentProps(element, current2, returnFiber), current2;
4708          if (null !== current2 && (current2.elementType === elementType || isCompatibleFamilyForHotReloading(current2, element) || "object" === typeof elementType && null !== elementType && elementType.$$typeof === REACT_LAZY_TYPE && resolveLazy(elementType) === current2.type))
4709            return current2 = useFiber(current2, element.props), coerceRef(current2, element), current2.return = returnFiber, current2._debugOwner = element._owner, current2._debugInfo = currentDebugInfo, current2;
4710          current2 = createFiberFromElement(element, returnFiber.mode, lanes);
4711          coerceRef(current2, element);
4712          current2.return = returnFiber;
4713          current2._debugInfo = currentDebugInfo;
4714          return current2;
4715        }
4716        function updatePortal(returnFiber, current2, portal, lanes) {
4717          if (null === current2 || 4 !== current2.tag || current2.stateNode.containerInfo !== portal.containerInfo || current2.stateNode.implementation !== portal.implementation)
4718            return current2 = createFiberFromPortal(portal, returnFiber.mode, lanes), current2.return = returnFiber, current2._debugInfo = currentDebugInfo, current2;
4719          current2 = useFiber(current2, portal.children || []);
4720          current2.return = returnFiber;
4721          current2._debugInfo = currentDebugInfo;
4722          return current2;
4723        }
4724        function updateFragment(returnFiber, current2, fragment, lanes, key) {
4725          if (null === current2 || 7 !== current2.tag)
4726            return current2 = createFiberFromFragment(
4727              fragment,
4728              returnFiber.mode,
4729              lanes,
4730              key
4731            ), current2.return = returnFiber, current2._debugOwner = returnFiber, current2._debugTask = returnFiber._debugTask, current2._debugInfo = currentDebugInfo, current2;
4732          current2 = useFiber(current2, fragment);
4733          current2.return = returnFiber;
4734          current2._debugInfo = currentDebugInfo;
4735          return current2;
4736        }
4737        function createChild(returnFiber, newChild, lanes) {
4738          if ("string" === typeof newChild && "" !== newChild || "number" === typeof newChild || "bigint" === typeof newChild)
4739            return newChild = createFiberFromText(
4740              "" + newChild,
4741              returnFiber.mode,
4742              lanes
4743            ), newChild.return = returnFiber, newChild._debugOwner = returnFiber, newChild._debugTask = returnFiber._debugTask, newChild._debugInfo = currentDebugInfo, newChild;
4744          if ("object" === typeof newChild && null !== newChild) {
4745            switch (newChild.$$typeof) {
4746              case REACT_ELEMENT_TYPE:
4747                return lanes = createFiberFromElement(
4748                  newChild,
4749                  returnFiber.mode,
4750                  lanes
4751                ), coerceRef(lanes, newChild), lanes.return = returnFiber, returnFiber = pushDebugInfo(newChild._debugInfo), lanes._debugInfo = currentDebugInfo, currentDebugInfo = returnFiber, lanes;
4752              case REACT_PORTAL_TYPE:
4753                return newChild = createFiberFromPortal(
4754                  newChild,
4755                  returnFiber.mode,
4756                  lanes
4757                ), newChild.return = returnFiber, newChild._debugInfo = currentDebugInfo, newChild;
4758              case REACT_LAZY_TYPE:
4759                var _prevDebugInfo = pushDebugInfo(newChild._debugInfo);
4760                newChild = resolveLazy(newChild);
4761                returnFiber = createChild(returnFiber, newChild, lanes);
4762                currentDebugInfo = _prevDebugInfo;
4763                return returnFiber;
4764            }
4765            if (isArrayImpl(newChild) || getIteratorFn(newChild))
4766              return lanes = createFiberFromFragment(
4767                newChild,
4768                returnFiber.mode,
4769                lanes,
4770                null
4771              ), lanes.return = returnFiber, lanes._debugOwner = returnFiber, lanes._debugTask = returnFiber._debugTask, returnFiber = pushDebugInfo(newChild._debugInfo), lanes._debugInfo = currentDebugInfo, currentDebugInfo = returnFiber, lanes;
4772            if ("function" === typeof newChild.then)
4773              return _prevDebugInfo = pushDebugInfo(newChild._debugInfo), returnFiber = createChild(
4774                returnFiber,
4775                unwrapThenable(newChild),
4776                lanes
4777              ), currentDebugInfo = _prevDebugInfo, returnFiber;
4778            if (newChild.$$typeof === REACT_CONTEXT_TYPE)
4779              return createChild(
4780                returnFiber,
4781                readContextDuringReconciliation(returnFiber, newChild),
4782                lanes
4783              );
4784            throwOnInvalidObjectType(returnFiber, newChild);
4785          }
4786          "function" === typeof newChild && warnOnFunctionType(returnFiber, newChild);
4787          "symbol" === typeof newChild && warnOnSymbolType(returnFiber, newChild);
4788          return null;
4789        }
4790        function updateSlot(returnFiber, oldFiber, newChild, lanes) {
4791          var key = null !== oldFiber ? oldFiber.key : null;
4792          if ("string" === typeof newChild && "" !== newChild || "number" === typeof newChild || "bigint" === typeof newChild)
4793            return null !== key ? null : updateTextNode(returnFiber, oldFiber, "" + newChild, lanes);
4794          if ("object" === typeof newChild && null !== newChild) {
4795            switch (newChild.$$typeof) {
4796              case REACT_ELEMENT_TYPE:
4797                return newChild.key === key ? (key = pushDebugInfo(newChild._debugInfo), returnFiber = updateElement(
4798                  returnFiber,
4799                  oldFiber,
4800                  newChild,
4801                  lanes
4802                ), currentDebugInfo = key, returnFiber) : null;
4803              case REACT_PORTAL_TYPE:
4804                return newChild.key === key ? updatePortal(returnFiber, oldFiber, newChild, lanes) : null;
4805              case REACT_LAZY_TYPE:
4806                return key = pushDebugInfo(newChild._debugInfo), newChild = resolveLazy(newChild), returnFiber = updateSlot(
4807                  returnFiber,
4808                  oldFiber,
4809                  newChild,
4810                  lanes
4811                ), currentDebugInfo = key, returnFiber;
4812            }
4813            if (isArrayImpl(newChild) || getIteratorFn(newChild)) {
4814              if (null !== key) return null;
4815              key = pushDebugInfo(newChild._debugInfo);
4816              returnFiber = updateFragment(
4817                returnFiber,
4818                oldFiber,
4819                newChild,
4820                lanes,
4821                null
4822              );
4823              currentDebugInfo = key;
4824              return returnFiber;
4825            }
4826            if ("function" === typeof newChild.then)
4827              return key = pushDebugInfo(newChild._debugInfo), returnFiber = updateSlot(
4828                returnFiber,
4829                oldFiber,
4830                unwrapThenable(newChild),
4831                lanes
4832              ), currentDebugInfo = key, returnFiber;
4833            if (newChild.$$typeof === REACT_CONTEXT_TYPE)
4834              return updateSlot(
4835                returnFiber,
4836                oldFiber,
4837                readContextDuringReconciliation(returnFiber, newChild),
4838                lanes
4839              );
4840            throwOnInvalidObjectType(returnFiber, newChild);
4841          }
4842          "function" === typeof newChild && warnOnFunctionType(returnFiber, newChild);
4843          "symbol" === typeof newChild && warnOnSymbolType(returnFiber, newChild);
4844          return null;
4845        }
4846        function updateFromMap(existingChildren, returnFiber, newIdx, newChild, lanes) {
4847          if ("string" === typeof newChild && "" !== newChild || "number" === typeof newChild || "bigint" === typeof newChild)
4848            return existingChildren = existingChildren.get(newIdx) || null, updateTextNode(returnFiber, existingChildren, "" + newChild, lanes);
4849          if ("object" === typeof newChild && null !== newChild) {
4850            switch (newChild.$$typeof) {
4851              case REACT_ELEMENT_TYPE:
4852                return newIdx = existingChildren.get(
4853                  null === newChild.key ? newIdx : newChild.key
4854                ) || null, existingChildren = pushDebugInfo(newChild._debugInfo), returnFiber = updateElement(
4855                  returnFiber,
4856                  newIdx,
4857                  newChild,
4858                  lanes
4859                ), currentDebugInfo = existingChildren, returnFiber;
4860              case REACT_PORTAL_TYPE:
4861                return existingChildren = existingChildren.get(
4862                  null === newChild.key ? newIdx : newChild.key
4863                ) || null, updatePortal(returnFiber, existingChildren, newChild, lanes);
4864              case REACT_LAZY_TYPE:
4865                var _prevDebugInfo7 = pushDebugInfo(newChild._debugInfo);
4866                newChild = resolveLazy(newChild);
4867                returnFiber = updateFromMap(
4868                  existingChildren,
4869                  returnFiber,
4870                  newIdx,
4871                  newChild,
4872                  lanes
4873                );
4874                currentDebugInfo = _prevDebugInfo7;
4875                return returnFiber;
4876            }
4877            if (isArrayImpl(newChild) || getIteratorFn(newChild))
4878              return newIdx = existingChildren.get(newIdx) || null, existingChildren = pushDebugInfo(newChild._debugInfo), returnFiber = updateFragment(
4879                returnFiber,
4880                newIdx,
4881                newChild,
4882                lanes,
4883                null
4884              ), currentDebugInfo = existingChildren, returnFiber;
4885            if ("function" === typeof newChild.then)
4886              return _prevDebugInfo7 = pushDebugInfo(newChild._debugInfo), returnFiber = updateFromMap(
4887                existingChildren,
4888                returnFiber,
4889                newIdx,
4890                unwrapThenable(newChild),
4891                lanes
4892              ), currentDebugInfo = _prevDebugInfo7, returnFiber;
4893            if (newChild.$$typeof === REACT_CONTEXT_TYPE)
4894              return updateFromMap(
4895                existingChildren,
4896                returnFiber,
4897                newIdx,
4898                readContextDuringReconciliation(returnFiber, newChild),
4899                lanes
4900              );
4901            throwOnInvalidObjectType(returnFiber, newChild);
4902          }
4903          "function" === typeof newChild && warnOnFunctionType(returnFiber, newChild);
4904          "symbol" === typeof newChild && warnOnSymbolType(returnFiber, newChild);
4905          return null;
4906        }
4907        function warnOnInvalidKey(returnFiber, workInProgress2, child, knownKeys) {
4908          if ("object" !== typeof child || null === child) return knownKeys;
4909          switch (child.$$typeof) {
4910            case REACT_ELEMENT_TYPE:
4911            case REACT_PORTAL_TYPE:
4912              warnForMissingKey(returnFiber, workInProgress2, child);
4913              var key = child.key;
4914              if ("string" !== typeof key) break;
4915              if (null === knownKeys) {
4916                knownKeys = /* @__PURE__ */ new Set();
4917                knownKeys.add(key);
4918                break;
4919              }
4920              if (!knownKeys.has(key)) {
4921                knownKeys.add(key);
4922                break;
4923              }
4924              runWithFiberInDEV(workInProgress2, function() {
4925                console.error(
4926                  "Encountered two children with the same key, `%s`. Keys should be unique so that components maintain their identity across updates. Non-unique keys may cause children to be duplicated and/or omitted — the behavior is unsupported and could change in a future version.",
4927                  key
4928                );
4929              });
4930              break;
4931            case REACT_LAZY_TYPE:
4932              child = resolveLazy(child), warnOnInvalidKey(returnFiber, workInProgress2, child, knownKeys);
4933          }
4934          return knownKeys;
4935        }
4936        function reconcileChildrenArray(returnFiber, currentFirstChild, newChildren, lanes) {
4937          for (var knownKeys = null, resultingFirstChild = null, previousNewFiber = null, oldFiber = currentFirstChild, newIdx = currentFirstChild = 0, nextOldFiber = null; null !== oldFiber && newIdx < newChildren.length; newIdx++) {
4938            oldFiber.index > newIdx ? (nextOldFiber = oldFiber, oldFiber = null) : nextOldFiber = oldFiber.sibling;
4939            var newFiber = updateSlot(
4940              returnFiber,
4941              oldFiber,
4942              newChildren[newIdx],
4943              lanes
4944            );
4945            if (null === newFiber) {
4946              null === oldFiber && (oldFiber = nextOldFiber);
4947              break;
4948            }
4949            knownKeys = warnOnInvalidKey(
4950              returnFiber,
4951              newFiber,
4952              newChildren[newIdx],
4953              knownKeys
4954            );
4955            shouldTrackSideEffects && oldFiber && null === newFiber.alternate && deleteChild(returnFiber, oldFiber);
4956            currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
4957            null === previousNewFiber ? resultingFirstChild = newFiber : previousNewFiber.sibling = newFiber;
4958            previousNewFiber = newFiber;
4959            oldFiber = nextOldFiber;
4960          }
4961          if (newIdx === newChildren.length)
4962            return deleteRemainingChildren(returnFiber, oldFiber), isHydrating && pushTreeFork(returnFiber, newIdx), resultingFirstChild;
4963          if (null === oldFiber) {
4964            for (; newIdx < newChildren.length; newIdx++)
4965              oldFiber = createChild(returnFiber, newChildren[newIdx], lanes), null !== oldFiber && (knownKeys = warnOnInvalidKey(
4966                returnFiber,
4967                oldFiber,
4968                newChildren[newIdx],
4969                knownKeys
4970              ), currentFirstChild = placeChild(
4971                oldFiber,
4972                currentFirstChild,
4973                newIdx
4974              ), null === previousNewFiber ? resultingFirstChild = oldFiber : previousNewFiber.sibling = oldFiber, previousNewFiber = oldFiber);
4975            isHydrating && pushTreeFork(returnFiber, newIdx);
4976            return resultingFirstChild;
4977          }
4978          for (oldFiber = mapRemainingChildren(oldFiber); newIdx < newChildren.length; newIdx++)
4979            nextOldFiber = updateFromMap(
4980              oldFiber,
4981              returnFiber,
4982              newIdx,
4983              newChildren[newIdx],
4984              lanes
4985            ), null !== nextOldFiber && (knownKeys = warnOnInvalidKey(
4986              returnFiber,
4987              nextOldFiber,
4988              newChildren[newIdx],
4989              knownKeys
4990            ), shouldTrackSideEffects && null !== nextOldFiber.alternate && oldFiber.delete(
4991              null === nextOldFiber.key ? newIdx : nextOldFiber.key
4992            ), currentFirstChild = placeChild(
4993              nextOldFiber,
4994              currentFirstChild,
4995              newIdx
4996            ), null === previousNewFiber ? resultingFirstChild = nextOldFiber : previousNewFiber.sibling = nextOldFiber, previousNewFiber = nextOldFiber);
4997          shouldTrackSideEffects && oldFiber.forEach(function(child) {
4998            return deleteChild(returnFiber, child);
4999          });
5000          isHydrating && pushTreeFork(returnFiber, newIdx);
5001          return resultingFirstChild;
5002        }
5003        function reconcileChildrenIterator(returnFiber, currentFirstChild, newChildren, lanes) {
5004          if (null == newChildren)
5005            throw Error("An iterable object provided no iterator.");
5006          for (var resultingFirstChild = null, previousNewFiber = null, oldFiber = currentFirstChild, newIdx = currentFirstChild = 0, nextOldFiber = null, knownKeys = null, step = newChildren.next(); null !== oldFiber && !step.done; newIdx++, step = newChildren.next()) {
5007            oldFiber.index > newIdx ? (nextOldFiber = oldFiber, oldFiber = null) : nextOldFiber = oldFiber.sibling;
5008            var newFiber = updateSlot(returnFiber, oldFiber, step.value, lanes);
5009            if (null === newFiber) {
5010              null === oldFiber && (oldFiber = nextOldFiber);
5011              break;
5012            }
5013            knownKeys = warnOnInvalidKey(
5014              returnFiber,
5015              newFiber,
5016              step.value,
5017              knownKeys
5018            );
5019            shouldTrackSideEffects && oldFiber && null === newFiber.alternate && deleteChild(returnFiber, oldFiber);
5020            currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
5021            null === previousNewFiber ? resultingFirstChild = newFiber : previousNewFiber.sibling = newFiber;
5022            previousNewFiber = newFiber;
5023            oldFiber = nextOldFiber;
5024          }
5025          if (step.done)
5026            return deleteRemainingChildren(returnFiber, oldFiber), isHydrating && pushTreeFork(returnFiber, newIdx), resultingFirstChild;
5027          if (null === oldFiber) {
5028            for (; !step.done; newIdx++, step = newChildren.next())
5029              oldFiber = createChild(returnFiber, step.value, lanes), null !== oldFiber && (knownKeys = warnOnInvalidKey(
5030                returnFiber,
5031                oldFiber,
5032                step.value,
5033                knownKeys
5034              ), currentFirstChild = placeChild(
5035                oldFiber,
5036                currentFirstChild,
5037                newIdx
5038              ), null === previousNewFiber ? resultingFirstChild = oldFiber : previousNewFiber.sibling = oldFiber, previousNewFiber = oldFiber);
5039            isHydrating && pushTreeFork(returnFiber, newIdx);
5040            return resultingFirstChild;
5041          }
5042          for (oldFiber = mapRemainingChildren(oldFiber); !step.done; newIdx++, step = newChildren.next())
5043            nextOldFiber = updateFromMap(
5044              oldFiber,
5045              returnFiber,
5046              newIdx,
5047              step.value,
5048              lanes
5049            ), null !== nextOldFiber && (knownKeys = warnOnInvalidKey(
5050              returnFiber,
5051              nextOldFiber,
5052              step.value,
5053              knownKeys
5054            ), shouldTrackSideEffects && null !== nextOldFiber.alternate && oldFiber.delete(
5055              null === nextOldFiber.key ? newIdx : nextOldFiber.key
5056            ), currentFirstChild = placeChild(
5057              nextOldFiber,
5058              currentFirstChild,
5059              newIdx
5060            ), null === previousNewFiber ? resultingFirstChild = nextOldFiber : previousNewFiber.sibling = nextOldFiber, previousNewFiber = nextOldFiber);
5061          shouldTrackSideEffects && oldFiber.forEach(function(child) {
5062            return deleteChild(returnFiber, child);
5063          });
5064          isHydrating && pushTreeFork(returnFiber, newIdx);
5065          return resultingFirstChild;
5066        }
5067        function reconcileChildFibersImpl(returnFiber, currentFirstChild, newChild, lanes) {
5068          "object" === typeof newChild && null !== newChild && newChild.type === REACT_FRAGMENT_TYPE && null === newChild.key && (validateFragmentProps(newChild, null, returnFiber), newChild = newChild.props.children);
5069          if ("object" === typeof newChild && null !== newChild) {
5070            switch (newChild.$$typeof) {
5071              case REACT_ELEMENT_TYPE:
5072                var prevDebugInfo = pushDebugInfo(newChild._debugInfo);
5073                a: {
5074                  for (var key = newChild.key; null !== currentFirstChild; ) {
5075                    if (currentFirstChild.key === key) {
5076                      key = newChild.type;
5077                      if (key === REACT_FRAGMENT_TYPE) {
5078                        if (7 === currentFirstChild.tag) {
5079                          deleteRemainingChildren(
5080                            returnFiber,
5081                            currentFirstChild.sibling
5082                          );
5083                          lanes = useFiber(
5084                            currentFirstChild,
5085                            newChild.props.children
5086                          );
5087                          lanes.return = returnFiber;
5088                          lanes._debugOwner = newChild._owner;
5089                          lanes._debugInfo = currentDebugInfo;
5090                          validateFragmentProps(newChild, lanes, returnFiber);
5091                          returnFiber = lanes;
5092                          break a;
5093                        }
5094                      } else if (currentFirstChild.elementType === key || isCompatibleFamilyForHotReloading(
5095                        currentFirstChild,
5096                        newChild
5097                      ) || "object" === typeof key && null !== key && key.$$typeof === REACT_LAZY_TYPE && resolveLazy(key) === currentFirstChild.type) {
5098                        deleteRemainingChildren(
5099                          returnFiber,
5100                          currentFirstChild.sibling
5101                        );
5102                        lanes = useFiber(currentFirstChild, newChild.props);
5103                        coerceRef(lanes, newChild);
5104                        lanes.return = returnFiber;
5105                        lanes._debugOwner = newChild._owner;
5106                        lanes._debugInfo = currentDebugInfo;
5107                        returnFiber = lanes;
5108                        break a;
5109                      }
5110                      deleteRemainingChildren(returnFiber, currentFirstChild);
5111                      break;
5112                    } else deleteChild(returnFiber, currentFirstChild);
5113                    currentFirstChild = currentFirstChild.sibling;
5114                  }
5115                  newChild.type === REACT_FRAGMENT_TYPE ? (lanes = createFiberFromFragment(
5116                    newChild.props.children,
5117                    returnFiber.mode,
5118                    lanes,
5119                    newChild.key
5120                  ), lanes.return = returnFiber, lanes._debugOwner = returnFiber, lanes._debugTask = returnFiber._debugTask, lanes._debugInfo = currentDebugInfo, validateFragmentProps(newChild, lanes, returnFiber), returnFiber = lanes) : (lanes = createFiberFromElement(
5121                    newChild,
5122                    returnFiber.mode,
5123                    lanes
5124                  ), coerceRef(lanes, newChild), lanes.return = returnFiber, lanes._debugInfo = currentDebugInfo, returnFiber = lanes);
5125                }
5126                returnFiber = placeSingleChild(returnFiber);
5127                currentDebugInfo = prevDebugInfo;
5128                return returnFiber;
5129              case REACT_PORTAL_TYPE:
5130                a: {
5131                  prevDebugInfo = newChild;
5132                  for (newChild = prevDebugInfo.key; null !== currentFirstChild; ) {
5133                    if (currentFirstChild.key === newChild)
5134                      if (4 === currentFirstChild.tag && currentFirstChild.stateNode.containerInfo === prevDebugInfo.containerInfo && currentFirstChild.stateNode.implementation === prevDebugInfo.implementation) {
5135                        deleteRemainingChildren(
5136                          returnFiber,
5137                          currentFirstChild.sibling
5138                        );
5139                        lanes = useFiber(
5140                          currentFirstChild,
5141                          prevDebugInfo.children || []
5142                        );
5143                        lanes.return = returnFiber;
5144                        returnFiber = lanes;
5145                        break a;
5146                      } else {
5147                        deleteRemainingChildren(returnFiber, currentFirstChild);
5148                        break;
5149                      }
5150                    else deleteChild(returnFiber, currentFirstChild);
5151                    currentFirstChild = currentFirstChild.sibling;
5152                  }
5153                  lanes = createFiberFromPortal(
5154                    prevDebugInfo,
5155                    returnFiber.mode,
5156                    lanes
5157                  );
5158                  lanes.return = returnFiber;
5159                  returnFiber = lanes;
5160                }
5161                return placeSingleChild(returnFiber);
5162              case REACT_LAZY_TYPE:
5163                return prevDebugInfo = pushDebugInfo(newChild._debugInfo), newChild = resolveLazy(newChild), returnFiber = reconcileChildFibersImpl(
5164                  returnFiber,
5165                  currentFirstChild,
5166                  newChild,
5167                  lanes
5168                ), currentDebugInfo = prevDebugInfo, returnFiber;
5169            }
5170            if (isArrayImpl(newChild))
5171              return prevDebugInfo = pushDebugInfo(newChild._debugInfo), returnFiber = reconcileChildrenArray(
5172                returnFiber,
5173                currentFirstChild,
5174                newChild,
5175                lanes
5176              ), currentDebugInfo = prevDebugInfo, returnFiber;
5177            if (getIteratorFn(newChild)) {
5178              prevDebugInfo = pushDebugInfo(newChild._debugInfo);
5179              key = getIteratorFn(newChild);
5180              if ("function" !== typeof key)
5181                throw Error(
5182                  "An object is not an iterable. This error is likely caused by a bug in React. Please file an issue."
5183                );
5184              var newChildren = key.call(newChild);
5185              if (newChildren === newChild) {
5186                if (0 !== returnFiber.tag || "[object GeneratorFunction]" !== Object.prototype.toString.call(returnFiber.type) || "[object Generator]" !== Object.prototype.toString.call(newChildren))
5187                  didWarnAboutGenerators || console.error(
5188                    "Using Iterators as children is unsupported and will likely yield unexpected results because enumerating a generator mutates it. You may convert it to an array with `Array.from()` or the `[...spread]` operator before rendering. You can also use an Iterable that can iterate multiple times over the same items."
5189                  ), didWarnAboutGenerators = true;
5190              } else
5191                newChild.entries !== key || didWarnAboutMaps || (console.error(
5192                  "Using Maps as children is not supported. Use an array of keyed ReactElements instead."
5193                ), didWarnAboutMaps = true);
5194              returnFiber = reconcileChildrenIterator(
5195                returnFiber,
5196                currentFirstChild,
5197                newChildren,
5198                lanes
5199              );
5200              currentDebugInfo = prevDebugInfo;
5201              return returnFiber;
5202            }
5203            if ("function" === typeof newChild.then)
5204              return prevDebugInfo = pushDebugInfo(newChild._debugInfo), returnFiber = reconcileChildFibersImpl(
5205                returnFiber,
5206                currentFirstChild,
5207                unwrapThenable(newChild),
5208                lanes
5209              ), currentDebugInfo = prevDebugInfo, returnFiber;
5210            if (newChild.$$typeof === REACT_CONTEXT_TYPE)
5211              return reconcileChildFibersImpl(
5212                returnFiber,
5213                currentFirstChild,
5214                readContextDuringReconciliation(returnFiber, newChild),
5215                lanes
5216              );
5217            throwOnInvalidObjectType(returnFiber, newChild);
5218          }
5219          if ("string" === typeof newChild && "" !== newChild || "number" === typeof newChild || "bigint" === typeof newChild)
5220            return prevDebugInfo = "" + newChild, null !== currentFirstChild && 6 === currentFirstChild.tag ? (deleteRemainingChildren(
5221              returnFiber,
5222              currentFirstChild.sibling
5223            ), lanes = useFiber(currentFirstChild, prevDebugInfo), lanes.return = returnFiber, returnFiber = lanes) : (deleteRemainingChildren(returnFiber, currentFirstChild), lanes = createFiberFromText(
5224              prevDebugInfo,
5225              returnFiber.mode,
5226              lanes
5227            ), lanes.return = returnFiber, lanes._debugOwner = returnFiber, lanes._debugTask = returnFiber._debugTask, lanes._debugInfo = currentDebugInfo, returnFiber = lanes), placeSingleChild(returnFiber);
5228          "function" === typeof newChild && warnOnFunctionType(returnFiber, newChild);
5229          "symbol" === typeof newChild && warnOnSymbolType(returnFiber, newChild);
5230          return deleteRemainingChildren(returnFiber, currentFirstChild);
5231        }
5232        return function(returnFiber, currentFirstChild, newChild, lanes) {
5233          var prevDebugInfo = currentDebugInfo;
5234          currentDebugInfo = null;
5235          try {
5236            thenableIndexCounter$1 = 0;
5237            var firstChildFiber = reconcileChildFibersImpl(
5238              returnFiber,
5239              currentFirstChild,
5240              newChild,
5241              lanes
5242            );
5243            thenableState$1 = null;
5244            return firstChildFiber;
5245          } catch (x) {
5246            if (x === SuspenseException || x === SuspenseActionException) throw x;
5247            var fiber = createFiber(29, x, null, returnFiber.mode);
5248            fiber.lanes = lanes;
5249            fiber.return = returnFiber;
5250            var debugInfo = fiber._debugInfo = currentDebugInfo;
5251            fiber._debugOwner = returnFiber._debugOwner;
5252            fiber._debugTask = returnFiber._debugTask;
5253            if (null != debugInfo) {
5254              for (var i = debugInfo.length - 1; 0 <= i; i--)
5255                if ("string" === typeof debugInfo[i].stack) {
5256                  fiber._debugOwner = debugInfo[i];
5257                  fiber._debugTask = debugInfo[i].debugTask;
5258                  break;
5259                }
5260            }
5261            return fiber;
5262          } finally {
5263            currentDebugInfo = prevDebugInfo;
5264          }
5265        };
5266      }
5267      function validateSuspenseListNestedChild(childSlot, index) {
5268        var isAnArray = isArrayImpl(childSlot);
5269        childSlot = !isAnArray && "function" === typeof getIteratorFn(childSlot);
5270        return isAnArray || childSlot ? (isAnArray = isAnArray ? "array" : "iterable", console.error(
5271          "A nested %s was passed to row #%s in <SuspenseList />. Wrap it in an additional SuspenseList to configure its revealOrder: <SuspenseList revealOrder=...> ... <SuspenseList revealOrder=...>{%s}</SuspenseList> ... </SuspenseList>",
5272          isAnArray,
5273          index,
5274          isAnArray
5275        ), false) : true;
5276      }
5277      function initializeUpdateQueue(fiber) {
5278        fiber.updateQueue = {
5279          baseState: fiber.memoizedState,
5280          firstBaseUpdate: null,
5281          lastBaseUpdate: null,
5282          shared: { pending: null, lanes: 0, hiddenCallbacks: null },
5283          callbacks: null
5284        };
5285      }
5286      function cloneUpdateQueue(current2, workInProgress2) {
5287        current2 = current2.updateQueue;
5288        workInProgress2.updateQueue === current2 && (workInProgress2.updateQueue = {
5289          baseState: current2.baseState,
5290          firstBaseUpdate: current2.firstBaseUpdate,
5291          lastBaseUpdate: current2.lastBaseUpdate,
5292          shared: current2.shared,
5293          callbacks: null
5294        });
5295      }
5296      function createUpdate(lane) {
5297        return {
5298          lane,
5299          tag: UpdateState,
5300          payload: null,
5301          callback: null,
5302          next: null
5303        };
5304      }
5305      function enqueueUpdate(fiber, update, lane) {
5306        var updateQueue = fiber.updateQueue;
5307        if (null === updateQueue) return null;
5308        updateQueue = updateQueue.shared;
5309        if (currentlyProcessingQueue === updateQueue && !didWarnUpdateInsideUpdate) {
5310          var componentName2 = getComponentNameFromFiber(fiber);
5311          console.error(
5312            "An update (setState, replaceState, or forceUpdate) was scheduled from inside an update function. Update functions should be pure, with zero side-effects. Consider using componentDidUpdate or a callback.\n\nPlease update the following component: %s",
5313            componentName2
5314          );
5315          didWarnUpdateInsideUpdate = true;
5316        }
5317        if ((executionContext & RenderContext) !== NoContext)
5318          return componentName2 = updateQueue.pending, null === componentName2 ? update.next = update : (update.next = componentName2.next, componentName2.next = update), updateQueue.pending = update, update = getRootForUpdatedFiber(fiber), markUpdateLaneFromFiberToRoot(fiber, null, lane), update;
5319        enqueueUpdate$1(fiber, updateQueue, update, lane);
5320        return getRootForUpdatedFiber(fiber);
5321      }
5322      function entangleTransitions(root2, fiber, lane) {
5323        fiber = fiber.updateQueue;
5324        if (null !== fiber && (fiber = fiber.shared, 0 !== (lane & 4194048))) {
5325          var queueLanes = fiber.lanes;
5326          queueLanes &= root2.pendingLanes;
5327          lane |= queueLanes;
5328          fiber.lanes = lane;
5329          markRootEntangled(root2, lane);
5330        }
5331      }
5332      function enqueueCapturedUpdate(workInProgress2, capturedUpdate) {
5333        var queue = workInProgress2.updateQueue, current2 = workInProgress2.alternate;
5334        if (null !== current2 && (current2 = current2.updateQueue, queue === current2)) {
5335          var newFirst = null, newLast = null;
5336          queue = queue.firstBaseUpdate;
5337          if (null !== queue) {
5338            do {
5339              var clone = {
5340                lane: queue.lane,
5341                tag: queue.tag,
5342                payload: queue.payload,
5343                callback: null,
5344                next: null
5345              };
5346              null === newLast ? newFirst = newLast = clone : newLast = newLast.next = clone;
5347              queue = queue.next;
5348            } while (null !== queue);
5349            null === newLast ? newFirst = newLast = capturedUpdate : newLast = newLast.next = capturedUpdate;
5350          } else newFirst = newLast = capturedUpdate;
5351          queue = {
5352            baseState: current2.baseState,
5353            firstBaseUpdate: newFirst,
5354            lastBaseUpdate: newLast,
5355            shared: current2.shared,
5356            callbacks: current2.callbacks
5357          };
5358          workInProgress2.updateQueue = queue;
5359          return;
5360        }
5361        workInProgress2 = queue.lastBaseUpdate;
5362        null === workInProgress2 ? queue.firstBaseUpdate = capturedUpdate : workInProgress2.next = capturedUpdate;
5363        queue.lastBaseUpdate = capturedUpdate;
5364      }
5365      function suspendIfUpdateReadFromEntangledAsyncAction() {
5366        if (didReadFromEntangledAsyncAction) {
5367          var entangledActionThenable = currentEntangledActionThenable;
5368          if (null !== entangledActionThenable) throw entangledActionThenable;
5369        }
5370      }
5371      function processUpdateQueue(workInProgress2, props, instance$jscomp$0, renderLanes2) {
5372        didReadFromEntangledAsyncAction = false;
5373        var queue = workInProgress2.updateQueue;
5374        hasForceUpdate = false;
5375        currentlyProcessingQueue = queue.shared;
5376        var firstBaseUpdate = queue.firstBaseUpdate, lastBaseUpdate = queue.lastBaseUpdate, pendingQueue = queue.shared.pending;
5377        if (null !== pendingQueue) {
5378          queue.shared.pending = null;
5379          var lastPendingUpdate = pendingQueue, firstPendingUpdate = lastPendingUpdate.next;
5380          lastPendingUpdate.next = null;
5381          null === lastBaseUpdate ? firstBaseUpdate = firstPendingUpdate : lastBaseUpdate.next = firstPendingUpdate;
5382          lastBaseUpdate = lastPendingUpdate;
5383          var current2 = workInProgress2.alternate;
5384          null !== current2 && (current2 = current2.updateQueue, pendingQueue = current2.lastBaseUpdate, pendingQueue !== lastBaseUpdate && (null === pendingQueue ? current2.firstBaseUpdate = firstPendingUpdate : pendingQueue.next = firstPendingUpdate, current2.lastBaseUpdate = lastPendingUpdate));
5385        }
5386        if (null !== firstBaseUpdate) {
5387          var newState = queue.baseState;
5388          lastBaseUpdate = 0;
5389          current2 = firstPendingUpdate = lastPendingUpdate = null;
5390          pendingQueue = firstBaseUpdate;
5391          do {
5392            var updateLane = pendingQueue.lane & -536870913, isHiddenUpdate = updateLane !== pendingQueue.lane;
5393            if (isHiddenUpdate ? (workInProgressRootRenderLanes & updateLane) === updateLane : (renderLanes2 & updateLane) === updateLane) {
5394              0 !== updateLane && updateLane === currentEntangledLane && (didReadFromEntangledAsyncAction = true);
5395              null !== current2 && (current2 = current2.next = {
5396                lane: 0,
5397                tag: pendingQueue.tag,
5398                payload: pendingQueue.payload,
5399                callback: null,
5400                next: null
5401              });
5402              a: {
5403                updateLane = workInProgress2;
5404                var partialState = pendingQueue;
5405                var nextProps = props, instance = instance$jscomp$0;
5406                switch (partialState.tag) {
5407                  case ReplaceState:
5408                    partialState = partialState.payload;
5409                    if ("function" === typeof partialState) {
5410                      isDisallowedContextReadInDEV = true;
5411                      var nextState = partialState.call(
5412                        instance,
5413                        newState,
5414                        nextProps
5415                      );
5416                      if (updateLane.mode & StrictLegacyMode) {
5417                        setIsStrictModeForDevtools(true);
5418                        try {
5419                          partialState.call(instance, newState, nextProps);
5420                        } finally {
5421                          setIsStrictModeForDevtools(false);
5422                        }
5423                      }
5424                      isDisallowedContextReadInDEV = false;
5425                      newState = nextState;
5426                      break a;
5427                    }
5428                    newState = partialState;
5429                    break a;
5430                  case CaptureUpdate:
5431                    updateLane.flags = updateLane.flags & -65537 | 128;
5432                  case UpdateState:
5433                    nextState = partialState.payload;
5434                    if ("function" === typeof nextState) {
5435                      isDisallowedContextReadInDEV = true;
5436                      partialState = nextState.call(
5437                        instance,
5438                        newState,
5439                        nextProps
5440                      );
5441                      if (updateLane.mode & StrictLegacyMode) {
5442                        setIsStrictModeForDevtools(true);
5443                        try {
5444                          nextState.call(instance, newState, nextProps);
5445                        } finally {
5446                          setIsStrictModeForDevtools(false);
5447                        }
5448                      }
5449                      isDisallowedContextReadInDEV = false;
5450                    } else partialState = nextState;
5451                    if (null === partialState || void 0 === partialState) break a;
5452                    newState = assign({}, newState, partialState);
5453                    break a;
5454                  case ForceUpdate:
5455                    hasForceUpdate = true;
5456                }
5457              }
5458              updateLane = pendingQueue.callback;
5459              null !== updateLane && (workInProgress2.flags |= 64, isHiddenUpdate && (workInProgress2.flags |= 8192), isHiddenUpdate = queue.callbacks, null === isHiddenUpdate ? queue.callbacks = [updateLane] : isHiddenUpdate.push(updateLane));
5460            } else
5461              isHiddenUpdate = {
5462                lane: updateLane,
5463                tag: pendingQueue.tag,
5464                payload: pendingQueue.payload,
5465                callback: pendingQueue.callback,
5466                next: null
5467              }, null === current2 ? (firstPendingUpdate = current2 = isHiddenUpdate, lastPendingUpdate = newState) : current2 = current2.next = isHiddenUpdate, lastBaseUpdate |= updateLane;
5468            pendingQueue = pendingQueue.next;
5469            if (null === pendingQueue)
5470              if (pendingQueue = queue.shared.pending, null === pendingQueue)
5471                break;
5472              else
5473                isHiddenUpdate = pendingQueue, pendingQueue = isHiddenUpdate.next, isHiddenUpdate.next = null, queue.lastBaseUpdate = isHiddenUpdate, queue.shared.pending = null;
5474          } while (1);
5475          null === current2 && (lastPendingUpdate = newState);
5476          queue.baseState = lastPendingUpdate;
5477          queue.firstBaseUpdate = firstPendingUpdate;
5478          queue.lastBaseUpdate = current2;
5479          null === firstBaseUpdate && (queue.shared.lanes = 0);
5480          workInProgressRootSkippedLanes |= lastBaseUpdate;
5481          workInProgress2.lanes = lastBaseUpdate;
5482          workInProgress2.memoizedState = newState;
5483        }
5484        currentlyProcessingQueue = null;
5485      }
5486      function callCallback(callback, context) {
5487        if ("function" !== typeof callback)
5488          throw Error(
5489            "Invalid argument passed as callback. Expected a function. Instead received: " + callback
5490          );
5491        callback.call(context);
5492      }
5493      function commitHiddenCallbacks(updateQueue, context) {
5494        var hiddenCallbacks = updateQueue.shared.hiddenCallbacks;
5495        if (null !== hiddenCallbacks)
5496          for (updateQueue.shared.hiddenCallbacks = null, updateQueue = 0; updateQueue < hiddenCallbacks.length; updateQueue++)
5497            callCallback(hiddenCallbacks[updateQueue], context);
5498      }
5499      function commitCallbacks(updateQueue, context) {
5500        var callbacks = updateQueue.callbacks;
5501        if (null !== callbacks)
5502          for (updateQueue.callbacks = null, updateQueue = 0; updateQueue < callbacks.length; updateQueue++)
5503            callCallback(callbacks[updateQueue], context);
5504      }
5505      function pushHiddenContext(fiber, context) {
5506        var prevEntangledRenderLanes = entangledRenderLanes;
5507        push(prevEntangledRenderLanesCursor, prevEntangledRenderLanes, fiber);
5508        push(currentTreeHiddenStackCursor, context, fiber);
5509        entangledRenderLanes = prevEntangledRenderLanes | context.baseLanes;
5510      }
5511      function reuseHiddenContextOnStack(fiber) {
5512        push(prevEntangledRenderLanesCursor, entangledRenderLanes, fiber);
5513        push(
5514          currentTreeHiddenStackCursor,
5515          currentTreeHiddenStackCursor.current,
5516          fiber
5517        );
5518      }
5519      function popHiddenContext(fiber) {
5520        entangledRenderLanes = prevEntangledRenderLanesCursor.current;
5521        pop(currentTreeHiddenStackCursor, fiber);
5522        pop(prevEntangledRenderLanesCursor, fiber);
5523      }
5524      function pushPrimaryTreeSuspenseHandler(handler) {
5525        var current2 = handler.alternate;
5526        push(
5527          suspenseStackCursor,
5528          suspenseStackCursor.current & SubtreeSuspenseContextMask,
5529          handler
5530        );
5531        push(suspenseHandlerStackCursor, handler, handler);
5532        null === shellBoundary && (null === current2 || null !== currentTreeHiddenStackCursor.current ? shellBoundary = handler : null !== current2.memoizedState && (shellBoundary = handler));
5533      }
5534      function pushDehydratedActivitySuspenseHandler(fiber) {
5535        push(suspenseStackCursor, suspenseStackCursor.current, fiber);
5536        push(suspenseHandlerStackCursor, fiber, fiber);
5537        null === shellBoundary && (shellBoundary = fiber);
5538      }
5539      function pushOffscreenSuspenseHandler(fiber) {
5540        22 === fiber.tag ? (push(suspenseStackCursor, suspenseStackCursor.current, fiber), push(suspenseHandlerStackCursor, fiber, fiber), null === shellBoundary && (shellBoundary = fiber)) : reuseSuspenseHandlerOnStack(fiber);
5541      }
5542      function reuseSuspenseHandlerOnStack(fiber) {
5543        push(suspenseStackCursor, suspenseStackCursor.current, fiber);
5544        push(
5545          suspenseHandlerStackCursor,
5546          suspenseHandlerStackCursor.current,
5547          fiber
5548        );
5549      }
5550      function popSuspenseHandler(fiber) {
5551        pop(suspenseHandlerStackCursor, fiber);
5552        shellBoundary === fiber && (shellBoundary = null);
5553        pop(suspenseStackCursor, fiber);
5554      }
5555      function findFirstSuspended(row) {
5556        for (var node = row; null !== node; ) {
5557          if (13 === node.tag) {
5558            var state = node.memoizedState;
5559            if (null !== state && (state = state.dehydrated, null === state || isSuspenseInstancePending(state) || isSuspenseInstanceFallback(state)))
5560              return node;
5561          } else if (19 === node.tag && ("forwards" === node.memoizedProps.revealOrder || "backwards" === node.memoizedProps.revealOrder || "unstable_legacy-backwards" === node.memoizedProps.revealOrder || "together" === node.memoizedProps.revealOrder)) {
5562            if (0 !== (node.flags & 128)) return node;
5563          } else if (null !== node.child) {
5564            node.child.return = node;
5565            node = node.child;
5566            continue;
5567          }
5568          if (node === row) break;
5569          for (; null === node.sibling; ) {
5570            if (null === node.return || node.return === row) return null;
5571            node = node.return;
5572          }
5573          node.sibling.return = node.return;
5574          node = node.sibling;
5575        }
5576        return null;
5577      }
5578      function mountHookTypesDev() {
5579        var hookName = currentHookNameInDev;
5580        null === hookTypesDev ? hookTypesDev = [hookName] : hookTypesDev.push(hookName);
5581      }
5582      function updateHookTypesDev() {
5583        var hookName = currentHookNameInDev;
5584        if (null !== hookTypesDev && (hookTypesUpdateIndexDev++, hookTypesDev[hookTypesUpdateIndexDev] !== hookName)) {
5585          var componentName2 = getComponentNameFromFiber(currentlyRenderingFiber);
5586          if (!didWarnAboutMismatchedHooksForComponent.has(componentName2) && (didWarnAboutMismatchedHooksForComponent.add(componentName2), null !== hookTypesDev)) {
5587            for (var table = "", i = 0; i <= hookTypesUpdateIndexDev; i++) {
5588              var oldHookName = hookTypesDev[i], newHookName = i === hookTypesUpdateIndexDev ? hookName : oldHookName;
5589              for (oldHookName = i + 1 + ". " + oldHookName; 30 > oldHookName.length; )
5590                oldHookName += " ";
5591              oldHookName += newHookName + "\n";
5592              table += oldHookName;
5593            }
5594            console.error(
5595              "React has detected a change in the order of Hooks called by %s. This will lead to bugs and errors if not fixed. For more information, read the Rules of Hooks: https://react.dev/link/rules-of-hooks\n\n   Previous render            Next render\n   ------------------------------------------------------\n%s   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n",
5596              componentName2,
5597              table
5598            );
5599          }
5600        }
5601      }
5602      function checkDepsAreArrayDev(deps) {
5603        void 0 === deps || null === deps || isArrayImpl(deps) || console.error(
5604          "%s received a final argument that is not an array (instead, received `%s`). When specified, the final argument must be an array.",
5605          currentHookNameInDev,
5606          typeof deps
5607        );
5608      }
5609      function warnOnUseFormStateInDev() {
5610        var componentName2 = getComponentNameFromFiber(currentlyRenderingFiber);
5611        didWarnAboutUseFormState.has(componentName2) || (didWarnAboutUseFormState.add(componentName2), console.error(
5612          "ReactDOM.useFormState has been renamed to React.useActionState. Please update %s to use React.useActionState.",
5613          componentName2
5614        ));
5615      }
5616      function throwInvalidHookError() {
5617        throw Error(
5618          "Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:\n1. You might have mismatching versions of React and the renderer (such as React DOM)\n2. You might be breaking the Rules of Hooks\n3. You might have more than one copy of React in the same app\nSee https://react.dev/link/invalid-hook-call for tips about how to debug and fix this problem."
5619        );
5620      }
5621      function areHookInputsEqual(nextDeps, prevDeps) {
5622        if (ignorePreviousDependencies) return false;
5623        if (null === prevDeps)
5624          return console.error(
5625            "%s received a final argument during this render, but not during the previous render. Even though the final argument is optional, its type cannot change between renders.",
5626            currentHookNameInDev
5627          ), false;
5628        nextDeps.length !== prevDeps.length && console.error(
5629          "The final argument passed to %s changed size between renders. The order and size of this array must remain constant.\n\nPrevious: %s\nIncoming: %s",
5630          currentHookNameInDev,
5631          "[" + prevDeps.join(", ") + "]",
5632          "[" + nextDeps.join(", ") + "]"
5633        );
5634        for (var i = 0; i < prevDeps.length && i < nextDeps.length; i++)
5635          if (!objectIs(nextDeps[i], prevDeps[i])) return false;
5636        return true;
5637      }
5638      function renderWithHooks(current2, workInProgress2, Component, props, secondArg, nextRenderLanes) {
5639        renderLanes = nextRenderLanes;
5640        currentlyRenderingFiber = workInProgress2;
5641        hookTypesDev = null !== current2 ? current2._debugHookTypes : null;
5642        hookTypesUpdateIndexDev = -1;
5643        ignorePreviousDependencies = null !== current2 && current2.type !== workInProgress2.type;
5644        if ("[object AsyncFunction]" === Object.prototype.toString.call(Component) || "[object AsyncGeneratorFunction]" === Object.prototype.toString.call(Component))
5645          nextRenderLanes = getComponentNameFromFiber(currentlyRenderingFiber), didWarnAboutAsyncClientComponent.has(nextRenderLanes) || (didWarnAboutAsyncClientComponent.add(nextRenderLanes), console.error(
5646            "%s is an async Client Component. Only Server Components can be async at the moment. This error is often caused by accidentally adding `'use client'` to a module that was originally written for the server.",
5647            null === nextRenderLanes ? "An unknown Component" : "<" + nextRenderLanes + ">"
5648          ));
5649        workInProgress2.memoizedState = null;
5650        workInProgress2.updateQueue = null;
5651        workInProgress2.lanes = 0;
5652        ReactSharedInternals.H = null !== current2 && null !== current2.memoizedState ? HooksDispatcherOnUpdateInDEV : null !== hookTypesDev ? HooksDispatcherOnMountWithHookTypesInDEV : HooksDispatcherOnMountInDEV;
5653        shouldDoubleInvokeUserFnsInHooksDEV = nextRenderLanes = (workInProgress2.mode & StrictLegacyMode) !== NoMode;
5654        var children = callComponentInDEV(Component, props, secondArg);
5655        shouldDoubleInvokeUserFnsInHooksDEV = false;
5656        didScheduleRenderPhaseUpdateDuringThisPass && (children = renderWithHooksAgain(
5657          workInProgress2,
5658          Component,
5659          props,
5660          secondArg
5661        ));
5662        if (nextRenderLanes) {
5663          setIsStrictModeForDevtools(true);
5664          try {
5665            children = renderWithHooksAgain(
5666              workInProgress2,
5667              Component,
5668              props,
5669              secondArg
5670            );
5671          } finally {
5672            setIsStrictModeForDevtools(false);
5673          }
5674        }
5675        finishRenderingHooks(current2, workInProgress2);
5676        return children;
5677      }
5678      function finishRenderingHooks(current2, workInProgress2) {
5679        workInProgress2._debugHookTypes = hookTypesDev;
5680        null === workInProgress2.dependencies ? null !== thenableState && (workInProgress2.dependencies = {
5681          lanes: 0,
5682          firstContext: null,
5683          _debugThenableState: thenableState
5684        }) : workInProgress2.dependencies._debugThenableState = thenableState;
5685        ReactSharedInternals.H = ContextOnlyDispatcher;
5686        var didRenderTooFewHooks = null !== currentHook && null !== currentHook.next;
5687        renderLanes = 0;
5688        hookTypesDev = currentHookNameInDev = workInProgressHook = currentHook = currentlyRenderingFiber = null;
5689        hookTypesUpdateIndexDev = -1;
5690        null !== current2 && (current2.flags & 65011712) !== (workInProgress2.flags & 65011712) && console.error(
5691          "Internal React error: Expected static flag was missing. Please notify the React team."
5692        );
5693        didScheduleRenderPhaseUpdate = false;
5694        thenableIndexCounter = 0;
5695        thenableState = null;
5696        if (didRenderTooFewHooks)
5697          throw Error(
5698            "Rendered fewer hooks than expected. This may be caused by an accidental early return statement."
5699          );
5700        null === current2 || didReceiveUpdate || (current2 = current2.dependencies, null !== current2 && checkIfContextChanged(current2) && (didReceiveUpdate = true));
5701        needsToResetSuspendedThenableDEV ? (needsToResetSuspendedThenableDEV = false, current2 = true) : current2 = false;
5702        current2 && (workInProgress2 = getComponentNameFromFiber(workInProgress2) || "Unknown", didWarnAboutUseWrappedInTryCatch.has(workInProgress2) || didWarnAboutAsyncClientComponent.has(workInProgress2) || (didWarnAboutUseWrappedInTryCatch.add(workInProgress2), console.error(
5703          "`use` was called from inside a try/catch block. This is not allowed and can lead to unexpected behavior. To handle errors triggered by `use`, wrap your component in a error boundary."
5704        )));
5705      }
5706      function renderWithHooksAgain(workInProgress2, Component, props, secondArg) {
5707        currentlyRenderingFiber = workInProgress2;
5708        var numberOfReRenders = 0;
5709        do {
5710          didScheduleRenderPhaseUpdateDuringThisPass && (thenableState = null);
5711          thenableIndexCounter = 0;
5712          didScheduleRenderPhaseUpdateDuringThisPass = false;
5713          if (numberOfReRenders >= RE_RENDER_LIMIT)
5714            throw Error(
5715              "Too many re-renders. React limits the number of renders to prevent an infinite loop."
5716            );
5717          numberOfReRenders += 1;
5718          ignorePreviousDependencies = false;
5719          workInProgressHook = currentHook = null;
5720          if (null != workInProgress2.updateQueue) {
5721            var children = workInProgress2.updateQueue;
5722            children.lastEffect = null;
5723            children.events = null;
5724            children.stores = null;
5725            null != children.memoCache && (children.memoCache.index = 0);
5726          }
5727          hookTypesUpdateIndexDev = -1;
5728          ReactSharedInternals.H = HooksDispatcherOnRerenderInDEV;
5729          children = callComponentInDEV(Component, props, secondArg);
5730        } while (didScheduleRenderPhaseUpdateDuringThisPass);
5731        return children;
5732      }
5733      function TransitionAwareHostComponent() {
5734        var dispatcher = ReactSharedInternals.H, maybeThenable = dispatcher.useState()[0];
5735        maybeThenable = "function" === typeof maybeThenable.then ? useThenable(maybeThenable) : maybeThenable;
5736        dispatcher = dispatcher.useState()[0];
5737        (null !== currentHook ? currentHook.memoizedState : null) !== dispatcher && (currentlyRenderingFiber.flags |= 1024);
5738        return maybeThenable;
5739      }
5740      function checkDidRenderIdHook() {
5741        var didRenderIdHook = 0 !== localIdCounter;
5742        localIdCounter = 0;
5743        return didRenderIdHook;
5744      }
5745      function bailoutHooks(current2, workInProgress2, lanes) {
5746        workInProgress2.updateQueue = current2.updateQueue;
5747        workInProgress2.flags = (workInProgress2.mode & StrictEffectsMode) !== NoMode ? workInProgress2.flags & -402655237 : workInProgress2.flags & -2053;
5748        current2.lanes &= ~lanes;
5749      }
5750      function resetHooksOnUnwind(workInProgress2) {
5751        if (didScheduleRenderPhaseUpdate) {
5752          for (workInProgress2 = workInProgress2.memoizedState; null !== workInProgress2; ) {
5753            var queue = workInProgress2.queue;
5754            null !== queue && (queue.pending = null);
5755            workInProgress2 = workInProgress2.next;
5756          }
5757          didScheduleRenderPhaseUpdate = false;
5758        }
5759        renderLanes = 0;
5760        hookTypesDev = workInProgressHook = currentHook = currentlyRenderingFiber = null;
5761        hookTypesUpdateIndexDev = -1;
5762        currentHookNameInDev = null;
5763        didScheduleRenderPhaseUpdateDuringThisPass = false;
5764        thenableIndexCounter = localIdCounter = 0;
5765        thenableState = null;
5766      }
5767      function mountWorkInProgressHook() {
5768        var hook = {
5769          memoizedState: null,
5770          baseState: null,
5771          baseQueue: null,
5772          queue: null,
5773          next: null
5774        };
5775        null === workInProgressHook ? currentlyRenderingFiber.memoizedState = workInProgressHook = hook : workInProgressHook = workInProgressHook.next = hook;
5776        return workInProgressHook;
5777      }
5778      function updateWorkInProgressHook() {
5779        if (null === currentHook) {
5780          var nextCurrentHook = currentlyRenderingFiber.alternate;
5781          nextCurrentHook = null !== nextCurrentHook ? nextCurrentHook.memoizedState : null;
5782        } else nextCurrentHook = currentHook.next;
5783        var nextWorkInProgressHook = null === workInProgressHook ? currentlyRenderingFiber.memoizedState : workInProgressHook.next;
5784        if (null !== nextWorkInProgressHook)
5785          workInProgressHook = nextWorkInProgressHook, currentHook = nextCurrentHook;
5786        else {
5787          if (null === nextCurrentHook) {
5788            if (null === currentlyRenderingFiber.alternate)
5789              throw Error(
5790                "Update hook called on initial render. This is likely a bug in React. Please file an issue."
5791              );
5792            throw Error("Rendered more hooks than during the previous render.");
5793          }
5794          currentHook = nextCurrentHook;
5795          nextCurrentHook = {
5796            memoizedState: currentHook.memoizedState,
5797            baseState: currentHook.baseState,
5798            baseQueue: currentHook.baseQueue,
5799            queue: currentHook.queue,
5800            next: null
5801          };
5802          null === workInProgressHook ? currentlyRenderingFiber.memoizedState = workInProgressHook = nextCurrentHook : workInProgressHook = workInProgressHook.next = nextCurrentHook;
5803        }
5804        return workInProgressHook;
5805      }
5806      function createFunctionComponentUpdateQueue() {
5807        return { lastEffect: null, events: null, stores: null, memoCache: null };
5808      }
5809      function useThenable(thenable) {
5810        var index = thenableIndexCounter;
5811        thenableIndexCounter += 1;
5812        null === thenableState && (thenableState = createThenableState());
5813        thenable = trackUsedThenable(thenableState, thenable, index);
5814        index = currentlyRenderingFiber;
5815        null === (null === workInProgressHook ? index.memoizedState : workInProgressHook.next) && (index = index.alternate, ReactSharedInternals.H = null !== index && null !== index.memoizedState ? HooksDispatcherOnUpdateInDEV : HooksDispatcherOnMountInDEV);
5816        return thenable;
5817      }
5818      function use(usable) {
5819        if (null !== usable && "object" === typeof usable) {
5820          if ("function" === typeof usable.then) return useThenable(usable);
5821          if (usable.$$typeof === REACT_CONTEXT_TYPE) return readContext(usable);
5822        }
5823        throw Error("An unsupported type was passed to use(): " + String(usable));
5824      }
5825      function useMemoCache(size) {
5826        var memoCache = null, updateQueue = currentlyRenderingFiber.updateQueue;
5827        null !== updateQueue && (memoCache = updateQueue.memoCache);
5828        if (null == memoCache) {
5829          var current2 = currentlyRenderingFiber.alternate;
5830          null !== current2 && (current2 = current2.updateQueue, null !== current2 && (current2 = current2.memoCache, null != current2 && (memoCache = {
5831            data: current2.data.map(function(array) {
5832              return array.slice();
5833            }),
5834            index: 0
5835          })));
5836        }
5837        null == memoCache && (memoCache = { data: [], index: 0 });
5838        null === updateQueue && (updateQueue = createFunctionComponentUpdateQueue(), currentlyRenderingFiber.updateQueue = updateQueue);
5839        updateQueue.memoCache = memoCache;
5840        updateQueue = memoCache.data[memoCache.index];
5841        if (void 0 === updateQueue || ignorePreviousDependencies)
5842          for (updateQueue = memoCache.data[memoCache.index] = Array(size), current2 = 0; current2 < size; current2++)
5843            updateQueue[current2] = REACT_MEMO_CACHE_SENTINEL;
5844        else
5845          updateQueue.length !== size && console.error(
5846            "Expected a constant size argument for each invocation of useMemoCache. The previous cache was allocated with size %s but size %s was requested.",
5847            updateQueue.length,
5848            size
5849          );
5850        memoCache.index++;
5851        return updateQueue;
5852      }
5853      function basicStateReducer(state, action) {
5854        return "function" === typeof action ? action(state) : action;
5855      }
5856      function mountReducer(reducer, initialArg, init) {
5857        var hook = mountWorkInProgressHook();
5858        if (void 0 !== init) {
5859          var initialState = init(initialArg);
5860          if (shouldDoubleInvokeUserFnsInHooksDEV) {
5861            setIsStrictModeForDevtools(true);
5862            try {
5863              init(initialArg);
5864            } finally {
5865              setIsStrictModeForDevtools(false);
5866            }
5867          }
5868        } else initialState = initialArg;
5869        hook.memoizedState = hook.baseState = initialState;
5870        reducer = {
5871          pending: null,
5872          lanes: 0,
5873          dispatch: null,
5874          lastRenderedReducer: reducer,
5875          lastRenderedState: initialState
5876        };
5877        hook.queue = reducer;
5878        reducer = reducer.dispatch = dispatchReducerAction.bind(
5879          null,
5880          currentlyRenderingFiber,
5881          reducer
5882        );
5883        return [hook.memoizedState, reducer];
5884      }
5885      function updateReducer(reducer) {
5886        var hook = updateWorkInProgressHook();
5887        return updateReducerImpl(hook, currentHook, reducer);
5888      }
5889      function updateReducerImpl(hook, current2, reducer) {
5890        var queue = hook.queue;
5891        if (null === queue)
5892          throw Error(
5893            "Should have a queue. You are likely calling Hooks conditionally, which is not allowed. (https://react.dev/link/invalid-hook-call)"
5894          );
5895        queue.lastRenderedReducer = reducer;
5896        var baseQueue = hook.baseQueue, pendingQueue = queue.pending;
5897        if (null !== pendingQueue) {
5898          if (null !== baseQueue) {
5899            var baseFirst = baseQueue.next;
5900            baseQueue.next = pendingQueue.next;
5901            pendingQueue.next = baseFirst;
5902          }
5903          current2.baseQueue !== baseQueue && console.error(
5904            "Internal error: Expected work-in-progress queue to be a clone. This is a bug in React."
5905          );
5906          current2.baseQueue = baseQueue = pendingQueue;
5907          queue.pending = null;
5908        }
5909        pendingQueue = hook.baseState;
5910        if (null === baseQueue) hook.memoizedState = pendingQueue;
5911        else {
5912          current2 = baseQueue.next;
5913          var newBaseQueueFirst = baseFirst = null, newBaseQueueLast = null, update = current2, didReadFromEntangledAsyncAction2 = false;
5914          do {
5915            var updateLane = update.lane & -536870913;
5916            if (updateLane !== update.lane ? (workInProgressRootRenderLanes & updateLane) === updateLane : (renderLanes & updateLane) === updateLane) {
5917              var revertLane = update.revertLane;
5918              if (0 === revertLane)
5919                null !== newBaseQueueLast && (newBaseQueueLast = newBaseQueueLast.next = {
5920                  lane: 0,
5921                  revertLane: 0,
5922                  gesture: null,
5923                  action: update.action,
5924                  hasEagerState: update.hasEagerState,
5925                  eagerState: update.eagerState,
5926                  next: null
5927                }), updateLane === currentEntangledLane && (didReadFromEntangledAsyncAction2 = true);
5928              else if ((renderLanes & revertLane) === revertLane) {
5929                update = update.next;
5930                revertLane === currentEntangledLane && (didReadFromEntangledAsyncAction2 = true);
5931                continue;
5932              } else
5933                updateLane = {
5934                  lane: 0,
5935                  revertLane: update.revertLane,
5936                  gesture: null,
5937                  action: update.action,
5938                  hasEagerState: update.hasEagerState,
5939                  eagerState: update.eagerState,
5940                  next: null
5941                }, null === newBaseQueueLast ? (newBaseQueueFirst = newBaseQueueLast = updateLane, baseFirst = pendingQueue) : newBaseQueueLast = newBaseQueueLast.next = updateLane, currentlyRenderingFiber.lanes |= revertLane, workInProgressRootSkippedLanes |= revertLane;
5942              updateLane = update.action;
5943              shouldDoubleInvokeUserFnsInHooksDEV && reducer(pendingQueue, updateLane);
5944              pendingQueue = update.hasEagerState ? update.eagerState : reducer(pendingQueue, updateLane);
5945            } else
5946              revertLane = {
5947                lane: updateLane,
5948                revertLane: update.revertLane,
5949                gesture: update.gesture,
5950                action: update.action,
5951                hasEagerState: update.hasEagerState,
5952                eagerState: update.eagerState,
5953                next: null
5954              }, null === newBaseQueueLast ? (newBaseQueueFirst = newBaseQueueLast = revertLane, baseFirst = pendingQueue) : newBaseQueueLast = newBaseQueueLast.next = revertLane, currentlyRenderingFiber.lanes |= updateLane, workInProgressRootSkippedLanes |= updateLane;
5955            update = update.next;
5956          } while (null !== update && update !== current2);
5957          null === newBaseQueueLast ? baseFirst = pendingQueue : newBaseQueueLast.next = newBaseQueueFirst;
5958          if (!objectIs(pendingQueue, hook.memoizedState) && (didReceiveUpdate = true, didReadFromEntangledAsyncAction2 && (reducer = currentEntangledActionThenable, null !== reducer)))
5959            throw reducer;
5960          hook.memoizedState = pendingQueue;
5961          hook.baseState = baseFirst;
5962          hook.baseQueue = newBaseQueueLast;
5963          queue.lastRenderedState = pendingQueue;
5964        }
5965        null === baseQueue && (queue.lanes = 0);
5966        return [hook.memoizedState, queue.dispatch];
5967      }
5968      function rerenderReducer(reducer) {
5969        var hook = updateWorkInProgressHook(), queue = hook.queue;
5970        if (null === queue)
5971          throw Error(
5972            "Should have a queue. You are likely calling Hooks conditionally, which is not allowed. (https://react.dev/link/invalid-hook-call)"
5973          );
5974        queue.lastRenderedReducer = reducer;
5975        var dispatch = queue.dispatch, lastRenderPhaseUpdate = queue.pending, newState = hook.memoizedState;
5976        if (null !== lastRenderPhaseUpdate) {
5977          queue.pending = null;
5978          var update = lastRenderPhaseUpdate = lastRenderPhaseUpdate.next;
5979          do
5980            newState = reducer(newState, update.action), update = update.next;
5981          while (update !== lastRenderPhaseUpdate);
5982          objectIs(newState, hook.memoizedState) || (didReceiveUpdate = true);
5983          hook.memoizedState = newState;
5984          null === hook.baseQueue && (hook.baseState = newState);
5985          queue.lastRenderedState = newState;
5986        }
5987        return [newState, dispatch];
5988      }
5989      function mountSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
5990        var fiber = currentlyRenderingFiber, hook = mountWorkInProgressHook();
5991        if (isHydrating) {
5992          if (void 0 === getServerSnapshot)
5993            throw Error(
5994              "Missing getServerSnapshot, which is required for server-rendered content. Will revert to client rendering."
5995            );
5996          var nextSnapshot = getServerSnapshot();
5997          didWarnUncachedGetSnapshot || nextSnapshot === getServerSnapshot() || (console.error(
5998            "The result of getServerSnapshot should be cached to avoid an infinite loop"
5999          ), didWarnUncachedGetSnapshot = true);
6000        } else {
6001          nextSnapshot = getSnapshot();
6002          didWarnUncachedGetSnapshot || (getServerSnapshot = getSnapshot(), objectIs(nextSnapshot, getServerSnapshot) || (console.error(
6003            "The result of getSnapshot should be cached to avoid an infinite loop"
6004          ), didWarnUncachedGetSnapshot = true));
6005          if (null === workInProgressRoot)
6006            throw Error(
6007              "Expected a work-in-progress root. This is a bug in React. Please file an issue."
6008            );
6009          0 !== (workInProgressRootRenderLanes & 127) || pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
6010        }
6011        hook.memoizedState = nextSnapshot;
6012        getServerSnapshot = { value: nextSnapshot, getSnapshot };
6013        hook.queue = getServerSnapshot;
6014        mountEffect(
6015          subscribeToStore.bind(null, fiber, getServerSnapshot, subscribe),
6016          [subscribe]
6017        );
6018        fiber.flags |= 2048;
6019        pushSimpleEffect(
6020          HasEffect | Passive,
6021          { destroy: void 0 },
6022          updateStoreInstance.bind(
6023            null,
6024            fiber,
6025            getServerSnapshot,
6026            nextSnapshot,
6027            getSnapshot
6028          ),
6029          null
6030        );
6031        return nextSnapshot;
6032      }
6033      function updateSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
6034        var fiber = currentlyRenderingFiber, hook = updateWorkInProgressHook(), isHydrating$jscomp$0 = isHydrating;
6035        if (isHydrating$jscomp$0) {
6036          if (void 0 === getServerSnapshot)
6037            throw Error(
6038              "Missing getServerSnapshot, which is required for server-rendered content. Will revert to client rendering."
6039            );
6040          getServerSnapshot = getServerSnapshot();
6041        } else if (getServerSnapshot = getSnapshot(), !didWarnUncachedGetSnapshot) {
6042          var cachedSnapshot = getSnapshot();
6043          objectIs(getServerSnapshot, cachedSnapshot) || (console.error(
6044            "The result of getSnapshot should be cached to avoid an infinite loop"
6045          ), didWarnUncachedGetSnapshot = true);
6046        }
6047        if (cachedSnapshot = !objectIs(
6048          (currentHook || hook).memoizedState,
6049          getServerSnapshot
6050        ))
6051          hook.memoizedState = getServerSnapshot, didReceiveUpdate = true;
6052        hook = hook.queue;
6053        var create = subscribeToStore.bind(null, fiber, hook, subscribe);
6054        updateEffectImpl(2048, Passive, create, [subscribe]);
6055        if (hook.getSnapshot !== getSnapshot || cachedSnapshot || null !== workInProgressHook && workInProgressHook.memoizedState.tag & HasEffect) {
6056          fiber.flags |= 2048;
6057          pushSimpleEffect(
6058            HasEffect | Passive,
6059            { destroy: void 0 },
6060            updateStoreInstance.bind(
6061              null,
6062              fiber,
6063              hook,
6064              getServerSnapshot,
6065              getSnapshot
6066            ),
6067            null
6068          );
6069          if (null === workInProgressRoot)
6070            throw Error(
6071              "Expected a work-in-progress root. This is a bug in React. Please file an issue."
6072            );
6073          isHydrating$jscomp$0 || 0 !== (renderLanes & 127) || pushStoreConsistencyCheck(fiber, getSnapshot, getServerSnapshot);
6074        }
6075        return getServerSnapshot;
6076      }
6077      function pushStoreConsistencyCheck(fiber, getSnapshot, renderedSnapshot) {
6078        fiber.flags |= 16384;
6079        fiber = { getSnapshot, value: renderedSnapshot };
6080        getSnapshot = currentlyRenderingFiber.updateQueue;
6081        null === getSnapshot ? (getSnapshot = createFunctionComponentUpdateQueue(), currentlyRenderingFiber.updateQueue = getSnapshot, getSnapshot.stores = [fiber]) : (renderedSnapshot = getSnapshot.stores, null === renderedSnapshot ? getSnapshot.stores = [fiber] : renderedSnapshot.push(fiber));
6082      }
6083      function updateStoreInstance(fiber, inst, nextSnapshot, getSnapshot) {
6084        inst.value = nextSnapshot;
6085        inst.getSnapshot = getSnapshot;
6086        checkIfSnapshotChanged(inst) && forceStoreRerender(fiber);
6087      }
6088      function subscribeToStore(fiber, inst, subscribe) {
6089        return subscribe(function() {
6090          checkIfSnapshotChanged(inst) && (startUpdateTimerByLane(2, "updateSyncExternalStore()", fiber), forceStoreRerender(fiber));
6091        });
6092      }
6093      function checkIfSnapshotChanged(inst) {
6094        var latestGetSnapshot = inst.getSnapshot;
6095        inst = inst.value;
6096        try {
6097          var nextValue = latestGetSnapshot();
6098          return !objectIs(inst, nextValue);
6099        } catch (error) {
6100          return true;
6101        }
6102      }
6103      function forceStoreRerender(fiber) {
6104        var root2 = enqueueConcurrentRenderForLane(fiber, 2);
6105        null !== root2 && scheduleUpdateOnFiber(root2, fiber, 2);
6106      }
6107      function mountStateImpl(initialState) {
6108        var hook = mountWorkInProgressHook();
6109        if ("function" === typeof initialState) {
6110          var initialStateInitializer = initialState;
6111          initialState = initialStateInitializer();
6112          if (shouldDoubleInvokeUserFnsInHooksDEV) {
6113            setIsStrictModeForDevtools(true);
6114            try {
6115              initialStateInitializer();
6116            } finally {
6117              setIsStrictModeForDevtools(false);
6118            }
6119          }
6120        }
6121        hook.memoizedState = hook.baseState = initialState;
6122        hook.queue = {
6123          pending: null,
6124          lanes: 0,
6125          dispatch: null,
6126          lastRenderedReducer: basicStateReducer,
6127          lastRenderedState: initialState
6128        };
6129        return hook;
6130      }
6131      function mountState(initialState) {
6132        initialState = mountStateImpl(initialState);
6133        var queue = initialState.queue, dispatch = dispatchSetState.bind(null, currentlyRenderingFiber, queue);
6134        queue.dispatch = dispatch;
6135        return [initialState.memoizedState, dispatch];
6136      }
6137      function mountOptimistic(passthrough) {
6138        var hook = mountWorkInProgressHook();
6139        hook.memoizedState = hook.baseState = passthrough;
6140        var queue = {
6141          pending: null,
6142          lanes: 0,
6143          dispatch: null,
6144          lastRenderedReducer: null,
6145          lastRenderedState: null
6146        };
6147        hook.queue = queue;
6148        hook = dispatchOptimisticSetState.bind(
6149          null,
6150          currentlyRenderingFiber,
6151          true,
6152          queue
6153        );
6154        queue.dispatch = hook;
6155        return [passthrough, hook];
6156      }
6157      function updateOptimistic(passthrough, reducer) {
6158        var hook = updateWorkInProgressHook();
6159        return updateOptimisticImpl(hook, currentHook, passthrough, reducer);
6160      }
6161      function updateOptimisticImpl(hook, current2, passthrough, reducer) {
6162        hook.baseState = passthrough;
6163        return updateReducerImpl(
6164          hook,
6165          currentHook,
6166          "function" === typeof reducer ? reducer : basicStateReducer
6167        );
6168      }
6169      function rerenderOptimistic(passthrough, reducer) {
6170        var hook = updateWorkInProgressHook();
6171        if (null !== currentHook)
6172          return updateOptimisticImpl(hook, currentHook, passthrough, reducer);
6173        hook.baseState = passthrough;
6174        return [passthrough, hook.queue.dispatch];
6175      }
6176      function dispatchActionState(fiber, actionQueue, setPendingState, setState, payload) {
6177        if (isRenderPhaseUpdate(fiber))
6178          throw Error("Cannot update form state while rendering.");
6179        fiber = actionQueue.action;
6180        if (null !== fiber) {
6181          var actionNode = {
6182            payload,
6183            action: fiber,
6184            next: null,
6185            isTransition: true,
6186            status: "pending",
6187            value: null,
6188            reason: null,
6189            listeners: [],
6190            then: function(listener) {
6191              actionNode.listeners.push(listener);
6192            }
6193          };
6194          null !== ReactSharedInternals.T ? setPendingState(true) : actionNode.isTransition = false;
6195          setState(actionNode);
6196          setPendingState = actionQueue.pending;
6197          null === setPendingState ? (actionNode.next = actionQueue.pending = actionNode, runActionStateAction(actionQueue, actionNode)) : (actionNode.next = setPendingState.next, actionQueue.pending = setPendingState.next = actionNode);
6198        }
6199      }
6200      function runActionStateAction(actionQueue, node) {
6201        var action = node.action, payload = node.payload, prevState = actionQueue.state;
6202        if (node.isTransition) {
6203          var prevTransition = ReactSharedInternals.T, currentTransition = {};
6204          currentTransition._updatedFibers = /* @__PURE__ */ new Set();
6205          ReactSharedInternals.T = currentTransition;
6206          try {
6207            var returnValue = action(prevState, payload), onStartTransitionFinish = ReactSharedInternals.S;
6208            null !== onStartTransitionFinish && onStartTransitionFinish(currentTransition, returnValue);
6209            handleActionReturnValue(actionQueue, node, returnValue);
6210          } catch (error) {
6211            onActionError(actionQueue, node, error);
6212          } finally {
6213            null !== prevTransition && null !== currentTransition.types && (null !== prevTransition.types && prevTransition.types !== currentTransition.types && console.error(
6214              "We expected inner Transitions to have transferred the outer types set and that you cannot add to the outer Transition while inside the inner.This is a bug in React."
6215            ), prevTransition.types = currentTransition.types), ReactSharedInternals.T = prevTransition, null === prevTransition && currentTransition._updatedFibers && (actionQueue = currentTransition._updatedFibers.size, currentTransition._updatedFibers.clear(), 10 < actionQueue && console.warn(
6216              "Detected a large number of updates inside startTransition. If this is due to a subscription please re-write it to use React provided hooks. Otherwise concurrent mode guarantees are off the table."
6217            ));
6218          }
6219        } else
6220          try {
6221            currentTransition = action(prevState, payload), handleActionReturnValue(actionQueue, node, currentTransition);
6222          } catch (error$4) {
6223            onActionError(actionQueue, node, error$4);
6224          }
6225      }
6226      function handleActionReturnValue(actionQueue, node, returnValue) {
6227        null !== returnValue && "object" === typeof returnValue && "function" === typeof returnValue.then ? (ReactSharedInternals.asyncTransitions++, returnValue.then(releaseAsyncTransition, releaseAsyncTransition), returnValue.then(
6228          function(nextState) {
6229            onActionSuccess(actionQueue, node, nextState);
6230          },
6231          function(error) {
6232            return onActionError(actionQueue, node, error);
6233          }
6234        ), node.isTransition || console.error(
6235          "An async function with useActionState was called outside of a transition. This is likely not what you intended (for example, isPending will not update correctly). Either call the returned function inside startTransition, or pass it to an `action` or `formAction` prop."
6236        )) : onActionSuccess(actionQueue, node, returnValue);
6237      }
6238      function onActionSuccess(actionQueue, actionNode, nextState) {
6239        actionNode.status = "fulfilled";
6240        actionNode.value = nextState;
6241        notifyActionListeners(actionNode);
6242        actionQueue.state = nextState;
6243        actionNode = actionQueue.pending;
6244        null !== actionNode && (nextState = actionNode.next, nextState === actionNode ? actionQueue.pending = null : (nextState = nextState.next, actionNode.next = nextState, runActionStateAction(actionQueue, nextState)));
6245      }
6246      function onActionError(actionQueue, actionNode, error) {
6247        var last = actionQueue.pending;
6248        actionQueue.pending = null;
6249        if (null !== last) {
6250          last = last.next;
6251          do
6252            actionNode.status = "rejected", actionNode.reason = error, notifyActionListeners(actionNode), actionNode = actionNode.next;
6253          while (actionNode !== last);
6254        }
6255        actionQueue.action = null;
6256      }
6257      function notifyActionListeners(actionNode) {
6258        actionNode = actionNode.listeners;
6259        for (var i = 0; i < actionNode.length; i++) (0, actionNode[i])();
6260      }
6261      function actionStateReducer(oldState, newState) {
6262        return newState;
6263      }
6264      function mountActionState(action, initialStateProp) {
6265        if (isHydrating) {
6266          var ssrFormState = workInProgressRoot.formState;
6267          if (null !== ssrFormState) {
6268            a: {
6269              var isMatching = currentlyRenderingFiber;
6270              if (isHydrating) {
6271                if (nextHydratableInstance) {
6272                  b: {
6273                    var markerInstance = nextHydratableInstance;
6274                    for (var inRootOrSingleton = rootOrSingletonContext; 8 !== markerInstance.nodeType; ) {
6275                      if (!inRootOrSingleton) {
6276                        markerInstance = null;
6277                        break b;
6278                      }
6279                      markerInstance = getNextHydratable(
6280                        markerInstance.nextSibling
6281                      );
6282                      if (null === markerInstance) {
6283                        markerInstance = null;
6284                        break b;
6285                      }
6286                    }
6287                    inRootOrSingleton = markerInstance.data;
6288                    markerInstance = inRootOrSingleton === FORM_STATE_IS_MATCHING || inRootOrSingleton === FORM_STATE_IS_NOT_MATCHING ? markerInstance : null;
6289                  }
6290                  if (markerInstance) {
6291                    nextHydratableInstance = getNextHydratable(
6292                      markerInstance.nextSibling
6293                    );
6294                    isMatching = markerInstance.data === FORM_STATE_IS_MATCHING;
6295                    break a;
6296                  }
6297                }
6298                throwOnHydrationMismatch(isMatching);
6299              }
6300              isMatching = false;
6301            }
6302            isMatching && (initialStateProp = ssrFormState[0]);
6303          }
6304        }
6305        ssrFormState = mountWorkInProgressHook();
6306        ssrFormState.memoizedState = ssrFormState.baseState = initialStateProp;
6307        isMatching = {
6308          pending: null,
6309          lanes: 0,
6310          dispatch: null,
6311          lastRenderedReducer: actionStateReducer,
6312          lastRenderedState: initialStateProp
6313        };
6314        ssrFormState.queue = isMatching;
6315        ssrFormState = dispatchSetState.bind(
6316          null,
6317          currentlyRenderingFiber,
6318          isMatching
6319        );
6320        isMatching.dispatch = ssrFormState;
6321        isMatching = mountStateImpl(false);
6322        inRootOrSingleton = dispatchOptimisticSetState.bind(
6323          null,
6324          currentlyRenderingFiber,
6325          false,
6326          isMatching.queue
6327        );
6328        isMatching = mountWorkInProgressHook();
6329        markerInstance = {
6330          state: initialStateProp,
6331          dispatch: null,
6332          action,
6333          pending: null
6334        };
6335        isMatching.queue = markerInstance;
6336        ssrFormState = dispatchActionState.bind(
6337          null,
6338          currentlyRenderingFiber,
6339          markerInstance,
6340          inRootOrSingleton,
6341          ssrFormState
6342        );
6343        markerInstance.dispatch = ssrFormState;
6344        isMatching.memoizedState = action;
6345        return [initialStateProp, ssrFormState, false];
6346      }
6347      function updateActionState(action) {
6348        var stateHook = updateWorkInProgressHook();
6349        return updateActionStateImpl(stateHook, currentHook, action);
6350      }
6351      function updateActionStateImpl(stateHook, currentStateHook, action) {
6352        currentStateHook = updateReducerImpl(
6353          stateHook,
6354          currentStateHook,
6355          actionStateReducer
6356        )[0];
6357        stateHook = updateReducer(basicStateReducer)[0];
6358        if ("object" === typeof currentStateHook && null !== currentStateHook && "function" === typeof currentStateHook.then)
6359          try {
6360            var state = useThenable(currentStateHook);
6361          } catch (x) {
6362            if (x === SuspenseException) throw SuspenseActionException;
6363            throw x;
6364          }
6365        else state = currentStateHook;
6366        currentStateHook = updateWorkInProgressHook();
6367        var actionQueue = currentStateHook.queue, dispatch = actionQueue.dispatch;
6368        action !== currentStateHook.memoizedState && (currentlyRenderingFiber.flags |= 2048, pushSimpleEffect(
6369          HasEffect | Passive,
6370          { destroy: void 0 },
6371          actionStateActionEffect.bind(null, actionQueue, action),
6372          null
6373        ));
6374        return [state, dispatch, stateHook];
6375      }
6376      function actionStateActionEffect(actionQueue, action) {
6377        actionQueue.action = action;
6378      }
6379      function rerenderActionState(action) {
6380        var stateHook = updateWorkInProgressHook(), currentStateHook = currentHook;
6381        if (null !== currentStateHook)
6382          return updateActionStateImpl(stateHook, currentStateHook, action);
6383        updateWorkInProgressHook();
6384        stateHook = stateHook.memoizedState;
6385        currentStateHook = updateWorkInProgressHook();
6386        var dispatch = currentStateHook.queue.dispatch;
6387        currentStateHook.memoizedState = action;
6388        return [stateHook, dispatch, false];
6389      }
6390      function pushSimpleEffect(tag, inst, create, deps) {
6391        tag = { tag, create, deps, inst, next: null };
6392        inst = currentlyRenderingFiber.updateQueue;
6393        null === inst && (inst = createFunctionComponentUpdateQueue(), currentlyRenderingFiber.updateQueue = inst);
6394        create = inst.lastEffect;
6395        null === create ? inst.lastEffect = tag.next = tag : (deps = create.next, create.next = tag, tag.next = deps, inst.lastEffect = tag);
6396        return tag;
6397      }
6398      function mountRef(initialValue) {
6399        var hook = mountWorkInProgressHook();
6400        initialValue = { current: initialValue };
6401        return hook.memoizedState = initialValue;
6402      }
6403      function mountEffectImpl(fiberFlags, hookFlags, create, deps) {
6404        var hook = mountWorkInProgressHook();
6405        currentlyRenderingFiber.flags |= fiberFlags;
6406        hook.memoizedState = pushSimpleEffect(
6407          HasEffect | hookFlags,
6408          { destroy: void 0 },
6409          create,
6410          void 0 === deps ? null : deps
6411        );
6412      }
6413      function updateEffectImpl(fiberFlags, hookFlags, create, deps) {
6414        var hook = updateWorkInProgressHook();
6415        deps = void 0 === deps ? null : deps;
6416        var inst = hook.memoizedState.inst;
6417        null !== currentHook && null !== deps && areHookInputsEqual(deps, currentHook.memoizedState.deps) ? hook.memoizedState = pushSimpleEffect(hookFlags, inst, create, deps) : (currentlyRenderingFiber.flags |= fiberFlags, hook.memoizedState = pushSimpleEffect(
6418          HasEffect | hookFlags,
6419          inst,
6420          create,
6421          deps
6422        ));
6423      }
6424      function mountEffect(create, deps) {
6425        (currentlyRenderingFiber.mode & StrictEffectsMode) !== NoMode ? mountEffectImpl(276826112, Passive, create, deps) : mountEffectImpl(8390656, Passive, create, deps);
6426      }
6427      function useEffectEventImpl(payload) {
6428        currentlyRenderingFiber.flags |= 4;
6429        var componentUpdateQueue = currentlyRenderingFiber.updateQueue;
6430        if (null === componentUpdateQueue)
6431          componentUpdateQueue = createFunctionComponentUpdateQueue(), currentlyRenderingFiber.updateQueue = componentUpdateQueue, componentUpdateQueue.events = [payload];
6432        else {
6433          var events = componentUpdateQueue.events;
6434          null === events ? componentUpdateQueue.events = [payload] : events.push(payload);
6435        }
6436      }
6437      function mountEvent(callback) {
6438        var hook = mountWorkInProgressHook(), ref = { impl: callback };
6439        hook.memoizedState = ref;
6440        return function() {
6441          if ((executionContext & RenderContext) !== NoContext)
6442            throw Error(
6443              "A function wrapped in useEffectEvent can't be called during rendering."
6444            );
6445          return ref.impl.apply(void 0, arguments);
6446        };
6447      }
6448      function updateEvent(callback) {
6449        var ref = updateWorkInProgressHook().memoizedState;
6450        useEffectEventImpl({ ref, nextImpl: callback });
6451        return function() {
6452          if ((executionContext & RenderContext) !== NoContext)
6453            throw Error(
6454              "A function wrapped in useEffectEvent can't be called during rendering."
6455            );
6456          return ref.impl.apply(void 0, arguments);
6457        };
6458      }
6459      function mountLayoutEffect(create, deps) {
6460        var fiberFlags = 4194308;
6461        (currentlyRenderingFiber.mode & StrictEffectsMode) !== NoMode && (fiberFlags |= 134217728);
6462        return mountEffectImpl(fiberFlags, Layout, create, deps);
6463      }
6464      function imperativeHandleEffect(create, ref) {
6465        if ("function" === typeof ref) {
6466          create = create();
6467          var refCleanup = ref(create);
6468          return function() {
6469            "function" === typeof refCleanup ? refCleanup() : ref(null);
6470          };
6471        }
6472        if (null !== ref && void 0 !== ref)
6473          return ref.hasOwnProperty("current") || console.error(
6474            "Expected useImperativeHandle() first argument to either be a ref callback or React.createRef() object. Instead received: %s.",
6475            "an object with keys {" + Object.keys(ref).join(", ") + "}"
6476          ), create = create(), ref.current = create, function() {
6477            ref.current = null;
6478          };
6479      }
6480      function mountImperativeHandle(ref, create, deps) {
6481        "function" !== typeof create && console.error(
6482          "Expected useImperativeHandle() second argument to be a function that creates a handle. Instead received: %s.",
6483          null !== create ? typeof create : "null"
6484        );
6485        deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
6486        var fiberFlags = 4194308;
6487        (currentlyRenderingFiber.mode & StrictEffectsMode) !== NoMode && (fiberFlags |= 134217728);
6488        mountEffectImpl(
6489          fiberFlags,
6490          Layout,
6491          imperativeHandleEffect.bind(null, create, ref),
6492          deps
6493        );
6494      }
6495      function updateImperativeHandle(ref, create, deps) {
6496        "function" !== typeof create && console.error(
6497          "Expected useImperativeHandle() second argument to be a function that creates a handle. Instead received: %s.",
6498          null !== create ? typeof create : "null"
6499        );
6500        deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
6501        updateEffectImpl(
6502          4,
6503          Layout,
6504          imperativeHandleEffect.bind(null, create, ref),
6505          deps
6506        );
6507      }
6508      function mountCallback(callback, deps) {
6509        mountWorkInProgressHook().memoizedState = [
6510          callback,
6511          void 0 === deps ? null : deps
6512        ];
6513        return callback;
6514      }
6515      function updateCallback(callback, deps) {
6516        var hook = updateWorkInProgressHook();
6517        deps = void 0 === deps ? null : deps;
6518        var prevState = hook.memoizedState;
6519        if (null !== deps && areHookInputsEqual(deps, prevState[1]))
6520          return prevState[0];
6521        hook.memoizedState = [callback, deps];
6522        return callback;
6523      }
6524      function mountMemo(nextCreate, deps) {
6525        var hook = mountWorkInProgressHook();
6526        deps = void 0 === deps ? null : deps;
6527        var nextValue = nextCreate();
6528        if (shouldDoubleInvokeUserFnsInHooksDEV) {
6529          setIsStrictModeForDevtools(true);
6530          try {
6531            nextCreate();
6532          } finally {
6533            setIsStrictModeForDevtools(false);
6534          }
6535        }
6536        hook.memoizedState = [nextValue, deps];
6537        return nextValue;
6538      }
6539      function updateMemo(nextCreate, deps) {
6540        var hook = updateWorkInProgressHook();
6541        deps = void 0 === deps ? null : deps;
6542        var prevState = hook.memoizedState;
6543        if (null !== deps && areHookInputsEqual(deps, prevState[1]))
6544          return prevState[0];
6545        prevState = nextCreate();
6546        if (shouldDoubleInvokeUserFnsInHooksDEV) {
6547          setIsStrictModeForDevtools(true);
6548          try {
6549            nextCreate();
6550          } finally {
6551            setIsStrictModeForDevtools(false);
6552          }
6553        }
6554        hook.memoizedState = [prevState, deps];
6555        return prevState;
6556      }
6557      function mountDeferredValue(value, initialValue) {
6558        var hook = mountWorkInProgressHook();
6559        return mountDeferredValueImpl(hook, value, initialValue);
6560      }
6561      function updateDeferredValue(value, initialValue) {
6562        var hook = updateWorkInProgressHook();
6563        return updateDeferredValueImpl(
6564          hook,
6565          currentHook.memoizedState,
6566          value,
6567          initialValue
6568        );
6569      }
6570      function rerenderDeferredValue(value, initialValue) {
6571        var hook = updateWorkInProgressHook();
6572        return null === currentHook ? mountDeferredValueImpl(hook, value, initialValue) : updateDeferredValueImpl(
6573          hook,
6574          currentHook.memoizedState,
6575          value,
6576          initialValue
6577        );
6578      }
6579      function mountDeferredValueImpl(hook, value, initialValue) {
6580        if (void 0 === initialValue || 0 !== (renderLanes & 1073741824) && 0 === (workInProgressRootRenderLanes & 261930))
6581          return hook.memoizedState = value;
6582        hook.memoizedState = initialValue;
6583        hook = requestDeferredLane();
6584        currentlyRenderingFiber.lanes |= hook;
6585        workInProgressRootSkippedLanes |= hook;
6586        return initialValue;
6587      }
6588      function updateDeferredValueImpl(hook, prevValue, value, initialValue) {
6589        if (objectIs(value, prevValue)) return value;
6590        if (null !== currentTreeHiddenStackCursor.current)
6591          return hook = mountDeferredValueImpl(hook, value, initialValue), objectIs(hook, prevValue) || (didReceiveUpdate = true), hook;
6592        if (0 === (renderLanes & 42) || 0 !== (renderLanes & 1073741824) && 0 === (workInProgressRootRenderLanes & 261930))
6593          return didReceiveUpdate = true, hook.memoizedState = value;
6594        hook = requestDeferredLane();
6595        currentlyRenderingFiber.lanes |= hook;
6596        workInProgressRootSkippedLanes |= hook;
6597        return prevValue;
6598      }
6599      function releaseAsyncTransition() {
6600        ReactSharedInternals.asyncTransitions--;
6601      }
6602      function startTransition(fiber, queue, pendingState, finishedState, callback) {
6603        var previousPriority = ReactDOMSharedInternals.p;
6604        ReactDOMSharedInternals.p = 0 !== previousPriority && previousPriority < ContinuousEventPriority ? previousPriority : ContinuousEventPriority;
6605        var prevTransition = ReactSharedInternals.T, currentTransition = {};
6606        currentTransition._updatedFibers = /* @__PURE__ */ new Set();
6607        ReactSharedInternals.T = currentTransition;
6608        dispatchOptimisticSetState(fiber, false, queue, pendingState);
6609        try {
6610          var returnValue = callback(), onStartTransitionFinish = ReactSharedInternals.S;
6611          null !== onStartTransitionFinish && onStartTransitionFinish(currentTransition, returnValue);
6612          if (null !== returnValue && "object" === typeof returnValue && "function" === typeof returnValue.then) {
6613            ReactSharedInternals.asyncTransitions++;
6614            returnValue.then(releaseAsyncTransition, releaseAsyncTransition);
6615            var thenableForFinishedState = chainThenableValue(
6616              returnValue,
6617              finishedState
6618            );
6619            dispatchSetStateInternal(
6620              fiber,
6621              queue,
6622              thenableForFinishedState,
6623              requestUpdateLane(fiber)
6624            );
6625          } else
6626            dispatchSetStateInternal(
6627              fiber,
6628              queue,
6629              finishedState,
6630              requestUpdateLane(fiber)
6631            );
6632        } catch (error) {
6633          dispatchSetStateInternal(
6634            fiber,
6635            queue,
6636            { then: function() {
6637            }, status: "rejected", reason: error },
6638            requestUpdateLane(fiber)
6639          );
6640        } finally {
6641          ReactDOMSharedInternals.p = previousPriority, null !== prevTransition && null !== currentTransition.types && (null !== prevTransition.types && prevTransition.types !== currentTransition.types && console.error(
6642            "We expected inner Transitions to have transferred the outer types set and that you cannot add to the outer Transition while inside the inner.This is a bug in React."
6643          ), prevTransition.types = currentTransition.types), ReactSharedInternals.T = prevTransition, null === prevTransition && currentTransition._updatedFibers && (fiber = currentTransition._updatedFibers.size, currentTransition._updatedFibers.clear(), 10 < fiber && console.warn(
6644            "Detected a large number of updates inside startTransition. If this is due to a subscription please re-write it to use React provided hooks. Otherwise concurrent mode guarantees are off the table."
6645          ));
6646        }
6647      }
6648      function startHostTransition(formFiber, pendingState, action, formData) {
6649        if (5 !== formFiber.tag)
6650          throw Error(
6651            "Expected the form instance to be a HostComponent. This is a bug in React."
6652          );
6653        var queue = ensureFormComponentIsStateful(formFiber).queue;
6654        startHostActionTimer(formFiber);
6655        startTransition(
6656          formFiber,
6657          queue,
6658          pendingState,
6659          NotPendingTransition,
6660          null === action ? noop : function() {
6661            requestFormReset$1(formFiber);
6662            return action(formData);
6663          }
6664        );
6665      }
6666      function ensureFormComponentIsStateful(formFiber) {
6667        var existingStateHook = formFiber.memoizedState;
6668        if (null !== existingStateHook) return existingStateHook;
6669        existingStateHook = {
6670          memoizedState: NotPendingTransition,
6671          baseState: NotPendingTransition,
6672          baseQueue: null,
6673          queue: {
6674            pending: null,
6675            lanes: 0,
6676            dispatch: null,
6677            lastRenderedReducer: basicStateReducer,
6678            lastRenderedState: NotPendingTransition
6679          },
6680          next: null
6681        };
6682        var initialResetState = {};
6683        existingStateHook.next = {
6684          memoizedState: initialResetState,
6685          baseState: initialResetState,
6686          baseQueue: null,
6687          queue: {
6688            pending: null,
6689            lanes: 0,
6690            dispatch: null,
6691            lastRenderedReducer: basicStateReducer,
6692            lastRenderedState: initialResetState
6693          },
6694          next: null
6695        };
6696        formFiber.memoizedState = existingStateHook;
6697        formFiber = formFiber.alternate;
6698        null !== formFiber && (formFiber.memoizedState = existingStateHook);
6699        return existingStateHook;
6700      }
6701      function requestFormReset$1(formFiber) {
6702        null === ReactSharedInternals.T && console.error(
6703          "requestFormReset was called outside a transition or action. To fix, move to an action, or wrap with startTransition."
6704        );
6705        var stateHook = ensureFormComponentIsStateful(formFiber);
6706        null === stateHook.next && (stateHook = formFiber.alternate.memoizedState);
6707        dispatchSetStateInternal(
6708          formFiber,
6709          stateHook.next.queue,
6710          {},
6711          requestUpdateLane(formFiber)
6712        );
6713      }
6714      function mountTransition() {
6715        var stateHook = mountStateImpl(false);
6716        stateHook = startTransition.bind(
6717          null,
6718          currentlyRenderingFiber,
6719          stateHook.queue,
6720          true,
6721          false
6722        );
6723        mountWorkInProgressHook().memoizedState = stateHook;
6724        return [false, stateHook];
6725      }
6726      function updateTransition() {
6727        var booleanOrThenable = updateReducer(basicStateReducer)[0], start = updateWorkInProgressHook().memoizedState;
6728        return [
6729          "boolean" === typeof booleanOrThenable ? booleanOrThenable : useThenable(booleanOrThenable),
6730          start
6731        ];
6732      }
6733      function rerenderTransition() {
6734        var booleanOrThenable = rerenderReducer(basicStateReducer)[0], start = updateWorkInProgressHook().memoizedState;
6735        return [
6736          "boolean" === typeof booleanOrThenable ? booleanOrThenable : useThenable(booleanOrThenable),
6737          start
6738        ];
6739      }
6740      function useHostTransitionStatus() {
6741        return readContext(HostTransitionContext);
6742      }
6743      function mountId() {
6744        var hook = mountWorkInProgressHook(), identifierPrefix = workInProgressRoot.identifierPrefix;
6745        if (isHydrating) {
6746          var treeId = treeContextOverflow;
6747          var idWithLeadingBit = treeContextId;
6748          treeId = (idWithLeadingBit & ~(1 << 32 - clz32(idWithLeadingBit) - 1)).toString(32) + treeId;
6749          identifierPrefix = "_" + identifierPrefix + "R_" + treeId;
6750          treeId = localIdCounter++;
6751          0 < treeId && (identifierPrefix += "H" + treeId.toString(32));
6752          identifierPrefix += "_";
6753        } else
6754          treeId = globalClientIdCounter++, identifierPrefix = "_" + identifierPrefix + "r_" + treeId.toString(32) + "_";
6755        return hook.memoizedState = identifierPrefix;
6756      }
6757      function mountRefresh() {
6758        return mountWorkInProgressHook().memoizedState = refreshCache.bind(
6759          null,
6760          currentlyRenderingFiber
6761        );
6762      }
6763      function refreshCache(fiber, seedKey) {
6764        for (var provider = fiber.return; null !== provider; ) {
6765          switch (provider.tag) {
6766            case 24:
6767            case 3:
6768              var lane = requestUpdateLane(provider), refreshUpdate = createUpdate(lane), root2 = enqueueUpdate(provider, refreshUpdate, lane);
6769              null !== root2 && (startUpdateTimerByLane(lane, "refresh()", fiber), scheduleUpdateOnFiber(root2, provider, lane), entangleTransitions(root2, provider, lane));
6770              fiber = createCache();
6771              null !== seedKey && void 0 !== seedKey && null !== root2 && console.error(
6772                "The seed argument is not enabled outside experimental channels."
6773              );
6774              refreshUpdate.payload = { cache: fiber };
6775              return;
6776          }
6777          provider = provider.return;
6778        }
6779      }
6780      function dispatchReducerAction(fiber, queue, action) {
6781        var args = arguments;
6782        "function" === typeof args[3] && console.error(
6783          "State updates from the useState() and useReducer() Hooks don't support the second callback argument. To execute a side effect after rendering, declare it in the component body with useEffect()."
6784        );
6785        args = requestUpdateLane(fiber);
6786        var update = {
6787          lane: args,
6788          revertLane: 0,
6789          gesture: null,
6790          action,
6791          hasEagerState: false,
6792          eagerState: null,
6793          next: null
6794        };
6795        isRenderPhaseUpdate(fiber) ? enqueueRenderPhaseUpdate(queue, update) : (update = enqueueConcurrentHookUpdate(fiber, queue, update, args), null !== update && (startUpdateTimerByLane(args, "dispatch()", fiber), scheduleUpdateOnFiber(update, fiber, args), entangleTransitionUpdate(update, queue, args)));
6796      }
6797      function dispatchSetState(fiber, queue, action) {
6798        var args = arguments;
6799        "function" === typeof args[3] && console.error(
6800          "State updates from the useState() and useReducer() Hooks don't support the second callback argument. To execute a side effect after rendering, declare it in the component body with useEffect()."
6801        );
6802        args = requestUpdateLane(fiber);
6803        dispatchSetStateInternal(fiber, queue, action, args) && startUpdateTimerByLane(args, "setState()", fiber);
6804      }
6805      function dispatchSetStateInternal(fiber, queue, action, lane) {
6806        var update = {
6807          lane,
6808          revertLane: 0,
6809          gesture: null,
6810          action,
6811          hasEagerState: false,
6812          eagerState: null,
6813          next: null
6814        };
6815        if (isRenderPhaseUpdate(fiber)) enqueueRenderPhaseUpdate(queue, update);
6816        else {
6817          var alternate = fiber.alternate;
6818          if (0 === fiber.lanes && (null === alternate || 0 === alternate.lanes) && (alternate = queue.lastRenderedReducer, null !== alternate)) {
6819            var prevDispatcher = ReactSharedInternals.H;
6820            ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
6821            try {
6822              var currentState = queue.lastRenderedState, eagerState = alternate(currentState, action);
6823              update.hasEagerState = true;
6824              update.eagerState = eagerState;
6825              if (objectIs(eagerState, currentState))
6826                return enqueueUpdate$1(fiber, queue, update, 0), null === workInProgressRoot && finishQueueingConcurrentUpdates(), false;
6827            } catch (error) {
6828            } finally {
6829              ReactSharedInternals.H = prevDispatcher;
6830            }
6831          }
6832          action = enqueueConcurrentHookUpdate(fiber, queue, update, lane);
6833          if (null !== action)
6834            return scheduleUpdateOnFiber(action, fiber, lane), entangleTransitionUpdate(action, queue, lane), true;
6835        }
6836        return false;
6837      }
6838      function dispatchOptimisticSetState(fiber, throwIfDuringRender, queue, action) {
6839        null === ReactSharedInternals.T && 0 === currentEntangledLane && console.error(
6840          "An optimistic state update occurred outside a transition or action. To fix, move the update to an action, or wrap with startTransition."
6841        );
6842        action = {
6843          lane: 2,
6844          revertLane: requestTransitionLane(),
6845          gesture: null,
6846          action,
6847          hasEagerState: false,
6848          eagerState: null,
6849          next: null
6850        };
6851        if (isRenderPhaseUpdate(fiber)) {
6852          if (throwIfDuringRender)
6853            throw Error("Cannot update optimistic state while rendering.");
6854          console.error("Cannot call startTransition while rendering.");
6855        } else
6856          throwIfDuringRender = enqueueConcurrentHookUpdate(
6857            fiber,
6858            queue,
6859            action,
6860            2
6861          ), null !== throwIfDuringRender && (startUpdateTimerByLane(2, "setOptimistic()", fiber), scheduleUpdateOnFiber(throwIfDuringRender, fiber, 2));
6862      }
6863      function isRenderPhaseUpdate(fiber) {
6864        var alternate = fiber.alternate;
6865        return fiber === currentlyRenderingFiber || null !== alternate && alternate === currentlyRenderingFiber;
6866      }
6867      function enqueueRenderPhaseUpdate(queue, update) {
6868        didScheduleRenderPhaseUpdateDuringThisPass = didScheduleRenderPhaseUpdate = true;
6869        var pending = queue.pending;
6870        null === pending ? update.next = update : (update.next = pending.next, pending.next = update);
6871        queue.pending = update;
6872      }
6873      function entangleTransitionUpdate(root2, queue, lane) {
6874        if (0 !== (lane & 4194048)) {
6875          var queueLanes = queue.lanes;
6876          queueLanes &= root2.pendingLanes;
6877          lane |= queueLanes;
6878          queue.lanes = lane;
6879          markRootEntangled(root2, lane);
6880        }
6881      }
6882      function warnOnInvalidCallback(callback) {
6883        if (null !== callback && "function" !== typeof callback) {
6884          var key = String(callback);
6885          didWarnOnInvalidCallback.has(key) || (didWarnOnInvalidCallback.add(key), console.error(
6886            "Expected the last optional `callback` argument to be a function. Instead received: %s.",
6887            callback
6888          ));
6889        }
6890      }
6891      function applyDerivedStateFromProps(workInProgress2, ctor, getDerivedStateFromProps, nextProps) {
6892        var prevState = workInProgress2.memoizedState, partialState = getDerivedStateFromProps(nextProps, prevState);
6893        if (workInProgress2.mode & StrictLegacyMode) {
6894          setIsStrictModeForDevtools(true);
6895          try {
6896            partialState = getDerivedStateFromProps(nextProps, prevState);
6897          } finally {
6898            setIsStrictModeForDevtools(false);
6899          }
6900        }
6901        void 0 === partialState && (ctor = getComponentNameFromType(ctor) || "Component", didWarnAboutUndefinedDerivedState.has(ctor) || (didWarnAboutUndefinedDerivedState.add(ctor), console.error(
6902          "%s.getDerivedStateFromProps(): A valid state object (or null) must be returned. You have returned undefined.",
6903          ctor
6904        )));
6905        prevState = null === partialState || void 0 === partialState ? prevState : assign({}, prevState, partialState);
6906        workInProgress2.memoizedState = prevState;
6907        0 === workInProgress2.lanes && (workInProgress2.updateQueue.baseState = prevState);
6908      }
6909      function checkShouldComponentUpdate(workInProgress2, ctor, oldProps, newProps, oldState, newState, nextContext) {
6910        var instance = workInProgress2.stateNode;
6911        if ("function" === typeof instance.shouldComponentUpdate) {
6912          oldProps = instance.shouldComponentUpdate(
6913            newProps,
6914            newState,
6915            nextContext
6916          );
6917          if (workInProgress2.mode & StrictLegacyMode) {
6918            setIsStrictModeForDevtools(true);
6919            try {
6920              oldProps = instance.shouldComponentUpdate(
6921                newProps,
6922                newState,
6923                nextContext
6924              );
6925            } finally {
6926              setIsStrictModeForDevtools(false);
6927            }
6928          }
6929          void 0 === oldProps && console.error(
6930            "%s.shouldComponentUpdate(): Returned undefined instead of a boolean value. Make sure to return true or false.",
6931            getComponentNameFromType(ctor) || "Component"
6932          );
6933          return oldProps;
6934        }
6935        return ctor.prototype && ctor.prototype.isPureReactComponent ? !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState) : true;
6936      }
6937      function callComponentWillReceiveProps(workInProgress2, instance, newProps, nextContext) {
6938        var oldState = instance.state;
6939        "function" === typeof instance.componentWillReceiveProps && instance.componentWillReceiveProps(newProps, nextContext);
6940        "function" === typeof instance.UNSAFE_componentWillReceiveProps && instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
6941        instance.state !== oldState && (workInProgress2 = getComponentNameFromFiber(workInProgress2) || "Component", didWarnAboutStateAssignmentForComponent.has(workInProgress2) || (didWarnAboutStateAssignmentForComponent.add(workInProgress2), console.error(
6942          "%s.componentWillReceiveProps(): Assigning directly to this.state is deprecated (except inside a component's constructor). Use setState instead.",
6943          workInProgress2
6944        )), classComponentUpdater.enqueueReplaceState(
6945          instance,
6946          instance.state,
6947          null
6948        ));
6949      }
6950      function resolveClassComponentProps(Component, baseProps) {
6951        var newProps = baseProps;
6952        if ("ref" in baseProps) {
6953          newProps = {};
6954          for (var propName in baseProps)
6955            "ref" !== propName && (newProps[propName] = baseProps[propName]);
6956        }
6957        if (Component = Component.defaultProps) {
6958          newProps === baseProps && (newProps = assign({}, newProps));
6959          for (var _propName in Component)
6960            void 0 === newProps[_propName] && (newProps[_propName] = Component[_propName]);
6961        }
6962        return newProps;
6963      }
6964      function defaultOnUncaughtError(error) {
6965        reportGlobalError(error);
6966        console.warn(
6967          "%s\n\n%s\n",
6968          componentName ? "An error occurred in the <" + componentName + "> component." : "An error occurred in one of your React components.",
6969          "Consider adding an error boundary to your tree to customize error handling behavior.\nVisit https://react.dev/link/error-boundaries to learn more about error boundaries."
6970        );
6971      }
6972      function defaultOnCaughtError(error) {
6973        var componentNameMessage = componentName ? "The above error occurred in the <" + componentName + "> component." : "The above error occurred in one of your React components.", recreateMessage = "React will try to recreate this component tree from scratch using the error boundary you provided, " + ((errorBoundaryName || "Anonymous") + ".");
6974        if ("object" === typeof error && null !== error && "string" === typeof error.environmentName) {
6975          var JSCompiler_inline_result = error.environmentName;
6976          error = [
6977            "%o\n\n%s\n\n%s\n",
6978            error,
6979            componentNameMessage,
6980            recreateMessage
6981          ].slice(0);
6982          "string" === typeof error[0] ? error.splice(
6983            0,
6984            1,
6985            badgeFormat + " " + error[0],
6986            badgeStyle,
6987            pad + JSCompiler_inline_result + pad,
6988            resetStyle
6989          ) : error.splice(
6990            0,
6991            0,
6992            badgeFormat,
6993            badgeStyle,
6994            pad + JSCompiler_inline_result + pad,
6995            resetStyle
6996          );
6997          error.unshift(console);
6998          JSCompiler_inline_result = bind.apply(console.error, error);
6999          JSCompiler_inline_result();
7000        } else
7001          console.error(
7002            "%o\n\n%s\n\n%s\n",
7003            error,
7004            componentNameMessage,
7005            recreateMessage
7006          );
7007      }
7008      function defaultOnRecoverableError(error) {
7009        reportGlobalError(error);
7010      }
7011      function logUncaughtError(root2, errorInfo) {
7012        try {
7013          componentName = errorInfo.source ? getComponentNameFromFiber(errorInfo.source) : null;
7014          errorBoundaryName = null;
7015          var error = errorInfo.value;
7016          if (null !== ReactSharedInternals.actQueue)
7017            ReactSharedInternals.thrownErrors.push(error);
7018          else {
7019            var onUncaughtError = root2.onUncaughtError;
7020            onUncaughtError(error, { componentStack: errorInfo.stack });
7021          }
7022        } catch (e$5) {
7023          setTimeout(function() {
7024            throw e$5;
7025          });
7026        }
7027      }
7028      function logCaughtError(root2, boundary, errorInfo) {
7029        try {
7030          componentName = errorInfo.source ? getComponentNameFromFiber(errorInfo.source) : null;
7031          errorBoundaryName = getComponentNameFromFiber(boundary);
7032          var onCaughtError = root2.onCaughtError;
7033          onCaughtError(errorInfo.value, {
7034            componentStack: errorInfo.stack,
7035            errorBoundary: 1 === boundary.tag ? boundary.stateNode : null
7036          });
7037        } catch (e$6) {
7038          setTimeout(function() {
7039            throw e$6;
7040          });
7041        }
7042      }
7043      function createRootErrorUpdate(root2, errorInfo, lane) {
7044        lane = createUpdate(lane);
7045        lane.tag = CaptureUpdate;
7046        lane.payload = { element: null };
7047        lane.callback = function() {
7048          runWithFiberInDEV(errorInfo.source, logUncaughtError, root2, errorInfo);
7049        };
7050        return lane;
7051      }
7052      function createClassErrorUpdate(lane) {
7053        lane = createUpdate(lane);
7054        lane.tag = CaptureUpdate;
7055        return lane;
7056      }
7057      function initializeClassErrorUpdate(update, root2, fiber, errorInfo) {
7058        var getDerivedStateFromError = fiber.type.getDerivedStateFromError;
7059        if ("function" === typeof getDerivedStateFromError) {
7060          var error = errorInfo.value;
7061          update.payload = function() {
7062            return getDerivedStateFromError(error);
7063          };
7064          update.callback = function() {
7065            markFailedErrorBoundaryForHotReloading(fiber);
7066            runWithFiberInDEV(
7067              errorInfo.source,
7068              logCaughtError,
7069              root2,
7070              fiber,
7071              errorInfo
7072            );
7073          };
7074        }
7075        var inst = fiber.stateNode;
7076        null !== inst && "function" === typeof inst.componentDidCatch && (update.callback = function() {
7077          markFailedErrorBoundaryForHotReloading(fiber);
7078          runWithFiberInDEV(
7079            errorInfo.source,
7080            logCaughtError,
7081            root2,
7082            fiber,
7083            errorInfo
7084          );
7085          "function" !== typeof getDerivedStateFromError && (null === legacyErrorBoundariesThatAlreadyFailed ? legacyErrorBoundariesThatAlreadyFailed = /* @__PURE__ */ new Set([this]) : legacyErrorBoundariesThatAlreadyFailed.add(this));
7086          callComponentDidCatchInDEV(this, errorInfo);
7087          "function" === typeof getDerivedStateFromError || 0 === (fiber.lanes & 2) && console.error(
7088            "%s: Error boundaries should implement getDerivedStateFromError(). In that method, return a state update to display an error message or fallback UI.",
7089            getComponentNameFromFiber(fiber) || "Unknown"
7090          );
7091        });
7092      }
7093      function throwException(root2, returnFiber, sourceFiber, value, rootRenderLanes) {
7094        sourceFiber.flags |= 32768;
7095        isDevToolsPresent && restorePendingUpdaters(root2, rootRenderLanes);
7096        if (null !== value && "object" === typeof value && "function" === typeof value.then) {
7097          returnFiber = sourceFiber.alternate;
7098          null !== returnFiber && propagateParentContextChanges(
7099            returnFiber,
7100            sourceFiber,
7101            rootRenderLanes,
7102            true
7103          );
7104          isHydrating && (didSuspendOrErrorDEV = true);
7105          sourceFiber = suspenseHandlerStackCursor.current;
7106          if (null !== sourceFiber) {
7107            switch (sourceFiber.tag) {
7108              case 31:
7109              case 13:
7110                return null === shellBoundary ? renderDidSuspendDelayIfPossible() : null === sourceFiber.alternate && workInProgressRootExitStatus === RootInProgress && (workInProgressRootExitStatus = RootSuspended), sourceFiber.flags &= -257, sourceFiber.flags |= 65536, sourceFiber.lanes = rootRenderLanes, value === noopSuspenseyCommitThenable ? sourceFiber.flags |= 16384 : (returnFiber = sourceFiber.updateQueue, null === returnFiber ? sourceFiber.updateQueue = /* @__PURE__ */ new Set([value]) : returnFiber.add(value), attachPingListener(root2, value, rootRenderLanes)), false;
7111              case 22:
7112                return sourceFiber.flags |= 65536, value === noopSuspenseyCommitThenable ? sourceFiber.flags |= 16384 : (returnFiber = sourceFiber.updateQueue, null === returnFiber ? (returnFiber = {
7113                  transitions: null,
7114                  markerInstances: null,
7115                  retryQueue: /* @__PURE__ */ new Set([value])
7116                }, sourceFiber.updateQueue = returnFiber) : (sourceFiber = returnFiber.retryQueue, null === sourceFiber ? returnFiber.retryQueue = /* @__PURE__ */ new Set([value]) : sourceFiber.add(value)), attachPingListener(root2, value, rootRenderLanes)), false;
7117            }
7118            throw Error(
7119              "Unexpected Suspense handler tag (" + sourceFiber.tag + "). This is a bug in React."
7120            );
7121          }
7122          attachPingListener(root2, value, rootRenderLanes);
7123          renderDidSuspendDelayIfPossible();
7124          return false;
7125        }
7126        if (isHydrating)
7127          return didSuspendOrErrorDEV = true, returnFiber = suspenseHandlerStackCursor.current, null !== returnFiber ? (0 === (returnFiber.flags & 65536) && (returnFiber.flags |= 256), returnFiber.flags |= 65536, returnFiber.lanes = rootRenderLanes, value !== HydrationMismatchException && queueHydrationError(
7128            createCapturedValueAtFiber(
7129              Error(
7130                "There was an error while hydrating but React was able to recover by instead client rendering from the nearest Suspense boundary.",
7131                { cause: value }
7132              ),
7133              sourceFiber
7134            )
7135          )) : (value !== HydrationMismatchException && queueHydrationError(
7136            createCapturedValueAtFiber(
7137              Error(
7138                "There was an error while hydrating but React was able to recover by instead client rendering the entire root.",
7139                { cause: value }
7140              ),
7141              sourceFiber
7142            )
7143          ), root2 = root2.current.alternate, root2.flags |= 65536, rootRenderLanes &= -rootRenderLanes, root2.lanes |= rootRenderLanes, value = createCapturedValueAtFiber(value, sourceFiber), rootRenderLanes = createRootErrorUpdate(
7144            root2.stateNode,
7145            value,
7146            rootRenderLanes
7147          ), enqueueCapturedUpdate(root2, rootRenderLanes), workInProgressRootExitStatus !== RootSuspendedWithDelay && (workInProgressRootExitStatus = RootErrored)), false;
7148        var error = createCapturedValueAtFiber(
7149          Error(
7150            "There was an error during concurrent rendering but React was able to recover by instead synchronously rendering the entire root.",
7151            { cause: value }
7152          ),
7153          sourceFiber
7154        );
7155        null === workInProgressRootConcurrentErrors ? workInProgressRootConcurrentErrors = [error] : workInProgressRootConcurrentErrors.push(error);
7156        workInProgressRootExitStatus !== RootSuspendedWithDelay && (workInProgressRootExitStatus = RootErrored);
7157        if (null === returnFiber) return true;
7158        value = createCapturedValueAtFiber(value, sourceFiber);
7159        sourceFiber = returnFiber;
7160        do {
7161          switch (sourceFiber.tag) {
7162            case 3:
7163              return sourceFiber.flags |= 65536, root2 = rootRenderLanes & -rootRenderLanes, sourceFiber.lanes |= root2, root2 = createRootErrorUpdate(
7164                sourceFiber.stateNode,
7165                value,
7166                root2
7167              ), enqueueCapturedUpdate(sourceFiber, root2), false;
7168            case 1:
7169              if (returnFiber = sourceFiber.type, error = sourceFiber.stateNode, 0 === (sourceFiber.flags & 128) && ("function" === typeof returnFiber.getDerivedStateFromError || null !== error && "function" === typeof error.componentDidCatch && (null === legacyErrorBoundariesThatAlreadyFailed || !legacyErrorBoundariesThatAlreadyFailed.has(error))))
7170                return sourceFiber.flags |= 65536, rootRenderLanes &= -rootRenderLanes, sourceFiber.lanes |= rootRenderLanes, rootRenderLanes = createClassErrorUpdate(rootRenderLanes), initializeClassErrorUpdate(
7171                  rootRenderLanes,
7172                  root2,
7173                  sourceFiber,
7174                  value
7175                ), enqueueCapturedUpdate(sourceFiber, rootRenderLanes), false;
7176          }
7177          sourceFiber = sourceFiber.return;
7178        } while (null !== sourceFiber);
7179        return false;
7180      }
7181      function reconcileChildren(current2, workInProgress2, nextChildren, renderLanes2) {
7182        workInProgress2.child = null === current2 ? mountChildFibers(workInProgress2, null, nextChildren, renderLanes2) : reconcileChildFibers(
7183          workInProgress2,
7184          current2.child,
7185          nextChildren,
7186          renderLanes2
7187        );
7188      }
7189      function updateForwardRef(current2, workInProgress2, Component, nextProps, renderLanes2) {
7190        Component = Component.render;
7191        var ref = workInProgress2.ref;
7192        if ("ref" in nextProps) {
7193          var propsWithoutRef = {};
7194          for (var key in nextProps)
7195            "ref" !== key && (propsWithoutRef[key] = nextProps[key]);
7196        } else propsWithoutRef = nextProps;
7197        prepareToReadContext(workInProgress2);
7198        nextProps = renderWithHooks(
7199          current2,
7200          workInProgress2,
7201          Component,
7202          propsWithoutRef,
7203          ref,
7204          renderLanes2
7205        );
7206        key = checkDidRenderIdHook();
7207        if (null !== current2 && !didReceiveUpdate)
7208          return bailoutHooks(current2, workInProgress2, renderLanes2), bailoutOnAlreadyFinishedWork(current2, workInProgress2, renderLanes2);
7209        isHydrating && key && pushMaterializedTreeId(workInProgress2);
7210        workInProgress2.flags |= 1;
7211        reconcileChildren(current2, workInProgress2, nextProps, renderLanes2);
7212        return workInProgress2.child;
7213      }
7214      function updateMemoComponent(current2, workInProgress2, Component, nextProps, renderLanes2) {
7215        if (null === current2) {
7216          var type = Component.type;
7217          if ("function" === typeof type && !shouldConstruct(type) && void 0 === type.defaultProps && null === Component.compare)
7218            return Component = resolveFunctionForHotReloading(type), workInProgress2.tag = 15, workInProgress2.type = Component, validateFunctionComponentInDev(workInProgress2, type), updateSimpleMemoComponent(
7219              current2,
7220              workInProgress2,
7221              Component,
7222              nextProps,
7223              renderLanes2
7224            );
7225          current2 = createFiberFromTypeAndProps(
7226            Component.type,
7227            null,
7228            nextProps,
7229            workInProgress2,
7230            workInProgress2.mode,
7231            renderLanes2
7232          );
7233          current2.ref = workInProgress2.ref;
7234          current2.return = workInProgress2;
7235          return workInProgress2.child = current2;
7236        }
7237        type = current2.child;
7238        if (!checkScheduledUpdateOrContext(current2, renderLanes2)) {
7239          var prevProps = type.memoizedProps;
7240          Component = Component.compare;
7241          Component = null !== Component ? Component : shallowEqual;
7242          if (Component(prevProps, nextProps) && current2.ref === workInProgress2.ref)
7243            return bailoutOnAlreadyFinishedWork(
7244              current2,
7245              workInProgress2,
7246              renderLanes2
7247            );
7248        }
7249        workInProgress2.flags |= 1;
7250        current2 = createWorkInProgress(type, nextProps);
7251        current2.ref = workInProgress2.ref;
7252        current2.return = workInProgress2;
7253        return workInProgress2.child = current2;
7254      }
7255      function updateSimpleMemoComponent(current2, workInProgress2, Component, nextProps, renderLanes2) {
7256        if (null !== current2) {
7257          var prevProps = current2.memoizedProps;
7258          if (shallowEqual(prevProps, nextProps) && current2.ref === workInProgress2.ref && workInProgress2.type === current2.type)
7259            if (didReceiveUpdate = false, workInProgress2.pendingProps = nextProps = prevProps, checkScheduledUpdateOrContext(current2, renderLanes2))
7260              0 !== (current2.flags & 131072) && (didReceiveUpdate = true);
7261            else
7262              return workInProgress2.lanes = current2.lanes, bailoutOnAlreadyFinishedWork(current2, workInProgress2, renderLanes2);
7263        }
7264        return updateFunctionComponent(
7265          current2,
7266          workInProgress2,
7267          Component,
7268          nextProps,
7269          renderLanes2
7270        );
7271      }
7272      function updateOffscreenComponent(current2, workInProgress2, renderLanes2, nextProps) {
7273        var nextChildren = nextProps.children, prevState = null !== current2 ? current2.memoizedState : null;
7274        null === current2 && null === workInProgress2.stateNode && (workInProgress2.stateNode = {
7275          _visibility: OffscreenVisible,
7276          _pendingMarkers: null,
7277          _retryCache: null,
7278          _transitions: null
7279        });
7280        if ("hidden" === nextProps.mode) {
7281          if (0 !== (workInProgress2.flags & 128)) {
7282            prevState = null !== prevState ? prevState.baseLanes | renderLanes2 : renderLanes2;
7283            if (null !== current2) {
7284              nextProps = workInProgress2.child = current2.child;
7285              for (nextChildren = 0; null !== nextProps; )
7286                nextChildren = nextChildren | nextProps.lanes | nextProps.childLanes, nextProps = nextProps.sibling;
7287              nextProps = nextChildren & ~prevState;
7288            } else nextProps = 0, workInProgress2.child = null;
7289            return deferHiddenOffscreenComponent(
7290              current2,
7291              workInProgress2,
7292              prevState,
7293              renderLanes2,
7294              nextProps
7295            );
7296          }
7297          if (0 !== (renderLanes2 & 536870912))
7298            workInProgress2.memoizedState = { baseLanes: 0, cachePool: null }, null !== current2 && pushTransition(
7299              workInProgress2,
7300              null !== prevState ? prevState.cachePool : null
7301            ), null !== prevState ? pushHiddenContext(workInProgress2, prevState) : reuseHiddenContextOnStack(workInProgress2), pushOffscreenSuspenseHandler(workInProgress2);
7302          else
7303            return nextProps = workInProgress2.lanes = 536870912, deferHiddenOffscreenComponent(
7304              current2,
7305              workInProgress2,
7306              null !== prevState ? prevState.baseLanes | renderLanes2 : renderLanes2,
7307              renderLanes2,
7308              nextProps
7309            );
7310        } else
7311          null !== prevState ? (pushTransition(workInProgress2, prevState.cachePool), pushHiddenContext(workInProgress2, prevState), reuseSuspenseHandlerOnStack(workInProgress2), workInProgress2.memoizedState = null) : (null !== current2 && pushTransition(workInProgress2, null), reuseHiddenContextOnStack(workInProgress2), reuseSuspenseHandlerOnStack(workInProgress2));
7312        reconcileChildren(current2, workInProgress2, nextChildren, renderLanes2);
7313        return workInProgress2.child;
7314      }
7315      function bailoutOffscreenComponent(current2, workInProgress2) {
7316        null !== current2 && 22 === current2.tag || null !== workInProgress2.stateNode || (workInProgress2.stateNode = {
7317          _visibility: OffscreenVisible,
7318          _pendingMarkers: null,
7319          _retryCache: null,
7320          _transitions: null
7321        });
7322        return workInProgress2.sibling;
7323      }
7324      function deferHiddenOffscreenComponent(current2, workInProgress2, nextBaseLanes, renderLanes2, remainingChildLanes) {
7325        var JSCompiler_inline_result = peekCacheFromPool();
7326        JSCompiler_inline_result = null === JSCompiler_inline_result ? null : {
7327          parent: CacheContext._currentValue,
7328          pool: JSCompiler_inline_result
7329        };
7330        workInProgress2.memoizedState = {
7331          baseLanes: nextBaseLanes,
7332          cachePool: JSCompiler_inline_result
7333        };
7334        null !== current2 && pushTransition(workInProgress2, null);
7335        reuseHiddenContextOnStack(workInProgress2);
7336        pushOffscreenSuspenseHandler(workInProgress2);
7337        null !== current2 && propagateParentContextChanges(current2, workInProgress2, renderLanes2, true);
7338        workInProgress2.childLanes = remainingChildLanes;
7339        return null;
7340      }
7341      function mountActivityChildren(workInProgress2, nextProps) {
7342        var hiddenProp = nextProps.hidden;
7343        void 0 !== hiddenProp && console.error(
7344          `<Activity> doesn't accept a hidden prop. Use mode="hidden" instead.
7345- <Activity %s>
7346+ <Activity %s>`,
7347          true === hiddenProp ? "hidden" : false === hiddenProp ? "hidden={false}" : "hidden={...}",
7348          hiddenProp ? 'mode="hidden"' : 'mode="visible"'
7349        );
7350        nextProps = mountWorkInProgressOffscreenFiber(
7351          { mode: nextProps.mode, children: nextProps.children },
7352          workInProgress2.mode
7353        );
7354        nextProps.ref = workInProgress2.ref;
7355        workInProgress2.child = nextProps;
7356        nextProps.return = workInProgress2;
7357        return nextProps;
7358      }
7359      function retryActivityComponentWithoutHydrating(current2, workInProgress2, renderLanes2) {
7360        reconcileChildFibers(workInProgress2, current2.child, null, renderLanes2);
7361        current2 = mountActivityChildren(
7362          workInProgress2,
7363          workInProgress2.pendingProps
7364        );
7365        current2.flags |= 2;
7366        popSuspenseHandler(workInProgress2);
7367        workInProgress2.memoizedState = null;
7368        return current2;
7369      }
7370      function updateActivityComponent(current2, workInProgress2, renderLanes2) {
7371        var nextProps = workInProgress2.pendingProps, didSuspend = 0 !== (workInProgress2.flags & 128);
7372        workInProgress2.flags &= -129;
7373        if (null === current2) {
7374          if (isHydrating) {
7375            if ("hidden" === nextProps.mode)
7376              return current2 = mountActivityChildren(workInProgress2, nextProps), workInProgress2.lanes = 536870912, bailoutOffscreenComponent(null, current2);
7377            pushDehydratedActivitySuspenseHandler(workInProgress2);
7378            (current2 = nextHydratableInstance) ? (renderLanes2 = canHydrateHydrationBoundary(
7379              current2,
7380              rootOrSingletonContext
7381            ), renderLanes2 = null !== renderLanes2 && renderLanes2.data === ACTIVITY_START_DATA ? renderLanes2 : null, null !== renderLanes2 && (nextProps = {
7382              dehydrated: renderLanes2,
7383              treeContext: getSuspendedTreeContext(),
7384              retryLane: 536870912,
7385              hydrationErrors: null
7386            }, workInProgress2.memoizedState = nextProps, nextProps = createFiberFromDehydratedFragment(renderLanes2), nextProps.return = workInProgress2, workInProgress2.child = nextProps, hydrationParentFiber = workInProgress2, nextHydratableInstance = null)) : renderLanes2 = null;
7387            if (null === renderLanes2)
7388              throw warnNonHydratedInstance(workInProgress2, current2), throwOnHydrationMismatch(workInProgress2);
7389            workInProgress2.lanes = 536870912;
7390            return null;
7391          }
7392          return mountActivityChildren(workInProgress2, nextProps);
7393        }
7394        var prevState = current2.memoizedState;
7395        if (null !== prevState) {
7396          var activityInstance = prevState.dehydrated;
7397          pushDehydratedActivitySuspenseHandler(workInProgress2);
7398          if (didSuspend)
7399            if (workInProgress2.flags & 256)
7400              workInProgress2.flags &= -257, workInProgress2 = retryActivityComponentWithoutHydrating(
7401                current2,
7402                workInProgress2,
7403                renderLanes2
7404              );
7405            else if (null !== workInProgress2.memoizedState)
7406              workInProgress2.child = current2.child, workInProgress2.flags |= 128, workInProgress2 = null;
7407            else
7408              throw Error(
7409                "Client rendering an Activity suspended it again. This is a bug in React."
7410              );
7411          else if (warnIfHydrating(), 0 !== (renderLanes2 & 536870912) && markRenderDerivedCause(workInProgress2), didReceiveUpdate || propagateParentContextChanges(
7412            current2,
7413            workInProgress2,
7414            renderLanes2,
7415            false
7416          ), didSuspend = 0 !== (renderLanes2 & current2.childLanes), didReceiveUpdate || didSuspend) {
7417            nextProps = workInProgressRoot;
7418            if (null !== nextProps && (activityInstance = getBumpedLaneForHydration(
7419              nextProps,
7420              renderLanes2
7421            ), 0 !== activityInstance && activityInstance !== prevState.retryLane))
7422              throw prevState.retryLane = activityInstance, enqueueConcurrentRenderForLane(current2, activityInstance), scheduleUpdateOnFiber(nextProps, current2, activityInstance), SelectiveHydrationException;
7423            renderDidSuspendDelayIfPossible();
7424            workInProgress2 = retryActivityComponentWithoutHydrating(
7425              current2,
7426              workInProgress2,
7427              renderLanes2
7428            );
7429          } else
7430            current2 = prevState.treeContext, nextHydratableInstance = getNextHydratable(
7431              activityInstance.nextSibling
7432            ), hydrationParentFiber = workInProgress2, isHydrating = true, hydrationErrors = null, didSuspendOrErrorDEV = false, hydrationDiffRootDEV = null, rootOrSingletonContext = false, null !== current2 && restoreSuspendedTreeContext(workInProgress2, current2), workInProgress2 = mountActivityChildren(workInProgress2, nextProps), workInProgress2.flags |= 4096;
7433          return workInProgress2;
7434        }
7435        prevState = current2.child;
7436        nextProps = { mode: nextProps.mode, children: nextProps.children };
7437        0 !== (renderLanes2 & 536870912) && 0 !== (renderLanes2 & current2.lanes) && markRenderDerivedCause(workInProgress2);
7438        current2 = createWorkInProgress(prevState, nextProps);
7439        current2.ref = workInProgress2.ref;
7440        workInProgress2.child = current2;
7441        current2.return = workInProgress2;
7442        return current2;
7443      }
7444      function markRef(current2, workInProgress2) {
7445        var ref = workInProgress2.ref;
7446        if (null === ref)
7447          null !== current2 && null !== current2.ref && (workInProgress2.flags |= 4194816);
7448        else {
7449          if ("function" !== typeof ref && "object" !== typeof ref)
7450            throw Error(
7451              "Expected ref to be a function, an object returned by React.createRef(), or undefined/null."
7452            );
7453          if (null === current2 || current2.ref !== ref)
7454            workInProgress2.flags |= 4194816;
7455        }
7456      }
7457      function updateFunctionComponent(current2, workInProgress2, Component, nextProps, renderLanes2) {
7458        if (Component.prototype && "function" === typeof Component.prototype.render) {
7459          var componentName2 = getComponentNameFromType(Component) || "Unknown";
7460          didWarnAboutBadClass[componentName2] || (console.error(
7461            "The <%s /> component appears to have a render method, but doesn't extend React.Component. This is likely to cause errors. Change %s to extend React.Component instead.",
7462            componentName2,
7463            componentName2
7464          ), didWarnAboutBadClass[componentName2] = true);
7465        }
7466        workInProgress2.mode & StrictLegacyMode && ReactStrictModeWarnings.recordLegacyContextWarning(
7467          workInProgress2,
7468          null
7469        );
7470        null === current2 && (validateFunctionComponentInDev(workInProgress2, workInProgress2.type), Component.contextTypes && (componentName2 = getComponentNameFromType(Component) || "Unknown", didWarnAboutContextTypes[componentName2] || (didWarnAboutContextTypes[componentName2] = true, console.error(
7471          "%s uses the legacy contextTypes API which was removed in React 19. Use React.createContext() with React.useContext() instead. (https://react.dev/link/legacy-context)",
7472          componentName2
7473        ))));
7474        prepareToReadContext(workInProgress2);
7475        Component = renderWithHooks(
7476          current2,
7477          workInProgress2,
7478          Component,
7479          nextProps,
7480          void 0,
7481          renderLanes2
7482        );
7483        nextProps = checkDidRenderIdHook();
7484        if (null !== current2 && !didReceiveUpdate)
7485          return bailoutHooks(current2, workInProgress2, renderLanes2), bailoutOnAlreadyFinishedWork(current2, workInProgress2, renderLanes2);
7486        isHydrating && nextProps && pushMaterializedTreeId(workInProgress2);
7487        workInProgress2.flags |= 1;
7488        reconcileChildren(current2, workInProgress2, Component, renderLanes2);
7489        return workInProgress2.child;
7490      }
7491      function replayFunctionComponent(current2, workInProgress2, nextProps, Component, secondArg, renderLanes2) {
7492        prepareToReadContext(workInProgress2);
7493        hookTypesUpdateIndexDev = -1;
7494        ignorePreviousDependencies = null !== current2 && current2.type !== workInProgress2.type;
7495        workInProgress2.updateQueue = null;
7496        nextProps = renderWithHooksAgain(
7497          workInProgress2,
7498          Component,
7499          nextProps,
7500          secondArg
7501        );
7502        finishRenderingHooks(current2, workInProgress2);
7503        Component = checkDidRenderIdHook();
7504        if (null !== current2 && !didReceiveUpdate)
7505          return bailoutHooks(current2, workInProgress2, renderLanes2), bailoutOnAlreadyFinishedWork(current2, workInProgress2, renderLanes2);
7506        isHydrating && Component && pushMaterializedTreeId(workInProgress2);
7507        workInProgress2.flags |= 1;
7508        reconcileChildren(current2, workInProgress2, nextProps, renderLanes2);
7509        return workInProgress2.child;
7510      }
7511      function updateClassComponent(current2, workInProgress2, Component, nextProps, renderLanes2) {
7512        switch (shouldErrorImpl(workInProgress2)) {
7513          case false:
7514            var _instance = workInProgress2.stateNode, state = new workInProgress2.type(
7515              workInProgress2.memoizedProps,
7516              _instance.context
7517            ).state;
7518            _instance.updater.enqueueSetState(_instance, state, null);
7519            break;
7520          case true:
7521            workInProgress2.flags |= 128;
7522            workInProgress2.flags |= 65536;
7523            _instance = Error("Simulated error coming from DevTools");
7524            var lane = renderLanes2 & -renderLanes2;
7525            workInProgress2.lanes |= lane;
7526            state = workInProgressRoot;
7527            if (null === state)
7528              throw Error(
7529                "Expected a work-in-progress root. This is a bug in React. Please file an issue."
7530              );
7531            lane = createClassErrorUpdate(lane);
7532            initializeClassErrorUpdate(
7533              lane,
7534              state,
7535              workInProgress2,
7536              createCapturedValueAtFiber(_instance, workInProgress2)
7537            );
7538            enqueueCapturedUpdate(workInProgress2, lane);
7539        }
7540        prepareToReadContext(workInProgress2);
7541        if (null === workInProgress2.stateNode) {
7542          state = emptyContextObject;
7543          _instance = Component.contextType;
7544          "contextType" in Component && null !== _instance && (void 0 === _instance || _instance.$$typeof !== REACT_CONTEXT_TYPE) && !didWarnAboutInvalidateContextType.has(Component) && (didWarnAboutInvalidateContextType.add(Component), lane = void 0 === _instance ? " However, it is set to undefined. This can be caused by a typo or by mixing up named and default imports. This can also happen due to a circular dependency, so try moving the createContext() call to a separate file." : "object" !== typeof _instance ? " However, it is set to a " + typeof _instance + "." : _instance.$$typeof === REACT_CONSUMER_TYPE ? " Did you accidentally pass the Context.Consumer instead?" : " However, it is set to an object with keys {" + Object.keys(_instance).join(", ") + "}.", console.error(
7545            "%s defines an invalid contextType. contextType should point to the Context object returned by React.createContext().%s",
7546            getComponentNameFromType(Component) || "Component",
7547            lane
7548          ));
7549          "object" === typeof _instance && null !== _instance && (state = readContext(_instance));
7550          _instance = new Component(nextProps, state);
7551          if (workInProgress2.mode & StrictLegacyMode) {
7552            setIsStrictModeForDevtools(true);
7553            try {
7554              _instance = new Component(nextProps, state);
7555            } finally {
7556              setIsStrictModeForDevtools(false);
7557            }
7558          }
7559          state = workInProgress2.memoizedState = null !== _instance.state && void 0 !== _instance.state ? _instance.state : null;
7560          _instance.updater = classComponentUpdater;
7561          workInProgress2.stateNode = _instance;
7562          _instance._reactInternals = workInProgress2;
7563          _instance._reactInternalInstance = fakeInternalInstance;
7564          "function" === typeof Component.getDerivedStateFromProps && null === state && (state = getComponentNameFromType(Component) || "Component", didWarnAboutUninitializedState.has(state) || (didWarnAboutUninitializedState.add(state), console.error(
7565            "`%s` uses `getDerivedStateFromProps` but its initial state is %s. This is not recommended. Instead, define the initial state by assigning an object to `this.state` in the constructor of `%s`. This ensures that `getDerivedStateFromProps` arguments have a consistent shape.",
7566            state,
7567            null === _instance.state ? "null" : "undefined",
7568            state
7569          )));
7570          if ("function" === typeof Component.getDerivedStateFromProps || "function" === typeof _instance.getSnapshotBeforeUpdate) {
7571            var foundWillUpdateName = lane = state = null;
7572            "function" === typeof _instance.componentWillMount && true !== _instance.componentWillMount.__suppressDeprecationWarning ? state = "componentWillMount" : "function" === typeof _instance.UNSAFE_componentWillMount && (state = "UNSAFE_componentWillMount");
7573            "function" === typeof _instance.componentWillReceiveProps && true !== _instance.componentWillReceiveProps.__suppressDeprecationWarning ? lane = "componentWillReceiveProps" : "function" === typeof _instance.UNSAFE_componentWillReceiveProps && (lane = "UNSAFE_componentWillReceiveProps");
7574            "function" === typeof _instance.componentWillUpdate && true !== _instance.componentWillUpdate.__suppressDeprecationWarning ? foundWillUpdateName = "componentWillUpdate" : "function" === typeof _instance.UNSAFE_componentWillUpdate && (foundWillUpdateName = "UNSAFE_componentWillUpdate");
7575            if (null !== state || null !== lane || null !== foundWillUpdateName) {
7576              _instance = getComponentNameFromType(Component) || "Component";
7577              var newApiName = "function" === typeof Component.getDerivedStateFromProps ? "getDerivedStateFromProps()" : "getSnapshotBeforeUpdate()";
7578              didWarnAboutLegacyLifecyclesAndDerivedState.has(_instance) || (didWarnAboutLegacyLifecyclesAndDerivedState.add(_instance), console.error(
7579                "Unsafe legacy lifecycles will not be called for components using new component APIs.\n\n%s uses %s but also contains the following legacy lifecycles:%s%s%s\n\nThe above lifecycles should be removed. Learn more about this warning here:\nhttps://react.dev/link/unsafe-component-lifecycles",
7580                _instance,
7581                newApiName,
7582                null !== state ? "\n  " + state : "",
7583                null !== lane ? "\n  " + lane : "",
7584                null !== foundWillUpdateName ? "\n  " + foundWillUpdateName : ""
7585              ));
7586            }
7587          }
7588          _instance = workInProgress2.stateNode;
7589          state = getComponentNameFromType(Component) || "Component";
7590          _instance.render || (Component.prototype && "function" === typeof Component.prototype.render ? console.error(
7591            "No `render` method found on the %s instance: did you accidentally return an object from the constructor?",
7592            state
7593          ) : console.error(
7594            "No `render` method found on the %s instance: you may have forgotten to define `render`.",
7595            state
7596          ));
7597          !_instance.getInitialState || _instance.getInitialState.isReactClassApproved || _instance.state || console.error(
7598            "getInitialState was defined on %s, a plain JavaScript class. This is only supported for classes created using React.createClass. Did you mean to define a state property instead?",
7599            state
7600          );
7601          _instance.getDefaultProps && !_instance.getDefaultProps.isReactClassApproved && console.error(
7602            "getDefaultProps was defined on %s, a plain JavaScript class. This is only supported for classes created using React.createClass. Use a static property to define defaultProps instead.",
7603            state
7604          );
7605          _instance.contextType && console.error(
7606            "contextType was defined as an instance property on %s. Use a static property to define contextType instead.",
7607            state
7608          );
7609          Component.childContextTypes && !didWarnAboutChildContextTypes.has(Component) && (didWarnAboutChildContextTypes.add(Component), console.error(
7610            "%s uses the legacy childContextTypes API which was removed in React 19. Use React.createContext() instead. (https://react.dev/link/legacy-context)",
7611            state
7612          ));
7613          Component.contextTypes && !didWarnAboutContextTypes$1.has(Component) && (didWarnAboutContextTypes$1.add(Component), console.error(
7614            "%s uses the legacy contextTypes API which was removed in React 19. Use React.createContext() with static contextType instead. (https://react.dev/link/legacy-context)",
7615            state
7616          ));
7617          "function" === typeof _instance.componentShouldUpdate && console.error(
7618            "%s has a method called componentShouldUpdate(). Did you mean shouldComponentUpdate()? The name is phrased as a question because the function is expected to return a value.",
7619            state
7620          );
7621          Component.prototype && Component.prototype.isPureReactComponent && "undefined" !== typeof _instance.shouldComponentUpdate && console.error(
7622            "%s has a method called shouldComponentUpdate(). shouldComponentUpdate should not be used when extending React.PureComponent. Please extend React.Component if shouldComponentUpdate is used.",
7623            getComponentNameFromType(Component) || "A pure component"
7624          );
7625          "function" === typeof _instance.componentDidUnmount && console.error(
7626            "%s has a method called componentDidUnmount(). But there is no such lifecycle method. Did you mean componentWillUnmount()?",
7627            state
7628          );
7629          "function" === typeof _instance.componentDidReceiveProps && console.error(
7630            "%s has a method called componentDidReceiveProps(). But there is no such lifecycle method. If you meant to update the state in response to changing props, use componentWillReceiveProps(). If you meant to fetch data or run side-effects or mutations after React has updated the UI, use componentDidUpdate().",
7631            state
7632          );
7633          "function" === typeof _instance.componentWillRecieveProps && console.error(
7634            "%s has a method called componentWillRecieveProps(). Did you mean componentWillReceiveProps()?",
7635            state
7636          );
7637          "function" === typeof _instance.UNSAFE_componentWillRecieveProps && console.error(
7638            "%s has a method called UNSAFE_componentWillRecieveProps(). Did you mean UNSAFE_componentWillReceiveProps()?",
7639            state
7640          );
7641          lane = _instance.props !== nextProps;
7642          void 0 !== _instance.props && lane && console.error(
7643            "When calling super() in `%s`, make sure to pass up the same props that your component's constructor was passed.",
7644            state
7645          );
7646          _instance.defaultProps && console.error(
7647            "Setting defaultProps as an instance property on %s is not supported and will be ignored. Instead, define defaultProps as a static property on %s.",
7648            state,
7649            state
7650          );
7651          "function" !== typeof _instance.getSnapshotBeforeUpdate || "function" === typeof _instance.componentDidUpdate || didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.has(Component) || (didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.add(Component), console.error(
7652            "%s: getSnapshotBeforeUpdate() should be used with componentDidUpdate(). This component defines getSnapshotBeforeUpdate() only.",
7653            getComponentNameFromType(Component)
7654          ));
7655          "function" === typeof _instance.getDerivedStateFromProps && console.error(
7656            "%s: getDerivedStateFromProps() is defined as an instance method and will be ignored. Instead, declare it as a static method.",
7657            state
7658          );
7659          "function" === typeof _instance.getDerivedStateFromError && console.error(
7660            "%s: getDerivedStateFromError() is defined as an instance method and will be ignored. Instead, declare it as a static method.",
7661            state
7662          );
7663          "function" === typeof Component.getSnapshotBeforeUpdate && console.error(
7664            "%s: getSnapshotBeforeUpdate() is defined as a static method and will be ignored. Instead, declare it as an instance method.",
7665            state
7666          );
7667          (lane = _instance.state) && ("object" !== typeof lane || isArrayImpl(lane)) && console.error("%s.state: must be set to an object or null", state);
7668          "function" === typeof _instance.getChildContext && "object" !== typeof Component.childContextTypes && console.error(
7669            "%s.getChildContext(): childContextTypes must be defined in order to use getChildContext().",
7670            state
7671          );
7672          _instance = workInProgress2.stateNode;
7673          _instance.props = nextProps;
7674          _instance.state = workInProgress2.memoizedState;
7675          _instance.refs = {};
7676          initializeUpdateQueue(workInProgress2);
7677          state = Component.contextType;
7678          _instance.context = "object" === typeof state && null !== state ? readContext(state) : emptyContextObject;
7679          _instance.state === nextProps && (state = getComponentNameFromType(Component) || "Component", didWarnAboutDirectlyAssigningPropsToState.has(state) || (didWarnAboutDirectlyAssigningPropsToState.add(state), console.error(
7680            "%s: It is not recommended to assign props directly to state because updates to props won't be reflected in state. In most cases, it is better to use props directly.",
7681            state
7682          )));
7683          workInProgress2.mode & StrictLegacyMode && ReactStrictModeWarnings.recordLegacyContextWarning(
7684            workInProgress2,
7685            _instance
7686          );
7687          ReactStrictModeWarnings.recordUnsafeLifecycleWarnings(
7688            workInProgress2,
7689            _instance
7690          );
7691          _instance.state = workInProgress2.memoizedState;
7692          state = Component.getDerivedStateFromProps;
7693          "function" === typeof state && (applyDerivedStateFromProps(
7694            workInProgress2,
7695            Component,
7696            state,
7697            nextProps
7698          ), _instance.state = workInProgress2.memoizedState);
7699          "function" === typeof Component.getDerivedStateFromProps || "function" === typeof _instance.getSnapshotBeforeUpdate || "function" !== typeof _instance.UNSAFE_componentWillMount && "function" !== typeof _instance.componentWillMount || (state = _instance.state, "function" === typeof _instance.componentWillMount && _instance.componentWillMount(), "function" === typeof _instance.UNSAFE_componentWillMount && _instance.UNSAFE_componentWillMount(), state !== _instance.state && (console.error(
7700            "%s.componentWillMount(): Assigning directly to this.state is deprecated (except inside a component's constructor). Use setState instead.",
7701            getComponentNameFromFiber(workInProgress2) || "Component"
7702          ), classComponentUpdater.enqueueReplaceState(
7703            _instance,
7704            _instance.state,
7705            null
7706          )), processUpdateQueue(workInProgress2, nextProps, _instance, renderLanes2), suspendIfUpdateReadFromEntangledAsyncAction(), _instance.state = workInProgress2.memoizedState);
7707          "function" === typeof _instance.componentDidMount && (workInProgress2.flags |= 4194308);
7708          (workInProgress2.mode & StrictEffectsMode) !== NoMode && (workInProgress2.flags |= 134217728);
7709          _instance = true;
7710        } else if (null === current2) {
7711          _instance = workInProgress2.stateNode;
7712          var unresolvedOldProps = workInProgress2.memoizedProps;
7713          lane = resolveClassComponentProps(Component, unresolvedOldProps);
7714          _instance.props = lane;
7715          var oldContext = _instance.context;
7716          foundWillUpdateName = Component.contextType;
7717          state = emptyContextObject;
7718          "object" === typeof foundWillUpdateName && null !== foundWillUpdateName && (state = readContext(foundWillUpdateName));
7719          newApiName = Component.getDerivedStateFromProps;
7720          foundWillUpdateName = "function" === typeof newApiName || "function" === typeof _instance.getSnapshotBeforeUpdate;
7721          unresolvedOldProps = workInProgress2.pendingProps !== unresolvedOldProps;
7722          foundWillUpdateName || "function" !== typeof _instance.UNSAFE_componentWillReceiveProps && "function" !== typeof _instance.componentWillReceiveProps || (unresolvedOldProps || oldContext !== state) && callComponentWillReceiveProps(
7723            workInProgress2,
7724            _instance,
7725            nextProps,
7726            state
7727          );
7728          hasForceUpdate = false;
7729          var oldState = workInProgress2.memoizedState;
7730          _instance.state = oldState;
7731          processUpdateQueue(workInProgress2, nextProps, _instance, renderLanes2);
7732          suspendIfUpdateReadFromEntangledAsyncAction();
7733          oldContext = workInProgress2.memoizedState;
7734          unresolvedOldProps || oldState !== oldContext || hasForceUpdate ? ("function" === typeof newApiName && (applyDerivedStateFromProps(
7735            workInProgress2,
7736            Component,
7737            newApiName,
7738            nextProps
7739          ), oldContext = workInProgress2.memoizedState), (lane = hasForceUpdate || checkShouldComponentUpdate(
7740            workInProgress2,
7741            Component,
7742            lane,
7743            nextProps,
7744            oldState,
7745            oldContext,
7746            state
7747          )) ? (foundWillUpdateName || "function" !== typeof _instance.UNSAFE_componentWillMount && "function" !== typeof _instance.componentWillMount || ("function" === typeof _instance.componentWillMount && _instance.componentWillMount(), "function" === typeof _instance.UNSAFE_componentWillMount && _instance.UNSAFE_componentWillMount()), "function" === typeof _instance.componentDidMount && (workInProgress2.flags |= 4194308), (workInProgress2.mode & StrictEffectsMode) !== NoMode && (workInProgress2.flags |= 134217728)) : ("function" === typeof _instance.componentDidMount && (workInProgress2.flags |= 4194308), (workInProgress2.mode & StrictEffectsMode) !== NoMode && (workInProgress2.flags |= 134217728), workInProgress2.memoizedProps = nextProps, workInProgress2.memoizedState = oldContext), _instance.props = nextProps, _instance.state = oldContext, _instance.context = state, _instance = lane) : ("function" === typeof _instance.componentDidMount && (workInProgress2.flags |= 4194308), (workInProgress2.mode & StrictEffectsMode) !== NoMode && (workInProgress2.flags |= 134217728), _instance = false);
7748        } else {
7749          _instance = workInProgress2.stateNode;
7750          cloneUpdateQueue(current2, workInProgress2);
7751          state = workInProgress2.memoizedProps;
7752          foundWillUpdateName = resolveClassComponentProps(Component, state);
7753          _instance.props = foundWillUpdateName;
7754          newApiName = workInProgress2.pendingProps;
7755          oldState = _instance.context;
7756          oldContext = Component.contextType;
7757          lane = emptyContextObject;
7758          "object" === typeof oldContext && null !== oldContext && (lane = readContext(oldContext));
7759          unresolvedOldProps = Component.getDerivedStateFromProps;
7760          (oldContext = "function" === typeof unresolvedOldProps || "function" === typeof _instance.getSnapshotBeforeUpdate) || "function" !== typeof _instance.UNSAFE_componentWillReceiveProps && "function" !== typeof _instance.componentWillReceiveProps || (state !== newApiName || oldState !== lane) && callComponentWillReceiveProps(
7761            workInProgress2,
7762            _instance,
7763            nextProps,
7764            lane
7765          );
7766          hasForceUpdate = false;
7767          oldState = workInProgress2.memoizedState;
7768          _instance.state = oldState;
7769          processUpdateQueue(workInProgress2, nextProps, _instance, renderLanes2);
7770          suspendIfUpdateReadFromEntangledAsyncAction();
7771          var newState = workInProgress2.memoizedState;
7772          state !== newApiName || oldState !== newState || hasForceUpdate || null !== current2 && null !== current2.dependencies && checkIfContextChanged(current2.dependencies) ? ("function" === typeof unresolvedOldProps && (applyDerivedStateFromProps(
7773            workInProgress2,
7774            Component,
7775            unresolvedOldProps,
7776            nextProps
7777          ), newState = workInProgress2.memoizedState), (foundWillUpdateName = hasForceUpdate || checkShouldComponentUpdate(
7778            workInProgress2,
7779            Component,
7780            foundWillUpdateName,
7781            nextProps,
7782            oldState,
7783            newState,
7784            lane
7785          ) || null !== current2 && null !== current2.dependencies && checkIfContextChanged(current2.dependencies)) ? (oldContext || "function" !== typeof _instance.UNSAFE_componentWillUpdate && "function" !== typeof _instance.componentWillUpdate || ("function" === typeof _instance.componentWillUpdate && _instance.componentWillUpdate(nextProps, newState, lane), "function" === typeof _instance.UNSAFE_componentWillUpdate && _instance.UNSAFE_componentWillUpdate(
7786            nextProps,
7787            newState,
7788            lane
7789          )), "function" === typeof _instance.componentDidUpdate && (workInProgress2.flags |= 4), "function" === typeof _instance.getSnapshotBeforeUpdate && (workInProgress2.flags |= 1024)) : ("function" !== typeof _instance.componentDidUpdate || state === current2.memoizedProps && oldState === current2.memoizedState || (workInProgress2.flags |= 4), "function" !== typeof _instance.getSnapshotBeforeUpdate || state === current2.memoizedProps && oldState === current2.memoizedState || (workInProgress2.flags |= 1024), workInProgress2.memoizedProps = nextProps, workInProgress2.memoizedState = newState), _instance.props = nextProps, _instance.state = newState, _instance.context = lane, _instance = foundWillUpdateName) : ("function" !== typeof _instance.componentDidUpdate || state === current2.memoizedProps && oldState === current2.memoizedState || (workInProgress2.flags |= 4), "function" !== typeof _instance.getSnapshotBeforeUpdate || state === current2.memoizedProps && oldState === current2.memoizedState || (workInProgress2.flags |= 1024), _instance = false);
7790        }
7791        lane = _instance;
7792        markRef(current2, workInProgress2);
7793        state = 0 !== (workInProgress2.flags & 128);
7794        if (lane || state) {
7795          lane = workInProgress2.stateNode;
7796          setCurrentFiber(workInProgress2);
7797          if (state && "function" !== typeof Component.getDerivedStateFromError)
7798            Component = null, profilerStartTime = -1;
7799          else if (Component = callRenderInDEV(lane), workInProgress2.mode & StrictLegacyMode) {
7800            setIsStrictModeForDevtools(true);
7801            try {
7802              callRenderInDEV(lane);
7803            } finally {
7804              setIsStrictModeForDevtools(false);
7805            }
7806          }
7807          workInProgress2.flags |= 1;
7808          null !== current2 && state ? (workInProgress2.child = reconcileChildFibers(
7809            workInProgress2,
7810            current2.child,
7811            null,
7812            renderLanes2
7813          ), workInProgress2.child = reconcileChildFibers(
7814            workInProgress2,
7815            null,
7816            Component,
7817            renderLanes2
7818          )) : reconcileChildren(current2, workInProgress2, Component, renderLanes2);
7819          workInProgress2.memoizedState = lane.state;
7820          current2 = workInProgress2.child;
7821        } else
7822          current2 = bailoutOnAlreadyFinishedWork(
7823            current2,
7824            workInProgress2,
7825            renderLanes2
7826          );
7827        renderLanes2 = workInProgress2.stateNode;
7828        _instance && renderLanes2.props !== nextProps && (didWarnAboutReassigningProps || console.error(
7829          "It looks like %s is reassigning its own `this.props` while rendering. This is not supported and can lead to confusing bugs.",
7830          getComponentNameFromFiber(workInProgress2) || "a component"
7831        ), didWarnAboutReassigningProps = true);
7832        return current2;
7833      }
7834      function mountHostRootWithoutHydrating(current2, workInProgress2, nextChildren, renderLanes2) {
7835        resetHydrationState();
7836        workInProgress2.flags |= 256;
7837        reconcileChildren(current2, workInProgress2, nextChildren, renderLanes2);
7838        return workInProgress2.child;
7839      }
7840      function validateFunctionComponentInDev(workInProgress2, Component) {
7841        Component && Component.childContextTypes && console.error(
7842          "childContextTypes cannot be defined on a function component.\n  %s.childContextTypes = ...",
7843          Component.displayName || Component.name || "Component"
7844        );
7845        "function" === typeof Component.getDerivedStateFromProps && (workInProgress2 = getComponentNameFromType(Component) || "Unknown", didWarnAboutGetDerivedStateOnFunctionComponent[workInProgress2] || (console.error(
7846          "%s: Function components do not support getDerivedStateFromProps.",
7847          workInProgress2
7848        ), didWarnAboutGetDerivedStateOnFunctionComponent[workInProgress2] = true));
7849        "object" === typeof Component.contextType && null !== Component.contextType && (Component = getComponentNameFromType(Component) || "Unknown", didWarnAboutContextTypeOnFunctionComponent[Component] || (console.error(
7850          "%s: Function components do not support contextType.",
7851          Component
7852        ), didWarnAboutContextTypeOnFunctionComponent[Component] = true));
7853      }
7854      function mountSuspenseOffscreenState(renderLanes2) {
7855        return { baseLanes: renderLanes2, cachePool: getSuspendedCache() };
7856      }
7857      function getRemainingWorkInPrimaryTree(current2, primaryTreeDidDefer, renderLanes2) {
7858        current2 = null !== current2 ? current2.childLanes & ~renderLanes2 : 0;
7859        primaryTreeDidDefer && (current2 |= workInProgressDeferredLane);
7860        return current2;
7861      }
7862      function updateSuspenseComponent(current2, workInProgress2, renderLanes2) {
7863        var JSCompiler_object_inline_digest_2724;
7864        var JSCompiler_object_inline_stack_2725 = workInProgress2.pendingProps;
7865        shouldSuspendImpl(workInProgress2) && (workInProgress2.flags |= 128);
7866        var JSCompiler_object_inline_message_2723 = false;
7867        var didSuspend = 0 !== (workInProgress2.flags & 128);
7868        (JSCompiler_object_inline_digest_2724 = didSuspend) || (JSCompiler_object_inline_digest_2724 = null !== current2 && null === current2.memoizedState ? false : 0 !== (suspenseStackCursor.current & ForceSuspenseFallback));
7869        JSCompiler_object_inline_digest_2724 && (JSCompiler_object_inline_message_2723 = true, workInProgress2.flags &= -129);
7870        JSCompiler_object_inline_digest_2724 = 0 !== (workInProgress2.flags & 32);
7871        workInProgress2.flags &= -33;
7872        if (null === current2) {
7873          if (isHydrating) {
7874            JSCompiler_object_inline_message_2723 ? pushPrimaryTreeSuspenseHandler(workInProgress2) : reuseSuspenseHandlerOnStack(workInProgress2);
7875            (current2 = nextHydratableInstance) ? (renderLanes2 = canHydrateHydrationBoundary(
7876              current2,
7877              rootOrSingletonContext
7878            ), renderLanes2 = null !== renderLanes2 && renderLanes2.data !== ACTIVITY_START_DATA ? renderLanes2 : null, null !== renderLanes2 && (JSCompiler_object_inline_digest_2724 = {
7879              dehydrated: renderLanes2,
7880              treeContext: getSuspendedTreeContext(),
7881              retryLane: 536870912,
7882              hydrationErrors: null
7883            }, workInProgress2.memoizedState = JSCompiler_object_inline_digest_2724, JSCompiler_object_inline_digest_2724 = createFiberFromDehydratedFragment(renderLanes2), JSCompiler_object_inline_digest_2724.return = workInProgress2, workInProgress2.child = JSCompiler_object_inline_digest_2724, hydrationParentFiber = workInProgress2, nextHydratableInstance = null)) : renderLanes2 = null;
7884            if (null === renderLanes2)
7885              throw warnNonHydratedInstance(workInProgress2, current2), throwOnHydrationMismatch(workInProgress2);
7886            isSuspenseInstanceFallback(renderLanes2) ? workInProgress2.lanes = 32 : workInProgress2.lanes = 536870912;
7887            return null;
7888          }
7889          var nextPrimaryChildren = JSCompiler_object_inline_stack_2725.children;
7890          JSCompiler_object_inline_stack_2725 = JSCompiler_object_inline_stack_2725.fallback;
7891          if (JSCompiler_object_inline_message_2723) {
7892            reuseSuspenseHandlerOnStack(workInProgress2);
7893            var mode = workInProgress2.mode;
7894            nextPrimaryChildren = mountWorkInProgressOffscreenFiber(
7895              { mode: "hidden", children: nextPrimaryChildren },
7896              mode
7897            );
7898            JSCompiler_object_inline_stack_2725 = createFiberFromFragment(
7899              JSCompiler_object_inline_stack_2725,
7900              mode,
7901              renderLanes2,
7902              null
7903            );
7904            nextPrimaryChildren.return = workInProgress2;
7905            JSCompiler_object_inline_stack_2725.return = workInProgress2;
7906            nextPrimaryChildren.sibling = JSCompiler_object_inline_stack_2725;
7907            workInProgress2.child = nextPrimaryChildren;
7908            JSCompiler_object_inline_stack_2725 = workInProgress2.child;
7909            JSCompiler_object_inline_stack_2725.memoizedState = mountSuspenseOffscreenState(renderLanes2);
7910            JSCompiler_object_inline_stack_2725.childLanes = getRemainingWorkInPrimaryTree(
7911              current2,
7912              JSCompiler_object_inline_digest_2724,
7913              renderLanes2
7914            );
7915            workInProgress2.memoizedState = SUSPENDED_MARKER;
7916            return bailoutOffscreenComponent(
7917              null,
7918              JSCompiler_object_inline_stack_2725
7919            );
7920          }
7921          pushPrimaryTreeSuspenseHandler(workInProgress2);
7922          return mountSuspensePrimaryChildren(
7923            workInProgress2,
7924            nextPrimaryChildren
7925          );
7926        }
7927        var prevState = current2.memoizedState;
7928        if (null !== prevState) {
7929          var JSCompiler_object_inline_componentStack_2726 = prevState.dehydrated;
7930          if (null !== JSCompiler_object_inline_componentStack_2726) {
7931            if (didSuspend)
7932              workInProgress2.flags & 256 ? (pushPrimaryTreeSuspenseHandler(workInProgress2), workInProgress2.flags &= -257, workInProgress2 = retrySuspenseComponentWithoutHydrating(
7933                current2,
7934                workInProgress2,
7935                renderLanes2
7936              )) : null !== workInProgress2.memoizedState ? (reuseSuspenseHandlerOnStack(workInProgress2), workInProgress2.child = current2.child, workInProgress2.flags |= 128, workInProgress2 = null) : (reuseSuspenseHandlerOnStack(workInProgress2), nextPrimaryChildren = JSCompiler_object_inline_stack_2725.fallback, mode = workInProgress2.mode, JSCompiler_object_inline_stack_2725 = mountWorkInProgressOffscreenFiber(
7937                {
7938                  mode: "visible",
7939                  children: JSCompiler_object_inline_stack_2725.children
7940                },
7941                mode
7942              ), nextPrimaryChildren = createFiberFromFragment(
7943                nextPrimaryChildren,
7944                mode,
7945                renderLanes2,
7946                null
7947              ), nextPrimaryChildren.flags |= 2, JSCompiler_object_inline_stack_2725.return = workInProgress2, nextPrimaryChildren.return = workInProgress2, JSCompiler_object_inline_stack_2725.sibling = nextPrimaryChildren, workInProgress2.child = JSCompiler_object_inline_stack_2725, reconcileChildFibers(
7948                workInProgress2,
7949                current2.child,
7950                null,
7951                renderLanes2
7952              ), JSCompiler_object_inline_stack_2725 = workInProgress2.child, JSCompiler_object_inline_stack_2725.memoizedState = mountSuspenseOffscreenState(renderLanes2), JSCompiler_object_inline_stack_2725.childLanes = getRemainingWorkInPrimaryTree(
7953                current2,
7954                JSCompiler_object_inline_digest_2724,
7955                renderLanes2
7956              ), workInProgress2.memoizedState = SUSPENDED_MARKER, workInProgress2 = bailoutOffscreenComponent(
7957                null,
7958                JSCompiler_object_inline_stack_2725
7959              ));
7960            else if (pushPrimaryTreeSuspenseHandler(workInProgress2), warnIfHydrating(), 0 !== (renderLanes2 & 536870912) && markRenderDerivedCause(workInProgress2), isSuspenseInstanceFallback(
7961              JSCompiler_object_inline_componentStack_2726
7962            )) {
7963              JSCompiler_object_inline_digest_2724 = JSCompiler_object_inline_componentStack_2726.nextSibling && JSCompiler_object_inline_componentStack_2726.nextSibling.dataset;
7964              if (JSCompiler_object_inline_digest_2724) {
7965                nextPrimaryChildren = JSCompiler_object_inline_digest_2724.dgst;
7966                var message = JSCompiler_object_inline_digest_2724.msg;
7967                mode = JSCompiler_object_inline_digest_2724.stck;
7968                var componentStack = JSCompiler_object_inline_digest_2724.cstck;
7969              }
7970              JSCompiler_object_inline_message_2723 = message;
7971              JSCompiler_object_inline_digest_2724 = nextPrimaryChildren;
7972              JSCompiler_object_inline_stack_2725 = mode;
7973              JSCompiler_object_inline_componentStack_2726 = componentStack;
7974              nextPrimaryChildren = JSCompiler_object_inline_message_2723;
7975              mode = JSCompiler_object_inline_componentStack_2726;
7976              nextPrimaryChildren = nextPrimaryChildren ? Error(nextPrimaryChildren) : Error(
7977                "The server could not finish this Suspense boundary, likely due to an error during server rendering. Switched to client rendering."
7978              );
7979              nextPrimaryChildren.stack = JSCompiler_object_inline_stack_2725 || "";
7980              nextPrimaryChildren.digest = JSCompiler_object_inline_digest_2724;
7981              JSCompiler_object_inline_digest_2724 = void 0 === mode ? null : mode;
7982              JSCompiler_object_inline_stack_2725 = {
7983                value: nextPrimaryChildren,
7984                source: null,
7985                stack: JSCompiler_object_inline_digest_2724
7986              };
7987              "string" === typeof JSCompiler_object_inline_digest_2724 && CapturedStacks.set(
7988                nextPrimaryChildren,
7989                JSCompiler_object_inline_stack_2725
7990              );
7991              queueHydrationError(JSCompiler_object_inline_stack_2725);
7992              workInProgress2 = retrySuspenseComponentWithoutHydrating(
7993                current2,
7994                workInProgress2,
7995                renderLanes2
7996              );
7997            } else if (didReceiveUpdate || propagateParentContextChanges(
7998              current2,
7999              workInProgress2,
8000              renderLanes2,
8001              false
8002            ), JSCompiler_object_inline_digest_2724 = 0 !== (renderLanes2 & current2.childLanes), didReceiveUpdate || JSCompiler_object_inline_digest_2724) {
8003              JSCompiler_object_inline_digest_2724 = workInProgressRoot;
8004              if (null !== JSCompiler_object_inline_digest_2724 && (JSCompiler_object_inline_stack_2725 = getBumpedLaneForHydration(
8005                JSCompiler_object_inline_digest_2724,
8006                renderLanes2
8007              ), 0 !== JSCompiler_object_inline_stack_2725 && JSCompiler_object_inline_stack_2725 !== prevState.retryLane))
8008                throw prevState.retryLane = JSCompiler_object_inline_stack_2725, enqueueConcurrentRenderForLane(
8009                  current2,
8010                  JSCompiler_object_inline_stack_2725
8011                ), scheduleUpdateOnFiber(
8012                  JSCompiler_object_inline_digest_2724,
8013                  current2,
8014                  JSCompiler_object_inline_stack_2725
8015                ), SelectiveHydrationException;
8016              isSuspenseInstancePending(
8017                JSCompiler_object_inline_componentStack_2726
8018              ) || renderDidSuspendDelayIfPossible();
8019              workInProgress2 = retrySuspenseComponentWithoutHydrating(
8020                current2,
8021                workInProgress2,
8022                renderLanes2
8023              );
8024            } else
8025              isSuspenseInstancePending(
8026                JSCompiler_object_inline_componentStack_2726
8027              ) ? (workInProgress2.flags |= 192, workInProgress2.child = current2.child, workInProgress2 = null) : (current2 = prevState.treeContext, nextHydratableInstance = getNextHydratable(
8028                JSCompiler_object_inline_componentStack_2726.nextSibling
8029              ), hydrationParentFiber = workInProgress2, isHydrating = true, hydrationErrors = null, didSuspendOrErrorDEV = false, hydrationDiffRootDEV = null, rootOrSingletonContext = false, null !== current2 && restoreSuspendedTreeContext(workInProgress2, current2), workInProgress2 = mountSuspensePrimaryChildren(
8030                workInProgress2,
8031                JSCompiler_object_inline_stack_2725.children
8032              ), workInProgress2.flags |= 4096);
8033            return workInProgress2;
8034          }
8035        }
8036        if (JSCompiler_object_inline_message_2723)
8037          return reuseSuspenseHandlerOnStack(workInProgress2), nextPrimaryChildren = JSCompiler_object_inline_stack_2725.fallback, mode = workInProgress2.mode, componentStack = current2.child, JSCompiler_object_inline_componentStack_2726 = componentStack.sibling, JSCompiler_object_inline_stack_2725 = createWorkInProgress(
8038            componentStack,
8039            {
8040              mode: "hidden",
8041              children: JSCompiler_object_inline_stack_2725.children
8042            }
8043          ), JSCompiler_object_inline_stack_2725.subtreeFlags = componentStack.subtreeFlags & 65011712, null !== JSCompiler_object_inline_componentStack_2726 ? nextPrimaryChildren = createWorkInProgress(
8044            JSCompiler_object_inline_componentStack_2726,
8045            nextPrimaryChildren
8046          ) : (nextPrimaryChildren = createFiberFromFragment(
8047            nextPrimaryChildren,
8048            mode,
8049            renderLanes2,
8050            null
8051          ), nextPrimaryChildren.flags |= 2), nextPrimaryChildren.return = workInProgress2, JSCompiler_object_inline_stack_2725.return = workInProgress2, JSCompiler_object_inline_stack_2725.sibling = nextPrimaryChildren, workInProgress2.child = JSCompiler_object_inline_stack_2725, bailoutOffscreenComponent(null, JSCompiler_object_inline_stack_2725), JSCompiler_object_inline_stack_2725 = workInProgress2.child, nextPrimaryChildren = current2.child.memoizedState, null === nextPrimaryChildren ? nextPrimaryChildren = mountSuspenseOffscreenState(renderLanes2) : (mode = nextPrimaryChildren.cachePool, null !== mode ? (componentStack = CacheContext._currentValue, mode = mode.parent !== componentStack ? { parent: componentStack, pool: componentStack } : mode) : mode = getSuspendedCache(), nextPrimaryChildren = {
8052            baseLanes: nextPrimaryChildren.baseLanes | renderLanes2,
8053            cachePool: mode
8054          }), JSCompiler_object_inline_stack_2725.memoizedState = nextPrimaryChildren, JSCompiler_object_inline_stack_2725.childLanes = getRemainingWorkInPrimaryTree(
8055            current2,
8056            JSCompiler_object_inline_digest_2724,
8057            renderLanes2
8058          ), workInProgress2.memoizedState = SUSPENDED_MARKER, bailoutOffscreenComponent(
8059            current2.child,
8060            JSCompiler_object_inline_stack_2725
8061          );
8062        null !== prevState && (renderLanes2 & 62914560) === renderLanes2 && 0 !== (renderLanes2 & current2.lanes) && markRenderDerivedCause(workInProgress2);
8063        pushPrimaryTreeSuspenseHandler(workInProgress2);
8064        renderLanes2 = current2.child;
8065        current2 = renderLanes2.sibling;
8066        renderLanes2 = createWorkInProgress(renderLanes2, {
8067          mode: "visible",
8068          children: JSCompiler_object_inline_stack_2725.children
8069        });
8070        renderLanes2.return = workInProgress2;
8071        renderLanes2.sibling = null;
8072        null !== current2 && (JSCompiler_object_inline_digest_2724 = workInProgress2.deletions, null === JSCompiler_object_inline_digest_2724 ? (workInProgress2.deletions = [current2], workInProgress2.flags |= 16) : JSCompiler_object_inline_digest_2724.push(current2));
8073        workInProgress2.child = renderLanes2;
8074        workInProgress2.memoizedState = null;
8075        return renderLanes2;
8076      }
8077      function mountSuspensePrimaryChildren(workInProgress2, primaryChildren) {
8078        primaryChildren = mountWorkInProgressOffscreenFiber(
8079          { mode: "visible", children: primaryChildren },
8080          workInProgress2.mode
8081        );
8082        primaryChildren.return = workInProgress2;
8083        return workInProgress2.child = primaryChildren;
8084      }
8085      function mountWorkInProgressOffscreenFiber(offscreenProps, mode) {
8086        offscreenProps = createFiber(22, offscreenProps, null, mode);
8087        offscreenProps.lanes = 0;
8088        return offscreenProps;
8089      }
8090      function retrySuspenseComponentWithoutHydrating(current2, workInProgress2, renderLanes2) {
8091        reconcileChildFibers(workInProgress2, current2.child, null, renderLanes2);
8092        current2 = mountSuspensePrimaryChildren(
8093          workInProgress2,
8094          workInProgress2.pendingProps.children
8095        );
8096        current2.flags |= 2;
8097        workInProgress2.memoizedState = null;
8098        return current2;
8099      }
8100      function scheduleSuspenseWorkOnFiber(fiber, renderLanes2, propagationRoot) {
8101        fiber.lanes |= renderLanes2;
8102        var alternate = fiber.alternate;
8103        null !== alternate && (alternate.lanes |= renderLanes2);
8104        scheduleContextWorkOnParentPath(
8105          fiber.return,
8106          renderLanes2,
8107          propagationRoot
8108        );
8109      }
8110      function initSuspenseListRenderState(workInProgress2, isBackwards, tail, lastContentRow, tailMode, treeForkCount2) {
8111        var renderState = workInProgress2.memoizedState;
8112        null === renderState ? workInProgress2.memoizedState = {
8113          isBackwards,
8114          rendering: null,
8115          renderingStartTime: 0,
8116          last: lastContentRow,
8117          tail,
8118          tailMode,
8119          treeForkCount: treeForkCount2
8120        } : (renderState.isBackwards = isBackwards, renderState.rendering = null, renderState.renderingStartTime = 0, renderState.last = lastContentRow, renderState.tail = tail, renderState.tailMode = tailMode, renderState.treeForkCount = treeForkCount2);
8121      }
8122      function updateSuspenseListComponent(current2, workInProgress2, renderLanes2) {
8123        var nextProps = workInProgress2.pendingProps, revealOrder = nextProps.revealOrder, tailMode = nextProps.tail, newChildren = nextProps.children, suspenseContext = suspenseStackCursor.current;
8124        (nextProps = 0 !== (suspenseContext & ForceSuspenseFallback)) ? (suspenseContext = suspenseContext & SubtreeSuspenseContextMask | ForceSuspenseFallback, workInProgress2.flags |= 128) : suspenseContext &= SubtreeSuspenseContextMask;
8125        push(suspenseStackCursor, suspenseContext, workInProgress2);
8126        suspenseContext = null == revealOrder ? "null" : revealOrder;
8127        if ("forwards" !== revealOrder && "unstable_legacy-backwards" !== revealOrder && "together" !== revealOrder && "independent" !== revealOrder && !didWarnAboutRevealOrder[suspenseContext])
8128          if (didWarnAboutRevealOrder[suspenseContext] = true, null == revealOrder)
8129            console.error(
8130              'The default for the <SuspenseList revealOrder="..."> prop is changing. To be future compatible you must explictly specify either "independent" (the current default), "together", "forwards" or "legacy_unstable-backwards".'
8131            );
8132          else if ("backwards" === revealOrder)
8133            console.error(
8134              'The rendering order of <SuspenseList revealOrder="backwards"> is changing. To be future compatible you must specify revealOrder="legacy_unstable-backwards" instead.'
8135            );
8136          else if ("string" === typeof revealOrder)
8137            switch (revealOrder.toLowerCase()) {
8138              case "together":
8139              case "forwards":
8140              case "backwards":
8141              case "independent":
8142                console.error(
8143                  '"%s" is not a valid value for revealOrder on <SuspenseList />. Use lowercase "%s" instead.',
8144                  revealOrder,
8145                  revealOrder.toLowerCase()
8146                );
8147                break;
8148              case "forward":
8149              case "backward":
8150                console.error(
8151                  '"%s" is not a valid value for revealOrder on <SuspenseList />. React uses the -s suffix in the spelling. Use "%ss" instead.',
8152                  revealOrder,
8153                  revealOrder.toLowerCase()
8154                );
8155                break;
8156              default:
8157                console.error(
8158                  '"%s" is not a supported revealOrder on <SuspenseList />. Did you mean "independent", "together", "forwards" or "backwards"?',
8159                  revealOrder
8160                );
8161            }
8162          else
8163            console.error(
8164              '%s is not a supported value for revealOrder on <SuspenseList />. Did you mean "independent", "together", "forwards" or "backwards"?',
8165              revealOrder
8166            );
8167        suspenseContext = null == tailMode ? "null" : tailMode;
8168        if (!didWarnAboutTailOptions[suspenseContext])
8169          if (null == tailMode) {
8170            if ("forwards" === revealOrder || "backwards" === revealOrder || "unstable_legacy-backwards" === revealOrder)
8171              didWarnAboutTailOptions[suspenseContext] = true, console.error(
8172                'The default for the <SuspenseList tail="..."> prop is changing. To be future compatible you must explictly specify either "visible" (the current default), "collapsed" or "hidden".'
8173              );
8174          } else
8175            "visible" !== tailMode && "collapsed" !== tailMode && "hidden" !== tailMode ? (didWarnAboutTailOptions[suspenseContext] = true, console.error(
8176              '"%s" is not a supported value for tail on <SuspenseList />. Did you mean "visible", "collapsed" or "hidden"?',
8177              tailMode
8178            )) : "forwards" !== revealOrder && "backwards" !== revealOrder && "unstable_legacy-backwards" !== revealOrder && (didWarnAboutTailOptions[suspenseContext] = true, console.error(
8179              '<SuspenseList tail="%s" /> is only valid if revealOrder is "forwards" or "backwards". Did you mean to specify revealOrder="forwards"?',
8180              tailMode
8181            ));
8182        a: if (("forwards" === revealOrder || "backwards" === revealOrder || "unstable_legacy-backwards" === revealOrder) && void 0 !== newChildren && null !== newChildren && false !== newChildren)
8183          if (isArrayImpl(newChildren))
8184            for (suspenseContext = 0; suspenseContext < newChildren.length; suspenseContext++) {
8185              if (!validateSuspenseListNestedChild(
8186                newChildren[suspenseContext],
8187                suspenseContext
8188              ))
8189                break a;
8190            }
8191          else if (suspenseContext = getIteratorFn(newChildren), "function" === typeof suspenseContext) {
8192            if (suspenseContext = suspenseContext.call(newChildren))
8193              for (var step = suspenseContext.next(), _i = 0; !step.done; step = suspenseContext.next()) {
8194                if (!validateSuspenseListNestedChild(step.value, _i)) break a;
8195                _i++;
8196              }
8197          } else
8198            console.error(
8199              'A single row was passed to a <SuspenseList revealOrder="%s" />. This is not useful since it needs multiple rows. Did you mean to pass multiple children or an array?',
8200              revealOrder
8201            );
8202        reconcileChildren(current2, workInProgress2, newChildren, renderLanes2);
8203        isHydrating ? (warnIfNotHydrating(), newChildren = treeForkCount) : newChildren = 0;
8204        if (!nextProps && null !== current2 && 0 !== (current2.flags & 128))
8205          a: for (current2 = workInProgress2.child; null !== current2; ) {
8206            if (13 === current2.tag)
8207              null !== current2.memoizedState && scheduleSuspenseWorkOnFiber(current2, renderLanes2, workInProgress2);
8208            else if (19 === current2.tag)
8209              scheduleSuspenseWorkOnFiber(current2, renderLanes2, workInProgress2);
8210            else if (null !== current2.child) {
8211              current2.child.return = current2;
8212              current2 = current2.child;
8213              continue;
8214            }
8215            if (current2 === workInProgress2) break a;
8216            for (; null === current2.sibling; ) {
8217              if (null === current2.return || current2.return === workInProgress2)
8218                break a;
8219              current2 = current2.return;
8220            }
8221            current2.sibling.return = current2.return;
8222            current2 = current2.sibling;
8223          }
8224        switch (revealOrder) {
8225          case "forwards":
8226            renderLanes2 = workInProgress2.child;
8227            for (revealOrder = null; null !== renderLanes2; )
8228              current2 = renderLanes2.alternate, null !== current2 && null === findFirstSuspended(current2) && (revealOrder = renderLanes2), renderLanes2 = renderLanes2.sibling;
8229            renderLanes2 = revealOrder;
8230            null === renderLanes2 ? (revealOrder = workInProgress2.child, workInProgress2.child = null) : (revealOrder = renderLanes2.sibling, renderLanes2.sibling = null);
8231            initSuspenseListRenderState(
8232              workInProgress2,
8233              false,
8234              revealOrder,
8235              renderLanes2,
8236              tailMode,
8237              newChildren
8238            );
8239            break;
8240          case "backwards":
8241          case "unstable_legacy-backwards":
8242            renderLanes2 = null;
8243            revealOrder = workInProgress2.child;
8244            for (workInProgress2.child = null; null !== revealOrder; ) {
8245              current2 = revealOrder.alternate;
8246              if (null !== current2 && null === findFirstSuspended(current2)) {
8247                workInProgress2.child = revealOrder;
8248                break;
8249              }
8250              current2 = revealOrder.sibling;
8251              revealOrder.sibling = renderLanes2;
8252              renderLanes2 = revealOrder;
8253              revealOrder = current2;
8254            }
8255            initSuspenseListRenderState(
8256              workInProgress2,
8257              true,
8258              renderLanes2,
8259              null,
8260              tailMode,
8261              newChildren
8262            );
8263            break;
8264          case "together":
8265            initSuspenseListRenderState(
8266              workInProgress2,
8267              false,
8268              null,
8269              null,
8270              void 0,
8271              newChildren
8272            );
8273            break;
8274          default:
8275            workInProgress2.memoizedState = null;
8276        }
8277        return workInProgress2.child;
8278      }
8279      function bailoutOnAlreadyFinishedWork(current2, workInProgress2, renderLanes2) {
8280        null !== current2 && (workInProgress2.dependencies = current2.dependencies);
8281        profilerStartTime = -1;
8282        workInProgressRootSkippedLanes |= workInProgress2.lanes;
8283        if (0 === (renderLanes2 & workInProgress2.childLanes))
8284          if (null !== current2) {
8285            if (propagateParentContextChanges(
8286              current2,
8287              workInProgress2,
8288              renderLanes2,
8289              false
8290            ), 0 === (renderLanes2 & workInProgress2.childLanes))
8291              return null;
8292          } else return null;
8293        if (null !== current2 && workInProgress2.child !== current2.child)
8294          throw Error("Resuming work not yet implemented.");
8295        if (null !== workInProgress2.child) {
8296          current2 = workInProgress2.child;
8297          renderLanes2 = createWorkInProgress(current2, current2.pendingProps);
8298          workInProgress2.child = renderLanes2;
8299          for (renderLanes2.return = workInProgress2; null !== current2.sibling; )
8300            current2 = current2.sibling, renderLanes2 = renderLanes2.sibling = createWorkInProgress(current2, current2.pendingProps), renderLanes2.return = workInProgress2;
8301          renderLanes2.sibling = null;
8302        }
8303        return workInProgress2.child;
8304      }
8305      function checkScheduledUpdateOrContext(current2, renderLanes2) {
8306        if (0 !== (current2.lanes & renderLanes2)) return true;
8307        current2 = current2.dependencies;
8308        return null !== current2 && checkIfContextChanged(current2) ? true : false;
8309      }
8310      function attemptEarlyBailoutIfNoScheduledUpdate(current2, workInProgress2, renderLanes2) {
8311        switch (workInProgress2.tag) {
8312          case 3:
8313            pushHostContainer(
8314              workInProgress2,
8315              workInProgress2.stateNode.containerInfo
8316            );
8317            pushProvider(
8318              workInProgress2,
8319              CacheContext,
8320              current2.memoizedState.cache
8321            );
8322            resetHydrationState();
8323            break;
8324          case 27:
8325          case 5:
8326            pushHostContext(workInProgress2);
8327            break;
8328          case 4:
8329            pushHostContainer(
8330              workInProgress2,
8331              workInProgress2.stateNode.containerInfo
8332            );
8333            break;
8334          case 10:
8335            pushProvider(
8336              workInProgress2,
8337              workInProgress2.type,
8338              workInProgress2.memoizedProps.value
8339            );
8340            break;
8341          case 12:
8342            0 !== (renderLanes2 & workInProgress2.childLanes) && (workInProgress2.flags |= 4);
8343            workInProgress2.flags |= 2048;
8344            var stateNode = workInProgress2.stateNode;
8345            stateNode.effectDuration = -0;
8346            stateNode.passiveEffectDuration = -0;
8347            break;
8348          case 31:
8349            if (null !== workInProgress2.memoizedState)
8350              return workInProgress2.flags |= 128, pushDehydratedActivitySuspenseHandler(workInProgress2), null;
8351            break;
8352          case 13:
8353            stateNode = workInProgress2.memoizedState;
8354            if (null !== stateNode) {
8355              if (null !== stateNode.dehydrated)
8356                return pushPrimaryTreeSuspenseHandler(workInProgress2), workInProgress2.flags |= 128, null;
8357              if (0 !== (renderLanes2 & workInProgress2.child.childLanes))
8358                return updateSuspenseComponent(
8359                  current2,
8360                  workInProgress2,
8361                  renderLanes2
8362                );
8363              pushPrimaryTreeSuspenseHandler(workInProgress2);
8364              current2 = bailoutOnAlreadyFinishedWork(
8365                current2,
8366                workInProgress2,
8367                renderLanes2
8368              );
8369              return null !== current2 ? current2.sibling : null;
8370            }
8371            pushPrimaryTreeSuspenseHandler(workInProgress2);
8372            break;
8373          case 19:
8374            var didSuspendBefore = 0 !== (current2.flags & 128);
8375            stateNode = 0 !== (renderLanes2 & workInProgress2.childLanes);
8376            stateNode || (propagateParentContextChanges(
8377              current2,
8378              workInProgress2,
8379              renderLanes2,
8380              false
8381            ), stateNode = 0 !== (renderLanes2 & workInProgress2.childLanes));
8382            if (didSuspendBefore) {
8383              if (stateNode)
8384                return updateSuspenseListComponent(
8385                  current2,
8386                  workInProgress2,
8387                  renderLanes2
8388                );
8389              workInProgress2.flags |= 128;
8390            }
8391            didSuspendBefore = workInProgress2.memoizedState;
8392            null !== didSuspendBefore && (didSuspendBefore.rendering = null, didSuspendBefore.tail = null, didSuspendBefore.lastEffect = null);
8393            push(
8394              suspenseStackCursor,
8395              suspenseStackCursor.current,
8396              workInProgress2
8397            );
8398            if (stateNode) break;
8399            else return null;
8400          case 22:
8401            return workInProgress2.lanes = 0, updateOffscreenComponent(
8402              current2,
8403              workInProgress2,
8404              renderLanes2,
8405              workInProgress2.pendingProps
8406            );
8407          case 24:
8408            pushProvider(
8409              workInProgress2,
8410              CacheContext,
8411              current2.memoizedState.cache
8412            );
8413        }
8414        return bailoutOnAlreadyFinishedWork(current2, workInProgress2, renderLanes2);
8415      }
8416      function beginWork(current2, workInProgress2, renderLanes2) {
8417        if (workInProgress2._debugNeedsRemount && null !== current2) {
8418          renderLanes2 = createFiberFromTypeAndProps(
8419            workInProgress2.type,
8420            workInProgress2.key,
8421            workInProgress2.pendingProps,
8422            workInProgress2._debugOwner || null,
8423            workInProgress2.mode,
8424            workInProgress2.lanes
8425          );
8426          renderLanes2._debugStack = workInProgress2._debugStack;
8427          renderLanes2._debugTask = workInProgress2._debugTask;
8428          var returnFiber = workInProgress2.return;
8429          if (null === returnFiber) throw Error("Cannot swap the root fiber.");
8430          current2.alternate = null;
8431          workInProgress2.alternate = null;
8432          renderLanes2.index = workInProgress2.index;
8433          renderLanes2.sibling = workInProgress2.sibling;
8434          renderLanes2.return = workInProgress2.return;
8435          renderLanes2.ref = workInProgress2.ref;
8436          renderLanes2._debugInfo = workInProgress2._debugInfo;
8437          if (workInProgress2 === returnFiber.child)
8438            returnFiber.child = renderLanes2;
8439          else {
8440            var prevSibling = returnFiber.child;
8441            if (null === prevSibling)
8442              throw Error("Expected parent to have a child.");
8443            for (; prevSibling.sibling !== workInProgress2; )
8444              if (prevSibling = prevSibling.sibling, null === prevSibling)
8445                throw Error("Expected to find the previous sibling.");
8446            prevSibling.sibling = renderLanes2;
8447          }
8448          workInProgress2 = returnFiber.deletions;
8449          null === workInProgress2 ? (returnFiber.deletions = [current2], returnFiber.flags |= 16) : workInProgress2.push(current2);
8450          renderLanes2.flags |= 2;
8451          return renderLanes2;
8452        }
8453        if (null !== current2)
8454          if (current2.memoizedProps !== workInProgress2.pendingProps || workInProgress2.type !== current2.type)
8455            didReceiveUpdate = true;
8456          else {
8457            if (!checkScheduledUpdateOrContext(current2, renderLanes2) && 0 === (workInProgress2.flags & 128))
8458              return didReceiveUpdate = false, attemptEarlyBailoutIfNoScheduledUpdate(
8459                current2,
8460                workInProgress2,
8461                renderLanes2
8462              );
8463            didReceiveUpdate = 0 !== (current2.flags & 131072) ? true : false;
8464          }
8465        else {
8466          didReceiveUpdate = false;
8467          if (returnFiber = isHydrating)
8468            warnIfNotHydrating(), returnFiber = 0 !== (workInProgress2.flags & 1048576);
8469          returnFiber && (returnFiber = workInProgress2.index, warnIfNotHydrating(), pushTreeId(workInProgress2, treeForkCount, returnFiber));
8470        }
8471        workInProgress2.lanes = 0;
8472        switch (workInProgress2.tag) {
8473          case 16:
8474            a: if (returnFiber = workInProgress2.pendingProps, current2 = resolveLazy(workInProgress2.elementType), workInProgress2.type = current2, "function" === typeof current2)
8475              shouldConstruct(current2) ? (returnFiber = resolveClassComponentProps(
8476                current2,
8477                returnFiber
8478              ), workInProgress2.tag = 1, workInProgress2.type = current2 = resolveFunctionForHotReloading(current2), workInProgress2 = updateClassComponent(
8479                null,
8480                workInProgress2,
8481                current2,
8482                returnFiber,
8483                renderLanes2
8484              )) : (workInProgress2.tag = 0, validateFunctionComponentInDev(workInProgress2, current2), workInProgress2.type = current2 = resolveFunctionForHotReloading(current2), workInProgress2 = updateFunctionComponent(
8485                null,
8486                workInProgress2,
8487                current2,
8488                returnFiber,
8489                renderLanes2
8490              ));
8491            else {
8492              if (void 0 !== current2 && null !== current2) {
8493                if (prevSibling = current2.$$typeof, prevSibling === REACT_FORWARD_REF_TYPE) {
8494                  workInProgress2.tag = 11;
8495                  workInProgress2.type = current2 = resolveForwardRefForHotReloading(current2);
8496                  workInProgress2 = updateForwardRef(
8497                    null,
8498                    workInProgress2,
8499                    current2,
8500                    returnFiber,
8501                    renderLanes2
8502                  );
8503                  break a;
8504                } else if (prevSibling === REACT_MEMO_TYPE) {
8505                  workInProgress2.tag = 14;
8506                  workInProgress2 = updateMemoComponent(
8507                    null,
8508                    workInProgress2,
8509                    current2,
8510                    returnFiber,
8511                    renderLanes2
8512                  );
8513                  break a;
8514                }
8515              }
8516              workInProgress2 = "";
8517              null !== current2 && "object" === typeof current2 && current2.$$typeof === REACT_LAZY_TYPE && (workInProgress2 = " Did you wrap a component in React.lazy() more than once?");
8518              renderLanes2 = getComponentNameFromType(current2) || current2;
8519              throw Error(
8520                "Element type is invalid. Received a promise that resolves to: " + renderLanes2 + ". Lazy element type must resolve to a class or function." + workInProgress2
8521              );
8522            }
8523            return workInProgress2;
8524          case 0:
8525            return updateFunctionComponent(
8526              current2,
8527              workInProgress2,
8528              workInProgress2.type,
8529              workInProgress2.pendingProps,
8530              renderLanes2
8531            );
8532          case 1:
8533            return returnFiber = workInProgress2.type, prevSibling = resolveClassComponentProps(
8534              returnFiber,
8535              workInProgress2.pendingProps
8536            ), updateClassComponent(
8537              current2,
8538              workInProgress2,
8539              returnFiber,
8540              prevSibling,
8541              renderLanes2
8542            );
8543          case 3:
8544            a: {
8545              pushHostContainer(
8546                workInProgress2,
8547                workInProgress2.stateNode.containerInfo
8548              );
8549              if (null === current2)
8550                throw Error(
8551                  "Should have a current fiber. This is a bug in React."
8552                );
8553              returnFiber = workInProgress2.pendingProps;
8554              var prevState = workInProgress2.memoizedState;
8555              prevSibling = prevState.element;
8556              cloneUpdateQueue(current2, workInProgress2);
8557              processUpdateQueue(workInProgress2, returnFiber, null, renderLanes2);
8558              var nextState = workInProgress2.memoizedState;
8559              returnFiber = nextState.cache;
8560              pushProvider(workInProgress2, CacheContext, returnFiber);
8561              returnFiber !== prevState.cache && propagateContextChanges(
8562                workInProgress2,
8563                [CacheContext],
8564                renderLanes2,
8565                true
8566              );
8567              suspendIfUpdateReadFromEntangledAsyncAction();
8568              returnFiber = nextState.element;
8569              if (prevState.isDehydrated)
8570                if (prevState = {
8571                  element: returnFiber,
8572                  isDehydrated: false,
8573                  cache: nextState.cache
8574                }, workInProgress2.updateQueue.baseState = prevState, workInProgress2.memoizedState = prevState, workInProgress2.flags & 256) {
8575                  workInProgress2 = mountHostRootWithoutHydrating(
8576                    current2,
8577                    workInProgress2,
8578                    returnFiber,
8579                    renderLanes2
8580                  );
8581                  break a;
8582                } else if (returnFiber !== prevSibling) {
8583                  prevSibling = createCapturedValueAtFiber(
8584                    Error(
8585                      "This root received an early update, before anything was able hydrate. Switched the entire root to client rendering."
8586                    ),
8587                    workInProgress2
8588                  );
8589                  queueHydrationError(prevSibling);
8590                  workInProgress2 = mountHostRootWithoutHydrating(
8591                    current2,
8592                    workInProgress2,
8593                    returnFiber,
8594                    renderLanes2
8595                  );
8596                  break a;
8597                } else {
8598                  current2 = workInProgress2.stateNode.containerInfo;
8599                  switch (current2.nodeType) {
8600                    case 9:
8601                      current2 = current2.body;
8602                      break;
8603                    default:
8604                      current2 = "HTML" === current2.nodeName ? current2.ownerDocument.body : current2;
8605                  }
8606                  nextHydratableInstance = getNextHydratable(current2.firstChild);
8607                  hydrationParentFiber = workInProgress2;
8608                  isHydrating = true;
8609                  hydrationErrors = null;
8610                  didSuspendOrErrorDEV = false;
8611                  hydrationDiffRootDEV = null;
8612                  rootOrSingletonContext = true;
8613                  renderLanes2 = mountChildFibers(
8614                    workInProgress2,
8615                    null,
8616                    returnFiber,
8617                    renderLanes2
8618                  );
8619                  for (workInProgress2.child = renderLanes2; renderLanes2; )
8620                    renderLanes2.flags = renderLanes2.flags & -3 | 4096, renderLanes2 = renderLanes2.sibling;
8621                }
8622              else {
8623                resetHydrationState();
8624                if (returnFiber === prevSibling) {
8625                  workInProgress2 = bailoutOnAlreadyFinishedWork(
8626                    current2,
8627                    workInProgress2,
8628                    renderLanes2
8629                  );
8630                  break a;
8631                }
8632                reconcileChildren(
8633                  current2,
8634                  workInProgress2,
8635                  returnFiber,
8636                  renderLanes2
8637                );
8638              }
8639              workInProgress2 = workInProgress2.child;
8640            }
8641            return workInProgress2;
8642          case 26:
8643            return markRef(current2, workInProgress2), null === current2 ? (renderLanes2 = getResource(
8644              workInProgress2.type,
8645              null,
8646              workInProgress2.pendingProps,
8647              null
8648            )) ? workInProgress2.memoizedState = renderLanes2 : isHydrating || (renderLanes2 = workInProgress2.type, current2 = workInProgress2.pendingProps, returnFiber = requiredContext(
8649              rootInstanceStackCursor.current
8650            ), returnFiber = getOwnerDocumentFromRootContainer(
8651              returnFiber
8652            ).createElement(renderLanes2), returnFiber[internalInstanceKey] = workInProgress2, returnFiber[internalPropsKey] = current2, setInitialProperties(returnFiber, renderLanes2, current2), markNodeAsHoistable(returnFiber), workInProgress2.stateNode = returnFiber) : workInProgress2.memoizedState = getResource(
8653              workInProgress2.type,
8654              current2.memoizedProps,
8655              workInProgress2.pendingProps,
8656              current2.memoizedState
8657            ), null;
8658          case 27:
8659            return pushHostContext(workInProgress2), null === current2 && isHydrating && (returnFiber = requiredContext(rootInstanceStackCursor.current), prevSibling = getHostContext(), returnFiber = workInProgress2.stateNode = resolveSingletonInstance(
8660              workInProgress2.type,
8661              workInProgress2.pendingProps,
8662              returnFiber,
8663              prevSibling,
8664              false
8665            ), didSuspendOrErrorDEV || (prevSibling = diffHydratedProperties(
8666              returnFiber,
8667              workInProgress2.type,
8668              workInProgress2.pendingProps,
8669              prevSibling
8670            ), null !== prevSibling && (buildHydrationDiffNode(workInProgress2, 0).serverProps = prevSibling)), hydrationParentFiber = workInProgress2, rootOrSingletonContext = true, prevSibling = nextHydratableInstance, isSingletonScope(workInProgress2.type) ? (previousHydratableOnEnteringScopedSingleton = prevSibling, nextHydratableInstance = getNextHydratable(
8671              returnFiber.firstChild
8672            )) : nextHydratableInstance = prevSibling), reconcileChildren(
8673              current2,
8674              workInProgress2,
8675              workInProgress2.pendingProps.children,
8676              renderLanes2
8677            ), markRef(current2, workInProgress2), null === current2 && (workInProgress2.flags |= 4194304), workInProgress2.child;
8678          case 5:
8679            return null === current2 && isHydrating && (prevState = getHostContext(), returnFiber = validateDOMNesting(
8680              workInProgress2.type,
8681              prevState.ancestorInfo
8682            ), prevSibling = nextHydratableInstance, (nextState = !prevSibling) || (nextState = canHydrateInstance(
8683              prevSibling,
8684              workInProgress2.type,
8685              workInProgress2.pendingProps,
8686              rootOrSingletonContext
8687            ), null !== nextState ? (workInProgress2.stateNode = nextState, didSuspendOrErrorDEV || (prevState = diffHydratedProperties(
8688              nextState,
8689              workInProgress2.type,
8690              workInProgress2.pendingProps,
8691              prevState
8692            ), null !== prevState && (buildHydrationDiffNode(workInProgress2, 0).serverProps = prevState)), hydrationParentFiber = workInProgress2, nextHydratableInstance = getNextHydratable(
8693              nextState.firstChild
8694            ), rootOrSingletonContext = false, prevState = true) : prevState = false, nextState = !prevState), nextState && (returnFiber && warnNonHydratedInstance(workInProgress2, prevSibling), throwOnHydrationMismatch(workInProgress2))), pushHostContext(workInProgress2), prevSibling = workInProgress2.type, prevState = workInProgress2.pendingProps, nextState = null !== current2 ? current2.memoizedProps : null, returnFiber = prevState.children, shouldSetTextContent(prevSibling, prevState) ? returnFiber = null : null !== nextState && shouldSetTextContent(prevSibling, nextState) && (workInProgress2.flags |= 32), null !== workInProgress2.memoizedState && (prevSibling = renderWithHooks(
8695              current2,
8696              workInProgress2,
8697              TransitionAwareHostComponent,
8698              null,
8699              null,
8700              renderLanes2
8701            ), HostTransitionContext._currentValue = prevSibling), markRef(current2, workInProgress2), reconcileChildren(
8702              current2,
8703              workInProgress2,
8704              returnFiber,
8705              renderLanes2
8706            ), workInProgress2.child;
8707          case 6:
8708            return null === current2 && isHydrating && (renderLanes2 = workInProgress2.pendingProps, current2 = getHostContext(), returnFiber = current2.ancestorInfo.current, renderLanes2 = null != returnFiber ? validateTextNesting(
8709              renderLanes2,
8710              returnFiber.tag,
8711              current2.ancestorInfo.implicitRootScope
8712            ) : true, current2 = nextHydratableInstance, (returnFiber = !current2) || (returnFiber = canHydrateTextInstance(
8713              current2,
8714              workInProgress2.pendingProps,
8715              rootOrSingletonContext
8716            ), null !== returnFiber ? (workInProgress2.stateNode = returnFiber, hydrationParentFiber = workInProgress2, nextHydratableInstance = null, returnFiber = true) : returnFiber = false, returnFiber = !returnFiber), returnFiber && (renderLanes2 && warnNonHydratedInstance(workInProgress2, current2), throwOnHydrationMismatch(workInProgress2))), null;
8717          case 13:
8718            return updateSuspenseComponent(current2, workInProgress2, renderLanes2);
8719          case 4:
8720            return pushHostContainer(
8721              workInProgress2,
8722              workInProgress2.stateNode.containerInfo
8723            ), returnFiber = workInProgress2.pendingProps, null === current2 ? workInProgress2.child = reconcileChildFibers(
8724              workInProgress2,
8725              null,
8726              returnFiber,
8727              renderLanes2
8728            ) : reconcileChildren(
8729              current2,
8730              workInProgress2,
8731              returnFiber,
8732              renderLanes2
8733            ), workInProgress2.child;
8734          case 11:
8735            return updateForwardRef(
8736              current2,
8737              workInProgress2,
8738              workInProgress2.type,
8739              workInProgress2.pendingProps,
8740              renderLanes2
8741            );
8742          case 7:
8743            return reconcileChildren(
8744              current2,
8745              workInProgress2,
8746              workInProgress2.pendingProps,
8747              renderLanes2
8748            ), workInProgress2.child;
8749          case 8:
8750            return reconcileChildren(
8751              current2,
8752              workInProgress2,
8753              workInProgress2.pendingProps.children,
8754              renderLanes2
8755            ), workInProgress2.child;
8756          case 12:
8757            return workInProgress2.flags |= 4, workInProgress2.flags |= 2048, returnFiber = workInProgress2.stateNode, returnFiber.effectDuration = -0, returnFiber.passiveEffectDuration = -0, reconcileChildren(
8758              current2,
8759              workInProgress2,
8760              workInProgress2.pendingProps.children,
8761              renderLanes2
8762            ), workInProgress2.child;
8763          case 10:
8764            return returnFiber = workInProgress2.type, prevSibling = workInProgress2.pendingProps, prevState = prevSibling.value, "value" in prevSibling || hasWarnedAboutUsingNoValuePropOnContextProvider || (hasWarnedAboutUsingNoValuePropOnContextProvider = true, console.error(
8765              "The `value` prop is required for the `<Context.Provider>`. Did you misspell it or forget to pass it?"
8766            )), pushProvider(workInProgress2, returnFiber, prevState), reconcileChildren(
8767              current2,
8768              workInProgress2,
8769              prevSibling.children,
8770              renderLanes2
8771            ), workInProgress2.child;
8772          case 9:
8773            return prevSibling = workInProgress2.type._context, returnFiber = workInProgress2.pendingProps.children, "function" !== typeof returnFiber && console.error(
8774              "A context consumer was rendered with multiple children, or a child that isn't a function. A context consumer expects a single child that is a function. If you did pass a function, make sure there is no trailing or leading whitespace around it."
8775            ), prepareToReadContext(workInProgress2), prevSibling = readContext(prevSibling), returnFiber = callComponentInDEV(
8776              returnFiber,
8777              prevSibling,
8778              void 0
8779            ), workInProgress2.flags |= 1, reconcileChildren(
8780              current2,
8781              workInProgress2,
8782              returnFiber,
8783              renderLanes2
8784            ), workInProgress2.child;
8785          case 14:
8786            return updateMemoComponent(
8787              current2,
8788              workInProgress2,
8789              workInProgress2.type,
8790              workInProgress2.pendingProps,
8791              renderLanes2
8792            );
8793          case 15:
8794            return updateSimpleMemoComponent(
8795              current2,
8796              workInProgress2,
8797              workInProgress2.type,
8798              workInProgress2.pendingProps,
8799              renderLanes2
8800            );
8801          case 19:
8802            return updateSuspenseListComponent(
8803              current2,
8804              workInProgress2,
8805              renderLanes2
8806            );
8807          case 31:
8808            return updateActivityComponent(current2, workInProgress2, renderLanes2);
8809          case 22:
8810            return updateOffscreenComponent(
8811              current2,
8812              workInProgress2,
8813              renderLanes2,
8814              workInProgress2.pendingProps
8815            );
8816          case 24:
8817            return prepareToReadContext(workInProgress2), returnFiber = readContext(CacheContext), null === current2 ? (prevSibling = peekCacheFromPool(), null === prevSibling && (prevSibling = workInProgressRoot, prevState = createCache(), prevSibling.pooledCache = prevState, retainCache(prevState), null !== prevState && (prevSibling.pooledCacheLanes |= renderLanes2), prevSibling = prevState), workInProgress2.memoizedState = {
8818              parent: returnFiber,
8819              cache: prevSibling
8820            }, initializeUpdateQueue(workInProgress2), pushProvider(workInProgress2, CacheContext, prevSibling)) : (0 !== (current2.lanes & renderLanes2) && (cloneUpdateQueue(current2, workInProgress2), processUpdateQueue(workInProgress2, null, null, renderLanes2), suspendIfUpdateReadFromEntangledAsyncAction()), prevSibling = current2.memoizedState, prevState = workInProgress2.memoizedState, prevSibling.parent !== returnFiber ? (prevSibling = {
8821              parent: returnFiber,
8822              cache: returnFiber
8823            }, workInProgress2.memoizedState = prevSibling, 0 === workInProgress2.lanes && (workInProgress2.memoizedState = workInProgress2.updateQueue.baseState = prevSibling), pushProvider(workInProgress2, CacheContext, returnFiber)) : (returnFiber = prevState.cache, pushProvider(workInProgress2, CacheContext, returnFiber), returnFiber !== prevSibling.cache && propagateContextChanges(
8824              workInProgress2,
8825              [CacheContext],
8826              renderLanes2,
8827              true
8828            ))), reconcileChildren(
8829              current2,
8830              workInProgress2,
8831              workInProgress2.pendingProps.children,
8832              renderLanes2
8833            ), workInProgress2.child;
8834          case 29:
8835            throw workInProgress2.pendingProps;
8836        }
8837        throw Error(
8838          "Unknown unit of work tag (" + workInProgress2.tag + "). This error is likely caused by a bug in React. Please file an issue."
8839        );
8840      }
8841      function markUpdate(workInProgress2) {
8842        workInProgress2.flags |= 4;
8843      }
8844      function preloadInstanceAndSuspendIfNeeded(workInProgress2, type, oldProps, newProps, renderLanes2) {
8845        if (type = (workInProgress2.mode & SuspenseyImagesMode) !== NoMode)
8846          type = false;
8847        if (type) {
8848          if (workInProgress2.flags |= 16777216, (renderLanes2 & 335544128) === renderLanes2)
8849            if (workInProgress2.stateNode.complete) workInProgress2.flags |= 8192;
8850            else if (shouldRemainOnPreviousScreen()) workInProgress2.flags |= 8192;
8851            else
8852              throw suspendedThenable = noopSuspenseyCommitThenable, SuspenseyCommitException;
8853        } else workInProgress2.flags &= -16777217;
8854      }
8855      function preloadResourceAndSuspendIfNeeded(workInProgress2, resource) {
8856        if ("stylesheet" !== resource.type || (resource.state.loading & Inserted) !== NotLoaded)
8857          workInProgress2.flags &= -16777217;
8858        else if (workInProgress2.flags |= 16777216, !preloadResource(resource))
8859          if (shouldRemainOnPreviousScreen()) workInProgress2.flags |= 8192;
8860          else
8861            throw suspendedThenable = noopSuspenseyCommitThenable, SuspenseyCommitException;
8862      }
8863      function scheduleRetryEffect(workInProgress2, retryQueue) {
8864        null !== retryQueue && (workInProgress2.flags |= 4);
8865        workInProgress2.flags & 16384 && (retryQueue = 22 !== workInProgress2.tag ? claimNextRetryLane() : 536870912, workInProgress2.lanes |= retryQueue, workInProgressSuspendedRetryLanes |= retryQueue);
8866      }
8867      function cutOffTailIfNeeded(renderState, hasRenderedATailFallback) {
8868        if (!isHydrating)
8869          switch (renderState.tailMode) {
8870            case "hidden":
8871              hasRenderedATailFallback = renderState.tail;
8872              for (var lastTailNode = null; null !== hasRenderedATailFallback; )
8873                null !== hasRenderedATailFallback.alternate && (lastTailNode = hasRenderedATailFallback), hasRenderedATailFallback = hasRenderedATailFallback.sibling;
8874              null === lastTailNode ? renderState.tail = null : lastTailNode.sibling = null;
8875              break;
8876            case "collapsed":
8877              lastTailNode = renderState.tail;
8878              for (var _lastTailNode = null; null !== lastTailNode; )
8879                null !== lastTailNode.alternate && (_lastTailNode = lastTailNode), lastTailNode = lastTailNode.sibling;
8880              null === _lastTailNode ? hasRenderedATailFallback || null === renderState.tail ? renderState.tail = null : renderState.tail.sibling = null : _lastTailNode.sibling = null;
8881          }
8882      }
8883      function bubbleProperties(completedWork) {
8884        var didBailout = null !== completedWork.alternate && completedWork.alternate.child === completedWork.child, newChildLanes = 0, subtreeFlags = 0;
8885        if (didBailout)
8886          if ((completedWork.mode & ProfileMode) !== NoMode) {
8887            for (var _treeBaseDuration = completedWork.selfBaseDuration, _child2 = completedWork.child; null !== _child2; )
8888              newChildLanes |= _child2.lanes | _child2.childLanes, subtreeFlags |= _child2.subtreeFlags & 65011712, subtreeFlags |= _child2.flags & 65011712, _treeBaseDuration += _child2.treeBaseDuration, _child2 = _child2.sibling;
8889            completedWork.treeBaseDuration = _treeBaseDuration;
8890          } else
8891            for (_treeBaseDuration = completedWork.child; null !== _treeBaseDuration; )
8892              newChildLanes |= _treeBaseDuration.lanes | _treeBaseDuration.childLanes, subtreeFlags |= _treeBaseDuration.subtreeFlags & 65011712, subtreeFlags |= _treeBaseDuration.flags & 65011712, _treeBaseDuration.return = completedWork, _treeBaseDuration = _treeBaseDuration.sibling;
8893        else if ((completedWork.mode & ProfileMode) !== NoMode) {
8894          _treeBaseDuration = completedWork.actualDuration;
8895          _child2 = completedWork.selfBaseDuration;
8896          for (var child = completedWork.child; null !== child; )
8897            newChildLanes |= child.lanes | child.childLanes, subtreeFlags |= child.subtreeFlags, subtreeFlags |= child.flags, _treeBaseDuration += child.actualDuration, _child2 += child.treeBaseDuration, child = child.sibling;
8898          completedWork.actualDuration = _treeBaseDuration;
8899          completedWork.treeBaseDuration = _child2;
8900        } else
8901          for (_treeBaseDuration = completedWork.child; null !== _treeBaseDuration; )
8902            newChildLanes |= _treeBaseDuration.lanes | _treeBaseDuration.childLanes, subtreeFlags |= _treeBaseDuration.subtreeFlags, subtreeFlags |= _treeBaseDuration.flags, _treeBaseDuration.return = completedWork, _treeBaseDuration = _treeBaseDuration.sibling;
8903        completedWork.subtreeFlags |= subtreeFlags;
8904        completedWork.childLanes = newChildLanes;
8905        return didBailout;
8906      }
8907      function completeWork(current2, workInProgress2, renderLanes2) {
8908        var newProps = workInProgress2.pendingProps;
8909        popTreeContext(workInProgress2);
8910        switch (workInProgress2.tag) {
8911          case 16:
8912          case 15:
8913          case 0:
8914          case 11:
8915          case 7:
8916          case 8:
8917          case 12:
8918          case 9:
8919          case 14:
8920            return bubbleProperties(workInProgress2), null;
8921          case 1:
8922            return bubbleProperties(workInProgress2), null;
8923          case 3:
8924            renderLanes2 = workInProgress2.stateNode;
8925            newProps = null;
8926            null !== current2 && (newProps = current2.memoizedState.cache);
8927            workInProgress2.memoizedState.cache !== newProps && (workInProgress2.flags |= 2048);
8928            popProvider(CacheContext, workInProgress2);
8929            popHostContainer(workInProgress2);
8930            renderLanes2.pendingContext && (renderLanes2.context = renderLanes2.pendingContext, renderLanes2.pendingContext = null);
8931            if (null === current2 || null === current2.child)
8932              popHydrationState(workInProgress2) ? (emitPendingHydrationWarnings(), markUpdate(workInProgress2)) : null === current2 || current2.memoizedState.isDehydrated && 0 === (workInProgress2.flags & 256) || (workInProgress2.flags |= 1024, upgradeHydrationErrorsToRecoverable());
8933            bubbleProperties(workInProgress2);
8934            return null;
8935          case 26:
8936            var type = workInProgress2.type, nextResource = workInProgress2.memoizedState;
8937            null === current2 ? (markUpdate(workInProgress2), null !== nextResource ? (bubbleProperties(workInProgress2), preloadResourceAndSuspendIfNeeded(
8938              workInProgress2,
8939              nextResource
8940            )) : (bubbleProperties(workInProgress2), preloadInstanceAndSuspendIfNeeded(
8941              workInProgress2,
8942              type,
8943              null,
8944              newProps,
8945              renderLanes2
8946            ))) : nextResource ? nextResource !== current2.memoizedState ? (markUpdate(workInProgress2), bubbleProperties(workInProgress2), preloadResourceAndSuspendIfNeeded(
8947              workInProgress2,
8948              nextResource
8949            )) : (bubbleProperties(workInProgress2), workInProgress2.flags &= -16777217) : (current2 = current2.memoizedProps, current2 !== newProps && markUpdate(workInProgress2), bubbleProperties(workInProgress2), preloadInstanceAndSuspendIfNeeded(
8950              workInProgress2,
8951              type,
8952              current2,
8953              newProps,
8954              renderLanes2
8955            ));
8956            return null;
8957          case 27:
8958            popHostContext(workInProgress2);
8959            renderLanes2 = requiredContext(rootInstanceStackCursor.current);
8960            type = workInProgress2.type;
8961            if (null !== current2 && null != workInProgress2.stateNode)
8962              current2.memoizedProps !== newProps && markUpdate(workInProgress2);
8963            else {
8964              if (!newProps) {
8965                if (null === workInProgress2.stateNode)
8966                  throw Error(
8967                    "We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue."
8968                  );
8969                bubbleProperties(workInProgress2);
8970                return null;
8971              }
8972              current2 = getHostContext();
8973              popHydrationState(workInProgress2) ? prepareToHydrateHostInstance(workInProgress2, current2) : (current2 = resolveSingletonInstance(
8974                type,
8975                newProps,
8976                renderLanes2,
8977                current2,
8978                true
8979              ), workInProgress2.stateNode = current2, markUpdate(workInProgress2));
8980            }
8981            bubbleProperties(workInProgress2);
8982            return null;
8983          case 5:
8984            popHostContext(workInProgress2);
8985            type = workInProgress2.type;
8986            if (null !== current2 && null != workInProgress2.stateNode)
8987              current2.memoizedProps !== newProps && markUpdate(workInProgress2);
8988            else {
8989              if (!newProps) {
8990                if (null === workInProgress2.stateNode)
8991                  throw Error(
8992                    "We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue."
8993                  );
8994                bubbleProperties(workInProgress2);
8995                return null;
8996              }
8997              var _currentHostContext = getHostContext();
8998              if (popHydrationState(workInProgress2))
8999                prepareToHydrateHostInstance(workInProgress2, _currentHostContext);
9000              else {
9001                nextResource = requiredContext(rootInstanceStackCursor.current);
9002                validateDOMNesting(type, _currentHostContext.ancestorInfo);
9003                _currentHostContext = _currentHostContext.context;
9004                nextResource = getOwnerDocumentFromRootContainer(nextResource);
9005                switch (_currentHostContext) {
9006                  case HostContextNamespaceSvg:
9007                    nextResource = nextResource.createElementNS(
9008                      SVG_NAMESPACE,
9009                      type
9010                    );
9011                    break;
9012                  case HostContextNamespaceMath:
9013                    nextResource = nextResource.createElementNS(
9014                      MATH_NAMESPACE,
9015                      type
9016                    );
9017                    break;
9018                  default:
9019                    switch (type) {
9020                      case "svg":
9021                        nextResource = nextResource.createElementNS(
9022                          SVG_NAMESPACE,
9023                          type
9024                        );
9025                        break;
9026                      case "math":
9027                        nextResource = nextResource.createElementNS(
9028                          MATH_NAMESPACE,
9029                          type
9030                        );
9031                        break;
9032                      case "script":
9033                        nextResource = nextResource.createElement("div");
9034                        nextResource.innerHTML = "<script><\/script>";
9035                        nextResource = nextResource.removeChild(
9036                          nextResource.firstChild
9037                        );
9038                        break;
9039                      case "select":
9040                        nextResource = "string" === typeof newProps.is ? nextResource.createElement("select", {
9041                          is: newProps.is
9042                        }) : nextResource.createElement("select");
9043                        newProps.multiple ? nextResource.multiple = true : newProps.size && (nextResource.size = newProps.size);
9044                        break;
9045                      default:
9046                        nextResource = "string" === typeof newProps.is ? nextResource.createElement(type, {
9047                          is: newProps.is
9048                        }) : nextResource.createElement(type), -1 === type.indexOf("-") && (type !== type.toLowerCase() && console.error(
9049                          "<%s /> is using incorrect casing. Use PascalCase for React components, or lowercase for HTML elements.",
9050                          type
9051                        ), "[object HTMLUnknownElement]" !== Object.prototype.toString.call(nextResource) || hasOwnProperty.call(warnedUnknownTags, type) || (warnedUnknownTags[type] = true, console.error(
9052                          "The tag <%s> is unrecognized in this browser. If you meant to render a React component, start its name with an uppercase letter.",
9053                          type
9054                        )));
9055                    }
9056                }
9057                nextResource[internalInstanceKey] = workInProgress2;
9058                nextResource[internalPropsKey] = newProps;
9059                a: for (_currentHostContext = workInProgress2.child; null !== _currentHostContext; ) {
9060                  if (5 === _currentHostContext.tag || 6 === _currentHostContext.tag)
9061                    nextResource.appendChild(_currentHostContext.stateNode);
9062                  else if (4 !== _currentHostContext.tag && 27 !== _currentHostContext.tag && null !== _currentHostContext.child) {
9063                    _currentHostContext.child.return = _currentHostContext;
9064                    _currentHostContext = _currentHostContext.child;
9065                    continue;
9066                  }
9067                  if (_currentHostContext === workInProgress2) break a;
9068                  for (; null === _currentHostContext.sibling; ) {
9069                    if (null === _currentHostContext.return || _currentHostContext.return === workInProgress2)
9070                      break a;
9071                    _currentHostContext = _currentHostContext.return;
9072                  }
9073                  _currentHostContext.sibling.return = _currentHostContext.return;
9074                  _currentHostContext = _currentHostContext.sibling;
9075                }
9076                workInProgress2.stateNode = nextResource;
9077                a: switch (setInitialProperties(nextResource, type, newProps), type) {
9078                  case "button":
9079                  case "input":
9080                  case "select":
9081                  case "textarea":
9082                    newProps = !!newProps.autoFocus;
9083                    break a;
9084                  case "img":
9085                    newProps = true;
9086                    break a;
9087                  default:
9088                    newProps = false;
9089                }
9090                newProps && markUpdate(workInProgress2);
9091              }
9092            }
9093            bubbleProperties(workInProgress2);
9094            preloadInstanceAndSuspendIfNeeded(
9095              workInProgress2,
9096              workInProgress2.type,
9097              null === current2 ? null : current2.memoizedProps,
9098              workInProgress2.pendingProps,
9099              renderLanes2
9100            );
9101            return null;
9102          case 6:
9103            if (current2 && null != workInProgress2.stateNode)
9104              current2.memoizedProps !== newProps && markUpdate(workInProgress2);
9105            else {
9106              if ("string" !== typeof newProps && null === workInProgress2.stateNode)
9107                throw Error(
9108                  "We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue."
9109                );
9110              current2 = requiredContext(rootInstanceStackCursor.current);
9111              renderLanes2 = getHostContext();
9112              if (popHydrationState(workInProgress2)) {
9113                current2 = workInProgress2.stateNode;
9114                renderLanes2 = workInProgress2.memoizedProps;
9115                type = !didSuspendOrErrorDEV;
9116                newProps = null;
9117                nextResource = hydrationParentFiber;
9118                if (null !== nextResource)
9119                  switch (nextResource.tag) {
9120                    case 3:
9121                      type && (type = diffHydratedTextForDevWarnings(
9122                        current2,
9123                        renderLanes2,
9124                        newProps
9125                      ), null !== type && (buildHydrationDiffNode(workInProgress2, 0).serverProps = type));
9126                      break;
9127                    case 27:
9128                    case 5:
9129                      newProps = nextResource.memoizedProps, type && (type = diffHydratedTextForDevWarnings(
9130                        current2,
9131                        renderLanes2,
9132                        newProps
9133                      ), null !== type && (buildHydrationDiffNode(
9134                        workInProgress2,
9135                        0
9136                      ).serverProps = type));
9137                  }
9138                current2[internalInstanceKey] = workInProgress2;
9139                current2 = current2.nodeValue === renderLanes2 || null !== newProps && true === newProps.suppressHydrationWarning || checkForUnmatchedText(current2.nodeValue, renderLanes2) ? true : false;
9140                current2 || throwOnHydrationMismatch(workInProgress2, true);
9141              } else
9142                type = renderLanes2.ancestorInfo.current, null != type && validateTextNesting(
9143                  newProps,
9144                  type.tag,
9145                  renderLanes2.ancestorInfo.implicitRootScope
9146                ), current2 = getOwnerDocumentFromRootContainer(current2).createTextNode(
9147                  newProps
9148                ), current2[internalInstanceKey] = workInProgress2, workInProgress2.stateNode = current2;
9149            }
9150            bubbleProperties(workInProgress2);
9151            return null;
9152          case 31:
9153            renderLanes2 = workInProgress2.memoizedState;
9154            if (null === current2 || null !== current2.memoizedState) {
9155              newProps = popHydrationState(workInProgress2);
9156              if (null !== renderLanes2) {
9157                if (null === current2) {
9158                  if (!newProps)
9159                    throw Error(
9160                      "A dehydrated suspense component was completed without a hydrated node. This is probably a bug in React."
9161                    );
9162                  current2 = workInProgress2.memoizedState;
9163                  current2 = null !== current2 ? current2.dehydrated : null;
9164                  if (!current2)
9165                    throw Error(
9166                      "Expected to have a hydrated activity instance. This error is likely caused by a bug in React. Please file an issue."
9167                    );
9168                  current2[internalInstanceKey] = workInProgress2;
9169                  bubbleProperties(workInProgress2);
9170                  (workInProgress2.mode & ProfileMode) !== NoMode && null !== renderLanes2 && (current2 = workInProgress2.child, null !== current2 && (workInProgress2.treeBaseDuration -= current2.treeBaseDuration));
9171                } else
9172                  emitPendingHydrationWarnings(), resetHydrationState(), 0 === (workInProgress2.flags & 128) && (renderLanes2 = workInProgress2.memoizedState = null), workInProgress2.flags |= 4, bubbleProperties(workInProgress2), (workInProgress2.mode & ProfileMode) !== NoMode && null !== renderLanes2 && (current2 = workInProgress2.child, null !== current2 && (workInProgress2.treeBaseDuration -= current2.treeBaseDuration));
9173                current2 = false;
9174              } else
9175                renderLanes2 = upgradeHydrationErrorsToRecoverable(), null !== current2 && null !== current2.memoizedState && (current2.memoizedState.hydrationErrors = renderLanes2), current2 = true;
9176              if (!current2) {
9177                if (workInProgress2.flags & 256)
9178                  return popSuspenseHandler(workInProgress2), workInProgress2;
9179                popSuspenseHandler(workInProgress2);
9180                return null;
9181              }
9182              if (0 !== (workInProgress2.flags & 128))
9183                throw Error(
9184                  "Client rendering an Activity suspended it again. This is a bug in React."
9185                );
9186            }
9187            bubbleProperties(workInProgress2);
9188            return null;
9189          case 13:
9190            newProps = workInProgress2.memoizedState;
9191            if (null === current2 || null !== current2.memoizedState && null !== current2.memoizedState.dehydrated) {
9192              type = newProps;
9193              nextResource = popHydrationState(workInProgress2);
9194              if (null !== type && null !== type.dehydrated) {
9195                if (null === current2) {
9196                  if (!nextResource)
9197                    throw Error(
9198                      "A dehydrated suspense component was completed without a hydrated node. This is probably a bug in React."
9199                    );
9200                  nextResource = workInProgress2.memoizedState;
9201                  nextResource = null !== nextResource ? nextResource.dehydrated : null;
9202                  if (!nextResource)
9203                    throw Error(
9204                      "Expected to have a hydrated suspense instance. This error is likely caused by a bug in React. Please file an issue."
9205                    );
9206                  nextResource[internalInstanceKey] = workInProgress2;
9207                  bubbleProperties(workInProgress2);
9208                  (workInProgress2.mode & ProfileMode) !== NoMode && null !== type && (type = workInProgress2.child, null !== type && (workInProgress2.treeBaseDuration -= type.treeBaseDuration));
9209                } else
9210                  emitPendingHydrationWarnings(), resetHydrationState(), 0 === (workInProgress2.flags & 128) && (type = workInProgress2.memoizedState = null), workInProgress2.flags |= 4, bubbleProperties(workInProgress2), (workInProgress2.mode & ProfileMode) !== NoMode && null !== type && (type = workInProgress2.child, null !== type && (workInProgress2.treeBaseDuration -= type.treeBaseDuration));
9211                type = false;
9212              } else
9213                type = upgradeHydrationErrorsToRecoverable(), null !== current2 && null !== current2.memoizedState && (current2.memoizedState.hydrationErrors = type), type = true;
9214              if (!type) {
9215                if (workInProgress2.flags & 256)
9216                  return popSuspenseHandler(workInProgress2), workInProgress2;
9217                popSuspenseHandler(workInProgress2);
9218                return null;
9219              }
9220            }
9221            popSuspenseHandler(workInProgress2);
9222            if (0 !== (workInProgress2.flags & 128))
9223              return workInProgress2.lanes = renderLanes2, (workInProgress2.mode & ProfileMode) !== NoMode && transferActualDuration(workInProgress2), workInProgress2;
9224            renderLanes2 = null !== newProps;
9225            current2 = null !== current2 && null !== current2.memoizedState;
9226            renderLanes2 && (newProps = workInProgress2.child, type = null, null !== newProps.alternate && null !== newProps.alternate.memoizedState && null !== newProps.alternate.memoizedState.cachePool && (type = newProps.alternate.memoizedState.cachePool.pool), nextResource = null, null !== newProps.memoizedState && null !== newProps.memoizedState.cachePool && (nextResource = newProps.memoizedState.cachePool.pool), nextResource !== type && (newProps.flags |= 2048));
9227            renderLanes2 !== current2 && renderLanes2 && (workInProgress2.child.flags |= 8192);
9228            scheduleRetryEffect(workInProgress2, workInProgress2.updateQueue);
9229            bubbleProperties(workInProgress2);
9230            (workInProgress2.mode & ProfileMode) !== NoMode && renderLanes2 && (current2 = workInProgress2.child, null !== current2 && (workInProgress2.treeBaseDuration -= current2.treeBaseDuration));
9231            return null;
9232          case 4:
9233            return popHostContainer(workInProgress2), null === current2 && listenToAllSupportedEvents(
9234              workInProgress2.stateNode.containerInfo
9235            ), bubbleProperties(workInProgress2), null;
9236          case 10:
9237            return popProvider(workInProgress2.type, workInProgress2), bubbleProperties(workInProgress2), null;
9238          case 19:
9239            pop(suspenseStackCursor, workInProgress2);
9240            newProps = workInProgress2.memoizedState;
9241            if (null === newProps) return bubbleProperties(workInProgress2), null;
9242            type = 0 !== (workInProgress2.flags & 128);
9243            nextResource = newProps.rendering;
9244            if (null === nextResource)
9245              if (type) cutOffTailIfNeeded(newProps, false);
9246              else {
9247                if (workInProgressRootExitStatus !== RootInProgress || null !== current2 && 0 !== (current2.flags & 128))
9248                  for (current2 = workInProgress2.child; null !== current2; ) {
9249                    nextResource = findFirstSuspended(current2);
9250                    if (null !== nextResource) {
9251                      workInProgress2.flags |= 128;
9252                      cutOffTailIfNeeded(newProps, false);
9253                      current2 = nextResource.updateQueue;
9254                      workInProgress2.updateQueue = current2;
9255                      scheduleRetryEffect(workInProgress2, current2);
9256                      workInProgress2.subtreeFlags = 0;
9257                      current2 = renderLanes2;
9258                      for (renderLanes2 = workInProgress2.child; null !== renderLanes2; )
9259                        resetWorkInProgress(renderLanes2, current2), renderLanes2 = renderLanes2.sibling;
9260                      push(
9261                        suspenseStackCursor,
9262                        suspenseStackCursor.current & SubtreeSuspenseContextMask | ForceSuspenseFallback,
9263                        workInProgress2
9264                      );
9265                      isHydrating && pushTreeFork(workInProgress2, newProps.treeForkCount);
9266                      return workInProgress2.child;
9267                    }
9268                    current2 = current2.sibling;
9269                  }
9270                null !== newProps.tail && now$1() > workInProgressRootRenderTargetTime && (workInProgress2.flags |= 128, type = true, cutOffTailIfNeeded(newProps, false), workInProgress2.lanes = 4194304);
9271              }
9272            else {
9273              if (!type)
9274                if (current2 = findFirstSuspended(nextResource), null !== current2) {
9275                  if (workInProgress2.flags |= 128, type = true, current2 = current2.updateQueue, workInProgress2.updateQueue = current2, scheduleRetryEffect(workInProgress2, current2), cutOffTailIfNeeded(newProps, true), null === newProps.tail && "hidden" === newProps.tailMode && !nextResource.alternate && !isHydrating)
9276                    return bubbleProperties(workInProgress2), null;
9277                } else
9278                  2 * now$1() - newProps.renderingStartTime > workInProgressRootRenderTargetTime && 536870912 !== renderLanes2 && (workInProgress2.flags |= 128, type = true, cutOffTailIfNeeded(newProps, false), workInProgress2.lanes = 4194304);
9279              newProps.isBackwards ? (nextResource.sibling = workInProgress2.child, workInProgress2.child = nextResource) : (current2 = newProps.last, null !== current2 ? current2.sibling = nextResource : workInProgress2.child = nextResource, newProps.last = nextResource);
9280            }
9281            if (null !== newProps.tail)
9282              return current2 = newProps.tail, newProps.rendering = current2, newProps.tail = current2.sibling, newProps.renderingStartTime = now$1(), current2.sibling = null, renderLanes2 = suspenseStackCursor.current, renderLanes2 = type ? renderLanes2 & SubtreeSuspenseContextMask | ForceSuspenseFallback : renderLanes2 & SubtreeSuspenseContextMask, push(suspenseStackCursor, renderLanes2, workInProgress2), isHydrating && pushTreeFork(workInProgress2, newProps.treeForkCount), current2;
9283            bubbleProperties(workInProgress2);
9284            return null;
9285          case 22:
9286          case 23:
9287            return popSuspenseHandler(workInProgress2), popHiddenContext(workInProgress2), newProps = null !== workInProgress2.memoizedState, null !== current2 ? null !== current2.memoizedState !== newProps && (workInProgress2.flags |= 8192) : newProps && (workInProgress2.flags |= 8192), newProps ? 0 !== (renderLanes2 & 536870912) && 0 === (workInProgress2.flags & 128) && (bubbleProperties(workInProgress2), workInProgress2.subtreeFlags & 6 && (workInProgress2.flags |= 8192)) : bubbleProperties(workInProgress2), renderLanes2 = workInProgress2.updateQueue, null !== renderLanes2 && scheduleRetryEffect(workInProgress2, renderLanes2.retryQueue), renderLanes2 = null, null !== current2 && null !== current2.memoizedState && null !== current2.memoizedState.cachePool && (renderLanes2 = current2.memoizedState.cachePool.pool), newProps = null, null !== workInProgress2.memoizedState && null !== workInProgress2.memoizedState.cachePool && (newProps = workInProgress2.memoizedState.cachePool.pool), newProps !== renderLanes2 && (workInProgress2.flags |= 2048), null !== current2 && pop(resumedCache, workInProgress2), null;
9288          case 24:
9289            return renderLanes2 = null, null !== current2 && (renderLanes2 = current2.memoizedState.cache), workInProgress2.memoizedState.cache !== renderLanes2 && (workInProgress2.flags |= 2048), popProvider(CacheContext, workInProgress2), bubbleProperties(workInProgress2), null;
9290          case 25:
9291            return null;
9292          case 30:
9293            return null;
9294        }
9295        throw Error(
9296          "Unknown unit of work tag (" + workInProgress2.tag + "). This error is likely caused by a bug in React. Please file an issue."
9297        );
9298      }
9299      function unwindWork(current2, workInProgress2) {
9300        popTreeContext(workInProgress2);
9301        switch (workInProgress2.tag) {
9302          case 1:
9303            return current2 = workInProgress2.flags, current2 & 65536 ? (workInProgress2.flags = current2 & -65537 | 128, (workInProgress2.mode & ProfileMode) !== NoMode && transferActualDuration(workInProgress2), workInProgress2) : null;
9304          case 3:
9305            return popProvider(CacheContext, workInProgress2), popHostContainer(workInProgress2), current2 = workInProgress2.flags, 0 !== (current2 & 65536) && 0 === (current2 & 128) ? (workInProgress2.flags = current2 & -65537 | 128, workInProgress2) : null;
9306          case 26:
9307          case 27:
9308          case 5:
9309            return popHostContext(workInProgress2), null;
9310          case 31:
9311            if (null !== workInProgress2.memoizedState) {
9312              popSuspenseHandler(workInProgress2);
9313              if (null === workInProgress2.alternate)
9314                throw Error(
9315                  "Threw in newly mounted dehydrated component. This is likely a bug in React. Please file an issue."
9316                );
9317              resetHydrationState();
9318            }
9319            current2 = workInProgress2.flags;
9320            return current2 & 65536 ? (workInProgress2.flags = current2 & -65537 | 128, (workInProgress2.mode & ProfileMode) !== NoMode && transferActualDuration(workInProgress2), workInProgress2) : null;
9321          case 13:
9322            popSuspenseHandler(workInProgress2);
9323            current2 = workInProgress2.memoizedState;
9324            if (null !== current2 && null !== current2.dehydrated) {
9325              if (null === workInProgress2.alternate)
9326                throw Error(
9327                  "Threw in newly mounted dehydrated component. This is likely a bug in React. Please file an issue."
9328                );
9329              resetHydrationState();
9330            }
9331            current2 = workInProgress2.flags;
9332            return current2 & 65536 ? (workInProgress2.flags = current2 & -65537 | 128, (workInProgress2.mode & ProfileMode) !== NoMode && transferActualDuration(workInProgress2), workInProgress2) : null;
9333          case 19:
9334            return pop(suspenseStackCursor, workInProgress2), null;
9335          case 4:
9336            return popHostContainer(workInProgress2), null;
9337          case 10:
9338            return popProvider(workInProgress2.type, workInProgress2), null;
9339          case 22:
9340          case 23:
9341            return popSuspenseHandler(workInProgress2), popHiddenContext(workInProgress2), null !== current2 && pop(resumedCache, workInProgress2), current2 = workInProgress2.flags, current2 & 65536 ? (workInProgress2.flags = current2 & -65537 | 128, (workInProgress2.mode & ProfileMode) !== NoMode && transferActualDuration(workInProgress2), workInProgress2) : null;
9342          case 24:
9343            return popProvider(CacheContext, workInProgress2), null;
9344          case 25:
9345            return null;
9346          default:
9347            return null;
9348        }
9349      }
9350      function unwindInterruptedWork(current2, interruptedWork) {
9351        popTreeContext(interruptedWork);
9352        switch (interruptedWork.tag) {
9353          case 3:
9354            popProvider(CacheContext, interruptedWork);
9355            popHostContainer(interruptedWork);
9356            break;
9357          case 26:
9358          case 27:
9359          case 5:
9360            popHostContext(interruptedWork);
9361            break;
9362          case 4:
9363            popHostContainer(interruptedWork);
9364            break;
9365          case 31:
9366            null !== interruptedWork.memoizedState && popSuspenseHandler(interruptedWork);
9367            break;
9368          case 13:
9369            popSuspenseHandler(interruptedWork);
9370            break;
9371          case 19:
9372            pop(suspenseStackCursor, interruptedWork);
9373            break;
9374          case 10:
9375            popProvider(interruptedWork.type, interruptedWork);
9376            break;
9377          case 22:
9378          case 23:
9379            popSuspenseHandler(interruptedWork);
9380            popHiddenContext(interruptedWork);
9381            null !== current2 && pop(resumedCache, interruptedWork);
9382            break;
9383          case 24:
9384            popProvider(CacheContext, interruptedWork);
9385        }
9386      }
9387      function shouldProfile(current2) {
9388        return (current2.mode & ProfileMode) !== NoMode;
9389      }
9390      function commitHookLayoutEffects(finishedWork, hookFlags) {
9391        shouldProfile(finishedWork) ? (startEffectTimer(), commitHookEffectListMount(hookFlags, finishedWork), recordEffectDuration()) : commitHookEffectListMount(hookFlags, finishedWork);
9392      }
9393      function commitHookLayoutUnmountEffects(finishedWork, nearestMountedAncestor, hookFlags) {
9394        shouldProfile(finishedWork) ? (startEffectTimer(), commitHookEffectListUnmount(
9395          hookFlags,
9396          finishedWork,
9397          nearestMountedAncestor
9398        ), recordEffectDuration()) : commitHookEffectListUnmount(
9399          hookFlags,
9400          finishedWork,
9401          nearestMountedAncestor
9402        );
9403      }
9404      function commitHookEffectListMount(flags, finishedWork) {
9405        try {
9406          var updateQueue = finishedWork.updateQueue, lastEffect = null !== updateQueue ? updateQueue.lastEffect : null;
9407          if (null !== lastEffect) {
9408            var firstEffect = lastEffect.next;
9409            updateQueue = firstEffect;
9410            do {
9411              if ((updateQueue.tag & flags) === flags && (lastEffect = void 0, (flags & Insertion) !== NoFlags && (isRunningInsertionEffect = true), lastEffect = runWithFiberInDEV(
9412                finishedWork,
9413                callCreateInDEV,
9414                updateQueue
9415              ), (flags & Insertion) !== NoFlags && (isRunningInsertionEffect = false), void 0 !== lastEffect && "function" !== typeof lastEffect)) {
9416                var hookName = void 0;
9417                hookName = 0 !== (updateQueue.tag & Layout) ? "useLayoutEffect" : 0 !== (updateQueue.tag & Insertion) ? "useInsertionEffect" : "useEffect";
9418                var addendum = void 0;
9419                addendum = null === lastEffect ? " You returned null. If your effect does not require clean up, return undefined (or nothing)." : "function" === typeof lastEffect.then ? "\n\nIt looks like you wrote " + hookName + "(async () => ...) or returned a Promise. Instead, write the async function inside your effect and call it immediately:\n\n" + hookName + "(() => {\n  async function fetchData() {\n    // You can await here\n    const response = await MyAPI.getData(someId);\n    // ...\n  }\n  fetchData();\n}, [someId]); // Or [] if effect doesn't need props or state\n\nLearn more about data fetching with Hooks: https://react.dev/link/hooks-data-fetching" : " You returned: " + lastEffect;
9420                runWithFiberInDEV(
9421                  finishedWork,
9422                  function(n, a) {
9423                    console.error(
9424                      "%s must not return anything besides a function, which is used for clean-up.%s",
9425                      n,
9426                      a
9427                    );
9428                  },
9429                  hookName,
9430                  addendum
9431                );
9432              }
9433              updateQueue = updateQueue.next;
9434            } while (updateQueue !== firstEffect);
9435          }
9436        } catch (error) {
9437          captureCommitPhaseError(finishedWork, finishedWork.return, error);
9438        }
9439      }
9440      function commitHookEffectListUnmount(flags, finishedWork, nearestMountedAncestor) {
9441        try {
9442          var updateQueue = finishedWork.updateQueue, lastEffect = null !== updateQueue ? updateQueue.lastEffect : null;
9443          if (null !== lastEffect) {
9444            var firstEffect = lastEffect.next;
9445            updateQueue = firstEffect;
9446            do {
9447              if ((updateQueue.tag & flags) === flags) {
9448                var inst = updateQueue.inst, destroy = inst.destroy;
9449                void 0 !== destroy && (inst.destroy = void 0, (flags & Insertion) !== NoFlags && (isRunningInsertionEffect = true), lastEffect = finishedWork, runWithFiberInDEV(
9450                  lastEffect,
9451                  callDestroyInDEV,
9452                  lastEffect,
9453                  nearestMountedAncestor,
9454                  destroy
9455                ), (flags & Insertion) !== NoFlags && (isRunningInsertionEffect = false));
9456              }
9457              updateQueue = updateQueue.next;
9458            } while (updateQueue !== firstEffect);
9459          }
9460        } catch (error) {
9461          captureCommitPhaseError(finishedWork, finishedWork.return, error);
9462        }
9463      }
9464      function commitHookPassiveMountEffects(finishedWork, hookFlags) {
9465        shouldProfile(finishedWork) ? (startEffectTimer(), commitHookEffectListMount(hookFlags, finishedWork), recordEffectDuration()) : commitHookEffectListMount(hookFlags, finishedWork);
9466      }
9467      function commitHookPassiveUnmountEffects(finishedWork, nearestMountedAncestor, hookFlags) {
9468        shouldProfile(finishedWork) ? (startEffectTimer(), commitHookEffectListUnmount(
9469          hookFlags,
9470          finishedWork,
9471          nearestMountedAncestor
9472        ), recordEffectDuration()) : commitHookEffectListUnmount(
9473          hookFlags,
9474          finishedWork,
9475          nearestMountedAncestor
9476        );
9477      }
9478      function commitClassCallbacks(finishedWork) {
9479        var updateQueue = finishedWork.updateQueue;
9480        if (null !== updateQueue) {
9481          var instance = finishedWork.stateNode;
9482          finishedWork.type.defaultProps || "ref" in finishedWork.memoizedProps || didWarnAboutReassigningProps || (instance.props !== finishedWork.memoizedProps && console.error(
9483            "Expected %s props to match memoized props before processing the update queue. This might either be because of a bug in React, or because a component reassigns its own `this.props`. Please file an issue.",
9484            getComponentNameFromFiber(finishedWork) || "instance"
9485          ), instance.state !== finishedWork.memoizedState && console.error(
9486            "Expected %s state to match memoized state before processing the update queue. This might either be because of a bug in React, or because a component reassigns its own `this.state`. Please file an issue.",
9487            getComponentNameFromFiber(finishedWork) || "instance"
9488          ));
9489          try {
9490            runWithFiberInDEV(
9491              finishedWork,
9492              commitCallbacks,
9493              updateQueue,
9494              instance
9495            );
9496          } catch (error) {
9497            captureCommitPhaseError(finishedWork, finishedWork.return, error);
9498          }
9499        }
9500      }
9501      function callGetSnapshotBeforeUpdates(instance, prevProps, prevState) {
9502        return instance.getSnapshotBeforeUpdate(prevProps, prevState);
9503      }
9504      function commitClassSnapshot(finishedWork, current2) {
9505        var prevProps = current2.memoizedProps, prevState = current2.memoizedState;
9506        current2 = finishedWork.stateNode;
9507        finishedWork.type.defaultProps || "ref" in finishedWork.memoizedProps || didWarnAboutReassigningProps || (current2.props !== finishedWork.memoizedProps && console.error(
9508          "Expected %s props to match memoized props before getSnapshotBeforeUpdate. This might either be because of a bug in React, or because a component reassigns its own `this.props`. Please file an issue.",
9509          getComponentNameFromFiber(finishedWork) || "instance"
9510        ), current2.state !== finishedWork.memoizedState && console.error(
9511          "Expected %s state to match memoized state before getSnapshotBeforeUpdate. This might either be because of a bug in React, or because a component reassigns its own `this.state`. Please file an issue.",
9512          getComponentNameFromFiber(finishedWork) || "instance"
9513        ));
9514        try {
9515          var resolvedPrevProps = resolveClassComponentProps(
9516            finishedWork.type,
9517            prevProps
9518          );
9519          var snapshot = runWithFiberInDEV(
9520            finishedWork,
9521            callGetSnapshotBeforeUpdates,
9522            current2,
9523            resolvedPrevProps,
9524            prevState
9525          );
9526          prevProps = didWarnAboutUndefinedSnapshotBeforeUpdate;
9527          void 0 !== snapshot || prevProps.has(finishedWork.type) || (prevProps.add(finishedWork.type), runWithFiberInDEV(finishedWork, function() {
9528            console.error(
9529              "%s.getSnapshotBeforeUpdate(): A snapshot value (or null) must be returned. You have returned undefined.",
9530              getComponentNameFromFiber(finishedWork)
9531            );
9532          }));
9533          current2.__reactInternalSnapshotBeforeUpdate = snapshot;
9534        } catch (error) {
9535          captureCommitPhaseError(finishedWork, finishedWork.return, error);
9536        }
9537      }
9538      function safelyCallComponentWillUnmount(current2, nearestMountedAncestor, instance) {
9539        instance.props = resolveClassComponentProps(
9540          current2.type,
9541          current2.memoizedProps
9542        );
9543        instance.state = current2.memoizedState;
9544        shouldProfile(current2) ? (startEffectTimer(), runWithFiberInDEV(
9545          current2,
9546          callComponentWillUnmountInDEV,
9547          current2,
9548          nearestMountedAncestor,
9549          instance
9550        ), recordEffectDuration()) : runWithFiberInDEV(
9551          current2,
9552          callComponentWillUnmountInDEV,
9553          current2,
9554          nearestMountedAncestor,
9555          instance
9556        );
9557      }
9558      function commitAttachRef(finishedWork) {
9559        var ref = finishedWork.ref;
9560        if (null !== ref) {
9561          switch (finishedWork.tag) {
9562            case 26:
9563            case 27:
9564            case 5:
9565              var instanceToUse = finishedWork.stateNode;
9566              break;
9567            case 30:
9568              instanceToUse = finishedWork.stateNode;
9569              break;
9570            default:
9571              instanceToUse = finishedWork.stateNode;
9572          }
9573          if ("function" === typeof ref)
9574            if (shouldProfile(finishedWork))
9575              try {
9576                startEffectTimer(), finishedWork.refCleanup = ref(instanceToUse);
9577              } finally {
9578                recordEffectDuration();
9579              }
9580            else finishedWork.refCleanup = ref(instanceToUse);
9581          else
9582            "string" === typeof ref ? console.error("String refs are no longer supported.") : ref.hasOwnProperty("current") || console.error(
9583              "Unexpected ref object provided for %s. Use either a ref-setter function or React.createRef().",
9584              getComponentNameFromFiber(finishedWork)
9585            ), ref.current = instanceToUse;
9586        }
9587      }
9588      function safelyAttachRef(current2, nearestMountedAncestor) {
9589        try {
9590          runWithFiberInDEV(current2, commitAttachRef, current2);
9591        } catch (error) {
9592          captureCommitPhaseError(current2, nearestMountedAncestor, error);
9593        }
9594      }
9595      function safelyDetachRef(current2, nearestMountedAncestor) {
9596        var ref = current2.ref, refCleanup = current2.refCleanup;
9597        if (null !== ref)
9598          if ("function" === typeof refCleanup)
9599            try {
9600              if (shouldProfile(current2))
9601                try {
9602                  startEffectTimer(), runWithFiberInDEV(current2, refCleanup);
9603                } finally {
9604                  recordEffectDuration(current2);
9605                }
9606              else runWithFiberInDEV(current2, refCleanup);
9607            } catch (error) {
9608              captureCommitPhaseError(current2, nearestMountedAncestor, error);
9609            } finally {
9610              current2.refCleanup = null, current2 = current2.alternate, null != current2 && (current2.refCleanup = null);
9611            }
9612          else if ("function" === typeof ref)
9613            try {
9614              if (shouldProfile(current2))
9615                try {
9616                  startEffectTimer(), runWithFiberInDEV(current2, ref, null);
9617                } finally {
9618                  recordEffectDuration(current2);
9619                }
9620              else runWithFiberInDEV(current2, ref, null);
9621            } catch (error$7) {
9622              captureCommitPhaseError(current2, nearestMountedAncestor, error$7);
9623            }
9624          else ref.current = null;
9625      }
9626      function commitProfiler(finishedWork, current2, commitStartTime2, effectDuration) {
9627        var _finishedWork$memoize = finishedWork.memoizedProps, id = _finishedWork$memoize.id, onCommit = _finishedWork$memoize.onCommit;
9628        _finishedWork$memoize = _finishedWork$memoize.onRender;
9629        current2 = null === current2 ? "mount" : "update";
9630        currentUpdateIsNested && (current2 = "nested-update");
9631        "function" === typeof _finishedWork$memoize && _finishedWork$memoize(
9632          id,
9633          current2,
9634          finishedWork.actualDuration,
9635          finishedWork.treeBaseDuration,
9636          finishedWork.actualStartTime,
9637          commitStartTime2
9638        );
9639        "function" === typeof onCommit && onCommit(id, current2, effectDuration, commitStartTime2);
9640      }
9641      function commitProfilerPostCommitImpl(finishedWork, current2, commitStartTime2, passiveEffectDuration) {
9642        var _finishedWork$memoize2 = finishedWork.memoizedProps;
9643        finishedWork = _finishedWork$memoize2.id;
9644        _finishedWork$memoize2 = _finishedWork$memoize2.onPostCommit;
9645        current2 = null === current2 ? "mount" : "update";
9646        currentUpdateIsNested && (current2 = "nested-update");
9647        "function" === typeof _finishedWork$memoize2 && _finishedWork$memoize2(
9648          finishedWork,
9649          current2,
9650          passiveEffectDuration,
9651          commitStartTime2
9652        );
9653      }
9654      function commitHostMount(finishedWork) {
9655        var type = finishedWork.type, props = finishedWork.memoizedProps, instance = finishedWork.stateNode;
9656        try {
9657          runWithFiberInDEV(
9658            finishedWork,
9659            commitMount,
9660            instance,
9661            type,
9662            props,
9663            finishedWork
9664          );
9665        } catch (error) {
9666          captureCommitPhaseError(finishedWork, finishedWork.return, error);
9667        }
9668      }
9669      function commitHostUpdate(finishedWork, newProps, oldProps) {
9670        try {
9671          runWithFiberInDEV(
9672            finishedWork,
9673            commitUpdate,
9674            finishedWork.stateNode,
9675            finishedWork.type,
9676            oldProps,
9677            newProps,
9678            finishedWork
9679          );
9680        } catch (error) {
9681          captureCommitPhaseError(finishedWork, finishedWork.return, error);
9682        }
9683      }
9684      function isHostParent(fiber) {
9685        return 5 === fiber.tag || 3 === fiber.tag || 26 === fiber.tag || 27 === fiber.tag && isSingletonScope(fiber.type) || 4 === fiber.tag;
9686      }
9687      function getHostSibling(fiber) {
9688        a: for (; ; ) {
9689          for (; null === fiber.sibling; ) {
9690            if (null === fiber.return || isHostParent(fiber.return)) return null;
9691            fiber = fiber.return;
9692          }
9693          fiber.sibling.return = fiber.return;
9694          for (fiber = fiber.sibling; 5 !== fiber.tag && 6 !== fiber.tag && 18 !== fiber.tag; ) {
9695            if (27 === fiber.tag && isSingletonScope(fiber.type)) continue a;
9696            if (fiber.flags & 2) continue a;
9697            if (null === fiber.child || 4 === fiber.tag) continue a;
9698            else fiber.child.return = fiber, fiber = fiber.child;
9699          }
9700          if (!(fiber.flags & 2)) return fiber.stateNode;
9701        }
9702      }
9703      function insertOrAppendPlacementNodeIntoContainer(node, before, parent) {
9704        var tag = node.tag;
9705        if (5 === tag || 6 === tag)
9706          node = node.stateNode, before ? (warnForReactChildrenConflict(parent), (9 === parent.nodeType ? parent.body : "HTML" === parent.nodeName ? parent.ownerDocument.body : parent).insertBefore(node, before)) : (warnForReactChildrenConflict(parent), before = 9 === parent.nodeType ? parent.body : "HTML" === parent.nodeName ? parent.ownerDocument.body : parent, before.appendChild(node), parent = parent._reactRootContainer, null !== parent && void 0 !== parent || null !== before.onclick || (before.onclick = noop$1));
9707        else if (4 !== tag && (27 === tag && isSingletonScope(node.type) && (parent = node.stateNode, before = null), node = node.child, null !== node))
9708          for (insertOrAppendPlacementNodeIntoContainer(node, before, parent), node = node.sibling; null !== node; )
9709            insertOrAppendPlacementNodeIntoContainer(node, before, parent), node = node.sibling;
9710      }
9711      function insertOrAppendPlacementNode(node, before, parent) {
9712        var tag = node.tag;
9713        if (5 === tag || 6 === tag)
9714          node = node.stateNode, before ? parent.insertBefore(node, before) : parent.appendChild(node);
9715        else if (4 !== tag && (27 === tag && isSingletonScope(node.type) && (parent = node.stateNode), node = node.child, null !== node))
9716          for (insertOrAppendPlacementNode(node, before, parent), node = node.sibling; null !== node; )
9717            insertOrAppendPlacementNode(node, before, parent), node = node.sibling;
9718      }
9719      function commitPlacement(finishedWork) {
9720        for (var hostParentFiber, parentFiber = finishedWork.return; null !== parentFiber; ) {
9721          if (isHostParent(parentFiber)) {
9722            hostParentFiber = parentFiber;
9723            break;
9724          }
9725          parentFiber = parentFiber.return;
9726        }
9727        if (null == hostParentFiber)
9728          throw Error(
9729            "Expected to find a host parent. This error is likely caused by a bug in React. Please file an issue."
9730          );
9731        switch (hostParentFiber.tag) {
9732          case 27:
9733            hostParentFiber = hostParentFiber.stateNode;
9734            parentFiber = getHostSibling(finishedWork);
9735            insertOrAppendPlacementNode(
9736              finishedWork,
9737              parentFiber,
9738              hostParentFiber
9739            );
9740            break;
9741          case 5:
9742            parentFiber = hostParentFiber.stateNode;
9743            hostParentFiber.flags & 32 && (resetTextContent(parentFiber), hostParentFiber.flags &= -33);
9744            hostParentFiber = getHostSibling(finishedWork);
9745            insertOrAppendPlacementNode(
9746              finishedWork,
9747              hostParentFiber,
9748              parentFiber
9749            );
9750            break;
9751          case 3:
9752          case 4:
9753            hostParentFiber = hostParentFiber.stateNode.containerInfo;
9754            parentFiber = getHostSibling(finishedWork);
9755            insertOrAppendPlacementNodeIntoContainer(
9756              finishedWork,
9757              parentFiber,
9758              hostParentFiber
9759            );
9760            break;
9761          default:
9762            throw Error(
9763              "Invalid host parent fiber. This error is likely caused by a bug in React. Please file an issue."
9764            );
9765        }
9766      }
9767      function commitHostSingletonAcquisition(finishedWork) {
9768        var singleton = finishedWork.stateNode, props = finishedWork.memoizedProps;
9769        try {
9770          runWithFiberInDEV(
9771            finishedWork,
9772            acquireSingletonInstance,
9773            finishedWork.type,
9774            props,
9775            singleton,
9776            finishedWork
9777          );
9778        } catch (error) {
9779          captureCommitPhaseError(finishedWork, finishedWork.return, error);
9780        }
9781      }
9782      function isHydratingParent(current2, finishedWork) {
9783        return 31 === finishedWork.tag ? (finishedWork = finishedWork.memoizedState, null !== current2.memoizedState && null === finishedWork) : 13 === finishedWork.tag ? (current2 = current2.memoizedState, finishedWork = finishedWork.memoizedState, null !== current2 && null !== current2.dehydrated && (null === finishedWork || null === finishedWork.dehydrated)) : 3 === finishedWork.tag ? current2.memoizedState.isDehydrated && 0 === (finishedWork.flags & 256) : false;
9784      }
9785      function commitBeforeMutationEffects(root2, firstChild) {
9786        root2 = root2.containerInfo;
9787        eventsEnabled = _enabled;
9788        root2 = getActiveElementDeep(root2);
9789        if (hasSelectionCapabilities(root2)) {
9790          if ("selectionStart" in root2)
9791            var JSCompiler_temp = {
9792              start: root2.selectionStart,
9793              end: root2.selectionEnd
9794            };
9795          else
9796            a: {
9797              JSCompiler_temp = (JSCompiler_temp = root2.ownerDocument) && JSCompiler_temp.defaultView || window;
9798              var selection = JSCompiler_temp.getSelection && JSCompiler_temp.getSelection();
9799              if (selection && 0 !== selection.rangeCount) {
9800                JSCompiler_temp = selection.anchorNode;
9801                var anchorOffset = selection.anchorOffset, focusNode = selection.focusNode;
9802                selection = selection.focusOffset;
9803                try {
9804                  JSCompiler_temp.nodeType, focusNode.nodeType;
9805                } catch (e$2) {
9806                  JSCompiler_temp = null;
9807                  break a;
9808                }
9809                var length = 0, start = -1, end = -1, indexWithinAnchor = 0, indexWithinFocus = 0, node = root2, parentNode = null;
9810                b: for (; ; ) {
9811                  for (var next; ; ) {
9812                    node !== JSCompiler_temp || 0 !== anchorOffset && 3 !== node.nodeType || (start = length + anchorOffset);
9813                    node !== focusNode || 0 !== selection && 3 !== node.nodeType || (end = length + selection);
9814                    3 === node.nodeType && (length += node.nodeValue.length);
9815                    if (null === (next = node.firstChild)) break;
9816                    parentNode = node;
9817                    node = next;
9818                  }
9819                  for (; ; ) {
9820                    if (node === root2) break b;
9821                    parentNode === JSCompiler_temp && ++indexWithinAnchor === anchorOffset && (start = length);
9822                    parentNode === focusNode && ++indexWithinFocus === selection && (end = length);
9823                    if (null !== (next = node.nextSibling)) break;
9824                    node = parentNode;
9825                    parentNode = node.parentNode;
9826                  }
9827                  node = next;
9828                }
9829                JSCompiler_temp = -1 === start || -1 === end ? null : { start, end };
9830              } else JSCompiler_temp = null;
9831            }
9832          JSCompiler_temp = JSCompiler_temp || { start: 0, end: 0 };
9833        } else JSCompiler_temp = null;
9834        selectionInformation = {
9835          focusedElem: root2,
9836          selectionRange: JSCompiler_temp
9837        };
9838        _enabled = false;
9839        for (nextEffect = firstChild; null !== nextEffect; )
9840          if (firstChild = nextEffect, root2 = firstChild.child, 0 !== (firstChild.subtreeFlags & 1028) && null !== root2)
9841            root2.return = firstChild, nextEffect = root2;
9842          else
9843            for (; null !== nextEffect; ) {
9844              root2 = firstChild = nextEffect;
9845              JSCompiler_temp = root2.alternate;
9846              anchorOffset = root2.flags;
9847              switch (root2.tag) {
9848                case 0:
9849                  if (0 !== (anchorOffset & 4) && (root2 = root2.updateQueue, root2 = null !== root2 ? root2.events : null, null !== root2))
9850                    for (JSCompiler_temp = 0; JSCompiler_temp < root2.length; JSCompiler_temp++)
9851                      anchorOffset = root2[JSCompiler_temp], anchorOffset.ref.impl = anchorOffset.nextImpl;
9852                  break;
9853                case 11:
9854                case 15:
9855                  break;
9856                case 1:
9857                  0 !== (anchorOffset & 1024) && null !== JSCompiler_temp && commitClassSnapshot(root2, JSCompiler_temp);
9858                  break;
9859                case 3:
9860                  if (0 !== (anchorOffset & 1024)) {
9861                    if (root2 = root2.stateNode.containerInfo, JSCompiler_temp = root2.nodeType, 9 === JSCompiler_temp)
9862                      clearContainerSparingly(root2);
9863                    else if (1 === JSCompiler_temp)
9864                      switch (root2.nodeName) {
9865                        case "HEAD":
9866                        case "HTML":
9867                        case "BODY":
9868                          clearContainerSparingly(root2);
9869                          break;
9870                        default:
9871                          root2.textContent = "";
9872                      }
9873                  }
9874                  break;
9875                case 5:
9876                case 26:
9877                case 27:
9878                case 6:
9879                case 4:
9880                case 17:
9881                  break;
9882                default:
9883                  if (0 !== (anchorOffset & 1024))
9884                    throw Error(
9885                      "This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue."
9886                    );
9887              }
9888              root2 = firstChild.sibling;
9889              if (null !== root2) {
9890                root2.return = firstChild.return;
9891                nextEffect = root2;
9892                break;
9893              }
9894              nextEffect = firstChild.return;
9895            }
9896      }
9897      function commitLayoutEffectOnFiber(finishedRoot, current2, finishedWork) {
9898        var prevEffectStart = pushComponentEffectStart(), prevEffectDuration = pushComponentEffectDuration(), prevEffectErrors = pushComponentEffectErrors(), prevEffectDidSpawnUpdate = pushComponentEffectDidSpawnUpdate(), flags = finishedWork.flags;
9899        switch (finishedWork.tag) {
9900          case 0:
9901          case 11:
9902          case 15:
9903            recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
9904            flags & 4 && commitHookLayoutEffects(finishedWork, Layout | HasEffect);
9905            break;
9906          case 1:
9907            recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
9908            if (flags & 4)
9909              if (finishedRoot = finishedWork.stateNode, null === current2)
9910                finishedWork.type.defaultProps || "ref" in finishedWork.memoizedProps || didWarnAboutReassigningProps || (finishedRoot.props !== finishedWork.memoizedProps && console.error(
9911                  "Expected %s props to match memoized props before componentDidMount. This might either be because of a bug in React, or because a component reassigns its own `this.props`. Please file an issue.",
9912                  getComponentNameFromFiber(finishedWork) || "instance"
9913                ), finishedRoot.state !== finishedWork.memoizedState && console.error(
9914                  "Expected %s state to match memoized state before componentDidMount. This might either be because of a bug in React, or because a component reassigns its own `this.state`. Please file an issue.",
9915                  getComponentNameFromFiber(finishedWork) || "instance"
9916                )), shouldProfile(finishedWork) ? (startEffectTimer(), runWithFiberInDEV(
9917                  finishedWork,
9918                  callComponentDidMountInDEV,
9919                  finishedWork,
9920                  finishedRoot
9921                ), recordEffectDuration()) : runWithFiberInDEV(
9922                  finishedWork,
9923                  callComponentDidMountInDEV,
9924                  finishedWork,
9925                  finishedRoot
9926                );
9927              else {
9928                var prevProps = resolveClassComponentProps(
9929                  finishedWork.type,
9930                  current2.memoizedProps
9931                );
9932                current2 = current2.memoizedState;
9933                finishedWork.type.defaultProps || "ref" in finishedWork.memoizedProps || didWarnAboutReassigningProps || (finishedRoot.props !== finishedWork.memoizedProps && console.error(
9934                  "Expected %s props to match memoized props before componentDidUpdate. This might either be because of a bug in React, or because a component reassigns its own `this.props`. Please file an issue.",
9935                  getComponentNameFromFiber(finishedWork) || "instance"
9936                ), finishedRoot.state !== finishedWork.memoizedState && console.error(
9937                  "Expected %s state to match memoized state before componentDidUpdate. This might either be because of a bug in React, or because a component reassigns its own `this.state`. Please file an issue.",
9938                  getComponentNameFromFiber(finishedWork) || "instance"
9939                ));
9940                shouldProfile(finishedWork) ? (startEffectTimer(), runWithFiberInDEV(
9941                  finishedWork,
9942                  callComponentDidUpdateInDEV,
9943                  finishedWork,
9944                  finishedRoot,
9945                  prevProps,
9946                  current2,
9947                  finishedRoot.__reactInternalSnapshotBeforeUpdate
9948                ), recordEffectDuration()) : runWithFiberInDEV(
9949                  finishedWork,
9950                  callComponentDidUpdateInDEV,
9951                  finishedWork,
9952                  finishedRoot,
9953                  prevProps,
9954                  current2,
9955                  finishedRoot.__reactInternalSnapshotBeforeUpdate
9956                );
9957              }
9958            flags & 64 && commitClassCallbacks(finishedWork);
9959            flags & 512 && safelyAttachRef(finishedWork, finishedWork.return);
9960            break;
9961          case 3:
9962            current2 = pushNestedEffectDurations();
9963            recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
9964            if (flags & 64 && (flags = finishedWork.updateQueue, null !== flags)) {
9965              prevProps = null;
9966              if (null !== finishedWork.child)
9967                switch (finishedWork.child.tag) {
9968                  case 27:
9969                  case 5:
9970                    prevProps = finishedWork.child.stateNode;
9971                    break;
9972                  case 1:
9973                    prevProps = finishedWork.child.stateNode;
9974                }
9975              try {
9976                runWithFiberInDEV(
9977                  finishedWork,
9978                  commitCallbacks,
9979                  flags,
9980                  prevProps
9981                );
9982              } catch (error) {
9983                captureCommitPhaseError(finishedWork, finishedWork.return, error);
9984              }
9985            }
9986            finishedRoot.effectDuration += popNestedEffectDurations(current2);
9987            break;
9988          case 27:
9989            null === current2 && flags & 4 && commitHostSingletonAcquisition(finishedWork);
9990          case 26:
9991          case 5:
9992            recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
9993            if (null === current2) {
9994              if (flags & 4) commitHostMount(finishedWork);
9995              else if (flags & 64) {
9996                finishedRoot = finishedWork.type;
9997                current2 = finishedWork.memoizedProps;
9998                prevProps = finishedWork.stateNode;
9999                try {
10000                  runWithFiberInDEV(
10001                    finishedWork,
10002                    commitHydratedInstance,
10003                    prevProps,
10004                    finishedRoot,
10005                    current2,
10006                    finishedWork
10007                  );
10008                } catch (error) {
10009                  captureCommitPhaseError(
10010                    finishedWork,
10011                    finishedWork.return,
10012                    error
10013                  );
10014                }
10015              }
10016            }
10017            flags & 512 && safelyAttachRef(finishedWork, finishedWork.return);
10018            break;
10019          case 12:
10020            if (flags & 4) {
10021              flags = pushNestedEffectDurations();
10022              recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
10023              finishedRoot = finishedWork.stateNode;
10024              finishedRoot.effectDuration += bubbleNestedEffectDurations(flags);
10025              try {
10026                runWithFiberInDEV(
10027                  finishedWork,
10028                  commitProfiler,
10029                  finishedWork,
10030                  current2,
10031                  commitStartTime,
10032                  finishedRoot.effectDuration
10033                );
10034              } catch (error) {
10035                captureCommitPhaseError(finishedWork, finishedWork.return, error);
10036              }
10037            } else recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
10038            break;
10039          case 31:
10040            recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
10041            flags & 4 && commitActivityHydrationCallbacks(finishedRoot, finishedWork);
10042            break;
10043          case 13:
10044            recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
10045            flags & 4 && commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
10046            flags & 64 && (finishedRoot = finishedWork.memoizedState, null !== finishedRoot && (finishedRoot = finishedRoot.dehydrated, null !== finishedRoot && (flags = retryDehydratedSuspenseBoundary.bind(
10047              null,
10048              finishedWork
10049            ), registerSuspenseInstanceRetry(finishedRoot, flags))));
10050            break;
10051          case 22:
10052            flags = null !== finishedWork.memoizedState || offscreenSubtreeIsHidden;
10053            if (!flags) {
10054              current2 = null !== current2 && null !== current2.memoizedState || offscreenSubtreeWasHidden;
10055              prevProps = offscreenSubtreeIsHidden;
10056              var prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
10057              offscreenSubtreeIsHidden = flags;
10058              (offscreenSubtreeWasHidden = current2) && !prevOffscreenSubtreeWasHidden ? (recursivelyTraverseReappearLayoutEffects(
10059                finishedRoot,
10060                finishedWork,
10061                0 !== (finishedWork.subtreeFlags & 8772)
10062              ), (finishedWork.mode & ProfileMode) !== NoMode && 0 <= componentEffectStartTime && 0 <= componentEffectEndTime && 0.05 < componentEffectEndTime - componentEffectStartTime && logComponentReappeared(
10063                finishedWork,
10064                componentEffectStartTime,
10065                componentEffectEndTime
10066              )) : recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
10067              offscreenSubtreeIsHidden = prevProps;
10068              offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
10069            }
10070            break;
10071          case 30:
10072            break;
10073          default:
10074            recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
10075        }
10076        (finishedWork.mode & ProfileMode) !== NoMode && 0 <= componentEffectStartTime && 0 <= componentEffectEndTime && ((componentEffectSpawnedUpdate || 0.05 < componentEffectDuration) && logComponentEffect(
10077          finishedWork,
10078          componentEffectStartTime,
10079          componentEffectEndTime,
10080          componentEffectDuration,
10081          componentEffectErrors
10082        ), null === finishedWork.alternate && null !== finishedWork.return && null !== finishedWork.return.alternate && 0.05 < componentEffectEndTime - componentEffectStartTime && (isHydratingParent(
10083          finishedWork.return.alternate,
10084          finishedWork.return
10085        ) || logComponentTrigger(
10086          finishedWork,
10087          componentEffectStartTime,
10088          componentEffectEndTime,
10089          "Mount"
10090        )));
10091        popComponentEffectStart(prevEffectStart);
10092        popComponentEffectDuration(prevEffectDuration);
10093        componentEffectErrors = prevEffectErrors;
10094        componentEffectSpawnedUpdate = prevEffectDidSpawnUpdate;
10095      }
10096      function detachFiberAfterEffects(fiber) {
10097        var alternate = fiber.alternate;
10098        null !== alternate && (fiber.alternate = null, detachFiberAfterEffects(alternate));
10099        fiber.child = null;
10100        fiber.deletions = null;
10101        fiber.sibling = null;
10102        5 === fiber.tag && (alternate = fiber.stateNode, null !== alternate && detachDeletedInstance(alternate));
10103        fiber.stateNode = null;
10104        fiber._debugOwner = null;
10105        fiber.return = null;
10106        fiber.dependencies = null;
10107        fiber.memoizedProps = null;
10108        fiber.memoizedState = null;
10109        fiber.pendingProps = null;
10110        fiber.stateNode = null;
10111        fiber.updateQueue = null;
10112      }
10113      function recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, parent) {
10114        for (parent = parent.child; null !== parent; )
10115          commitDeletionEffectsOnFiber(
10116            finishedRoot,
10117            nearestMountedAncestor,
10118            parent
10119          ), parent = parent.sibling;
10120      }
10121      function commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, deletedFiber) {
10122        if (injectedHook && "function" === typeof injectedHook.onCommitFiberUnmount)
10123          try {
10124            injectedHook.onCommitFiberUnmount(rendererID, deletedFiber);
10125          } catch (err) {
10126            hasLoggedError || (hasLoggedError = true, console.error(
10127              "React instrumentation encountered an error: %o",
10128              err
10129            ));
10130          }
10131        var prevEffectStart = pushComponentEffectStart(), prevEffectDuration = pushComponentEffectDuration(), prevEffectErrors = pushComponentEffectErrors(), prevEffectDidSpawnUpdate = pushComponentEffectDidSpawnUpdate();
10132        switch (deletedFiber.tag) {
10133          case 26:
10134            offscreenSubtreeWasHidden || safelyDetachRef(deletedFiber, nearestMountedAncestor);
10135            recursivelyTraverseDeletionEffects(
10136              finishedRoot,
10137              nearestMountedAncestor,
10138              deletedFiber
10139            );
10140            deletedFiber.memoizedState ? deletedFiber.memoizedState.count-- : deletedFiber.stateNode && (finishedRoot = deletedFiber.stateNode, finishedRoot.parentNode.removeChild(finishedRoot));
10141            break;
10142          case 27:
10143            offscreenSubtreeWasHidden || safelyDetachRef(deletedFiber, nearestMountedAncestor);
10144            var prevHostParent = hostParent, prevHostParentIsContainer = hostParentIsContainer;
10145            isSingletonScope(deletedFiber.type) && (hostParent = deletedFiber.stateNode, hostParentIsContainer = false);
10146            recursivelyTraverseDeletionEffects(
10147              finishedRoot,
10148              nearestMountedAncestor,
10149              deletedFiber
10150            );
10151            runWithFiberInDEV(
10152              deletedFiber,
10153              releaseSingletonInstance,
10154              deletedFiber.stateNode
10155            );
10156            hostParent = prevHostParent;
10157            hostParentIsContainer = prevHostParentIsContainer;
10158            break;
10159          case 5:
10160            offscreenSubtreeWasHidden || safelyDetachRef(deletedFiber, nearestMountedAncestor);
10161          case 6:
10162            prevHostParent = hostParent;
10163            prevHostParentIsContainer = hostParentIsContainer;
10164            hostParent = null;
10165            recursivelyTraverseDeletionEffects(
10166              finishedRoot,
10167              nearestMountedAncestor,
10168              deletedFiber
10169            );
10170            hostParent = prevHostParent;
10171            hostParentIsContainer = prevHostParentIsContainer;
10172            if (null !== hostParent)
10173              if (hostParentIsContainer)
10174                try {
10175                  runWithFiberInDEV(
10176                    deletedFiber,
10177                    removeChildFromContainer,
10178                    hostParent,
10179                    deletedFiber.stateNode
10180                  );
10181                } catch (error) {
10182                  captureCommitPhaseError(
10183                    deletedFiber,
10184                    nearestMountedAncestor,
10185                    error
10186                  );
10187                }
10188              else
10189                try {
10190                  runWithFiberInDEV(
10191                    deletedFiber,
10192                    removeChild,
10193                    hostParent,
10194                    deletedFiber.stateNode
10195                  );
10196                } catch (error) {
10197                  captureCommitPhaseError(
10198                    deletedFiber,
10199                    nearestMountedAncestor,
10200                    error
10201                  );
10202                }
10203            break;
10204          case 18:
10205            null !== hostParent && (hostParentIsContainer ? (finishedRoot = hostParent, clearHydrationBoundary(
10206              9 === finishedRoot.nodeType ? finishedRoot.body : "HTML" === finishedRoot.nodeName ? finishedRoot.ownerDocument.body : finishedRoot,
10207              deletedFiber.stateNode
10208            ), retryIfBlockedOn(finishedRoot)) : clearHydrationBoundary(hostParent, deletedFiber.stateNode));
10209            break;
10210          case 4:
10211            prevHostParent = hostParent;
10212            prevHostParentIsContainer = hostParentIsContainer;
10213            hostParent = deletedFiber.stateNode.containerInfo;
10214            hostParentIsContainer = true;
10215            recursivelyTraverseDeletionEffects(
10216              finishedRoot,
10217              nearestMountedAncestor,
10218              deletedFiber
10219            );
10220            hostParent = prevHostParent;
10221            hostParentIsContainer = prevHostParentIsContainer;
10222            break;
10223          case 0:
10224          case 11:
10225          case 14:
10226          case 15:
10227            commitHookEffectListUnmount(
10228              Insertion,
10229              deletedFiber,
10230              nearestMountedAncestor
10231            );
10232            offscreenSubtreeWasHidden || commitHookLayoutUnmountEffects(
10233              deletedFiber,
10234              nearestMountedAncestor,
10235              Layout
10236            );
10237            recursivelyTraverseDeletionEffects(
10238              finishedRoot,
10239              nearestMountedAncestor,
10240              deletedFiber
10241            );
10242            break;
10243          case 1:
10244            offscreenSubtreeWasHidden || (safelyDetachRef(deletedFiber, nearestMountedAncestor), prevHostParent = deletedFiber.stateNode, "function" === typeof prevHostParent.componentWillUnmount && safelyCallComponentWillUnmount(
10245              deletedFiber,
10246              nearestMountedAncestor,
10247              prevHostParent
10248            ));
10249            recursivelyTraverseDeletionEffects(
10250              finishedRoot,
10251              nearestMountedAncestor,
10252              deletedFiber
10253            );
10254            break;
10255          case 21:
10256            recursivelyTraverseDeletionEffects(
10257              finishedRoot,
10258              nearestMountedAncestor,
10259              deletedFiber
10260            );
10261            break;
10262          case 22:
10263            offscreenSubtreeWasHidden = (prevHostParent = offscreenSubtreeWasHidden) || null !== deletedFiber.memoizedState;
10264            recursivelyTraverseDeletionEffects(
10265              finishedRoot,
10266              nearestMountedAncestor,
10267              deletedFiber
10268            );
10269            offscreenSubtreeWasHidden = prevHostParent;
10270            break;
10271          default:
10272            recursivelyTraverseDeletionEffects(
10273              finishedRoot,
10274              nearestMountedAncestor,
10275              deletedFiber
10276            );
10277        }
10278        (deletedFiber.mode & ProfileMode) !== NoMode && 0 <= componentEffectStartTime && 0 <= componentEffectEndTime && (componentEffectSpawnedUpdate || 0.05 < componentEffectDuration) && logComponentEffect(
10279          deletedFiber,
10280          componentEffectStartTime,
10281          componentEffectEndTime,
10282          componentEffectDuration,
10283          componentEffectErrors
10284        );
10285        popComponentEffectStart(prevEffectStart);
10286        popComponentEffectDuration(prevEffectDuration);
10287        componentEffectErrors = prevEffectErrors;
10288        componentEffectSpawnedUpdate = prevEffectDidSpawnUpdate;
10289      }
10290      function commitActivityHydrationCallbacks(finishedRoot, finishedWork) {
10291        if (null === finishedWork.memoizedState && (finishedRoot = finishedWork.alternate, null !== finishedRoot && (finishedRoot = finishedRoot.memoizedState, null !== finishedRoot))) {
10292          finishedRoot = finishedRoot.dehydrated;
10293          try {
10294            runWithFiberInDEV(
10295              finishedWork,
10296              commitHydratedActivityInstance,
10297              finishedRoot
10298            );
10299          } catch (error) {
10300            captureCommitPhaseError(finishedWork, finishedWork.return, error);
10301          }
10302        }
10303      }
10304      function commitSuspenseHydrationCallbacks(finishedRoot, finishedWork) {
10305        if (null === finishedWork.memoizedState && (finishedRoot = finishedWork.alternate, null !== finishedRoot && (finishedRoot = finishedRoot.memoizedState, null !== finishedRoot && (finishedRoot = finishedRoot.dehydrated, null !== finishedRoot))))
10306          try {
10307            runWithFiberInDEV(
10308              finishedWork,
10309              commitHydratedSuspenseInstance,
10310              finishedRoot
10311            );
10312          } catch (error) {
10313            captureCommitPhaseError(finishedWork, finishedWork.return, error);
10314          }
10315      }
10316      function getRetryCache(finishedWork) {
10317        switch (finishedWork.tag) {
10318          case 31:
10319          case 13:
10320          case 19:
10321            var retryCache = finishedWork.stateNode;
10322            null === retryCache && (retryCache = finishedWork.stateNode = new PossiblyWeakSet());
10323            return retryCache;
10324          case 22:
10325            return finishedWork = finishedWork.stateNode, retryCache = finishedWork._retryCache, null === retryCache && (retryCache = finishedWork._retryCache = new PossiblyWeakSet()), retryCache;
10326          default:
10327            throw Error(
10328              "Unexpected Suspense handler tag (" + finishedWork.tag + "). This is a bug in React."
10329            );
10330        }
10331      }
10332      function attachSuspenseRetryListeners(finishedWork, wakeables) {
10333        var retryCache = getRetryCache(finishedWork);
10334        wakeables.forEach(function(wakeable) {
10335          if (!retryCache.has(wakeable)) {
10336            retryCache.add(wakeable);
10337            if (isDevToolsPresent)
10338              if (null !== inProgressLanes && null !== inProgressRoot)
10339                restorePendingUpdaters(inProgressRoot, inProgressLanes);
10340              else
10341                throw Error(
10342                  "Expected finished root and lanes to be set. This is a bug in React."
10343                );
10344            var retry = resolveRetryWakeable.bind(null, finishedWork, wakeable);
10345            wakeable.then(retry, retry);
10346          }
10347        });
10348      }
10349      function recursivelyTraverseMutationEffects(root$jscomp$0, parentFiber) {
10350        var deletions = parentFiber.deletions;
10351        if (null !== deletions)
10352          for (var i = 0; i < deletions.length; i++) {
10353            var root2 = root$jscomp$0, returnFiber = parentFiber, deletedFiber = deletions[i], prevEffectStart = pushComponentEffectStart(), parent = returnFiber;
10354            a: for (; null !== parent; ) {
10355              switch (parent.tag) {
10356                case 27:
10357                  if (isSingletonScope(parent.type)) {
10358                    hostParent = parent.stateNode;
10359                    hostParentIsContainer = false;
10360                    break a;
10361                  }
10362                  break;
10363                case 5:
10364                  hostParent = parent.stateNode;
10365                  hostParentIsContainer = false;
10366                  break a;
10367                case 3:
10368                case 4:
10369                  hostParent = parent.stateNode.containerInfo;
10370                  hostParentIsContainer = true;
10371                  break a;
10372              }
10373              parent = parent.return;
10374            }
10375            if (null === hostParent)
10376              throw Error(
10377                "Expected to find a host parent. This error is likely caused by a bug in React. Please file an issue."
10378              );
10379            commitDeletionEffectsOnFiber(root2, returnFiber, deletedFiber);
10380            hostParent = null;
10381            hostParentIsContainer = false;
10382            (deletedFiber.mode & ProfileMode) !== NoMode && 0 <= componentEffectStartTime && 0 <= componentEffectEndTime && 0.05 < componentEffectEndTime - componentEffectStartTime && logComponentTrigger(
10383              deletedFiber,
10384              componentEffectStartTime,
10385              componentEffectEndTime,
10386              "Unmount"
10387            );
10388            popComponentEffectStart(prevEffectStart);
10389            root2 = deletedFiber;
10390            returnFiber = root2.alternate;
10391            null !== returnFiber && (returnFiber.return = null);
10392            root2.return = null;
10393          }
10394        if (parentFiber.subtreeFlags & 13886)
10395          for (parentFiber = parentFiber.child; null !== parentFiber; )
10396            commitMutationEffectsOnFiber(parentFiber, root$jscomp$0), parentFiber = parentFiber.sibling;
10397      }
10398      function commitMutationEffectsOnFiber(finishedWork, root2) {
10399        var prevEffectStart = pushComponentEffectStart(), prevEffectDuration = pushComponentEffectDuration(), prevEffectErrors = pushComponentEffectErrors(), prevEffectDidSpawnUpdate = pushComponentEffectDidSpawnUpdate(), current2 = finishedWork.alternate, flags = finishedWork.flags;
10400        switch (finishedWork.tag) {
10401          case 0:
10402          case 11:
10403          case 14:
10404          case 15:
10405            recursivelyTraverseMutationEffects(root2, finishedWork);
10406            commitReconciliationEffects(finishedWork);
10407            flags & 4 && (commitHookEffectListUnmount(
10408              Insertion | HasEffect,
10409              finishedWork,
10410              finishedWork.return
10411            ), commitHookEffectListMount(Insertion | HasEffect, finishedWork), commitHookLayoutUnmountEffects(
10412              finishedWork,
10413              finishedWork.return,
10414              Layout | HasEffect
10415            ));
10416            break;
10417          case 1:
10418            recursivelyTraverseMutationEffects(root2, finishedWork);
10419            commitReconciliationEffects(finishedWork);
10420            flags & 512 && (offscreenSubtreeWasHidden || null === current2 || safelyDetachRef(current2, current2.return));
10421            if (flags & 64 && offscreenSubtreeIsHidden && (flags = finishedWork.updateQueue, null !== flags && (current2 = flags.callbacks, null !== current2))) {
10422              var existingHiddenCallbacks = flags.shared.hiddenCallbacks;
10423              flags.shared.hiddenCallbacks = null === existingHiddenCallbacks ? current2 : existingHiddenCallbacks.concat(current2);
10424            }
10425            break;
10426          case 26:
10427            existingHiddenCallbacks = currentHoistableRoot;
10428            recursivelyTraverseMutationEffects(root2, finishedWork);
10429            commitReconciliationEffects(finishedWork);
10430            flags & 512 && (offscreenSubtreeWasHidden || null === current2 || safelyDetachRef(current2, current2.return));
10431            if (flags & 4) {
10432              var currentResource = null !== current2 ? current2.memoizedState : null;
10433              flags = finishedWork.memoizedState;
10434              if (null === current2)
10435                if (null === flags)
10436                  if (null === finishedWork.stateNode) {
10437                    a: {
10438                      flags = finishedWork.type;
10439                      current2 = finishedWork.memoizedProps;
10440                      existingHiddenCallbacks = existingHiddenCallbacks.ownerDocument || existingHiddenCallbacks;
10441                      b: switch (flags) {
10442                        case "title":
10443                          currentResource = existingHiddenCallbacks.getElementsByTagName(
10444                            "title"
10445                          )[0];
10446                          if (!currentResource || currentResource[internalHoistableMarker] || currentResource[internalInstanceKey] || currentResource.namespaceURI === SVG_NAMESPACE || currentResource.hasAttribute("itemprop"))
10447                            currentResource = existingHiddenCallbacks.createElement(flags), existingHiddenCallbacks.head.insertBefore(
10448                              currentResource,
10449                              existingHiddenCallbacks.querySelector(
10450                                "head > title"
10451                              )
10452                            );
10453                          setInitialProperties(currentResource, flags, current2);
10454                          currentResource[internalInstanceKey] = finishedWork;
10455                          markNodeAsHoistable(currentResource);
10456                          flags = currentResource;
10457                          break a;
10458                        case "link":
10459                          var maybeNodes = getHydratableHoistableCache(
10460                            "link",
10461                            "href",
10462                            existingHiddenCallbacks
10463                          ).get(flags + (current2.href || ""));
10464                          if (maybeNodes) {
10465                            for (var i = 0; i < maybeNodes.length; i++)
10466                              if (currentResource = maybeNodes[i], currentResource.getAttribute("href") === (null == current2.href || "" === current2.href ? null : current2.href) && currentResource.getAttribute("rel") === (null == current2.rel ? null : current2.rel) && currentResource.getAttribute("title") === (null == current2.title ? null : current2.title) && currentResource.getAttribute("crossorigin") === (null == current2.crossOrigin ? null : current2.crossOrigin)) {
10467                                maybeNodes.splice(i, 1);
10468                                break b;
10469                              }
10470                          }
10471                          currentResource = existingHiddenCallbacks.createElement(flags);
10472                          setInitialProperties(currentResource, flags, current2);
10473                          existingHiddenCallbacks.head.appendChild(
10474                            currentResource
10475                          );
10476                          break;
10477                        case "meta":
10478                          if (maybeNodes = getHydratableHoistableCache(
10479                            "meta",
10480                            "content",
10481                            existingHiddenCallbacks
10482                          ).get(flags + (current2.content || ""))) {
10483                            for (i = 0; i < maybeNodes.length; i++)
10484                              if (currentResource = maybeNodes[i], checkAttributeStringCoercion(
10485                                current2.content,
10486                                "content"
10487                              ), currentResource.getAttribute("content") === (null == current2.content ? null : "" + current2.content) && currentResource.getAttribute("name") === (null == current2.name ? null : current2.name) && currentResource.getAttribute("property") === (null == current2.property ? null : current2.property) && currentResource.getAttribute("http-equiv") === (null == current2.httpEquiv ? null : current2.httpEquiv) && currentResource.getAttribute("charset") === (null == current2.charSet ? null : current2.charSet)) {
10488                                maybeNodes.splice(i, 1);
10489                                break b;
10490                              }
10491                          }
10492                          currentResource = existingHiddenCallbacks.createElement(flags);
10493                          setInitialProperties(currentResource, flags, current2);
10494                          existingHiddenCallbacks.head.appendChild(
10495                            currentResource
10496                          );
10497                          break;
10498                        default:
10499                          throw Error(
10500                            'getNodesForType encountered a type it did not expect: "' + flags + '". This is a bug in React.'
10501                          );
10502                      }
10503                      currentResource[internalInstanceKey] = finishedWork;
10504                      markNodeAsHoistable(currentResource);
10505                      flags = currentResource;
10506                    }
10507                    finishedWork.stateNode = flags;
10508                  } else
10509                    mountHoistable(
10510                      existingHiddenCallbacks,
10511                      finishedWork.type,
10512                      finishedWork.stateNode
10513                    );
10514                else
10515                  finishedWork.stateNode = acquireResource(
10516                    existingHiddenCallbacks,
10517                    flags,
10518                    finishedWork.memoizedProps
10519                  );
10520              else
10521                currentResource !== flags ? (null === currentResource ? null !== current2.stateNode && (current2 = current2.stateNode, current2.parentNode.removeChild(current2)) : currentResource.count--, null === flags ? mountHoistable(
10522                  existingHiddenCallbacks,
10523                  finishedWork.type,
10524                  finishedWork.stateNode
10525                ) : acquireResource(
10526                  existingHiddenCallbacks,
10527                  flags,
10528                  finishedWork.memoizedProps
10529                )) : null === flags && null !== finishedWork.stateNode && commitHostUpdate(
10530                  finishedWork,
10531                  finishedWork.memoizedProps,
10532                  current2.memoizedProps
10533                );
10534            }
10535            break;
10536          case 27:
10537            recursivelyTraverseMutationEffects(root2, finishedWork);
10538            commitReconciliationEffects(finishedWork);
10539            flags & 512 && (offscreenSubtreeWasHidden || null === current2 || safelyDetachRef(current2, current2.return));
10540            null !== current2 && flags & 4 && commitHostUpdate(
10541              finishedWork,
10542              finishedWork.memoizedProps,
10543              current2.memoizedProps
10544            );
10545            break;
10546          case 5:
10547            recursivelyTraverseMutationEffects(root2, finishedWork);
10548            commitReconciliationEffects(finishedWork);
10549            flags & 512 && (offscreenSubtreeWasHidden || null === current2 || safelyDetachRef(current2, current2.return));
10550            if (finishedWork.flags & 32) {
10551              existingHiddenCallbacks = finishedWork.stateNode;
10552              try {
10553                runWithFiberInDEV(
10554                  finishedWork,
10555                  resetTextContent,
10556                  existingHiddenCallbacks
10557                );
10558              } catch (error) {
10559                captureCommitPhaseError(finishedWork, finishedWork.return, error);
10560              }
10561            }
10562            flags & 4 && null != finishedWork.stateNode && (existingHiddenCallbacks = finishedWork.memoizedProps, commitHostUpdate(
10563              finishedWork,
10564              existingHiddenCallbacks,
10565              null !== current2 ? current2.memoizedProps : existingHiddenCallbacks
10566            ));
10567            flags & 1024 && (needsFormReset = true, "form" !== finishedWork.type && console.error(
10568              "Unexpected host component type. Expected a form. This is a bug in React."
10569            ));
10570            break;
10571          case 6:
10572            recursivelyTraverseMutationEffects(root2, finishedWork);
10573            commitReconciliationEffects(finishedWork);
10574            if (flags & 4) {
10575              if (null === finishedWork.stateNode)
10576                throw Error(
10577                  "This should have a text node initialized. This error is likely caused by a bug in React. Please file an issue."
10578                );
10579              flags = finishedWork.memoizedProps;
10580              current2 = null !== current2 ? current2.memoizedProps : flags;
10581              existingHiddenCallbacks = finishedWork.stateNode;
10582              try {
10583                runWithFiberInDEV(
10584                  finishedWork,
10585                  commitTextUpdate,
10586                  existingHiddenCallbacks,
10587                  current2,
10588                  flags
10589                );
10590              } catch (error) {
10591                captureCommitPhaseError(finishedWork, finishedWork.return, error);
10592              }
10593            }
10594            break;
10595          case 3:
10596            existingHiddenCallbacks = pushNestedEffectDurations();
10597            tagCaches = null;
10598            currentResource = currentHoistableRoot;
10599            currentHoistableRoot = getHoistableRoot(root2.containerInfo);
10600            recursivelyTraverseMutationEffects(root2, finishedWork);
10601            currentHoistableRoot = currentResource;
10602            commitReconciliationEffects(finishedWork);
10603            if (flags & 4 && null !== current2 && current2.memoizedState.isDehydrated)
10604              try {
10605                runWithFiberInDEV(
10606                  finishedWork,
10607                  commitHydratedContainer,
10608                  root2.containerInfo
10609                );
10610              } catch (error) {
10611                captureCommitPhaseError(finishedWork, finishedWork.return, error);
10612              }
10613            needsFormReset && (needsFormReset = false, recursivelyResetForms(finishedWork));
10614            root2.effectDuration += popNestedEffectDurations(
10615              existingHiddenCallbacks
10616            );
10617            break;
10618          case 4:
10619            flags = currentHoistableRoot;
10620            currentHoistableRoot = getHoistableRoot(
10621              finishedWork.stateNode.containerInfo
10622            );
10623            recursivelyTraverseMutationEffects(root2, finishedWork);
10624            commitReconciliationEffects(finishedWork);
10625            currentHoistableRoot = flags;
10626            break;
10627          case 12:
10628            flags = pushNestedEffectDurations();
10629            recursivelyTraverseMutationEffects(root2, finishedWork);
10630            commitReconciliationEffects(finishedWork);
10631            finishedWork.stateNode.effectDuration += bubbleNestedEffectDurations(flags);
10632            break;
10633          case 31:
10634            recursivelyTraverseMutationEffects(root2, finishedWork);
10635            commitReconciliationEffects(finishedWork);
10636            flags & 4 && (flags = finishedWork.updateQueue, null !== flags && (finishedWork.updateQueue = null, attachSuspenseRetryListeners(finishedWork, flags)));
10637            break;
10638          case 13:
10639            recursivelyTraverseMutationEffects(root2, finishedWork);
10640            commitReconciliationEffects(finishedWork);
10641            finishedWork.child.flags & 8192 && null !== finishedWork.memoizedState !== (null !== current2 && null !== current2.memoizedState) && (globalMostRecentFallbackTime = now$1());
10642            flags & 4 && (flags = finishedWork.updateQueue, null !== flags && (finishedWork.updateQueue = null, attachSuspenseRetryListeners(finishedWork, flags)));
10643            break;
10644          case 22:
10645            existingHiddenCallbacks = null !== finishedWork.memoizedState;
10646            var wasHidden = null !== current2 && null !== current2.memoizedState, prevOffscreenSubtreeIsHidden = offscreenSubtreeIsHidden, prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
10647            offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden || existingHiddenCallbacks;
10648            offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden || wasHidden;
10649            recursivelyTraverseMutationEffects(root2, finishedWork);
10650            offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
10651            offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden;
10652            wasHidden && !existingHiddenCallbacks && !prevOffscreenSubtreeIsHidden && !prevOffscreenSubtreeWasHidden && (finishedWork.mode & ProfileMode) !== NoMode && 0 <= componentEffectStartTime && 0 <= componentEffectEndTime && 0.05 < componentEffectEndTime - componentEffectStartTime && logComponentReappeared(
10653              finishedWork,
10654              componentEffectStartTime,
10655              componentEffectEndTime
10656            );
10657            commitReconciliationEffects(finishedWork);
10658            if (flags & 8192)
10659              a: for (root2 = finishedWork.stateNode, root2._visibility = existingHiddenCallbacks ? root2._visibility & ~OffscreenVisible : root2._visibility | OffscreenVisible, !existingHiddenCallbacks || null === current2 || wasHidden || offscreenSubtreeIsHidden || offscreenSubtreeWasHidden || (recursivelyTraverseDisappearLayoutEffects(finishedWork), (finishedWork.mode & ProfileMode) !== NoMode && 0 <= componentEffectStartTime && 0 <= componentEffectEndTime && 0.05 < componentEffectEndTime - componentEffectStartTime && logComponentTrigger(
10660                finishedWork,
10661                componentEffectStartTime,
10662                componentEffectEndTime,
10663                "Disconnect"
10664              )), current2 = null, root2 = finishedWork; ; ) {
10665                if (5 === root2.tag || 26 === root2.tag) {
10666                  if (null === current2) {
10667                    wasHidden = current2 = root2;
10668                    try {
10669                      currentResource = wasHidden.stateNode, existingHiddenCallbacks ? runWithFiberInDEV(
10670                        wasHidden,
10671                        hideInstance,
10672                        currentResource
10673                      ) : runWithFiberInDEV(
10674                        wasHidden,
10675                        unhideInstance,
10676                        wasHidden.stateNode,
10677                        wasHidden.memoizedProps
10678                      );
10679                    } catch (error) {
10680                      captureCommitPhaseError(wasHidden, wasHidden.return, error);
10681                    }
10682                  }
10683                } else if (6 === root2.tag) {
10684                  if (null === current2) {
10685                    wasHidden = root2;
10686                    try {
10687                      maybeNodes = wasHidden.stateNode, existingHiddenCallbacks ? runWithFiberInDEV(
10688                        wasHidden,
10689                        hideTextInstance,
10690                        maybeNodes
10691                      ) : runWithFiberInDEV(
10692                        wasHidden,
10693                        unhideTextInstance,
10694                        maybeNodes,
10695                        wasHidden.memoizedProps
10696                      );
10697                    } catch (error) {
10698                      captureCommitPhaseError(wasHidden, wasHidden.return, error);
10699                    }
10700                  }
10701                } else if (18 === root2.tag) {
10702                  if (null === current2) {
10703                    wasHidden = root2;
10704                    try {
10705                      i = wasHidden.stateNode, existingHiddenCallbacks ? runWithFiberInDEV(
10706                        wasHidden,
10707                        hideDehydratedBoundary,
10708                        i
10709                      ) : runWithFiberInDEV(
10710                        wasHidden,
10711                        unhideDehydratedBoundary,
10712                        wasHidden.stateNode
10713                      );
10714                    } catch (error) {
10715                      captureCommitPhaseError(wasHidden, wasHidden.return, error);
10716                    }
10717                  }
10718                } else if ((22 !== root2.tag && 23 !== root2.tag || null === root2.memoizedState || root2 === finishedWork) && null !== root2.child) {
10719                  root2.child.return = root2;
10720                  root2 = root2.child;
10721                  continue;
10722                }
10723                if (root2 === finishedWork) break a;
10724                for (; null === root2.sibling; ) {
10725                  if (null === root2.return || root2.return === finishedWork)
10726                    break a;
10727                  current2 === root2 && (current2 = null);
10728                  root2 = root2.return;
10729                }
10730                current2 === root2 && (current2 = null);
10731                root2.sibling.return = root2.return;
10732                root2 = root2.sibling;
10733              }
10734            flags & 4 && (flags = finishedWork.updateQueue, null !== flags && (current2 = flags.retryQueue, null !== current2 && (flags.retryQueue = null, attachSuspenseRetryListeners(finishedWork, current2))));
10735            break;
10736          case 19:
10737            recursivelyTraverseMutationEffects(root2, finishedWork);
10738            commitReconciliationEffects(finishedWork);
10739            flags & 4 && (flags = finishedWork.updateQueue, null !== flags && (finishedWork.updateQueue = null, attachSuspenseRetryListeners(finishedWork, flags)));
10740            break;
10741          case 30:
10742            break;
10743          case 21:
10744            break;
10745          default:
10746            recursivelyTraverseMutationEffects(root2, finishedWork), commitReconciliationEffects(finishedWork);
10747        }
10748        (finishedWork.mode & ProfileMode) !== NoMode && 0 <= componentEffectStartTime && 0 <= componentEffectEndTime && ((componentEffectSpawnedUpdate || 0.05 < componentEffectDuration) && logComponentEffect(
10749          finishedWork,
10750          componentEffectStartTime,
10751          componentEffectEndTime,
10752          componentEffectDuration,
10753          componentEffectErrors
10754        ), null === finishedWork.alternate && null !== finishedWork.return && null !== finishedWork.return.alternate && 0.05 < componentEffectEndTime - componentEffectStartTime && (isHydratingParent(
10755          finishedWork.return.alternate,
10756          finishedWork.return
10757        ) || logComponentTrigger(
10758          finishedWork,
10759          componentEffectStartTime,
10760          componentEffectEndTime,
10761          "Mount"
10762        )));
10763        popComponentEffectStart(prevEffectStart);
10764        popComponentEffectDuration(prevEffectDuration);
10765        componentEffectErrors = prevEffectErrors;
10766        componentEffectSpawnedUpdate = prevEffectDidSpawnUpdate;
10767      }
10768      function commitReconciliationEffects(finishedWork) {
10769        var flags = finishedWork.flags;
10770        if (flags & 2) {
10771          try {
10772            runWithFiberInDEV(finishedWork, commitPlacement, finishedWork);
10773          } catch (error) {
10774            captureCommitPhaseError(finishedWork, finishedWork.return, error);
10775          }
10776          finishedWork.flags &= -3;
10777        }
10778        flags & 4096 && (finishedWork.flags &= -4097);
10779      }
10780      function recursivelyResetForms(parentFiber) {
10781        if (parentFiber.subtreeFlags & 1024)
10782          for (parentFiber = parentFiber.child; null !== parentFiber; ) {
10783            var fiber = parentFiber;
10784            recursivelyResetForms(fiber);
10785            5 === fiber.tag && fiber.flags & 1024 && fiber.stateNode.reset();
10786            parentFiber = parentFiber.sibling;
10787          }
10788      }
10789      function recursivelyTraverseLayoutEffects(root2, parentFiber) {
10790        if (parentFiber.subtreeFlags & 8772)
10791          for (parentFiber = parentFiber.child; null !== parentFiber; )
10792            commitLayoutEffectOnFiber(root2, parentFiber.alternate, parentFiber), parentFiber = parentFiber.sibling;
10793      }
10794      function disappearLayoutEffects(finishedWork) {
10795        var prevEffectStart = pushComponentEffectStart(), prevEffectDuration = pushComponentEffectDuration(), prevEffectErrors = pushComponentEffectErrors(), prevEffectDidSpawnUpdate = pushComponentEffectDidSpawnUpdate();
10796        switch (finishedWork.tag) {
10797          case 0:
10798          case 11:
10799          case 14:
10800          case 15:
10801            commitHookLayoutUnmountEffects(
10802              finishedWork,
10803              finishedWork.return,
10804              Layout
10805            );
10806            recursivelyTraverseDisappearLayoutEffects(finishedWork);
10807            break;
10808          case 1:
10809            safelyDetachRef(finishedWork, finishedWork.return);
10810            var instance = finishedWork.stateNode;
10811            "function" === typeof instance.componentWillUnmount && safelyCallComponentWillUnmount(
10812              finishedWork,
10813              finishedWork.return,
10814              instance
10815            );
10816            recursivelyTraverseDisappearLayoutEffects(finishedWork);
10817            break;
10818          case 27:
10819            runWithFiberInDEV(
10820              finishedWork,
10821              releaseSingletonInstance,
10822              finishedWork.stateNode
10823            );
10824          case 26:
10825          case 5:
10826            safelyDetachRef(finishedWork, finishedWork.return);
10827            recursivelyTraverseDisappearLayoutEffects(finishedWork);
10828            break;
10829          case 22:
10830            null === finishedWork.memoizedState && recursivelyTraverseDisappearLayoutEffects(finishedWork);
10831            break;
10832          case 30:
10833            recursivelyTraverseDisappearLayoutEffects(finishedWork);
10834            break;
10835          default:
10836            recursivelyTraverseDisappearLayoutEffects(finishedWork);
10837        }
10838        (finishedWork.mode & ProfileMode) !== NoMode && 0 <= componentEffectStartTime && 0 <= componentEffectEndTime && (componentEffectSpawnedUpdate || 0.05 < componentEffectDuration) && logComponentEffect(
10839          finishedWork,
10840          componentEffectStartTime,
10841          componentEffectEndTime,
10842          componentEffectDuration,
10843          componentEffectErrors
10844        );
10845        popComponentEffectStart(prevEffectStart);
10846        popComponentEffectDuration(prevEffectDuration);
10847        componentEffectErrors = prevEffectErrors;
10848        componentEffectSpawnedUpdate = prevEffectDidSpawnUpdate;
10849      }
10850      function recursivelyTraverseDisappearLayoutEffects(parentFiber) {
10851        for (parentFiber = parentFiber.child; null !== parentFiber; )
10852          disappearLayoutEffects(parentFiber), parentFiber = parentFiber.sibling;
10853      }
10854      function reappearLayoutEffects(finishedRoot, current2, finishedWork, includeWorkInProgressEffects) {
10855        var prevEffectStart = pushComponentEffectStart(), prevEffectDuration = pushComponentEffectDuration(), prevEffectErrors = pushComponentEffectErrors(), prevEffectDidSpawnUpdate = pushComponentEffectDidSpawnUpdate(), flags = finishedWork.flags;
10856        switch (finishedWork.tag) {
10857          case 0:
10858          case 11:
10859          case 15:
10860            recursivelyTraverseReappearLayoutEffects(
10861              finishedRoot,
10862              finishedWork,
10863              includeWorkInProgressEffects
10864            );
10865            commitHookLayoutEffects(finishedWork, Layout);
10866            break;
10867          case 1:
10868            recursivelyTraverseReappearLayoutEffects(
10869              finishedRoot,
10870              finishedWork,
10871              includeWorkInProgressEffects
10872            );
10873            current2 = finishedWork.stateNode;
10874            "function" === typeof current2.componentDidMount && runWithFiberInDEV(
10875              finishedWork,
10876              callComponentDidMountInDEV,
10877              finishedWork,
10878              current2
10879            );
10880            current2 = finishedWork.updateQueue;
10881            if (null !== current2) {
10882              finishedRoot = finishedWork.stateNode;
10883              try {
10884                runWithFiberInDEV(
10885                  finishedWork,
10886                  commitHiddenCallbacks,
10887                  current2,
10888                  finishedRoot
10889                );
10890              } catch (error) {
10891                captureCommitPhaseError(finishedWork, finishedWork.return, error);
10892              }
10893            }
10894            includeWorkInProgressEffects && flags & 64 && commitClassCallbacks(finishedWork);
10895            safelyAttachRef(finishedWork, finishedWork.return);
10896            break;
10897          case 27:
10898            commitHostSingletonAcquisition(finishedWork);
10899          case 26:
10900          case 5:
10901            recursivelyTraverseReappearLayoutEffects(
10902              finishedRoot,
10903              finishedWork,
10904              includeWorkInProgressEffects
10905            );
10906            includeWorkInProgressEffects && null === current2 && flags & 4 && commitHostMount(finishedWork);
10907            safelyAttachRef(finishedWork, finishedWork.return);
10908            break;
10909          case 12:
10910            if (includeWorkInProgressEffects && flags & 4) {
10911              flags = pushNestedEffectDurations();
10912              recursivelyTraverseReappearLayoutEffects(
10913                finishedRoot,
10914                finishedWork,
10915                includeWorkInProgressEffects
10916              );
10917              includeWorkInProgressEffects = finishedWork.stateNode;
10918              includeWorkInProgressEffects.effectDuration += bubbleNestedEffectDurations(flags);
10919              try {
10920                runWithFiberInDEV(
10921                  finishedWork,
10922                  commitProfiler,
10923                  finishedWork,
10924                  current2,
10925                  commitStartTime,
10926                  includeWorkInProgressEffects.effectDuration
10927                );
10928              } catch (error) {
10929                captureCommitPhaseError(finishedWork, finishedWork.return, error);
10930              }
10931            } else
10932              recursivelyTraverseReappearLayoutEffects(
10933                finishedRoot,
10934                finishedWork,
10935                includeWorkInProgressEffects
10936              );
10937            break;
10938          case 31:
10939            recursivelyTraverseReappearLayoutEffects(
10940              finishedRoot,
10941              finishedWork,
10942              includeWorkInProgressEffects
10943            );
10944            includeWorkInProgressEffects && flags & 4 && commitActivityHydrationCallbacks(finishedRoot, finishedWork);
10945            break;
10946          case 13:
10947            recursivelyTraverseReappearLayoutEffects(
10948              finishedRoot,
10949              finishedWork,
10950              includeWorkInProgressEffects
10951            );
10952            includeWorkInProgressEffects && flags & 4 && commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
10953            break;
10954          case 22:
10955            null === finishedWork.memoizedState && recursivelyTraverseReappearLayoutEffects(
10956              finishedRoot,
10957              finishedWork,
10958              includeWorkInProgressEffects
10959            );
10960            safelyAttachRef(finishedWork, finishedWork.return);
10961            break;
10962          case 30:
10963            break;
10964          default:
10965            recursivelyTraverseReappearLayoutEffects(
10966              finishedRoot,
10967              finishedWork,
10968              includeWorkInProgressEffects
10969            );
10970        }
10971        (finishedWork.mode & ProfileMode) !== NoMode && 0 <= componentEffectStartTime && 0 <= componentEffectEndTime && (componentEffectSpawnedUpdate || 0.05 < componentEffectDuration) && logComponentEffect(
10972          finishedWork,
10973          componentEffectStartTime,
10974          componentEffectEndTime,
10975          componentEffectDuration,
10976          componentEffectErrors
10977        );
10978        popComponentEffectStart(prevEffectStart);
10979        popComponentEffectDuration(prevEffectDuration);
10980        componentEffectErrors = prevEffectErrors;
10981        componentEffectSpawnedUpdate = prevEffectDidSpawnUpdate;
10982      }
10983      function recursivelyTraverseReappearLayoutEffects(finishedRoot, parentFiber, includeWorkInProgressEffects) {
10984        includeWorkInProgressEffects = includeWorkInProgressEffects && 0 !== (parentFiber.subtreeFlags & 8772);
10985        for (parentFiber = parentFiber.child; null !== parentFiber; )
10986          reappearLayoutEffects(
10987            finishedRoot,
10988            parentFiber.alternate,
10989            parentFiber,
10990            includeWorkInProgressEffects
10991          ), parentFiber = parentFiber.sibling;
10992      }
10993      function commitOffscreenPassiveMountEffects(current2, finishedWork) {
10994        var previousCache = null;
10995        null !== current2 && null !== current2.memoizedState && null !== current2.memoizedState.cachePool && (previousCache = current2.memoizedState.cachePool.pool);
10996        current2 = null;
10997        null !== finishedWork.memoizedState && null !== finishedWork.memoizedState.cachePool && (current2 = finishedWork.memoizedState.cachePool.pool);
10998        current2 !== previousCache && (null != current2 && retainCache(current2), null != previousCache && releaseCache(previousCache));
10999      }
11000      function commitCachePassiveMountEffect(current2, finishedWork) {
11001        current2 = null;
11002        null !== finishedWork.alternate && (current2 = finishedWork.alternate.memoizedState.cache);
11003        finishedWork = finishedWork.memoizedState.cache;
11004        finishedWork !== current2 && (retainCache(finishedWork), null != current2 && releaseCache(current2));
11005      }
11006      function recursivelyTraversePassiveMountEffects(root2, parentFiber, committedLanes, committedTransitions, endTime) {
11007        if (parentFiber.subtreeFlags & 10256 || 0 !== parentFiber.actualDuration && (null === parentFiber.alternate || parentFiber.alternate.child !== parentFiber.child))
11008          for (parentFiber = parentFiber.child; null !== parentFiber; ) {
11009            var nextSibling = parentFiber.sibling;
11010            commitPassiveMountOnFiber(
11011              root2,
11012              parentFiber,
11013              committedLanes,
11014              committedTransitions,
11015              null !== nextSibling ? nextSibling.actualStartTime : endTime
11016            );
11017            parentFiber = nextSibling;
11018          }
11019      }
11020      function commitPassiveMountOnFiber(finishedRoot, finishedWork, committedLanes, committedTransitions, endTime) {
11021        var prevEffectStart = pushComponentEffectStart(), prevEffectDuration = pushComponentEffectDuration(), prevEffectErrors = pushComponentEffectErrors(), prevEffectDidSpawnUpdate = pushComponentEffectDidSpawnUpdate(), prevDeepEquality = alreadyWarnedForDeepEquality, flags = finishedWork.flags;
11022        switch (finishedWork.tag) {
11023          case 0:
11024          case 11:
11025          case 15:
11026            (finishedWork.mode & ProfileMode) !== NoMode && 0 < finishedWork.actualStartTime && 0 !== (finishedWork.flags & 1) && logComponentRender(
11027              finishedWork,
11028              finishedWork.actualStartTime,
11029              endTime,
11030              inHydratedSubtree,
11031              committedLanes
11032            );
11033            recursivelyTraversePassiveMountEffects(
11034              finishedRoot,
11035              finishedWork,
11036              committedLanes,
11037              committedTransitions,
11038              endTime
11039            );
11040            flags & 2048 && commitHookPassiveMountEffects(finishedWork, Passive | HasEffect);
11041            break;
11042          case 1:
11043            (finishedWork.mode & ProfileMode) !== NoMode && 0 < finishedWork.actualStartTime && (0 !== (finishedWork.flags & 128) ? logComponentErrored(
11044              finishedWork,
11045              finishedWork.actualStartTime,
11046              endTime,
11047              []
11048            ) : 0 !== (finishedWork.flags & 1) && logComponentRender(
11049              finishedWork,
11050              finishedWork.actualStartTime,
11051              endTime,
11052              inHydratedSubtree,
11053              committedLanes
11054            ));
11055            recursivelyTraversePassiveMountEffects(
11056              finishedRoot,
11057              finishedWork,
11058              committedLanes,
11059              committedTransitions,
11060              endTime
11061            );
11062            break;
11063          case 3:
11064            var prevProfilerEffectDuration = pushNestedEffectDurations(), wasInHydratedSubtree = inHydratedSubtree;
11065            inHydratedSubtree = null !== finishedWork.alternate && finishedWork.alternate.memoizedState.isDehydrated && 0 === (finishedWork.flags & 256);
11066            recursivelyTraversePassiveMountEffects(
11067              finishedRoot,
11068              finishedWork,
11069              committedLanes,
11070              committedTransitions,
11071              endTime
11072            );
11073            inHydratedSubtree = wasInHydratedSubtree;
11074            flags & 2048 && (committedLanes = null, null !== finishedWork.alternate && (committedLanes = finishedWork.alternate.memoizedState.cache), committedTransitions = finishedWork.memoizedState.cache, committedTransitions !== committedLanes && (retainCache(committedTransitions), null != committedLanes && releaseCache(committedLanes)));
11075            finishedRoot.passiveEffectDuration += popNestedEffectDurations(
11076              prevProfilerEffectDuration
11077            );
11078            break;
11079          case 12:
11080            if (flags & 2048) {
11081              flags = pushNestedEffectDurations();
11082              recursivelyTraversePassiveMountEffects(
11083                finishedRoot,
11084                finishedWork,
11085                committedLanes,
11086                committedTransitions,
11087                endTime
11088              );
11089              finishedRoot = finishedWork.stateNode;
11090              finishedRoot.passiveEffectDuration += bubbleNestedEffectDurations(flags);
11091              try {
11092                runWithFiberInDEV(
11093                  finishedWork,
11094                  commitProfilerPostCommitImpl,
11095                  finishedWork,
11096                  finishedWork.alternate,
11097                  commitStartTime,
11098                  finishedRoot.passiveEffectDuration
11099                );
11100              } catch (error) {
11101                captureCommitPhaseError(finishedWork, finishedWork.return, error);
11102              }
11103            } else
11104              recursivelyTraversePassiveMountEffects(
11105                finishedRoot,
11106                finishedWork,
11107                committedLanes,
11108                committedTransitions,
11109                endTime
11110              );
11111            break;
11112          case 31:
11113            flags = inHydratedSubtree;
11114            prevProfilerEffectDuration = null !== finishedWork.alternate ? finishedWork.alternate.memoizedState : null;
11115            wasInHydratedSubtree = finishedWork.memoizedState;
11116            null !== prevProfilerEffectDuration && null === wasInHydratedSubtree ? (wasInHydratedSubtree = finishedWork.deletions, null !== wasInHydratedSubtree && 0 < wasInHydratedSubtree.length && 18 === wasInHydratedSubtree[0].tag ? (inHydratedSubtree = false, prevProfilerEffectDuration = prevProfilerEffectDuration.hydrationErrors, null !== prevProfilerEffectDuration && logComponentErrored(
11117              finishedWork,
11118              finishedWork.actualStartTime,
11119              endTime,
11120              prevProfilerEffectDuration
11121            )) : inHydratedSubtree = true) : inHydratedSubtree = false;
11122            recursivelyTraversePassiveMountEffects(
11123              finishedRoot,
11124              finishedWork,
11125              committedLanes,
11126              committedTransitions,
11127              endTime
11128            );
11129            inHydratedSubtree = flags;
11130            break;
11131          case 13:
11132            flags = inHydratedSubtree;
11133            prevProfilerEffectDuration = null !== finishedWork.alternate ? finishedWork.alternate.memoizedState : null;
11134            wasInHydratedSubtree = finishedWork.memoizedState;
11135            null === prevProfilerEffectDuration || null === prevProfilerEffectDuration.dehydrated || null !== wasInHydratedSubtree && null !== wasInHydratedSubtree.dehydrated ? inHydratedSubtree = false : (wasInHydratedSubtree = finishedWork.deletions, null !== wasInHydratedSubtree && 0 < wasInHydratedSubtree.length && 18 === wasInHydratedSubtree[0].tag ? (inHydratedSubtree = false, prevProfilerEffectDuration = prevProfilerEffectDuration.hydrationErrors, null !== prevProfilerEffectDuration && logComponentErrored(
11136              finishedWork,
11137              finishedWork.actualStartTime,
11138              endTime,
11139              prevProfilerEffectDuration
11140            )) : inHydratedSubtree = true);
11141            recursivelyTraversePassiveMountEffects(
11142              finishedRoot,
11143              finishedWork,
11144              committedLanes,
11145              committedTransitions,
11146              endTime
11147            );
11148            inHydratedSubtree = flags;
11149            break;
11150          case 23:
11151            break;
11152          case 22:
11153            wasInHydratedSubtree = finishedWork.stateNode;
11154            prevProfilerEffectDuration = finishedWork.alternate;
11155            null !== finishedWork.memoizedState ? wasInHydratedSubtree._visibility & OffscreenPassiveEffectsConnected ? recursivelyTraversePassiveMountEffects(
11156              finishedRoot,
11157              finishedWork,
11158              committedLanes,
11159              committedTransitions,
11160              endTime
11161            ) : recursivelyTraverseAtomicPassiveEffects(
11162              finishedRoot,
11163              finishedWork,
11164              committedLanes,
11165              committedTransitions,
11166              endTime
11167            ) : wasInHydratedSubtree._visibility & OffscreenPassiveEffectsConnected ? recursivelyTraversePassiveMountEffects(
11168              finishedRoot,
11169              finishedWork,
11170              committedLanes,
11171              committedTransitions,
11172              endTime
11173            ) : (wasInHydratedSubtree._visibility |= OffscreenPassiveEffectsConnected, recursivelyTraverseReconnectPassiveEffects(
11174              finishedRoot,
11175              finishedWork,
11176              committedLanes,
11177              committedTransitions,
11178              0 !== (finishedWork.subtreeFlags & 10256) || 0 !== finishedWork.actualDuration && (null === finishedWork.alternate || finishedWork.alternate.child !== finishedWork.child),
11179              endTime
11180            ), (finishedWork.mode & ProfileMode) === NoMode || inHydratedSubtree || (finishedRoot = finishedWork.actualStartTime, 0 <= finishedRoot && 0.05 < endTime - finishedRoot && logComponentReappeared(finishedWork, finishedRoot, endTime), 0 <= componentEffectStartTime && 0 <= componentEffectEndTime && 0.05 < componentEffectEndTime - componentEffectStartTime && logComponentReappeared(
11181              finishedWork,
11182              componentEffectStartTime,
11183              componentEffectEndTime
11184            )));
11185            flags & 2048 && commitOffscreenPassiveMountEffects(
11186              prevProfilerEffectDuration,
11187              finishedWork
11188            );
11189            break;
11190          case 24:
11191            recursivelyTraversePassiveMountEffects(
11192              finishedRoot,
11193              finishedWork,
11194              committedLanes,
11195              committedTransitions,
11196              endTime
11197            );
11198            flags & 2048 && commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
11199            break;
11200          default:
11201            recursivelyTraversePassiveMountEffects(
11202              finishedRoot,
11203              finishedWork,
11204              committedLanes,
11205              committedTransitions,
11206              endTime
11207            );
11208        }
11209        if ((finishedWork.mode & ProfileMode) !== NoMode) {
11210          if (finishedRoot = !inHydratedSubtree && null === finishedWork.alternate && null !== finishedWork.return && null !== finishedWork.return.alternate)
11211            committedLanes = finishedWork.actualStartTime, 0 <= committedLanes && 0.05 < endTime - committedLanes && logComponentTrigger(
11212              finishedWork,
11213              committedLanes,
11214              endTime,
11215              "Mount"
11216            );
11217          0 <= componentEffectStartTime && 0 <= componentEffectEndTime && ((componentEffectSpawnedUpdate || 0.05 < componentEffectDuration) && logComponentEffect(
11218            finishedWork,
11219            componentEffectStartTime,
11220            componentEffectEndTime,
11221            componentEffectDuration,
11222            componentEffectErrors
11223          ), finishedRoot && 0.05 < componentEffectEndTime - componentEffectStartTime && logComponentTrigger(
11224            finishedWork,
11225            componentEffectStartTime,
11226            componentEffectEndTime,
11227            "Mount"
11228          ));
11229        }
11230        popComponentEffectStart(prevEffectStart);
11231        popComponentEffectDuration(prevEffectDuration);
11232        componentEffectErrors = prevEffectErrors;
11233        componentEffectSpawnedUpdate = prevEffectDidSpawnUpdate;
11234        alreadyWarnedForDeepEquality = prevDeepEquality;
11235      }
11236      function recursivelyTraverseReconnectPassiveEffects(finishedRoot, parentFiber, committedLanes, committedTransitions, includeWorkInProgressEffects, endTime) {
11237        includeWorkInProgressEffects = includeWorkInProgressEffects && (0 !== (parentFiber.subtreeFlags & 10256) || 0 !== parentFiber.actualDuration && (null === parentFiber.alternate || parentFiber.alternate.child !== parentFiber.child));
11238        for (parentFiber = parentFiber.child; null !== parentFiber; ) {
11239          var nextSibling = parentFiber.sibling;
11240          reconnectPassiveEffects(
11241            finishedRoot,
11242            parentFiber,
11243            committedLanes,
11244            committedTransitions,
11245            includeWorkInProgressEffects,
11246            null !== nextSibling ? nextSibling.actualStartTime : endTime
11247          );
11248          parentFiber = nextSibling;
11249        }
11250      }
11251      function reconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects, endTime) {
11252        var prevEffectStart = pushComponentEffectStart(), prevEffectDuration = pushComponentEffectDuration(), prevEffectErrors = pushComponentEffectErrors(), prevEffectDidSpawnUpdate = pushComponentEffectDidSpawnUpdate(), prevDeepEquality = alreadyWarnedForDeepEquality;
11253        includeWorkInProgressEffects && (finishedWork.mode & ProfileMode) !== NoMode && 0 < finishedWork.actualStartTime && 0 !== (finishedWork.flags & 1) && logComponentRender(
11254          finishedWork,
11255          finishedWork.actualStartTime,
11256          endTime,
11257          inHydratedSubtree,
11258          committedLanes
11259        );
11260        var flags = finishedWork.flags;
11261        switch (finishedWork.tag) {
11262          case 0:
11263          case 11:
11264          case 15:
11265            recursivelyTraverseReconnectPassiveEffects(
11266              finishedRoot,
11267              finishedWork,
11268              committedLanes,
11269              committedTransitions,
11270              includeWorkInProgressEffects,
11271              endTime
11272            );
11273            commitHookPassiveMountEffects(finishedWork, Passive);
11274            break;
11275          case 23:
11276            break;
11277          case 22:
11278            var _instance2 = finishedWork.stateNode;
11279            null !== finishedWork.memoizedState ? _instance2._visibility & OffscreenPassiveEffectsConnected ? recursivelyTraverseReconnectPassiveEffects(
11280              finishedRoot,
11281              finishedWork,
11282              committedLanes,
11283              committedTransitions,
11284              includeWorkInProgressEffects,
11285              endTime
11286            ) : recursivelyTraverseAtomicPassiveEffects(
11287              finishedRoot,
11288              finishedWork,
11289              committedLanes,
11290              committedTransitions,
11291              endTime
11292            ) : (_instance2._visibility |= OffscreenPassiveEffectsConnected, recursivelyTraverseReconnectPassiveEffects(
11293              finishedRoot,
11294              finishedWork,
11295              committedLanes,
11296              committedTransitions,
11297              includeWorkInProgressEffects,
11298              endTime
11299            ));
11300            includeWorkInProgressEffects && flags & 2048 && commitOffscreenPassiveMountEffects(
11301              finishedWork.alternate,
11302              finishedWork
11303            );
11304            break;
11305          case 24:
11306            recursivelyTraverseReconnectPassiveEffects(
11307              finishedRoot,
11308              finishedWork,
11309              committedLanes,
11310              committedTransitions,
11311              includeWorkInProgressEffects,
11312              endTime
11313            );
11314            includeWorkInProgressEffects && flags & 2048 && commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
11315            break;
11316          default:
11317            recursivelyTraverseReconnectPassiveEffects(
11318              finishedRoot,
11319              finishedWork,
11320              committedLanes,
11321              committedTransitions,
11322              includeWorkInProgressEffects,
11323              endTime
11324            );
11325        }
11326        (finishedWork.mode & ProfileMode) !== NoMode && 0 <= componentEffectStartTime && 0 <= componentEffectEndTime && (componentEffectSpawnedUpdate || 0.05 < componentEffectDuration) && logComponentEffect(
11327          finishedWork,
11328          componentEffectStartTime,
11329          componentEffectEndTime,
11330          componentEffectDuration,
11331          componentEffectErrors
11332        );
11333        popComponentEffectStart(prevEffectStart);
11334        popComponentEffectDuration(prevEffectDuration);
11335        componentEffectErrors = prevEffectErrors;
11336        componentEffectSpawnedUpdate = prevEffectDidSpawnUpdate;
11337        alreadyWarnedForDeepEquality = prevDeepEquality;
11338      }
11339      function recursivelyTraverseAtomicPassiveEffects(finishedRoot$jscomp$0, parentFiber, committedLanes$jscomp$0, committedTransitions$jscomp$0, endTime$jscomp$0) {
11340        if (parentFiber.subtreeFlags & 10256 || 0 !== parentFiber.actualDuration && (null === parentFiber.alternate || parentFiber.alternate.child !== parentFiber.child))
11341          for (var child = parentFiber.child; null !== child; ) {
11342            parentFiber = child.sibling;
11343            var finishedRoot = finishedRoot$jscomp$0, committedLanes = committedLanes$jscomp$0, committedTransitions = committedTransitions$jscomp$0, endTime = null !== parentFiber ? parentFiber.actualStartTime : endTime$jscomp$0, prevDeepEquality = alreadyWarnedForDeepEquality;
11344            (child.mode & ProfileMode) !== NoMode && 0 < child.actualStartTime && 0 !== (child.flags & 1) && logComponentRender(
11345              child,
11346              child.actualStartTime,
11347              endTime,
11348              inHydratedSubtree,
11349              committedLanes
11350            );
11351            var flags = child.flags;
11352            switch (child.tag) {
11353              case 22:
11354                recursivelyTraverseAtomicPassiveEffects(
11355                  finishedRoot,
11356                  child,
11357                  committedLanes,
11358                  committedTransitions,
11359                  endTime
11360                );
11361                flags & 2048 && commitOffscreenPassiveMountEffects(child.alternate, child);
11362                break;
11363              case 24:
11364                recursivelyTraverseAtomicPassiveEffects(
11365                  finishedRoot,
11366                  child,
11367                  committedLanes,
11368                  committedTransitions,
11369                  endTime
11370                );
11371                flags & 2048 && commitCachePassiveMountEffect(child.alternate, child);
11372                break;
11373              default:
11374                recursivelyTraverseAtomicPassiveEffects(
11375                  finishedRoot,
11376                  child,
11377                  committedLanes,
11378                  committedTransitions,
11379                  endTime
11380                );
11381            }
11382            alreadyWarnedForDeepEquality = prevDeepEquality;
11383            child = parentFiber;
11384          }
11385      }
11386      function recursivelyAccumulateSuspenseyCommit(parentFiber, committedLanes, suspendedState) {
11387        if (parentFiber.subtreeFlags & suspenseyCommitFlag)
11388          for (parentFiber = parentFiber.child; null !== parentFiber; )
11389            accumulateSuspenseyCommitOnFiber(
11390              parentFiber,
11391              committedLanes,
11392              suspendedState
11393            ), parentFiber = parentFiber.sibling;
11394      }
11395      function accumulateSuspenseyCommitOnFiber(fiber, committedLanes, suspendedState) {
11396        switch (fiber.tag) {
11397          case 26:
11398            recursivelyAccumulateSuspenseyCommit(
11399              fiber,
11400              committedLanes,
11401              suspendedState
11402            );
11403            fiber.flags & suspenseyCommitFlag && null !== fiber.memoizedState && suspendResource(
11404              suspendedState,
11405              currentHoistableRoot,
11406              fiber.memoizedState,
11407              fiber.memoizedProps
11408            );
11409            break;
11410          case 5:
11411            recursivelyAccumulateSuspenseyCommit(
11412              fiber,
11413              committedLanes,
11414              suspendedState
11415            );
11416            break;
11417          case 3:
11418          case 4:
11419            var previousHoistableRoot = currentHoistableRoot;
11420            currentHoistableRoot = getHoistableRoot(
11421              fiber.stateNode.containerInfo
11422            );
11423            recursivelyAccumulateSuspenseyCommit(
11424              fiber,
11425              committedLanes,
11426              suspendedState
11427            );
11428            currentHoistableRoot = previousHoistableRoot;
11429            break;
11430          case 22:
11431            null === fiber.memoizedState && (previousHoistableRoot = fiber.alternate, null !== previousHoistableRoot && null !== previousHoistableRoot.memoizedState ? (previousHoistableRoot = suspenseyCommitFlag, suspenseyCommitFlag = 16777216, recursivelyAccumulateSuspenseyCommit(
11432              fiber,
11433              committedLanes,
11434              suspendedState
11435            ), suspenseyCommitFlag = previousHoistableRoot) : recursivelyAccumulateSuspenseyCommit(
11436              fiber,
11437              committedLanes,
11438              suspendedState
11439            ));
11440            break;
11441          default:
11442            recursivelyAccumulateSuspenseyCommit(
11443              fiber,
11444              committedLanes,
11445              suspendedState
11446            );
11447        }
11448      }
11449      function detachAlternateSiblings(parentFiber) {
11450        var previousFiber = parentFiber.alternate;
11451        if (null !== previousFiber && (parentFiber = previousFiber.child, null !== parentFiber)) {
11452          previousFiber.child = null;
11453          do
11454            previousFiber = parentFiber.sibling, parentFiber.sibling = null, parentFiber = previousFiber;
11455          while (null !== parentFiber);
11456        }
11457      }
11458      function recursivelyTraversePassiveUnmountEffects(parentFiber) {
11459        var deletions = parentFiber.deletions;
11460        if (0 !== (parentFiber.flags & 16)) {
11461          if (null !== deletions)
11462            for (var i = 0; i < deletions.length; i++) {
11463              var childToDelete = deletions[i], prevEffectStart = pushComponentEffectStart();
11464              nextEffect = childToDelete;
11465              commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
11466                childToDelete,
11467                parentFiber
11468              );
11469              (childToDelete.mode & ProfileMode) !== NoMode && 0 <= componentEffectStartTime && 0 <= componentEffectEndTime && 0.05 < componentEffectEndTime - componentEffectStartTime && logComponentTrigger(
11470                childToDelete,
11471                componentEffectStartTime,
11472                componentEffectEndTime,
11473                "Unmount"
11474              );
11475              popComponentEffectStart(prevEffectStart);
11476            }
11477          detachAlternateSiblings(parentFiber);
11478        }
11479        if (parentFiber.subtreeFlags & 10256)
11480          for (parentFiber = parentFiber.child; null !== parentFiber; )
11481            commitPassiveUnmountOnFiber(parentFiber), parentFiber = parentFiber.sibling;
11482      }
11483      function commitPassiveUnmountOnFiber(finishedWork) {
11484        var prevEffectStart = pushComponentEffectStart(), prevEffectDuration = pushComponentEffectDuration(), prevEffectErrors = pushComponentEffectErrors(), prevEffectDidSpawnUpdate = pushComponentEffectDidSpawnUpdate();
11485        switch (finishedWork.tag) {
11486          case 0:
11487          case 11:
11488          case 15:
11489            recursivelyTraversePassiveUnmountEffects(finishedWork);
11490            finishedWork.flags & 2048 && commitHookPassiveUnmountEffects(
11491              finishedWork,
11492              finishedWork.return,
11493              Passive | HasEffect
11494            );
11495            break;
11496          case 3:
11497            var prevProfilerEffectDuration = pushNestedEffectDurations();
11498            recursivelyTraversePassiveUnmountEffects(finishedWork);
11499            finishedWork.stateNode.passiveEffectDuration += popNestedEffectDurations(prevProfilerEffectDuration);
11500            break;
11501          case 12:
11502            prevProfilerEffectDuration = pushNestedEffectDurations();
11503            recursivelyTraversePassiveUnmountEffects(finishedWork);
11504            finishedWork.stateNode.passiveEffectDuration += bubbleNestedEffectDurations(prevProfilerEffectDuration);
11505            break;
11506          case 22:
11507            prevProfilerEffectDuration = finishedWork.stateNode;
11508            null !== finishedWork.memoizedState && prevProfilerEffectDuration._visibility & OffscreenPassiveEffectsConnected && (null === finishedWork.return || 13 !== finishedWork.return.tag) ? (prevProfilerEffectDuration._visibility &= ~OffscreenPassiveEffectsConnected, recursivelyTraverseDisconnectPassiveEffects(finishedWork), (finishedWork.mode & ProfileMode) !== NoMode && 0 <= componentEffectStartTime && 0 <= componentEffectEndTime && 0.05 < componentEffectEndTime - componentEffectStartTime && logComponentTrigger(
11509              finishedWork,
11510              componentEffectStartTime,
11511              componentEffectEndTime,
11512              "Disconnect"
11513            )) : recursivelyTraversePassiveUnmountEffects(finishedWork);
11514            break;
11515          default:
11516            recursivelyTraversePassiveUnmountEffects(finishedWork);
11517        }
11518        (finishedWork.mode & ProfileMode) !== NoMode && 0 <= componentEffectStartTime && 0 <= componentEffectEndTime && (componentEffectSpawnedUpdate || 0.05 < componentEffectDuration) && logComponentEffect(
11519          finishedWork,
11520          componentEffectStartTime,
11521          componentEffectEndTime,
11522          componentEffectDuration,
11523          componentEffectErrors
11524        );
11525        popComponentEffectStart(prevEffectStart);
11526        popComponentEffectDuration(prevEffectDuration);
11527        componentEffectSpawnedUpdate = prevEffectDidSpawnUpdate;
11528        componentEffectErrors = prevEffectErrors;
11529      }
11530      function recursivelyTraverseDisconnectPassiveEffects(parentFiber) {
11531        var deletions = parentFiber.deletions;
11532        if (0 !== (parentFiber.flags & 16)) {
11533          if (null !== deletions)
11534            for (var i = 0; i < deletions.length; i++) {
11535              var childToDelete = deletions[i], prevEffectStart = pushComponentEffectStart();
11536              nextEffect = childToDelete;
11537              commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
11538                childToDelete,
11539                parentFiber
11540              );
11541              (childToDelete.mode & ProfileMode) !== NoMode && 0 <= componentEffectStartTime && 0 <= componentEffectEndTime && 0.05 < componentEffectEndTime - componentEffectStartTime && logComponentTrigger(
11542                childToDelete,
11543                componentEffectStartTime,
11544                componentEffectEndTime,
11545                "Unmount"
11546              );
11547              popComponentEffectStart(prevEffectStart);
11548            }
11549          detachAlternateSiblings(parentFiber);
11550        }
11551        for (parentFiber = parentFiber.child; null !== parentFiber; )
11552          disconnectPassiveEffect(parentFiber), parentFiber = parentFiber.sibling;
11553      }
11554      function disconnectPassiveEffect(finishedWork) {
11555        var prevEffectStart = pushComponentEffectStart(), prevEffectDuration = pushComponentEffectDuration(), prevEffectErrors = pushComponentEffectErrors(), prevEffectDidSpawnUpdate = pushComponentEffectDidSpawnUpdate();
11556        switch (finishedWork.tag) {
11557          case 0:
11558          case 11:
11559          case 15:
11560            commitHookPassiveUnmountEffects(
11561              finishedWork,
11562              finishedWork.return,
11563              Passive
11564            );
11565            recursivelyTraverseDisconnectPassiveEffects(finishedWork);
11566            break;
11567          case 22:
11568            var instance = finishedWork.stateNode;
11569            instance._visibility & OffscreenPassiveEffectsConnected && (instance._visibility &= ~OffscreenPassiveEffectsConnected, recursivelyTraverseDisconnectPassiveEffects(finishedWork));
11570            break;
11571          default:
11572            recursivelyTraverseDisconnectPassiveEffects(finishedWork);
11573        }
11574        (finishedWork.mode & ProfileMode) !== NoMode && 0 <= componentEffectStartTime && 0 <= componentEffectEndTime && (componentEffectSpawnedUpdate || 0.05 < componentEffectDuration) && logComponentEffect(
11575          finishedWork,
11576          componentEffectStartTime,
11577          componentEffectEndTime,
11578          componentEffectDuration,
11579          componentEffectErrors
11580        );
11581        popComponentEffectStart(prevEffectStart);
11582        popComponentEffectDuration(prevEffectDuration);
11583        componentEffectSpawnedUpdate = prevEffectDidSpawnUpdate;
11584        componentEffectErrors = prevEffectErrors;
11585      }
11586      function commitPassiveUnmountEffectsInsideOfDeletedTree_begin(deletedSubtreeRoot, nearestMountedAncestor$jscomp$0) {
11587        for (; null !== nextEffect; ) {
11588          var fiber = nextEffect, current2 = fiber, nearestMountedAncestor = nearestMountedAncestor$jscomp$0, prevEffectStart = pushComponentEffectStart(), prevEffectDuration = pushComponentEffectDuration(), prevEffectErrors = pushComponentEffectErrors(), prevEffectDidSpawnUpdate = pushComponentEffectDidSpawnUpdate();
11589          switch (current2.tag) {
11590            case 0:
11591            case 11:
11592            case 15:
11593              commitHookPassiveUnmountEffects(
11594                current2,
11595                nearestMountedAncestor,
11596                Passive
11597              );
11598              break;
11599            case 23:
11600            case 22:
11601              null !== current2.memoizedState && null !== current2.memoizedState.cachePool && (nearestMountedAncestor = current2.memoizedState.cachePool.pool, null != nearestMountedAncestor && retainCache(nearestMountedAncestor));
11602              break;
11603            case 24:
11604              releaseCache(current2.memoizedState.cache);
11605          }
11606          (current2.mode & ProfileMode) !== NoMode && 0 <= componentEffectStartTime && 0 <= componentEffectEndTime && (componentEffectSpawnedUpdate || 0.05 < componentEffectDuration) && logComponentEffect(
11607            current2,
11608            componentEffectStartTime,
11609            componentEffectEndTime,
11610            componentEffectDuration,
11611            componentEffectErrors
11612          );
11613          popComponentEffectStart(prevEffectStart);
11614          popComponentEffectDuration(prevEffectDuration);
11615          componentEffectSpawnedUpdate = prevEffectDidSpawnUpdate;
11616          componentEffectErrors = prevEffectErrors;
11617          current2 = fiber.child;
11618          if (null !== current2) current2.return = fiber, nextEffect = current2;
11619          else
11620            a: for (fiber = deletedSubtreeRoot; null !== nextEffect; ) {
11621              current2 = nextEffect;
11622              prevEffectStart = current2.sibling;
11623              prevEffectDuration = current2.return;
11624              detachFiberAfterEffects(current2);
11625              if (current2 === fiber) {
11626                nextEffect = null;
11627                break a;
11628              }
11629              if (null !== prevEffectStart) {
11630                prevEffectStart.return = prevEffectDuration;
11631                nextEffect = prevEffectStart;
11632                break a;
11633              }
11634              nextEffect = prevEffectDuration;
11635            }
11636        }
11637      }
11638      function onCommitRoot() {
11639        commitHooks.forEach(function(commitHook) {
11640          return commitHook();
11641        });
11642      }
11643      function isConcurrentActEnvironment() {
11644        var isReactActEnvironmentGlobal = "undefined" !== typeof IS_REACT_ACT_ENVIRONMENT ? IS_REACT_ACT_ENVIRONMENT : void 0;
11645        isReactActEnvironmentGlobal || null === ReactSharedInternals.actQueue || console.error(
11646          "The current testing environment is not configured to support act(...)"
11647        );
11648        return isReactActEnvironmentGlobal;
11649      }
11650      function requestUpdateLane(fiber) {
11651        if ((executionContext & RenderContext) !== NoContext && 0 !== workInProgressRootRenderLanes)
11652          return workInProgressRootRenderLanes & -workInProgressRootRenderLanes;
11653        var transition = ReactSharedInternals.T;
11654        return null !== transition ? (transition._updatedFibers || (transition._updatedFibers = /* @__PURE__ */ new Set()), transition._updatedFibers.add(fiber), requestTransitionLane()) : resolveUpdatePriority();
11655      }
11656      function requestDeferredLane() {
11657        if (0 === workInProgressDeferredLane)
11658          if (0 === (workInProgressRootRenderLanes & 536870912) || isHydrating) {
11659            var lane = nextTransitionDeferredLane;
11660            nextTransitionDeferredLane <<= 1;
11661            0 === (nextTransitionDeferredLane & 3932160) && (nextTransitionDeferredLane = 262144);
11662            workInProgressDeferredLane = lane;
11663          } else workInProgressDeferredLane = 536870912;
11664        lane = suspenseHandlerStackCursor.current;
11665        null !== lane && (lane.flags |= 32);
11666        return workInProgressDeferredLane;
11667      }
11668      function scheduleUpdateOnFiber(root2, fiber, lane) {
11669        isRunningInsertionEffect && console.error("useInsertionEffect must not schedule updates.");
11670        isFlushingPassiveEffects && (didScheduleUpdateDuringPassiveEffects = true);
11671        if (root2 === workInProgressRoot && (workInProgressSuspendedReason === SuspendedOnData || workInProgressSuspendedReason === SuspendedOnAction) || null !== root2.cancelPendingCommit)
11672          prepareFreshStack(root2, 0), markRootSuspended(
11673            root2,
11674            workInProgressRootRenderLanes,
11675            workInProgressDeferredLane,
11676            false
11677          );
11678        markRootUpdated$1(root2, lane);
11679        if ((executionContext & RenderContext) !== NoContext && root2 === workInProgressRoot) {
11680          if (isRendering)
11681            switch (fiber.tag) {
11682              case 0:
11683              case 11:
11684              case 15:
11685                root2 = workInProgress && getComponentNameFromFiber(workInProgress) || "Unknown";
11686                didWarnAboutUpdateInRenderForAnotherComponent.has(root2) || (didWarnAboutUpdateInRenderForAnotherComponent.add(root2), fiber = getComponentNameFromFiber(fiber) || "Unknown", console.error(
11687                  "Cannot update a component (`%s`) while rendering a different component (`%s`). To locate the bad setState() call inside `%s`, follow the stack trace as described in https://react.dev/link/setstate-in-render",
11688                  fiber,
11689                  root2,
11690                  root2
11691                ));
11692                break;
11693              case 1:
11694                didWarnAboutUpdateInRender || (console.error(
11695                  "Cannot update during an existing state transition (such as within `render`). Render methods should be a pure function of props and state."
11696                ), didWarnAboutUpdateInRender = true);
11697            }
11698        } else
11699          isDevToolsPresent && addFiberToLanesMap(root2, fiber, lane), warnIfUpdatesNotWrappedWithActDEV(fiber), root2 === workInProgressRoot && ((executionContext & RenderContext) === NoContext && (workInProgressRootInterleavedUpdatedLanes |= lane), workInProgressRootExitStatus === RootSuspendedWithDelay && markRootSuspended(
11700            root2,
11701            workInProgressRootRenderLanes,
11702            workInProgressDeferredLane,
11703            false
11704          )), ensureRootIsScheduled(root2);
11705      }
11706      function performWorkOnRoot(root2, lanes, forceSync) {
11707        if ((executionContext & (RenderContext | CommitContext)) !== NoContext)
11708          throw Error("Should not already be working.");
11709        if (0 !== workInProgressRootRenderLanes && null !== workInProgress) {
11710          var yieldedFiber = workInProgress, yieldEndTime = now$1();
11711          switch (yieldReason) {
11712            case SuspendedOnImmediate:
11713            case SuspendedOnData:
11714              var startTime = yieldStartTime;
11715              supportsUserTiming && ((yieldedFiber = yieldedFiber._debugTask) ? yieldedFiber.run(
11716                console.timeStamp.bind(
11717                  console,
11718                  "Suspended",
11719                  startTime,
11720                  yieldEndTime,
11721                  COMPONENTS_TRACK,
11722                  void 0,
11723                  "primary-light"
11724                )
11725              ) : console.timeStamp(
11726                "Suspended",
11727                startTime,
11728                yieldEndTime,
11729                COMPONENTS_TRACK,
11730                void 0,
11731                "primary-light"
11732              ));
11733              break;
11734            case SuspendedOnAction:
11735              startTime = yieldStartTime;
11736              supportsUserTiming && ((yieldedFiber = yieldedFiber._debugTask) ? yieldedFiber.run(
11737                console.timeStamp.bind(
11738                  console,
11739                  "Action",
11740                  startTime,
11741                  yieldEndTime,
11742                  COMPONENTS_TRACK,
11743                  void 0,
11744                  "primary-light"
11745                )
11746              ) : console.timeStamp(
11747                "Action",
11748                startTime,
11749                yieldEndTime,
11750                COMPONENTS_TRACK,
11751                void 0,
11752                "primary-light"
11753              ));
11754              break;
11755            default:
11756              supportsUserTiming && (yieldedFiber = yieldEndTime - yieldStartTime, 3 > yieldedFiber || console.timeStamp(
11757                "Blocked",
11758                yieldStartTime,
11759                yieldEndTime,
11760                COMPONENTS_TRACK,
11761                void 0,
11762                5 > yieldedFiber ? "primary-light" : 10 > yieldedFiber ? "primary" : 100 > yieldedFiber ? "primary-dark" : "error"
11763              ));
11764          }
11765        }
11766        startTime = (forceSync = !forceSync && 0 === (lanes & 127) && 0 === (lanes & root2.expiredLanes) || checkIfRootIsPrerendering(root2, lanes)) ? renderRootConcurrent(root2, lanes) : renderRootSync(root2, lanes, true);
11767        var renderWasConcurrent = forceSync;
11768        do {
11769          if (startTime === RootInProgress) {
11770            workInProgressRootIsPrerendering && !forceSync && markRootSuspended(root2, lanes, 0, false);
11771            lanes = workInProgressSuspendedReason;
11772            yieldStartTime = now();
11773            yieldReason = lanes;
11774            break;
11775          } else {
11776            yieldedFiber = now$1();
11777            yieldEndTime = root2.current.alternate;
11778            if (renderWasConcurrent && !isRenderConsistentWithExternalStores(yieldEndTime)) {
11779              setCurrentTrackFromLanes(lanes);
11780              yieldEndTime = renderStartTime;
11781              startTime = yieldedFiber;
11782              !supportsUserTiming || startTime <= yieldEndTime || (workInProgressUpdateTask ? workInProgressUpdateTask.run(
11783                console.timeStamp.bind(
11784                  console,
11785                  "Teared Render",
11786                  yieldEndTime,
11787                  startTime,
11788                  currentTrack,
11789                  LANES_TRACK_GROUP,
11790                  "error"
11791                )
11792              ) : console.timeStamp(
11793                "Teared Render",
11794                yieldEndTime,
11795                startTime,
11796                currentTrack,
11797                LANES_TRACK_GROUP,
11798                "error"
11799              ));
11800              finalizeRender(lanes, yieldedFiber);
11801              startTime = renderRootSync(root2, lanes, false);
11802              renderWasConcurrent = false;
11803              continue;
11804            }
11805            if (startTime === RootErrored) {
11806              renderWasConcurrent = lanes;
11807              if (root2.errorRecoveryDisabledLanes & renderWasConcurrent)
11808                var errorRetryLanes = 0;
11809              else
11810                errorRetryLanes = root2.pendingLanes & -536870913, errorRetryLanes = 0 !== errorRetryLanes ? errorRetryLanes : errorRetryLanes & 536870912 ? 536870912 : 0;
11811              if (0 !== errorRetryLanes) {
11812                setCurrentTrackFromLanes(lanes);
11813                logErroredRenderPhase(
11814                  renderStartTime,
11815                  yieldedFiber,
11816                  lanes,
11817                  workInProgressUpdateTask
11818                );
11819                finalizeRender(lanes, yieldedFiber);
11820                lanes = errorRetryLanes;
11821                a: {
11822                  yieldedFiber = root2;
11823                  startTime = renderWasConcurrent;
11824                  renderWasConcurrent = workInProgressRootConcurrentErrors;
11825                  var wasRootDehydrated = yieldedFiber.current.memoizedState.isDehydrated;
11826                  wasRootDehydrated && (prepareFreshStack(yieldedFiber, errorRetryLanes).flags |= 256);
11827                  errorRetryLanes = renderRootSync(
11828                    yieldedFiber,
11829                    errorRetryLanes,
11830                    false
11831                  );
11832                  if (errorRetryLanes !== RootErrored) {
11833                    if (workInProgressRootDidAttachPingListener && !wasRootDehydrated) {
11834                      yieldedFiber.errorRecoveryDisabledLanes |= startTime;
11835                      workInProgressRootInterleavedUpdatedLanes |= startTime;
11836                      startTime = RootSuspendedWithDelay;
11837                      break a;
11838                    }
11839                    yieldedFiber = workInProgressRootRecoverableErrors;
11840                    workInProgressRootRecoverableErrors = renderWasConcurrent;
11841                    null !== yieldedFiber && (null === workInProgressRootRecoverableErrors ? workInProgressRootRecoverableErrors = yieldedFiber : workInProgressRootRecoverableErrors.push.apply(
11842                      workInProgressRootRecoverableErrors,
11843                      yieldedFiber
11844                    ));
11845                  }
11846                  startTime = errorRetryLanes;
11847                }
11848                renderWasConcurrent = false;
11849                if (startTime !== RootErrored) continue;
11850                else yieldedFiber = now$1();
11851              }
11852            }
11853            if (startTime === RootFatalErrored) {
11854              setCurrentTrackFromLanes(lanes);
11855              logErroredRenderPhase(
11856                renderStartTime,
11857                yieldedFiber,
11858                lanes,
11859                workInProgressUpdateTask
11860              );
11861              finalizeRender(lanes, yieldedFiber);
11862              prepareFreshStack(root2, 0);
11863              markRootSuspended(root2, lanes, 0, true);
11864              break;
11865            }
11866            a: {
11867              forceSync = root2;
11868              switch (startTime) {
11869                case RootInProgress:
11870                case RootFatalErrored:
11871                  throw Error("Root did not complete. This is a bug in React.");
11872                case RootSuspendedWithDelay:
11873                  if ((lanes & 4194048) !== lanes) break;
11874                case RootSuspendedAtTheShell:
11875                  setCurrentTrackFromLanes(lanes);
11876                  logSuspendedRenderPhase(
11877                    renderStartTime,
11878                    yieldedFiber,
11879                    lanes,
11880                    workInProgressUpdateTask
11881                  );
11882                  finalizeRender(lanes, yieldedFiber);
11883                  yieldEndTime = lanes;
11884                  0 !== (yieldEndTime & 127) ? blockingSuspendedTime = yieldedFiber : 0 !== (yieldEndTime & 4194048) && (transitionSuspendedTime = yieldedFiber);
11885                  markRootSuspended(
11886                    forceSync,
11887                    lanes,
11888                    workInProgressDeferredLane,
11889                    !workInProgressRootDidSkipSuspendedSiblings
11890                  );
11891                  break a;
11892                case RootErrored:
11893                  workInProgressRootRecoverableErrors = null;
11894                  break;
11895                case RootSuspended:
11896                case RootCompleted:
11897                  break;
11898                default:
11899                  throw Error("Unknown root exit status.");
11900              }
11901              if (null !== ReactSharedInternals.actQueue)
11902                commitRoot(
11903                  forceSync,
11904                  yieldEndTime,
11905                  lanes,
11906                  workInProgressRootRecoverableErrors,
11907                  workInProgressTransitions,
11908                  workInProgressRootDidIncludeRecursiveRenderUpdate,
11909                  workInProgressDeferredLane,
11910                  workInProgressRootInterleavedUpdatedLanes,
11911                  workInProgressSuspendedRetryLanes,
11912                  startTime,
11913                  null,
11914                  null,
11915                  renderStartTime,
11916                  yieldedFiber
11917                );
11918              else {
11919                if ((lanes & 62914560) === lanes && (renderWasConcurrent = globalMostRecentFallbackTime + FALLBACK_THROTTLE_MS - now$1(), 10 < renderWasConcurrent)) {
11920                  markRootSuspended(
11921                    forceSync,
11922                    lanes,
11923                    workInProgressDeferredLane,
11924                    !workInProgressRootDidSkipSuspendedSiblings
11925                  );
11926                  if (0 !== getNextLanes(forceSync, 0, true)) break a;
11927                  pendingEffectsLanes = lanes;
11928                  forceSync.timeoutHandle = scheduleTimeout(
11929                    commitRootWhenReady.bind(
11930                      null,
11931                      forceSync,
11932                      yieldEndTime,
11933                      workInProgressRootRecoverableErrors,
11934                      workInProgressTransitions,
11935                      workInProgressRootDidIncludeRecursiveRenderUpdate,
11936                      lanes,
11937                      workInProgressDeferredLane,
11938                      workInProgressRootInterleavedUpdatedLanes,
11939                      workInProgressSuspendedRetryLanes,
11940                      workInProgressRootDidSkipSuspendedSiblings,
11941                      startTime,
11942                      "Throttled",
11943                      renderStartTime,
11944                      yieldedFiber
11945                    ),
11946                    renderWasConcurrent
11947                  );
11948                  break a;
11949                }
11950                commitRootWhenReady(
11951                  forceSync,
11952                  yieldEndTime,
11953                  workInProgressRootRecoverableErrors,
11954                  workInProgressTransitions,
11955                  workInProgressRootDidIncludeRecursiveRenderUpdate,
11956                  lanes,
11957                  workInProgressDeferredLane,
11958                  workInProgressRootInterleavedUpdatedLanes,
11959                  workInProgressSuspendedRetryLanes,
11960                  workInProgressRootDidSkipSuspendedSiblings,
11961                  startTime,
11962                  null,
11963                  renderStartTime,
11964                  yieldedFiber
11965                );
11966              }
11967            }
11968          }
11969          break;
11970        } while (1);
11971        ensureRootIsScheduled(root2);
11972      }
11973      function commitRootWhenReady(root2, finishedWork, recoverableErrors, transitions, didIncludeRenderPhaseUpdate, lanes, spawnedLane, updatedLanes, suspendedRetryLanes, didSkipSuspendedSiblings, exitStatus, suspendedCommitReason, completedRenderStartTime, completedRenderEndTime) {
11974        root2.timeoutHandle = noTimeout;
11975        var subtreeFlags = finishedWork.subtreeFlags, suspendedState = null;
11976        if (subtreeFlags & 8192 || 16785408 === (subtreeFlags & 16785408)) {
11977          if (suspendedState = {
11978            stylesheets: null,
11979            count: 0,
11980            imgCount: 0,
11981            imgBytes: 0,
11982            suspenseyImages: [],
11983            waitingForImages: true,
11984            waitingForViewTransition: false,
11985            unsuspend: noop$1
11986          }, accumulateSuspenseyCommitOnFiber(finishedWork, lanes, suspendedState), subtreeFlags = (lanes & 62914560) === lanes ? globalMostRecentFallbackTime - now$1() : (lanes & 4194048) === lanes ? globalMostRecentTransitionTime - now$1() : 0, subtreeFlags = waitForCommitToBeReady(suspendedState, subtreeFlags), null !== subtreeFlags) {
11987            pendingEffectsLanes = lanes;
11988            root2.cancelPendingCommit = subtreeFlags(
11989              commitRoot.bind(
11990                null,
11991                root2,
11992                finishedWork,
11993                lanes,
11994                recoverableErrors,
11995                transitions,
11996                didIncludeRenderPhaseUpdate,
11997                spawnedLane,
11998                updatedLanes,
11999                suspendedRetryLanes,
12000                exitStatus,
12001                suspendedState,
12002                suspendedState.waitingForViewTransition ? "Waiting for the previous Animation" : 0 < suspendedState.count ? 0 < suspendedState.imgCount ? "Suspended on CSS and Images" : "Suspended on CSS" : 1 === suspendedState.imgCount ? "Suspended on an Image" : 0 < suspendedState.imgCount ? "Suspended on Images" : null,
12003                completedRenderStartTime,
12004                completedRenderEndTime
12005              )
12006            );
12007            markRootSuspended(
12008              root2,
12009              lanes,
12010              spawnedLane,
12011              !didSkipSuspendedSiblings
12012            );
12013            return;
12014          }
12015        }
12016        commitRoot(
12017          root2,
12018          finishedWork,
12019          lanes,
12020          recoverableErrors,
12021          transitions,
12022          didIncludeRenderPhaseUpdate,
12023          spawnedLane,
12024          updatedLanes,
12025          suspendedRetryLanes,
12026          exitStatus,
12027          suspendedState,
12028          suspendedCommitReason,
12029          completedRenderStartTime,
12030          completedRenderEndTime
12031        );
12032      }
12033      function isRenderConsistentWithExternalStores(finishedWork) {
12034        for (var node = finishedWork; ; ) {
12035          var tag = node.tag;
12036          if ((0 === tag || 11 === tag || 15 === tag) && node.flags & 16384 && (tag = node.updateQueue, null !== tag && (tag = tag.stores, null !== tag)))
12037            for (var i = 0; i < tag.length; i++) {
12038              var check = tag[i], getSnapshot = check.getSnapshot;
12039              check = check.value;
12040              try {
12041                if (!objectIs(getSnapshot(), check)) return false;
12042              } catch (error) {
12043                return false;
12044              }
12045            }
12046          tag = node.child;
12047          if (node.subtreeFlags & 16384 && null !== tag)
12048            tag.return = node, node = tag;
12049          else {
12050            if (node === finishedWork) break;
12051            for (; null === node.sibling; ) {
12052              if (null === node.return || node.return === finishedWork) return true;
12053              node = node.return;
12054            }
12055            node.sibling.return = node.return;
12056            node = node.sibling;
12057          }
12058        }
12059        return true;
12060      }
12061      function markRootSuspended(root2, suspendedLanes, spawnedLane, didAttemptEntireTree) {
12062        suspendedLanes &= ~workInProgressRootPingedLanes;
12063        suspendedLanes &= ~workInProgressRootInterleavedUpdatedLanes;
12064        root2.suspendedLanes |= suspendedLanes;
12065        root2.pingedLanes &= ~suspendedLanes;
12066        didAttemptEntireTree && (root2.warmLanes |= suspendedLanes);
12067        didAttemptEntireTree = root2.expirationTimes;
12068        for (var lanes = suspendedLanes; 0 < lanes; ) {
12069          var index = 31 - clz32(lanes), lane = 1 << index;
12070          didAttemptEntireTree[index] = -1;
12071          lanes &= ~lane;
12072        }
12073        0 !== spawnedLane && markSpawnedDeferredLane(root2, spawnedLane, suspendedLanes);
12074      }
12075      function flushSyncWork$1() {
12076        return (executionContext & (RenderContext | CommitContext)) === NoContext ? (flushSyncWorkAcrossRoots_impl(0, false), false) : true;
12077      }
12078      function resetWorkInProgressStack() {
12079        if (null !== workInProgress) {
12080          if (workInProgressSuspendedReason === NotSuspended)
12081            var interruptedWork = workInProgress.return;
12082          else
12083            interruptedWork = workInProgress, resetContextDependencies(), resetHooksOnUnwind(interruptedWork), thenableState$1 = null, thenableIndexCounter$1 = 0, interruptedWork = workInProgress;
12084          for (; null !== interruptedWork; )
12085            unwindInterruptedWork(interruptedWork.alternate, interruptedWork), interruptedWork = interruptedWork.return;
12086          workInProgress = null;
12087        }
12088      }
12089      function finalizeRender(lanes, finalizationTime) {
12090        0 !== (lanes & 127) && (blockingClampTime = finalizationTime);
12091        0 !== (lanes & 4194048) && (transitionClampTime = finalizationTime);
12092        0 !== (lanes & 62914560) && (retryClampTime = finalizationTime);
12093        0 !== (lanes & 2080374784) && (idleClampTime = finalizationTime);
12094      }
12095      function prepareFreshStack(root2, lanes) {
12096        supportsUserTiming && (console.timeStamp(
12097          "Blocking Track",
12098          3e-3,
12099          3e-3,
12100          "Blocking",
12101          LANES_TRACK_GROUP,
12102          "primary-light"
12103        ), console.timeStamp(
12104          "Transition Track",
12105          3e-3,
12106          3e-3,
12107          "Transition",
12108          LANES_TRACK_GROUP,
12109          "primary-light"
12110        ), console.timeStamp(
12111          "Suspense Track",
12112          3e-3,
12113          3e-3,
12114          "Suspense",
12115          LANES_TRACK_GROUP,
12116          "primary-light"
12117        ), console.timeStamp(
12118          "Idle Track",
12119          3e-3,
12120          3e-3,
12121          "Idle",
12122          LANES_TRACK_GROUP,
12123          "primary-light"
12124        ));
12125        var previousRenderStartTime = renderStartTime;
12126        renderStartTime = now();
12127        if (0 !== workInProgressRootRenderLanes && 0 < previousRenderStartTime) {
12128          setCurrentTrackFromLanes(workInProgressRootRenderLanes);
12129          if (workInProgressRootExitStatus === RootSuspended || workInProgressRootExitStatus === RootSuspendedWithDelay)
12130            logSuspendedRenderPhase(
12131              previousRenderStartTime,
12132              renderStartTime,
12133              lanes,
12134              workInProgressUpdateTask
12135            );
12136          else {
12137            var endTime = renderStartTime, debugTask = workInProgressUpdateTask;
12138            if (supportsUserTiming && !(endTime <= previousRenderStartTime)) {
12139              var color = (lanes & 738197653) === lanes ? "tertiary-dark" : "primary-dark", label = (lanes & 536870912) === lanes ? "Prewarm" : (lanes & 201326741) === lanes ? "Interrupted Hydration" : "Interrupted Render";
12140              debugTask ? debugTask.run(
12141                console.timeStamp.bind(
12142                  console,
12143                  label,
12144                  previousRenderStartTime,
12145                  endTime,
12146                  currentTrack,
12147                  LANES_TRACK_GROUP,
12148                  color
12149                )
12150              ) : console.timeStamp(
12151                label,
12152                previousRenderStartTime,
12153                endTime,
12154                currentTrack,
12155                LANES_TRACK_GROUP,
12156                color
12157              );
12158            }
12159          }
12160          finalizeRender(workInProgressRootRenderLanes, renderStartTime);
12161        }
12162        previousRenderStartTime = workInProgressUpdateTask;
12163        workInProgressUpdateTask = null;
12164        if (0 !== (lanes & 127)) {
12165          workInProgressUpdateTask = blockingUpdateTask;
12166          debugTask = 0 <= blockingUpdateTime && blockingUpdateTime < blockingClampTime ? blockingClampTime : blockingUpdateTime;
12167          endTime = 0 <= blockingEventTime && blockingEventTime < blockingClampTime ? blockingClampTime : blockingEventTime;
12168          color = 0 <= endTime ? endTime : 0 <= debugTask ? debugTask : renderStartTime;
12169          0 <= blockingSuspendedTime ? (setCurrentTrackFromLanes(2), logSuspendedWithDelayPhase(
12170            blockingSuspendedTime,
12171            color,
12172            lanes,
12173            previousRenderStartTime
12174          )) : 0 !== (animatingLanes & 127) && (setCurrentTrackFromLanes(2), logAnimatingPhase(blockingClampTime, color, animatingTask));
12175          previousRenderStartTime = debugTask;
12176          var eventTime = endTime, eventType = blockingEventType, eventIsRepeat = 0 < blockingEventRepeatTime, isSpawnedUpdate = blockingUpdateType === SPAWNED_UPDATE, isPingedUpdate = blockingUpdateType === PINGED_UPDATE;
12177          debugTask = renderStartTime;
12178          endTime = blockingUpdateTask;
12179          color = blockingUpdateMethodName;
12180          label = blockingUpdateComponentName;
12181          if (supportsUserTiming) {
12182            currentTrack = "Blocking";
12183            0 < previousRenderStartTime ? previousRenderStartTime > debugTask && (previousRenderStartTime = debugTask) : previousRenderStartTime = debugTask;
12184            0 < eventTime ? eventTime > previousRenderStartTime && (eventTime = previousRenderStartTime) : eventTime = previousRenderStartTime;
12185            if (null !== eventType && previousRenderStartTime > eventTime) {
12186              var color$jscomp$0 = eventIsRepeat ? "secondary-light" : "warning";
12187              endTime ? endTime.run(
12188                console.timeStamp.bind(
12189                  console,
12190                  eventIsRepeat ? "Consecutive" : "Event: " + eventType,
12191                  eventTime,
12192                  previousRenderStartTime,
12193                  currentTrack,
12194                  LANES_TRACK_GROUP,
12195                  color$jscomp$0
12196                )
12197              ) : console.timeStamp(
12198                eventIsRepeat ? "Consecutive" : "Event: " + eventType,
12199                eventTime,
12200                previousRenderStartTime,
12201                currentTrack,
12202                LANES_TRACK_GROUP,
12203                color$jscomp$0
12204              );
12205            }
12206            debugTask > previousRenderStartTime && (eventTime = isSpawnedUpdate ? "error" : (lanes & 738197653) === lanes ? "tertiary-light" : "primary-light", isSpawnedUpdate = isPingedUpdate ? "Promise Resolved" : isSpawnedUpdate ? "Cascading Update" : 5 < debugTask - previousRenderStartTime ? "Update Blocked" : "Update", isPingedUpdate = [], null != label && isPingedUpdate.push(["Component name", label]), null != color && isPingedUpdate.push(["Method name", color]), previousRenderStartTime = {
12207              start: previousRenderStartTime,
12208              end: debugTask,
12209              detail: {
12210                devtools: {
12211                  properties: isPingedUpdate,
12212                  track: currentTrack,
12213                  trackGroup: LANES_TRACK_GROUP,
12214                  color: eventTime
12215                }
12216              }
12217            }, endTime ? endTime.run(
12218              performance.measure.bind(
12219                performance,
12220                isSpawnedUpdate,
12221                previousRenderStartTime
12222              )
12223            ) : performance.measure(isSpawnedUpdate, previousRenderStartTime));
12224          }
12225          blockingUpdateTime = -1.1;
12226          blockingUpdateType = 0;
12227          blockingUpdateComponentName = blockingUpdateMethodName = null;
12228          blockingSuspendedTime = -1.1;
12229          blockingEventRepeatTime = blockingEventTime;
12230          blockingEventTime = -1.1;
12231          blockingClampTime = now();
12232        }
12233        0 !== (lanes & 4194048) && (workInProgressUpdateTask = transitionUpdateTask, debugTask = 0 <= transitionStartTime && transitionStartTime < transitionClampTime ? transitionClampTime : transitionStartTime, previousRenderStartTime = 0 <= transitionUpdateTime && transitionUpdateTime < transitionClampTime ? transitionClampTime : transitionUpdateTime, endTime = 0 <= transitionEventTime && transitionEventTime < transitionClampTime ? transitionClampTime : transitionEventTime, color = 0 <= endTime ? endTime : 0 <= previousRenderStartTime ? previousRenderStartTime : renderStartTime, 0 <= transitionSuspendedTime ? (setCurrentTrackFromLanes(256), logSuspendedWithDelayPhase(
12234          transitionSuspendedTime,
12235          color,
12236          lanes,
12237          workInProgressUpdateTask
12238        )) : 0 !== (animatingLanes & 4194048) && (setCurrentTrackFromLanes(256), logAnimatingPhase(transitionClampTime, color, animatingTask)), isPingedUpdate = endTime, eventTime = transitionEventType, eventType = 0 < transitionEventRepeatTime, eventIsRepeat = transitionUpdateType === PINGED_UPDATE, color = renderStartTime, endTime = transitionUpdateTask, label = transitionUpdateMethodName, isSpawnedUpdate = transitionUpdateComponentName, supportsUserTiming && (currentTrack = "Transition", 0 < previousRenderStartTime ? previousRenderStartTime > color && (previousRenderStartTime = color) : previousRenderStartTime = color, 0 < debugTask ? debugTask > previousRenderStartTime && (debugTask = previousRenderStartTime) : debugTask = previousRenderStartTime, 0 < isPingedUpdate ? isPingedUpdate > debugTask && (isPingedUpdate = debugTask) : isPingedUpdate = debugTask, debugTask > isPingedUpdate && null !== eventTime && (color$jscomp$0 = eventType ? "secondary-light" : "warning", endTime ? endTime.run(
12239          console.timeStamp.bind(
12240            console,
12241            eventType ? "Consecutive" : "Event: " + eventTime,
12242            isPingedUpdate,
12243            debugTask,
12244            currentTrack,
12245            LANES_TRACK_GROUP,
12246            color$jscomp$0
12247          )
12248        ) : console.timeStamp(
12249          eventType ? "Consecutive" : "Event: " + eventTime,
12250          isPingedUpdate,
12251          debugTask,
12252          currentTrack,
12253          LANES_TRACK_GROUP,
12254          color$jscomp$0
12255        )), previousRenderStartTime > debugTask && (endTime ? endTime.run(
12256          console.timeStamp.bind(
12257            console,
12258            "Action",
12259            debugTask,
12260            previousRenderStartTime,
12261            currentTrack,
12262            LANES_TRACK_GROUP,
12263            "primary-dark"
12264          )
12265        ) : console.timeStamp(
12266          "Action",
12267          debugTask,
12268          previousRenderStartTime,
12269          currentTrack,
12270          LANES_TRACK_GROUP,
12271          "primary-dark"
12272        )), color > previousRenderStartTime && (debugTask = eventIsRepeat ? "Promise Resolved" : 5 < color - previousRenderStartTime ? "Update Blocked" : "Update", isPingedUpdate = [], null != isSpawnedUpdate && isPingedUpdate.push(["Component name", isSpawnedUpdate]), null != label && isPingedUpdate.push(["Method name", label]), previousRenderStartTime = {
12273          start: previousRenderStartTime,
12274          end: color,
12275          detail: {
12276            devtools: {
12277              properties: isPingedUpdate,
12278              track: currentTrack,
12279              trackGroup: LANES_TRACK_GROUP,
12280              color: "primary-light"
12281            }
12282          }
12283        }, endTime ? endTime.run(
12284          performance.measure.bind(
12285            performance,
12286            debugTask,
12287            previousRenderStartTime
12288          )
12289        ) : performance.measure(debugTask, previousRenderStartTime))), transitionUpdateTime = transitionStartTime = -1.1, transitionUpdateType = 0, transitionSuspendedTime = -1.1, transitionEventRepeatTime = transitionEventTime, transitionEventTime = -1.1, transitionClampTime = now());
12290        0 !== (lanes & 62914560) && 0 !== (animatingLanes & 62914560) && (setCurrentTrackFromLanes(4194304), logAnimatingPhase(retryClampTime, renderStartTime, animatingTask));
12291        0 !== (lanes & 2080374784) && 0 !== (animatingLanes & 2080374784) && (setCurrentTrackFromLanes(268435456), logAnimatingPhase(idleClampTime, renderStartTime, animatingTask));
12292        previousRenderStartTime = root2.timeoutHandle;
12293        previousRenderStartTime !== noTimeout && (root2.timeoutHandle = noTimeout, cancelTimeout(previousRenderStartTime));
12294        previousRenderStartTime = root2.cancelPendingCommit;
12295        null !== previousRenderStartTime && (root2.cancelPendingCommit = null, previousRenderStartTime());
12296        pendingEffectsLanes = 0;
12297        resetWorkInProgressStack();
12298        workInProgressRoot = root2;
12299        workInProgress = previousRenderStartTime = createWorkInProgress(
12300          root2.current,
12301          null
12302        );
12303        workInProgressRootRenderLanes = lanes;
12304        workInProgressSuspendedReason = NotSuspended;
12305        workInProgressThrownValue = null;
12306        workInProgressRootDidSkipSuspendedSiblings = false;
12307        workInProgressRootIsPrerendering = checkIfRootIsPrerendering(root2, lanes);
12308        workInProgressRootDidAttachPingListener = false;
12309        workInProgressRootExitStatus = RootInProgress;
12310        workInProgressSuspendedRetryLanes = workInProgressDeferredLane = workInProgressRootPingedLanes = workInProgressRootInterleavedUpdatedLanes = workInProgressRootSkippedLanes = 0;
12311        workInProgressRootRecoverableErrors = workInProgressRootConcurrentErrors = null;
12312        workInProgressRootDidIncludeRecursiveRenderUpdate = false;
12313        0 !== (lanes & 8) && (lanes |= lanes & 32);
12314        endTime = root2.entangledLanes;
12315        if (0 !== endTime)
12316          for (root2 = root2.entanglements, endTime &= lanes; 0 < endTime; )
12317            debugTask = 31 - clz32(endTime), color = 1 << debugTask, lanes |= root2[debugTask], endTime &= ~color;
12318        entangledRenderLanes = lanes;
12319        finishQueueingConcurrentUpdates();
12320        root2 = getCurrentTime();
12321        1e3 < root2 - lastResetTime && (ReactSharedInternals.recentlyCreatedOwnerStacks = 0, lastResetTime = root2);
12322        ReactStrictModeWarnings.discardPendingWarnings();
12323        return previousRenderStartTime;
12324      }
12325      function handleThrow(root2, thrownValue) {
12326        currentlyRenderingFiber = null;
12327        ReactSharedInternals.H = ContextOnlyDispatcher;
12328        ReactSharedInternals.getCurrentStack = null;
12329        isRendering = false;
12330        current = null;
12331        thrownValue === SuspenseException || thrownValue === SuspenseActionException ? (thrownValue = getSuspendedThenable(), workInProgressSuspendedReason = SuspendedOnImmediate) : thrownValue === SuspenseyCommitException ? (thrownValue = getSuspendedThenable(), workInProgressSuspendedReason = SuspendedOnInstance) : workInProgressSuspendedReason = thrownValue === SelectiveHydrationException ? SuspendedOnHydration : null !== thrownValue && "object" === typeof thrownValue && "function" === typeof thrownValue.then ? SuspendedOnDeprecatedThrowPromise : SuspendedOnError;
12332        workInProgressThrownValue = thrownValue;
12333        var erroredWork = workInProgress;
12334        null === erroredWork ? (workInProgressRootExitStatus = RootFatalErrored, logUncaughtError(
12335          root2,
12336          createCapturedValueAtFiber(thrownValue, root2.current)
12337        )) : erroredWork.mode & ProfileMode && stopProfilerTimerIfRunningAndRecordDuration(erroredWork);
12338      }
12339      function shouldRemainOnPreviousScreen() {
12340        var handler = suspenseHandlerStackCursor.current;
12341        return null === handler ? true : (workInProgressRootRenderLanes & 4194048) === workInProgressRootRenderLanes ? null === shellBoundary ? true : false : (workInProgressRootRenderLanes & 62914560) === workInProgressRootRenderLanes || 0 !== (workInProgressRootRenderLanes & 536870912) ? handler === shellBoundary : false;
12342      }
12343      function pushDispatcher() {
12344        var prevDispatcher = ReactSharedInternals.H;
12345        ReactSharedInternals.H = ContextOnlyDispatcher;
12346        return null === prevDispatcher ? ContextOnlyDispatcher : prevDispatcher;
12347      }
12348      function pushAsyncDispatcher() {
12349        var prevAsyncDispatcher = ReactSharedInternals.A;
12350        ReactSharedInternals.A = DefaultAsyncDispatcher;
12351        return prevAsyncDispatcher;
12352      }
12353      function markRenderDerivedCause(fiber) {
12354        null === workInProgressUpdateTask && (workInProgressUpdateTask = null == fiber._debugTask ? null : fiber._debugTask);
12355      }
12356      function renderDidSuspendDelayIfPossible() {
12357        workInProgressRootExitStatus = RootSuspendedWithDelay;
12358        workInProgressRootDidSkipSuspendedSiblings || (workInProgressRootRenderLanes & 4194048) !== workInProgressRootRenderLanes && null !== suspenseHandlerStackCursor.current || (workInProgressRootIsPrerendering = true);
12359        0 === (workInProgressRootSkippedLanes & 134217727) && 0 === (workInProgressRootInterleavedUpdatedLanes & 134217727) || null === workInProgressRoot || markRootSuspended(
12360          workInProgressRoot,
12361          workInProgressRootRenderLanes,
12362          workInProgressDeferredLane,
12363          false
12364        );
12365      }
12366      function renderRootSync(root2, lanes, shouldYieldForPrerendering) {
12367        var prevExecutionContext = executionContext;
12368        executionContext |= RenderContext;
12369        var prevDispatcher = pushDispatcher(), prevAsyncDispatcher = pushAsyncDispatcher();
12370        if (workInProgressRoot !== root2 || workInProgressRootRenderLanes !== lanes) {
12371          if (isDevToolsPresent) {
12372            var memoizedUpdaters = root2.memoizedUpdaters;
12373            0 < memoizedUpdaters.size && (restorePendingUpdaters(root2, workInProgressRootRenderLanes), memoizedUpdaters.clear());
12374            movePendingFibersToMemoized(root2, lanes);
12375          }
12376          workInProgressTransitions = null;
12377          prepareFreshStack(root2, lanes);
12378        }
12379        lanes = false;
12380        memoizedUpdaters = workInProgressRootExitStatus;
12381        a: do
12382          try {
12383            if (workInProgressSuspendedReason !== NotSuspended && null !== workInProgress) {
12384              var unitOfWork = workInProgress, thrownValue = workInProgressThrownValue;
12385              switch (workInProgressSuspendedReason) {
12386                case SuspendedOnHydration:
12387                  resetWorkInProgressStack();
12388                  memoizedUpdaters = RootSuspendedAtTheShell;
12389                  break a;
12390                case SuspendedOnImmediate:
12391                case SuspendedOnData:
12392                case SuspendedOnAction:
12393                case SuspendedOnDeprecatedThrowPromise:
12394                  null === suspenseHandlerStackCursor.current && (lanes = true);
12395                  var reason = workInProgressSuspendedReason;
12396                  workInProgressSuspendedReason = NotSuspended;
12397                  workInProgressThrownValue = null;
12398                  throwAndUnwindWorkLoop(root2, unitOfWork, thrownValue, reason);
12399                  if (shouldYieldForPrerendering && workInProgressRootIsPrerendering) {
12400                    memoizedUpdaters = RootInProgress;
12401                    break a;
12402                  }
12403                  break;
12404                default:
12405                  reason = workInProgressSuspendedReason, workInProgressSuspendedReason = NotSuspended, workInProgressThrownValue = null, throwAndUnwindWorkLoop(root2, unitOfWork, thrownValue, reason);
12406              }
12407            }
12408            workLoopSync();
12409            memoizedUpdaters = workInProgressRootExitStatus;
12410            break;
12411          } catch (thrownValue$8) {
12412            handleThrow(root2, thrownValue$8);
12413          }
12414        while (1);
12415        lanes && root2.shellSuspendCounter++;
12416        resetContextDependencies();
12417        executionContext = prevExecutionContext;
12418        ReactSharedInternals.H = prevDispatcher;
12419        ReactSharedInternals.A = prevAsyncDispatcher;
12420        null === workInProgress && (workInProgressRoot = null, workInProgressRootRenderLanes = 0, finishQueueingConcurrentUpdates());
12421        return memoizedUpdaters;
12422      }
12423      function workLoopSync() {
12424        for (; null !== workInProgress; ) performUnitOfWork(workInProgress);
12425      }
12426      function renderRootConcurrent(root2, lanes) {
12427        var prevExecutionContext = executionContext;
12428        executionContext |= RenderContext;
12429        var prevDispatcher = pushDispatcher(), prevAsyncDispatcher = pushAsyncDispatcher();
12430        if (workInProgressRoot !== root2 || workInProgressRootRenderLanes !== lanes) {
12431          if (isDevToolsPresent) {
12432            var memoizedUpdaters = root2.memoizedUpdaters;
12433            0 < memoizedUpdaters.size && (restorePendingUpdaters(root2, workInProgressRootRenderLanes), memoizedUpdaters.clear());
12434            movePendingFibersToMemoized(root2, lanes);
12435          }
12436          workInProgressTransitions = null;
12437          workInProgressRootRenderTargetTime = now$1() + RENDER_TIMEOUT_MS;
12438          prepareFreshStack(root2, lanes);
12439        } else
12440          workInProgressRootIsPrerendering = checkIfRootIsPrerendering(
12441            root2,
12442            lanes
12443          );
12444        a: do
12445          try {
12446            if (workInProgressSuspendedReason !== NotSuspended && null !== workInProgress)
12447              b: switch (lanes = workInProgress, memoizedUpdaters = workInProgressThrownValue, workInProgressSuspendedReason) {
12448                case SuspendedOnError:
12449                  workInProgressSuspendedReason = NotSuspended;
12450                  workInProgressThrownValue = null;
12451                  throwAndUnwindWorkLoop(
12452                    root2,
12453                    lanes,
12454                    memoizedUpdaters,
12455                    SuspendedOnError
12456                  );
12457                  break;
12458                case SuspendedOnData:
12459                case SuspendedOnAction:
12460                  if (isThenableResolved(memoizedUpdaters)) {
12461                    workInProgressSuspendedReason = NotSuspended;
12462                    workInProgressThrownValue = null;
12463                    replaySuspendedUnitOfWork(lanes);
12464                    break;
12465                  }
12466                  lanes = function() {
12467                    workInProgressSuspendedReason !== SuspendedOnData && workInProgressSuspendedReason !== SuspendedOnAction || workInProgressRoot !== root2 || (workInProgressSuspendedReason = SuspendedAndReadyToContinue);
12468                    ensureRootIsScheduled(root2);
12469                  };
12470                  memoizedUpdaters.then(lanes, lanes);
12471                  break a;
12472                case SuspendedOnImmediate:
12473                  workInProgressSuspendedReason = SuspendedAndReadyToContinue;
12474                  break a;
12475                case SuspendedOnInstance:
12476                  workInProgressSuspendedReason = SuspendedOnInstanceAndReadyToContinue;
12477                  break a;
12478                case SuspendedAndReadyToContinue:
12479                  isThenableResolved(memoizedUpdaters) ? (workInProgressSuspendedReason = NotSuspended, workInProgressThrownValue = null, replaySuspendedUnitOfWork(lanes)) : (workInProgressSuspendedReason = NotSuspended, workInProgressThrownValue = null, throwAndUnwindWorkLoop(
12480                    root2,
12481                    lanes,
12482                    memoizedUpdaters,
12483                    SuspendedAndReadyToContinue
12484                  ));
12485                  break;
12486                case SuspendedOnInstanceAndReadyToContinue:
12487                  var resource = null;
12488                  switch (workInProgress.tag) {
12489                    case 26:
12490                      resource = workInProgress.memoizedState;
12491                    case 5:
12492                    case 27:
12493                      var hostFiber = workInProgress;
12494                      if (resource ? preloadResource(resource) : hostFiber.stateNode.complete) {
12495                        workInProgressSuspendedReason = NotSuspended;
12496                        workInProgressThrownValue = null;
12497                        var sibling = hostFiber.sibling;
12498                        if (null !== sibling) workInProgress = sibling;
12499                        else {
12500                          var returnFiber = hostFiber.return;
12501                          null !== returnFiber ? (workInProgress = returnFiber, completeUnitOfWork(returnFiber)) : workInProgress = null;
12502                        }
12503                        break b;
12504                      }
12505                      break;
12506                    default:
12507                      console.error(
12508                        "Unexpected type of fiber triggered a suspensey commit. This is a bug in React."
12509                      );
12510                  }
12511                  workInProgressSuspendedReason = NotSuspended;
12512                  workInProgressThrownValue = null;
12513                  throwAndUnwindWorkLoop(
12514                    root2,
12515                    lanes,
12516                    memoizedUpdaters,
12517                    SuspendedOnInstanceAndReadyToContinue
12518                  );
12519                  break;
12520                case SuspendedOnDeprecatedThrowPromise:
12521                  workInProgressSuspendedReason = NotSuspended;
12522                  workInProgressThrownValue = null;
12523                  throwAndUnwindWorkLoop(
12524                    root2,
12525                    lanes,
12526                    memoizedUpdaters,
12527                    SuspendedOnDeprecatedThrowPromise
12528                  );
12529                  break;
12530                case SuspendedOnHydration:
12531                  resetWorkInProgressStack();
12532                  workInProgressRootExitStatus = RootSuspendedAtTheShell;
12533                  break a;
12534                default:
12535                  throw Error(
12536                    "Unexpected SuspendedReason. This is a bug in React."
12537                  );
12538              }
12539            null !== ReactSharedInternals.actQueue ? workLoopSync() : workLoopConcurrentByScheduler();
12540            break;
12541          } catch (thrownValue$9) {
12542            handleThrow(root2, thrownValue$9);
12543          }
12544        while (1);
12545        resetContextDependencies();
12546        ReactSharedInternals.H = prevDispatcher;
12547        ReactSharedInternals.A = prevAsyncDispatcher;
12548        executionContext = prevExecutionContext;
12549        if (null !== workInProgress) return RootInProgress;
12550        workInProgressRoot = null;
12551        workInProgressRootRenderLanes = 0;
12552        finishQueueingConcurrentUpdates();
12553        return workInProgressRootExitStatus;
12554      }
12555      function workLoopConcurrentByScheduler() {
12556        for (; null !== workInProgress && !shouldYield(); )
12557          performUnitOfWork(workInProgress);
12558      }
12559      function performUnitOfWork(unitOfWork) {
12560        var current2 = unitOfWork.alternate;
12561        (unitOfWork.mode & ProfileMode) !== NoMode ? (startProfilerTimer(unitOfWork), current2 = runWithFiberInDEV(
12562          unitOfWork,
12563          beginWork,
12564          current2,
12565          unitOfWork,
12566          entangledRenderLanes
12567        ), stopProfilerTimerIfRunningAndRecordDuration(unitOfWork)) : current2 = runWithFiberInDEV(
12568          unitOfWork,
12569          beginWork,
12570          current2,
12571          unitOfWork,
12572          entangledRenderLanes
12573        );
12574        unitOfWork.memoizedProps = unitOfWork.pendingProps;
12575        null === current2 ? completeUnitOfWork(unitOfWork) : workInProgress = current2;
12576      }
12577      function replaySuspendedUnitOfWork(unitOfWork) {
12578        var next = runWithFiberInDEV(unitOfWork, replayBeginWork, unitOfWork);
12579        unitOfWork.memoizedProps = unitOfWork.pendingProps;
12580        null === next ? completeUnitOfWork(unitOfWork) : workInProgress = next;
12581      }
12582      function replayBeginWork(unitOfWork) {
12583        var current2 = unitOfWork.alternate, isProfilingMode = (unitOfWork.mode & ProfileMode) !== NoMode;
12584        isProfilingMode && startProfilerTimer(unitOfWork);
12585        switch (unitOfWork.tag) {
12586          case 15:
12587          case 0:
12588            current2 = replayFunctionComponent(
12589              current2,
12590              unitOfWork,
12591              unitOfWork.pendingProps,
12592              unitOfWork.type,
12593              void 0,
12594              workInProgressRootRenderLanes
12595            );
12596            break;
12597          case 11:
12598            current2 = replayFunctionComponent(
12599              current2,
12600              unitOfWork,
12601              unitOfWork.pendingProps,
12602              unitOfWork.type.render,
12603              unitOfWork.ref,
12604              workInProgressRootRenderLanes
12605            );
12606            break;
12607          case 5:
12608            resetHooksOnUnwind(unitOfWork);
12609          default:
12610            unwindInterruptedWork(current2, unitOfWork), unitOfWork = workInProgress = resetWorkInProgress(unitOfWork, entangledRenderLanes), current2 = beginWork(current2, unitOfWork, entangledRenderLanes);
12611        }
12612        isProfilingMode && stopProfilerTimerIfRunningAndRecordDuration(unitOfWork);
12613        return current2;
12614      }
12615      function throwAndUnwindWorkLoop(root2, unitOfWork, thrownValue, suspendedReason) {
12616        resetContextDependencies();
12617        resetHooksOnUnwind(unitOfWork);
12618        thenableState$1 = null;
12619        thenableIndexCounter$1 = 0;
12620        var returnFiber = unitOfWork.return;
12621        try {
12622          if (throwException(
12623            root2,
12624            returnFiber,
12625            unitOfWork,
12626            thrownValue,
12627            workInProgressRootRenderLanes
12628          )) {
12629            workInProgressRootExitStatus = RootFatalErrored;
12630            logUncaughtError(
12631              root2,
12632              createCapturedValueAtFiber(thrownValue, root2.current)
12633            );
12634            workInProgress = null;
12635            return;
12636          }
12637        } catch (error) {
12638          if (null !== returnFiber) throw workInProgress = returnFiber, error;
12639          workInProgressRootExitStatus = RootFatalErrored;
12640          logUncaughtError(
12641            root2,
12642            createCapturedValueAtFiber(thrownValue, root2.current)
12643          );
12644          workInProgress = null;
12645          return;
12646        }
12647        if (unitOfWork.flags & 32768) {
12648          if (isHydrating || suspendedReason === SuspendedOnError) root2 = true;
12649          else if (workInProgressRootIsPrerendering || 0 !== (workInProgressRootRenderLanes & 536870912))
12650            root2 = false;
12651          else if (workInProgressRootDidSkipSuspendedSiblings = root2 = true, suspendedReason === SuspendedOnData || suspendedReason === SuspendedOnAction || suspendedReason === SuspendedOnImmediate || suspendedReason === SuspendedOnDeprecatedThrowPromise)
12652            suspendedReason = suspenseHandlerStackCursor.current, null !== suspendedReason && 13 === suspendedReason.tag && (suspendedReason.flags |= 16384);
12653          unwindUnitOfWork(unitOfWork, root2);
12654        } else completeUnitOfWork(unitOfWork);
12655      }
12656      function completeUnitOfWork(unitOfWork) {
12657        var completedWork = unitOfWork;
12658        do {
12659          if (0 !== (completedWork.flags & 32768)) {
12660            unwindUnitOfWork(
12661              completedWork,
12662              workInProgressRootDidSkipSuspendedSiblings
12663            );
12664            return;
12665          }
12666          var current2 = completedWork.alternate;
12667          unitOfWork = completedWork.return;
12668          startProfilerTimer(completedWork);
12669          current2 = runWithFiberInDEV(
12670            completedWork,
12671            completeWork,
12672            current2,
12673            completedWork,
12674            entangledRenderLanes
12675          );
12676          (completedWork.mode & ProfileMode) !== NoMode && stopProfilerTimerIfRunningAndRecordIncompleteDuration(completedWork);
12677          if (null !== current2) {
12678            workInProgress = current2;
12679            return;
12680          }
12681          completedWork = completedWork.sibling;
12682          if (null !== completedWork) {
12683            workInProgress = completedWork;
12684            return;
12685          }
12686          workInProgress = completedWork = unitOfWork;
12687        } while (null !== completedWork);
12688        workInProgressRootExitStatus === RootInProgress && (workInProgressRootExitStatus = RootCompleted);
12689      }
12690      function unwindUnitOfWork(unitOfWork, skipSiblings) {
12691        do {
12692          var next = unwindWork(unitOfWork.alternate, unitOfWork);
12693          if (null !== next) {
12694            next.flags &= 32767;
12695            workInProgress = next;
12696            return;
12697          }
12698          if ((unitOfWork.mode & ProfileMode) !== NoMode) {
12699            stopProfilerTimerIfRunningAndRecordIncompleteDuration(unitOfWork);
12700            next = unitOfWork.actualDuration;
12701            for (var child = unitOfWork.child; null !== child; )
12702              next += child.actualDuration, child = child.sibling;
12703            unitOfWork.actualDuration = next;
12704          }
12705          next = unitOfWork.return;
12706          null !== next && (next.flags |= 32768, next.subtreeFlags = 0, next.deletions = null);
12707          if (!skipSiblings && (unitOfWork = unitOfWork.sibling, null !== unitOfWork)) {
12708            workInProgress = unitOfWork;
12709            return;
12710          }
12711          workInProgress = unitOfWork = next;
12712        } while (null !== unitOfWork);
12713        workInProgressRootExitStatus = RootSuspendedAtTheShell;
12714        workInProgress = null;
12715      }
12716      function commitRoot(root2, finishedWork, lanes, recoverableErrors, transitions, didIncludeRenderPhaseUpdate, spawnedLane, updatedLanes, suspendedRetryLanes, exitStatus, suspendedState, suspendedCommitReason, completedRenderStartTime, completedRenderEndTime) {
12717        root2.cancelPendingCommit = null;
12718        do
12719          flushPendingEffects();
12720        while (pendingEffectsStatus !== NO_PENDING_EFFECTS);
12721        ReactStrictModeWarnings.flushLegacyContextWarning();
12722        ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings();
12723        if ((executionContext & (RenderContext | CommitContext)) !== NoContext)
12724          throw Error("Should not already be working.");
12725        setCurrentTrackFromLanes(lanes);
12726        exitStatus === RootErrored ? logErroredRenderPhase(
12727          completedRenderStartTime,
12728          completedRenderEndTime,
12729          lanes,
12730          workInProgressUpdateTask
12731        ) : null !== recoverableErrors ? logRecoveredRenderPhase(
12732          completedRenderStartTime,
12733          completedRenderEndTime,
12734          lanes,
12735          recoverableErrors,
12736          null !== finishedWork && null !== finishedWork.alternate && finishedWork.alternate.memoizedState.isDehydrated && 0 !== (finishedWork.flags & 256),
12737          workInProgressUpdateTask
12738        ) : logRenderPhase(
12739          completedRenderStartTime,
12740          completedRenderEndTime,
12741          lanes,
12742          workInProgressUpdateTask
12743        );
12744        if (null !== finishedWork) {
12745          0 === lanes && console.error(
12746            "finishedLanes should not be empty during a commit. This is a bug in React."
12747          );
12748          if (finishedWork === root2.current)
12749            throw Error(
12750              "Cannot commit the same tree as before. This error is likely caused by a bug in React. Please file an issue."
12751            );
12752          didIncludeRenderPhaseUpdate = finishedWork.lanes | finishedWork.childLanes;
12753          didIncludeRenderPhaseUpdate |= concurrentlyUpdatedLanes;
12754          markRootFinished(
12755            root2,
12756            lanes,
12757            didIncludeRenderPhaseUpdate,
12758            spawnedLane,
12759            updatedLanes,
12760            suspendedRetryLanes
12761          );
12762          root2 === workInProgressRoot && (workInProgress = workInProgressRoot = null, workInProgressRootRenderLanes = 0);
12763          pendingFinishedWork = finishedWork;
12764          pendingEffectsRoot = root2;
12765          pendingEffectsLanes = lanes;
12766          pendingEffectsRemainingLanes = didIncludeRenderPhaseUpdate;
12767          pendingPassiveTransitions = transitions;
12768          pendingRecoverableErrors = recoverableErrors;
12769          pendingEffectsRenderEndTime = completedRenderEndTime;
12770          pendingSuspendedCommitReason = suspendedCommitReason;
12771          pendingDelayedCommitReason = IMMEDIATE_COMMIT;
12772          pendingSuspendedViewTransitionReason = null;
12773          0 !== finishedWork.actualDuration || 0 !== (finishedWork.subtreeFlags & 10256) || 0 !== (finishedWork.flags & 10256) ? (root2.callbackNode = null, root2.callbackPriority = 0, scheduleCallback$1(NormalPriority$1, function() {
12774            schedulerEvent = window.event;
12775            pendingDelayedCommitReason === IMMEDIATE_COMMIT && (pendingDelayedCommitReason = DELAYED_PASSIVE_COMMIT);
12776            flushPassiveEffects();
12777            return null;
12778          })) : (root2.callbackNode = null, root2.callbackPriority = 0);
12779          commitErrors = null;
12780          commitStartTime = now();
12781          null !== suspendedCommitReason && logSuspendedCommitPhase(
12782            completedRenderEndTime,
12783            commitStartTime,
12784            suspendedCommitReason,
12785            workInProgressUpdateTask
12786          );
12787          recoverableErrors = 0 !== (finishedWork.flags & 13878);
12788          if (0 !== (finishedWork.subtreeFlags & 13878) || recoverableErrors) {
12789            recoverableErrors = ReactSharedInternals.T;
12790            ReactSharedInternals.T = null;
12791            transitions = ReactDOMSharedInternals.p;
12792            ReactDOMSharedInternals.p = DiscreteEventPriority;
12793            spawnedLane = executionContext;
12794            executionContext |= CommitContext;
12795            try {
12796              commitBeforeMutationEffects(root2, finishedWork, lanes);
12797            } finally {
12798              executionContext = spawnedLane, ReactDOMSharedInternals.p = transitions, ReactSharedInternals.T = recoverableErrors;
12799            }
12800          }
12801          pendingEffectsStatus = PENDING_MUTATION_PHASE;
12802          flushMutationEffects();
12803          flushLayoutEffects();
12804          flushSpawnedWork();
12805        }
12806      }
12807      function flushMutationEffects() {
12808        if (pendingEffectsStatus === PENDING_MUTATION_PHASE) {
12809          pendingEffectsStatus = NO_PENDING_EFFECTS;
12810          var root2 = pendingEffectsRoot, finishedWork = pendingFinishedWork, lanes = pendingEffectsLanes, rootMutationHasEffect = 0 !== (finishedWork.flags & 13878);
12811          if (0 !== (finishedWork.subtreeFlags & 13878) || rootMutationHasEffect) {
12812            rootMutationHasEffect = ReactSharedInternals.T;
12813            ReactSharedInternals.T = null;
12814            var previousPriority = ReactDOMSharedInternals.p;
12815            ReactDOMSharedInternals.p = DiscreteEventPriority;
12816            var prevExecutionContext = executionContext;
12817            executionContext |= CommitContext;
12818            try {
12819              inProgressLanes = lanes;
12820              inProgressRoot = root2;
12821              resetComponentEffectTimers();
12822              commitMutationEffectsOnFiber(finishedWork, root2);
12823              inProgressRoot = inProgressLanes = null;
12824              lanes = selectionInformation;
12825              var curFocusedElem = getActiveElementDeep(root2.containerInfo), priorFocusedElem = lanes.focusedElem, priorSelectionRange = lanes.selectionRange;
12826              if (curFocusedElem !== priorFocusedElem && priorFocusedElem && priorFocusedElem.ownerDocument && containsNode(
12827                priorFocusedElem.ownerDocument.documentElement,
12828                priorFocusedElem
12829              )) {
12830                if (null !== priorSelectionRange && hasSelectionCapabilities(priorFocusedElem)) {
12831                  var start = priorSelectionRange.start, end = priorSelectionRange.end;
12832                  void 0 === end && (end = start);
12833                  if ("selectionStart" in priorFocusedElem)
12834                    priorFocusedElem.selectionStart = start, priorFocusedElem.selectionEnd = Math.min(
12835                      end,
12836                      priorFocusedElem.value.length
12837                    );
12838                  else {
12839                    var doc = priorFocusedElem.ownerDocument || document, win = doc && doc.defaultView || window;
12840                    if (win.getSelection) {
12841                      var selection = win.getSelection(), length = priorFocusedElem.textContent.length, start$jscomp$0 = Math.min(
12842                        priorSelectionRange.start,
12843                        length
12844                      ), end$jscomp$0 = void 0 === priorSelectionRange.end ? start$jscomp$0 : Math.min(priorSelectionRange.end, length);
12845                      !selection.extend && start$jscomp$0 > end$jscomp$0 && (curFocusedElem = end$jscomp$0, end$jscomp$0 = start$jscomp$0, start$jscomp$0 = curFocusedElem);
12846                      var startMarker = getNodeForCharacterOffset(
12847                        priorFocusedElem,
12848                        start$jscomp$0
12849                      ), endMarker = getNodeForCharacterOffset(
12850                        priorFocusedElem,
12851                        end$jscomp$0
12852                      );
12853                      if (startMarker && endMarker && (1 !== selection.rangeCount || selection.anchorNode !== startMarker.node || selection.anchorOffset !== startMarker.offset || selection.focusNode !== endMarker.node || selection.focusOffset !== endMarker.offset)) {
12854                        var range = doc.createRange();
12855                        range.setStart(startMarker.node, startMarker.offset);
12856                        selection.removeAllRanges();
12857                        start$jscomp$0 > end$jscomp$0 ? (selection.addRange(range), selection.extend(endMarker.node, endMarker.offset)) : (range.setEnd(endMarker.node, endMarker.offset), selection.addRange(range));
12858                      }
12859                    }
12860                  }
12861                }
12862                doc = [];
12863                for (selection = priorFocusedElem; selection = selection.parentNode; )
12864                  1 === selection.nodeType && doc.push({
12865                    element: selection,
12866                    left: selection.scrollLeft,
12867                    top: selection.scrollTop
12868                  });
12869                "function" === typeof priorFocusedElem.focus && priorFocusedElem.focus();
12870                for (priorFocusedElem = 0; priorFocusedElem < doc.length; priorFocusedElem++) {
12871                  var info = doc[priorFocusedElem];
12872                  info.element.scrollLeft = info.left;
12873                  info.element.scrollTop = info.top;
12874                }
12875              }
12876              _enabled = !!eventsEnabled;
12877              selectionInformation = eventsEnabled = null;
12878            } finally {
12879              executionContext = prevExecutionContext, ReactDOMSharedInternals.p = previousPriority, ReactSharedInternals.T = rootMutationHasEffect;
12880            }
12881          }
12882          root2.current = finishedWork;
12883          pendingEffectsStatus = PENDING_LAYOUT_PHASE;
12884        }
12885      }
12886      function flushLayoutEffects() {
12887        if (pendingEffectsStatus === PENDING_LAYOUT_PHASE) {
12888          pendingEffectsStatus = NO_PENDING_EFFECTS;
12889          var suspendedViewTransitionReason = pendingSuspendedViewTransitionReason;
12890          if (null !== suspendedViewTransitionReason) {
12891            commitStartTime = now();
12892            var startTime = commitEndTime, endTime = commitStartTime;
12893            !supportsUserTiming || endTime <= startTime || (animatingTask ? animatingTask.run(
12894              console.timeStamp.bind(
12895                console,
12896                suspendedViewTransitionReason,
12897                startTime,
12898                endTime,
12899                currentTrack,
12900                LANES_TRACK_GROUP,
12901                "secondary-light"
12902              )
12903            ) : console.timeStamp(
12904              suspendedViewTransitionReason,
12905              startTime,
12906              endTime,
12907              currentTrack,
12908              LANES_TRACK_GROUP,
12909              "secondary-light"
12910            ));
12911          }
12912          suspendedViewTransitionReason = pendingEffectsRoot;
12913          startTime = pendingFinishedWork;
12914          endTime = pendingEffectsLanes;
12915          var rootHasLayoutEffect = 0 !== (startTime.flags & 8772);
12916          if (0 !== (startTime.subtreeFlags & 8772) || rootHasLayoutEffect) {
12917            rootHasLayoutEffect = ReactSharedInternals.T;
12918            ReactSharedInternals.T = null;
12919            var _previousPriority = ReactDOMSharedInternals.p;
12920            ReactDOMSharedInternals.p = DiscreteEventPriority;
12921            var _prevExecutionContext = executionContext;
12922            executionContext |= CommitContext;
12923            try {
12924              inProgressLanes = endTime, inProgressRoot = suspendedViewTransitionReason, resetComponentEffectTimers(), commitLayoutEffectOnFiber(
12925                suspendedViewTransitionReason,
12926                startTime.alternate,
12927                startTime
12928              ), inProgressRoot = inProgressLanes = null;
12929            } finally {
12930              executionContext = _prevExecutionContext, ReactDOMSharedInternals.p = _previousPriority, ReactSharedInternals.T = rootHasLayoutEffect;
12931            }
12932          }
12933          suspendedViewTransitionReason = pendingEffectsRenderEndTime;
12934          startTime = pendingSuspendedCommitReason;
12935          commitEndTime = now();
12936          suspendedViewTransitionReason = null === startTime ? suspendedViewTransitionReason : commitStartTime;
12937          startTime = commitEndTime;
12938          endTime = pendingDelayedCommitReason === ABORTED_VIEW_TRANSITION_COMMIT;
12939          rootHasLayoutEffect = workInProgressUpdateTask;
12940          null !== commitErrors ? logCommitErrored(
12941            suspendedViewTransitionReason,
12942            startTime,
12943            commitErrors,
12944            false,
12945            rootHasLayoutEffect
12946          ) : !supportsUserTiming || startTime <= suspendedViewTransitionReason || (rootHasLayoutEffect ? rootHasLayoutEffect.run(
12947            console.timeStamp.bind(
12948              console,
12949              endTime ? "Commit Interrupted View Transition" : "Commit",
12950              suspendedViewTransitionReason,
12951              startTime,
12952              currentTrack,
12953              LANES_TRACK_GROUP,
12954              endTime ? "error" : "secondary-dark"
12955            )
12956          ) : console.timeStamp(
12957            endTime ? "Commit Interrupted View Transition" : "Commit",
12958            suspendedViewTransitionReason,
12959            startTime,
12960            currentTrack,
12961            LANES_TRACK_GROUP,
12962            endTime ? "error" : "secondary-dark"
12963          ));
12964          pendingEffectsStatus = PENDING_AFTER_MUTATION_PHASE;
12965        }
12966      }
12967      function flushSpawnedWork() {
12968        if (pendingEffectsStatus === PENDING_SPAWNED_WORK || pendingEffectsStatus === PENDING_AFTER_MUTATION_PHASE) {
12969          if (pendingEffectsStatus === PENDING_SPAWNED_WORK) {
12970            var startViewTransitionStartTime = commitEndTime;
12971            commitEndTime = now();
12972            var endTime = commitEndTime, abortedViewTransition = pendingDelayedCommitReason === ABORTED_VIEW_TRANSITION_COMMIT;
12973            !supportsUserTiming || endTime <= startViewTransitionStartTime || (animatingTask ? animatingTask.run(
12974              console.timeStamp.bind(
12975                console,
12976                abortedViewTransition ? "Interrupted View Transition" : "Starting Animation",
12977                startViewTransitionStartTime,
12978                endTime,
12979                currentTrack,
12980                LANES_TRACK_GROUP,
12981                abortedViewTransition ? "error" : "secondary-light"
12982              )
12983            ) : console.timeStamp(
12984              abortedViewTransition ? "Interrupted View Transition" : "Starting Animation",
12985              startViewTransitionStartTime,
12986              endTime,
12987              currentTrack,
12988              LANES_TRACK_GROUP,
12989              abortedViewTransition ? " error" : "secondary-light"
12990            ));
12991            pendingDelayedCommitReason !== ABORTED_VIEW_TRANSITION_COMMIT && (pendingDelayedCommitReason = ANIMATION_STARTED_COMMIT);
12992          }
12993          pendingEffectsStatus = NO_PENDING_EFFECTS;
12994          requestPaint();
12995          startViewTransitionStartTime = pendingEffectsRoot;
12996          var finishedWork = pendingFinishedWork;
12997          endTime = pendingEffectsLanes;
12998          abortedViewTransition = pendingRecoverableErrors;
12999          var rootDidHavePassiveEffects = 0 !== finishedWork.actualDuration || 0 !== (finishedWork.subtreeFlags & 10256) || 0 !== (finishedWork.flags & 10256);
13000          rootDidHavePassiveEffects ? pendingEffectsStatus = PENDING_PASSIVE_PHASE : (pendingEffectsStatus = NO_PENDING_EFFECTS, pendingFinishedWork = pendingEffectsRoot = null, releaseRootPooledCache(
13001            startViewTransitionStartTime,
13002            startViewTransitionStartTime.pendingLanes
13003          ), nestedPassiveUpdateCount = 0, rootWithPassiveNestedUpdates = null);
13004          var remainingLanes = startViewTransitionStartTime.pendingLanes;
13005          0 === remainingLanes && (legacyErrorBoundariesThatAlreadyFailed = null);
13006          rootDidHavePassiveEffects || commitDoubleInvokeEffectsInDEV(startViewTransitionStartTime);
13007          remainingLanes = lanesToEventPriority(endTime);
13008          finishedWork = finishedWork.stateNode;
13009          if (injectedHook && "function" === typeof injectedHook.onCommitFiberRoot)
13010            try {
13011              var didError = 128 === (finishedWork.current.flags & 128);
13012              switch (remainingLanes) {
13013                case DiscreteEventPriority:
13014                  var schedulerPriority = ImmediatePriority;
13015                  break;
13016                case ContinuousEventPriority:
13017                  schedulerPriority = UserBlockingPriority;
13018                  break;
13019                case DefaultEventPriority:
13020                  schedulerPriority = NormalPriority$1;
13021                  break;
13022                case IdleEventPriority:
13023                  schedulerPriority = IdlePriority;
13024                  break;
13025                default:
13026                  schedulerPriority = NormalPriority$1;
13027              }
13028              injectedHook.onCommitFiberRoot(
13029                rendererID,
13030                finishedWork,
13031                schedulerPriority,
13032                didError
13033              );
13034            } catch (err) {
13035              hasLoggedError || (hasLoggedError = true, console.error(
13036                "React instrumentation encountered an error: %o",
13037                err
13038              ));
13039            }
13040          isDevToolsPresent && startViewTransitionStartTime.memoizedUpdaters.clear();
13041          onCommitRoot();
13042          if (null !== abortedViewTransition) {
13043            didError = ReactSharedInternals.T;
13044            schedulerPriority = ReactDOMSharedInternals.p;
13045            ReactDOMSharedInternals.p = DiscreteEventPriority;
13046            ReactSharedInternals.T = null;
13047            try {
13048              var onRecoverableError = startViewTransitionStartTime.onRecoverableError;
13049              for (finishedWork = 0; finishedWork < abortedViewTransition.length; finishedWork++) {
13050                var recoverableError = abortedViewTransition[finishedWork], errorInfo = makeErrorInfo(recoverableError.stack);
13051                runWithFiberInDEV(
13052                  recoverableError.source,
13053                  onRecoverableError,
13054                  recoverableError.value,
13055                  errorInfo
13056                );
13057              }
13058            } finally {
13059              ReactSharedInternals.T = didError, ReactDOMSharedInternals.p = schedulerPriority;
13060            }
13061          }
13062          0 !== (pendingEffectsLanes & 3) && flushPendingEffects();
13063          ensureRootIsScheduled(startViewTransitionStartTime);
13064          remainingLanes = startViewTransitionStartTime.pendingLanes;
13065          0 !== (endTime & 261930) && 0 !== (remainingLanes & 42) ? (nestedUpdateScheduled = true, startViewTransitionStartTime === rootWithNestedUpdates ? nestedUpdateCount++ : (nestedUpdateCount = 0, rootWithNestedUpdates = startViewTransitionStartTime)) : nestedUpdateCount = 0;
13066          rootDidHavePassiveEffects || finalizeRender(endTime, commitEndTime);
13067          flushSyncWorkAcrossRoots_impl(0, false);
13068        }
13069      }
13070      function makeErrorInfo(componentStack) {
13071        componentStack = { componentStack };
13072        Object.defineProperty(componentStack, "digest", {
13073          get: function() {
13074            console.error(
13075              'You are accessing "digest" from the errorInfo object passed to onRecoverableError. This property is no longer provided as part of errorInfo but can be accessed as a property of the Error instance itself.'
13076            );
13077          }
13078        });
13079        return componentStack;
13080      }
13081      function releaseRootPooledCache(root2, remainingLanes) {
13082        0 === (root2.pooledCacheLanes &= remainingLanes) && (remainingLanes = root2.pooledCache, null != remainingLanes && (root2.pooledCache = null, releaseCache(remainingLanes)));
13083      }
13084      function flushPendingEffects() {
13085        flushMutationEffects();
13086        flushLayoutEffects();
13087        flushSpawnedWork();
13088        return flushPassiveEffects();
13089      }
13090      function flushPassiveEffects() {
13091        if (pendingEffectsStatus !== PENDING_PASSIVE_PHASE) return false;
13092        var root2 = pendingEffectsRoot, remainingLanes = pendingEffectsRemainingLanes;
13093        pendingEffectsRemainingLanes = 0;
13094        var renderPriority = lanesToEventPriority(pendingEffectsLanes), priority = 0 === DefaultEventPriority || DefaultEventPriority > renderPriority ? DefaultEventPriority : renderPriority;
13095        renderPriority = ReactSharedInternals.T;
13096        var previousPriority = ReactDOMSharedInternals.p;
13097        try {
13098          ReactDOMSharedInternals.p = priority;
13099          ReactSharedInternals.T = null;
13100          var transitions = pendingPassiveTransitions;
13101          pendingPassiveTransitions = null;
13102          priority = pendingEffectsRoot;
13103          var lanes = pendingEffectsLanes;
13104          pendingEffectsStatus = NO_PENDING_EFFECTS;
13105          pendingFinishedWork = pendingEffectsRoot = null;
13106          pendingEffectsLanes = 0;
13107          if ((executionContext & (RenderContext | CommitContext)) !== NoContext)
13108            throw Error("Cannot flush passive effects while already rendering.");
13109          setCurrentTrackFromLanes(lanes);
13110          isFlushingPassiveEffects = true;
13111          didScheduleUpdateDuringPassiveEffects = false;
13112          var passiveEffectStartTime = 0;
13113          commitErrors = null;
13114          passiveEffectStartTime = now$1();
13115          if (pendingDelayedCommitReason === ANIMATION_STARTED_COMMIT)
13116            logAnimatingPhase(
13117              commitEndTime,
13118              passiveEffectStartTime,
13119              animatingTask
13120            );
13121          else {
13122            var startTime = commitEndTime, endTime = passiveEffectStartTime, delayedUntilPaint = pendingDelayedCommitReason === DELAYED_PASSIVE_COMMIT;
13123            !supportsUserTiming || endTime <= startTime || (workInProgressUpdateTask ? workInProgressUpdateTask.run(
13124              console.timeStamp.bind(
13125                console,
13126                delayedUntilPaint ? "Waiting for Paint" : "Waiting",
13127                startTime,
13128                endTime,
13129                currentTrack,
13130                LANES_TRACK_GROUP,
13131                "secondary-light"
13132              )
13133            ) : console.timeStamp(
13134              delayedUntilPaint ? "Waiting for Paint" : "Waiting",
13135              startTime,
13136              endTime,
13137              currentTrack,
13138              LANES_TRACK_GROUP,
13139              "secondary-light"
13140            ));
13141          }
13142          startTime = executionContext;
13143          executionContext |= CommitContext;
13144          var finishedWork = priority.current;
13145          resetComponentEffectTimers();
13146          commitPassiveUnmountOnFiber(finishedWork);
13147          var finishedWork$jscomp$0 = priority.current;
13148          finishedWork = pendingEffectsRenderEndTime;
13149          resetComponentEffectTimers();
13150          commitPassiveMountOnFiber(
13151            priority,
13152            finishedWork$jscomp$0,
13153            lanes,
13154            transitions,
13155            finishedWork
13156          );
13157          commitDoubleInvokeEffectsInDEV(priority);
13158          executionContext = startTime;
13159          var passiveEffectsEndTime = now$1();
13160          finishedWork$jscomp$0 = passiveEffectStartTime;
13161          finishedWork = workInProgressUpdateTask;
13162          null !== commitErrors ? logCommitErrored(
13163            finishedWork$jscomp$0,
13164            passiveEffectsEndTime,
13165            commitErrors,
13166            true,
13167            finishedWork
13168          ) : !supportsUserTiming || passiveEffectsEndTime <= finishedWork$jscomp$0 || (finishedWork ? finishedWork.run(
13169            console.timeStamp.bind(
13170              console,
13171              "Remaining Effects",
13172              finishedWork$jscomp$0,
13173              passiveEffectsEndTime,
13174              currentTrack,
13175              LANES_TRACK_GROUP,
13176              "secondary-dark"
13177            )
13178          ) : console.timeStamp(
13179            "Remaining Effects",
13180            finishedWork$jscomp$0,
13181            passiveEffectsEndTime,
13182            currentTrack,
13183            LANES_TRACK_GROUP,
13184            "secondary-dark"
13185          ));
13186          finalizeRender(lanes, passiveEffectsEndTime);
13187          flushSyncWorkAcrossRoots_impl(0, false);
13188          didScheduleUpdateDuringPassiveEffects ? priority === rootWithPassiveNestedUpdates ? nestedPassiveUpdateCount++ : (nestedPassiveUpdateCount = 0, rootWithPassiveNestedUpdates = priority) : nestedPassiveUpdateCount = 0;
13189          didScheduleUpdateDuringPassiveEffects = isFlushingPassiveEffects = false;
13190          if (injectedHook && "function" === typeof injectedHook.onPostCommitFiberRoot)
13191            try {
13192              injectedHook.onPostCommitFiberRoot(rendererID, priority);
13193            } catch (err) {
13194              hasLoggedError || (hasLoggedError = true, console.error(
13195                "React instrumentation encountered an error: %o",
13196                err
13197              ));
13198            }
13199          var stateNode = priority.current.stateNode;
13200          stateNode.effectDuration = 0;
13201          stateNode.passiveEffectDuration = 0;
13202          return true;
13203        } finally {
13204          ReactDOMSharedInternals.p = previousPriority, ReactSharedInternals.T = renderPriority, releaseRootPooledCache(root2, remainingLanes);
13205        }
13206      }
13207      function captureCommitPhaseErrorOnRoot(rootFiber, sourceFiber, error) {
13208        sourceFiber = createCapturedValueAtFiber(error, sourceFiber);
13209        recordEffectError(sourceFiber);
13210        sourceFiber = createRootErrorUpdate(rootFiber.stateNode, sourceFiber, 2);
13211        rootFiber = enqueueUpdate(rootFiber, sourceFiber, 2);
13212        null !== rootFiber && (markRootUpdated$1(rootFiber, 2), ensureRootIsScheduled(rootFiber));
13213      }
13214      function captureCommitPhaseError(sourceFiber, nearestMountedAncestor, error) {
13215        isRunningInsertionEffect = false;
13216        if (3 === sourceFiber.tag)
13217          captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error);
13218        else {
13219          for (; null !== nearestMountedAncestor; ) {
13220            if (3 === nearestMountedAncestor.tag) {
13221              captureCommitPhaseErrorOnRoot(
13222                nearestMountedAncestor,
13223                sourceFiber,
13224                error
13225              );
13226              return;
13227            }
13228            if (1 === nearestMountedAncestor.tag) {
13229              var instance = nearestMountedAncestor.stateNode;
13230              if ("function" === typeof nearestMountedAncestor.type.getDerivedStateFromError || "function" === typeof instance.componentDidCatch && (null === legacyErrorBoundariesThatAlreadyFailed || !legacyErrorBoundariesThatAlreadyFailed.has(instance))) {
13231                sourceFiber = createCapturedValueAtFiber(error, sourceFiber);
13232                recordEffectError(sourceFiber);
13233                error = createClassErrorUpdate(2);
13234                instance = enqueueUpdate(nearestMountedAncestor, error, 2);
13235                null !== instance && (initializeClassErrorUpdate(
13236                  error,
13237                  instance,
13238                  nearestMountedAncestor,
13239                  sourceFiber
13240                ), markRootUpdated$1(instance, 2), ensureRootIsScheduled(instance));
13241                return;
13242              }
13243            }
13244            nearestMountedAncestor = nearestMountedAncestor.return;
13245          }
13246          console.error(
13247            "Internal React error: Attempted to capture a commit phase error inside a detached tree. This indicates a bug in React. Potential causes include deleting the same fiber more than once, committing an already-finished tree, or an inconsistent return pointer.\n\nError message:\n\n%s",
13248            error
13249          );
13250        }
13251      }
13252      function attachPingListener(root2, wakeable, lanes) {
13253        var pingCache = root2.pingCache;
13254        if (null === pingCache) {
13255          pingCache = root2.pingCache = new PossiblyWeakMap();
13256          var threadIDs = /* @__PURE__ */ new Set();
13257          pingCache.set(wakeable, threadIDs);
13258        } else
13259          threadIDs = pingCache.get(wakeable), void 0 === threadIDs && (threadIDs = /* @__PURE__ */ new Set(), pingCache.set(wakeable, threadIDs));
13260        threadIDs.has(lanes) || (workInProgressRootDidAttachPingListener = true, threadIDs.add(lanes), pingCache = pingSuspendedRoot.bind(null, root2, wakeable, lanes), isDevToolsPresent && restorePendingUpdaters(root2, lanes), wakeable.then(pingCache, pingCache));
13261      }
13262      function pingSuspendedRoot(root2, wakeable, pingedLanes) {
13263        var pingCache = root2.pingCache;
13264        null !== pingCache && pingCache.delete(wakeable);
13265        root2.pingedLanes |= root2.suspendedLanes & pingedLanes;
13266        root2.warmLanes &= ~pingedLanes;
13267        0 !== (pingedLanes & 127) ? 0 > blockingUpdateTime && (blockingClampTime = blockingUpdateTime = now(), blockingUpdateTask = createTask("Promise Resolved"), blockingUpdateType = PINGED_UPDATE) : 0 !== (pingedLanes & 4194048) && 0 > transitionUpdateTime && (transitionClampTime = transitionUpdateTime = now(), transitionUpdateTask = createTask("Promise Resolved"), transitionUpdateType = PINGED_UPDATE);
13268        isConcurrentActEnvironment() && null === ReactSharedInternals.actQueue && console.error(
13269          "A suspended resource finished loading inside a test, but the event was not wrapped in act(...).\n\nWhen testing, code that resolves suspended data should be wrapped into act(...):\n\nact(() => {\n  /* finish loading suspended data */\n});\n/* assert on the output */\n\nThis ensures that you're testing the behavior the user would see in the browser. Learn more at https://react.dev/link/wrap-tests-with-act"
13270        );
13271        workInProgressRoot === root2 && (workInProgressRootRenderLanes & pingedLanes) === pingedLanes && (workInProgressRootExitStatus === RootSuspendedWithDelay || workInProgressRootExitStatus === RootSuspended && (workInProgressRootRenderLanes & 62914560) === workInProgressRootRenderLanes && now$1() - globalMostRecentFallbackTime < FALLBACK_THROTTLE_MS ? (executionContext & RenderContext) === NoContext && prepareFreshStack(root2, 0) : workInProgressRootPingedLanes |= pingedLanes, workInProgressSuspendedRetryLanes === workInProgressRootRenderLanes && (workInProgressSuspendedRetryLanes = 0));
13272        ensureRootIsScheduled(root2);
13273      }
13274      function retryTimedOutBoundary(boundaryFiber, retryLane) {
13275        0 === retryLane && (retryLane = claimNextRetryLane());
13276        boundaryFiber = enqueueConcurrentRenderForLane(boundaryFiber, retryLane);
13277        null !== boundaryFiber && (markRootUpdated$1(boundaryFiber, retryLane), ensureRootIsScheduled(boundaryFiber));
13278      }
13279      function retryDehydratedSuspenseBoundary(boundaryFiber) {
13280        var suspenseState = boundaryFiber.memoizedState, retryLane = 0;
13281        null !== suspenseState && (retryLane = suspenseState.retryLane);
13282        retryTimedOutBoundary(boundaryFiber, retryLane);
13283      }
13284      function resolveRetryWakeable(boundaryFiber, wakeable) {
13285        var retryLane = 0;
13286        switch (boundaryFiber.tag) {
13287          case 31:
13288          case 13:
13289            var retryCache = boundaryFiber.stateNode;
13290            var suspenseState = boundaryFiber.memoizedState;
13291            null !== suspenseState && (retryLane = suspenseState.retryLane);
13292            break;
13293          case 19:
13294            retryCache = boundaryFiber.stateNode;
13295            break;
13296          case 22:
13297            retryCache = boundaryFiber.stateNode._retryCache;
13298            break;
13299          default:
13300            throw Error(
13301              "Pinged unknown suspense boundary type. This is probably a bug in React."
13302            );
13303        }
13304        null !== retryCache && retryCache.delete(wakeable);
13305        retryTimedOutBoundary(boundaryFiber, retryLane);
13306      }
13307      function recursivelyTraverseAndDoubleInvokeEffectsInDEV(root$jscomp$0, parentFiber, isInStrictMode) {
13308        if (0 !== (parentFiber.subtreeFlags & 67117056))
13309          for (parentFiber = parentFiber.child; null !== parentFiber; ) {
13310            var root2 = root$jscomp$0, fiber = parentFiber, isStrictModeFiber = fiber.type === REACT_STRICT_MODE_TYPE;
13311            isStrictModeFiber = isInStrictMode || isStrictModeFiber;
13312            22 !== fiber.tag ? fiber.flags & 67108864 ? isStrictModeFiber && runWithFiberInDEV(
13313              fiber,
13314              doubleInvokeEffectsOnFiber,
13315              root2,
13316              fiber
13317            ) : recursivelyTraverseAndDoubleInvokeEffectsInDEV(
13318              root2,
13319              fiber,
13320              isStrictModeFiber
13321            ) : null === fiber.memoizedState && (isStrictModeFiber && fiber.flags & 8192 ? runWithFiberInDEV(
13322              fiber,
13323              doubleInvokeEffectsOnFiber,
13324              root2,
13325              fiber
13326            ) : fiber.subtreeFlags & 67108864 && runWithFiberInDEV(
13327              fiber,
13328              recursivelyTraverseAndDoubleInvokeEffectsInDEV,
13329              root2,
13330              fiber,
13331              isStrictModeFiber
13332            ));
13333            parentFiber = parentFiber.sibling;
13334          }
13335      }
13336      function doubleInvokeEffectsOnFiber(root2, fiber) {
13337        setIsStrictModeForDevtools(true);
13338        try {
13339          disappearLayoutEffects(fiber), disconnectPassiveEffect(fiber), reappearLayoutEffects(root2, fiber.alternate, fiber, false), reconnectPassiveEffects(root2, fiber, 0, null, false, 0);
13340        } finally {
13341          setIsStrictModeForDevtools(false);
13342        }
13343      }
13344      function commitDoubleInvokeEffectsInDEV(root2) {
13345        var doubleInvokeEffects = true;
13346        root2.current.mode & (StrictLegacyMode | StrictEffectsMode) || (doubleInvokeEffects = false);
13347        recursivelyTraverseAndDoubleInvokeEffectsInDEV(
13348          root2,
13349          root2.current,
13350          doubleInvokeEffects
13351        );
13352      }
13353      function warnAboutUpdateOnNotYetMountedFiberInDEV(fiber) {
13354        if ((executionContext & RenderContext) === NoContext) {
13355          var tag = fiber.tag;
13356          if (3 === tag || 1 === tag || 0 === tag || 11 === tag || 14 === tag || 15 === tag) {
13357            tag = getComponentNameFromFiber(fiber) || "ReactComponent";
13358            if (null !== didWarnStateUpdateForNotYetMountedComponent) {
13359              if (didWarnStateUpdateForNotYetMountedComponent.has(tag)) return;
13360              didWarnStateUpdateForNotYetMountedComponent.add(tag);
13361            } else didWarnStateUpdateForNotYetMountedComponent = /* @__PURE__ */ new Set([tag]);
13362            runWithFiberInDEV(fiber, function() {
13363              console.error(
13364                "Can't perform a React state update on a component that hasn't mounted yet. This indicates that you have a side-effect in your render function that asynchronously tries to update the component. Move this work to useEffect instead."
13365              );
13366            });
13367          }
13368        }
13369      }
13370      function restorePendingUpdaters(root2, lanes) {
13371        isDevToolsPresent && root2.memoizedUpdaters.forEach(function(schedulingFiber) {
13372          addFiberToLanesMap(root2, schedulingFiber, lanes);
13373        });
13374      }
13375      function scheduleCallback$1(priorityLevel, callback) {
13376        var actQueue = ReactSharedInternals.actQueue;
13377        return null !== actQueue ? (actQueue.push(callback), fakeActCallbackNode$1) : scheduleCallback$3(priorityLevel, callback);
13378      }
13379      function warnIfUpdatesNotWrappedWithActDEV(fiber) {
13380        isConcurrentActEnvironment() && null === ReactSharedInternals.actQueue && runWithFiberInDEV(fiber, function() {
13381          console.error(
13382            "An update to %s inside a test was not wrapped in act(...).\n\nWhen testing, code that causes React state updates should be wrapped into act(...):\n\nact(() => {\n  /* fire events that update state */\n});\n/* assert on the output */\n\nThis ensures that you're testing the behavior the user would see in the browser. Learn more at https://react.dev/link/wrap-tests-with-act",
13383            getComponentNameFromFiber(fiber)
13384          );
13385        });
13386      }
13387      function ensureRootIsScheduled(root2) {
13388        root2 !== lastScheduledRoot && null === root2.next && (null === lastScheduledRoot ? firstScheduledRoot = lastScheduledRoot = root2 : lastScheduledRoot = lastScheduledRoot.next = root2);
13389        mightHavePendingSyncWork = true;
13390        null !== ReactSharedInternals.actQueue ? didScheduleMicrotask_act || (didScheduleMicrotask_act = true, scheduleImmediateRootScheduleTask()) : didScheduleMicrotask || (didScheduleMicrotask = true, scheduleImmediateRootScheduleTask());
13391      }
13392      function flushSyncWorkAcrossRoots_impl(syncTransitionLanes, onlyLegacy) {
13393        if (!isFlushingWork && mightHavePendingSyncWork) {
13394          isFlushingWork = true;
13395          do {
13396            var didPerformSomeWork = false;
13397            for (var root2 = firstScheduledRoot; null !== root2; ) {
13398              if (!onlyLegacy)
13399                if (0 !== syncTransitionLanes) {
13400                  var pendingLanes = root2.pendingLanes;
13401                  if (0 === pendingLanes) var nextLanes = 0;
13402                  else {
13403                    var suspendedLanes = root2.suspendedLanes, pingedLanes = root2.pingedLanes;
13404                    nextLanes = (1 << 31 - clz32(42 | syncTransitionLanes) + 1) - 1;
13405                    nextLanes &= pendingLanes & ~(suspendedLanes & ~pingedLanes);
13406                    nextLanes = nextLanes & 201326741 ? nextLanes & 201326741 | 1 : nextLanes ? nextLanes | 2 : 0;
13407                  }
13408                  0 !== nextLanes && (didPerformSomeWork = true, performSyncWorkOnRoot(root2, nextLanes));
13409                } else
13410                  nextLanes = workInProgressRootRenderLanes, nextLanes = getNextLanes(
13411                    root2,
13412                    root2 === workInProgressRoot ? nextLanes : 0,
13413                    null !== root2.cancelPendingCommit || root2.timeoutHandle !== noTimeout
13414                  ), 0 === (nextLanes & 3) || checkIfRootIsPrerendering(root2, nextLanes) || (didPerformSomeWork = true, performSyncWorkOnRoot(root2, nextLanes));
13415              root2 = root2.next;
13416            }
13417          } while (didPerformSomeWork);
13418          isFlushingWork = false;
13419        }
13420      }
13421      function processRootScheduleInImmediateTask() {
13422        schedulerEvent = window.event;
13423        processRootScheduleInMicrotask();
13424      }
13425      function processRootScheduleInMicrotask() {
13426        mightHavePendingSyncWork = didScheduleMicrotask_act = didScheduleMicrotask = false;
13427        var syncTransitionLanes = 0;
13428        0 !== currentEventTransitionLane && shouldAttemptEagerTransition() && (syncTransitionLanes = currentEventTransitionLane);
13429        for (var currentTime = now$1(), prev = null, root2 = firstScheduledRoot; null !== root2; ) {
13430          var next = root2.next, nextLanes = scheduleTaskForRootDuringMicrotask(root2, currentTime);
13431          if (0 === nextLanes)
13432            root2.next = null, null === prev ? firstScheduledRoot = next : prev.next = next, null === next && (lastScheduledRoot = prev);
13433          else if (prev = root2, 0 !== syncTransitionLanes || 0 !== (nextLanes & 3))
13434            mightHavePendingSyncWork = true;
13435          root2 = next;
13436        }
13437        pendingEffectsStatus !== NO_PENDING_EFFECTS && pendingEffectsStatus !== PENDING_PASSIVE_PHASE || flushSyncWorkAcrossRoots_impl(syncTransitionLanes, false);
13438        0 !== currentEventTransitionLane && (currentEventTransitionLane = 0);
13439      }
13440      function scheduleTaskForRootDuringMicrotask(root2, currentTime) {
13441        for (var suspendedLanes = root2.suspendedLanes, pingedLanes = root2.pingedLanes, expirationTimes = root2.expirationTimes, lanes = root2.pendingLanes & -62914561; 0 < lanes; ) {
13442          var index = 31 - clz32(lanes), lane = 1 << index, expirationTime = expirationTimes[index];
13443          if (-1 === expirationTime) {
13444            if (0 === (lane & suspendedLanes) || 0 !== (lane & pingedLanes))
13445              expirationTimes[index] = computeExpirationTime(lane, currentTime);
13446          } else expirationTime <= currentTime && (root2.expiredLanes |= lane);
13447          lanes &= ~lane;
13448        }
13449        currentTime = workInProgressRoot;
13450        suspendedLanes = workInProgressRootRenderLanes;
13451        suspendedLanes = getNextLanes(
13452          root2,
13453          root2 === currentTime ? suspendedLanes : 0,
13454          null !== root2.cancelPendingCommit || root2.timeoutHandle !== noTimeout
13455        );
13456        pingedLanes = root2.callbackNode;
13457        if (0 === suspendedLanes || root2 === currentTime && (workInProgressSuspendedReason === SuspendedOnData || workInProgressSuspendedReason === SuspendedOnAction) || null !== root2.cancelPendingCommit)
13458          return null !== pingedLanes && cancelCallback(pingedLanes), root2.callbackNode = null, root2.callbackPriority = 0;
13459        if (0 === (suspendedLanes & 3) || checkIfRootIsPrerendering(root2, suspendedLanes)) {
13460          currentTime = suspendedLanes & -suspendedLanes;
13461          if (currentTime !== root2.callbackPriority || null !== ReactSharedInternals.actQueue && pingedLanes !== fakeActCallbackNode)
13462            cancelCallback(pingedLanes);
13463          else return currentTime;
13464          switch (lanesToEventPriority(suspendedLanes)) {
13465            case DiscreteEventPriority:
13466            case ContinuousEventPriority:
13467              suspendedLanes = UserBlockingPriority;
13468              break;
13469            case DefaultEventPriority:
13470              suspendedLanes = NormalPriority$1;
13471              break;
13472            case IdleEventPriority:
13473              suspendedLanes = IdlePriority;
13474              break;
13475            default:
13476              suspendedLanes = NormalPriority$1;
13477          }
13478          pingedLanes = performWorkOnRootViaSchedulerTask.bind(null, root2);
13479          null !== ReactSharedInternals.actQueue ? (ReactSharedInternals.actQueue.push(pingedLanes), suspendedLanes = fakeActCallbackNode) : suspendedLanes = scheduleCallback$3(suspendedLanes, pingedLanes);
13480          root2.callbackPriority = currentTime;
13481          root2.callbackNode = suspendedLanes;
13482          return currentTime;
13483        }
13484        null !== pingedLanes && cancelCallback(pingedLanes);
13485        root2.callbackPriority = 2;
13486        root2.callbackNode = null;
13487        return 2;
13488      }
13489      function performWorkOnRootViaSchedulerTask(root2, didTimeout) {
13490        nestedUpdateScheduled = currentUpdateIsNested = false;
13491        schedulerEvent = window.event;
13492        if (pendingEffectsStatus !== NO_PENDING_EFFECTS && pendingEffectsStatus !== PENDING_PASSIVE_PHASE)
13493          return root2.callbackNode = null, root2.callbackPriority = 0, null;
13494        var originalCallbackNode = root2.callbackNode;
13495        pendingDelayedCommitReason === IMMEDIATE_COMMIT && (pendingDelayedCommitReason = DELAYED_PASSIVE_COMMIT);
13496        if (flushPendingEffects() && root2.callbackNode !== originalCallbackNode)
13497          return null;
13498        var workInProgressRootRenderLanes$jscomp$0 = workInProgressRootRenderLanes;
13499        workInProgressRootRenderLanes$jscomp$0 = getNextLanes(
13500          root2,
13501          root2 === workInProgressRoot ? workInProgressRootRenderLanes$jscomp$0 : 0,
13502          null !== root2.cancelPendingCommit || root2.timeoutHandle !== noTimeout
13503        );
13504        if (0 === workInProgressRootRenderLanes$jscomp$0) return null;
13505        performWorkOnRoot(
13506          root2,
13507          workInProgressRootRenderLanes$jscomp$0,
13508          didTimeout
13509        );
13510        scheduleTaskForRootDuringMicrotask(root2, now$1());
13511        return null != root2.callbackNode && root2.callbackNode === originalCallbackNode ? performWorkOnRootViaSchedulerTask.bind(null, root2) : null;
13512      }
13513      function performSyncWorkOnRoot(root2, lanes) {
13514        if (flushPendingEffects()) return null;
13515        currentUpdateIsNested = nestedUpdateScheduled;
13516        nestedUpdateScheduled = false;
13517        performWorkOnRoot(root2, lanes, true);
13518      }
13519      function cancelCallback(callbackNode) {
13520        callbackNode !== fakeActCallbackNode && null !== callbackNode && cancelCallback$1(callbackNode);
13521      }
13522      function scheduleImmediateRootScheduleTask() {
13523        null !== ReactSharedInternals.actQueue && ReactSharedInternals.actQueue.push(function() {
13524          processRootScheduleInMicrotask();
13525          return null;
13526        });
13527        scheduleMicrotask(function() {
13528          (executionContext & (RenderContext | CommitContext)) !== NoContext ? scheduleCallback$3(
13529            ImmediatePriority,
13530            processRootScheduleInImmediateTask
13531          ) : processRootScheduleInMicrotask();
13532        });
13533      }
13534      function requestTransitionLane() {
13535        if (0 === currentEventTransitionLane) {
13536          var actionScopeLane = currentEntangledLane;
13537          0 === actionScopeLane && (actionScopeLane = nextTransitionUpdateLane, nextTransitionUpdateLane <<= 1, 0 === (nextTransitionUpdateLane & 261888) && (nextTransitionUpdateLane = 256));
13538          currentEventTransitionLane = actionScopeLane;
13539        }
13540        return currentEventTransitionLane;
13541      }
13542      function coerceFormActionProp(actionProp) {
13543        if (null == actionProp || "symbol" === typeof actionProp || "boolean" === typeof actionProp)
13544          return null;
13545        if ("function" === typeof actionProp) return actionProp;
13546        checkAttributeStringCoercion(actionProp, "action");
13547        return sanitizeURL("" + actionProp);
13548      }
13549      function createFormDataWithSubmitter(form, submitter) {
13550        var temp = submitter.ownerDocument.createElement("input");
13551        temp.name = submitter.name;
13552        temp.value = submitter.value;
13553        form.id && temp.setAttribute("form", form.id);
13554        submitter.parentNode.insertBefore(temp, submitter);
13555        form = new FormData(form);
13556        temp.parentNode.removeChild(temp);
13557        return form;
13558      }
13559      function extractEvents$1(dispatchQueue, domEventName, maybeTargetInst, nativeEvent, nativeEventTarget) {
13560        if ("submit" === domEventName && maybeTargetInst && maybeTargetInst.stateNode === nativeEventTarget) {
13561          var action = coerceFormActionProp(
13562            (nativeEventTarget[internalPropsKey] || null).action
13563          ), submitter = nativeEvent.submitter;
13564          submitter && (domEventName = (domEventName = submitter[internalPropsKey] || null) ? coerceFormActionProp(domEventName.formAction) : submitter.getAttribute("formAction"), null !== domEventName && (action = domEventName, submitter = null));
13565          var event = new SyntheticEvent(
13566            "action",
13567            "action",
13568            null,
13569            nativeEvent,
13570            nativeEventTarget
13571          );
13572          dispatchQueue.push({
13573            event,
13574            listeners: [
13575              {
13576                instance: null,
13577                listener: function() {
13578                  if (nativeEvent.defaultPrevented) {
13579                    if (0 !== currentEventTransitionLane) {
13580                      var formData = submitter ? createFormDataWithSubmitter(
13581                        nativeEventTarget,
13582                        submitter
13583                      ) : new FormData(nativeEventTarget), pendingState = {
13584                        pending: true,
13585                        data: formData,
13586                        method: nativeEventTarget.method,
13587                        action
13588                      };
13589                      Object.freeze(pendingState);
13590                      startHostTransition(
13591                        maybeTargetInst,
13592                        pendingState,
13593                        null,
13594                        formData
13595                      );
13596                    }
13597                  } else
13598                    "function" === typeof action && (event.preventDefault(), formData = submitter ? createFormDataWithSubmitter(
13599                      nativeEventTarget,
13600                      submitter
13601                    ) : new FormData(nativeEventTarget), pendingState = {
13602                      pending: true,
13603                      data: formData,
13604                      method: nativeEventTarget.method,
13605                      action
13606                    }, Object.freeze(pendingState), startHostTransition(
13607                      maybeTargetInst,
13608                      pendingState,
13609                      action,
13610                      formData
13611                    ));
13612                },
13613                currentTarget: nativeEventTarget
13614              }
13615            ]
13616          });
13617        }
13618      }
13619      function executeDispatch(event, listener, currentTarget) {
13620        event.currentTarget = currentTarget;
13621        try {
13622          listener(event);
13623        } catch (error) {
13624          reportGlobalError(error);
13625        }
13626        event.currentTarget = null;
13627      }
13628      function processDispatchQueue(dispatchQueue, eventSystemFlags) {
13629        eventSystemFlags = 0 !== (eventSystemFlags & 4);
13630        for (var i = 0; i < dispatchQueue.length; i++) {
13631          var _dispatchQueue$i = dispatchQueue[i];
13632          a: {
13633            var previousInstance = void 0, event = _dispatchQueue$i.event;
13634            _dispatchQueue$i = _dispatchQueue$i.listeners;
13635            if (eventSystemFlags)
13636              for (var i$jscomp$0 = _dispatchQueue$i.length - 1; 0 <= i$jscomp$0; i$jscomp$0--) {
13637                var _dispatchListeners$i = _dispatchQueue$i[i$jscomp$0], instance = _dispatchListeners$i.instance, currentTarget = _dispatchListeners$i.currentTarget;
13638                _dispatchListeners$i = _dispatchListeners$i.listener;
13639                if (instance !== previousInstance && event.isPropagationStopped())
13640                  break a;
13641                null !== instance ? runWithFiberInDEV(
13642                  instance,
13643                  executeDispatch,
13644                  event,
13645                  _dispatchListeners$i,
13646                  currentTarget
13647                ) : executeDispatch(event, _dispatchListeners$i, currentTarget);
13648                previousInstance = instance;
13649              }
13650            else
13651              for (i$jscomp$0 = 0; i$jscomp$0 < _dispatchQueue$i.length; i$jscomp$0++) {
13652                _dispatchListeners$i = _dispatchQueue$i[i$jscomp$0];
13653                instance = _dispatchListeners$i.instance;
13654                currentTarget = _dispatchListeners$i.currentTarget;
13655                _dispatchListeners$i = _dispatchListeners$i.listener;
13656                if (instance !== previousInstance && event.isPropagationStopped())
13657                  break a;
13658                null !== instance ? runWithFiberInDEV(
13659                  instance,
13660                  executeDispatch,
13661                  event,
13662                  _dispatchListeners$i,
13663                  currentTarget
13664                ) : executeDispatch(event, _dispatchListeners$i, currentTarget);
13665                previousInstance = instance;
13666              }
13667          }
13668        }
13669      }
13670      function listenToNonDelegatedEvent(domEventName, targetElement) {
13671        nonDelegatedEvents.has(domEventName) || console.error(
13672          'Did not expect a listenToNonDelegatedEvent() call for "%s". This is a bug in React. Please file an issue.',
13673          domEventName
13674        );
13675        var listenerSet = targetElement[internalEventHandlersKey];
13676        void 0 === listenerSet && (listenerSet = targetElement[internalEventHandlersKey] = /* @__PURE__ */ new Set());
13677        var listenerSetKey = domEventName + "__bubble";
13678        listenerSet.has(listenerSetKey) || (addTrappedEventListener(targetElement, domEventName, 2, false), listenerSet.add(listenerSetKey));
13679      }
13680      function listenToNativeEvent(domEventName, isCapturePhaseListener, target) {
13681        nonDelegatedEvents.has(domEventName) && !isCapturePhaseListener && console.error(
13682          'Did not expect a listenToNativeEvent() call for "%s" in the bubble phase. This is a bug in React. Please file an issue.',
13683          domEventName
13684        );
13685        var eventSystemFlags = 0;
13686        isCapturePhaseListener && (eventSystemFlags |= 4);
13687        addTrappedEventListener(
13688          target,
13689          domEventName,
13690          eventSystemFlags,
13691          isCapturePhaseListener
13692        );
13693      }
13694      function listenToAllSupportedEvents(rootContainerElement) {
13695        if (!rootContainerElement[listeningMarker]) {
13696          rootContainerElement[listeningMarker] = true;
13697          allNativeEvents.forEach(function(domEventName) {
13698            "selectionchange" !== domEventName && (nonDelegatedEvents.has(domEventName) || listenToNativeEvent(domEventName, false, rootContainerElement), listenToNativeEvent(domEventName, true, rootContainerElement));
13699          });
13700          var ownerDocument = 9 === rootContainerElement.nodeType ? rootContainerElement : rootContainerElement.ownerDocument;
13701          null === ownerDocument || ownerDocument[listeningMarker] || (ownerDocument[listeningMarker] = true, listenToNativeEvent("selectionchange", false, ownerDocument));
13702        }
13703      }
13704      function addTrappedEventListener(targetContainer, domEventName, eventSystemFlags, isCapturePhaseListener) {
13705        switch (getEventPriority(domEventName)) {
13706          case DiscreteEventPriority:
13707            var listenerWrapper = dispatchDiscreteEvent;
13708            break;
13709          case ContinuousEventPriority:
13710            listenerWrapper = dispatchContinuousEvent;
13711            break;
13712          default:
13713            listenerWrapper = dispatchEvent;
13714        }
13715        eventSystemFlags = listenerWrapper.bind(
13716          null,
13717          domEventName,
13718          eventSystemFlags,
13719          targetContainer
13720        );
13721        listenerWrapper = void 0;
13722        !passiveBrowserEventsSupported || "touchstart" !== domEventName && "touchmove" !== domEventName && "wheel" !== domEventName || (listenerWrapper = true);
13723        isCapturePhaseListener ? void 0 !== listenerWrapper ? targetContainer.addEventListener(domEventName, eventSystemFlags, {
13724          capture: true,
13725          passive: listenerWrapper
13726        }) : targetContainer.addEventListener(domEventName, eventSystemFlags, true) : void 0 !== listenerWrapper ? targetContainer.addEventListener(domEventName, eventSystemFlags, {
13727          passive: listenerWrapper
13728        }) : targetContainer.addEventListener(
13729          domEventName,
13730          eventSystemFlags,
13731          false
13732        );
13733      }
13734      function dispatchEventForPluginEventSystem(domEventName, eventSystemFlags, nativeEvent, targetInst$jscomp$0, targetContainer) {
13735        var ancestorInst = targetInst$jscomp$0;
13736        if (0 === (eventSystemFlags & 1) && 0 === (eventSystemFlags & 2) && null !== targetInst$jscomp$0)
13737          a: for (; ; ) {
13738            if (null === targetInst$jscomp$0) return;
13739            var nodeTag = targetInst$jscomp$0.tag;
13740            if (3 === nodeTag || 4 === nodeTag) {
13741              var container = targetInst$jscomp$0.stateNode.containerInfo;
13742              if (container === targetContainer) break;
13743              if (4 === nodeTag)
13744                for (nodeTag = targetInst$jscomp$0.return; null !== nodeTag; ) {
13745                  var grandTag = nodeTag.tag;
13746                  if ((3 === grandTag || 4 === grandTag) && nodeTag.stateNode.containerInfo === targetContainer)
13747                    return;
13748                  nodeTag = nodeTag.return;
13749                }
13750              for (; null !== container; ) {
13751                nodeTag = getClosestInstanceFromNode(container);
13752                if (null === nodeTag) return;
13753                grandTag = nodeTag.tag;
13754                if (5 === grandTag || 6 === grandTag || 26 === grandTag || 27 === grandTag) {
13755                  targetInst$jscomp$0 = ancestorInst = nodeTag;
13756                  continue a;
13757                }
13758                container = container.parentNode;
13759              }
13760            }
13761            targetInst$jscomp$0 = targetInst$jscomp$0.return;
13762          }
13763        batchedUpdates$1(function() {
13764          var targetInst = ancestorInst, nativeEventTarget = getEventTarget(nativeEvent), dispatchQueue = [];
13765          a: {
13766            var reactName = topLevelEventsToReactNames.get(domEventName);
13767            if (void 0 !== reactName) {
13768              var SyntheticEventCtor = SyntheticEvent, reactEventType = domEventName;
13769              switch (domEventName) {
13770                case "keypress":
13771                  if (0 === getEventCharCode(nativeEvent)) break a;
13772                case "keydown":
13773                case "keyup":
13774                  SyntheticEventCtor = SyntheticKeyboardEvent;
13775                  break;
13776                case "focusin":
13777                  reactEventType = "focus";
13778                  SyntheticEventCtor = SyntheticFocusEvent;
13779                  break;
13780                case "focusout":
13781                  reactEventType = "blur";
13782                  SyntheticEventCtor = SyntheticFocusEvent;
13783                  break;
13784                case "beforeblur":
13785                case "afterblur":
13786                  SyntheticEventCtor = SyntheticFocusEvent;
13787                  break;
13788                case "click":
13789                  if (2 === nativeEvent.button) break a;
13790                case "auxclick":
13791                case "dblclick":
13792                case "mousedown":
13793                case "mousemove":
13794                case "mouseup":
13795                case "mouseout":
13796                case "mouseover":
13797                case "contextmenu":
13798                  SyntheticEventCtor = SyntheticMouseEvent;
13799                  break;
13800                case "drag":
13801                case "dragend":
13802                case "dragenter":
13803                case "dragexit":
13804                case "dragleave":
13805                case "dragover":
13806                case "dragstart":
13807                case "drop":
13808                  SyntheticEventCtor = SyntheticDragEvent;
13809                  break;
13810                case "touchcancel":
13811                case "touchend":
13812                case "touchmove":
13813                case "touchstart":
13814                  SyntheticEventCtor = SyntheticTouchEvent;
13815                  break;
13816                case ANIMATION_END:
13817                case ANIMATION_ITERATION:
13818                case ANIMATION_START:
13819                  SyntheticEventCtor = SyntheticAnimationEvent;
13820                  break;
13821                case TRANSITION_END:
13822                  SyntheticEventCtor = SyntheticTransitionEvent;
13823                  break;
13824                case "scroll":
13825                case "scrollend":
13826                  SyntheticEventCtor = SyntheticUIEvent;
13827                  break;
13828                case "wheel":
13829                  SyntheticEventCtor = SyntheticWheelEvent;
13830                  break;
13831                case "copy":
13832                case "cut":
13833                case "paste":
13834                  SyntheticEventCtor = SyntheticClipboardEvent;
13835                  break;
13836                case "gotpointercapture":
13837                case "lostpointercapture":
13838                case "pointercancel":
13839                case "pointerdown":
13840                case "pointermove":
13841                case "pointerout":
13842                case "pointerover":
13843                case "pointerup":
13844                  SyntheticEventCtor = SyntheticPointerEvent;
13845                  break;
13846                case "toggle":
13847                case "beforetoggle":
13848                  SyntheticEventCtor = SyntheticToggleEvent;
13849              }
13850              var inCapturePhase = 0 !== (eventSystemFlags & 4), accumulateTargetOnly = !inCapturePhase && ("scroll" === domEventName || "scrollend" === domEventName), reactEventName = inCapturePhase ? null !== reactName ? reactName + "Capture" : null : reactName;
13851              inCapturePhase = [];
13852              for (var instance = targetInst, lastHostComponent; null !== instance; ) {
13853                var _instance2 = instance;
13854                lastHostComponent = _instance2.stateNode;
13855                _instance2 = _instance2.tag;
13856                5 !== _instance2 && 26 !== _instance2 && 27 !== _instance2 || null === lastHostComponent || null === reactEventName || (_instance2 = getListener(instance, reactEventName), null != _instance2 && inCapturePhase.push(
13857                  createDispatchListener(
13858                    instance,
13859                    _instance2,
13860                    lastHostComponent
13861                  )
13862                ));
13863                if (accumulateTargetOnly) break;
13864                instance = instance.return;
13865              }
13866              0 < inCapturePhase.length && (reactName = new SyntheticEventCtor(
13867                reactName,
13868                reactEventType,
13869                null,
13870                nativeEvent,
13871                nativeEventTarget
13872              ), dispatchQueue.push({
13873                event: reactName,
13874                listeners: inCapturePhase
13875              }));
13876            }
13877          }
13878          if (0 === (eventSystemFlags & 7)) {
13879            a: {
13880              reactName = "mouseover" === domEventName || "pointerover" === domEventName;
13881              SyntheticEventCtor = "mouseout" === domEventName || "pointerout" === domEventName;
13882              if (reactName && nativeEvent !== currentReplayingEvent && (reactEventType = nativeEvent.relatedTarget || nativeEvent.fromElement) && (getClosestInstanceFromNode(reactEventType) || reactEventType[internalContainerInstanceKey]))
13883                break a;
13884              if (SyntheticEventCtor || reactName) {
13885                reactName = nativeEventTarget.window === nativeEventTarget ? nativeEventTarget : (reactName = nativeEventTarget.ownerDocument) ? reactName.defaultView || reactName.parentWindow : window;
13886                if (SyntheticEventCtor) {
13887                  if (reactEventType = nativeEvent.relatedTarget || nativeEvent.toElement, SyntheticEventCtor = targetInst, reactEventType = reactEventType ? getClosestInstanceFromNode(reactEventType) : null, null !== reactEventType && (accumulateTargetOnly = getNearestMountedFiber(reactEventType), inCapturePhase = reactEventType.tag, reactEventType !== accumulateTargetOnly || 5 !== inCapturePhase && 27 !== inCapturePhase && 6 !== inCapturePhase))
13888                    reactEventType = null;
13889                } else SyntheticEventCtor = null, reactEventType = targetInst;
13890                if (SyntheticEventCtor !== reactEventType) {
13891                  inCapturePhase = SyntheticMouseEvent;
13892                  _instance2 = "onMouseLeave";
13893                  reactEventName = "onMouseEnter";
13894                  instance = "mouse";
13895                  if ("pointerout" === domEventName || "pointerover" === domEventName)
13896                    inCapturePhase = SyntheticPointerEvent, _instance2 = "onPointerLeave", reactEventName = "onPointerEnter", instance = "pointer";
13897                  accumulateTargetOnly = null == SyntheticEventCtor ? reactName : getNodeFromInstance(SyntheticEventCtor);
13898                  lastHostComponent = null == reactEventType ? reactName : getNodeFromInstance(reactEventType);
13899                  reactName = new inCapturePhase(
13900                    _instance2,
13901                    instance + "leave",
13902                    SyntheticEventCtor,
13903                    nativeEvent,
13904                    nativeEventTarget
13905                  );
13906                  reactName.target = accumulateTargetOnly;
13907                  reactName.relatedTarget = lastHostComponent;
13908                  _instance2 = null;
13909                  getClosestInstanceFromNode(nativeEventTarget) === targetInst && (inCapturePhase = new inCapturePhase(
13910                    reactEventName,
13911                    instance + "enter",
13912                    reactEventType,
13913                    nativeEvent,
13914                    nativeEventTarget
13915                  ), inCapturePhase.target = lastHostComponent, inCapturePhase.relatedTarget = accumulateTargetOnly, _instance2 = inCapturePhase);
13916                  accumulateTargetOnly = _instance2;
13917                  if (SyntheticEventCtor && reactEventType)
13918                    b: {
13919                      inCapturePhase = getParent;
13920                      reactEventName = SyntheticEventCtor;
13921                      instance = reactEventType;
13922                      lastHostComponent = 0;
13923                      for (_instance2 = reactEventName; _instance2; _instance2 = inCapturePhase(_instance2))
13924                        lastHostComponent++;
13925                      _instance2 = 0;
13926                      for (var tempB = instance; tempB; tempB = inCapturePhase(tempB))
13927                        _instance2++;
13928                      for (; 0 < lastHostComponent - _instance2; )
13929                        reactEventName = inCapturePhase(reactEventName), lastHostComponent--;
13930                      for (; 0 < _instance2 - lastHostComponent; )
13931                        instance = inCapturePhase(instance), _instance2--;
13932                      for (; lastHostComponent--; ) {
13933                        if (reactEventName === instance || null !== instance && reactEventName === instance.alternate) {
13934                          inCapturePhase = reactEventName;
13935                          break b;
13936                        }
13937                        reactEventName = inCapturePhase(reactEventName);
13938                        instance = inCapturePhase(instance);
13939                      }
13940                      inCapturePhase = null;
13941                    }
13942                  else inCapturePhase = null;
13943                  null !== SyntheticEventCtor && accumulateEnterLeaveListenersForEvent(
13944                    dispatchQueue,
13945                    reactName,
13946                    SyntheticEventCtor,
13947                    inCapturePhase,
13948                    false
13949                  );
13950                  null !== reactEventType && null !== accumulateTargetOnly && accumulateEnterLeaveListenersForEvent(
13951                    dispatchQueue,
13952                    accumulateTargetOnly,
13953                    reactEventType,
13954                    inCapturePhase,
13955                    true
13956                  );
13957                }
13958              }
13959            }
13960            a: {
13961              reactName = targetInst ? getNodeFromInstance(targetInst) : window;
13962              SyntheticEventCtor = reactName.nodeName && reactName.nodeName.toLowerCase();
13963              if ("select" === SyntheticEventCtor || "input" === SyntheticEventCtor && "file" === reactName.type)
13964                var getTargetInstFunc = getTargetInstForChangeEvent;
13965              else if (isTextInputElement(reactName))
13966                if (isInputEventSupported)
13967                  getTargetInstFunc = getTargetInstForInputOrChangeEvent;
13968                else {
13969                  getTargetInstFunc = getTargetInstForInputEventPolyfill;
13970                  var handleEventFunc = handleEventsForInputEventPolyfill;
13971                }
13972              else
13973                SyntheticEventCtor = reactName.nodeName, !SyntheticEventCtor || "input" !== SyntheticEventCtor.toLowerCase() || "checkbox" !== reactName.type && "radio" !== reactName.type ? targetInst && isCustomElement(targetInst.elementType) && (getTargetInstFunc = getTargetInstForChangeEvent) : getTargetInstFunc = getTargetInstForClickEvent;
13974              if (getTargetInstFunc && (getTargetInstFunc = getTargetInstFunc(domEventName, targetInst))) {
13975                createAndAccumulateChangeEvent(
13976                  dispatchQueue,
13977                  getTargetInstFunc,
13978                  nativeEvent,
13979                  nativeEventTarget
13980                );
13981                break a;
13982              }
13983              handleEventFunc && handleEventFunc(domEventName, reactName, targetInst);
13984              "focusout" === domEventName && targetInst && "number" === reactName.type && null != targetInst.memoizedProps.value && setDefaultValue(reactName, "number", reactName.value);
13985            }
13986            handleEventFunc = targetInst ? getNodeFromInstance(targetInst) : window;
13987            switch (domEventName) {
13988              case "focusin":
13989                if (isTextInputElement(handleEventFunc) || "true" === handleEventFunc.contentEditable)
13990                  activeElement = handleEventFunc, activeElementInst = targetInst, lastSelection = null;
13991                break;
13992              case "focusout":
13993                lastSelection = activeElementInst = activeElement = null;
13994                break;
13995              case "mousedown":
13996                mouseDown = true;
13997                break;
13998              case "contextmenu":
13999              case "mouseup":
14000              case "dragend":
14001                mouseDown = false;
14002                constructSelectEvent(
14003                  dispatchQueue,
14004                  nativeEvent,
14005                  nativeEventTarget
14006                );
14007                break;
14008              case "selectionchange":
14009                if (skipSelectionChangeEvent) break;
14010              case "keydown":
14011              case "keyup":
14012                constructSelectEvent(
14013                  dispatchQueue,
14014                  nativeEvent,
14015                  nativeEventTarget
14016                );
14017            }
14018            var fallbackData;
14019            if (canUseCompositionEvent)
14020              b: {
14021                switch (domEventName) {
14022                  case "compositionstart":
14023                    var eventType = "onCompositionStart";
14024                    break b;
14025                  case "compositionend":
14026                    eventType = "onCompositionEnd";
14027                    break b;
14028                  case "compositionupdate":
14029                    eventType = "onCompositionUpdate";
14030                    break b;
14031                }
14032                eventType = void 0;
14033              }
14034            else
14035              isComposing ? isFallbackCompositionEnd(domEventName, nativeEvent) && (eventType = "onCompositionEnd") : "keydown" === domEventName && nativeEvent.keyCode === START_KEYCODE && (eventType = "onCompositionStart");
14036            eventType && (useFallbackCompositionData && "ko" !== nativeEvent.locale && (isComposing || "onCompositionStart" !== eventType ? "onCompositionEnd" === eventType && isComposing && (fallbackData = getData()) : (root = nativeEventTarget, startText = "value" in root ? root.value : root.textContent, isComposing = true)), handleEventFunc = accumulateTwoPhaseListeners(
14037              targetInst,
14038              eventType
14039            ), 0 < handleEventFunc.length && (eventType = new SyntheticCompositionEvent(
14040              eventType,
14041              domEventName,
14042              null,
14043              nativeEvent,
14044              nativeEventTarget
14045            ), dispatchQueue.push({
14046              event: eventType,
14047              listeners: handleEventFunc
14048            }), fallbackData ? eventType.data = fallbackData : (fallbackData = getDataFromCustomEvent(nativeEvent), null !== fallbackData && (eventType.data = fallbackData))));
14049            if (fallbackData = canUseTextInputEvent ? getNativeBeforeInputChars(domEventName, nativeEvent) : getFallbackBeforeInputChars(domEventName, nativeEvent))
14050              eventType = accumulateTwoPhaseListeners(
14051                targetInst,
14052                "onBeforeInput"
14053              ), 0 < eventType.length && (handleEventFunc = new SyntheticInputEvent(
14054                "onBeforeInput",
14055                "beforeinput",
14056                null,
14057                nativeEvent,
14058                nativeEventTarget
14059              ), dispatchQueue.push({
14060                event: handleEventFunc,
14061                listeners: eventType
14062              }), handleEventFunc.data = fallbackData);
14063            extractEvents$1(
14064              dispatchQueue,
14065              domEventName,
14066              targetInst,
14067              nativeEvent,
14068              nativeEventTarget
14069            );
14070          }
14071          processDispatchQueue(dispatchQueue, eventSystemFlags);
14072        });
14073      }
14074      function createDispatchListener(instance, listener, currentTarget) {
14075        return {
14076          instance,
14077          listener,
14078          currentTarget
14079        };
14080      }
14081      function accumulateTwoPhaseListeners(targetFiber, reactName) {
14082        for (var captureName = reactName + "Capture", listeners = []; null !== targetFiber; ) {
14083          var _instance3 = targetFiber, stateNode = _instance3.stateNode;
14084          _instance3 = _instance3.tag;
14085          5 !== _instance3 && 26 !== _instance3 && 27 !== _instance3 || null === stateNode || (_instance3 = getListener(targetFiber, captureName), null != _instance3 && listeners.unshift(
14086            createDispatchListener(targetFiber, _instance3, stateNode)
14087          ), _instance3 = getListener(targetFiber, reactName), null != _instance3 && listeners.push(
14088            createDispatchListener(targetFiber, _instance3, stateNode)
14089          ));
14090          if (3 === targetFiber.tag) return listeners;
14091          targetFiber = targetFiber.return;
14092        }
14093        return [];
14094      }
14095      function getParent(inst) {
14096        if (null === inst) return null;
14097        do
14098          inst = inst.return;
14099        while (inst && 5 !== inst.tag && 27 !== inst.tag);
14100        return inst ? inst : null;
14101      }
14102      function accumulateEnterLeaveListenersForEvent(dispatchQueue, event, target, common, inCapturePhase) {
14103        for (var registrationName = event._reactName, listeners = []; null !== target && target !== common; ) {
14104          var _instance4 = target, alternate = _instance4.alternate, stateNode = _instance4.stateNode;
14105          _instance4 = _instance4.tag;
14106          if (null !== alternate && alternate === common) break;
14107          5 !== _instance4 && 26 !== _instance4 && 27 !== _instance4 || null === stateNode || (alternate = stateNode, inCapturePhase ? (stateNode = getListener(target, registrationName), null != stateNode && listeners.unshift(
14108            createDispatchListener(target, stateNode, alternate)
14109          )) : inCapturePhase || (stateNode = getListener(target, registrationName), null != stateNode && listeners.push(
14110            createDispatchListener(target, stateNode, alternate)
14111          )));
14112          target = target.return;
14113        }
14114        0 !== listeners.length && dispatchQueue.push({ event, listeners });
14115      }
14116      function validatePropertiesInDevelopment(type, props) {
14117        validateProperties$2(type, props);
14118        "input" !== type && "textarea" !== type && "select" !== type || null == props || null !== props.value || didWarnValueNull || (didWarnValueNull = true, "select" === type && props.multiple ? console.error(
14119          "`value` prop on `%s` should not be null. Consider using an empty array when `multiple` is set to `true` to clear the component or `undefined` for uncontrolled components.",
14120          type
14121        ) : console.error(
14122          "`value` prop on `%s` should not be null. Consider using an empty string to clear the component or `undefined` for uncontrolled components.",
14123          type
14124        ));
14125        var eventRegistry = {
14126          registrationNameDependencies,
14127          possibleRegistrationNames
14128        };
14129        isCustomElement(type) || "string" === typeof props.is || warnUnknownProperties(type, props, eventRegistry);
14130        props.contentEditable && !props.suppressContentEditableWarning && null != props.children && console.error(
14131          "A component is `contentEditable` and contains `children` managed by React. It is now your responsibility to guarantee that none of those nodes are unexpectedly modified or duplicated. This is probably not intentional."
14132        );
14133      }
14134      function warnForPropDifference(propName, serverValue, clientValue, serverDifferences) {
14135        serverValue !== clientValue && (clientValue = normalizeMarkupForTextOrAttribute(clientValue), normalizeMarkupForTextOrAttribute(serverValue) !== clientValue && (serverDifferences[propName] = serverValue));
14136      }
14137      function warnForExtraAttributes(domElement, attributeNames, serverDifferences) {
14138        attributeNames.forEach(function(attributeName) {
14139          serverDifferences[getPropNameFromAttributeName(attributeName)] = "style" === attributeName ? getStylesObjectFromElement(domElement) : domElement.getAttribute(attributeName);
14140        });
14141      }
14142      function warnForInvalidEventListener(registrationName, listener) {
14143        false === listener ? console.error(
14144          "Expected `%s` listener to be a function, instead got `false`.\n\nIf you used to conditionally omit it with %s={condition && value}, pass %s={condition ? value : undefined} instead.",
14145          registrationName,
14146          registrationName,
14147          registrationName
14148        ) : console.error(
14149          "Expected `%s` listener to be a function, instead got a value of `%s` type.",
14150          registrationName,
14151          typeof listener
14152        );
14153      }
14154      function normalizeHTML(parent, html) {
14155        parent = parent.namespaceURI === MATH_NAMESPACE || parent.namespaceURI === SVG_NAMESPACE ? parent.ownerDocument.createElementNS(
14156          parent.namespaceURI,
14157          parent.tagName
14158        ) : parent.ownerDocument.createElement(parent.tagName);
14159        parent.innerHTML = html;
14160        return parent.innerHTML;
14161      }
14162      function normalizeMarkupForTextOrAttribute(markup) {
14163        willCoercionThrow(markup) && (console.error(
14164          "The provided HTML markup uses a value of unsupported type %s. This value must be coerced to a string before using it here.",
14165          typeName(markup)
14166        ), testStringCoercion(markup));
14167        return ("string" === typeof markup ? markup : "" + markup).replace(NORMALIZE_NEWLINES_REGEX, "\n").replace(NORMALIZE_NULL_AND_REPLACEMENT_REGEX, "");
14168      }
14169      function checkForUnmatchedText(serverText, clientText) {
14170        clientText = normalizeMarkupForTextOrAttribute(clientText);
14171        return normalizeMarkupForTextOrAttribute(serverText) === clientText ? true : false;
14172      }
14173      function setProp(domElement, tag, key, value, props, prevValue) {
14174        switch (key) {
14175          case "children":
14176            if ("string" === typeof value)
14177              validateTextNesting(value, tag, false), "body" === tag || "textarea" === tag && "" === value || setTextContent(domElement, value);
14178            else if ("number" === typeof value || "bigint" === typeof value)
14179              validateTextNesting("" + value, tag, false), "body" !== tag && setTextContent(domElement, "" + value);
14180            break;
14181          case "className":
14182            setValueForKnownAttribute(domElement, "class", value);
14183            break;
14184          case "tabIndex":
14185            setValueForKnownAttribute(domElement, "tabindex", value);
14186            break;
14187          case "dir":
14188          case "role":
14189          case "viewBox":
14190          case "width":
14191          case "height":
14192            setValueForKnownAttribute(domElement, key, value);
14193            break;
14194          case "style":
14195            setValueForStyles(domElement, value, prevValue);
14196            break;
14197          case "data":
14198            if ("object" !== tag) {
14199              setValueForKnownAttribute(domElement, "data", value);
14200              break;
14201            }
14202          case "src":
14203          case "href":
14204            if ("" === value && ("a" !== tag || "href" !== key)) {
14205              "src" === key ? console.error(
14206                'An empty string ("") was passed to the %s attribute. This may cause the browser to download the whole page again over the network. To fix this, either do not render the element at all or pass null to %s instead of an empty string.',
14207                key,
14208                key
14209              ) : console.error(
14210                'An empty string ("") was passed to the %s attribute. To fix this, either do not render the element at all or pass null to %s instead of an empty string.',
14211                key,
14212                key
14213              );
14214              domElement.removeAttribute(key);
14215              break;
14216            }
14217            if (null == value || "function" === typeof value || "symbol" === typeof value || "boolean" === typeof value) {
14218              domElement.removeAttribute(key);
14219              break;
14220            }
14221            checkAttributeStringCoercion(value, key);
14222            value = sanitizeURL("" + value);
14223            domElement.setAttribute(key, value);
14224            break;
14225          case "action":
14226          case "formAction":
14227            null != value && ("form" === tag ? "formAction" === key ? console.error(
14228              "You can only pass the formAction prop to <input> or <button>. Use the action prop on <form>."
14229            ) : "function" === typeof value && (null == props.encType && null == props.method || didWarnFormActionMethod || (didWarnFormActionMethod = true, console.error(
14230              "Cannot specify a encType or method for a form that specifies a function as the action. React provides those automatically. They will get overridden."
14231            )), null == props.target || didWarnFormActionTarget || (didWarnFormActionTarget = true, console.error(
14232              "Cannot specify a target for a form that specifies a function as the action. The function will always be executed in the same window."
14233            ))) : "input" === tag || "button" === tag ? "action" === key ? console.error(
14234              "You can only pass the action prop to <form>. Use the formAction prop on <input> or <button>."
14235            ) : "input" !== tag || "submit" === props.type || "image" === props.type || didWarnFormActionType ? "button" !== tag || null == props.type || "submit" === props.type || didWarnFormActionType ? "function" === typeof value && (null == props.name || didWarnFormActionName || (didWarnFormActionName = true, console.error(
14236              'Cannot specify a "name" prop for a button that specifies a function as a formAction. React needs it to encode which action should be invoked. It will get overridden.'
14237            )), null == props.formEncType && null == props.formMethod || didWarnFormActionMethod || (didWarnFormActionMethod = true, console.error(
14238              "Cannot specify a formEncType or formMethod for a button that specifies a function as a formAction. React provides those automatically. They will get overridden."
14239            )), null == props.formTarget || didWarnFormActionTarget || (didWarnFormActionTarget = true, console.error(
14240              "Cannot specify a formTarget for a button that specifies a function as a formAction. The function will always be executed in the same window."
14241            ))) : (didWarnFormActionType = true, console.error(
14242              'A button can only specify a formAction along with type="submit" or no type.'
14243            )) : (didWarnFormActionType = true, console.error(
14244              'An input can only specify a formAction along with type="submit" or type="image".'
14245            )) : "action" === key ? console.error(
14246              "You can only pass the action prop to <form>."
14247            ) : console.error(
14248              "You can only pass the formAction prop to <input> or <button>."
14249            ));
14250            if ("function" === typeof value) {
14251              domElement.setAttribute(
14252                key,
14253                "javascript:throw new Error('A React form was unexpectedly submitted. If you called form.submit() manually, consider using form.requestSubmit() instead. If you\\'re trying to use event.stopPropagation() in a submit event handler, consider also calling event.preventDefault().')"
14254              );
14255              break;
14256            } else
14257              "function" === typeof prevValue && ("formAction" === key ? ("input" !== tag && setProp(domElement, tag, "name", props.name, props, null), setProp(
14258                domElement,
14259                tag,
14260                "formEncType",
14261                props.formEncType,
14262                props,
14263                null
14264              ), setProp(
14265                domElement,
14266                tag,
14267                "formMethod",
14268                props.formMethod,
14269                props,
14270                null
14271              ), setProp(
14272                domElement,
14273                tag,
14274                "formTarget",
14275                props.formTarget,
14276                props,
14277                null
14278              )) : (setProp(
14279                domElement,
14280                tag,
14281                "encType",
14282                props.encType,
14283                props,
14284                null
14285              ), setProp(domElement, tag, "method", props.method, props, null), setProp(
14286                domElement,
14287                tag,
14288                "target",
14289                props.target,
14290                props,
14291                null
14292              )));
14293            if (null == value || "symbol" === typeof value || "boolean" === typeof value) {
14294              domElement.removeAttribute(key);
14295              break;
14296            }
14297            checkAttributeStringCoercion(value, key);
14298            value = sanitizeURL("" + value);
14299            domElement.setAttribute(key, value);
14300            break;
14301          case "onClick":
14302            null != value && ("function" !== typeof value && warnForInvalidEventListener(key, value), domElement.onclick = noop$1);
14303            break;
14304          case "onScroll":
14305            null != value && ("function" !== typeof value && warnForInvalidEventListener(key, value), listenToNonDelegatedEvent("scroll", domElement));
14306            break;
14307          case "onScrollEnd":
14308            null != value && ("function" !== typeof value && warnForInvalidEventListener(key, value), listenToNonDelegatedEvent("scrollend", domElement));
14309            break;
14310          case "dangerouslySetInnerHTML":
14311            if (null != value) {
14312              if ("object" !== typeof value || !("__html" in value))
14313                throw Error(
14314                  "`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. Please visit https://react.dev/link/dangerously-set-inner-html for more information."
14315                );
14316              key = value.__html;
14317              if (null != key) {
14318                if (null != props.children)
14319                  throw Error(
14320                    "Can only set one of `children` or `props.dangerouslySetInnerHTML`."
14321                  );
14322                domElement.innerHTML = key;
14323              }
14324            }
14325            break;
14326          case "multiple":
14327            domElement.multiple = value && "function" !== typeof value && "symbol" !== typeof value;
14328            break;
14329          case "muted":
14330            domElement.muted = value && "function" !== typeof value && "symbol" !== typeof value;
14331            break;
14332          case "suppressContentEditableWarning":
14333          case "suppressHydrationWarning":
14334          case "defaultValue":
14335          case "defaultChecked":
14336          case "innerHTML":
14337          case "ref":
14338            break;
14339          case "autoFocus":
14340            break;
14341          case "xlinkHref":
14342            if (null == value || "function" === typeof value || "boolean" === typeof value || "symbol" === typeof value) {
14343              domElement.removeAttribute("xlink:href");
14344              break;
14345            }
14346            checkAttributeStringCoercion(value, key);
14347            key = sanitizeURL("" + value);
14348            domElement.setAttributeNS(xlinkNamespace, "xlink:href", key);
14349            break;
14350          case "contentEditable":
14351          case "spellCheck":
14352          case "draggable":
14353          case "value":
14354          case "autoReverse":
14355          case "externalResourcesRequired":
14356          case "focusable":
14357          case "preserveAlpha":
14358            null != value && "function" !== typeof value && "symbol" !== typeof value ? (checkAttributeStringCoercion(value, key), domElement.setAttribute(key, "" + value)) : domElement.removeAttribute(key);
14359            break;
14360          case "inert":
14361            "" !== value || didWarnForNewBooleanPropsWithEmptyValue[key] || (didWarnForNewBooleanPropsWithEmptyValue[key] = true, console.error(
14362              "Received an empty string for a boolean attribute `%s`. This will treat the attribute as if it were false. Either pass `false` to silence this warning, or pass `true` if you used an empty string in earlier versions of React to indicate this attribute is true.",
14363              key
14364            ));
14365          case "allowFullScreen":
14366          case "async":
14367          case "autoPlay":
14368          case "controls":
14369          case "default":
14370          case "defer":
14371          case "disabled":
14372          case "disablePictureInPicture":
14373          case "disableRemotePlayback":
14374          case "formNoValidate":
14375          case "hidden":
14376          case "loop":
14377          case "noModule":
14378          case "noValidate":
14379          case "open":
14380          case "playsInline":
14381          case "readOnly":
14382          case "required":
14383          case "reversed":
14384          case "scoped":
14385          case "seamless":
14386          case "itemScope":
14387            value && "function" !== typeof value && "symbol" !== typeof value ? domElement.setAttribute(key, "") : domElement.removeAttribute(key);
14388            break;
14389          case "capture":
14390          case "download":
14391            true === value ? domElement.setAttribute(key, "") : false !== value && null != value && "function" !== typeof value && "symbol" !== typeof value ? (checkAttributeStringCoercion(value, key), domElement.setAttribute(key, value)) : domElement.removeAttribute(key);
14392            break;
14393          case "cols":
14394          case "rows":
14395          case "size":
14396          case "span":
14397            null != value && "function" !== typeof value && "symbol" !== typeof value && !isNaN(value) && 1 <= value ? (checkAttributeStringCoercion(value, key), domElement.setAttribute(key, value)) : domElement.removeAttribute(key);
14398            break;
14399          case "rowSpan":
14400          case "start":
14401            null == value || "function" === typeof value || "symbol" === typeof value || isNaN(value) ? domElement.removeAttribute(key) : (checkAttributeStringCoercion(value, key), domElement.setAttribute(key, value));
14402            break;
14403          case "popover":
14404            listenToNonDelegatedEvent("beforetoggle", domElement);
14405            listenToNonDelegatedEvent("toggle", domElement);
14406            setValueForAttribute(domElement, "popover", value);
14407            break;
14408          case "xlinkActuate":
14409            setValueForNamespacedAttribute(
14410              domElement,
14411              xlinkNamespace,
14412              "xlink:actuate",
14413              value
14414            );
14415            break;
14416          case "xlinkArcrole":
14417            setValueForNamespacedAttribute(
14418              domElement,
14419              xlinkNamespace,
14420              "xlink:arcrole",
14421              value
14422            );
14423            break;
14424          case "xlinkRole":
14425            setValueForNamespacedAttribute(
14426              domElement,
14427              xlinkNamespace,
14428              "xlink:role",
14429              value
14430            );
14431            break;
14432          case "xlinkShow":
14433            setValueForNamespacedAttribute(
14434              domElement,
14435              xlinkNamespace,
14436              "xlink:show",
14437              value
14438            );
14439            break;
14440          case "xlinkTitle":
14441            setValueForNamespacedAttribute(
14442              domElement,
14443              xlinkNamespace,
14444              "xlink:title",
14445              value
14446            );
14447            break;
14448          case "xlinkType":
14449            setValueForNamespacedAttribute(
14450              domElement,
14451              xlinkNamespace,
14452              "xlink:type",
14453              value
14454            );
14455            break;
14456          case "xmlBase":
14457            setValueForNamespacedAttribute(
14458              domElement,
14459              xmlNamespace,
14460              "xml:base",
14461              value
14462            );
14463            break;
14464          case "xmlLang":
14465            setValueForNamespacedAttribute(
14466              domElement,
14467              xmlNamespace,
14468              "xml:lang",
14469              value
14470            );
14471            break;
14472          case "xmlSpace":
14473            setValueForNamespacedAttribute(
14474              domElement,
14475              xmlNamespace,
14476              "xml:space",
14477              value
14478            );
14479            break;
14480          case "is":
14481            null != prevValue && console.error(
14482              'Cannot update the "is" prop after it has been initialized.'
14483            );
14484            setValueForAttribute(domElement, "is", value);
14485            break;
14486          case "innerText":
14487          case "textContent":
14488            break;
14489          case "popoverTarget":
14490            didWarnPopoverTargetObject || null == value || "object" !== typeof value || (didWarnPopoverTargetObject = true, console.error(
14491              "The `popoverTarget` prop expects the ID of an Element as a string. Received %s instead.",
14492              value
14493            ));
14494          default:
14495            !(2 < key.length) || "o" !== key[0] && "O" !== key[0] || "n" !== key[1] && "N" !== key[1] ? (key = getAttributeAlias(key), setValueForAttribute(domElement, key, value)) : registrationNameDependencies.hasOwnProperty(key) && null != value && "function" !== typeof value && warnForInvalidEventListener(key, value);
14496        }
14497      }
14498      function setPropOnCustomElement(domElement, tag, key, value, props, prevValue) {
14499        switch (key) {
14500          case "style":
14501            setValueForStyles(domElement, value, prevValue);
14502            break;
14503          case "dangerouslySetInnerHTML":
14504            if (null != value) {
14505              if ("object" !== typeof value || !("__html" in value))
14506                throw Error(
14507                  "`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. Please visit https://react.dev/link/dangerously-set-inner-html for more information."
14508                );
14509              key = value.__html;
14510              if (null != key) {
14511                if (null != props.children)
14512                  throw Error(
14513                    "Can only set one of `children` or `props.dangerouslySetInnerHTML`."
14514                  );
14515                domElement.innerHTML = key;
14516              }
14517            }
14518            break;
14519          case "children":
14520            "string" === typeof value ? setTextContent(domElement, value) : ("number" === typeof value || "bigint" === typeof value) && setTextContent(domElement, "" + value);
14521            break;
14522          case "onScroll":
14523            null != value && ("function" !== typeof value && warnForInvalidEventListener(key, value), listenToNonDelegatedEvent("scroll", domElement));
14524            break;
14525          case "onScrollEnd":
14526            null != value && ("function" !== typeof value && warnForInvalidEventListener(key, value), listenToNonDelegatedEvent("scrollend", domElement));
14527            break;
14528          case "onClick":
14529            null != value && ("function" !== typeof value && warnForInvalidEventListener(key, value), domElement.onclick = noop$1);
14530            break;
14531          case "suppressContentEditableWarning":
14532          case "suppressHydrationWarning":
14533          case "innerHTML":
14534          case "ref":
14535            break;
14536          case "innerText":
14537          case "textContent":
14538            break;
14539          default:
14540            if (registrationNameDependencies.hasOwnProperty(key))
14541              null != value && "function" !== typeof value && warnForInvalidEventListener(key, value);
14542            else
14543              a: {
14544                if ("o" === key[0] && "n" === key[1] && (props = key.endsWith("Capture"), tag = key.slice(2, props ? key.length - 7 : void 0), prevValue = domElement[internalPropsKey] || null, prevValue = null != prevValue ? prevValue[key] : null, "function" === typeof prevValue && domElement.removeEventListener(tag, prevValue, props), "function" === typeof value)) {
14545                  "function" !== typeof prevValue && null !== prevValue && (key in domElement ? domElement[key] = null : domElement.hasAttribute(key) && domElement.removeAttribute(key));
14546                  domElement.addEventListener(tag, value, props);
14547                  break a;
14548                }
14549                key in domElement ? domElement[key] = value : true === value ? domElement.setAttribute(key, "") : setValueForAttribute(domElement, key, value);
14550              }
14551        }
14552      }
14553      function setInitialProperties(domElement, tag, props) {
14554        validatePropertiesInDevelopment(tag, props);
14555        switch (tag) {
14556          case "div":
14557          case "span":
14558          case "svg":
14559          case "path":
14560          case "a":
14561          case "g":
14562          case "p":
14563          case "li":
14564            break;
14565          case "img":
14566            listenToNonDelegatedEvent("error", domElement);
14567            listenToNonDelegatedEvent("load", domElement);
14568            var hasSrc = false, hasSrcSet = false, propKey;
14569            for (propKey in props)
14570              if (props.hasOwnProperty(propKey)) {
14571                var propValue = props[propKey];
14572                if (null != propValue)
14573                  switch (propKey) {
14574                    case "src":
14575                      hasSrc = true;
14576                      break;
14577                    case "srcSet":
14578                      hasSrcSet = true;
14579                      break;
14580                    case "children":
14581                    case "dangerouslySetInnerHTML":
14582                      throw Error(
14583                        tag + " is a void element tag and must neither have `children` nor use `dangerouslySetInnerHTML`."
14584                      );
14585                    default:
14586                      setProp(domElement, tag, propKey, propValue, props, null);
14587                  }
14588              }
14589            hasSrcSet && setProp(domElement, tag, "srcSet", props.srcSet, props, null);
14590            hasSrc && setProp(domElement, tag, "src", props.src, props, null);
14591            return;
14592          case "input":
14593            checkControlledValueProps("input", props);
14594            listenToNonDelegatedEvent("invalid", domElement);
14595            var defaultValue = propKey = propValue = hasSrcSet = null, checked = null, defaultChecked = null;
14596            for (hasSrc in props)
14597              if (props.hasOwnProperty(hasSrc)) {
14598                var _propValue = props[hasSrc];
14599                if (null != _propValue)
14600                  switch (hasSrc) {
14601                    case "name":
14602                      hasSrcSet = _propValue;
14603                      break;
14604                    case "type":
14605                      propValue = _propValue;
14606                      break;
14607                    case "checked":
14608                      checked = _propValue;
14609                      break;
14610                    case "defaultChecked":
14611                      defaultChecked = _propValue;
14612                      break;
14613                    case "value":
14614                      propKey = _propValue;
14615                      break;
14616                    case "defaultValue":
14617                      defaultValue = _propValue;
14618                      break;
14619                    case "children":
14620                    case "dangerouslySetInnerHTML":
14621                      if (null != _propValue)
14622                        throw Error(
14623                          tag + " is a void element tag and must neither have `children` nor use `dangerouslySetInnerHTML`."
14624                        );
14625                      break;
14626                    default:
14627                      setProp(domElement, tag, hasSrc, _propValue, props, null);
14628                  }
14629              }
14630            validateInputProps(domElement, props);
14631            initInput(
14632              domElement,
14633              propKey,
14634              defaultValue,
14635              checked,
14636              defaultChecked,
14637              propValue,
14638              hasSrcSet,
14639              false
14640            );
14641            return;
14642          case "select":
14643            checkControlledValueProps("select", props);
14644            listenToNonDelegatedEvent("invalid", domElement);
14645            hasSrc = propValue = propKey = null;
14646            for (hasSrcSet in props)
14647              if (props.hasOwnProperty(hasSrcSet) && (defaultValue = props[hasSrcSet], null != defaultValue))
14648                switch (hasSrcSet) {
14649                  case "value":
14650                    propKey = defaultValue;
14651                    break;
14652                  case "defaultValue":
14653                    propValue = defaultValue;
14654                    break;
14655                  case "multiple":
14656                    hasSrc = defaultValue;
14657                  default:
14658                    setProp(
14659                      domElement,
14660                      tag,
14661                      hasSrcSet,
14662                      defaultValue,
14663                      props,
14664                      null
14665                    );
14666                }
14667            validateSelectProps(domElement, props);
14668            tag = propKey;
14669            props = propValue;
14670            domElement.multiple = !!hasSrc;
14671            null != tag ? updateOptions(domElement, !!hasSrc, tag, false) : null != props && updateOptions(domElement, !!hasSrc, props, true);
14672            return;
14673          case "textarea":
14674            checkControlledValueProps("textarea", props);
14675            listenToNonDelegatedEvent("invalid", domElement);
14676            propKey = hasSrcSet = hasSrc = null;
14677            for (propValue in props)
14678              if (props.hasOwnProperty(propValue) && (defaultValue = props[propValue], null != defaultValue))
14679                switch (propValue) {
14680                  case "value":
14681                    hasSrc = defaultValue;
14682                    break;
14683                  case "defaultValue":
14684                    hasSrcSet = defaultValue;
14685                    break;
14686                  case "children":
14687                    propKey = defaultValue;
14688                    break;
14689                  case "dangerouslySetInnerHTML":
14690                    if (null != defaultValue)
14691                      throw Error(
14692                        "`dangerouslySetInnerHTML` does not make sense on <textarea>."
14693                      );
14694                    break;
14695                  default:
14696                    setProp(
14697                      domElement,
14698                      tag,
14699                      propValue,
14700                      defaultValue,
14701                      props,
14702                      null
14703                    );
14704                }
14705            validateTextareaProps(domElement, props);
14706            initTextarea(domElement, hasSrc, hasSrcSet, propKey);
14707            return;
14708          case "option":
14709            validateOptionProps(domElement, props);
14710            for (checked in props)
14711              if (props.hasOwnProperty(checked) && (hasSrc = props[checked], null != hasSrc))
14712                switch (checked) {
14713                  case "selected":
14714                    domElement.selected = hasSrc && "function" !== typeof hasSrc && "symbol" !== typeof hasSrc;
14715                    break;
14716                  default:
14717                    setProp(domElement, tag, checked, hasSrc, props, null);
14718                }
14719            return;
14720          case "dialog":
14721            listenToNonDelegatedEvent("beforetoggle", domElement);
14722            listenToNonDelegatedEvent("toggle", domElement);
14723            listenToNonDelegatedEvent("cancel", domElement);
14724            listenToNonDelegatedEvent("close", domElement);
14725            break;
14726          case "iframe":
14727          case "object":
14728            listenToNonDelegatedEvent("load", domElement);
14729            break;
14730          case "video":
14731          case "audio":
14732            for (hasSrc = 0; hasSrc < mediaEventTypes.length; hasSrc++)
14733              listenToNonDelegatedEvent(mediaEventTypes[hasSrc], domElement);
14734            break;
14735          case "image":
14736            listenToNonDelegatedEvent("error", domElement);
14737            listenToNonDelegatedEvent("load", domElement);
14738            break;
14739          case "details":
14740            listenToNonDelegatedEvent("toggle", domElement);
14741            break;
14742          case "embed":
14743          case "source":
14744          case "link":
14745            listenToNonDelegatedEvent("error", domElement), listenToNonDelegatedEvent("load", domElement);
14746          case "area":
14747          case "base":
14748          case "br":
14749          case "col":
14750          case "hr":
14751          case "keygen":
14752          case "meta":
14753          case "param":
14754          case "track":
14755          case "wbr":
14756          case "menuitem":
14757            for (defaultChecked in props)
14758              if (props.hasOwnProperty(defaultChecked) && (hasSrc = props[defaultChecked], null != hasSrc))
14759                switch (defaultChecked) {
14760                  case "children":
14761                  case "dangerouslySetInnerHTML":
14762                    throw Error(
14763                      tag + " is a void element tag and must neither have `children` nor use `dangerouslySetInnerHTML`."
14764                    );
14765                  default:
14766                    setProp(domElement, tag, defaultChecked, hasSrc, props, null);
14767                }
14768            return;
14769          default:
14770            if (isCustomElement(tag)) {
14771              for (_propValue in props)
14772                props.hasOwnProperty(_propValue) && (hasSrc = props[_propValue], void 0 !== hasSrc && setPropOnCustomElement(
14773                  domElement,
14774                  tag,
14775                  _propValue,
14776                  hasSrc,
14777                  props,
14778                  void 0
14779                ));
14780              return;
14781            }
14782        }
14783        for (defaultValue in props)
14784          props.hasOwnProperty(defaultValue) && (hasSrc = props[defaultValue], null != hasSrc && setProp(domElement, tag, defaultValue, hasSrc, props, null));
14785      }
14786      function updateProperties(domElement, tag, lastProps, nextProps) {
14787        validatePropertiesInDevelopment(tag, nextProps);
14788        switch (tag) {
14789          case "div":
14790          case "span":
14791          case "svg":
14792          case "path":
14793          case "a":
14794          case "g":
14795          case "p":
14796          case "li":
14797            break;
14798          case "input":
14799            var name = null, type = null, value = null, defaultValue = null, lastDefaultValue = null, checked = null, defaultChecked = null;
14800            for (propKey in lastProps) {
14801              var lastProp = lastProps[propKey];
14802              if (lastProps.hasOwnProperty(propKey) && null != lastProp)
14803                switch (propKey) {
14804                  case "checked":
14805                    break;
14806                  case "value":
14807                    break;
14808                  case "defaultValue":
14809                    lastDefaultValue = lastProp;
14810                  default:
14811                    nextProps.hasOwnProperty(propKey) || setProp(
14812                      domElement,
14813                      tag,
14814                      propKey,
14815                      null,
14816                      nextProps,
14817                      lastProp
14818                    );
14819                }
14820            }
14821            for (var _propKey8 in nextProps) {
14822              var propKey = nextProps[_propKey8];
14823              lastProp = lastProps[_propKey8];
14824              if (nextProps.hasOwnProperty(_propKey8) && (null != propKey || null != lastProp))
14825                switch (_propKey8) {
14826                  case "type":
14827                    type = propKey;
14828                    break;
14829                  case "name":
14830                    name = propKey;
14831                    break;
14832                  case "checked":
14833                    checked = propKey;
14834                    break;
14835                  case "defaultChecked":
14836                    defaultChecked = propKey;
14837                    break;
14838                  case "value":
14839                    value = propKey;
14840                    break;
14841                  case "defaultValue":
14842                    defaultValue = propKey;
14843                    break;
14844                  case "children":
14845                  case "dangerouslySetInnerHTML":
14846                    if (null != propKey)
14847                      throw Error(
14848                        tag + " is a void element tag and must neither have `children` nor use `dangerouslySetInnerHTML`."
14849                      );
14850                    break;
14851                  default:
14852                    propKey !== lastProp && setProp(
14853                      domElement,
14854                      tag,
14855                      _propKey8,
14856                      propKey,
14857                      nextProps,
14858                      lastProp
14859                    );
14860                }
14861            }
14862            tag = "checkbox" === lastProps.type || "radio" === lastProps.type ? null != lastProps.checked : null != lastProps.value;
14863            nextProps = "checkbox" === nextProps.type || "radio" === nextProps.type ? null != nextProps.checked : null != nextProps.value;
14864            tag || !nextProps || didWarnUncontrolledToControlled || (console.error(
14865              "A component is changing an uncontrolled input to be controlled. This is likely caused by the value changing from undefined to a defined value, which should not happen. Decide between using a controlled or uncontrolled input element for the lifetime of the component. More info: https://react.dev/link/controlled-components"
14866            ), didWarnUncontrolledToControlled = true);
14867            !tag || nextProps || didWarnControlledToUncontrolled || (console.error(
14868              "A component is changing a controlled input to be uncontrolled. This is likely caused by the value changing from a defined to undefined, which should not happen. Decide between using a controlled or uncontrolled input element for the lifetime of the component. More info: https://react.dev/link/controlled-components"
14869            ), didWarnControlledToUncontrolled = true);
14870            updateInput(
14871              domElement,
14872              value,
14873              defaultValue,
14874              lastDefaultValue,
14875              checked,
14876              defaultChecked,
14877              type,
14878              name
14879            );
14880            return;
14881          case "select":
14882            propKey = value = defaultValue = _propKey8 = null;
14883            for (type in lastProps)
14884              if (lastDefaultValue = lastProps[type], lastProps.hasOwnProperty(type) && null != lastDefaultValue)
14885                switch (type) {
14886                  case "value":
14887                    break;
14888                  case "multiple":
14889                    propKey = lastDefaultValue;
14890                  default:
14891                    nextProps.hasOwnProperty(type) || setProp(
14892                      domElement,
14893                      tag,
14894                      type,
14895                      null,
14896                      nextProps,
14897                      lastDefaultValue
14898                    );
14899                }
14900            for (name in nextProps)
14901              if (type = nextProps[name], lastDefaultValue = lastProps[name], nextProps.hasOwnProperty(name) && (null != type || null != lastDefaultValue))
14902                switch (name) {
14903                  case "value":
14904                    _propKey8 = type;
14905                    break;
14906                  case "defaultValue":
14907                    defaultValue = type;
14908                    break;
14909                  case "multiple":
14910                    value = type;
14911                  default:
14912                    type !== lastDefaultValue && setProp(
14913                      domElement,
14914                      tag,
14915                      name,
14916                      type,
14917                      nextProps,
14918                      lastDefaultValue
14919                    );
14920                }
14921            nextProps = defaultValue;
14922            tag = value;
14923            lastProps = propKey;
14924            null != _propKey8 ? updateOptions(domElement, !!tag, _propKey8, false) : !!lastProps !== !!tag && (null != nextProps ? updateOptions(domElement, !!tag, nextProps, true) : updateOptions(domElement, !!tag, tag ? [] : "", false));
14925            return;
14926          case "textarea":
14927            propKey = _propKey8 = null;
14928            for (defaultValue in lastProps)
14929              if (name = lastProps[defaultValue], lastProps.hasOwnProperty(defaultValue) && null != name && !nextProps.hasOwnProperty(defaultValue))
14930                switch (defaultValue) {
14931                  case "value":
14932                    break;
14933                  case "children":
14934                    break;
14935                  default:
14936                    setProp(domElement, tag, defaultValue, null, nextProps, name);
14937                }
14938            for (value in nextProps)
14939              if (name = nextProps[value], type = lastProps[value], nextProps.hasOwnProperty(value) && (null != name || null != type))
14940                switch (value) {
14941                  case "value":
14942                    _propKey8 = name;
14943                    break;
14944                  case "defaultValue":
14945                    propKey = name;
14946                    break;
14947                  case "children":
14948                    break;
14949                  case "dangerouslySetInnerHTML":
14950                    if (null != name)
14951                      throw Error(
14952                        "`dangerouslySetInnerHTML` does not make sense on <textarea>."
14953                      );
14954                    break;
14955                  default:
14956                    name !== type && setProp(domElement, tag, value, name, nextProps, type);
14957                }
14958            updateTextarea(domElement, _propKey8, propKey);
14959            return;
14960          case "option":
14961            for (var _propKey13 in lastProps)
14962              if (_propKey8 = lastProps[_propKey13], lastProps.hasOwnProperty(_propKey13) && null != _propKey8 && !nextProps.hasOwnProperty(_propKey13))
14963                switch (_propKey13) {
14964                  case "selected":
14965                    domElement.selected = false;
14966                    break;
14967                  default:
14968                    setProp(
14969                      domElement,
14970                      tag,
14971                      _propKey13,
14972                      null,
14973                      nextProps,
14974                      _propKey8
14975                    );
14976                }
14977            for (lastDefaultValue in nextProps)
14978              if (_propKey8 = nextProps[lastDefaultValue], propKey = lastProps[lastDefaultValue], nextProps.hasOwnProperty(lastDefaultValue) && _propKey8 !== propKey && (null != _propKey8 || null != propKey))
14979                switch (lastDefaultValue) {
14980                  case "selected":
14981                    domElement.selected = _propKey8 && "function" !== typeof _propKey8 && "symbol" !== typeof _propKey8;
14982                    break;
14983                  default:
14984                    setProp(
14985                      domElement,
14986                      tag,
14987                      lastDefaultValue,
14988                      _propKey8,
14989                      nextProps,
14990                      propKey
14991                    );
14992                }
14993            return;
14994          case "img":
14995          case "link":
14996          case "area":
14997          case "base":
14998          case "br":
14999          case "col":
15000          case "embed":
15001          case "hr":
15002          case "keygen":
15003          case "meta":
15004          case "param":
15005          case "source":
15006          case "track":
15007          case "wbr":
15008          case "menuitem":
15009            for (var _propKey15 in lastProps)
15010              _propKey8 = lastProps[_propKey15], lastProps.hasOwnProperty(_propKey15) && null != _propKey8 && !nextProps.hasOwnProperty(_propKey15) && setProp(
15011                domElement,
15012                tag,
15013                _propKey15,
15014                null,
15015                nextProps,
15016                _propKey8
15017              );
15018            for (checked in nextProps)
15019              if (_propKey8 = nextProps[checked], propKey = lastProps[checked], nextProps.hasOwnProperty(checked) && _propKey8 !== propKey && (null != _propKey8 || null != propKey))
15020                switch (checked) {
15021                  case "children":
15022                  case "dangerouslySetInnerHTML":
15023                    if (null != _propKey8)
15024                      throw Error(
15025                        tag + " is a void element tag and must neither have `children` nor use `dangerouslySetInnerHTML`."
15026                      );
15027                    break;
15028                  default:
15029                    setProp(
15030                      domElement,
15031                      tag,
15032                      checked,
15033                      _propKey8,
15034                      nextProps,
15035                      propKey
15036                    );
15037                }
15038            return;
15039          default:
15040            if (isCustomElement(tag)) {
15041              for (var _propKey17 in lastProps)
15042                _propKey8 = lastProps[_propKey17], lastProps.hasOwnProperty(_propKey17) && void 0 !== _propKey8 && !nextProps.hasOwnProperty(_propKey17) && setPropOnCustomElement(
15043                  domElement,
15044                  tag,
15045                  _propKey17,
15046                  void 0,
15047                  nextProps,
15048                  _propKey8
15049                );
15050              for (defaultChecked in nextProps)
15051                _propKey8 = nextProps[defaultChecked], propKey = lastProps[defaultChecked], !nextProps.hasOwnProperty(defaultChecked) || _propKey8 === propKey || void 0 === _propKey8 && void 0 === propKey || setPropOnCustomElement(
15052                  domElement,
15053                  tag,
15054                  defaultChecked,
15055                  _propKey8,
15056                  nextProps,
15057                  propKey
15058                );
15059              return;
15060            }
15061        }
15062        for (var _propKey19 in lastProps)
15063          _propKey8 = lastProps[_propKey19], lastProps.hasOwnProperty(_propKey19) && null != _propKey8 && !nextProps.hasOwnProperty(_propKey19) && setProp(domElement, tag, _propKey19, null, nextProps, _propKey8);
15064        for (lastProp in nextProps)
15065          _propKey8 = nextProps[lastProp], propKey = lastProps[lastProp], !nextProps.hasOwnProperty(lastProp) || _propKey8 === propKey || null == _propKey8 && null == propKey || setProp(domElement, tag, lastProp, _propKey8, nextProps, propKey);
15066      }
15067      function getPropNameFromAttributeName(attrName) {
15068        switch (attrName) {
15069          case "class":
15070            return "className";
15071          case "for":
15072            return "htmlFor";
15073          default:
15074            return attrName;
15075        }
15076      }
15077      function getStylesObjectFromElement(domElement) {
15078        var serverValueInObjectForm = {};
15079        domElement = domElement.style;
15080        for (var i = 0; i < domElement.length; i++) {
15081          var styleName = domElement[i];
15082          serverValueInObjectForm[styleName] = domElement.getPropertyValue(styleName);
15083        }
15084        return serverValueInObjectForm;
15085      }
15086      function diffHydratedStyles(domElement, value$jscomp$0, serverDifferences) {
15087        if (null != value$jscomp$0 && "object" !== typeof value$jscomp$0)
15088          console.error(
15089            "The `style` prop expects a mapping from style properties to values, not a string. For example, style={{marginRight: spacing + 'em'}} when using JSX."
15090          );
15091        else {
15092          var clientValue;
15093          var delimiter = clientValue = "", styleName;
15094          for (styleName in value$jscomp$0)
15095            if (value$jscomp$0.hasOwnProperty(styleName)) {
15096              var value = value$jscomp$0[styleName];
15097              null != value && "boolean" !== typeof value && "" !== value && (0 === styleName.indexOf("--") ? (checkCSSPropertyStringCoercion(value, styleName), clientValue += delimiter + styleName + ":" + ("" + value).trim()) : "number" !== typeof value || 0 === value || unitlessNumbers.has(styleName) ? (checkCSSPropertyStringCoercion(value, styleName), clientValue += delimiter + styleName.replace(uppercasePattern, "-$1").toLowerCase().replace(msPattern$1, "-ms-") + ":" + ("" + value).trim()) : clientValue += delimiter + styleName.replace(uppercasePattern, "-$1").toLowerCase().replace(msPattern$1, "-ms-") + ":" + value + "px", delimiter = ";");
15098            }
15099          clientValue = clientValue || null;
15100          value$jscomp$0 = domElement.getAttribute("style");
15101          value$jscomp$0 !== clientValue && (clientValue = normalizeMarkupForTextOrAttribute(clientValue), normalizeMarkupForTextOrAttribute(value$jscomp$0) !== clientValue && (serverDifferences.style = getStylesObjectFromElement(domElement)));
15102        }
15103      }
15104      function hydrateAttribute(domElement, propKey, attributeName, value, extraAttributes, serverDifferences) {
15105        extraAttributes.delete(attributeName);
15106        domElement = domElement.getAttribute(attributeName);
15107        if (null === domElement)
15108          switch (typeof value) {
15109            case "undefined":
15110            case "function":
15111            case "symbol":
15112            case "boolean":
15113              return;
15114          }
15115        else if (null != value)
15116          switch (typeof value) {
15117            case "function":
15118            case "symbol":
15119            case "boolean":
15120              break;
15121            default:
15122              if (checkAttributeStringCoercion(value, propKey), domElement === "" + value)
15123                return;
15124          }
15125        warnForPropDifference(propKey, domElement, value, serverDifferences);
15126      }
15127      function hydrateBooleanAttribute(domElement, propKey, attributeName, value, extraAttributes, serverDifferences) {
15128        extraAttributes.delete(attributeName);
15129        domElement = domElement.getAttribute(attributeName);
15130        if (null === domElement) {
15131          switch (typeof value) {
15132            case "function":
15133            case "symbol":
15134              return;
15135          }
15136          if (!value) return;
15137        } else
15138          switch (typeof value) {
15139            case "function":
15140            case "symbol":
15141              break;
15142            default:
15143              if (value) return;
15144          }
15145        warnForPropDifference(propKey, domElement, value, serverDifferences);
15146      }
15147      function hydrateBooleanishAttribute(domElement, propKey, attributeName, value, extraAttributes, serverDifferences) {
15148        extraAttributes.delete(attributeName);
15149        domElement = domElement.getAttribute(attributeName);
15150        if (null === domElement)
15151          switch (typeof value) {
15152            case "undefined":
15153            case "function":
15154            case "symbol":
15155              return;
15156          }
15157        else if (null != value)
15158          switch (typeof value) {
15159            case "function":
15160            case "symbol":
15161              break;
15162            default:
15163              if (checkAttributeStringCoercion(value, attributeName), domElement === "" + value)
15164                return;
15165          }
15166        warnForPropDifference(propKey, domElement, value, serverDifferences);
15167      }
15168      function hydrateNumericAttribute(domElement, propKey, attributeName, value, extraAttributes, serverDifferences) {
15169        extraAttributes.delete(attributeName);
15170        domElement = domElement.getAttribute(attributeName);
15171        if (null === domElement)
15172          switch (typeof value) {
15173            case "undefined":
15174            case "function":
15175            case "symbol":
15176            case "boolean":
15177              return;
15178            default:
15179              if (isNaN(value)) return;
15180          }
15181        else if (null != value)
15182          switch (typeof value) {
15183            case "function":
15184            case "symbol":
15185            case "boolean":
15186              break;
15187            default:
15188              if (!isNaN(value) && (checkAttributeStringCoercion(value, propKey), domElement === "" + value))
15189                return;
15190          }
15191        warnForPropDifference(propKey, domElement, value, serverDifferences);
15192      }
15193      function hydrateSanitizedAttribute(domElement, propKey, attributeName, value, extraAttributes, serverDifferences) {
15194        extraAttributes.delete(attributeName);
15195        domElement = domElement.getAttribute(attributeName);
15196        if (null === domElement)
15197          switch (typeof value) {
15198            case "undefined":
15199            case "function":
15200            case "symbol":
15201            case "boolean":
15202              return;
15203          }
15204        else if (null != value)
15205          switch (typeof value) {
15206            case "function":
15207            case "symbol":
15208            case "boolean":
15209              break;
15210            default:
15211              if (checkAttributeStringCoercion(value, propKey), attributeName = sanitizeURL("" + value), domElement === attributeName)
15212                return;
15213          }
15214        warnForPropDifference(propKey, domElement, value, serverDifferences);
15215      }
15216      function diffHydratedProperties(domElement, tag, props, hostContext) {
15217        for (var serverDifferences = {}, extraAttributes = /* @__PURE__ */ new Set(), attributes = domElement.attributes, i = 0; i < attributes.length; i++)
15218          switch (attributes[i].name.toLowerCase()) {
15219            case "value":
15220              break;
15221            case "checked":
15222              break;
15223            case "selected":
15224              break;
15225            default:
15226              extraAttributes.add(attributes[i].name);
15227          }
15228        if (isCustomElement(tag))
15229          for (var propKey in props) {
15230            if (props.hasOwnProperty(propKey)) {
15231              var value = props[propKey];
15232              if (null != value) {
15233                if (registrationNameDependencies.hasOwnProperty(propKey))
15234                  "function" !== typeof value && warnForInvalidEventListener(propKey, value);
15235                else if (true !== props.suppressHydrationWarning)
15236                  switch (propKey) {
15237                    case "children":
15238                      "string" !== typeof value && "number" !== typeof value || warnForPropDifference(
15239                        "children",
15240                        domElement.textContent,
15241                        value,
15242                        serverDifferences
15243                      );
15244                      continue;
15245                    case "suppressContentEditableWarning":
15246                    case "suppressHydrationWarning":
15247                    case "defaultValue":
15248                    case "defaultChecked":
15249                    case "innerHTML":
15250                    case "ref":
15251                      continue;
15252                    case "dangerouslySetInnerHTML":
15253                      attributes = domElement.innerHTML;
15254                      value = value ? value.__html : void 0;
15255                      null != value && (value = normalizeHTML(domElement, value), warnForPropDifference(
15256                        propKey,
15257                        attributes,
15258                        value,
15259                        serverDifferences
15260                      ));
15261                      continue;
15262                    case "style":
15263                      extraAttributes.delete(propKey);
15264                      diffHydratedStyles(domElement, value, serverDifferences);
15265                      continue;
15266                    case "offsetParent":
15267                    case "offsetTop":
15268                    case "offsetLeft":
15269                    case "offsetWidth":
15270                    case "offsetHeight":
15271                    case "isContentEditable":
15272                    case "outerText":
15273                    case "outerHTML":
15274                      extraAttributes.delete(propKey.toLowerCase());
15275                      console.error(
15276                        "Assignment to read-only property will result in a no-op: `%s`",
15277                        propKey
15278                      );
15279                      continue;
15280                    case "className":
15281                      extraAttributes.delete("class");
15282                      attributes = getValueForAttributeOnCustomComponent(
15283                        domElement,
15284                        "class",
15285                        value
15286                      );
15287                      warnForPropDifference(
15288                        "className",
15289                        attributes,
15290                        value,
15291                        serverDifferences
15292                      );
15293                      continue;
15294                    default:
15295                      hostContext.context === HostContextNamespaceNone && "svg" !== tag && "math" !== tag ? extraAttributes.delete(propKey.toLowerCase()) : extraAttributes.delete(propKey), attributes = getValueForAttributeOnCustomComponent(
15296                        domElement,
15297                        propKey,
15298                        value
15299                      ), warnForPropDifference(
15300                        propKey,
15301                        attributes,
15302                        value,
15303                        serverDifferences
15304                      );
15305                  }
15306              }
15307            }
15308          }
15309        else
15310          for (value in props)
15311            if (props.hasOwnProperty(value) && (propKey = props[value], null != propKey)) {
15312              if (registrationNameDependencies.hasOwnProperty(value))
15313                "function" !== typeof propKey && warnForInvalidEventListener(value, propKey);
15314              else if (true !== props.suppressHydrationWarning)
15315                switch (value) {
15316                  case "children":
15317                    "string" !== typeof propKey && "number" !== typeof propKey || warnForPropDifference(
15318                      "children",
15319                      domElement.textContent,
15320                      propKey,
15321                      serverDifferences
15322                    );
15323                    continue;
15324                  case "suppressContentEditableWarning":
15325                  case "suppressHydrationWarning":
15326                  case "value":
15327                  case "checked":
15328                  case "selected":
15329                  case "defaultValue":
15330                  case "defaultChecked":
15331                  case "innerHTML":
15332                  case "ref":
15333                    continue;
15334                  case "dangerouslySetInnerHTML":
15335                    attributes = domElement.innerHTML;
15336                    propKey = propKey ? propKey.__html : void 0;
15337                    null != propKey && (propKey = normalizeHTML(domElement, propKey), attributes !== propKey && (serverDifferences[value] = { __html: attributes }));
15338                    continue;
15339                  case "className":
15340                    hydrateAttribute(
15341                      domElement,
15342                      value,
15343                      "class",
15344                      propKey,
15345                      extraAttributes,
15346                      serverDifferences
15347                    );
15348                    continue;
15349                  case "tabIndex":
15350                    hydrateAttribute(
15351                      domElement,
15352                      value,
15353                      "tabindex",
15354                      propKey,
15355                      extraAttributes,
15356                      serverDifferences
15357                    );
15358                    continue;
15359                  case "style":
15360                    extraAttributes.delete(value);
15361                    diffHydratedStyles(domElement, propKey, serverDifferences);
15362                    continue;
15363                  case "multiple":
15364                    extraAttributes.delete(value);
15365                    warnForPropDifference(
15366                      value,
15367                      domElement.multiple,
15368                      propKey,
15369                      serverDifferences
15370                    );
15371                    continue;
15372                  case "muted":
15373                    extraAttributes.delete(value);
15374                    warnForPropDifference(
15375                      value,
15376                      domElement.muted,
15377                      propKey,
15378                      serverDifferences
15379                    );
15380                    continue;
15381                  case "autoFocus":
15382                    extraAttributes.delete("autofocus");
15383                    warnForPropDifference(
15384                      value,
15385                      domElement.autofocus,
15386                      propKey,
15387                      serverDifferences
15388                    );
15389                    continue;
15390                  case "data":
15391                    if ("object" !== tag) {
15392                      extraAttributes.delete(value);
15393                      attributes = domElement.getAttribute("data");
15394                      warnForPropDifference(
15395                        value,
15396                        attributes,
15397                        propKey,
15398                        serverDifferences
15399                      );
15400                      continue;
15401                    }
15402                  case "src":
15403                  case "href":
15404                    if (!("" !== propKey || "a" === tag && "href" === value || "object" === tag && "data" === value)) {
15405                      "src" === value ? console.error(
15406                        'An empty string ("") was passed to the %s attribute. This may cause the browser to download the whole page again over the network. To fix this, either do not render the element at all or pass null to %s instead of an empty string.',
15407                        value,
15408                        value
15409                      ) : console.error(
15410                        'An empty string ("") was passed to the %s attribute. To fix this, either do not render the element at all or pass null to %s instead of an empty string.',
15411                        value,
15412                        value
15413                      );
15414                      continue;
15415                    }
15416                    hydrateSanitizedAttribute(
15417                      domElement,
15418                      value,
15419                      value,
15420                      propKey,
15421                      extraAttributes,
15422                      serverDifferences
15423                    );
15424                    continue;
15425                  case "action":
15426                  case "formAction":
15427                    attributes = domElement.getAttribute(value);
15428                    if ("function" === typeof propKey) {
15429                      extraAttributes.delete(value.toLowerCase());
15430                      "formAction" === value ? (extraAttributes.delete("name"), extraAttributes.delete("formenctype"), extraAttributes.delete("formmethod"), extraAttributes.delete("formtarget")) : (extraAttributes.delete("enctype"), extraAttributes.delete("method"), extraAttributes.delete("target"));
15431                      continue;
15432                    } else if (attributes === EXPECTED_FORM_ACTION_URL) {
15433                      extraAttributes.delete(value.toLowerCase());
15434                      warnForPropDifference(
15435                        value,
15436                        "function",
15437                        propKey,
15438                        serverDifferences
15439                      );
15440                      continue;
15441                    }
15442                    hydrateSanitizedAttribute(
15443                      domElement,
15444                      value,
15445                      value.toLowerCase(),
15446                      propKey,
15447                      extraAttributes,
15448                      serverDifferences
15449                    );
15450                    continue;
15451                  case "xlinkHref":
15452                    hydrateSanitizedAttribute(
15453                      domElement,
15454                      value,
15455                      "xlink:href",
15456                      propKey,
15457                      extraAttributes,
15458                      serverDifferences
15459                    );
15460                    continue;
15461                  case "contentEditable":
15462                    hydrateBooleanishAttribute(
15463                      domElement,
15464                      value,
15465                      "contenteditable",
15466                      propKey,
15467                      extraAttributes,
15468                      serverDifferences
15469                    );
15470                    continue;
15471                  case "spellCheck":
15472                    hydrateBooleanishAttribute(
15473                      domElement,
15474                      value,
15475                      "spellcheck",
15476                      propKey,
15477                      extraAttributes,
15478                      serverDifferences
15479                    );
15480                    continue;
15481                  case "draggable":
15482                  case "autoReverse":
15483                  case "externalResourcesRequired":
15484                  case "focusable":
15485                  case "preserveAlpha":
15486                    hydrateBooleanishAttribute(
15487                      domElement,
15488                      value,
15489                      value,
15490                      propKey,
15491                      extraAttributes,
15492                      serverDifferences
15493                    );
15494                    continue;
15495                  case "allowFullScreen":
15496                  case "async":
15497                  case "autoPlay":
15498                  case "controls":
15499                  case "default":
15500                  case "defer":
15501                  case "disabled":
15502                  case "disablePictureInPicture":
15503                  case "disableRemotePlayback":
15504                  case "formNoValidate":
15505                  case "hidden":
15506                  case "loop":
15507                  case "noModule":
15508                  case "noValidate":
15509                  case "open":
15510                  case "playsInline":
15511                  case "readOnly":
15512                  case "required":
15513                  case "reversed":
15514                  case "scoped":
15515                  case "seamless":
15516                  case "itemScope":
15517                    hydrateBooleanAttribute(
15518                      domElement,
15519                      value,
15520                      value.toLowerCase(),
15521                      propKey,
15522                      extraAttributes,
15523                      serverDifferences
15524                    );
15525                    continue;
15526                  case "capture":
15527                  case "download":
15528                    a: {
15529                      i = domElement;
15530                      var attributeName = attributes = value, serverDifferences$jscomp$0 = serverDifferences;
15531                      extraAttributes.delete(attributeName);
15532                      i = i.getAttribute(attributeName);
15533                      if (null === i)
15534                        switch (typeof propKey) {
15535                          case "undefined":
15536                          case "function":
15537                          case "symbol":
15538                            break a;
15539                          default:
15540                            if (false === propKey) break a;
15541                        }
15542                      else if (null != propKey)
15543                        switch (typeof propKey) {
15544                          case "function":
15545                          case "symbol":
15546                            break;
15547                          case "boolean":
15548                            if (true === propKey && "" === i) break a;
15549                            break;
15550                          default:
15551                            if (checkAttributeStringCoercion(propKey, attributes), i === "" + propKey)
15552                              break a;
15553                        }
15554                      warnForPropDifference(
15555                        attributes,
15556                        i,
15557                        propKey,
15558                        serverDifferences$jscomp$0
15559                      );
15560                    }
15561                    continue;
15562                  case "cols":
15563                  case "rows":
15564                  case "size":
15565                  case "span":
15566                    a: {
15567                      i = domElement;
15568                      attributeName = attributes = value;
15569                      serverDifferences$jscomp$0 = serverDifferences;
15570                      extraAttributes.delete(attributeName);
15571                      i = i.getAttribute(attributeName);
15572                      if (null === i)
15573                        switch (typeof propKey) {
15574                          case "undefined":
15575                          case "function":
15576                          case "symbol":
15577                          case "boolean":
15578                            break a;
15579                          default:
15580                            if (isNaN(propKey) || 1 > propKey) break a;
15581                        }
15582                      else if (null != propKey)
15583                        switch (typeof propKey) {
15584                          case "function":
15585                          case "symbol":
15586                          case "boolean":
15587                            break;
15588                          default:
15589                            if (!(isNaN(propKey) || 1 > propKey) && (checkAttributeStringCoercion(propKey, attributes), i === "" + propKey))
15590                              break a;
15591                        }
15592                      warnForPropDifference(
15593                        attributes,
15594                        i,
15595                        propKey,
15596                        serverDifferences$jscomp$0
15597                      );
15598                    }
15599                    continue;
15600                  case "rowSpan":
15601                    hydrateNumericAttribute(
15602                      domElement,
15603                      value,
15604                      "rowspan",
15605                      propKey,
15606                      extraAttributes,
15607                      serverDifferences
15608                    );
15609                    continue;
15610                  case "start":
15611                    hydrateNumericAttribute(
15612                      domElement,
15613                      value,
15614                      value,
15615                      propKey,
15616                      extraAttributes,
15617                      serverDifferences
15618                    );
15619                    continue;
15620                  case "xHeight":
15621                    hydrateAttribute(
15622                      domElement,
15623                      value,
15624                      "x-height",
15625                      propKey,
15626                      extraAttributes,
15627                      serverDifferences
15628                    );
15629                    continue;
15630                  case "xlinkActuate":
15631                    hydrateAttribute(
15632                      domElement,
15633                      value,
15634                      "xlink:actuate",
15635                      propKey,
15636                      extraAttributes,
15637                      serverDifferences
15638                    );
15639                    continue;
15640                  case "xlinkArcrole":
15641                    hydrateAttribute(
15642                      domElement,
15643                      value,
15644                      "xlink:arcrole",
15645                      propKey,
15646                      extraAttributes,
15647                      serverDifferences
15648                    );
15649                    continue;
15650                  case "xlinkRole":
15651                    hydrateAttribute(
15652                      domElement,
15653                      value,
15654                      "xlink:role",
15655                      propKey,
15656                      extraAttributes,
15657                      serverDifferences
15658                    );
15659                    continue;
15660                  case "xlinkShow":
15661                    hydrateAttribute(
15662                      domElement,
15663                      value,
15664                      "xlink:show",
15665                      propKey,
15666                      extraAttributes,
15667                      serverDifferences
15668                    );
15669                    continue;
15670                  case "xlinkTitle":
15671                    hydrateAttribute(
15672                      domElement,
15673                      value,
15674                      "xlink:title",
15675                      propKey,
15676                      extraAttributes,
15677                      serverDifferences
15678                    );
15679                    continue;
15680                  case "xlinkType":
15681                    hydrateAttribute(
15682                      domElement,
15683                      value,
15684                      "xlink:type",
15685                      propKey,
15686                      extraAttributes,
15687                      serverDifferences
15688                    );
15689                    continue;
15690                  case "xmlBase":
15691                    hydrateAttribute(
15692                      domElement,
15693                      value,
15694                      "xml:base",
15695                      propKey,
15696                      extraAttributes,
15697                      serverDifferences
15698                    );
15699                    continue;
15700                  case "xmlLang":
15701                    hydrateAttribute(
15702                      domElement,
15703                      value,
15704                      "xml:lang",
15705                      propKey,
15706                      extraAttributes,
15707                      serverDifferences
15708                    );
15709                    continue;
15710                  case "xmlSpace":
15711                    hydrateAttribute(
15712                      domElement,
15713                      value,
15714                      "xml:space",
15715                      propKey,
15716                      extraAttributes,
15717                      serverDifferences
15718                    );
15719                    continue;
15720                  case "inert":
15721                    "" !== propKey || didWarnForNewBooleanPropsWithEmptyValue[value] || (didWarnForNewBooleanPropsWithEmptyValue[value] = true, console.error(
15722                      "Received an empty string for a boolean attribute `%s`. This will treat the attribute as if it were false. Either pass `false` to silence this warning, or pass `true` if you used an empty string in earlier versions of React to indicate this attribute is true.",
15723                      value
15724                    ));
15725                    hydrateBooleanAttribute(
15726                      domElement,
15727                      value,
15728                      value,
15729                      propKey,
15730                      extraAttributes,
15731                      serverDifferences
15732                    );
15733                    continue;
15734                  default:
15735                    if (!(2 < value.length) || "o" !== value[0] && "O" !== value[0] || "n" !== value[1] && "N" !== value[1]) {
15736                      i = getAttributeAlias(value);
15737                      attributes = false;
15738                      hostContext.context === HostContextNamespaceNone && "svg" !== tag && "math" !== tag ? extraAttributes.delete(i.toLowerCase()) : (attributeName = value.toLowerCase(), attributeName = possibleStandardNames.hasOwnProperty(
15739                        attributeName
15740                      ) ? possibleStandardNames[attributeName] || null : null, null !== attributeName && attributeName !== value && (attributes = true, extraAttributes.delete(attributeName)), extraAttributes.delete(i));
15741                      a: if (attributeName = domElement, serverDifferences$jscomp$0 = i, i = propKey, isAttributeNameSafe(serverDifferences$jscomp$0))
15742                        if (attributeName.hasAttribute(serverDifferences$jscomp$0))
15743                          attributeName = attributeName.getAttribute(
15744                            serverDifferences$jscomp$0
15745                          ), checkAttributeStringCoercion(
15746                            i,
15747                            serverDifferences$jscomp$0
15748                          ), i = attributeName === "" + i ? i : attributeName;
15749                        else {
15750                          switch (typeof i) {
15751                            case "function":
15752                            case "symbol":
15753                              break a;
15754                            case "boolean":
15755                              if (attributeName = serverDifferences$jscomp$0.toLowerCase().slice(0, 5), "data-" !== attributeName && "aria-" !== attributeName)
15756                                break a;
15757                          }
15758                          i = void 0 === i ? void 0 : null;
15759                        }
15760                      else i = void 0;
15761                      attributes || warnForPropDifference(
15762                        value,
15763                        i,
15764                        propKey,
15765                        serverDifferences
15766                      );
15767                    }
15768                }
15769            }
15770        0 < extraAttributes.size && true !== props.suppressHydrationWarning && warnForExtraAttributes(domElement, extraAttributes, serverDifferences);
15771        return 0 === Object.keys(serverDifferences).length ? null : serverDifferences;
15772      }
15773      function propNamesListJoin(list, combinator) {
15774        switch (list.length) {
15775          case 0:
15776            return "";
15777          case 1:
15778            return list[0];
15779          case 2:
15780            return list[0] + " " + combinator + " " + list[1];
15781          default:
15782            return list.slice(0, -1).join(", ") + ", " + combinator + " " + list[list.length - 1];
15783        }
15784      }
15785      function isLikelyStaticResource(initiatorType) {
15786        switch (initiatorType) {
15787          case "css":
15788          case "script":
15789          case "font":
15790          case "img":
15791          case "image":
15792          case "input":
15793          case "link":
15794            return true;
15795          default:
15796            return false;
15797        }
15798      }
15799      function estimateBandwidth() {
15800        if ("function" === typeof performance.getEntriesByType) {
15801          for (var count = 0, bits = 0, resourceEntries = performance.getEntriesByType("resource"), i = 0; i < resourceEntries.length; i++) {
15802            var entry = resourceEntries[i], transferSize = entry.transferSize, initiatorType = entry.initiatorType, duration = entry.duration;
15803            if (transferSize && duration && isLikelyStaticResource(initiatorType)) {
15804              initiatorType = 0;
15805              duration = entry.responseEnd;
15806              for (i += 1; i < resourceEntries.length; i++) {
15807                var overlapEntry = resourceEntries[i], overlapStartTime = overlapEntry.startTime;
15808                if (overlapStartTime > duration) break;
15809                var overlapTransferSize = overlapEntry.transferSize, overlapInitiatorType = overlapEntry.initiatorType;
15810                overlapTransferSize && isLikelyStaticResource(overlapInitiatorType) && (overlapEntry = overlapEntry.responseEnd, initiatorType += overlapTransferSize * (overlapEntry < duration ? 1 : (duration - overlapStartTime) / (overlapEntry - overlapStartTime)));
15811              }
15812              --i;
15813              bits += 8 * (transferSize + initiatorType) / (entry.duration / 1e3);
15814              count++;
15815              if (10 < count) break;
15816            }
15817          }
15818          if (0 < count) return bits / count / 1e6;
15819        }
15820        return navigator.connection && (count = navigator.connection.downlink, "number" === typeof count) ? count : 5;
15821      }
15822      function getOwnerDocumentFromRootContainer(rootContainerElement) {
15823        return 9 === rootContainerElement.nodeType ? rootContainerElement : rootContainerElement.ownerDocument;
15824      }
15825      function getOwnHostContext(namespaceURI) {
15826        switch (namespaceURI) {
15827          case SVG_NAMESPACE:
15828            return HostContextNamespaceSvg;
15829          case MATH_NAMESPACE:
15830            return HostContextNamespaceMath;
15831          default:
15832            return HostContextNamespaceNone;
15833        }
15834      }
15835      function getChildHostContextProd(parentNamespace, type) {
15836        if (parentNamespace === HostContextNamespaceNone)
15837          switch (type) {
15838            case "svg":
15839              return HostContextNamespaceSvg;
15840            case "math":
15841              return HostContextNamespaceMath;
15842            default:
15843              return HostContextNamespaceNone;
15844          }
15845        return parentNamespace === HostContextNamespaceSvg && "foreignObject" === type ? HostContextNamespaceNone : parentNamespace;
15846      }
15847      function shouldSetTextContent(type, props) {
15848        return "textarea" === type || "noscript" === type || "string" === typeof props.children || "number" === typeof props.children || "bigint" === typeof props.children || "object" === typeof props.dangerouslySetInnerHTML && null !== props.dangerouslySetInnerHTML && null != props.dangerouslySetInnerHTML.__html;
15849      }
15850      function shouldAttemptEagerTransition() {
15851        var event = window.event;
15852        if (event && "popstate" === event.type) {
15853          if (event === currentPopstateTransitionEvent) return false;
15854          currentPopstateTransitionEvent = event;
15855          return true;
15856        }
15857        currentPopstateTransitionEvent = null;
15858        return false;
15859      }
15860      function resolveEventType() {
15861        var event = window.event;
15862        return event && event !== schedulerEvent ? event.type : null;
15863      }
15864      function resolveEventTimeStamp() {
15865        var event = window.event;
15866        return event && event !== schedulerEvent ? event.timeStamp : -1.1;
15867      }
15868      function handleErrorInNextTick(error) {
15869        setTimeout(function() {
15870          throw error;
15871        });
15872      }
15873      function commitMount(domElement, type, newProps) {
15874        switch (type) {
15875          case "button":
15876          case "input":
15877          case "select":
15878          case "textarea":
15879            newProps.autoFocus && domElement.focus();
15880            break;
15881          case "img":
15882            newProps.src ? domElement.src = newProps.src : newProps.srcSet && (domElement.srcset = newProps.srcSet);
15883        }
15884      }
15885      function commitHydratedInstance() {
15886      }
15887      function commitUpdate(domElement, type, oldProps, newProps) {
15888        updateProperties(domElement, type, oldProps, newProps);
15889        domElement[internalPropsKey] = newProps;
15890      }
15891      function resetTextContent(domElement) {
15892        setTextContent(domElement, "");
15893      }
15894      function commitTextUpdate(textInstance, oldText, newText) {
15895        textInstance.nodeValue = newText;
15896      }
15897      function warnForReactChildrenConflict(container) {
15898        if (!container.__reactWarnedAboutChildrenConflict) {
15899          var props = container[internalPropsKey] || null;
15900          if (null !== props) {
15901            var fiber = getInstanceFromNode(container);
15902            null !== fiber && ("string" === typeof props.children || "number" === typeof props.children ? (container.__reactWarnedAboutChildrenConflict = true, runWithFiberInDEV(fiber, function() {
15903              console.error(
15904                'Cannot use a ref on a React element as a container to `createRoot` or `createPortal` if that element also sets "children" text content using React. It should be a leaf with no children. Otherwise it\'s ambiguous which children should be used.'
15905              );
15906            })) : null != props.dangerouslySetInnerHTML && (container.__reactWarnedAboutChildrenConflict = true, runWithFiberInDEV(fiber, function() {
15907              console.error(
15908                'Cannot use a ref on a React element as a container to `createRoot` or `createPortal` if that element also sets "dangerouslySetInnerHTML" using React. It should be a leaf with no children. Otherwise it\'s ambiguous which children should be used.'
15909              );
15910            })));
15911          }
15912        }
15913      }
15914      function isSingletonScope(type) {
15915        return "head" === type;
15916      }
15917      function removeChild(parentInstance, child) {
15918        parentInstance.removeChild(child);
15919      }
15920      function removeChildFromContainer(container, child) {
15921        (9 === container.nodeType ? container.body : "HTML" === container.nodeName ? container.ownerDocument.body : container).removeChild(child);
15922      }
15923      function clearHydrationBoundary(parentInstance, hydrationInstance) {
15924        var node = hydrationInstance, depth = 0;
15925        do {
15926          var nextNode = node.nextSibling;
15927          parentInstance.removeChild(node);
15928          if (nextNode && 8 === nextNode.nodeType)
15929            if (node = nextNode.data, node === SUSPENSE_END_DATA || node === ACTIVITY_END_DATA) {
15930              if (0 === depth) {
15931                parentInstance.removeChild(nextNode);
15932                retryIfBlockedOn(hydrationInstance);
15933                return;
15934              }
15935              depth--;
15936            } else if (node === SUSPENSE_START_DATA || node === SUSPENSE_PENDING_START_DATA || node === SUSPENSE_QUEUED_START_DATA || node === SUSPENSE_FALLBACK_START_DATA || node === ACTIVITY_START_DATA)
15937              depth++;
15938            else if (node === PREAMBLE_CONTRIBUTION_HTML)
15939              releaseSingletonInstance(
15940                parentInstance.ownerDocument.documentElement
15941              );
15942            else if (node === PREAMBLE_CONTRIBUTION_HEAD) {
15943              node = parentInstance.ownerDocument.head;
15944              releaseSingletonInstance(node);
15945              for (var node$jscomp$0 = node.firstChild; node$jscomp$0; ) {
15946                var nextNode$jscomp$0 = node$jscomp$0.nextSibling, nodeName = node$jscomp$0.nodeName;
15947                node$jscomp$0[internalHoistableMarker] || "SCRIPT" === nodeName || "STYLE" === nodeName || "LINK" === nodeName && "stylesheet" === node$jscomp$0.rel.toLowerCase() || node.removeChild(node$jscomp$0);
15948                node$jscomp$0 = nextNode$jscomp$0;
15949              }
15950            } else
15951              node === PREAMBLE_CONTRIBUTION_BODY && releaseSingletonInstance(parentInstance.ownerDocument.body);
15952          node = nextNode;
15953        } while (node);
15954        retryIfBlockedOn(hydrationInstance);
15955      }
15956      function hideOrUnhideDehydratedBoundary(suspenseInstance, isHidden) {
15957        var node = suspenseInstance;
15958        suspenseInstance = 0;
15959        do {
15960          var nextNode = node.nextSibling;
15961          1 === node.nodeType ? isHidden ? (node._stashedDisplay = node.style.display, node.style.display = "none") : (node.style.display = node._stashedDisplay || "", "" === node.getAttribute("style") && node.removeAttribute("style")) : 3 === node.nodeType && (isHidden ? (node._stashedText = node.nodeValue, node.nodeValue = "") : node.nodeValue = node._stashedText || "");
15962          if (nextNode && 8 === nextNode.nodeType)
15963            if (node = nextNode.data, node === SUSPENSE_END_DATA)
15964              if (0 === suspenseInstance) break;
15965              else suspenseInstance--;
15966            else
15967              node !== SUSPENSE_START_DATA && node !== SUSPENSE_PENDING_START_DATA && node !== SUSPENSE_QUEUED_START_DATA && node !== SUSPENSE_FALLBACK_START_DATA || suspenseInstance++;
15968          node = nextNode;
15969        } while (node);
15970      }
15971      function hideDehydratedBoundary(suspenseInstance) {
15972        hideOrUnhideDehydratedBoundary(suspenseInstance, true);
15973      }
15974      function hideInstance(instance) {
15975        instance = instance.style;
15976        "function" === typeof instance.setProperty ? instance.setProperty("display", "none", "important") : instance.display = "none";
15977      }
15978      function hideTextInstance(textInstance) {
15979        textInstance.nodeValue = "";
15980      }
15981      function unhideDehydratedBoundary(dehydratedInstance) {
15982        hideOrUnhideDehydratedBoundary(dehydratedInstance, false);
15983      }
15984      function unhideInstance(instance, props) {
15985        props = props[STYLE];
15986        props = void 0 !== props && null !== props && props.hasOwnProperty("display") ? props.display : null;
15987        instance.style.display = null == props || "boolean" === typeof props ? "" : ("" + props).trim();
15988      }
15989      function unhideTextInstance(textInstance, text) {
15990        textInstance.nodeValue = text;
15991      }
15992      function clearContainerSparingly(container) {
15993        var nextNode = container.firstChild;
15994        nextNode && 10 === nextNode.nodeType && (nextNode = nextNode.nextSibling);
15995        for (; nextNode; ) {
15996          var node = nextNode;
15997          nextNode = nextNode.nextSibling;
15998          switch (node.nodeName) {
15999            case "HTML":
16000            case "HEAD":
16001            case "BODY":
16002              clearContainerSparingly(node);
16003              detachDeletedInstance(node);
16004              continue;
16005            case "SCRIPT":
16006            case "STYLE":
16007              continue;
16008            case "LINK":
16009              if ("stylesheet" === node.rel.toLowerCase()) continue;
16010          }
16011          container.removeChild(node);
16012        }
16013      }
16014      function canHydrateInstance(instance, type, props, inRootOrSingleton) {
16015        for (; 1 === instance.nodeType; ) {
16016          var anyProps = props;
16017          if (instance.nodeName.toLowerCase() !== type.toLowerCase()) {
16018            if (!inRootOrSingleton && ("INPUT" !== instance.nodeName || "hidden" !== instance.type))
16019              break;
16020          } else if (!inRootOrSingleton)
16021            if ("input" === type && "hidden" === instance.type) {
16022              checkAttributeStringCoercion(anyProps.name, "name");
16023              var name = null == anyProps.name ? null : "" + anyProps.name;
16024              if ("hidden" === anyProps.type && instance.getAttribute("name") === name)
16025                return instance;
16026            } else return instance;
16027          else if (!instance[internalHoistableMarker])
16028            switch (type) {
16029              case "meta":
16030                if (!instance.hasAttribute("itemprop")) break;
16031                return instance;
16032              case "link":
16033                name = instance.getAttribute("rel");
16034                if ("stylesheet" === name && instance.hasAttribute("data-precedence"))
16035                  break;
16036                else if (name !== anyProps.rel || instance.getAttribute("href") !== (null == anyProps.href || "" === anyProps.href ? null : anyProps.href) || instance.getAttribute("crossorigin") !== (null == anyProps.crossOrigin ? null : anyProps.crossOrigin) || instance.getAttribute("title") !== (null == anyProps.title ? null : anyProps.title))
16037                  break;
16038                return instance;
16039              case "style":
16040                if (instance.hasAttribute("data-precedence")) break;
16041                return instance;
16042              case "script":
16043                name = instance.getAttribute("src");
16044                if ((name !== (null == anyProps.src ? null : anyProps.src) || instance.getAttribute("type") !== (null == anyProps.type ? null : anyProps.type) || instance.getAttribute("crossorigin") !== (null == anyProps.crossOrigin ? null : anyProps.crossOrigin)) && name && instance.hasAttribute("async") && !instance.hasAttribute("itemprop"))
16045                  break;
16046                return instance;
16047              default:
16048                return instance;
16049            }
16050          instance = getNextHydratable(instance.nextSibling);
16051          if (null === instance) break;
16052        }
16053        return null;
16054      }
16055      function canHydrateTextInstance(instance, text, inRootOrSingleton) {
16056        if ("" === text) return null;
16057        for (; 3 !== instance.nodeType; ) {
16058          if ((1 !== instance.nodeType || "INPUT" !== instance.nodeName || "hidden" !== instance.type) && !inRootOrSingleton)
16059            return null;
16060          instance = getNextHydratable(instance.nextSibling);
16061          if (null === instance) return null;
16062        }
16063        return instance;
16064      }
16065      function canHydrateHydrationBoundary(instance, inRootOrSingleton) {
16066        for (; 8 !== instance.nodeType; ) {
16067          if ((1 !== instance.nodeType || "INPUT" !== instance.nodeName || "hidden" !== instance.type) && !inRootOrSingleton)
16068            return null;
16069          instance = getNextHydratable(instance.nextSibling);
16070          if (null === instance) return null;
16071        }
16072        return instance;
16073      }
16074      function isSuspenseInstancePending(instance) {
16075        return instance.data === SUSPENSE_PENDING_START_DATA || instance.data === SUSPENSE_QUEUED_START_DATA;
16076      }
16077      function isSuspenseInstanceFallback(instance) {
16078        return instance.data === SUSPENSE_FALLBACK_START_DATA || instance.data === SUSPENSE_PENDING_START_DATA && instance.ownerDocument.readyState !== DOCUMENT_READY_STATE_LOADING;
16079      }
16080      function registerSuspenseInstanceRetry(instance, callback) {
16081        var ownerDocument = instance.ownerDocument;
16082        if (instance.data === SUSPENSE_QUEUED_START_DATA)
16083          instance._reactRetry = callback;
16084        else if (instance.data !== SUSPENSE_PENDING_START_DATA || ownerDocument.readyState !== DOCUMENT_READY_STATE_LOADING)
16085          callback();
16086        else {
16087          var listener = function() {
16088            callback();
16089            ownerDocument.removeEventListener("DOMContentLoaded", listener);
16090          };
16091          ownerDocument.addEventListener("DOMContentLoaded", listener);
16092          instance._reactRetry = listener;
16093        }
16094      }
16095      function getNextHydratable(node) {
16096        for (; null != node; node = node.nextSibling) {
16097          var nodeType = node.nodeType;
16098          if (1 === nodeType || 3 === nodeType) break;
16099          if (8 === nodeType) {
16100            nodeType = node.data;
16101            if (nodeType === SUSPENSE_START_DATA || nodeType === SUSPENSE_FALLBACK_START_DATA || nodeType === SUSPENSE_PENDING_START_DATA || nodeType === SUSPENSE_QUEUED_START_DATA || nodeType === ACTIVITY_START_DATA || nodeType === FORM_STATE_IS_MATCHING || nodeType === FORM_STATE_IS_NOT_MATCHING)
16102              break;
16103            if (nodeType === SUSPENSE_END_DATA || nodeType === ACTIVITY_END_DATA)
16104              return null;
16105          }
16106        }
16107        return node;
16108      }
16109      function describeHydratableInstanceForDevWarnings(instance) {
16110        if (1 === instance.nodeType) {
16111          for (var JSCompiler_temp_const = instance.nodeName.toLowerCase(), serverDifferences = {}, attributes = instance.attributes, i = 0; i < attributes.length; i++) {
16112            var attr = attributes[i];
16113            serverDifferences[getPropNameFromAttributeName(attr.name)] = "style" === attr.name.toLowerCase() ? getStylesObjectFromElement(instance) : attr.value;
16114          }
16115          return { type: JSCompiler_temp_const, props: serverDifferences };
16116        }
16117        return 8 === instance.nodeType ? instance.data === ACTIVITY_START_DATA ? { type: "Activity", props: {} } : { type: "Suspense", props: {} } : instance.nodeValue;
16118      }
16119      function diffHydratedTextForDevWarnings(textInstance, text, parentProps) {
16120        return null === parentProps || true !== parentProps[SUPPRESS_HYDRATION_WARNING] ? (textInstance.nodeValue === text ? textInstance = null : (text = normalizeMarkupForTextOrAttribute(text), textInstance = normalizeMarkupForTextOrAttribute(textInstance.nodeValue) === text ? null : textInstance.nodeValue), textInstance) : null;
16121      }
16122      function getNextHydratableInstanceAfterHydrationBoundary(hydrationInstance) {
16123        hydrationInstance = hydrationInstance.nextSibling;
16124        for (var depth = 0; hydrationInstance; ) {
16125          if (8 === hydrationInstance.nodeType) {
16126            var data = hydrationInstance.data;
16127            if (data === SUSPENSE_END_DATA || data === ACTIVITY_END_DATA) {
16128              if (0 === depth)
16129                return getNextHydratable(hydrationInstance.nextSibling);
16130              depth--;
16131            } else
16132              data !== SUSPENSE_START_DATA && data !== SUSPENSE_FALLBACK_START_DATA && data !== SUSPENSE_PENDING_START_DATA && data !== SUSPENSE_QUEUED_START_DATA && data !== ACTIVITY_START_DATA || depth++;
16133          }
16134          hydrationInstance = hydrationInstance.nextSibling;
16135        }
16136        return null;
16137      }
16138      function getParentHydrationBoundary(targetInstance) {
16139        targetInstance = targetInstance.previousSibling;
16140        for (var depth = 0; targetInstance; ) {
16141          if (8 === targetInstance.nodeType) {
16142            var data = targetInstance.data;
16143            if (data === SUSPENSE_START_DATA || data === SUSPENSE_FALLBACK_START_DATA || data === SUSPENSE_PENDING_START_DATA || data === SUSPENSE_QUEUED_START_DATA || data === ACTIVITY_START_DATA) {
16144              if (0 === depth) return targetInstance;
16145              depth--;
16146            } else
16147              data !== SUSPENSE_END_DATA && data !== ACTIVITY_END_DATA || depth++;
16148          }
16149          targetInstance = targetInstance.previousSibling;
16150        }
16151        return null;
16152      }
16153      function commitHydratedContainer(container) {
16154        retryIfBlockedOn(container);
16155      }
16156      function commitHydratedActivityInstance(activityInstance) {
16157        retryIfBlockedOn(activityInstance);
16158      }
16159      function commitHydratedSuspenseInstance(suspenseInstance) {
16160        retryIfBlockedOn(suspenseInstance);
16161      }
16162      function resolveSingletonInstance(type, props, rootContainerInstance, hostContext, validateDOMNestingDev) {
16163        validateDOMNestingDev && validateDOMNesting(type, hostContext.ancestorInfo);
16164        props = getOwnerDocumentFromRootContainer(rootContainerInstance);
16165        switch (type) {
16166          case "html":
16167            type = props.documentElement;
16168            if (!type)
16169              throw Error(
16170                "React expected an <html> element (document.documentElement) to exist in the Document but one was not found. React never removes the documentElement for any Document it renders into so the cause is likely in some other script running on this page."
16171              );
16172            return type;
16173          case "head":
16174            type = props.head;
16175            if (!type)
16176              throw Error(
16177                "React expected a <head> element (document.head) to exist in the Document but one was not found. React never removes the head for any Document it renders into so the cause is likely in some other script running on this page."
16178              );
16179            return type;
16180          case "body":
16181            type = props.body;
16182            if (!type)
16183              throw Error(
16184                "React expected a <body> element (document.body) to exist in the Document but one was not found. React never removes the body for any Document it renders into so the cause is likely in some other script running on this page."
16185              );
16186            return type;
16187          default:
16188            throw Error(
16189              "resolveSingletonInstance was called with an element type that is not supported. This is a bug in React."
16190            );
16191        }
16192      }
16193      function acquireSingletonInstance(type, props, instance, internalInstanceHandle) {
16194        if (!instance[internalContainerInstanceKey] && getInstanceFromNode(instance)) {
16195          var tagName = instance.tagName.toLowerCase();
16196          console.error(
16197            "You are mounting a new %s component when a previous one has not first unmounted. It is an error to render more than one %s component at a time and attributes and children of these components will likely fail in unpredictable ways. Please only render a single instance of <%s> and if you need to mount a new one, ensure any previous ones have unmounted first.",
16198            tagName,
16199            tagName,
16200            tagName
16201          );
16202        }
16203        switch (type) {
16204          case "html":
16205          case "head":
16206          case "body":
16207            break;
16208          default:
16209            console.error(
16210              "acquireSingletonInstance was called with an element type that is not supported. This is a bug in React."
16211            );
16212        }
16213        for (tagName = instance.attributes; tagName.length; )
16214          instance.removeAttributeNode(tagName[0]);
16215        setInitialProperties(instance, type, props);
16216        instance[internalInstanceKey] = internalInstanceHandle;
16217        instance[internalPropsKey] = props;
16218      }
16219      function releaseSingletonInstance(instance) {
16220        for (var attributes = instance.attributes; attributes.length; )
16221          instance.removeAttributeNode(attributes[0]);
16222        detachDeletedInstance(instance);
16223      }
16224      function getHoistableRoot(container) {
16225        return "function" === typeof container.getRootNode ? container.getRootNode() : 9 === container.nodeType ? container : container.ownerDocument;
16226      }
16227      function preconnectAs(rel, href, crossOrigin) {
16228        var ownerDocument = globalDocument;
16229        if (ownerDocument && "string" === typeof href && href) {
16230          var limitedEscapedHref = escapeSelectorAttributeValueInsideDoubleQuotes(href);
16231          limitedEscapedHref = 'link[rel="' + rel + '"][href="' + limitedEscapedHref + '"]';
16232          "string" === typeof crossOrigin && (limitedEscapedHref += '[crossorigin="' + crossOrigin + '"]');
16233          preconnectsSet.has(limitedEscapedHref) || (preconnectsSet.add(limitedEscapedHref), rel = { rel, crossOrigin, href }, null === ownerDocument.querySelector(limitedEscapedHref) && (href = ownerDocument.createElement("link"), setInitialProperties(href, "link", rel), markNodeAsHoistable(href), ownerDocument.head.appendChild(href)));
16234        }
16235      }
16236      function getResource(type, currentProps, pendingProps, currentResource) {
16237        var resourceRoot = (resourceRoot = rootInstanceStackCursor.current) ? getHoistableRoot(resourceRoot) : null;
16238        if (!resourceRoot)
16239          throw Error(
16240            '"resourceRoot" was expected to exist. This is a bug in React.'
16241          );
16242        switch (type) {
16243          case "meta":
16244          case "title":
16245            return null;
16246          case "style":
16247            return "string" === typeof pendingProps.precedence && "string" === typeof pendingProps.href ? (pendingProps = getStyleKey(pendingProps.href), currentProps = getResourcesFromRoot(resourceRoot).hoistableStyles, currentResource = currentProps.get(pendingProps), currentResource || (currentResource = {
16248              type: "style",
16249              instance: null,
16250              count: 0,
16251              state: null
16252            }, currentProps.set(pendingProps, currentResource)), currentResource) : { type: "void", instance: null, count: 0, state: null };
16253          case "link":
16254            if ("stylesheet" === pendingProps.rel && "string" === typeof pendingProps.href && "string" === typeof pendingProps.precedence) {
16255              type = getStyleKey(pendingProps.href);
16256              var _styles = getResourcesFromRoot(resourceRoot).hoistableStyles, _resource = _styles.get(type);
16257              if (!_resource && (resourceRoot = resourceRoot.ownerDocument || resourceRoot, _resource = {
16258                type: "stylesheet",
16259                instance: null,
16260                count: 0,
16261                state: { loading: NotLoaded, preload: null }
16262              }, _styles.set(type, _resource), (_styles = resourceRoot.querySelector(
16263                getStylesheetSelectorFromKey(type)
16264              )) && !_styles._p && (_resource.instance = _styles, _resource.state.loading = Loaded | Inserted), !preloadPropsMap.has(type))) {
16265                var preloadProps = {
16266                  rel: "preload",
16267                  as: "style",
16268                  href: pendingProps.href,
16269                  crossOrigin: pendingProps.crossOrigin,
16270                  integrity: pendingProps.integrity,
16271                  media: pendingProps.media,
16272                  hrefLang: pendingProps.hrefLang,
16273                  referrerPolicy: pendingProps.referrerPolicy
16274                };
16275                preloadPropsMap.set(type, preloadProps);
16276                _styles || preloadStylesheet(
16277                  resourceRoot,
16278                  type,
16279                  preloadProps,
16280                  _resource.state
16281                );
16282              }
16283              if (currentProps && null === currentResource)
16284                throw pendingProps = "\n\n  - " + describeLinkForResourceErrorDEV(currentProps) + "\n  + " + describeLinkForResourceErrorDEV(pendingProps), Error(
16285                  "Expected <link> not to update to be updated to a stylesheet with precedence. Check the `rel`, `href`, and `precedence` props of this component. Alternatively, check whether two different <link> components render in the same slot or share the same key." + pendingProps
16286                );
16287              return _resource;
16288            }
16289            if (currentProps && null !== currentResource)
16290              throw pendingProps = "\n\n  - " + describeLinkForResourceErrorDEV(currentProps) + "\n  + " + describeLinkForResourceErrorDEV(pendingProps), Error(
16291                "Expected stylesheet with precedence to not be updated to a different kind of <link>. Check the `rel`, `href`, and `precedence` props of this component. Alternatively, check whether two different <link> components render in the same slot or share the same key." + pendingProps
16292              );
16293            return null;
16294          case "script":
16295            return currentProps = pendingProps.async, pendingProps = pendingProps.src, "string" === typeof pendingProps && currentProps && "function" !== typeof currentProps && "symbol" !== typeof currentProps ? (pendingProps = getScriptKey(pendingProps), currentProps = getResourcesFromRoot(resourceRoot).hoistableScripts, currentResource = currentProps.get(pendingProps), currentResource || (currentResource = {
16296              type: "script",
16297              instance: null,
16298              count: 0,
16299              state: null
16300            }, currentProps.set(pendingProps, currentResource)), currentResource) : { type: "void", instance: null, count: 0, state: null };
16301          default:
16302            throw Error(
16303              'getResource encountered a type it did not expect: "' + type + '". this is a bug in React.'
16304            );
16305        }
16306      }
16307      function describeLinkForResourceErrorDEV(props) {
16308        var describedProps = 0, description = "<link";
16309        "string" === typeof props.rel ? (describedProps++, description += ' rel="' + props.rel + '"') : hasOwnProperty.call(props, "rel") && (describedProps++, description += ' rel="' + (null === props.rel ? "null" : "invalid type " + typeof props.rel) + '"');
16310        "string" === typeof props.href ? (describedProps++, description += ' href="' + props.href + '"') : hasOwnProperty.call(props, "href") && (describedProps++, description += ' href="' + (null === props.href ? "null" : "invalid type " + typeof props.href) + '"');
16311        "string" === typeof props.precedence ? (describedProps++, description += ' precedence="' + props.precedence + '"') : hasOwnProperty.call(props, "precedence") && (describedProps++, description += " precedence={" + (null === props.precedence ? "null" : "invalid type " + typeof props.precedence) + "}");
16312        Object.getOwnPropertyNames(props).length > describedProps && (description += " ...");
16313        return description + " />";
16314      }
16315      function getStyleKey(href) {
16316        return 'href="' + escapeSelectorAttributeValueInsideDoubleQuotes(href) + '"';
16317      }
16318      function getStylesheetSelectorFromKey(key) {
16319        return 'link[rel="stylesheet"][' + key + "]";
16320      }
16321      function stylesheetPropsFromRawProps(rawProps) {
16322        return assign({}, rawProps, {
16323          "data-precedence": rawProps.precedence,
16324          precedence: null
16325        });
16326      }
16327      function preloadStylesheet(ownerDocument, key, preloadProps, state) {
16328        ownerDocument.querySelector(
16329          'link[rel="preload"][as="style"][' + key + "]"
16330        ) ? state.loading = Loaded : (key = ownerDocument.createElement("link"), state.preload = key, key.addEventListener("load", function() {
16331          return state.loading |= Loaded;
16332        }), key.addEventListener("error", function() {
16333          return state.loading |= Errored;
16334        }), setInitialProperties(key, "link", preloadProps), markNodeAsHoistable(key), ownerDocument.head.appendChild(key));
16335      }
16336      function getScriptKey(src) {
16337        return '[src="' + escapeSelectorAttributeValueInsideDoubleQuotes(src) + '"]';
16338      }
16339      function getScriptSelectorFromKey(key) {
16340        return "script[async]" + key;
16341      }
16342      function acquireResource(hoistableRoot, resource, props) {
16343        resource.count++;
16344        if (null === resource.instance)
16345          switch (resource.type) {
16346            case "style":
16347              var instance = hoistableRoot.querySelector(
16348                'style[data-href~="' + escapeSelectorAttributeValueInsideDoubleQuotes(props.href) + '"]'
16349              );
16350              if (instance)
16351                return resource.instance = instance, markNodeAsHoistable(instance), instance;
16352              var styleProps = assign({}, props, {
16353                "data-href": props.href,
16354                "data-precedence": props.precedence,
16355                href: null,
16356                precedence: null
16357              });
16358              instance = (hoistableRoot.ownerDocument || hoistableRoot).createElement("style");
16359              markNodeAsHoistable(instance);
16360              setInitialProperties(instance, "style", styleProps);
16361              insertStylesheet(instance, props.precedence, hoistableRoot);
16362              return resource.instance = instance;
16363            case "stylesheet":
16364              styleProps = getStyleKey(props.href);
16365              var _instance = hoistableRoot.querySelector(
16366                getStylesheetSelectorFromKey(styleProps)
16367              );
16368              if (_instance)
16369                return resource.state.loading |= Inserted, resource.instance = _instance, markNodeAsHoistable(_instance), _instance;
16370              instance = stylesheetPropsFromRawProps(props);
16371              (styleProps = preloadPropsMap.get(styleProps)) && adoptPreloadPropsForStylesheet(instance, styleProps);
16372              _instance = (hoistableRoot.ownerDocument || hoistableRoot).createElement("link");
16373              markNodeAsHoistable(_instance);
16374              var linkInstance = _instance;
16375              linkInstance._p = new Promise(function(resolve, reject) {
16376                linkInstance.onload = resolve;
16377                linkInstance.onerror = reject;
16378              });
16379              setInitialProperties(_instance, "link", instance);
16380              resource.state.loading |= Inserted;
16381              insertStylesheet(_instance, props.precedence, hoistableRoot);
16382              return resource.instance = _instance;
16383            case "script":
16384              _instance = getScriptKey(props.src);
16385              if (styleProps = hoistableRoot.querySelector(
16386                getScriptSelectorFromKey(_instance)
16387              ))
16388                return resource.instance = styleProps, markNodeAsHoistable(styleProps), styleProps;
16389              instance = props;
16390              if (styleProps = preloadPropsMap.get(_instance))
16391                instance = assign({}, props), adoptPreloadPropsForScript(instance, styleProps);
16392              hoistableRoot = hoistableRoot.ownerDocument || hoistableRoot;
16393              styleProps = hoistableRoot.createElement("script");
16394              markNodeAsHoistable(styleProps);
16395              setInitialProperties(styleProps, "link", instance);
16396              hoistableRoot.head.appendChild(styleProps);
16397              return resource.instance = styleProps;
16398            case "void":
16399              return null;
16400            default:
16401              throw Error(
16402                'acquireResource encountered a resource type it did not expect: "' + resource.type + '". this is a bug in React.'
16403              );
16404          }
16405        else
16406          "stylesheet" === resource.type && (resource.state.loading & Inserted) === NotLoaded && (instance = resource.instance, resource.state.loading |= Inserted, insertStylesheet(instance, props.precedence, hoistableRoot));
16407        return resource.instance;
16408      }
16409      function insertStylesheet(instance, precedence, root2) {
16410        for (var nodes = root2.querySelectorAll(
16411          'link[rel="stylesheet"][data-precedence],style[data-precedence]'
16412        ), last = nodes.length ? nodes[nodes.length - 1] : null, prior = last, i = 0; i < nodes.length; i++) {
16413          var node = nodes[i];
16414          if (node.dataset.precedence === precedence) prior = node;
16415          else if (prior !== last) break;
16416        }
16417        prior ? prior.parentNode.insertBefore(instance, prior.nextSibling) : (precedence = 9 === root2.nodeType ? root2.head : root2, precedence.insertBefore(instance, precedence.firstChild));
16418      }
16419      function adoptPreloadPropsForStylesheet(stylesheetProps, preloadProps) {
16420        null == stylesheetProps.crossOrigin && (stylesheetProps.crossOrigin = preloadProps.crossOrigin);
16421        null == stylesheetProps.referrerPolicy && (stylesheetProps.referrerPolicy = preloadProps.referrerPolicy);
16422        null == stylesheetProps.title && (stylesheetProps.title = preloadProps.title);
16423      }
16424      function adoptPreloadPropsForScript(scriptProps, preloadProps) {
16425        null == scriptProps.crossOrigin && (scriptProps.crossOrigin = preloadProps.crossOrigin);
16426        null == scriptProps.referrerPolicy && (scriptProps.referrerPolicy = preloadProps.referrerPolicy);
16427        null == scriptProps.integrity && (scriptProps.integrity = preloadProps.integrity);
16428      }
16429      function getHydratableHoistableCache(type, keyAttribute, ownerDocument) {
16430        if (null === tagCaches) {
16431          var cache = /* @__PURE__ */ new Map();
16432          var caches = tagCaches = /* @__PURE__ */ new Map();
16433          caches.set(ownerDocument, cache);
16434        } else
16435          caches = tagCaches, cache = caches.get(ownerDocument), cache || (cache = /* @__PURE__ */ new Map(), caches.set(ownerDocument, cache));
16436        if (cache.has(type)) return cache;
16437        cache.set(type, null);
16438        ownerDocument = ownerDocument.getElementsByTagName(type);
16439        for (caches = 0; caches < ownerDocument.length; caches++) {
16440          var node = ownerDocument[caches];
16441          if (!(node[internalHoistableMarker] || node[internalInstanceKey] || "link" === type && "stylesheet" === node.getAttribute("rel")) && node.namespaceURI !== SVG_NAMESPACE) {
16442            var nodeKey = node.getAttribute(keyAttribute) || "";
16443            nodeKey = type + nodeKey;
16444            var existing = cache.get(nodeKey);
16445            existing ? existing.push(node) : cache.set(nodeKey, [node]);
16446          }
16447        }
16448        return cache;
16449      }
16450      function mountHoistable(hoistableRoot, type, instance) {
16451        hoistableRoot = hoistableRoot.ownerDocument || hoistableRoot;
16452        hoistableRoot.head.insertBefore(
16453          instance,
16454          "title" === type ? hoistableRoot.querySelector("head > title") : null
16455        );
16456      }
16457      function isHostHoistableType(type, props, hostContext) {
16458        var outsideHostContainerContext = !hostContext.ancestorInfo.containerTagInScope;
16459        if (hostContext.context === HostContextNamespaceSvg || null != props.itemProp)
16460          return !outsideHostContainerContext || null == props.itemProp || "meta" !== type && "title" !== type && "style" !== type && "link" !== type && "script" !== type || console.error(
16461            "Cannot render a <%s> outside the main document if it has an `itemProp` prop. `itemProp` suggests the tag belongs to an `itemScope` which can appear anywhere in the DOM. If you were intending for React to hoist this <%s> remove the `itemProp` prop. Otherwise, try moving this tag into the <head> or <body> of the Document.",
16462            type,
16463            type
16464          ), false;
16465        switch (type) {
16466          case "meta":
16467          case "title":
16468            return true;
16469          case "style":
16470            if ("string" !== typeof props.precedence || "string" !== typeof props.href || "" === props.href) {
16471              outsideHostContainerContext && console.error(
16472                'Cannot render a <style> outside the main document without knowing its precedence and a unique href key. React can hoist and deduplicate <style> tags if you provide a `precedence` prop along with an `href` prop that does not conflict with the `href` values used in any other hoisted <style> or <link rel="stylesheet" ...> tags.  Note that hoisting <style> tags is considered an advanced feature that most will not use directly. Consider moving the <style> tag to the <head> or consider adding a `precedence="default"` and `href="some unique resource identifier"`.'
16473              );
16474              break;
16475            }
16476            return true;
16477          case "link":
16478            if ("string" !== typeof props.rel || "string" !== typeof props.href || "" === props.href || props.onLoad || props.onError) {
16479              if ("stylesheet" === props.rel && "string" === typeof props.precedence) {
16480                type = props.href;
16481                var onError = props.onError, disabled = props.disabled;
16482                hostContext = [];
16483                props.onLoad && hostContext.push("`onLoad`");
16484                onError && hostContext.push("`onError`");
16485                null != disabled && hostContext.push("`disabled`");
16486                onError = propNamesListJoin(hostContext, "and");
16487                onError += 1 === hostContext.length ? " prop" : " props";
16488                disabled = 1 === hostContext.length ? "an " + onError : "the " + onError;
16489                hostContext.length && console.error(
16490                  'React encountered a <link rel="stylesheet" href="%s" ... /> with a `precedence` prop that also included %s. The presence of loading and error handlers indicates an intent to manage the stylesheet loading state from your from your Component code and React will not hoist or deduplicate this stylesheet. If your intent was to have React hoist and deduplciate this stylesheet using the `precedence` prop remove the %s, otherwise remove the `precedence` prop.',
16491                  type,
16492                  disabled,
16493                  onError
16494                );
16495              }
16496              outsideHostContainerContext && ("string" !== typeof props.rel || "string" !== typeof props.href || "" === props.href ? console.error(
16497                "Cannot render a <link> outside the main document without a `rel` and `href` prop. Try adding a `rel` and/or `href` prop to this <link> or moving the link into the <head> tag"
16498              ) : (props.onError || props.onLoad) && console.error(
16499                "Cannot render a <link> with onLoad or onError listeners outside the main document. Try removing onLoad={...} and onError={...} or moving it into the root <head> tag or somewhere in the <body>."
16500              ));
16501              break;
16502            }
16503            switch (props.rel) {
16504              case "stylesheet":
16505                return type = props.precedence, props = props.disabled, "string" !== typeof type && outsideHostContainerContext && console.error(
16506                  'Cannot render a <link rel="stylesheet" /> outside the main document without knowing its precedence. Consider adding precedence="default" or moving it into the root <head> tag.'
16507                ), "string" === typeof type && null == props;
16508              default:
16509                return true;
16510            }
16511          case "script":
16512            type = props.async && "function" !== typeof props.async && "symbol" !== typeof props.async;
16513            if (!type || props.onLoad || props.onError || !props.src || "string" !== typeof props.src) {
16514              outsideHostContainerContext && (type ? props.onLoad || props.onError ? console.error(
16515                "Cannot render a <script> with onLoad or onError listeners outside the main document. Try removing onLoad={...} and onError={...} or moving it into the root <head> tag or somewhere in the <body>."
16516              ) : console.error(
16517                "Cannot render a <script> outside the main document without `async={true}` and a non-empty `src` prop. Ensure there is a valid `src` and either make the script async or move it into the root <head> tag or somewhere in the <body>."
16518              ) : console.error(
16519                'Cannot render a sync or defer <script> outside the main document without knowing its order. Try adding async="" or moving it into the root <head> tag.'
16520              ));
16521              break;
16522            }
16523            return true;
16524          case "noscript":
16525          case "template":
16526            outsideHostContainerContext && console.error(
16527              "Cannot render <%s> outside the main document. Try moving it into the root <head> tag.",
16528              type
16529            );
16530        }
16531        return false;
16532      }
16533      function preloadResource(resource) {
16534        return "stylesheet" === resource.type && (resource.state.loading & Settled) === NotLoaded ? false : true;
16535      }
16536      function suspendResource(state, hoistableRoot, resource, props) {
16537        if ("stylesheet" === resource.type && ("string" !== typeof props.media || false !== matchMedia(props.media).matches) && (resource.state.loading & Inserted) === NotLoaded) {
16538          if (null === resource.instance) {
16539            var key = getStyleKey(props.href), instance = hoistableRoot.querySelector(
16540              getStylesheetSelectorFromKey(key)
16541            );
16542            if (instance) {
16543              hoistableRoot = instance._p;
16544              null !== hoistableRoot && "object" === typeof hoistableRoot && "function" === typeof hoistableRoot.then && (state.count++, state = onUnsuspend.bind(state), hoistableRoot.then(state, state));
16545              resource.state.loading |= Inserted;
16546              resource.instance = instance;
16547              markNodeAsHoistable(instance);
16548              return;
16549            }
16550            instance = hoistableRoot.ownerDocument || hoistableRoot;
16551            props = stylesheetPropsFromRawProps(props);
16552            (key = preloadPropsMap.get(key)) && adoptPreloadPropsForStylesheet(props, key);
16553            instance = instance.createElement("link");
16554            markNodeAsHoistable(instance);
16555            var linkInstance = instance;
16556            linkInstance._p = new Promise(function(resolve, reject) {
16557              linkInstance.onload = resolve;
16558              linkInstance.onerror = reject;
16559            });
16560            setInitialProperties(instance, "link", props);
16561            resource.instance = instance;
16562          }
16563          null === state.stylesheets && (state.stylesheets = /* @__PURE__ */ new Map());
16564          state.stylesheets.set(resource, hoistableRoot);
16565          (hoistableRoot = resource.state.preload) && (resource.state.loading & Settled) === NotLoaded && (state.count++, resource = onUnsuspend.bind(state), hoistableRoot.addEventListener("load", resource), hoistableRoot.addEventListener("error", resource));
16566        }
16567      }
16568      function waitForCommitToBeReady(state, timeoutOffset) {
16569        state.stylesheets && 0 === state.count && insertSuspendedStylesheets(state, state.stylesheets);
16570        return 0 < state.count || 0 < state.imgCount ? function(commit) {
16571          var stylesheetTimer = setTimeout(function() {
16572            state.stylesheets && insertSuspendedStylesheets(state, state.stylesheets);
16573            if (state.unsuspend) {
16574              var unsuspend = state.unsuspend;
16575              state.unsuspend = null;
16576              unsuspend();
16577            }
16578          }, SUSPENSEY_STYLESHEET_TIMEOUT + timeoutOffset);
16579          0 < state.imgBytes && 0 === estimatedBytesWithinLimit && (estimatedBytesWithinLimit = 125 * estimateBandwidth() * SUSPENSEY_IMAGE_TIME_ESTIMATE);
16580          var imgTimer = setTimeout(
16581            function() {
16582              state.waitingForImages = false;
16583              if (0 === state.count && (state.stylesheets && insertSuspendedStylesheets(state, state.stylesheets), state.unsuspend)) {
16584                var unsuspend = state.unsuspend;
16585                state.unsuspend = null;
16586                unsuspend();
16587              }
16588            },
16589            (state.imgBytes > estimatedBytesWithinLimit ? 50 : SUSPENSEY_IMAGE_TIMEOUT) + timeoutOffset
16590          );
16591          state.unsuspend = commit;
16592          return function() {
16593            state.unsuspend = null;
16594            clearTimeout(stylesheetTimer);
16595            clearTimeout(imgTimer);
16596          };
16597        } : null;
16598      }
16599      function onUnsuspend() {
16600        this.count--;
16601        if (0 === this.count && (0 === this.imgCount || !this.waitingForImages)) {
16602          if (this.stylesheets)
16603            insertSuspendedStylesheets(this, this.stylesheets);
16604          else if (this.unsuspend) {
16605            var unsuspend = this.unsuspend;
16606            this.unsuspend = null;
16607            unsuspend();
16608          }
16609        }
16610      }
16611      function insertSuspendedStylesheets(state, resources) {
16612        state.stylesheets = null;
16613        null !== state.unsuspend && (state.count++, precedencesByRoot = /* @__PURE__ */ new Map(), resources.forEach(insertStylesheetIntoRoot, state), precedencesByRoot = null, onUnsuspend.call(state));
16614      }
16615      function insertStylesheetIntoRoot(root2, resource) {
16616        if (!(resource.state.loading & Inserted)) {
16617          var precedences = precedencesByRoot.get(root2);
16618          if (precedences) var last = precedences.get(LAST_PRECEDENCE);
16619          else {
16620            precedences = /* @__PURE__ */ new Map();
16621            precedencesByRoot.set(root2, precedences);
16622            for (var nodes = root2.querySelectorAll(
16623              "link[data-precedence],style[data-precedence]"
16624            ), i = 0; i < nodes.length; i++) {
16625              var node = nodes[i];
16626              if ("LINK" === node.nodeName || "not all" !== node.getAttribute("media"))
16627                precedences.set(node.dataset.precedence, node), last = node;
16628            }
16629            last && precedences.set(LAST_PRECEDENCE, last);
16630          }
16631          nodes = resource.instance;
16632          node = nodes.getAttribute("data-precedence");
16633          i = precedences.get(node) || last;
16634          i === last && precedences.set(LAST_PRECEDENCE, nodes);
16635          precedences.set(node, nodes);
16636          this.count++;
16637          last = onUnsuspend.bind(this);
16638          nodes.addEventListener("load", last);
16639          nodes.addEventListener("error", last);
16640          i ? i.parentNode.insertBefore(nodes, i.nextSibling) : (root2 = 9 === root2.nodeType ? root2.head : root2, root2.insertBefore(nodes, root2.firstChild));
16641          resource.state.loading |= Inserted;
16642        }
16643      }
16644      function FiberRootNode(containerInfo, tag, hydrate, identifierPrefix, onUncaughtError, onCaughtError, onRecoverableError, onDefaultTransitionIndicator, formState) {
16645        this.tag = 1;
16646        this.containerInfo = containerInfo;
16647        this.pingCache = this.current = this.pendingChildren = null;
16648        this.timeoutHandle = noTimeout;
16649        this.callbackNode = this.next = this.pendingContext = this.context = this.cancelPendingCommit = null;
16650        this.callbackPriority = 0;
16651        this.expirationTimes = createLaneMap(-1);
16652        this.entangledLanes = this.shellSuspendCounter = this.errorRecoveryDisabledLanes = this.expiredLanes = this.warmLanes = this.pingedLanes = this.suspendedLanes = this.pendingLanes = 0;
16653        this.entanglements = createLaneMap(0);
16654        this.hiddenUpdates = createLaneMap(null);
16655        this.identifierPrefix = identifierPrefix;
16656        this.onUncaughtError = onUncaughtError;
16657        this.onCaughtError = onCaughtError;
16658        this.onRecoverableError = onRecoverableError;
16659        this.pooledCache = null;
16660        this.pooledCacheLanes = 0;
16661        this.formState = formState;
16662        this.incompleteTransitions = /* @__PURE__ */ new Map();
16663        this.passiveEffectDuration = this.effectDuration = -0;
16664        this.memoizedUpdaters = /* @__PURE__ */ new Set();
16665        containerInfo = this.pendingUpdatersLaneMap = [];
16666        for (tag = 0; 31 > tag; tag++) containerInfo.push(/* @__PURE__ */ new Set());
16667        this._debugRootType = hydrate ? "hydrateRoot()" : "createRoot()";
16668      }
16669      function createFiberRoot(containerInfo, tag, hydrate, initialChildren, hydrationCallbacks, isStrictMode, identifierPrefix, formState, onUncaughtError, onCaughtError, onRecoverableError, onDefaultTransitionIndicator) {
16670        containerInfo = new FiberRootNode(
16671          containerInfo,
16672          tag,
16673          hydrate,
16674          identifierPrefix,
16675          onUncaughtError,
16676          onCaughtError,
16677          onRecoverableError,
16678          onDefaultTransitionIndicator,
16679          formState
16680        );
16681        tag = ConcurrentMode;
16682        true === isStrictMode && (tag |= StrictLegacyMode | StrictEffectsMode);
16683        tag |= ProfileMode;
16684        isStrictMode = createFiber(3, null, null, tag);
16685        containerInfo.current = isStrictMode;
16686        isStrictMode.stateNode = containerInfo;
16687        tag = createCache();
16688        retainCache(tag);
16689        containerInfo.pooledCache = tag;
16690        retainCache(tag);
16691        isStrictMode.memoizedState = {
16692          element: initialChildren,
16693          isDehydrated: hydrate,
16694          cache: tag
16695        };
16696        initializeUpdateQueue(isStrictMode);
16697        return containerInfo;
16698      }
16699      function getContextForSubtree(parentComponent) {
16700        if (!parentComponent) return emptyContextObject;
16701        parentComponent = emptyContextObject;
16702        return parentComponent;
16703      }
16704      function updateContainerImpl(rootFiber, lane, element, container, parentComponent, callback) {
16705        if (injectedHook && "function" === typeof injectedHook.onScheduleFiberRoot)
16706          try {
16707            injectedHook.onScheduleFiberRoot(rendererID, container, element);
16708          } catch (err) {
16709            hasLoggedError || (hasLoggedError = true, console.error(
16710              "React instrumentation encountered an error: %o",
16711              err
16712            ));
16713          }
16714        parentComponent = getContextForSubtree(parentComponent);
16715        null === container.context ? container.context = parentComponent : container.pendingContext = parentComponent;
16716        isRendering && null !== current && !didWarnAboutNestedUpdates && (didWarnAboutNestedUpdates = true, console.error(
16717          "Render methods should be a pure function of props and state; triggering nested component updates from render is not allowed. If necessary, trigger nested updates in componentDidUpdate.\n\nCheck the render method of %s.",
16718          getComponentNameFromFiber(current) || "Unknown"
16719        ));
16720        container = createUpdate(lane);
16721        container.payload = { element };
16722        callback = void 0 === callback ? null : callback;
16723        null !== callback && ("function" !== typeof callback && console.error(
16724          "Expected the last optional `callback` argument to be a function. Instead received: %s.",
16725          callback
16726        ), container.callback = callback);
16727        element = enqueueUpdate(rootFiber, container, lane);
16728        null !== element && (startUpdateTimerByLane(lane, "root.render()", null), scheduleUpdateOnFiber(element, rootFiber, lane), entangleTransitions(element, rootFiber, lane));
16729      }
16730      function markRetryLaneImpl(fiber, retryLane) {
16731        fiber = fiber.memoizedState;
16732        if (null !== fiber && null !== fiber.dehydrated) {
16733          var a = fiber.retryLane;
16734          fiber.retryLane = 0 !== a && a < retryLane ? a : retryLane;
16735        }
16736      }
16737      function markRetryLaneIfNotHydrated(fiber, retryLane) {
16738        markRetryLaneImpl(fiber, retryLane);
16739        (fiber = fiber.alternate) && markRetryLaneImpl(fiber, retryLane);
16740      }
16741      function attemptContinuousHydration(fiber) {
16742        if (13 === fiber.tag || 31 === fiber.tag) {
16743          var root2 = enqueueConcurrentRenderForLane(fiber, 67108864);
16744          null !== root2 && scheduleUpdateOnFiber(root2, fiber, 67108864);
16745          markRetryLaneIfNotHydrated(fiber, 67108864);
16746        }
16747      }
16748      function attemptHydrationAtCurrentPriority(fiber) {
16749        if (13 === fiber.tag || 31 === fiber.tag) {
16750          var lane = requestUpdateLane(fiber);
16751          lane = getBumpedLaneForHydrationByLane(lane);
16752          var root2 = enqueueConcurrentRenderForLane(fiber, lane);
16753          null !== root2 && scheduleUpdateOnFiber(root2, fiber, lane);
16754          markRetryLaneIfNotHydrated(fiber, lane);
16755        }
16756      }
16757      function getCurrentFiberForDevTools() {
16758        return current;
16759      }
16760      function dispatchDiscreteEvent(domEventName, eventSystemFlags, container, nativeEvent) {
16761        var prevTransition = ReactSharedInternals.T;
16762        ReactSharedInternals.T = null;
16763        var previousPriority = ReactDOMSharedInternals.p;
16764        try {
16765          ReactDOMSharedInternals.p = DiscreteEventPriority, dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
16766        } finally {
16767          ReactDOMSharedInternals.p = previousPriority, ReactSharedInternals.T = prevTransition;
16768        }
16769      }
16770      function dispatchContinuousEvent(domEventName, eventSystemFlags, container, nativeEvent) {
16771        var prevTransition = ReactSharedInternals.T;
16772        ReactSharedInternals.T = null;
16773        var previousPriority = ReactDOMSharedInternals.p;
16774        try {
16775          ReactDOMSharedInternals.p = ContinuousEventPriority, dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
16776        } finally {
16777          ReactDOMSharedInternals.p = previousPriority, ReactSharedInternals.T = prevTransition;
16778        }
16779      }
16780      function dispatchEvent(domEventName, eventSystemFlags, targetContainer, nativeEvent) {
16781        if (_enabled) {
16782          var blockedOn = findInstanceBlockingEvent(nativeEvent);
16783          if (null === blockedOn)
16784            dispatchEventForPluginEventSystem(
16785              domEventName,
16786              eventSystemFlags,
16787              nativeEvent,
16788              return_targetInst,
16789              targetContainer
16790            ), clearIfContinuousEvent(domEventName, nativeEvent);
16791          else if (queueIfContinuousEvent(
16792            blockedOn,
16793            domEventName,
16794            eventSystemFlags,
16795            targetContainer,
16796            nativeEvent
16797          ))
16798            nativeEvent.stopPropagation();
16799          else if (clearIfContinuousEvent(domEventName, nativeEvent), eventSystemFlags & 4 && -1 < discreteReplayableEvents.indexOf(domEventName)) {
16800            for (; null !== blockedOn; ) {
16801              var fiber = getInstanceFromNode(blockedOn);
16802              if (null !== fiber)
16803                switch (fiber.tag) {
16804                  case 3:
16805                    fiber = fiber.stateNode;
16806                    if (fiber.current.memoizedState.isDehydrated) {
16807                      var lanes = getHighestPriorityLanes(fiber.pendingLanes);
16808                      if (0 !== lanes) {
16809                        var root2 = fiber;
16810                        root2.pendingLanes |= 2;
16811                        for (root2.entangledLanes |= 2; lanes; ) {
16812                          var lane = 1 << 31 - clz32(lanes);
16813                          root2.entanglements[1] |= lane;
16814                          lanes &= ~lane;
16815                        }
16816                        ensureRootIsScheduled(fiber);
16817                        (executionContext & (RenderContext | CommitContext)) === NoContext && (workInProgressRootRenderTargetTime = now$1() + RENDER_TIMEOUT_MS, flushSyncWorkAcrossRoots_impl(0, false));
16818                      }
16819                    }
16820                    break;
16821                  case 31:
16822                  case 13:
16823                    root2 = enqueueConcurrentRenderForLane(fiber, 2), null !== root2 && scheduleUpdateOnFiber(root2, fiber, 2), flushSyncWork$1(), markRetryLaneIfNotHydrated(fiber, 2);
16824                }
16825              fiber = findInstanceBlockingEvent(nativeEvent);
16826              null === fiber && dispatchEventForPluginEventSystem(
16827                domEventName,
16828                eventSystemFlags,
16829                nativeEvent,
16830                return_targetInst,
16831                targetContainer
16832              );
16833              if (fiber === blockedOn) break;
16834              blockedOn = fiber;
16835            }
16836            null !== blockedOn && nativeEvent.stopPropagation();
16837          } else
16838            dispatchEventForPluginEventSystem(
16839              domEventName,
16840              eventSystemFlags,
16841              nativeEvent,
16842              null,
16843              targetContainer
16844            );
16845        }
16846      }
16847      function findInstanceBlockingEvent(nativeEvent) {
16848        nativeEvent = getEventTarget(nativeEvent);
16849        return findInstanceBlockingTarget(nativeEvent);
16850      }
16851      function findInstanceBlockingTarget(targetNode) {
16852        return_targetInst = null;
16853        targetNode = getClosestInstanceFromNode(targetNode);
16854        if (null !== targetNode) {
16855          var nearestMounted = getNearestMountedFiber(targetNode);
16856          if (null === nearestMounted) targetNode = null;
16857          else {
16858            var tag = nearestMounted.tag;
16859            if (13 === tag) {
16860              targetNode = getSuspenseInstanceFromFiber(nearestMounted);
16861              if (null !== targetNode) return targetNode;
16862              targetNode = null;
16863            } else if (31 === tag) {
16864              targetNode = getActivityInstanceFromFiber(nearestMounted);
16865              if (null !== targetNode) return targetNode;
16866              targetNode = null;
16867            } else if (3 === tag) {
16868              if (nearestMounted.stateNode.current.memoizedState.isDehydrated)
16869                return 3 === nearestMounted.tag ? nearestMounted.stateNode.containerInfo : null;
16870              targetNode = null;
16871            } else nearestMounted !== targetNode && (targetNode = null);
16872          }
16873        }
16874        return_targetInst = targetNode;
16875        return null;
16876      }
16877      function getEventPriority(domEventName) {
16878        switch (domEventName) {
16879          case "beforetoggle":
16880          case "cancel":
16881          case "click":
16882          case "close":
16883          case "contextmenu":
16884          case "copy":
16885          case "cut":
16886          case "auxclick":
16887          case "dblclick":
16888          case "dragend":
16889          case "dragstart":
16890          case "drop":
16891          case "focusin":
16892          case "focusout":
16893          case "input":
16894          case "invalid":
16895          case "keydown":
16896          case "keypress":
16897          case "keyup":
16898          case "mousedown":
16899          case "mouseup":
16900          case "paste":
16901          case "pause":
16902          case "play":
16903          case "pointercancel":
16904          case "pointerdown":
16905          case "pointerup":
16906          case "ratechange":
16907          case "reset":
16908          case "resize":
16909          case "seeked":
16910          case "submit":
16911          case "toggle":
16912          case "touchcancel":
16913          case "touchend":
16914          case "touchstart":
16915          case "volumechange":
16916          case "change":
16917          case "selectionchange":
16918          case "textInput":
16919          case "compositionstart":
16920          case "compositionend":
16921          case "compositionupdate":
16922          case "beforeblur":
16923          case "afterblur":
16924          case "beforeinput":
16925          case "blur":
16926          case "fullscreenchange":
16927          case "focus":
16928          case "hashchange":
16929          case "popstate":
16930          case "select":
16931          case "selectstart":
16932            return DiscreteEventPriority;
16933          case "drag":
16934          case "dragenter":
16935          case "dragexit":
16936          case "dragleave":
16937          case "dragover":
16938          case "mousemove":
16939          case "mouseout":
16940          case "mouseover":
16941          case "pointermove":
16942          case "pointerout":
16943          case "pointerover":
16944          case "scroll":
16945          case "touchmove":
16946          case "wheel":
16947          case "mouseenter":
16948          case "mouseleave":
16949          case "pointerenter":
16950          case "pointerleave":
16951            return ContinuousEventPriority;
16952          case "message":
16953            switch (getCurrentPriorityLevel()) {
16954              case ImmediatePriority:
16955                return DiscreteEventPriority;
16956              case UserBlockingPriority:
16957                return ContinuousEventPriority;
16958              case NormalPriority$1:
16959              case LowPriority:
16960                return DefaultEventPriority;
16961              case IdlePriority:
16962                return IdleEventPriority;
16963              default:
16964                return DefaultEventPriority;
16965            }
16966          default:
16967            return DefaultEventPriority;
16968        }
16969      }
16970      function clearIfContinuousEvent(domEventName, nativeEvent) {
16971        switch (domEventName) {
16972          case "focusin":
16973          case "focusout":
16974            queuedFocus = null;
16975            break;
16976          case "dragenter":
16977          case "dragleave":
16978            queuedDrag = null;
16979            break;
16980          case "mouseover":
16981          case "mouseout":
16982            queuedMouse = null;
16983            break;
16984          case "pointerover":
16985          case "pointerout":
16986            queuedPointers.delete(nativeEvent.pointerId);
16987            break;
16988          case "gotpointercapture":
16989          case "lostpointercapture":
16990            queuedPointerCaptures.delete(nativeEvent.pointerId);
16991        }
16992      }
16993      function accumulateOrCreateContinuousQueuedReplayableEvent(existingQueuedEvent, blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent) {
16994        if (null === existingQueuedEvent || existingQueuedEvent.nativeEvent !== nativeEvent)
16995          return existingQueuedEvent = {
16996            blockedOn,
16997            domEventName,
16998            eventSystemFlags,
16999            nativeEvent,
17000            targetContainers: [targetContainer]
17001          }, null !== blockedOn && (blockedOn = getInstanceFromNode(blockedOn), null !== blockedOn && attemptContinuousHydration(blockedOn)), existingQueuedEvent;
17002        existingQueuedEvent.eventSystemFlags |= eventSystemFlags;
17003        blockedOn = existingQueuedEvent.targetContainers;
17004        null !== targetContainer && -1 === blockedOn.indexOf(targetContainer) && blockedOn.push(targetContainer);
17005        return existingQueuedEvent;
17006      }
17007      function queueIfContinuousEvent(blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent) {
17008        switch (domEventName) {
17009          case "focusin":
17010            return queuedFocus = accumulateOrCreateContinuousQueuedReplayableEvent(
17011              queuedFocus,
17012              blockedOn,
17013              domEventName,
17014              eventSystemFlags,
17015              targetContainer,
17016              nativeEvent
17017            ), true;
17018          case "dragenter":
17019            return queuedDrag = accumulateOrCreateContinuousQueuedReplayableEvent(
17020              queuedDrag,
17021              blockedOn,
17022              domEventName,
17023              eventSystemFlags,
17024              targetContainer,
17025              nativeEvent
17026            ), true;
17027          case "mouseover":
17028            return queuedMouse = accumulateOrCreateContinuousQueuedReplayableEvent(
17029              queuedMouse,
17030              blockedOn,
17031              domEventName,
17032              eventSystemFlags,
17033              targetContainer,
17034              nativeEvent
17035            ), true;
17036          case "pointerover":
17037            var pointerId = nativeEvent.pointerId;
17038            queuedPointers.set(
17039              pointerId,
17040              accumulateOrCreateContinuousQueuedReplayableEvent(
17041                queuedPointers.get(pointerId) || null,
17042                blockedOn,
17043                domEventName,
17044                eventSystemFlags,
17045                targetContainer,
17046                nativeEvent
17047              )
17048            );
17049            return true;
17050          case "gotpointercapture":
17051            return pointerId = nativeEvent.pointerId, queuedPointerCaptures.set(
17052              pointerId,
17053              accumulateOrCreateContinuousQueuedReplayableEvent(
17054                queuedPointerCaptures.get(pointerId) || null,
17055                blockedOn,
17056                domEventName,
17057                eventSystemFlags,
17058                targetContainer,
17059                nativeEvent
17060              )
17061            ), true;
17062        }
17063        return false;
17064      }
17065      function attemptExplicitHydrationTarget(queuedTarget) {
17066        var targetInst = getClosestInstanceFromNode(queuedTarget.target);
17067        if (null !== targetInst) {
17068          var nearestMounted = getNearestMountedFiber(targetInst);
17069          if (null !== nearestMounted) {
17070            if (targetInst = nearestMounted.tag, 13 === targetInst) {
17071              if (targetInst = getSuspenseInstanceFromFiber(nearestMounted), null !== targetInst) {
17072                queuedTarget.blockedOn = targetInst;
17073                runWithPriority(queuedTarget.priority, function() {
17074                  attemptHydrationAtCurrentPriority(nearestMounted);
17075                });
17076                return;
17077              }
17078            } else if (31 === targetInst) {
17079              if (targetInst = getActivityInstanceFromFiber(nearestMounted), null !== targetInst) {
17080                queuedTarget.blockedOn = targetInst;
17081                runWithPriority(queuedTarget.priority, function() {
17082                  attemptHydrationAtCurrentPriority(nearestMounted);
17083                });
17084                return;
17085              }
17086            } else if (3 === targetInst && nearestMounted.stateNode.current.memoizedState.isDehydrated) {
17087              queuedTarget.blockedOn = 3 === nearestMounted.tag ? nearestMounted.stateNode.containerInfo : null;
17088              return;
17089            }
17090          }
17091        }
17092        queuedTarget.blockedOn = null;
17093      }
17094      function attemptReplayContinuousQueuedEvent(queuedEvent) {
17095        if (null !== queuedEvent.blockedOn) return false;
17096        for (var targetContainers = queuedEvent.targetContainers; 0 < targetContainers.length; ) {
17097          var nextBlockedOn = findInstanceBlockingEvent(queuedEvent.nativeEvent);
17098          if (null === nextBlockedOn) {
17099            nextBlockedOn = queuedEvent.nativeEvent;
17100            var nativeEventClone = new nextBlockedOn.constructor(
17101              nextBlockedOn.type,
17102              nextBlockedOn
17103            ), event = nativeEventClone;
17104            null !== currentReplayingEvent && console.error(
17105              "Expected currently replaying event to be null. This error is likely caused by a bug in React. Please file an issue."
17106            );
17107            currentReplayingEvent = event;
17108            nextBlockedOn.target.dispatchEvent(nativeEventClone);
17109            null === currentReplayingEvent && console.error(
17110              "Expected currently replaying event to not be null. This error is likely caused by a bug in React. Please file an issue."
17111            );
17112            currentReplayingEvent = null;
17113          } else
17114            return targetContainers = getInstanceFromNode(nextBlockedOn), null !== targetContainers && attemptContinuousHydration(targetContainers), queuedEvent.blockedOn = nextBlockedOn, false;
17115          targetContainers.shift();
17116        }
17117        return true;
17118      }
17119      function attemptReplayContinuousQueuedEventInMap(queuedEvent, key, map) {
17120        attemptReplayContinuousQueuedEvent(queuedEvent) && map.delete(key);
17121      }
17122      function replayUnblockedEvents() {
17123        hasScheduledReplayAttempt = false;
17124        null !== queuedFocus && attemptReplayContinuousQueuedEvent(queuedFocus) && (queuedFocus = null);
17125        null !== queuedDrag && attemptReplayContinuousQueuedEvent(queuedDrag) && (queuedDrag = null);
17126        null !== queuedMouse && attemptReplayContinuousQueuedEvent(queuedMouse) && (queuedMouse = null);
17127        queuedPointers.forEach(attemptReplayContinuousQueuedEventInMap);
17128        queuedPointerCaptures.forEach(attemptReplayContinuousQueuedEventInMap);
17129      }
17130      function scheduleCallbackIfUnblocked(queuedEvent, unblocked) {
17131        queuedEvent.blockedOn === unblocked && (queuedEvent.blockedOn = null, hasScheduledReplayAttempt || (hasScheduledReplayAttempt = true, Scheduler.unstable_scheduleCallback(
17132          Scheduler.unstable_NormalPriority,
17133          replayUnblockedEvents
17134        )));
17135      }
17136      function scheduleReplayQueueIfNeeded(formReplayingQueue) {
17137        lastScheduledReplayQueue !== formReplayingQueue && (lastScheduledReplayQueue = formReplayingQueue, Scheduler.unstable_scheduleCallback(
17138          Scheduler.unstable_NormalPriority,
17139          function() {
17140            lastScheduledReplayQueue === formReplayingQueue && (lastScheduledReplayQueue = null);
17141            for (var i = 0; i < formReplayingQueue.length; i += 3) {
17142              var form = formReplayingQueue[i], submitterOrAction = formReplayingQueue[i + 1], formData = formReplayingQueue[i + 2];
17143              if ("function" !== typeof submitterOrAction)
17144                if (null === findInstanceBlockingTarget(submitterOrAction || form))
17145                  continue;
17146                else break;
17147              var formInst = getInstanceFromNode(form);
17148              null !== formInst && (formReplayingQueue.splice(i, 3), i -= 3, form = {
17149                pending: true,
17150                data: formData,
17151                method: form.method,
17152                action: submitterOrAction
17153              }, Object.freeze(form), startHostTransition(
17154                formInst,
17155                form,
17156                submitterOrAction,
17157                formData
17158              ));
17159            }
17160          }
17161        ));
17162      }
17163      function retryIfBlockedOn(unblocked) {
17164        function unblock(queuedEvent) {
17165          return scheduleCallbackIfUnblocked(queuedEvent, unblocked);
17166        }
17167        null !== queuedFocus && scheduleCallbackIfUnblocked(queuedFocus, unblocked);
17168        null !== queuedDrag && scheduleCallbackIfUnblocked(queuedDrag, unblocked);
17169        null !== queuedMouse && scheduleCallbackIfUnblocked(queuedMouse, unblocked);
17170        queuedPointers.forEach(unblock);
17171        queuedPointerCaptures.forEach(unblock);
17172        for (var i = 0; i < queuedExplicitHydrationTargets.length; i++) {
17173          var queuedTarget = queuedExplicitHydrationTargets[i];
17174          queuedTarget.blockedOn === unblocked && (queuedTarget.blockedOn = null);
17175        }
17176        for (; 0 < queuedExplicitHydrationTargets.length && (i = queuedExplicitHydrationTargets[0], null === i.blockedOn); )
17177          attemptExplicitHydrationTarget(i), null === i.blockedOn && queuedExplicitHydrationTargets.shift();
17178        i = (unblocked.ownerDocument || unblocked).$$reactFormReplay;
17179        if (null != i)
17180          for (queuedTarget = 0; queuedTarget < i.length; queuedTarget += 3) {
17181            var form = i[queuedTarget], submitterOrAction = i[queuedTarget + 1], formProps = form[internalPropsKey] || null;
17182            if ("function" === typeof submitterOrAction)
17183              formProps || scheduleReplayQueueIfNeeded(i);
17184            else if (formProps) {
17185              var action = null;
17186              if (submitterOrAction && submitterOrAction.hasAttribute("formAction"))
17187                if (form = submitterOrAction, formProps = submitterOrAction[internalPropsKey] || null)
17188                  action = formProps.formAction;
17189                else {
17190                  if (null !== findInstanceBlockingTarget(form)) continue;
17191                }
17192              else action = formProps.action;
17193              "function" === typeof action ? i[queuedTarget + 1] = action : (i.splice(queuedTarget, 3), queuedTarget -= 3);
17194              scheduleReplayQueueIfNeeded(i);
17195            }
17196          }
17197      }
17198      function defaultOnDefaultTransitionIndicator() {
17199        function handleNavigate(event) {
17200          event.canIntercept && "react-transition" === event.info && event.intercept({
17201            handler: function() {
17202              return new Promise(function(resolve) {
17203                return pendingResolve = resolve;
17204              });
17205            },
17206            focusReset: "manual",
17207            scroll: "manual"
17208          });
17209        }
17210        function handleNavigateComplete() {
17211          null !== pendingResolve && (pendingResolve(), pendingResolve = null);
17212          isCancelled || setTimeout(startFakeNavigation, 20);
17213        }
17214        function startFakeNavigation() {
17215          if (!isCancelled && !navigation.transition) {
17216            var currentEntry = navigation.currentEntry;
17217            currentEntry && null != currentEntry.url && navigation.navigate(currentEntry.url, {
17218              state: currentEntry.getState(),
17219              info: "react-transition",
17220              history: "replace"
17221            });
17222          }
17223        }
17224        if ("object" === typeof navigation) {
17225          var isCancelled = false, pendingResolve = null;
17226          navigation.addEventListener("navigate", handleNavigate);
17227          navigation.addEventListener("navigatesuccess", handleNavigateComplete);
17228          navigation.addEventListener("navigateerror", handleNavigateComplete);
17229          setTimeout(startFakeNavigation, 100);
17230          return function() {
17231            isCancelled = true;
17232            navigation.removeEventListener("navigate", handleNavigate);
17233            navigation.removeEventListener(
17234              "navigatesuccess",
17235              handleNavigateComplete
17236            );
17237            navigation.removeEventListener(
17238              "navigateerror",
17239              handleNavigateComplete
17240            );
17241            null !== pendingResolve && (pendingResolve(), pendingResolve = null);
17242          };
17243        }
17244      }
17245      function ReactDOMRoot(internalRoot) {
17246        this._internalRoot = internalRoot;
17247      }
17248      function ReactDOMHydrationRoot(internalRoot) {
17249        this._internalRoot = internalRoot;
17250      }
17251      function warnIfReactDOMContainerInDEV(container) {
17252        container[internalContainerInstanceKey] && (container._reactRootContainer ? console.error(
17253          "You are calling ReactDOMClient.createRoot() on a container that was previously passed to ReactDOM.render(). This is not supported."
17254        ) : console.error(
17255          "You are calling ReactDOMClient.createRoot() on a container that has already been passed to createRoot() before. Instead, call root.render() on the existing root instead if you want to update it."
17256        ));
17257      }
17258      "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
17259      var Scheduler = require_scheduler(), React = require_react(), ReactDOM = require_react_dom(), assign = Object.assign, REACT_LEGACY_ELEMENT_TYPE = Symbol.for("react.element"), REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy");
17260      Symbol.for("react.scope");
17261      var REACT_ACTIVITY_TYPE = Symbol.for("react.activity");
17262      Symbol.for("react.legacy_hidden");
17263      Symbol.for("react.tracing_marker");
17264      var REACT_MEMO_CACHE_SENTINEL = Symbol.for("react.memo_cache_sentinel");
17265      Symbol.for("react.view_transition");
17266      var MAYBE_ITERATOR_SYMBOL = Symbol.iterator, REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"), isArrayImpl = Array.isArray, ReactSharedInternals = React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, ReactDOMSharedInternals = ReactDOM.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE, NotPending = Object.freeze({
17267        pending: false,
17268        data: null,
17269        method: null,
17270        action: null
17271      }), valueStack = [];
17272      var fiberStack = [];
17273      var index$jscomp$0 = -1, contextStackCursor = createCursor(null), contextFiberStackCursor = createCursor(null), rootInstanceStackCursor = createCursor(null), hostTransitionProviderCursor = createCursor(null), disabledDepth = 0, prevLog, prevInfo, prevWarn, prevError, prevGroup, prevGroupCollapsed, prevGroupEnd;
17274      disabledLog.__reactDisabledLog = true;
17275      var prefix, suffix, reentry = false;
17276      var componentFrameCache = new ("function" === typeof WeakMap ? WeakMap : Map)();
17277      var current = null, isRendering = false, hasOwnProperty = Object.prototype.hasOwnProperty, scheduleCallback$3 = Scheduler.unstable_scheduleCallback, cancelCallback$1 = Scheduler.unstable_cancelCallback, shouldYield = Scheduler.unstable_shouldYield, requestPaint = Scheduler.unstable_requestPaint, now$1 = Scheduler.unstable_now, getCurrentPriorityLevel = Scheduler.unstable_getCurrentPriorityLevel, ImmediatePriority = Scheduler.unstable_ImmediatePriority, UserBlockingPriority = Scheduler.unstable_UserBlockingPriority, NormalPriority$1 = Scheduler.unstable_NormalPriority, LowPriority = Scheduler.unstable_LowPriority, IdlePriority = Scheduler.unstable_IdlePriority, log$1 = Scheduler.log, unstable_setDisableYieldValue = Scheduler.unstable_setDisableYieldValue, rendererID = null, injectedHook = null, hasLoggedError = false, isDevToolsPresent = "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__, clz32 = Math.clz32 ? Math.clz32 : clz32Fallback, log = Math.log, LN2 = Math.LN2, nextTransitionUpdateLane = 256, nextTransitionDeferredLane = 262144, nextRetryLane = 4194304, DiscreteEventPriority = 2, ContinuousEventPriority = 8, DefaultEventPriority = 32, IdleEventPriority = 268435456, randomKey = Math.random().toString(36).slice(2), internalInstanceKey = "__reactFiber$" + randomKey, internalPropsKey = "__reactProps$" + randomKey, internalContainerInstanceKey = "__reactContainer$" + randomKey, internalEventHandlersKey = "__reactEvents$" + randomKey, internalEventHandlerListenersKey = "__reactListeners$" + randomKey, internalEventHandlesSetKey = "__reactHandles$" + randomKey, internalRootNodeResourcesKey = "__reactResources$" + randomKey, internalHoistableMarker = "__reactMarker$" + randomKey, allNativeEvents = /* @__PURE__ */ new Set(), registrationNameDependencies = {}, possibleRegistrationNames = {}, hasReadOnlyValue = {
17278        button: true,
17279        checkbox: true,
17280        image: true,
17281        hidden: true,
17282        radio: true,
17283        reset: true,
17284        submit: true
17285      }, VALID_ATTRIBUTE_NAME_REGEX = RegExp(
17286        "^[:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD][:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$"
17287      ), illegalAttributeNameCache = {}, validatedAttributeNameCache = {}, escapeSelectorAttributeValueInsideDoubleQuotesRegex = /[\n"\\]/g, didWarnValueDefaultValue$1 = false, didWarnCheckedDefaultChecked = false, didWarnSelectedSetOnOption = false, didWarnInvalidChild = false, didWarnInvalidInnerHTML = false;
17288      var didWarnValueDefaultValue = false;
17289      var valuePropNames = ["value", "defaultValue"], didWarnValDefaultVal = false, needsEscaping = /["'&<>\n\t]|^\s|\s$/, specialTags = "address applet area article aside base basefont bgsound blockquote body br button caption center col colgroup dd details dir div dl dt embed fieldset figcaption figure footer form frame frameset h1 h2 h3 h4 h5 h6 head header hgroup hr html iframe img input isindex li link listing main marquee menu menuitem meta nav noembed noframes noscript object ol p param plaintext pre script section select source style summary table tbody td template textarea tfoot th thead title tr track ul wbr xmp".split(
17290        " "
17291      ), inScopeTags = "applet caption html table td th marquee object template foreignObject desc title".split(
17292        " "
17293      ), buttonScopeTags = inScopeTags.concat(["button"]), impliedEndTags = "dd dt li option optgroup p rp rt".split(" "), emptyAncestorInfoDev = {
17294        current: null,
17295        formTag: null,
17296        aTagInScope: null,
17297        buttonTagInScope: null,
17298        nobrTagInScope: null,
17299        pTagInButtonScope: null,
17300        listItemTagAutoclosing: null,
17301        dlItemTagAutoclosing: null,
17302        containerTagInScope: null,
17303        implicitRootScope: false
17304      }, didWarn = {}, shorthandToLonghand = {
17305        animation: "animationDelay animationDirection animationDuration animationFillMode animationIterationCount animationName animationPlayState animationTimingFunction".split(
17306          " "
17307        ),
17308        background: "backgroundAttachment backgroundClip backgroundColor backgroundImage backgroundOrigin backgroundPositionX backgroundPositionY backgroundRepeat backgroundSize".split(
17309          " "
17310        ),
17311        backgroundPosition: ["backgroundPositionX", "backgroundPositionY"],
17312        border: "borderBottomColor borderBottomStyle borderBottomWidth borderImageOutset borderImageRepeat borderImageSlice borderImageSource borderImageWidth borderLeftColor borderLeftStyle borderLeftWidth borderRightColor borderRightStyle borderRightWidth borderTopColor borderTopStyle borderTopWidth".split(
17313          " "
17314        ),
17315        borderBlockEnd: [
17316          "borderBlockEndColor",
17317          "borderBlockEndStyle",
17318          "borderBlockEndWidth"
17319        ],
17320        borderBlockStart: [
17321          "borderBlockStartColor",
17322          "borderBlockStartStyle",
17323          "borderBlockStartWidth"
17324        ],
17325        borderBottom: [
17326          "borderBottomColor",
17327          "borderBottomStyle",
17328          "borderBottomWidth"
17329        ],
17330        borderColor: [
17331          "borderBottomColor",
17332          "borderLeftColor",
17333          "borderRightColor",
17334          "borderTopColor"
17335        ],
17336        borderImage: [
17337          "borderImageOutset",
17338          "borderImageRepeat",
17339          "borderImageSlice",
17340          "borderImageSource",
17341          "borderImageWidth"
17342        ],
17343        borderInlineEnd: [
17344          "borderInlineEndColor",
17345          "borderInlineEndStyle",
17346          "borderInlineEndWidth"
17347        ],
17348        borderInlineStart: [
17349          "borderInlineStartColor",
17350          "borderInlineStartStyle",
17351          "borderInlineStartWidth"
17352        ],
17353        borderLeft: ["borderLeftColor", "borderLeftStyle", "borderLeftWidth"],
17354        borderRadius: [
17355          "borderBottomLeftRadius",
17356          "borderBottomRightRadius",
17357          "borderTopLeftRadius",
17358          "borderTopRightRadius"
17359        ],
17360        borderRight: [
17361          "borderRightColor",
17362          "borderRightStyle",
17363          "borderRightWidth"
17364        ],
17365        borderStyle: [
17366          "borderBottomStyle",
17367          "borderLeftStyle",
17368          "borderRightStyle",
17369          "borderTopStyle"
17370        ],
17371        borderTop: ["borderTopColor", "borderTopStyle", "borderTopWidth"],
17372        borderWidth: [
17373          "borderBottomWidth",
17374          "borderLeftWidth",
17375          "borderRightWidth",
17376          "borderTopWidth"
17377        ],
17378        columnRule: ["columnRuleColor", "columnRuleStyle", "columnRuleWidth"],
17379        columns: ["columnCount", "columnWidth"],
17380        flex: ["flexBasis", "flexGrow", "flexShrink"],
17381        flexFlow: ["flexDirection", "flexWrap"],
17382        font: "fontFamily fontFeatureSettings fontKerning fontLanguageOverride fontSize fontSizeAdjust fontStretch fontStyle fontVariant fontVariantAlternates fontVariantCaps fontVariantEastAsian fontVariantLigatures fontVariantNumeric fontVariantPosition fontWeight lineHeight".split(
17383          " "
17384        ),
17385        fontVariant: "fontVariantAlternates fontVariantCaps fontVariantEastAsian fontVariantLigatures fontVariantNumeric fontVariantPosition".split(
17386          " "
17387        ),
17388        gap: ["columnGap", "rowGap"],
17389        grid: "gridAutoColumns gridAutoFlow gridAutoRows gridTemplateAreas gridTemplateColumns gridTemplateRows".split(
17390          " "
17391        ),
17392        gridArea: [
17393          "gridColumnEnd",
17394          "gridColumnStart",
17395          "gridRowEnd",
17396          "gridRowStart"
17397        ],
17398        gridColumn: ["gridColumnEnd", "gridColumnStart"],
17399        gridColumnGap: ["columnGap"],
17400        gridGap: ["columnGap", "rowGap"],
17401        gridRow: ["gridRowEnd", "gridRowStart"],
17402        gridRowGap: ["rowGap"],
17403        gridTemplate: [
17404          "gridTemplateAreas",
17405          "gridTemplateColumns",
17406          "gridTemplateRows"
17407        ],
17408        listStyle: ["listStyleImage", "listStylePosition", "listStyleType"],
17409        margin: ["marginBottom", "marginLeft", "marginRight", "marginTop"],
17410        marker: ["markerEnd", "markerMid", "markerStart"],
17411        mask: "maskClip maskComposite maskImage maskMode maskOrigin maskPositionX maskPositionY maskRepeat maskSize".split(
17412          " "
17413        ),
17414        maskPosition: ["maskPositionX", "maskPositionY"],
17415        outline: ["outlineColor", "outlineStyle", "outlineWidth"],
17416        overflow: ["overflowX", "overflowY"],
17417        padding: ["paddingBottom", "paddingLeft", "paddingRight", "paddingTop"],
17418        placeContent: ["alignContent", "justifyContent"],
17419        placeItems: ["alignItems", "justifyItems"],
17420        placeSelf: ["alignSelf", "justifySelf"],
17421        textDecoration: [
17422          "textDecorationColor",
17423          "textDecorationLine",
17424          "textDecorationStyle"
17425        ],
17426        textEmphasis: ["textEmphasisColor", "textEmphasisStyle"],
17427        transition: [
17428          "transitionDelay",
17429          "transitionDuration",
17430          "transitionProperty",
17431          "transitionTimingFunction"
17432        ],
17433        wordWrap: ["overflowWrap"]
17434      }, uppercasePattern = /([A-Z])/g, msPattern$1 = /^ms-/, badVendoredStyleNamePattern = /^(?:webkit|moz|o)[A-Z]/, msPattern = /^-ms-/, hyphenPattern = /-(.)/g, badStyleValueWithSemicolonPattern = /;\s*$/, warnedStyleNames = {}, warnedStyleValues = {}, warnedForNaNValue = false, warnedForInfinityValue = false, unitlessNumbers = new Set(
17435        "animationIterationCount aspectRatio borderImageOutset borderImageSlice borderImageWidth boxFlex boxFlexGroup boxOrdinalGroup columnCount columns flex flexGrow flexPositive flexShrink flexNegative flexOrder gridArea gridRow gridRowEnd gridRowSpan gridRowStart gridColumn gridColumnEnd gridColumnSpan gridColumnStart fontWeight lineClamp lineHeight opacity order orphans scale tabSize widows zIndex zoom fillOpacity floodOpacity stopOpacity strokeDasharray strokeDashoffset strokeMiterlimit strokeOpacity strokeWidth MozAnimationIterationCount MozBoxFlex MozBoxFlexGroup MozLineClamp msAnimationIterationCount msFlex msZoom msFlexGrow msFlexNegative msFlexOrder msFlexPositive msFlexShrink msGridColumn msGridColumnSpan msGridRow msGridRowSpan WebkitAnimationIterationCount WebkitBoxFlex WebKitBoxFlexGroup WebkitBoxOrdinalGroup WebkitColumnCount WebkitColumns WebkitFlex WebkitFlexGrow WebkitFlexPositive WebkitFlexShrink WebkitLineClamp".split(
17436          " "
17437        )
17438      ), MATH_NAMESPACE = "http://www.w3.org/1998/Math/MathML", SVG_NAMESPACE = "http://www.w3.org/2000/svg", aliases = /* @__PURE__ */ new Map([
17439        ["acceptCharset", "accept-charset"],
17440        ["htmlFor", "for"],
17441        ["httpEquiv", "http-equiv"],
17442        ["crossOrigin", "crossorigin"],
17443        ["accentHeight", "accent-height"],
17444        ["alignmentBaseline", "alignment-baseline"],
17445        ["arabicForm", "arabic-form"],
17446        ["baselineShift", "baseline-shift"],
17447        ["capHeight", "cap-height"],
17448        ["clipPath", "clip-path"],
17449        ["clipRule", "clip-rule"],
17450        ["colorInterpolation", "color-interpolation"],
17451        ["colorInterpolationFilters", "color-interpolation-filters"],
17452        ["colorProfile", "color-profile"],
17453        ["colorRendering", "color-rendering"],
17454        ["dominantBaseline", "dominant-baseline"],
17455        ["enableBackground", "enable-background"],
17456        ["fillOpacity", "fill-opacity"],
17457        ["fillRule", "fill-rule"],
17458        ["floodColor", "flood-color"],
17459        ["floodOpacity", "flood-opacity"],
17460        ["fontFamily", "font-family"],
17461        ["fontSize", "font-size"],
17462        ["fontSizeAdjust", "font-size-adjust"],
17463        ["fontStretch", "font-stretch"],
17464        ["fontStyle", "font-style"],
17465        ["fontVariant", "font-variant"],
17466        ["fontWeight", "font-weight"],
17467        ["glyphName", "glyph-name"],
17468        ["glyphOrientationHorizontal", "glyph-orientation-horizontal"],
17469        ["glyphOrientationVertical", "glyph-orientation-vertical"],
17470        ["horizAdvX", "horiz-adv-x"],
17471        ["horizOriginX", "horiz-origin-x"],
17472        ["imageRendering", "image-rendering"],
17473        ["letterSpacing", "letter-spacing"],
17474        ["lightingColor", "lighting-color"],
17475        ["markerEnd", "marker-end"],
17476        ["markerMid", "marker-mid"],
17477        ["markerStart", "marker-start"],
17478        ["overlinePosition", "overline-position"],
17479        ["overlineThickness", "overline-thickness"],
17480        ["paintOrder", "paint-order"],
17481        ["panose-1", "panose-1"],
17482        ["pointerEvents", "pointer-events"],
17483        ["renderingIntent", "rendering-intent"],
17484        ["shapeRendering", "shape-rendering"],
17485        ["stopColor", "stop-color"],
17486        ["stopOpacity", "stop-opacity"],
17487        ["strikethroughPosition", "strikethrough-position"],
17488        ["strikethroughThickness", "strikethrough-thickness"],
17489        ["strokeDasharray", "stroke-dasharray"],
17490        ["strokeDashoffset", "stroke-dashoffset"],
17491        ["strokeLinecap", "stroke-linecap"],
17492        ["strokeLinejoin", "stroke-linejoin"],
17493        ["strokeMiterlimit", "stroke-miterlimit"],
17494        ["strokeOpacity", "stroke-opacity"],
17495        ["strokeWidth", "stroke-width"],
17496        ["textAnchor", "text-anchor"],
17497        ["textDecoration", "text-decoration"],
17498        ["textRendering", "text-rendering"],
17499        ["transformOrigin", "transform-origin"],
17500        ["underlinePosition", "underline-position"],
17501        ["underlineThickness", "underline-thickness"],
17502        ["unicodeBidi", "unicode-bidi"],
17503        ["unicodeRange", "unicode-range"],
17504        ["unitsPerEm", "units-per-em"],
17505        ["vAlphabetic", "v-alphabetic"],
17506        ["vHanging", "v-hanging"],
17507        ["vIdeographic", "v-ideographic"],
17508        ["vMathematical", "v-mathematical"],
17509        ["vectorEffect", "vector-effect"],
17510        ["vertAdvY", "vert-adv-y"],
17511        ["vertOriginX", "vert-origin-x"],
17512        ["vertOriginY", "vert-origin-y"],
17513        ["wordSpacing", "word-spacing"],
17514        ["writingMode", "writing-mode"],
17515        ["xmlnsXlink", "xmlns:xlink"],
17516        ["xHeight", "x-height"]
17517      ]), possibleStandardNames = {
17518        accept: "accept",
17519        acceptcharset: "acceptCharset",
17520        "accept-charset": "acceptCharset",
17521        accesskey: "accessKey",
17522        action: "action",
17523        allowfullscreen: "allowFullScreen",
17524        alt: "alt",
17525        as: "as",
17526        async: "async",
17527        autocapitalize: "autoCapitalize",
17528        autocomplete: "autoComplete",
17529        autocorrect: "autoCorrect",
17530        autofocus: "autoFocus",
17531        autoplay: "autoPlay",
17532        autosave: "autoSave",
17533        capture: "capture",
17534        cellpadding: "cellPadding",
17535        cellspacing: "cellSpacing",
17536        challenge: "challenge",
17537        charset: "charSet",
17538        checked: "checked",
17539        children: "children",
17540        cite: "cite",
17541        class: "className",
17542        classid: "classID",
17543        classname: "className",
17544        cols: "cols",
17545        colspan: "colSpan",
17546        content: "content",
17547        contenteditable: "contentEditable",
17548        contextmenu: "contextMenu",
17549        controls: "controls",
17550        controlslist: "controlsList",
17551        coords: "coords",
17552        crossorigin: "crossOrigin",
17553        dangerouslysetinnerhtml: "dangerouslySetInnerHTML",
17554        data: "data",
17555        datetime: "dateTime",
17556        default: "default",
17557        defaultchecked: "defaultChecked",
17558        defaultvalue: "defaultValue",
17559        defer: "defer",
17560        dir: "dir",
17561        disabled: "disabled",
17562        disablepictureinpicture: "disablePictureInPicture",
17563        disableremoteplayback: "disableRemotePlayback",
17564        download: "download",
17565        draggable: "draggable",
17566        enctype: "encType",
17567        enterkeyhint: "enterKeyHint",
17568        fetchpriority: "fetchPriority",
17569        for: "htmlFor",
17570        form: "form",
17571        formmethod: "formMethod",
17572        formaction: "formAction",
17573        formenctype: "formEncType",
17574        formnovalidate: "formNoValidate",
17575        formtarget: "formTarget",
17576        frameborder: "frameBorder",
17577        headers: "headers",
17578        height: "height",
17579        hidden: "hidden",
17580        high: "high",
17581        href: "href",
17582        hreflang: "hrefLang",
17583        htmlfor: "htmlFor",
17584        httpequiv: "httpEquiv",
17585        "http-equiv": "httpEquiv",
17586        icon: "icon",
17587        id: "id",
17588        imagesizes: "imageSizes",
17589        imagesrcset: "imageSrcSet",
17590        inert: "inert",
17591        innerhtml: "innerHTML",
17592        inputmode: "inputMode",
17593        integrity: "integrity",
17594        is: "is",
17595        itemid: "itemID",
17596        itemprop: "itemProp",
17597        itemref: "itemRef",
17598        itemscope: "itemScope",
17599        itemtype: "itemType",
17600        keyparams: "keyParams",
17601        keytype: "keyType",
17602        kind: "kind",
17603        label: "label",
17604        lang: "lang",
17605        list: "list",
17606        loop: "loop",
17607        low: "low",
17608        manifest: "manifest",
17609        marginwidth: "marginWidth",
17610        marginheight: "marginHeight",
17611        max: "max",
17612        maxlength: "maxLength",
17613        media: "media",
17614        mediagroup: "mediaGroup",
17615        method: "method",
17616        min: "min",
17617        minlength: "minLength",
17618        multiple: "multiple",
17619        muted: "muted",
17620        name: "name",
17621        nomodule: "noModule",
17622        nonce: "nonce",
17623        novalidate: "noValidate",
17624        open: "open",
17625        optimum: "optimum",
17626        pattern: "pattern",
17627        placeholder: "placeholder",
17628        playsinline: "playsInline",
17629        poster: "poster",
17630        preload: "preload",
17631        profile: "profile",
17632        radiogroup: "radioGroup",
17633        readonly: "readOnly",
17634        referrerpolicy: "referrerPolicy",
17635        rel: "rel",
17636        required: "required",
17637        reversed: "reversed",
17638        role: "role",
17639        rows: "rows",
17640        rowspan: "rowSpan",
17641        sandbox: "sandbox",
17642        scope: "scope",
17643        scoped: "scoped",
17644        scrolling: "scrolling",
17645        seamless: "seamless",
17646        selected: "selected",
17647        shape: "shape",
17648        size: "size",
17649        sizes: "sizes",
17650        span: "span",
17651        spellcheck: "spellCheck",
17652        src: "src",
17653        srcdoc: "srcDoc",
17654        srclang: "srcLang",
17655        srcset: "srcSet",
17656        start: "start",
17657        step: "step",
17658        style: "style",
17659        summary: "summary",
17660        tabindex: "tabIndex",
17661        target: "target",
17662        title: "title",
17663        type: "type",
17664        usemap: "useMap",
17665        value: "value",
17666        width: "width",
17667        wmode: "wmode",
17668        wrap: "wrap",
17669        about: "about",
17670        accentheight: "accentHeight",
17671        "accent-height": "accentHeight",
17672        accumulate: "accumulate",
17673        additive: "additive",
17674        alignmentbaseline: "alignmentBaseline",
17675        "alignment-baseline": "alignmentBaseline",
17676        allowreorder: "allowReorder",
17677        alphabetic: "alphabetic",
17678        amplitude: "amplitude",
17679        arabicform: "arabicForm",
17680        "arabic-form": "arabicForm",
17681        ascent: "ascent",
17682        attributename: "attributeName",
17683        attributetype: "attributeType",
17684        autoreverse: "autoReverse",
17685        azimuth: "azimuth",
17686        basefrequency: "baseFrequency",
17687        baselineshift: "baselineShift",
17688        "baseline-shift": "baselineShift",
17689        baseprofile: "baseProfile",
17690        bbox: "bbox",
17691        begin: "begin",
17692        bias: "bias",
17693        by: "by",
17694        calcmode: "calcMode",
17695        capheight: "capHeight",
17696        "cap-height": "capHeight",
17697        clip: "clip",
17698        clippath: "clipPath",
17699        "clip-path": "clipPath",
17700        clippathunits: "clipPathUnits",
17701        cliprule: "clipRule",
17702        "clip-rule": "clipRule",
17703        color: "color",
17704        colorinterpolation: "colorInterpolation",
17705        "color-interpolation": "colorInterpolation",
17706        colorinterpolationfilters: "colorInterpolationFilters",
17707        "color-interpolation-filters": "colorInterpolationFilters",
17708        colorprofile: "colorProfile",
17709        "color-profile": "colorProfile",
17710        colorrendering: "colorRendering",
17711        "color-rendering": "colorRendering",
17712        contentscripttype: "contentScriptType",
17713        contentstyletype: "contentStyleType",
17714        cursor: "cursor",
17715        cx: "cx",
17716        cy: "cy",
17717        d: "d",
17718        datatype: "datatype",
17719        decelerate: "decelerate",
17720        descent: "descent",
17721        diffuseconstant: "diffuseConstant",
17722        direction: "direction",
17723        display: "display",
17724        divisor: "divisor",
17725        dominantbaseline: "dominantBaseline",
17726        "dominant-baseline": "dominantBaseline",
17727        dur: "dur",
17728        dx: "dx",
17729        dy: "dy",
17730        edgemode: "edgeMode",
17731        elevation: "elevation",
17732        enablebackground: "enableBackground",
17733        "enable-background": "enableBackground",
17734        end: "end",
17735        exponent: "exponent",
17736        externalresourcesrequired: "externalResourcesRequired",
17737        fill: "fill",
17738        fillopacity: "fillOpacity",
17739        "fill-opacity": "fillOpacity",
17740        fillrule: "fillRule",
17741        "fill-rule": "fillRule",
17742        filter: "filter",
17743        filterres: "filterRes",
17744        filterunits: "filterUnits",
17745        floodopacity: "floodOpacity",
17746        "flood-opacity": "floodOpacity",
17747        floodcolor: "floodColor",
17748        "flood-color": "floodColor",
17749        focusable: "focusable",
17750        fontfamily: "fontFamily",
17751        "font-family": "fontFamily",
17752        fontsize: "fontSize",
17753        "font-size": "fontSize",
17754        fontsizeadjust: "fontSizeAdjust",
17755        "font-size-adjust": "fontSizeAdjust",
17756        fontstretch: "fontStretch",
17757        "font-stretch": "fontStretch",
17758        fontstyle: "fontStyle",
17759        "font-style": "fontStyle",
17760        fontvariant: "fontVariant",
17761        "font-variant": "fontVariant",
17762        fontweight: "fontWeight",
17763        "font-weight": "fontWeight",
17764        format: "format",
17765        from: "from",
17766        fx: "fx",
17767        fy: "fy",
17768        g1: "g1",
17769        g2: "g2",
17770        glyphname: "glyphName",
17771        "glyph-name": "glyphName",
17772        glyphorientationhorizontal: "glyphOrientationHorizontal",
17773        "glyph-orientation-horizontal": "glyphOrientationHorizontal",
17774        glyphorientationvertical: "glyphOrientationVertical",
17775        "glyph-orientation-vertical": "glyphOrientationVertical",
17776        glyphref: "glyphRef",
17777        gradienttransform: "gradientTransform",
17778        gradientunits: "gradientUnits",
17779        hanging: "hanging",
17780        horizadvx: "horizAdvX",
17781        "horiz-adv-x": "horizAdvX",
17782        horizoriginx: "horizOriginX",
17783        "horiz-origin-x": "horizOriginX",
17784        ideographic: "ideographic",
17785        imagerendering: "imageRendering",
17786        "image-rendering": "imageRendering",
17787        in2: "in2",
17788        in: "in",
17789        inlist: "inlist",
17790        intercept: "intercept",
17791        k1: "k1",
17792        k2: "k2",
17793        k3: "k3",
17794        k4: "k4",
17795        k: "k",
17796        kernelmatrix: "kernelMatrix",
17797        kernelunitlength: "kernelUnitLength",
17798        kerning: "kerning",
17799        keypoints: "keyPoints",
17800        keysplines: "keySplines",
17801        keytimes: "keyTimes",
17802        lengthadjust: "lengthAdjust",
17803        letterspacing: "letterSpacing",
17804        "letter-spacing": "letterSpacing",
17805        lightingcolor: "lightingColor",
17806        "lighting-color": "lightingColor",
17807        limitingconeangle: "limitingConeAngle",
17808        local: "local",
17809        markerend: "markerEnd",
17810        "marker-end": "markerEnd",
17811        markerheight: "markerHeight",
17812        markermid: "markerMid",
17813        "marker-mid": "markerMid",
17814        markerstart: "markerStart",
17815        "marker-start": "markerStart",
17816        markerunits: "markerUnits",
17817        markerwidth: "markerWidth",
17818        mask: "mask",
17819        maskcontentunits: "maskContentUnits",
17820        maskunits: "maskUnits",
17821        mathematical: "mathematical",
17822        mode: "mode",
17823        numoctaves: "numOctaves",
17824        offset: "offset",
17825        opacity: "opacity",
17826        operator: "operator",
17827        order: "order",
17828        orient: "orient",
17829        orientation: "orientation",
17830        origin: "origin",
17831        overflow: "overflow",
17832        overlineposition: "overlinePosition",
17833        "overline-position": "overlinePosition",
17834        overlinethickness: "overlineThickness",
17835        "overline-thickness": "overlineThickness",
17836        paintorder: "paintOrder",
17837        "paint-order": "paintOrder",
17838        panose1: "panose1",
17839        "panose-1": "panose1",
17840        pathlength: "pathLength",
17841        patterncontentunits: "patternContentUnits",
17842        patterntransform: "patternTransform",
17843        patternunits: "patternUnits",
17844        pointerevents: "pointerEvents",
17845        "pointer-events": "pointerEvents",
17846        points: "points",
17847        pointsatx: "pointsAtX",
17848        pointsaty: "pointsAtY",
17849        pointsatz: "pointsAtZ",
17850        popover: "popover",
17851        popovertarget: "popoverTarget",
17852        popovertargetaction: "popoverTargetAction",
17853        prefix: "prefix",
17854        preservealpha: "preserveAlpha",
17855        preserveaspectratio: "preserveAspectRatio",
17856        primitiveunits: "primitiveUnits",
17857        property: "property",
17858        r: "r",
17859        radius: "radius",
17860        refx: "refX",
17861        refy: "refY",
17862        renderingintent: "renderingIntent",
17863        "rendering-intent": "renderingIntent",
17864        repeatcount: "repeatCount",
17865        repeatdur: "repeatDur",
17866        requiredextensions: "requiredExtensions",
17867        requiredfeatures: "requiredFeatures",
17868        resource: "resource",
17869        restart: "restart",
17870        result: "result",
17871        results: "results",
17872        rotate: "rotate",
17873        rx: "rx",
17874        ry: "ry",
17875        scale: "scale",
17876        security: "security",
17877        seed: "seed",
17878        shaperendering: "shapeRendering",
17879        "shape-rendering": "shapeRendering",
17880        slope: "slope",
17881        spacing: "spacing",
17882        specularconstant: "specularConstant",
17883        specularexponent: "specularExponent",
17884        speed: "speed",
17885        spreadmethod: "spreadMethod",
17886        startoffset: "startOffset",
17887        stddeviation: "stdDeviation",
17888        stemh: "stemh",
17889        stemv: "stemv",
17890        stitchtiles: "stitchTiles",
17891        stopcolor: "stopColor",
17892        "stop-color": "stopColor",
17893        stopopacity: "stopOpacity",
17894        "stop-opacity": "stopOpacity",
17895        strikethroughposition: "strikethroughPosition",
17896        "strikethrough-position": "strikethroughPosition",
17897        strikethroughthickness: "strikethroughThickness",
17898        "strikethrough-thickness": "strikethroughThickness",
17899        string: "string",
17900        stroke: "stroke",
17901        strokedasharray: "strokeDasharray",
17902        "stroke-dasharray": "strokeDasharray",
17903        strokedashoffset: "strokeDashoffset",
17904        "stroke-dashoffset": "strokeDashoffset",
17905        strokelinecap: "strokeLinecap",
17906        "stroke-linecap": "strokeLinecap",
17907        strokelinejoin: "strokeLinejoin",
17908        "stroke-linejoin": "strokeLinejoin",
17909        strokemiterlimit: "strokeMiterlimit",
17910        "stroke-miterlimit": "strokeMiterlimit",
17911        strokewidth: "strokeWidth",
17912        "stroke-width": "strokeWidth",
17913        strokeopacity: "strokeOpacity",
17914        "stroke-opacity": "strokeOpacity",
17915        suppresscontenteditablewarning: "suppressContentEditableWarning",
17916        suppresshydrationwarning: "suppressHydrationWarning",
17917        surfacescale: "surfaceScale",
17918        systemlanguage: "systemLanguage",
17919        tablevalues: "tableValues",
17920        targetx: "targetX",
17921        targety: "targetY",
17922        textanchor: "textAnchor",
17923        "text-anchor": "textAnchor",
17924        textdecoration: "textDecoration",
17925        "text-decoration": "textDecoration",
17926        textlength: "textLength",
17927        textrendering: "textRendering",
17928        "text-rendering": "textRendering",
17929        to: "to",
17930        transform: "transform",
17931        transformorigin: "transformOrigin",
17932        "transform-origin": "transformOrigin",
17933        typeof: "typeof",
17934        u1: "u1",
17935        u2: "u2",
17936        underlineposition: "underlinePosition",
17937        "underline-position": "underlinePosition",
17938        underlinethickness: "underlineThickness",
17939        "underline-thickness": "underlineThickness",
17940        unicode: "unicode",
17941        unicodebidi: "unicodeBidi",
17942        "unicode-bidi": "unicodeBidi",
17943        unicoderange: "unicodeRange",
17944        "unicode-range": "unicodeRange",
17945        unitsperem: "unitsPerEm",
17946        "units-per-em": "unitsPerEm",
17947        unselectable: "unselectable",
17948        valphabetic: "vAlphabetic",
17949        "v-alphabetic": "vAlphabetic",
17950        values: "values",
17951        vectoreffect: "vectorEffect",
17952        "vector-effect": "vectorEffect",
17953        version: "version",
17954        vertadvy: "vertAdvY",
17955        "vert-adv-y": "vertAdvY",
17956        vertoriginx: "vertOriginX",
17957        "vert-origin-x": "vertOriginX",
17958        vertoriginy: "vertOriginY",
17959        "vert-origin-y": "vertOriginY",
17960        vhanging: "vHanging",
17961        "v-hanging": "vHanging",
17962        videographic: "vIdeographic",
17963        "v-ideographic": "vIdeographic",
17964        viewbox: "viewBox",
17965        viewtarget: "viewTarget",
17966        visibility: "visibility",
17967        vmathematical: "vMathematical",
17968        "v-mathematical": "vMathematical",
17969        vocab: "vocab",
17970        widths: "widths",
17971        wordspacing: "wordSpacing",
17972        "word-spacing": "wordSpacing",
17973        writingmode: "writingMode",
17974        "writing-mode": "writingMode",
17975        x1: "x1",
17976        x2: "x2",
17977        x: "x",
17978        xchannelselector: "xChannelSelector",
17979        xheight: "xHeight",
17980        "x-height": "xHeight",
17981        xlinkactuate: "xlinkActuate",
17982        "xlink:actuate": "xlinkActuate",
17983        xlinkarcrole: "xlinkArcrole",
17984        "xlink:arcrole": "xlinkArcrole",
17985        xlinkhref: "xlinkHref",
17986        "xlink:href": "xlinkHref",
17987        xlinkrole: "xlinkRole",
17988        "xlink:role": "xlinkRole",
17989        xlinkshow: "xlinkShow",
17990        "xlink:show": "xlinkShow",
17991        xlinktitle: "xlinkTitle",
17992        "xlink:title": "xlinkTitle",
17993        xlinktype: "xlinkType",
17994        "xlink:type": "xlinkType",
17995        xmlbase: "xmlBase",
17996        "xml:base": "xmlBase",
17997        xmllang: "xmlLang",
17998        "xml:lang": "xmlLang",
17999        xmlns: "xmlns",
18000        "xml:space": "xmlSpace",
18001        xmlnsxlink: "xmlnsXlink",
18002        "xmlns:xlink": "xmlnsXlink",
18003        xmlspace: "xmlSpace",
18004        y1: "y1",
18005        y2: "y2",
18006        y: "y",
18007        ychannelselector: "yChannelSelector",
18008        z: "z",
18009        zoomandpan: "zoomAndPan"
18010      }, ariaProperties = {
18011        "aria-current": 0,
18012        "aria-description": 0,
18013        "aria-details": 0,
18014        "aria-disabled": 0,
18015        "aria-hidden": 0,
18016        "aria-invalid": 0,
18017        "aria-keyshortcuts": 0,
18018        "aria-label": 0,
18019        "aria-roledescription": 0,
18020        "aria-autocomplete": 0,
18021        "aria-checked": 0,
18022        "aria-expanded": 0,
18023        "aria-haspopup": 0,
18024        "aria-level": 0,
18025        "aria-modal": 0,
18026        "aria-multiline": 0,
18027        "aria-multiselectable": 0,
18028        "aria-orientation": 0,
18029        "aria-placeholder": 0,
18030        "aria-pressed": 0,
18031        "aria-readonly": 0,
18032        "aria-required": 0,
18033        "aria-selected": 0,
18034        "aria-sort": 0,
18035        "aria-valuemax": 0,
18036        "aria-valuemin": 0,
18037        "aria-valuenow": 0,
18038        "aria-valuetext": 0,
18039        "aria-atomic": 0,
18040        "aria-busy": 0,
18041        "aria-live": 0,
18042        "aria-relevant": 0,
18043        "aria-dropeffect": 0,
18044        "aria-grabbed": 0,
18045        "aria-activedescendant": 0,
18046        "aria-colcount": 0,
18047        "aria-colindex": 0,
18048        "aria-colspan": 0,
18049        "aria-controls": 0,
18050        "aria-describedby": 0,
18051        "aria-errormessage": 0,
18052        "aria-flowto": 0,
18053        "aria-labelledby": 0,
18054        "aria-owns": 0,
18055        "aria-posinset": 0,
18056        "aria-rowcount": 0,
18057        "aria-rowindex": 0,
18058        "aria-rowspan": 0,
18059        "aria-setsize": 0,
18060        "aria-braillelabel": 0,
18061        "aria-brailleroledescription": 0,
18062        "aria-colindextext": 0,
18063        "aria-rowindextext": 0
18064      }, warnedProperties$1 = {}, rARIA$1 = RegExp(
18065        "^(aria)-[:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$"
18066      ), rARIACamel$1 = RegExp(
18067        "^(aria)[A-Z][:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$"
18068      ), didWarnValueNull = false, warnedProperties = {}, EVENT_NAME_REGEX = /^on./, INVALID_EVENT_NAME_REGEX = /^on[^A-Z]/, rARIA = RegExp(
18069        "^(aria)-[:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$"
18070      ), rARIACamel = RegExp(
18071        "^(aria)[A-Z][:A-Z_a-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD\\-.0-9\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$"
18072      ), isJavaScriptProtocol = /^[\u0000-\u001F ]*j[\r\n\t]*a[\r\n\t]*v[\r\n\t]*a[\r\n\t]*s[\r\n\t]*c[\r\n\t]*r[\r\n\t]*i[\r\n\t]*p[\r\n\t]*t[\r\n\t]*:/i, currentReplayingEvent = null, restoreTarget = null, restoreQueue = null, isInsideEventHandler = false, canUseDOM = !("undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement), passiveBrowserEventsSupported = false;
18073      if (canUseDOM)
18074        try {
18075          var options$jscomp$0 = {};
18076          Object.defineProperty(options$jscomp$0, "passive", {
18077            get: function() {
18078              passiveBrowserEventsSupported = true;
18079            }
18080          });
18081          window.addEventListener("test", options$jscomp$0, options$jscomp$0);
18082          window.removeEventListener("test", options$jscomp$0, options$jscomp$0);
18083        } catch (e) {
18084          passiveBrowserEventsSupported = false;
18085        }
18086      var root = null, startText = null, fallbackText = null, EventInterface = {
18087        eventPhase: 0,
18088        bubbles: 0,
18089        cancelable: 0,
18090        timeStamp: function(event) {
18091          return event.timeStamp || Date.now();
18092        },
18093        defaultPrevented: 0,
18094        isTrusted: 0
18095      }, SyntheticEvent = createSyntheticEvent(EventInterface), UIEventInterface = assign({}, EventInterface, { view: 0, detail: 0 }), SyntheticUIEvent = createSyntheticEvent(UIEventInterface), lastMovementX, lastMovementY, lastMouseEvent, MouseEventInterface = assign({}, UIEventInterface, {
18096        screenX: 0,
18097        screenY: 0,
18098        clientX: 0,
18099        clientY: 0,
18100        pageX: 0,
18101        pageY: 0,
18102        ctrlKey: 0,
18103        shiftKey: 0,
18104        altKey: 0,
18105        metaKey: 0,
18106        getModifierState: getEventModifierState,
18107        button: 0,
18108        buttons: 0,
18109        relatedTarget: function(event) {
18110          return void 0 === event.relatedTarget ? event.fromElement === event.srcElement ? event.toElement : event.fromElement : event.relatedTarget;
18111        },
18112        movementX: function(event) {
18113          if ("movementX" in event) return event.movementX;
18114          event !== lastMouseEvent && (lastMouseEvent && "mousemove" === event.type ? (lastMovementX = event.screenX - lastMouseEvent.screenX, lastMovementY = event.screenY - lastMouseEvent.screenY) : lastMovementY = lastMovementX = 0, lastMouseEvent = event);
18115          return lastMovementX;
18116        },
18117        movementY: function(event) {
18118          return "movementY" in event ? event.movementY : lastMovementY;
18119        }
18120      }), SyntheticMouseEvent = createSyntheticEvent(MouseEventInterface), DragEventInterface = assign({}, MouseEventInterface, { dataTransfer: 0 }), SyntheticDragEvent = createSyntheticEvent(DragEventInterface), FocusEventInterface = assign({}, UIEventInterface, { relatedTarget: 0 }), SyntheticFocusEvent = createSyntheticEvent(FocusEventInterface), AnimationEventInterface = assign({}, EventInterface, {
18121        animationName: 0,
18122        elapsedTime: 0,
18123        pseudoElement: 0
18124      }), SyntheticAnimationEvent = createSyntheticEvent(AnimationEventInterface), ClipboardEventInterface = assign({}, EventInterface, {
18125        clipboardData: function(event) {
18126          return "clipboardData" in event ? event.clipboardData : window.clipboardData;
18127        }
18128      }), SyntheticClipboardEvent = createSyntheticEvent(ClipboardEventInterface), CompositionEventInterface = assign({}, EventInterface, { data: 0 }), SyntheticCompositionEvent = createSyntheticEvent(
18129        CompositionEventInterface
18130      ), SyntheticInputEvent = SyntheticCompositionEvent, normalizeKey = {
18131        Esc: "Escape",
18132        Spacebar: " ",
18133        Left: "ArrowLeft",
18134        Up: "ArrowUp",
18135        Right: "ArrowRight",
18136        Down: "ArrowDown",
18137        Del: "Delete",
18138        Win: "OS",
18139        Menu: "ContextMenu",
18140        Apps: "ContextMenu",
18141        Scroll: "ScrollLock",
18142        MozPrintableKey: "Unidentified"
18143      }, translateToKey = {
18144        8: "Backspace",
18145        9: "Tab",
18146        12: "Clear",
18147        13: "Enter",
18148        16: "Shift",
18149        17: "Control",
18150        18: "Alt",
18151        19: "Pause",
18152        20: "CapsLock",
18153        27: "Escape",
18154        32: " ",
18155        33: "PageUp",
18156        34: "PageDown",
18157        35: "End",
18158        36: "Home",
18159        37: "ArrowLeft",
18160        38: "ArrowUp",
18161        39: "ArrowRight",
18162        40: "ArrowDown",
18163        45: "Insert",
18164        46: "Delete",
18165        112: "F1",
18166        113: "F2",
18167        114: "F3",
18168        115: "F4",
18169        116: "F5",
18170        117: "F6",
18171        118: "F7",
18172        119: "F8",
18173        120: "F9",
18174        121: "F10",
18175        122: "F11",
18176        123: "F12",
18177        144: "NumLock",
18178        145: "ScrollLock",
18179        224: "Meta"
18180      }, modifierKeyToProp = {
18181        Alt: "altKey",
18182        Control: "ctrlKey",
18183        Meta: "metaKey",
18184        Shift: "shiftKey"
18185      }, KeyboardEventInterface = assign({}, UIEventInterface, {
18186        key: function(nativeEvent) {
18187          if (nativeEvent.key) {
18188            var key = normalizeKey[nativeEvent.key] || nativeEvent.key;
18189            if ("Unidentified" !== key) return key;
18190          }
18191          return "keypress" === nativeEvent.type ? (nativeEvent = getEventCharCode(nativeEvent), 13 === nativeEvent ? "Enter" : String.fromCharCode(nativeEvent)) : "keydown" === nativeEvent.type || "keyup" === nativeEvent.type ? translateToKey[nativeEvent.keyCode] || "Unidentified" : "";
18192        },
18193        code: 0,
18194        location: 0,
18195        ctrlKey: 0,
18196        shiftKey: 0,
18197        altKey: 0,
18198        metaKey: 0,
18199        repeat: 0,
18200        locale: 0,
18201        getModifierState: getEventModifierState,
18202        charCode: function(event) {
18203          return "keypress" === event.type ? getEventCharCode(event) : 0;
18204        },
18205        keyCode: function(event) {
18206          return "keydown" === event.type || "keyup" === event.type ? event.keyCode : 0;
18207        },
18208        which: function(event) {
18209          return "keypress" === event.type ? getEventCharCode(event) : "keydown" === event.type || "keyup" === event.type ? event.keyCode : 0;
18210        }
18211      }), SyntheticKeyboardEvent = createSyntheticEvent(KeyboardEventInterface), PointerEventInterface = assign({}, MouseEventInterface, {
18212        pointerId: 0,
18213        width: 0,
18214        height: 0,
18215        pressure: 0,
18216        tangentialPressure: 0,
18217        tiltX: 0,
18218        tiltY: 0,
18219        twist: 0,
18220        pointerType: 0,
18221        isPrimary: 0
18222      }), SyntheticPointerEvent = createSyntheticEvent(PointerEventInterface), TouchEventInterface = assign({}, UIEventInterface, {
18223        touches: 0,
18224        targetTouches: 0,
18225        changedTouches: 0,
18226        altKey: 0,
18227        metaKey: 0,
18228        ctrlKey: 0,
18229        shiftKey: 0,
18230        getModifierState: getEventModifierState
18231      }), SyntheticTouchEvent = createSyntheticEvent(TouchEventInterface), TransitionEventInterface = assign({}, EventInterface, {
18232        propertyName: 0,
18233        elapsedTime: 0,
18234        pseudoElement: 0
18235      }), SyntheticTransitionEvent = createSyntheticEvent(TransitionEventInterface), WheelEventInterface = assign({}, MouseEventInterface, {
18236        deltaX: function(event) {
18237          return "deltaX" in event ? event.deltaX : "wheelDeltaX" in event ? -event.wheelDeltaX : 0;
18238        },
18239        deltaY: function(event) {
18240          return "deltaY" in event ? event.deltaY : "wheelDeltaY" in event ? -event.wheelDeltaY : "wheelDelta" in event ? -event.wheelDelta : 0;
18241        },
18242        deltaZ: 0,
18243        deltaMode: 0
18244      }), SyntheticWheelEvent = createSyntheticEvent(WheelEventInterface), ToggleEventInterface = assign({}, EventInterface, {
18245        newState: 0,
18246        oldState: 0
18247      }), SyntheticToggleEvent = createSyntheticEvent(ToggleEventInterface), END_KEYCODES = [9, 13, 27, 32], START_KEYCODE = 229, canUseCompositionEvent = canUseDOM && "CompositionEvent" in window, documentMode = null;
18248      canUseDOM && "documentMode" in document && (documentMode = document.documentMode);
18249      var canUseTextInputEvent = canUseDOM && "TextEvent" in window && !documentMode, useFallbackCompositionData = canUseDOM && (!canUseCompositionEvent || documentMode && 8 < documentMode && 11 >= documentMode), SPACEBAR_CODE = 32, SPACEBAR_CHAR = String.fromCharCode(SPACEBAR_CODE), hasSpaceKeypress = false, isComposing = false, supportedInputTypes = {
18250        color: true,
18251        date: true,
18252        datetime: true,
18253        "datetime-local": true,
18254        email: true,
18255        month: true,
18256        number: true,
18257        password: true,
18258        range: true,
18259        search: true,
18260        tel: true,
18261        text: true,
18262        time: true,
18263        url: true,
18264        week: true
18265      }, activeElement$1 = null, activeElementInst$1 = null, isInputEventSupported = false;
18266      canUseDOM && (isInputEventSupported = isEventSupported("input") && (!document.documentMode || 9 < document.documentMode));
18267      var objectIs = "function" === typeof Object.is ? Object.is : is, skipSelectionChangeEvent = canUseDOM && "documentMode" in document && 11 >= document.documentMode, activeElement = null, activeElementInst = null, lastSelection = null, mouseDown = false, vendorPrefixes = {
18268        animationend: makePrefixMap("Animation", "AnimationEnd"),
18269        animationiteration: makePrefixMap("Animation", "AnimationIteration"),
18270        animationstart: makePrefixMap("Animation", "AnimationStart"),
18271        transitionrun: makePrefixMap("Transition", "TransitionRun"),
18272        transitionstart: makePrefixMap("Transition", "TransitionStart"),
18273        transitioncancel: makePrefixMap("Transition", "TransitionCancel"),
18274        transitionend: makePrefixMap("Transition", "TransitionEnd")
18275      }, prefixedEventNames = {}, style = {};
18276      canUseDOM && (style = document.createElement("div").style, "AnimationEvent" in window || (delete vendorPrefixes.animationend.animation, delete vendorPrefixes.animationiteration.animation, delete vendorPrefixes.animationstart.animation), "TransitionEvent" in window || delete vendorPrefixes.transitionend.transition);
18277      var ANIMATION_END = getVendorPrefixedEventName("animationend"), ANIMATION_ITERATION = getVendorPrefixedEventName("animationiteration"), ANIMATION_START = getVendorPrefixedEventName("animationstart"), TRANSITION_RUN = getVendorPrefixedEventName("transitionrun"), TRANSITION_START = getVendorPrefixedEventName("transitionstart"), TRANSITION_CANCEL = getVendorPrefixedEventName("transitioncancel"), TRANSITION_END = getVendorPrefixedEventName("transitionend"), topLevelEventsToReactNames = /* @__PURE__ */ new Map(), simpleEventPluginEvents = "abort auxClick beforeToggle cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel".split(
18278        " "
18279      );
18280      simpleEventPluginEvents.push("scrollEnd");
18281      var lastResetTime = 0;
18282      if ("object" === typeof performance && "function" === typeof performance.now) {
18283        var localPerformance = performance;
18284        var getCurrentTime = function() {
18285          return localPerformance.now();
18286        };
18287      } else {
18288        var localDate = Date;
18289        getCurrentTime = function() {
18290          return localDate.now();
18291        };
18292      }
18293      var reportGlobalError = "function" === typeof reportError ? reportError : function(error) {
18294        if ("object" === typeof window && "function" === typeof window.ErrorEvent) {
18295          var event = new window.ErrorEvent("error", {
18296            bubbles: true,
18297            cancelable: true,
18298            message: "object" === typeof error && null !== error && "string" === typeof error.message ? String(error.message) : String(error),
18299            error
18300          });
18301          if (!window.dispatchEvent(event)) return;
18302        } else if ("object" === typeof process && "function" === typeof process.emit) {
18303          process.emit("uncaughtException", error);
18304          return;
18305        }
18306        console.error(error);
18307      }, OMITTED_PROP_ERROR = "This object has been omitted by React in the console log to avoid sending too much data from the server. Try logging smaller or more specific objects.", EMPTY_ARRAY = 0, COMPLEX_ARRAY = 1, PRIMITIVE_ARRAY = 2, ENTRIES_ARRAY = 3, REMOVED = "– ", ADDED = "+ ", UNCHANGED = "  ", supportsUserTiming = "undefined" !== typeof console && "function" === typeof console.timeStamp && "undefined" !== typeof performance && "function" === typeof performance.measure, COMPONENTS_TRACK = "Components ⚛", LANES_TRACK_GROUP = "Scheduler ⚛", currentTrack = "Blocking", alreadyWarnedForDeepEquality = false, reusableComponentDevToolDetails = {
18308        color: "primary",
18309        properties: null,
18310        tooltipText: "",
18311        track: COMPONENTS_TRACK
18312      }, reusableComponentOptions = {
18313        start: -0,
18314        end: -0,
18315        detail: { devtools: reusableComponentDevToolDetails }
18316      }, resuableChangedPropsEntry = ["Changed Props", ""], DEEP_EQUALITY_WARNING = "This component received deeply equal props. It might benefit from useMemo or the React Compiler in its owner.", reusableDeeplyEqualPropsEntry = ["Changed Props", DEEP_EQUALITY_WARNING], OffscreenVisible = 1, OffscreenPassiveEffectsConnected = 2, concurrentQueues = [], concurrentQueuesIndex = 0, concurrentlyUpdatedLanes = 0, emptyContextObject = {};
18317      Object.freeze(emptyContextObject);
18318      var resolveFamily = null, failedBoundaries = null, NoMode = 0, ConcurrentMode = 1, ProfileMode = 2, StrictLegacyMode = 8, StrictEffectsMode = 16, SuspenseyImagesMode = 32;
18319      var hasBadMapPolyfill = false;
18320      try {
18321        var nonExtensibleObject = Object.preventExtensions({});
18322        /* @__PURE__ */ new Map([[nonExtensibleObject, null]]);
18323        /* @__PURE__ */ new Set([nonExtensibleObject]);
18324      } catch (e$3) {
18325        hasBadMapPolyfill = true;
18326      }
18327      var CapturedStacks = /* @__PURE__ */ new WeakMap(), forkStack = [], forkStackIndex = 0, treeForkProvider = null, treeForkCount = 0, idStack = [], idStackIndex = 0, treeContextProvider = null, treeContextId = 1, treeContextOverflow = "", hydrationParentFiber = null, nextHydratableInstance = null, isHydrating = false, didSuspendOrErrorDEV = false, hydrationDiffRootDEV = null, hydrationErrors = null, rootOrSingletonContext = false, HydrationMismatchException = Error(
18328        "Hydration Mismatch Exception: This is not a real error, and should not leak into userspace. If you're seeing this, it's likely a bug in React."
18329      ), valueCursor = createCursor(null);
18330      var rendererCursorDEV = createCursor(null);
18331      var rendererSigil = {};
18332      var currentlyRenderingFiber$1 = null, lastContextDependency = null, isDisallowedContextReadInDEV = false, AbortControllerLocal = "undefined" !== typeof AbortController ? AbortController : function() {
18333        var listeners = [], signal = this.signal = {
18334          aborted: false,
18335          addEventListener: function(type, listener) {
18336            listeners.push(listener);
18337          }
18338        };
18339        this.abort = function() {
18340          signal.aborted = true;
18341          listeners.forEach(function(listener) {
18342            return listener();
18343          });
18344        };
18345      }, scheduleCallback$2 = Scheduler.unstable_scheduleCallback, NormalPriority = Scheduler.unstable_NormalPriority, CacheContext = {
18346        $$typeof: REACT_CONTEXT_TYPE,
18347        Consumer: null,
18348        Provider: null,
18349        _currentValue: null,
18350        _currentValue2: null,
18351        _threadCount: 0,
18352        _currentRenderer: null,
18353        _currentRenderer2: null
18354      }, now = Scheduler.unstable_now, createTask = console.createTask ? console.createTask : function() {
18355        return null;
18356      }, SPAWNED_UPDATE = 1, PINGED_UPDATE = 2, renderStartTime = -0, commitStartTime = -0, commitEndTime = -0, commitErrors = null, profilerStartTime = -1.1, profilerEffectDuration = -0, componentEffectDuration = -0, componentEffectStartTime = -1.1, componentEffectEndTime = -1.1, componentEffectErrors = null, componentEffectSpawnedUpdate = false, blockingClampTime = -0, blockingUpdateTime = -1.1, blockingUpdateTask = null, blockingUpdateType = 0, blockingUpdateMethodName = null, blockingUpdateComponentName = null, blockingEventTime = -1.1, blockingEventType = null, blockingEventRepeatTime = -1.1, blockingSuspendedTime = -1.1, transitionClampTime = -0, transitionStartTime = -1.1, transitionUpdateTime = -1.1, transitionUpdateType = 0, transitionUpdateTask = null, transitionUpdateMethodName = null, transitionUpdateComponentName = null, transitionEventTime = -1.1, transitionEventType = null, transitionEventRepeatTime = -1.1, transitionSuspendedTime = -1.1, retryClampTime = -0, idleClampTime = -0, animatingLanes = 0, animatingTask = null, yieldReason = 0, yieldStartTime = -1.1, currentUpdateIsNested = false, nestedUpdateScheduled = false, currentEntangledListeners = null, currentEntangledPendingCount = 0, currentEntangledLane = 0, currentEntangledActionThenable = null, prevOnStartTransitionFinish = ReactSharedInternals.S;
18357      ReactSharedInternals.S = function(transition, returnValue) {
18358        globalMostRecentTransitionTime = now$1();
18359        if ("object" === typeof returnValue && null !== returnValue && "function" === typeof returnValue.then) {
18360          if (0 > transitionStartTime && 0 > transitionUpdateTime) {
18361            transitionStartTime = now();
18362            var newEventTime = resolveEventTimeStamp(), newEventType = resolveEventType();
18363            if (newEventTime !== transitionEventRepeatTime || newEventType !== transitionEventType)
18364              transitionEventRepeatTime = -1.1;
18365            transitionEventTime = newEventTime;
18366            transitionEventType = newEventType;
18367          }
18368          entangleAsyncAction(transition, returnValue);
18369        }
18370        null !== prevOnStartTransitionFinish && prevOnStartTransitionFinish(transition, returnValue);
18371      };
18372      var resumedCache = createCursor(null), ReactStrictModeWarnings = {
18373        recordUnsafeLifecycleWarnings: function() {
18374        },
18375        flushPendingUnsafeLifecycleWarnings: function() {
18376        },
18377        recordLegacyContextWarning: function() {
18378        },
18379        flushLegacyContextWarning: function() {
18380        },
18381        discardPendingWarnings: function() {
18382        }
18383      }, pendingComponentWillMountWarnings = [], pendingUNSAFE_ComponentWillMountWarnings = [], pendingComponentWillReceivePropsWarnings = [], pendingUNSAFE_ComponentWillReceivePropsWarnings = [], pendingComponentWillUpdateWarnings = [], pendingUNSAFE_ComponentWillUpdateWarnings = [], didWarnAboutUnsafeLifecycles = /* @__PURE__ */ new Set();
18384      ReactStrictModeWarnings.recordUnsafeLifecycleWarnings = function(fiber, instance) {
18385        didWarnAboutUnsafeLifecycles.has(fiber.type) || ("function" === typeof instance.componentWillMount && true !== instance.componentWillMount.__suppressDeprecationWarning && pendingComponentWillMountWarnings.push(fiber), fiber.mode & StrictLegacyMode && "function" === typeof instance.UNSAFE_componentWillMount && pendingUNSAFE_ComponentWillMountWarnings.push(fiber), "function" === typeof instance.componentWillReceiveProps && true !== instance.componentWillReceiveProps.__suppressDeprecationWarning && pendingComponentWillReceivePropsWarnings.push(fiber), fiber.mode & StrictLegacyMode && "function" === typeof instance.UNSAFE_componentWillReceiveProps && pendingUNSAFE_ComponentWillReceivePropsWarnings.push(fiber), "function" === typeof instance.componentWillUpdate && true !== instance.componentWillUpdate.__suppressDeprecationWarning && pendingComponentWillUpdateWarnings.push(fiber), fiber.mode & StrictLegacyMode && "function" === typeof instance.UNSAFE_componentWillUpdate && pendingUNSAFE_ComponentWillUpdateWarnings.push(fiber));
18386      };
18387      ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings = function() {
18388        var componentWillMountUniqueNames = /* @__PURE__ */ new Set();
18389        0 < pendingComponentWillMountWarnings.length && (pendingComponentWillMountWarnings.forEach(function(fiber) {
18390          componentWillMountUniqueNames.add(
18391            getComponentNameFromFiber(fiber) || "Component"
18392          );
18393          didWarnAboutUnsafeLifecycles.add(fiber.type);
18394        }), pendingComponentWillMountWarnings = []);
18395        var UNSAFE_componentWillMountUniqueNames = /* @__PURE__ */ new Set();
18396        0 < pendingUNSAFE_ComponentWillMountWarnings.length && (pendingUNSAFE_ComponentWillMountWarnings.forEach(function(fiber) {
18397          UNSAFE_componentWillMountUniqueNames.add(
18398            getComponentNameFromFiber(fiber) || "Component"
18399          );
18400          didWarnAboutUnsafeLifecycles.add(fiber.type);
18401        }), pendingUNSAFE_ComponentWillMountWarnings = []);
18402        var componentWillReceivePropsUniqueNames = /* @__PURE__ */ new Set();
18403        0 < pendingComponentWillReceivePropsWarnings.length && (pendingComponentWillReceivePropsWarnings.forEach(function(fiber) {
18404          componentWillReceivePropsUniqueNames.add(
18405            getComponentNameFromFiber(fiber) || "Component"
18406          );
18407          didWarnAboutUnsafeLifecycles.add(fiber.type);
18408        }), pendingComponentWillReceivePropsWarnings = []);
18409        var UNSAFE_componentWillReceivePropsUniqueNames = /* @__PURE__ */ new Set();
18410        0 < pendingUNSAFE_ComponentWillReceivePropsWarnings.length && (pendingUNSAFE_ComponentWillReceivePropsWarnings.forEach(
18411          function(fiber) {
18412            UNSAFE_componentWillReceivePropsUniqueNames.add(
18413              getComponentNameFromFiber(fiber) || "Component"
18414            );
18415            didWarnAboutUnsafeLifecycles.add(fiber.type);
18416          }
18417        ), pendingUNSAFE_ComponentWillReceivePropsWarnings = []);
18418        var componentWillUpdateUniqueNames = /* @__PURE__ */ new Set();
18419        0 < pendingComponentWillUpdateWarnings.length && (pendingComponentWillUpdateWarnings.forEach(function(fiber) {
18420          componentWillUpdateUniqueNames.add(
18421            getComponentNameFromFiber(fiber) || "Component"
18422          );
18423          didWarnAboutUnsafeLifecycles.add(fiber.type);
18424        }), pendingComponentWillUpdateWarnings = []);
18425        var UNSAFE_componentWillUpdateUniqueNames = /* @__PURE__ */ new Set();
18426        0 < pendingUNSAFE_ComponentWillUpdateWarnings.length && (pendingUNSAFE_ComponentWillUpdateWarnings.forEach(function(fiber) {
18427          UNSAFE_componentWillUpdateUniqueNames.add(
18428            getComponentNameFromFiber(fiber) || "Component"
18429          );
18430          didWarnAboutUnsafeLifecycles.add(fiber.type);
18431        }), pendingUNSAFE_ComponentWillUpdateWarnings = []);
18432        if (0 < UNSAFE_componentWillMountUniqueNames.size) {
18433          var sortedNames = setToSortedString(
18434            UNSAFE_componentWillMountUniqueNames
18435          );
18436          console.error(
18437            "Using UNSAFE_componentWillMount in strict mode is not recommended and may indicate bugs in your code. See https://react.dev/link/unsafe-component-lifecycles for details.\n\n* Move code with side effects to componentDidMount, and set initial state in the constructor.\n\nPlease update the following components: %s",
18438            sortedNames
18439          );
18440        }
18441        0 < UNSAFE_componentWillReceivePropsUniqueNames.size && (sortedNames = setToSortedString(
18442          UNSAFE_componentWillReceivePropsUniqueNames
18443        ), console.error(
18444          "Using UNSAFE_componentWillReceiveProps in strict mode is not recommended and may indicate bugs in your code. See https://react.dev/link/unsafe-component-lifecycles for details.\n\n* Move data fetching code or side effects to componentDidUpdate.\n* If you're updating state whenever props change, refactor your code to use memoization techniques or move it to static getDerivedStateFromProps. Learn more at: https://react.dev/link/derived-state\n\nPlease update the following components: %s",
18445          sortedNames
18446        ));
18447        0 < UNSAFE_componentWillUpdateUniqueNames.size && (sortedNames = setToSortedString(
18448          UNSAFE_componentWillUpdateUniqueNames
18449        ), console.error(
18450          "Using UNSAFE_componentWillUpdate in strict mode is not recommended and may indicate bugs in your code. See https://react.dev/link/unsafe-component-lifecycles for details.\n\n* Move data fetching code or side effects to componentDidUpdate.\n\nPlease update the following components: %s",
18451          sortedNames
18452        ));
18453        0 < componentWillMountUniqueNames.size && (sortedNames = setToSortedString(componentWillMountUniqueNames), console.warn(
18454          "componentWillMount has been renamed, and is not recommended for use. See https://react.dev/link/unsafe-component-lifecycles for details.\n\n* Move code with side effects to componentDidMount, and set initial state in the constructor.\n* Rename componentWillMount to UNSAFE_componentWillMount to suppress this warning in non-strict mode. In React 18.x, only the UNSAFE_ name will work. To rename all deprecated lifecycles to their new names, you can run `npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n\nPlease update the following components: %s",
18455          sortedNames
18456        ));
18457        0 < componentWillReceivePropsUniqueNames.size && (sortedNames = setToSortedString(
18458          componentWillReceivePropsUniqueNames
18459        ), console.warn(
18460          "componentWillReceiveProps has been renamed, and is not recommended for use. See https://react.dev/link/unsafe-component-lifecycles for details.\n\n* Move data fetching code or side effects to componentDidUpdate.\n* If you're updating state whenever props change, refactor your code to use memoization techniques or move it to static getDerivedStateFromProps. Learn more at: https://react.dev/link/derived-state\n* Rename componentWillReceiveProps to UNSAFE_componentWillReceiveProps to suppress this warning in non-strict mode. In React 18.x, only the UNSAFE_ name will work. To rename all deprecated lifecycles to their new names, you can run `npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n\nPlease update the following components: %s",
18461          sortedNames
18462        ));
18463        0 < componentWillUpdateUniqueNames.size && (sortedNames = setToSortedString(componentWillUpdateUniqueNames), console.warn(
18464          "componentWillUpdate has been renamed, and is not recommended for use. See https://react.dev/link/unsafe-component-lifecycles for details.\n\n* Move data fetching code or side effects to componentDidUpdate.\n* Rename componentWillUpdate to UNSAFE_componentWillUpdate to suppress this warning in non-strict mode. In React 18.x, only the UNSAFE_ name will work. To rename all deprecated lifecycles to their new names, you can run `npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n\nPlease update the following components: %s",
18465          sortedNames
18466        ));
18467      };
18468      var pendingLegacyContextWarning = /* @__PURE__ */ new Map(), didWarnAboutLegacyContext = /* @__PURE__ */ new Set();
18469      ReactStrictModeWarnings.recordLegacyContextWarning = function(fiber, instance) {
18470        var strictRoot = null;
18471        for (var node = fiber; null !== node; )
18472          node.mode & StrictLegacyMode && (strictRoot = node), node = node.return;
18473        null === strictRoot ? console.error(
18474          "Expected to find a StrictMode component in a strict mode tree. This error is likely caused by a bug in React. Please file an issue."
18475        ) : !didWarnAboutLegacyContext.has(fiber.type) && (node = pendingLegacyContextWarning.get(strictRoot), null != fiber.type.contextTypes || null != fiber.type.childContextTypes || null !== instance && "function" === typeof instance.getChildContext) && (void 0 === node && (node = [], pendingLegacyContextWarning.set(strictRoot, node)), node.push(fiber));
18476      };
18477      ReactStrictModeWarnings.flushLegacyContextWarning = function() {
18478        pendingLegacyContextWarning.forEach(function(fiberArray) {
18479          if (0 !== fiberArray.length) {
18480            var firstFiber = fiberArray[0], uniqueNames = /* @__PURE__ */ new Set();
18481            fiberArray.forEach(function(fiber) {
18482              uniqueNames.add(getComponentNameFromFiber(fiber) || "Component");
18483              didWarnAboutLegacyContext.add(fiber.type);
18484            });
18485            var sortedNames = setToSortedString(uniqueNames);
18486            runWithFiberInDEV(firstFiber, function() {
18487              console.error(
18488                "Legacy context API has been detected within a strict-mode tree.\n\nThe old API will be supported in all 16.x releases, but applications using it should migrate to the new version.\n\nPlease update the following components: %s\n\nLearn more about this warning here: https://react.dev/link/legacy-context",
18489                sortedNames
18490              );
18491            });
18492          }
18493        });
18494      };
18495      ReactStrictModeWarnings.discardPendingWarnings = function() {
18496        pendingComponentWillMountWarnings = [];
18497        pendingUNSAFE_ComponentWillMountWarnings = [];
18498        pendingComponentWillReceivePropsWarnings = [];
18499        pendingUNSAFE_ComponentWillReceivePropsWarnings = [];
18500        pendingComponentWillUpdateWarnings = [];
18501        pendingUNSAFE_ComponentWillUpdateWarnings = [];
18502        pendingLegacyContextWarning = /* @__PURE__ */ new Map();
18503      };
18504      var callComponent = {
18505        react_stack_bottom_frame: function(Component, props, secondArg) {
18506          var wasRendering = isRendering;
18507          isRendering = true;
18508          try {
18509            return Component(props, secondArg);
18510          } finally {
18511            isRendering = wasRendering;
18512          }
18513        }
18514      }, callComponentInDEV = callComponent.react_stack_bottom_frame.bind(callComponent), callRender = {
18515        react_stack_bottom_frame: function(instance) {
18516          var wasRendering = isRendering;
18517          isRendering = true;
18518          try {
18519            return instance.render();
18520          } finally {
18521            isRendering = wasRendering;
18522          }
18523        }
18524      }, callRenderInDEV = callRender.react_stack_bottom_frame.bind(callRender), callComponentDidMount = {
18525        react_stack_bottom_frame: function(finishedWork, instance) {
18526          try {
18527            instance.componentDidMount();
18528          } catch (error) {
18529            captureCommitPhaseError(finishedWork, finishedWork.return, error);
18530          }
18531        }
18532      }, callComponentDidMountInDEV = callComponentDidMount.react_stack_bottom_frame.bind(
18533        callComponentDidMount
18534      ), callComponentDidUpdate = {
18535        react_stack_bottom_frame: function(finishedWork, instance, prevProps, prevState, snapshot) {
18536          try {
18537            instance.componentDidUpdate(prevProps, prevState, snapshot);
18538          } catch (error) {
18539            captureCommitPhaseError(finishedWork, finishedWork.return, error);
18540          }
18541        }
18542      }, callComponentDidUpdateInDEV = callComponentDidUpdate.react_stack_bottom_frame.bind(
18543        callComponentDidUpdate
18544      ), callComponentDidCatch = {
18545        react_stack_bottom_frame: function(instance, errorInfo) {
18546          var stack = errorInfo.stack;
18547          instance.componentDidCatch(errorInfo.value, {
18548            componentStack: null !== stack ? stack : ""
18549          });
18550        }
18551      }, callComponentDidCatchInDEV = callComponentDidCatch.react_stack_bottom_frame.bind(
18552        callComponentDidCatch
18553      ), callComponentWillUnmount = {
18554        react_stack_bottom_frame: function(current2, nearestMountedAncestor, instance) {
18555          try {
18556            instance.componentWillUnmount();
18557          } catch (error) {
18558            captureCommitPhaseError(current2, nearestMountedAncestor, error);
18559          }
18560        }
18561      }, callComponentWillUnmountInDEV = callComponentWillUnmount.react_stack_bottom_frame.bind(
18562        callComponentWillUnmount
18563      ), callCreate = {
18564        react_stack_bottom_frame: function(effect) {
18565          var create = effect.create;
18566          effect = effect.inst;
18567          create = create();
18568          return effect.destroy = create;
18569        }
18570      }, callCreateInDEV = callCreate.react_stack_bottom_frame.bind(callCreate), callDestroy = {
18571        react_stack_bottom_frame: function(current2, nearestMountedAncestor, destroy) {
18572          try {
18573            destroy();
18574          } catch (error) {
18575            captureCommitPhaseError(current2, nearestMountedAncestor, error);
18576          }
18577        }
18578      }, callDestroyInDEV = callDestroy.react_stack_bottom_frame.bind(callDestroy), callLazyInit = {
18579        react_stack_bottom_frame: function(lazy) {
18580          var init = lazy._init;
18581          return init(lazy._payload);
18582        }
18583      }, callLazyInitInDEV = callLazyInit.react_stack_bottom_frame.bind(callLazyInit), SuspenseException = Error(
18584        "Suspense Exception: This is not a real error! It's an implementation detail of `use` to interrupt the current render. You must either rethrow it immediately, or move the `use` call outside of the `try/catch` block. Capturing without rethrowing will lead to unexpected behavior.\n\nTo handle async errors, wrap your component in an error boundary, or call the promise's `.catch` method and pass the result to `use`."
18585      ), SuspenseyCommitException = Error(
18586        "Suspense Exception: This is not a real error, and should not leak into userspace. If you're seeing this, it's likely a bug in React."
18587      ), SuspenseActionException = Error(
18588        "Suspense Exception: This is not a real error! It's an implementation detail of `useActionState` to interrupt the current render. You must either rethrow it immediately, or move the `useActionState` call outside of the `try/catch` block. Capturing without rethrowing will lead to unexpected behavior.\n\nTo handle async errors, wrap your component in an error boundary."
18589      ), noopSuspenseyCommitThenable = {
18590        then: function() {
18591          console.error(
18592            'Internal React error: A listener was unexpectedly attached to a "noop" thenable. This is a bug in React. Please file an issue.'
18593          );
18594        }
18595      }, suspendedThenable = null, needsToResetSuspendedThenableDEV = false, thenableState$1 = null, thenableIndexCounter$1 = 0, currentDebugInfo = null, didWarnAboutMaps;
18596      var didWarnAboutGenerators = didWarnAboutMaps = false;
18597      var ownerHasKeyUseWarning = {};
18598      var ownerHasFunctionTypeWarning = {};
18599      var ownerHasSymbolTypeWarning = {};
18600      warnForMissingKey = function(returnFiber, workInProgress2, child) {
18601        if (null !== child && "object" === typeof child && child._store && (!child._store.validated && null == child.key || 2 === child._store.validated)) {
18602          if ("object" !== typeof child._store)
18603            throw Error(
18604              "React Component in warnForMissingKey should have a _store. This error is likely caused by a bug in React. Please file an issue."
18605            );
18606          child._store.validated = 1;
18607          var componentName2 = getComponentNameFromFiber(returnFiber), componentKey = componentName2 || "null";
18608          if (!ownerHasKeyUseWarning[componentKey]) {
18609            ownerHasKeyUseWarning[componentKey] = true;
18610            child = child._owner;
18611            returnFiber = returnFiber._debugOwner;
18612            var currentComponentErrorInfo = "";
18613            returnFiber && "number" === typeof returnFiber.tag && (componentKey = getComponentNameFromFiber(returnFiber)) && (currentComponentErrorInfo = "\n\nCheck the render method of `" + componentKey + "`.");
18614            currentComponentErrorInfo || componentName2 && (currentComponentErrorInfo = "\n\nCheck the top-level render call using <" + componentName2 + ">.");
18615            var childOwnerAppendix = "";
18616            null != child && returnFiber !== child && (componentName2 = null, "number" === typeof child.tag ? componentName2 = getComponentNameFromFiber(child) : "string" === typeof child.name && (componentName2 = child.name), componentName2 && (childOwnerAppendix = " It was passed a child from " + componentName2 + "."));
18617            runWithFiberInDEV(workInProgress2, function() {
18618              console.error(
18619                'Each child in a list should have a unique "key" prop.%s%s See https://react.dev/link/warning-keys for more information.',
18620                currentComponentErrorInfo,
18621                childOwnerAppendix
18622              );
18623            });
18624          }
18625        }
18626      };
18627      var reconcileChildFibers = createChildReconciler(true), mountChildFibers = createChildReconciler(false), UpdateState = 0, ReplaceState = 1, ForceUpdate = 2, CaptureUpdate = 3, hasForceUpdate = false;
18628      var didWarnUpdateInsideUpdate = false;
18629      var currentlyProcessingQueue = null;
18630      var didReadFromEntangledAsyncAction = false, currentTreeHiddenStackCursor = createCursor(null), prevEntangledRenderLanesCursor = createCursor(0), suspenseHandlerStackCursor = createCursor(null), shellBoundary = null, SubtreeSuspenseContextMask = 1, ForceSuspenseFallback = 2, suspenseStackCursor = createCursor(0), NoFlags = 0, HasEffect = 1, Insertion = 2, Layout = 4, Passive = 8, didWarnUncachedGetSnapshot;
18631      var didWarnAboutMismatchedHooksForComponent = /* @__PURE__ */ new Set();
18632      var didWarnAboutUseWrappedInTryCatch = /* @__PURE__ */ new Set();
18633      var didWarnAboutAsyncClientComponent = /* @__PURE__ */ new Set();
18634      var didWarnAboutUseFormState = /* @__PURE__ */ new Set();
18635      var renderLanes = 0, currentlyRenderingFiber = null, currentHook = null, workInProgressHook = null, didScheduleRenderPhaseUpdate = false, didScheduleRenderPhaseUpdateDuringThisPass = false, shouldDoubleInvokeUserFnsInHooksDEV = false, localIdCounter = 0, thenableIndexCounter = 0, thenableState = null, globalClientIdCounter = 0, RE_RENDER_LIMIT = 25, currentHookNameInDev = null, hookTypesDev = null, hookTypesUpdateIndexDev = -1, ignorePreviousDependencies = false, ContextOnlyDispatcher = {
18636        readContext,
18637        use,
18638        useCallback: throwInvalidHookError,
18639        useContext: throwInvalidHookError,
18640        useEffect: throwInvalidHookError,
18641        useImperativeHandle: throwInvalidHookError,
18642        useLayoutEffect: throwInvalidHookError,
18643        useInsertionEffect: throwInvalidHookError,
18644        useMemo: throwInvalidHookError,
18645        useReducer: throwInvalidHookError,
18646        useRef: throwInvalidHookError,
18647        useState: throwInvalidHookError,
18648        useDebugValue: throwInvalidHookError,
18649        useDeferredValue: throwInvalidHookError,
18650        useTransition: throwInvalidHookError,
18651        useSyncExternalStore: throwInvalidHookError,
18652        useId: throwInvalidHookError,
18653        useHostTransitionStatus: throwInvalidHookError,
18654        useFormState: throwInvalidHookError,
18655        useActionState: throwInvalidHookError,
18656        useOptimistic: throwInvalidHookError,
18657        useMemoCache: throwInvalidHookError,
18658        useCacheRefresh: throwInvalidHookError
18659      };
18660      ContextOnlyDispatcher.useEffectEvent = throwInvalidHookError;
18661      var HooksDispatcherOnMountInDEV = null, HooksDispatcherOnMountWithHookTypesInDEV = null, HooksDispatcherOnUpdateInDEV = null, HooksDispatcherOnRerenderInDEV = null, InvalidNestedHooksDispatcherOnMountInDEV = null, InvalidNestedHooksDispatcherOnUpdateInDEV = null, InvalidNestedHooksDispatcherOnRerenderInDEV = null;
18662      HooksDispatcherOnMountInDEV = {
18663        readContext: function(context) {
18664          return readContext(context);
18665        },
18666        use,
18667        useCallback: function(callback, deps) {
18668          currentHookNameInDev = "useCallback";
18669          mountHookTypesDev();
18670          checkDepsAreArrayDev(deps);
18671          return mountCallback(callback, deps);
18672        },
18673        useContext: function(context) {
18674          currentHookNameInDev = "useContext";
18675          mountHookTypesDev();
18676          return readContext(context);
18677        },
18678        useEffect: function(create, deps) {
18679          currentHookNameInDev = "useEffect";
18680          mountHookTypesDev();
18681          checkDepsAreArrayDev(deps);
18682          return mountEffect(create, deps);
18683        },
18684        useImperativeHandle: function(ref, create, deps) {
18685          currentHookNameInDev = "useImperativeHandle";
18686          mountHookTypesDev();
18687          checkDepsAreArrayDev(deps);
18688          return mountImperativeHandle(ref, create, deps);
18689        },
18690        useInsertionEffect: function(create, deps) {
18691          currentHookNameInDev = "useInsertionEffect";
18692          mountHookTypesDev();
18693          checkDepsAreArrayDev(deps);
18694          mountEffectImpl(4, Insertion, create, deps);
18695        },
18696        useLayoutEffect: function(create, deps) {
18697          currentHookNameInDev = "useLayoutEffect";
18698          mountHookTypesDev();
18699          checkDepsAreArrayDev(deps);
18700          return mountLayoutEffect(create, deps);
18701        },
18702        useMemo: function(create, deps) {
18703          currentHookNameInDev = "useMemo";
18704          mountHookTypesDev();
18705          checkDepsAreArrayDev(deps);
18706          var prevDispatcher = ReactSharedInternals.H;
18707          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnMountInDEV;
18708          try {
18709            return mountMemo(create, deps);
18710          } finally {
18711            ReactSharedInternals.H = prevDispatcher;
18712          }
18713        },
18714        useReducer: function(reducer, initialArg, init) {
18715          currentHookNameInDev = "useReducer";
18716          mountHookTypesDev();
18717          var prevDispatcher = ReactSharedInternals.H;
18718          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnMountInDEV;
18719          try {
18720            return mountReducer(reducer, initialArg, init);
18721          } finally {
18722            ReactSharedInternals.H = prevDispatcher;
18723          }
18724        },
18725        useRef: function(initialValue) {
18726          currentHookNameInDev = "useRef";
18727          mountHookTypesDev();
18728          return mountRef(initialValue);
18729        },
18730        useState: function(initialState) {
18731          currentHookNameInDev = "useState";
18732          mountHookTypesDev();
18733          var prevDispatcher = ReactSharedInternals.H;
18734          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnMountInDEV;
18735          try {
18736            return mountState(initialState);
18737          } finally {
18738            ReactSharedInternals.H = prevDispatcher;
18739          }
18740        },
18741        useDebugValue: function() {
18742          currentHookNameInDev = "useDebugValue";
18743          mountHookTypesDev();
18744        },
18745        useDeferredValue: function(value, initialValue) {
18746          currentHookNameInDev = "useDeferredValue";
18747          mountHookTypesDev();
18748          return mountDeferredValue(value, initialValue);
18749        },
18750        useTransition: function() {
18751          currentHookNameInDev = "useTransition";
18752          mountHookTypesDev();
18753          return mountTransition();
18754        },
18755        useSyncExternalStore: function(subscribe, getSnapshot, getServerSnapshot) {
18756          currentHookNameInDev = "useSyncExternalStore";
18757          mountHookTypesDev();
18758          return mountSyncExternalStore(
18759            subscribe,
18760            getSnapshot,
18761            getServerSnapshot
18762          );
18763        },
18764        useId: function() {
18765          currentHookNameInDev = "useId";
18766          mountHookTypesDev();
18767          return mountId();
18768        },
18769        useFormState: function(action, initialState) {
18770          currentHookNameInDev = "useFormState";
18771          mountHookTypesDev();
18772          warnOnUseFormStateInDev();
18773          return mountActionState(action, initialState);
18774        },
18775        useActionState: function(action, initialState) {
18776          currentHookNameInDev = "useActionState";
18777          mountHookTypesDev();
18778          return mountActionState(action, initialState);
18779        },
18780        useOptimistic: function(passthrough) {
18781          currentHookNameInDev = "useOptimistic";
18782          mountHookTypesDev();
18783          return mountOptimistic(passthrough);
18784        },
18785        useHostTransitionStatus,
18786        useMemoCache,
18787        useCacheRefresh: function() {
18788          currentHookNameInDev = "useCacheRefresh";
18789          mountHookTypesDev();
18790          return mountRefresh();
18791        },
18792        useEffectEvent: function(callback) {
18793          currentHookNameInDev = "useEffectEvent";
18794          mountHookTypesDev();
18795          return mountEvent(callback);
18796        }
18797      };
18798      HooksDispatcherOnMountWithHookTypesInDEV = {
18799        readContext: function(context) {
18800          return readContext(context);
18801        },
18802        use,
18803        useCallback: function(callback, deps) {
18804          currentHookNameInDev = "useCallback";
18805          updateHookTypesDev();
18806          return mountCallback(callback, deps);
18807        },
18808        useContext: function(context) {
18809          currentHookNameInDev = "useContext";
18810          updateHookTypesDev();
18811          return readContext(context);
18812        },
18813        useEffect: function(create, deps) {
18814          currentHookNameInDev = "useEffect";
18815          updateHookTypesDev();
18816          return mountEffect(create, deps);
18817        },
18818        useImperativeHandle: function(ref, create, deps) {
18819          currentHookNameInDev = "useImperativeHandle";
18820          updateHookTypesDev();
18821          return mountImperativeHandle(ref, create, deps);
18822        },
18823        useInsertionEffect: function(create, deps) {
18824          currentHookNameInDev = "useInsertionEffect";
18825          updateHookTypesDev();
18826          mountEffectImpl(4, Insertion, create, deps);
18827        },
18828        useLayoutEffect: function(create, deps) {
18829          currentHookNameInDev = "useLayoutEffect";
18830          updateHookTypesDev();
18831          return mountLayoutEffect(create, deps);
18832        },
18833        useMemo: function(create, deps) {
18834          currentHookNameInDev = "useMemo";
18835          updateHookTypesDev();
18836          var prevDispatcher = ReactSharedInternals.H;
18837          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnMountInDEV;
18838          try {
18839            return mountMemo(create, deps);
18840          } finally {
18841            ReactSharedInternals.H = prevDispatcher;
18842          }
18843        },
18844        useReducer: function(reducer, initialArg, init) {
18845          currentHookNameInDev = "useReducer";
18846          updateHookTypesDev();
18847          var prevDispatcher = ReactSharedInternals.H;
18848          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnMountInDEV;
18849          try {
18850            return mountReducer(reducer, initialArg, init);
18851          } finally {
18852            ReactSharedInternals.H = prevDispatcher;
18853          }
18854        },
18855        useRef: function(initialValue) {
18856          currentHookNameInDev = "useRef";
18857          updateHookTypesDev();
18858          return mountRef(initialValue);
18859        },
18860        useState: function(initialState) {
18861          currentHookNameInDev = "useState";
18862          updateHookTypesDev();
18863          var prevDispatcher = ReactSharedInternals.H;
18864          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnMountInDEV;
18865          try {
18866            return mountState(initialState);
18867          } finally {
18868            ReactSharedInternals.H = prevDispatcher;
18869          }
18870        },
18871        useDebugValue: function() {
18872          currentHookNameInDev = "useDebugValue";
18873          updateHookTypesDev();
18874        },
18875        useDeferredValue: function(value, initialValue) {
18876          currentHookNameInDev = "useDeferredValue";
18877          updateHookTypesDev();
18878          return mountDeferredValue(value, initialValue);
18879        },
18880        useTransition: function() {
18881          currentHookNameInDev = "useTransition";
18882          updateHookTypesDev();
18883          return mountTransition();
18884        },
18885        useSyncExternalStore: function(subscribe, getSnapshot, getServerSnapshot) {
18886          currentHookNameInDev = "useSyncExternalStore";
18887          updateHookTypesDev();
18888          return mountSyncExternalStore(
18889            subscribe,
18890            getSnapshot,
18891            getServerSnapshot
18892          );
18893        },
18894        useId: function() {
18895          currentHookNameInDev = "useId";
18896          updateHookTypesDev();
18897          return mountId();
18898        },
18899        useActionState: function(action, initialState) {
18900          currentHookNameInDev = "useActionState";
18901          updateHookTypesDev();
18902          return mountActionState(action, initialState);
18903        },
18904        useFormState: function(action, initialState) {
18905          currentHookNameInDev = "useFormState";
18906          updateHookTypesDev();
18907          warnOnUseFormStateInDev();
18908          return mountActionState(action, initialState);
18909        },
18910        useOptimistic: function(passthrough) {
18911          currentHookNameInDev = "useOptimistic";
18912          updateHookTypesDev();
18913          return mountOptimistic(passthrough);
18914        },
18915        useHostTransitionStatus,
18916        useMemoCache,
18917        useCacheRefresh: function() {
18918          currentHookNameInDev = "useCacheRefresh";
18919          updateHookTypesDev();
18920          return mountRefresh();
18921        },
18922        useEffectEvent: function(callback) {
18923          currentHookNameInDev = "useEffectEvent";
18924          updateHookTypesDev();
18925          return mountEvent(callback);
18926        }
18927      };
18928      HooksDispatcherOnUpdateInDEV = {
18929        readContext: function(context) {
18930          return readContext(context);
18931        },
18932        use,
18933        useCallback: function(callback, deps) {
18934          currentHookNameInDev = "useCallback";
18935          updateHookTypesDev();
18936          return updateCallback(callback, deps);
18937        },
18938        useContext: function(context) {
18939          currentHookNameInDev = "useContext";
18940          updateHookTypesDev();
18941          return readContext(context);
18942        },
18943        useEffect: function(create, deps) {
18944          currentHookNameInDev = "useEffect";
18945          updateHookTypesDev();
18946          updateEffectImpl(2048, Passive, create, deps);
18947        },
18948        useImperativeHandle: function(ref, create, deps) {
18949          currentHookNameInDev = "useImperativeHandle";
18950          updateHookTypesDev();
18951          return updateImperativeHandle(ref, create, deps);
18952        },
18953        useInsertionEffect: function(create, deps) {
18954          currentHookNameInDev = "useInsertionEffect";
18955          updateHookTypesDev();
18956          return updateEffectImpl(4, Insertion, create, deps);
18957        },
18958        useLayoutEffect: function(create, deps) {
18959          currentHookNameInDev = "useLayoutEffect";
18960          updateHookTypesDev();
18961          return updateEffectImpl(4, Layout, create, deps);
18962        },
18963        useMemo: function(create, deps) {
18964          currentHookNameInDev = "useMemo";
18965          updateHookTypesDev();
18966          var prevDispatcher = ReactSharedInternals.H;
18967          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
18968          try {
18969            return updateMemo(create, deps);
18970          } finally {
18971            ReactSharedInternals.H = prevDispatcher;
18972          }
18973        },
18974        useReducer: function(reducer, initialArg, init) {
18975          currentHookNameInDev = "useReducer";
18976          updateHookTypesDev();
18977          var prevDispatcher = ReactSharedInternals.H;
18978          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
18979          try {
18980            return updateReducer(reducer, initialArg, init);
18981          } finally {
18982            ReactSharedInternals.H = prevDispatcher;
18983          }
18984        },
18985        useRef: function() {
18986          currentHookNameInDev = "useRef";
18987          updateHookTypesDev();
18988          return updateWorkInProgressHook().memoizedState;
18989        },
18990        useState: function() {
18991          currentHookNameInDev = "useState";
18992          updateHookTypesDev();
18993          var prevDispatcher = ReactSharedInternals.H;
18994          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
18995          try {
18996            return updateReducer(basicStateReducer);
18997          } finally {
18998            ReactSharedInternals.H = prevDispatcher;
18999          }
19000        },
19001        useDebugValue: function() {
19002          currentHookNameInDev = "useDebugValue";
19003          updateHookTypesDev();
19004        },
19005        useDeferredValue: function(value, initialValue) {
19006          currentHookNameInDev = "useDeferredValue";
19007          updateHookTypesDev();
19008          return updateDeferredValue(value, initialValue);
19009        },
19010        useTransition: function() {
19011          currentHookNameInDev = "useTransition";
19012          updateHookTypesDev();
19013          return updateTransition();
19014        },
19015        useSyncExternalStore: function(subscribe, getSnapshot, getServerSnapshot) {
19016          currentHookNameInDev = "useSyncExternalStore";
19017          updateHookTypesDev();
19018          return updateSyncExternalStore(
19019            subscribe,
19020            getSnapshot,
19021            getServerSnapshot
19022          );
19023        },
19024        useId: function() {
19025          currentHookNameInDev = "useId";
19026          updateHookTypesDev();
19027          return updateWorkInProgressHook().memoizedState;
19028        },
19029        useFormState: function(action) {
19030          currentHookNameInDev = "useFormState";
19031          updateHookTypesDev();
19032          warnOnUseFormStateInDev();
19033          return updateActionState(action);
19034        },
19035        useActionState: function(action) {
19036          currentHookNameInDev = "useActionState";
19037          updateHookTypesDev();
19038          return updateActionState(action);
19039        },
19040        useOptimistic: function(passthrough, reducer) {
19041          currentHookNameInDev = "useOptimistic";
19042          updateHookTypesDev();
19043          return updateOptimistic(passthrough, reducer);
19044        },
19045        useHostTransitionStatus,
19046        useMemoCache,
19047        useCacheRefresh: function() {
19048          currentHookNameInDev = "useCacheRefresh";
19049          updateHookTypesDev();
19050          return updateWorkInProgressHook().memoizedState;
19051        },
19052        useEffectEvent: function(callback) {
19053          currentHookNameInDev = "useEffectEvent";
19054          updateHookTypesDev();
19055          return updateEvent(callback);
19056        }
19057      };
19058      HooksDispatcherOnRerenderInDEV = {
19059        readContext: function(context) {
19060          return readContext(context);
19061        },
19062        use,
19063        useCallback: function(callback, deps) {
19064          currentHookNameInDev = "useCallback";
19065          updateHookTypesDev();
19066          return updateCallback(callback, deps);
19067        },
19068        useContext: function(context) {
19069          currentHookNameInDev = "useContext";
19070          updateHookTypesDev();
19071          return readContext(context);
19072        },
19073        useEffect: function(create, deps) {
19074          currentHookNameInDev = "useEffect";
19075          updateHookTypesDev();
19076          updateEffectImpl(2048, Passive, create, deps);
19077        },
19078        useImperativeHandle: function(ref, create, deps) {
19079          currentHookNameInDev = "useImperativeHandle";
19080          updateHookTypesDev();
19081          return updateImperativeHandle(ref, create, deps);
19082        },
19083        useInsertionEffect: function(create, deps) {
19084          currentHookNameInDev = "useInsertionEffect";
19085          updateHookTypesDev();
19086          return updateEffectImpl(4, Insertion, create, deps);
19087        },
19088        useLayoutEffect: function(create, deps) {
19089          currentHookNameInDev = "useLayoutEffect";
19090          updateHookTypesDev();
19091          return updateEffectImpl(4, Layout, create, deps);
19092        },
19093        useMemo: function(create, deps) {
19094          currentHookNameInDev = "useMemo";
19095          updateHookTypesDev();
19096          var prevDispatcher = ReactSharedInternals.H;
19097          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnRerenderInDEV;
19098          try {
19099            return updateMemo(create, deps);
19100          } finally {
19101            ReactSharedInternals.H = prevDispatcher;
19102          }
19103        },
19104        useReducer: function(reducer, initialArg, init) {
19105          currentHookNameInDev = "useReducer";
19106          updateHookTypesDev();
19107          var prevDispatcher = ReactSharedInternals.H;
19108          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnRerenderInDEV;
19109          try {
19110            return rerenderReducer(reducer, initialArg, init);
19111          } finally {
19112            ReactSharedInternals.H = prevDispatcher;
19113          }
19114        },
19115        useRef: function() {
19116          currentHookNameInDev = "useRef";
19117          updateHookTypesDev();
19118          return updateWorkInProgressHook().memoizedState;
19119        },
19120        useState: function() {
19121          currentHookNameInDev = "useState";
19122          updateHookTypesDev();
19123          var prevDispatcher = ReactSharedInternals.H;
19124          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnRerenderInDEV;
19125          try {
19126            return rerenderReducer(basicStateReducer);
19127          } finally {
19128            ReactSharedInternals.H = prevDispatcher;
19129          }
19130        },
19131        useDebugValue: function() {
19132          currentHookNameInDev = "useDebugValue";
19133          updateHookTypesDev();
19134        },
19135        useDeferredValue: function(value, initialValue) {
19136          currentHookNameInDev = "useDeferredValue";
19137          updateHookTypesDev();
19138          return rerenderDeferredValue(value, initialValue);
19139        },
19140        useTransition: function() {
19141          currentHookNameInDev = "useTransition";
19142          updateHookTypesDev();
19143          return rerenderTransition();
19144        },
19145        useSyncExternalStore: function(subscribe, getSnapshot, getServerSnapshot) {
19146          currentHookNameInDev = "useSyncExternalStore";
19147          updateHookTypesDev();
19148          return updateSyncExternalStore(
19149            subscribe,
19150            getSnapshot,
19151            getServerSnapshot
19152          );
19153        },
19154        useId: function() {
19155          currentHookNameInDev = "useId";
19156          updateHookTypesDev();
19157          return updateWorkInProgressHook().memoizedState;
19158        },
19159        useFormState: function(action) {
19160          currentHookNameInDev = "useFormState";
19161          updateHookTypesDev();
19162          warnOnUseFormStateInDev();
19163          return rerenderActionState(action);
19164        },
19165        useActionState: function(action) {
19166          currentHookNameInDev = "useActionState";
19167          updateHookTypesDev();
19168          return rerenderActionState(action);
19169        },
19170        useOptimistic: function(passthrough, reducer) {
19171          currentHookNameInDev = "useOptimistic";
19172          updateHookTypesDev();
19173          return rerenderOptimistic(passthrough, reducer);
19174        },
19175        useHostTransitionStatus,
19176        useMemoCache,
19177        useCacheRefresh: function() {
19178          currentHookNameInDev = "useCacheRefresh";
19179          updateHookTypesDev();
19180          return updateWorkInProgressHook().memoizedState;
19181        },
19182        useEffectEvent: function(callback) {
19183          currentHookNameInDev = "useEffectEvent";
19184          updateHookTypesDev();
19185          return updateEvent(callback);
19186        }
19187      };
19188      InvalidNestedHooksDispatcherOnMountInDEV = {
19189        readContext: function(context) {
19190          warnInvalidContextAccess();
19191          return readContext(context);
19192        },
19193        use: function(usable) {
19194          warnInvalidHookAccess();
19195          return use(usable);
19196        },
19197        useCallback: function(callback, deps) {
19198          currentHookNameInDev = "useCallback";
19199          warnInvalidHookAccess();
19200          mountHookTypesDev();
19201          return mountCallback(callback, deps);
19202        },
19203        useContext: function(context) {
19204          currentHookNameInDev = "useContext";
19205          warnInvalidHookAccess();
19206          mountHookTypesDev();
19207          return readContext(context);
19208        },
19209        useEffect: function(create, deps) {
19210          currentHookNameInDev = "useEffect";
19211          warnInvalidHookAccess();
19212          mountHookTypesDev();
19213          return mountEffect(create, deps);
19214        },
19215        useImperativeHandle: function(ref, create, deps) {
19216          currentHookNameInDev = "useImperativeHandle";
19217          warnInvalidHookAccess();
19218          mountHookTypesDev();
19219          return mountImperativeHandle(ref, create, deps);
19220        },
19221        useInsertionEffect: function(create, deps) {
19222          currentHookNameInDev = "useInsertionEffect";
19223          warnInvalidHookAccess();
19224          mountHookTypesDev();
19225          mountEffectImpl(4, Insertion, create, deps);
19226        },
19227        useLayoutEffect: function(create, deps) {
19228          currentHookNameInDev = "useLayoutEffect";
19229          warnInvalidHookAccess();
19230          mountHookTypesDev();
19231          return mountLayoutEffect(create, deps);
19232        },
19233        useMemo: function(create, deps) {
19234          currentHookNameInDev = "useMemo";
19235          warnInvalidHookAccess();
19236          mountHookTypesDev();
19237          var prevDispatcher = ReactSharedInternals.H;
19238          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnMountInDEV;
19239          try {
19240            return mountMemo(create, deps);
19241          } finally {
19242            ReactSharedInternals.H = prevDispatcher;
19243          }
19244        },
19245        useReducer: function(reducer, initialArg, init) {
19246          currentHookNameInDev = "useReducer";
19247          warnInvalidHookAccess();
19248          mountHookTypesDev();
19249          var prevDispatcher = ReactSharedInternals.H;
19250          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnMountInDEV;
19251          try {
19252            return mountReducer(reducer, initialArg, init);
19253          } finally {
19254            ReactSharedInternals.H = prevDispatcher;
19255          }
19256        },
19257        useRef: function(initialValue) {
19258          currentHookNameInDev = "useRef";
19259          warnInvalidHookAccess();
19260          mountHookTypesDev();
19261          return mountRef(initialValue);
19262        },
19263        useState: function(initialState) {
19264          currentHookNameInDev = "useState";
19265          warnInvalidHookAccess();
19266          mountHookTypesDev();
19267          var prevDispatcher = ReactSharedInternals.H;
19268          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnMountInDEV;
19269          try {
19270            return mountState(initialState);
19271          } finally {
19272            ReactSharedInternals.H = prevDispatcher;
19273          }
19274        },
19275        useDebugValue: function() {
19276          currentHookNameInDev = "useDebugValue";
19277          warnInvalidHookAccess();
19278          mountHookTypesDev();
19279        },
19280        useDeferredValue: function(value, initialValue) {
19281          currentHookNameInDev = "useDeferredValue";
19282          warnInvalidHookAccess();
19283          mountHookTypesDev();
19284          return mountDeferredValue(value, initialValue);
19285        },
19286        useTransition: function() {
19287          currentHookNameInDev = "useTransition";
19288          warnInvalidHookAccess();
19289          mountHookTypesDev();
19290          return mountTransition();
19291        },
19292        useSyncExternalStore: function(subscribe, getSnapshot, getServerSnapshot) {
19293          currentHookNameInDev = "useSyncExternalStore";
19294          warnInvalidHookAccess();
19295          mountHookTypesDev();
19296          return mountSyncExternalStore(
19297            subscribe,
19298            getSnapshot,
19299            getServerSnapshot
19300          );
19301        },
19302        useId: function() {
19303          currentHookNameInDev = "useId";
19304          warnInvalidHookAccess();
19305          mountHookTypesDev();
19306          return mountId();
19307        },
19308        useFormState: function(action, initialState) {
19309          currentHookNameInDev = "useFormState";
19310          warnInvalidHookAccess();
19311          mountHookTypesDev();
19312          return mountActionState(action, initialState);
19313        },
19314        useActionState: function(action, initialState) {
19315          currentHookNameInDev = "useActionState";
19316          warnInvalidHookAccess();
19317          mountHookTypesDev();
19318          return mountActionState(action, initialState);
19319        },
19320        useOptimistic: function(passthrough) {
19321          currentHookNameInDev = "useOptimistic";
19322          warnInvalidHookAccess();
19323          mountHookTypesDev();
19324          return mountOptimistic(passthrough);
19325        },
19326        useMemoCache: function(size) {
19327          warnInvalidHookAccess();
19328          return useMemoCache(size);
19329        },
19330        useHostTransitionStatus,
19331        useCacheRefresh: function() {
19332          currentHookNameInDev = "useCacheRefresh";
19333          mountHookTypesDev();
19334          return mountRefresh();
19335        },
19336        useEffectEvent: function(callback) {
19337          currentHookNameInDev = "useEffectEvent";
19338          warnInvalidHookAccess();
19339          mountHookTypesDev();
19340          return mountEvent(callback);
19341        }
19342      };
19343      InvalidNestedHooksDispatcherOnUpdateInDEV = {
19344        readContext: function(context) {
19345          warnInvalidContextAccess();
19346          return readContext(context);
19347        },
19348        use: function(usable) {
19349          warnInvalidHookAccess();
19350          return use(usable);
19351        },
19352        useCallback: function(callback, deps) {
19353          currentHookNameInDev = "useCallback";
19354          warnInvalidHookAccess();
19355          updateHookTypesDev();
19356          return updateCallback(callback, deps);
19357        },
19358        useContext: function(context) {
19359          currentHookNameInDev = "useContext";
19360          warnInvalidHookAccess();
19361          updateHookTypesDev();
19362          return readContext(context);
19363        },
19364        useEffect: function(create, deps) {
19365          currentHookNameInDev = "useEffect";
19366          warnInvalidHookAccess();
19367          updateHookTypesDev();
19368          updateEffectImpl(2048, Passive, create, deps);
19369        },
19370        useImperativeHandle: function(ref, create, deps) {
19371          currentHookNameInDev = "useImperativeHandle";
19372          warnInvalidHookAccess();
19373          updateHookTypesDev();
19374          return updateImperativeHandle(ref, create, deps);
19375        },
19376        useInsertionEffect: function(create, deps) {
19377          currentHookNameInDev = "useInsertionEffect";
19378          warnInvalidHookAccess();
19379          updateHookTypesDev();
19380          return updateEffectImpl(4, Insertion, create, deps);
19381        },
19382        useLayoutEffect: function(create, deps) {
19383          currentHookNameInDev = "useLayoutEffect";
19384          warnInvalidHookAccess();
19385          updateHookTypesDev();
19386          return updateEffectImpl(4, Layout, create, deps);
19387        },
19388        useMemo: function(create, deps) {
19389          currentHookNameInDev = "useMemo";
19390          warnInvalidHookAccess();
19391          updateHookTypesDev();
19392          var prevDispatcher = ReactSharedInternals.H;
19393          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
19394          try {
19395            return updateMemo(create, deps);
19396          } finally {
19397            ReactSharedInternals.H = prevDispatcher;
19398          }
19399        },
19400        useReducer: function(reducer, initialArg, init) {
19401          currentHookNameInDev = "useReducer";
19402          warnInvalidHookAccess();
19403          updateHookTypesDev();
19404          var prevDispatcher = ReactSharedInternals.H;
19405          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
19406          try {
19407            return updateReducer(reducer, initialArg, init);
19408          } finally {
19409            ReactSharedInternals.H = prevDispatcher;
19410          }
19411        },
19412        useRef: function() {
19413          currentHookNameInDev = "useRef";
19414          warnInvalidHookAccess();
19415          updateHookTypesDev();
19416          return updateWorkInProgressHook().memoizedState;
19417        },
19418        useState: function() {
19419          currentHookNameInDev = "useState";
19420          warnInvalidHookAccess();
19421          updateHookTypesDev();
19422          var prevDispatcher = ReactSharedInternals.H;
19423          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
19424          try {
19425            return updateReducer(basicStateReducer);
19426          } finally {
19427            ReactSharedInternals.H = prevDispatcher;
19428          }
19429        },
19430        useDebugValue: function() {
19431          currentHookNameInDev = "useDebugValue";
19432          warnInvalidHookAccess();
19433          updateHookTypesDev();
19434        },
19435        useDeferredValue: function(value, initialValue) {
19436          currentHookNameInDev = "useDeferredValue";
19437          warnInvalidHookAccess();
19438          updateHookTypesDev();
19439          return updateDeferredValue(value, initialValue);
19440        },
19441        useTransition: function() {
19442          currentHookNameInDev = "useTransition";
19443          warnInvalidHookAccess();
19444          updateHookTypesDev();
19445          return updateTransition();
19446        },
19447        useSyncExternalStore: function(subscribe, getSnapshot, getServerSnapshot) {
19448          currentHookNameInDev = "useSyncExternalStore";
19449          warnInvalidHookAccess();
19450          updateHookTypesDev();
19451          return updateSyncExternalStore(
19452            subscribe,
19453            getSnapshot,
19454            getServerSnapshot
19455          );
19456        },
19457        useId: function() {
19458          currentHookNameInDev = "useId";
19459          warnInvalidHookAccess();
19460          updateHookTypesDev();
19461          return updateWorkInProgressHook().memoizedState;
19462        },
19463        useFormState: function(action) {
19464          currentHookNameInDev = "useFormState";
19465          warnInvalidHookAccess();
19466          updateHookTypesDev();
19467          return updateActionState(action);
19468        },
19469        useActionState: function(action) {
19470          currentHookNameInDev = "useActionState";
19471          warnInvalidHookAccess();
19472          updateHookTypesDev();
19473          return updateActionState(action);
19474        },
19475        useOptimistic: function(passthrough, reducer) {
19476          currentHookNameInDev = "useOptimistic";
19477          warnInvalidHookAccess();
19478          updateHookTypesDev();
19479          return updateOptimistic(passthrough, reducer);
19480        },
19481        useMemoCache: function(size) {
19482          warnInvalidHookAccess();
19483          return useMemoCache(size);
19484        },
19485        useHostTransitionStatus,
19486        useCacheRefresh: function() {
19487          currentHookNameInDev = "useCacheRefresh";
19488          updateHookTypesDev();
19489          return updateWorkInProgressHook().memoizedState;
19490        },
19491        useEffectEvent: function(callback) {
19492          currentHookNameInDev = "useEffectEvent";
19493          warnInvalidHookAccess();
19494          updateHookTypesDev();
19495          return updateEvent(callback);
19496        }
19497      };
19498      InvalidNestedHooksDispatcherOnRerenderInDEV = {
19499        readContext: function(context) {
19500          warnInvalidContextAccess();
19501          return readContext(context);
19502        },
19503        use: function(usable) {
19504          warnInvalidHookAccess();
19505          return use(usable);
19506        },
19507        useCallback: function(callback, deps) {
19508          currentHookNameInDev = "useCallback";
19509          warnInvalidHookAccess();
19510          updateHookTypesDev();
19511          return updateCallback(callback, deps);
19512        },
19513        useContext: function(context) {
19514          currentHookNameInDev = "useContext";
19515          warnInvalidHookAccess();
19516          updateHookTypesDev();
19517          return readContext(context);
19518        },
19519        useEffect: function(create, deps) {
19520          currentHookNameInDev = "useEffect";
19521          warnInvalidHookAccess();
19522          updateHookTypesDev();
19523          updateEffectImpl(2048, Passive, create, deps);
19524        },
19525        useImperativeHandle: function(ref, create, deps) {
19526          currentHookNameInDev = "useImperativeHandle";
19527          warnInvalidHookAccess();
19528          updateHookTypesDev();
19529          return updateImperativeHandle(ref, create, deps);
19530        },
19531        useInsertionEffect: function(create, deps) {
19532          currentHookNameInDev = "useInsertionEffect";
19533          warnInvalidHookAccess();
19534          updateHookTypesDev();
19535          return updateEffectImpl(4, Insertion, create, deps);
19536        },
19537        useLayoutEffect: function(create, deps) {
19538          currentHookNameInDev = "useLayoutEffect";
19539          warnInvalidHookAccess();
19540          updateHookTypesDev();
19541          return updateEffectImpl(4, Layout, create, deps);
19542        },
19543        useMemo: function(create, deps) {
19544          currentHookNameInDev = "useMemo";
19545          warnInvalidHookAccess();
19546          updateHookTypesDev();
19547          var prevDispatcher = ReactSharedInternals.H;
19548          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
19549          try {
19550            return updateMemo(create, deps);
19551          } finally {
19552            ReactSharedInternals.H = prevDispatcher;
19553          }
19554        },
19555        useReducer: function(reducer, initialArg, init) {
19556          currentHookNameInDev = "useReducer";
19557          warnInvalidHookAccess();
19558          updateHookTypesDev();
19559          var prevDispatcher = ReactSharedInternals.H;
19560          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
19561          try {
19562            return rerenderReducer(reducer, initialArg, init);
19563          } finally {
19564            ReactSharedInternals.H = prevDispatcher;
19565          }
19566        },
19567        useRef: function() {
19568          currentHookNameInDev = "useRef";
19569          warnInvalidHookAccess();
19570          updateHookTypesDev();
19571          return updateWorkInProgressHook().memoizedState;
19572        },
19573        useState: function() {
19574          currentHookNameInDev = "useState";
19575          warnInvalidHookAccess();
19576          updateHookTypesDev();
19577          var prevDispatcher = ReactSharedInternals.H;
19578          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
19579          try {
19580            return rerenderReducer(basicStateReducer);
19581          } finally {
19582            ReactSharedInternals.H = prevDispatcher;
19583          }
19584        },
19585        useDebugValue: function() {
19586          currentHookNameInDev = "useDebugValue";
19587          warnInvalidHookAccess();
19588          updateHookTypesDev();
19589        },
19590        useDeferredValue: function(value, initialValue) {
19591          currentHookNameInDev = "useDeferredValue";
19592          warnInvalidHookAccess();
19593          updateHookTypesDev();
19594          return rerenderDeferredValue(value, initialValue);
19595        },
19596        useTransition: function() {
19597          currentHookNameInDev = "useTransition";
19598          warnInvalidHookAccess();
19599          updateHookTypesDev();
19600          return rerenderTransition();
19601        },
19602        useSyncExternalStore: function(subscribe, getSnapshot, getServerSnapshot) {
19603          currentHookNameInDev = "useSyncExternalStore";
19604          warnInvalidHookAccess();
19605          updateHookTypesDev();
19606          return updateSyncExternalStore(
19607            subscribe,
19608            getSnapshot,
19609            getServerSnapshot
19610          );
19611        },
19612        useId: function() {
19613          currentHookNameInDev = "useId";
19614          warnInvalidHookAccess();
19615          updateHookTypesDev();
19616          return updateWorkInProgressHook().memoizedState;
19617        },
19618        useFormState: function(action) {
19619          currentHookNameInDev = "useFormState";
19620          warnInvalidHookAccess();
19621          updateHookTypesDev();
19622          return rerenderActionState(action);
19623        },
19624        useActionState: function(action) {
19625          currentHookNameInDev = "useActionState";
19626          warnInvalidHookAccess();
19627          updateHookTypesDev();
19628          return rerenderActionState(action);
19629        },
19630        useOptimistic: function(passthrough, reducer) {
19631          currentHookNameInDev = "useOptimistic";
19632          warnInvalidHookAccess();
19633          updateHookTypesDev();
19634          return rerenderOptimistic(passthrough, reducer);
19635        },
19636        useMemoCache: function(size) {
19637          warnInvalidHookAccess();
19638          return useMemoCache(size);
19639        },
19640        useHostTransitionStatus,
19641        useCacheRefresh: function() {
19642          currentHookNameInDev = "useCacheRefresh";
19643          updateHookTypesDev();
19644          return updateWorkInProgressHook().memoizedState;
19645        },
19646        useEffectEvent: function(callback) {
19647          currentHookNameInDev = "useEffectEvent";
19648          warnInvalidHookAccess();
19649          updateHookTypesDev();
19650          return updateEvent(callback);
19651        }
19652      };
19653      var fakeInternalInstance = {};
19654      var didWarnAboutStateAssignmentForComponent = /* @__PURE__ */ new Set();
19655      var didWarnAboutUninitializedState = /* @__PURE__ */ new Set();
19656      var didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate = /* @__PURE__ */ new Set();
19657      var didWarnAboutLegacyLifecyclesAndDerivedState = /* @__PURE__ */ new Set();
19658      var didWarnAboutDirectlyAssigningPropsToState = /* @__PURE__ */ new Set();
19659      var didWarnAboutUndefinedDerivedState = /* @__PURE__ */ new Set();
19660      var didWarnAboutContextTypes$1 = /* @__PURE__ */ new Set();
19661      var didWarnAboutChildContextTypes = /* @__PURE__ */ new Set();
19662      var didWarnAboutInvalidateContextType = /* @__PURE__ */ new Set();
19663      var didWarnOnInvalidCallback = /* @__PURE__ */ new Set();
19664      Object.freeze(fakeInternalInstance);
19665      var classComponentUpdater = {
19666        enqueueSetState: function(inst, payload, callback) {
19667          inst = inst._reactInternals;
19668          var lane = requestUpdateLane(inst), update = createUpdate(lane);
19669          update.payload = payload;
19670          void 0 !== callback && null !== callback && (warnOnInvalidCallback(callback), update.callback = callback);
19671          payload = enqueueUpdate(inst, update, lane);
19672          null !== payload && (startUpdateTimerByLane(lane, "this.setState()", inst), scheduleUpdateOnFiber(payload, inst, lane), entangleTransitions(payload, inst, lane));
19673        },
19674        enqueueReplaceState: function(inst, payload, callback) {
19675          inst = inst._reactInternals;
19676          var lane = requestUpdateLane(inst), update = createUpdate(lane);
19677          update.tag = ReplaceState;
19678          update.payload = payload;
19679          void 0 !== callback && null !== callback && (warnOnInvalidCallback(callback), update.callback = callback);
19680          payload = enqueueUpdate(inst, update, lane);
19681          null !== payload && (startUpdateTimerByLane(lane, "this.replaceState()", inst), scheduleUpdateOnFiber(payload, inst, lane), entangleTransitions(payload, inst, lane));
19682        },
19683        enqueueForceUpdate: function(inst, callback) {
19684          inst = inst._reactInternals;
19685          var lane = requestUpdateLane(inst), update = createUpdate(lane);
19686          update.tag = ForceUpdate;
19687          void 0 !== callback && null !== callback && (warnOnInvalidCallback(callback), update.callback = callback);
19688          callback = enqueueUpdate(inst, update, lane);
19689          null !== callback && (startUpdateTimerByLane(lane, "this.forceUpdate()", inst), scheduleUpdateOnFiber(callback, inst, lane), entangleTransitions(callback, inst, lane));
19690        }
19691      }, componentName = null, errorBoundaryName = null, SelectiveHydrationException = Error(
19692        "This is not a real error. It's an implementation detail of React's selective hydration feature. If this leaks into userspace, it's a bug in React. Please file an issue."
19693      ), didReceiveUpdate = false;
19694      var didWarnAboutBadClass = {};
19695      var didWarnAboutContextTypeOnFunctionComponent = {};
19696      var didWarnAboutContextTypes = {};
19697      var didWarnAboutGetDerivedStateOnFunctionComponent = {};
19698      var didWarnAboutReassigningProps = false;
19699      var didWarnAboutRevealOrder = {};
19700      var didWarnAboutTailOptions = {};
19701      var SUSPENDED_MARKER = {
19702        dehydrated: null,
19703        treeContext: null,
19704        retryLane: 0,
19705        hydrationErrors: null
19706      }, hasWarnedAboutUsingNoValuePropOnContextProvider = false, didWarnAboutUndefinedSnapshotBeforeUpdate = null;
19707      didWarnAboutUndefinedSnapshotBeforeUpdate = /* @__PURE__ */ new Set();
19708      var offscreenSubtreeIsHidden = false, offscreenSubtreeWasHidden = false, needsFormReset = false, PossiblyWeakSet = "function" === typeof WeakSet ? WeakSet : Set, nextEffect = null, inProgressLanes = null, inProgressRoot = null, hostParent = null, hostParentIsContainer = false, currentHoistableRoot = null, inHydratedSubtree = false, suspenseyCommitFlag = 8192, DefaultAsyncDispatcher = {
19709        getCacheForType: function(resourceType) {
19710          var cache = readContext(CacheContext), cacheForType = cache.data.get(resourceType);
19711          void 0 === cacheForType && (cacheForType = resourceType(), cache.data.set(resourceType, cacheForType));
19712          return cacheForType;
19713        },
19714        cacheSignal: function() {
19715          return readContext(CacheContext).controller.signal;
19716        },
19717        getOwner: function() {
19718          return current;
19719        }
19720      };
19721      if ("function" === typeof Symbol && Symbol.for) {
19722        var symbolFor = Symbol.for;
19723        symbolFor("selector.component");
19724        symbolFor("selector.has_pseudo_class");
19725        symbolFor("selector.role");
19726        symbolFor("selector.test_id");
19727        symbolFor("selector.text");
19728      }
19729      var commitHooks = [], PossiblyWeakMap = "function" === typeof WeakMap ? WeakMap : Map, NoContext = 0, RenderContext = 2, CommitContext = 4, RootInProgress = 0, RootFatalErrored = 1, RootErrored = 2, RootSuspended = 3, RootSuspendedWithDelay = 4, RootSuspendedAtTheShell = 6, RootCompleted = 5, executionContext = NoContext, workInProgressRoot = null, workInProgress = null, workInProgressRootRenderLanes = 0, NotSuspended = 0, SuspendedOnError = 1, SuspendedOnData = 2, SuspendedOnImmediate = 3, SuspendedOnInstance = 4, SuspendedOnInstanceAndReadyToContinue = 5, SuspendedOnDeprecatedThrowPromise = 6, SuspendedAndReadyToContinue = 7, SuspendedOnHydration = 8, SuspendedOnAction = 9, workInProgressSuspendedReason = NotSuspended, workInProgressThrownValue = null, workInProgressRootDidSkipSuspendedSiblings = false, workInProgressRootIsPrerendering = false, workInProgressRootDidAttachPingListener = false, entangledRenderLanes = 0, workInProgressRootExitStatus = RootInProgress, workInProgressRootSkippedLanes = 0, workInProgressRootInterleavedUpdatedLanes = 0, workInProgressRootPingedLanes = 0, workInProgressDeferredLane = 0, workInProgressSuspendedRetryLanes = 0, workInProgressRootConcurrentErrors = null, workInProgressRootRecoverableErrors = null, workInProgressRootDidIncludeRecursiveRenderUpdate = false, globalMostRecentFallbackTime = 0, globalMostRecentTransitionTime = 0, FALLBACK_THROTTLE_MS = 300, workInProgressRootRenderTargetTime = Infinity, RENDER_TIMEOUT_MS = 500, workInProgressTransitions = null, workInProgressUpdateTask = null, legacyErrorBoundariesThatAlreadyFailed = null, IMMEDIATE_COMMIT = 0, ABORTED_VIEW_TRANSITION_COMMIT = 1, DELAYED_PASSIVE_COMMIT = 2, ANIMATION_STARTED_COMMIT = 3, NO_PENDING_EFFECTS = 0, PENDING_MUTATION_PHASE = 1, PENDING_LAYOUT_PHASE = 2, PENDING_AFTER_MUTATION_PHASE = 3, PENDING_SPAWNED_WORK = 4, PENDING_PASSIVE_PHASE = 5, pendingEffectsStatus = 0, pendingEffectsRoot = null, pendingFinishedWork = null, pendingEffectsLanes = 0, pendingEffectsRemainingLanes = 0, pendingEffectsRenderEndTime = -0, pendingPassiveTransitions = null, pendingRecoverableErrors = null, pendingSuspendedCommitReason = null, pendingDelayedCommitReason = IMMEDIATE_COMMIT, pendingSuspendedViewTransitionReason = null, NESTED_UPDATE_LIMIT = 50, nestedUpdateCount = 0, rootWithNestedUpdates = null, isFlushingPassiveEffects = false, didScheduleUpdateDuringPassiveEffects = false, NESTED_PASSIVE_UPDATE_LIMIT = 50, nestedPassiveUpdateCount = 0, rootWithPassiveNestedUpdates = null, isRunningInsertionEffect = false, didWarnStateUpdateForNotYetMountedComponent = null, didWarnAboutUpdateInRender = false;
19730      var didWarnAboutUpdateInRenderForAnotherComponent = /* @__PURE__ */ new Set();
19731      var fakeActCallbackNode$1 = {}, firstScheduledRoot = null, lastScheduledRoot = null, didScheduleMicrotask = false, didScheduleMicrotask_act = false, mightHavePendingSyncWork = false, isFlushingWork = false, currentEventTransitionLane = 0, fakeActCallbackNode = {};
19732      (function() {
19733        for (var i = 0; i < simpleEventPluginEvents.length; i++) {
19734          var eventName = simpleEventPluginEvents[i], domEventName = eventName.toLowerCase();
19735          eventName = eventName[0].toUpperCase() + eventName.slice(1);
19736          registerSimpleEvent(domEventName, "on" + eventName);
19737        }
19738        registerSimpleEvent(ANIMATION_END, "onAnimationEnd");
19739        registerSimpleEvent(ANIMATION_ITERATION, "onAnimationIteration");
19740        registerSimpleEvent(ANIMATION_START, "onAnimationStart");
19741        registerSimpleEvent("dblclick", "onDoubleClick");
19742        registerSimpleEvent("focusin", "onFocus");
19743        registerSimpleEvent("focusout", "onBlur");
19744        registerSimpleEvent(TRANSITION_RUN, "onTransitionRun");
19745        registerSimpleEvent(TRANSITION_START, "onTransitionStart");
19746        registerSimpleEvent(TRANSITION_CANCEL, "onTransitionCancel");
19747        registerSimpleEvent(TRANSITION_END, "onTransitionEnd");
19748      })();
19749      registerDirectEvent("onMouseEnter", ["mouseout", "mouseover"]);
19750      registerDirectEvent("onMouseLeave", ["mouseout", "mouseover"]);
19751      registerDirectEvent("onPointerEnter", ["pointerout", "pointerover"]);
19752      registerDirectEvent("onPointerLeave", ["pointerout", "pointerover"]);
19753      registerTwoPhaseEvent(
19754        "onChange",
19755        "change click focusin focusout input keydown keyup selectionchange".split(
19756          " "
19757        )
19758      );
19759      registerTwoPhaseEvent(
19760        "onSelect",
19761        "focusout contextmenu dragend focusin keydown keyup mousedown mouseup selectionchange".split(
19762          " "
19763        )
19764      );
19765      registerTwoPhaseEvent("onBeforeInput", [
19766        "compositionend",
19767        "keypress",
19768        "textInput",
19769        "paste"
19770      ]);
19771      registerTwoPhaseEvent(
19772        "onCompositionEnd",
19773        "compositionend focusout keydown keypress keyup mousedown".split(" ")
19774      );
19775      registerTwoPhaseEvent(
19776        "onCompositionStart",
19777        "compositionstart focusout keydown keypress keyup mousedown".split(" ")
19778      );
19779      registerTwoPhaseEvent(
19780        "onCompositionUpdate",
19781        "compositionupdate focusout keydown keypress keyup mousedown".split(" ")
19782      );
19783      var mediaEventTypes = "abort canplay canplaythrough durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart pause play playing progress ratechange resize seeked seeking stalled suspend timeupdate volumechange waiting".split(
19784        " "
19785      ), nonDelegatedEvents = new Set(
19786        "beforetoggle cancel close invalid load scroll scrollend toggle".split(" ").concat(mediaEventTypes)
19787      ), listeningMarker = "_reactListening" + Math.random().toString(36).slice(2), didWarnControlledToUncontrolled = false, didWarnUncontrolledToControlled = false, didWarnFormActionType = false, didWarnFormActionName = false, didWarnFormActionTarget = false, didWarnFormActionMethod = false, didWarnPopoverTargetObject = false;
19788      var didWarnForNewBooleanPropsWithEmptyValue = {};
19789      var NORMALIZE_NEWLINES_REGEX = /\r\n?/g, NORMALIZE_NULL_AND_REPLACEMENT_REGEX = /\u0000|\uFFFD/g, xlinkNamespace = "http://www.w3.org/1999/xlink", xmlNamespace = "http://www.w3.org/XML/1998/namespace", EXPECTED_FORM_ACTION_URL = "javascript:throw new Error('React form unexpectedly submitted.')", SUPPRESS_HYDRATION_WARNING = "suppressHydrationWarning", ACTIVITY_START_DATA = "&", ACTIVITY_END_DATA = "/&", SUSPENSE_START_DATA = "$", SUSPENSE_END_DATA = "/$", SUSPENSE_PENDING_START_DATA = "$?", SUSPENSE_QUEUED_START_DATA = "$~", SUSPENSE_FALLBACK_START_DATA = "$!", PREAMBLE_CONTRIBUTION_HTML = "html", PREAMBLE_CONTRIBUTION_BODY = "body", PREAMBLE_CONTRIBUTION_HEAD = "head", FORM_STATE_IS_MATCHING = "F!", FORM_STATE_IS_NOT_MATCHING = "F", DOCUMENT_READY_STATE_LOADING = "loading", STYLE = "style", HostContextNamespaceNone = 0, HostContextNamespaceSvg = 1, HostContextNamespaceMath = 2, eventsEnabled = null, selectionInformation = null, warnedUnknownTags = { dialog: true, webview: true }, currentPopstateTransitionEvent = null, schedulerEvent = void 0, scheduleTimeout = "function" === typeof setTimeout ? setTimeout : void 0, cancelTimeout = "function" === typeof clearTimeout ? clearTimeout : void 0, noTimeout = -1, localPromise = "function" === typeof Promise ? Promise : void 0, scheduleMicrotask = "function" === typeof queueMicrotask ? queueMicrotask : "undefined" !== typeof localPromise ? function(callback) {
19790        return localPromise.resolve(null).then(callback).catch(handleErrorInNextTick);
19791      } : scheduleTimeout, previousHydratableOnEnteringScopedSingleton = null, NotLoaded = 0, Loaded = 1, Errored = 2, Settled = 3, Inserted = 4, preloadPropsMap = /* @__PURE__ */ new Map(), preconnectsSet = /* @__PURE__ */ new Set(), previousDispatcher = ReactDOMSharedInternals.d;
19792      ReactDOMSharedInternals.d = {
19793        f: function() {
19794          var previousWasRendering = previousDispatcher.f(), wasRendering = flushSyncWork$1();
19795          return previousWasRendering || wasRendering;
19796        },
19797        r: function(form) {
19798          var formInst = getInstanceFromNode(form);
19799          null !== formInst && 5 === formInst.tag && "form" === formInst.type ? requestFormReset$1(formInst) : previousDispatcher.r(form);
19800        },
19801        D: function(href) {
19802          previousDispatcher.D(href);
19803          preconnectAs("dns-prefetch", href, null);
19804        },
19805        C: function(href, crossOrigin) {
19806          previousDispatcher.C(href, crossOrigin);
19807          preconnectAs("preconnect", href, crossOrigin);
19808        },
19809        L: function(href, as, options) {
19810          previousDispatcher.L(href, as, options);
19811          var ownerDocument = globalDocument;
19812          if (ownerDocument && href && as) {
19813            var preloadSelector = 'link[rel="preload"][as="' + escapeSelectorAttributeValueInsideDoubleQuotes(as) + '"]';
19814            "image" === as ? options && options.imageSrcSet ? (preloadSelector += '[imagesrcset="' + escapeSelectorAttributeValueInsideDoubleQuotes(
19815              options.imageSrcSet
19816            ) + '"]', "string" === typeof options.imageSizes && (preloadSelector += '[imagesizes="' + escapeSelectorAttributeValueInsideDoubleQuotes(
19817              options.imageSizes
19818            ) + '"]')) : preloadSelector += '[href="' + escapeSelectorAttributeValueInsideDoubleQuotes(href) + '"]' : preloadSelector += '[href="' + escapeSelectorAttributeValueInsideDoubleQuotes(href) + '"]';
19819            var key = preloadSelector;
19820            switch (as) {
19821              case "style":
19822                key = getStyleKey(href);
19823                break;
19824              case "script":
19825                key = getScriptKey(href);
19826            }
19827            preloadPropsMap.has(key) || (href = assign(
19828              {
19829                rel: "preload",
19830                href: "image" === as && options && options.imageSrcSet ? void 0 : href,
19831                as
19832              },
19833              options
19834            ), preloadPropsMap.set(key, href), null !== ownerDocument.querySelector(preloadSelector) || "style" === as && ownerDocument.querySelector(
19835              getStylesheetSelectorFromKey(key)
19836            ) || "script" === as && ownerDocument.querySelector(getScriptSelectorFromKey(key)) || (as = ownerDocument.createElement("link"), setInitialProperties(as, "link", href), markNodeAsHoistable(as), ownerDocument.head.appendChild(as)));
19837          }
19838        },
19839        m: function(href, options) {
19840          previousDispatcher.m(href, options);
19841          var ownerDocument = globalDocument;
19842          if (ownerDocument && href) {
19843            var as = options && "string" === typeof options.as ? options.as : "script", preloadSelector = 'link[rel="modulepreload"][as="' + escapeSelectorAttributeValueInsideDoubleQuotes(as) + '"][href="' + escapeSelectorAttributeValueInsideDoubleQuotes(href) + '"]', key = preloadSelector;
19844            switch (as) {
19845              case "audioworklet":
19846              case "paintworklet":
19847              case "serviceworker":
19848              case "sharedworker":
19849              case "worker":
19850              case "script":
19851                key = getScriptKey(href);
19852            }
19853            if (!preloadPropsMap.has(key) && (href = assign({ rel: "modulepreload", href }, options), preloadPropsMap.set(key, href), null === ownerDocument.querySelector(preloadSelector))) {
19854              switch (as) {
19855                case "audioworklet":
19856                case "paintworklet":
19857                case "serviceworker":
19858                case "sharedworker":
19859                case "worker":
19860                case "script":
19861                  if (ownerDocument.querySelector(getScriptSelectorFromKey(key)))
19862                    return;
19863              }
19864              as = ownerDocument.createElement("link");
19865              setInitialProperties(as, "link", href);
19866              markNodeAsHoistable(as);
19867              ownerDocument.head.appendChild(as);
19868            }
19869          }
19870        },
19871        X: function(src, options) {
19872          previousDispatcher.X(src, options);
19873          var ownerDocument = globalDocument;
19874          if (ownerDocument && src) {
19875            var scripts = getResourcesFromRoot(ownerDocument).hoistableScripts, key = getScriptKey(src), resource = scripts.get(key);
19876            resource || (resource = ownerDocument.querySelector(
19877              getScriptSelectorFromKey(key)
19878            ), resource || (src = assign({ src, async: true }, options), (options = preloadPropsMap.get(key)) && adoptPreloadPropsForScript(src, options), resource = ownerDocument.createElement("script"), markNodeAsHoistable(resource), setInitialProperties(resource, "link", src), ownerDocument.head.appendChild(resource)), resource = {
19879              type: "script",
19880              instance: resource,
19881              count: 1,
19882              state: null
19883            }, scripts.set(key, resource));
19884          }
19885        },
19886        S: function(href, precedence, options) {
19887          previousDispatcher.S(href, precedence, options);
19888          var ownerDocument = globalDocument;
19889          if (ownerDocument && href) {
19890            var styles = getResourcesFromRoot(ownerDocument).hoistableStyles, key = getStyleKey(href);
19891            precedence = precedence || "default";
19892            var resource = styles.get(key);
19893            if (!resource) {
19894              var state = { loading: NotLoaded, preload: null };
19895              if (resource = ownerDocument.querySelector(
19896                getStylesheetSelectorFromKey(key)
19897              ))
19898                state.loading = Loaded | Inserted;
19899              else {
19900                href = assign(
19901                  {
19902                    rel: "stylesheet",
19903                    href,
19904                    "data-precedence": precedence
19905                  },
19906                  options
19907                );
19908                (options = preloadPropsMap.get(key)) && adoptPreloadPropsForStylesheet(href, options);
19909                var link = resource = ownerDocument.createElement("link");
19910                markNodeAsHoistable(link);
19911                setInitialProperties(link, "link", href);
19912                link._p = new Promise(function(resolve, reject) {
19913                  link.onload = resolve;
19914                  link.onerror = reject;
19915                });
19916                link.addEventListener("load", function() {
19917                  state.loading |= Loaded;
19918                });
19919                link.addEventListener("error", function() {
19920                  state.loading |= Errored;
19921                });
19922                state.loading |= Inserted;
19923                insertStylesheet(resource, precedence, ownerDocument);
19924              }
19925              resource = {
19926                type: "stylesheet",
19927                instance: resource,
19928                count: 1,
19929                state
19930              };
19931              styles.set(key, resource);
19932            }
19933          }
19934        },
19935        M: function(src, options) {
19936          previousDispatcher.M(src, options);
19937          var ownerDocument = globalDocument;
19938          if (ownerDocument && src) {
19939            var scripts = getResourcesFromRoot(ownerDocument).hoistableScripts, key = getScriptKey(src), resource = scripts.get(key);
19940            resource || (resource = ownerDocument.querySelector(
19941              getScriptSelectorFromKey(key)
19942            ), resource || (src = assign({ src, async: true, type: "module" }, options), (options = preloadPropsMap.get(key)) && adoptPreloadPropsForScript(src, options), resource = ownerDocument.createElement("script"), markNodeAsHoistable(resource), setInitialProperties(resource, "link", src), ownerDocument.head.appendChild(resource)), resource = {
19943              type: "script",
19944              instance: resource,
19945              count: 1,
19946              state: null
19947            }, scripts.set(key, resource));
19948          }
19949        }
19950      };
19951      var globalDocument = "undefined" === typeof document ? null : document, tagCaches = null, SUSPENSEY_STYLESHEET_TIMEOUT = 6e4, SUSPENSEY_IMAGE_TIMEOUT = 800, SUSPENSEY_IMAGE_TIME_ESTIMATE = 500, estimatedBytesWithinLimit = 0, LAST_PRECEDENCE = null, precedencesByRoot = null, NotPendingTransition = NotPending, HostTransitionContext = {
19952        $$typeof: REACT_CONTEXT_TYPE,
19953        Provider: null,
19954        Consumer: null,
19955        _currentValue: NotPendingTransition,
19956        _currentValue2: NotPendingTransition,
19957        _threadCount: 0
19958      }, badgeFormat = "%c%s%c", badgeStyle = "background: #e6e6e6;background: light-dark(rgba(0,0,0,0.1), rgba(255,255,255,0.25));color: #000000;color: light-dark(#000000, #ffffff);border-radius: 2px", resetStyle = "", pad = " ", bind = Function.prototype.bind;
19959      var didWarnAboutNestedUpdates = false;
19960      var overrideHookState = null, overrideHookStateDeletePath = null, overrideHookStateRenamePath = null, overrideProps = null, overridePropsDeletePath = null, overridePropsRenamePath = null, scheduleUpdate = null, scheduleRetry = null, setErrorHandler = null, setSuspenseHandler = null;
19961      overrideHookState = function(fiber, id, path, value) {
19962        id = findHook(fiber, id);
19963        null !== id && (path = copyWithSetImpl(id.memoizedState, path, 0, value), id.memoizedState = path, id.baseState = path, fiber.memoizedProps = assign({}, fiber.memoizedProps), path = enqueueConcurrentRenderForLane(fiber, 2), null !== path && scheduleUpdateOnFiber(path, fiber, 2));
19964      };
19965      overrideHookStateDeletePath = function(fiber, id, path) {
19966        id = findHook(fiber, id);
19967        null !== id && (path = copyWithDeleteImpl(id.memoizedState, path, 0), id.memoizedState = path, id.baseState = path, fiber.memoizedProps = assign({}, fiber.memoizedProps), path = enqueueConcurrentRenderForLane(fiber, 2), null !== path && scheduleUpdateOnFiber(path, fiber, 2));
19968      };
19969      overrideHookStateRenamePath = function(fiber, id, oldPath, newPath) {
19970        id = findHook(fiber, id);
19971        null !== id && (oldPath = copyWithRename(id.memoizedState, oldPath, newPath), id.memoizedState = oldPath, id.baseState = oldPath, fiber.memoizedProps = assign({}, fiber.memoizedProps), oldPath = enqueueConcurrentRenderForLane(fiber, 2), null !== oldPath && scheduleUpdateOnFiber(oldPath, fiber, 2));
19972      };
19973      overrideProps = function(fiber, path, value) {
19974        fiber.pendingProps = copyWithSetImpl(fiber.memoizedProps, path, 0, value);
19975        fiber.alternate && (fiber.alternate.pendingProps = fiber.pendingProps);
19976        path = enqueueConcurrentRenderForLane(fiber, 2);
19977        null !== path && scheduleUpdateOnFiber(path, fiber, 2);
19978      };
19979      overridePropsDeletePath = function(fiber, path) {
19980        fiber.pendingProps = copyWithDeleteImpl(fiber.memoizedProps, path, 0);
19981        fiber.alternate && (fiber.alternate.pendingProps = fiber.pendingProps);
19982        path = enqueueConcurrentRenderForLane(fiber, 2);
19983        null !== path && scheduleUpdateOnFiber(path, fiber, 2);
19984      };
19985      overridePropsRenamePath = function(fiber, oldPath, newPath) {
19986        fiber.pendingProps = copyWithRename(
19987          fiber.memoizedProps,
19988          oldPath,
19989          newPath
19990        );
19991        fiber.alternate && (fiber.alternate.pendingProps = fiber.pendingProps);
19992        oldPath = enqueueConcurrentRenderForLane(fiber, 2);
19993        null !== oldPath && scheduleUpdateOnFiber(oldPath, fiber, 2);
19994      };
19995      scheduleUpdate = function(fiber) {
19996        var root2 = enqueueConcurrentRenderForLane(fiber, 2);
19997        null !== root2 && scheduleUpdateOnFiber(root2, fiber, 2);
19998      };
19999      scheduleRetry = function(fiber) {
20000        var lane = claimNextRetryLane(), root2 = enqueueConcurrentRenderForLane(fiber, lane);
20001        null !== root2 && scheduleUpdateOnFiber(root2, fiber, lane);
20002      };
20003      setErrorHandler = function(newShouldErrorImpl) {
20004        shouldErrorImpl = newShouldErrorImpl;
20005      };
20006      setSuspenseHandler = function(newShouldSuspendImpl) {
20007        shouldSuspendImpl = newShouldSuspendImpl;
20008      };
20009      var _enabled = true, return_targetInst = null, hasScheduledReplayAttempt = false, queuedFocus = null, queuedDrag = null, queuedMouse = null, queuedPointers = /* @__PURE__ */ new Map(), queuedPointerCaptures = /* @__PURE__ */ new Map(), queuedExplicitHydrationTargets = [], discreteReplayableEvents = "mousedown mouseup touchcancel touchend touchstart auxclick dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend compositionstart keydown keypress keyup input textInput copy cut paste click change contextmenu reset".split(
20010        " "
20011      ), lastScheduledReplayQueue = null;
20012      ReactDOMHydrationRoot.prototype.render = ReactDOMRoot.prototype.render = function(children) {
20013        var root2 = this._internalRoot;
20014        if (null === root2) throw Error("Cannot update an unmounted root.");
20015        var args = arguments;
20016        "function" === typeof args[1] ? console.error(
20017          "does not support the second callback argument. To execute a side effect after rendering, declare it in a component body with useEffect()."
20018        ) : isValidContainer(args[1]) ? console.error(
20019          "You passed a container to the second argument of root.render(...). You don't need to pass it again since you already passed it to create the root."
20020        ) : "undefined" !== typeof args[1] && console.error(
20021          "You passed a second argument to root.render(...) but it only accepts one argument."
20022        );
20023        args = children;
20024        var current2 = root2.current, lane = requestUpdateLane(current2);
20025        updateContainerImpl(current2, lane, args, root2, null, null);
20026      };
20027      ReactDOMHydrationRoot.prototype.unmount = ReactDOMRoot.prototype.unmount = function() {
20028        var args = arguments;
20029        "function" === typeof args[0] && console.error(
20030          "does not support a callback argument. To execute a side effect after rendering, declare it in a component body with useEffect()."
20031        );
20032        args = this._internalRoot;
20033        if (null !== args) {
20034          this._internalRoot = null;
20035          var container = args.containerInfo;
20036          (executionContext & (RenderContext | CommitContext)) !== NoContext && console.error(
20037            "Attempted to synchronously unmount a root while React was already rendering. React cannot finish unmounting the root until the current render has completed, which may lead to a race condition."
20038          );
20039          updateContainerImpl(args.current, 2, null, args, null, null);
20040          flushSyncWork$1();
20041          container[internalContainerInstanceKey] = null;
20042        }
20043      };
20044      ReactDOMHydrationRoot.prototype.unstable_scheduleHydration = function(target) {
20045        if (target) {
20046          var updatePriority = resolveUpdatePriority();
20047          target = { blockedOn: null, target, priority: updatePriority };
20048          for (var i = 0; i < queuedExplicitHydrationTargets.length && 0 !== updatePriority && updatePriority < queuedExplicitHydrationTargets[i].priority; i++) ;
20049          queuedExplicitHydrationTargets.splice(i, 0, target);
20050          0 === i && attemptExplicitHydrationTarget(target);
20051        }
20052      };
20053      (function() {
20054        var isomorphicReactPackageVersion = React.version;
20055        if ("19.2.3" !== isomorphicReactPackageVersion)
20056          throw Error(
20057            'Incompatible React versions: The "react" and "react-dom" packages must have the exact same version. Instead got:\n  - react:      ' + (isomorphicReactPackageVersion + "\n  - react-dom:  19.2.3\nLearn more: https://react.dev/warnings/version-mismatch")
20058          );
20059      })();
20060      "function" === typeof Map && null != Map.prototype && "function" === typeof Map.prototype.forEach && "function" === typeof Set && null != Set.prototype && "function" === typeof Set.prototype.clear && "function" === typeof Set.prototype.forEach || console.error(
20061        "React depends on Map and Set built-in types. Make sure that you load a polyfill in older browsers. https://react.dev/link/react-polyfills"
20062      );
20063      ReactDOMSharedInternals.findDOMNode = function(componentOrElement) {
20064        var fiber = componentOrElement._reactInternals;
20065        if (void 0 === fiber) {
20066          if ("function" === typeof componentOrElement.render)
20067            throw Error("Unable to find node on an unmounted component.");
20068          componentOrElement = Object.keys(componentOrElement).join(",");
20069          throw Error(
20070            "Argument appears to not be a ReactComponent. Keys: " + componentOrElement
20071          );
20072        }
20073        componentOrElement = findCurrentFiberUsingSlowPath(fiber);
20074        componentOrElement = null !== componentOrElement ? findCurrentHostFiberImpl(componentOrElement) : null;
20075        componentOrElement = null === componentOrElement ? null : componentOrElement.stateNode;
20076        return componentOrElement;
20077      };
20078      if (!(function() {
20079        var internals = {
20080          bundleType: 1,
20081          version: "19.2.3",
20082          rendererPackageName: "react-dom",
20083          currentDispatcherRef: ReactSharedInternals,
20084          reconcilerVersion: "19.2.3"
20085        };
20086        internals.overrideHookState = overrideHookState;
20087        internals.overrideHookStateDeletePath = overrideHookStateDeletePath;
20088        internals.overrideHookStateRenamePath = overrideHookStateRenamePath;
20089        internals.overrideProps = overrideProps;
20090        internals.overridePropsDeletePath = overridePropsDeletePath;
20091        internals.overridePropsRenamePath = overridePropsRenamePath;
20092        internals.scheduleUpdate = scheduleUpdate;
20093        internals.scheduleRetry = scheduleRetry;
20094        internals.setErrorHandler = setErrorHandler;
20095        internals.setSuspenseHandler = setSuspenseHandler;
20096        internals.scheduleRefresh = scheduleRefresh;
20097        internals.scheduleRoot = scheduleRoot;
20098        internals.setRefreshHandler = setRefreshHandler;
20099        internals.getCurrentFiber = getCurrentFiberForDevTools;
20100        return injectInternals(internals);
20101      })() && canUseDOM && window.top === window.self && (-1 < navigator.userAgent.indexOf("Chrome") && -1 === navigator.userAgent.indexOf("Edge") || -1 < navigator.userAgent.indexOf("Firefox"))) {
20102        var protocol = window.location.protocol;
20103        /^(https?|file):$/.test(protocol) && console.info(
20104          "%cDownload the React DevTools for a better development experience: https://react.dev/link/react-devtools" + ("file:" === protocol ? "\nYou might need to use a local HTTP server (instead of file://): https://react.dev/link/react-devtools-faq" : ""),
20105          "font-weight:bold"
20106        );
20107      }
20108      exports.createRoot = function(container, options) {
20109        if (!isValidContainer(container))
20110          throw Error("Target container is not a DOM element.");
20111        warnIfReactDOMContainerInDEV(container);
20112        var isStrictMode = false, identifierPrefix = "", onUncaughtError = defaultOnUncaughtError, onCaughtError = defaultOnCaughtError, onRecoverableError = defaultOnRecoverableError;
20113        null !== options && void 0 !== options && (options.hydrate ? console.warn(
20114          "hydrate through createRoot is deprecated. Use ReactDOMClient.hydrateRoot(container, <App />) instead."
20115        ) : "object" === typeof options && null !== options && options.$$typeof === REACT_ELEMENT_TYPE && console.error(
20116          "You passed a JSX element to createRoot. You probably meant to call root.render instead. Example usage:\n\n  let root = createRoot(domContainer);\n  root.render(<App />);"
20117        ), true === options.unstable_strictMode && (isStrictMode = true), void 0 !== options.identifierPrefix && (identifierPrefix = options.identifierPrefix), void 0 !== options.onUncaughtError && (onUncaughtError = options.onUncaughtError), void 0 !== options.onCaughtError && (onCaughtError = options.onCaughtError), void 0 !== options.onRecoverableError && (onRecoverableError = options.onRecoverableError));
20118        options = createFiberRoot(
20119          container,
20120          1,
20121          false,
20122          null,
20123          null,
20124          isStrictMode,
20125          identifierPrefix,
20126          null,
20127          onUncaughtError,
20128          onCaughtError,
20129          onRecoverableError,
20130          defaultOnDefaultTransitionIndicator
20131        );
20132        container[internalContainerInstanceKey] = options.current;
20133        listenToAllSupportedEvents(container);
20134        return new ReactDOMRoot(options);
20135      };
20136      exports.hydrateRoot = function(container, initialChildren, options) {
20137        if (!isValidContainer(container))
20138          throw Error("Target container is not a DOM element.");
20139        warnIfReactDOMContainerInDEV(container);
20140        void 0 === initialChildren && console.error(
20141          "Must provide initial children as second argument to hydrateRoot. Example usage: hydrateRoot(domContainer, <App />)"
20142        );
20143        var isStrictMode = false, identifierPrefix = "", onUncaughtError = defaultOnUncaughtError, onCaughtError = defaultOnCaughtError, onRecoverableError = defaultOnRecoverableError, formState = null;
20144        null !== options && void 0 !== options && (true === options.unstable_strictMode && (isStrictMode = true), void 0 !== options.identifierPrefix && (identifierPrefix = options.identifierPrefix), void 0 !== options.onUncaughtError && (onUncaughtError = options.onUncaughtError), void 0 !== options.onCaughtError && (onCaughtError = options.onCaughtError), void 0 !== options.onRecoverableError && (onRecoverableError = options.onRecoverableError), void 0 !== options.formState && (formState = options.formState));
20145        initialChildren = createFiberRoot(
20146          container,
20147          1,
20148          true,
20149          initialChildren,
20150          null != options ? options : null,
20151          isStrictMode,
20152          identifierPrefix,
20153          formState,
20154          onUncaughtError,
20155          onCaughtError,
20156          onRecoverableError,
20157          defaultOnDefaultTransitionIndicator
20158        );
20159        initialChildren.context = getContextForSubtree(null);
20160        options = initialChildren.current;
20161        isStrictMode = requestUpdateLane(options);
20162        isStrictMode = getBumpedLaneForHydrationByLane(isStrictMode);
20163        identifierPrefix = createUpdate(isStrictMode);
20164        identifierPrefix.callback = null;
20165        enqueueUpdate(options, identifierPrefix, isStrictMode);
20166        startUpdateTimerByLane(isStrictMode, "hydrateRoot()", null);
20167        options = isStrictMode;
20168        initialChildren.current.lanes = options;
20169        markRootUpdated$1(initialChildren, options);
20170        ensureRootIsScheduled(initialChildren);
20171        container[internalContainerInstanceKey] = initialChildren.current;
20172        listenToAllSupportedEvents(container);
20173        return new ReactDOMHydrationRoot(initialChildren);
20174      };
20175      exports.version = "19.2.3";
20176      "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
20177    })();
20178  }
20179});
20180