https://yano.ai/assets/application-8d58e5a4.js

34// node_modules/@rails/actioncable/src/adapters.js
35var adapters_default;
36var init_adapters = __esm({
37  "node_modules/@rails/actioncable/src/adapters.js"() {
38    adapters_default = {
39      logger: typeof console !== "undefined" ? console : void 0,
40      WebSocket: typeof WebSocket !== "undefined" ? WebSocket : void 0
41    };
42  }
43});
44

45// node_modules/@rails/actioncable/src/logger.js
46var logger_default;
47var init_logger = __esm({
48  "node_modules/@rails/actioncable/src/logger.js"() {
49    init_adapters();
50    logger_default = {
51      log(...messages) {
52        if (this.enabled) {
53          messages.push(Date.now());
54          adapters_default.logger.log("[ActionCable]", ...messages);
55        }
56      }
57    };
58  }
59});
60

61// node_modules/@rails/actioncable/src/connection_monitor.js
62var now, secondsSince, ConnectionMonitor, connection_monitor_default;
63var init_connection_monitor = __esm({
64  "node_modules/@rails/actioncable/src/connection_monitor.js"() {
65    init_logger();
66    now = () => (/* @__PURE__ */ new Date()).getTime();
67    secondsSince = (time) => (now() - time) / 1e3;
68    ConnectionMonitor = class {
69      constructor(connection) {
70        this.visibilityDidChange = this.visibilityDidChange.bind(this);
71        this.connection = connection;
72        this.reconnectAttempts = 0;
73      }
74      start() {
75        if (!this.isRunning()) {
76          this.startedAt = now();
77          delete this.stoppedAt;
78          this.startPolling();
79          addEventListener("visibilitychange", this.visibilityDidChange);
80          logger_default.log(`ConnectionMonitor started. stale threshold = ${this.constructor.staleThreshold} s`);
81        }
82      }
83      stop() {
84        if (this.isRunning()) {
85          this.stoppedAt = now();
86          this.stopPolling();
87          removeEventListener("visibilitychange", this.visibilityDidChange);
88          logger_default.log("ConnectionMonitor stopped");
89        }
90      }
91      isRunning() {
92        return this.startedAt && !this.stoppedAt;
93      }
94      recordMessage() {
95        this.pingedAt = now();
96      }
97      recordConnect() {
98        this.reconnectAttempts = 0;
99        delete this.disconnectedAt;
100        logger_default.log("ConnectionMonitor recorded connect");
101      }
102      recordDisconnect() {
103        this.disconnectedAt = now();
104        logger_default.log("ConnectionMonitor recorded disconnect");
105      }
106      // Private
107      startPolling() {
108        this.stopPolling();
109        this.poll();
110      }
111      stopPolling() {
112        clearTimeout(this.pollTimeout);
113      }
114      poll() {
115        this.pollTimeout = setTimeout(
116          () => {
117            this.reconnectIfStale();
118            this.poll();
119          },
120          this.getPollInterval()
121        );
122      }
123      getPollInterval() {
124        const { staleThreshold, reconnectionBackoffRate } = this.constructor;
125        const backoff = Math.pow(1 + reconnectionBackoffRate, Math.min(this.reconnectAttempts, 10));
126        const jitterMax = this.reconnectAttempts === 0 ? 1 : reconnectionBackoffRate;
127        const jitter = jitterMax * Math.random();
128        return staleThreshold * 1e3 * backoff * (1 + jitter);
129      }
130      reconnectIfStale() {
131        if (this.connectionIsStale()) {
132          logger_default.log(`ConnectionMonitor detected stale connection. reconnectAttempts = ${this.reconnectAttempts}, time stale = ${secondsSince(this.refreshedAt)} s, stale threshold = ${this.constructor.staleThreshold} s`);
133          this.reconnectAttempts++;
134          if (this.disconnectedRecently()) {
135            logger_default.log(`ConnectionMonitor skipping reopening recent disconnect. time disconnected = ${secondsSince(this.disconnectedAt)} s`);
136          } else {
137            logger_default.log("ConnectionMonitor reopening");
138            this.connection.reopen();
139          }
140        }
141      }
142      get refreshedAt() {
143        return this.pingedAt ? this.pingedAt : this.startedAt;
144      }
145      connectionIsStale() {
146        return secondsSince(this.refreshedAt) > this.constructor.staleThreshold;
147      }
148      disconnectedRecently() {
149        return this.disconnectedAt && secondsSince(this.disconnectedAt) < this.constructor.staleThreshold;
150      }
151      visibilityDidChange() {
152        if (document.visibilityState === "visible") {
153          setTimeout(
154            () => {
155              if (this.connectionIsStale() || !this.connection.isOpen()) {
156                logger_default.log(`ConnectionMonitor reopening stale connection on visibilitychange. visibilityState = ${document.visibilityState}`);
157                this.connection.reopen();
158              }
159            },
160            200
161          );
162        }
163      }
164    };
165    ConnectionMonitor.staleThreshold = 6;
166    ConnectionMonitor.reconnectionBackoffRate = 0.15;
167    connection_monitor_default = ConnectionMonitor;
168  }
169});
170

171// node_modules/@rails/actioncable/src/internal.js
172var internal_default;
173var init_internal = __esm({
174  "node_modules/@rails/actioncable/src/internal.js"() {
175    internal_default = {
176      "message_types": {
177        "welcome": "welcome",
178        "disconnect": "disconnect",
179        "ping": "ping",
180        "confirmation": "confirm_subscription",
181        "rejection": "reject_subscription"
182      },
183      "disconnect_reasons": {
184        "unauthorized": "unauthorized",
185        "invalid_request": "invalid_request",
186        "server_restart": "server_restart",
187        "remote": "remote"
188      },
189      "default_mount_path": "/cable",
190      "protocols": [
191        "actioncable-v1-json",
192        "actioncable-unsupported"
193      ]
194    };
195  }
196});
197

198// node_modules/@rails/actioncable/src/connection.js
199var message_types, protocols, supportedProtocols, indexOf, Connection, connection_default;
200var init_connection = __esm({
201  "node_modules/@rails/actioncable/src/connection.js"() {
202    init_adapters();
203    init_connection_monitor();
204    init_internal();
205    init_logger();
206    ({ message_types, protocols } = internal_default);
207    supportedProtocols = protocols.slice(0, protocols.length - 1);
208    indexOf = [].indexOf;
209    Connection = class {
210      constructor(consumer2) {
211        this.open = this.open.bind(this);
212        this.consumer = consumer2;
213        this.subscriptions = this.consumer.subscriptions;
214        this.monitor = new connection_monitor_default(this);
215        this.disconnected = true;
216      }
217      send(data) {
218        if (this.isOpen()) {
219          this.webSocket.send(JSON.stringify(data));
220          return true;
221        } else {
222          return false;
223        }
224      }
225      open() {
226        if (this.isActive()) {
227          logger_default.log(`Attempted to open WebSocket, but existing socket is ${this.getState()}`);
228          return false;
229        } else {
230          const socketProtocols = [...protocols, ...this.consumer.subprotocols || []];
231          logger_default.log(`Opening WebSocket, current state is ${this.getState()}, subprotocols: ${socketProtocols}`);
232          if (this.webSocket) {
233            this.uninstallEventHandlers();
234          }
235          this.webSocket = new adapters_default.WebSocket(this.consumer.url, socketProtocols);
236          this.installEventHandlers();
237          this.monitor.start();
238          return true;
239        }
240      }
241      close({ allowReconnect } = { allowReconnect: true }) {
242        if (!allowReconnect) {
243          this.monitor.stop();
244        }
245        if (this.isOpen()) {
246          return this.webSocket.close();
247        }
248      }
249      reopen() {
250        logger_default.log(`Reopening WebSocket, current state is ${this.getState()}`);
251        if (this.isActive()) {
252          try {
253            return this.close();
254          } catch (error2) {
255            logger_default.log("Failed to reopen WebSocket", error2);
256          } finally {
257            logger_default.log(`Reopening WebSocket in ${this.constructor.reopenDelay}ms`);
258            setTimeout(this.open, this.constructor.reopenDelay);
259          }
260        } else {
261          return this.open();
262        }
263      }
264      getProtocol() {
265        if (this.webSocket) {
266          return this.webSocket.protocol;
267        }
268      }
269      isOpen() {
270        return this.isState("open");
271      }
272      isActive() {
273        return this.isState("open", "connecting");
274      }
275      triedToReconnect() {
276        return this.monitor.reconnectAttempts > 0;
277      }
278      // Private
279      isProtocolSupported() {
280        return indexOf.call(supportedProtocols, this.getProtocol()) >= 0;
281      }
282      isState(...states) {
283        return indexOf.call(states, this.getState()) >= 0;
284      }
285      getState() {
286        if (this.webSocket) {
287          for (let state in adapters_default.WebSocket) {
288            if (adapters_default.WebSocket[state] === this.webSocket.readyState) {
289              return state.toLowerCase();
290            }
291          }
292        }
293        return null;
294      }
295      installEventHandlers() {
296        for (let eventName in this.events) {
297          const handler = this.events[eventName].bind(this);
298          this.webSocket[`on${eventName}`] = handler;
299        }
300      }
301      uninstallEventHandlers() {
302        for (let eventName in this.events) {
303          this.webSocket[`on${eventName}`] = function() {
304          };
305        }
306      }
307    };
308    Connection.reopenDelay = 500;
309    Connection.prototype.events = {
310      message(event) {
311        if (!this.isProtocolSupported()) {
312          return;
313        }
314        const { identifier, message, reason, reconnect, type } = JSON.parse(event.data);
315        this.monitor.recordMessage();
316        switch (type) {
317          case message_types.welcome:
318            if (this.triedToReconnect()) {
319              this.reconnectAttempted = true;
320            }
321            this.monitor.recordConnect();
322            return this.subscriptions.reload();
323          case message_types.disconnect:
324            logger_default.log(`Disconnecting. Reason: ${reason}`);
325            return this.close({ allowReconnect: reconnect });
326          case message_types.ping:
327            return null;
328          case message_types.confirmation:
329            this.subscriptions.confirmSubscription(identifier);
330            if (this.reconnectAttempted) {
331              this.reconnectAttempted = false;
332              return this.subscriptions.notify(identifier, "connected", { reconnected: true });
333            } else {
334              return this.subscriptions.notify(identifier, "connected", { reconnected: false });
335            }
336          case message_types.rejection:
337            return this.subscriptions.reject(identifier);
338          default:
339            return this.subscriptions.notify(identifier, "received", message);
340        }
341      },
342      open() {
343        logger_default.log(`WebSocket onopen event, using '${this.getProtocol()}' subprotocol`);
344        this.disconnected = false;
345        if (!this.isProtocolSupported()) {
346          logger_default.log("Protocol is unsupported. Stopping monitor and disconnecting.");
347          return this.close({ allowReconnect: false });
348        }
349      },
350      close(event) {
351        logger_default.log("WebSocket onclose event");
352        if (this.disconnected) {
353          return;
354        }
355        this.disconnected = true;
356        this.monitor.recordDisconnect();
357        return this.subscriptions.notifyAll("disconnected", { willAttemptReconnect: this.monitor.isRunning() });
358      },
359      error() {
360        logger_default.log("WebSocket onerror event");
361      }
362    };
363    connection_default = Connection;
364  }
365});
366

367// node_modules/@rails/actioncable/src/subscription.js
368var extend, Subscription;
369var init_subscription = __esm({
370  "node_modules/@rails/actioncable/src/subscription.js"() {
371    extend = function(object, properties) {
372      if (properties != null) {
373        for (let key in properties) {
374          const value = properties[key];
375          object[key] = value;
376        }
377      }
378      return object;
379    };
380    Subscription = class {
381      constructor(consumer2, params = {}, mixin) {
382        this.consumer = consumer2;
383        this.identifier = JSON.stringify(params);
384        extend(this, mixin);
385      }
386      // Perform a channel action with the optional data passed as an attribute
387      perform(action, data = {}) {
388        data.action = action;
389        return this.send(data);
390      }
391      send(data) {
392        return this.consumer.send({ command: "message", identifier: this.identifier, data: JSON.stringify(data) });
393      }
394      unsubscribe() {
395        return this.consumer.subscriptions.remove(this);
396      }
397    };
398  }
399});
400

401// node_modules/@rails/actioncable/src/subscription_guarantor.js
402var SubscriptionGuarantor, subscription_guarantor_default;
403var init_subscription_guarantor = __esm({
404  "node_modules/@rails/actioncable/src/subscription_guarantor.js"() {
405    init_logger();
406    SubscriptionGuarantor = class {
407      constructor(subscriptions) {
408        this.subscriptions = subscriptions;
409        this.pendingSubscriptions = [];
410      }
411      guarantee(subscription) {
412        if (this.pendingSubscriptions.indexOf(subscription) == -1) {
413          logger_default.log(`SubscriptionGuarantor guaranteeing ${subscription.identifier}`);
414          this.pendingSubscriptions.push(subscription);
415        } else {
416          logger_default.log(`SubscriptionGuarantor already guaranteeing ${subscription.identifier}`);
417        }
418        this.startGuaranteeing();
419      }
420      forget(subscription) {
421        logger_default.log(`SubscriptionGuarantor forgetting ${subscription.identifier}`);
422        this.pendingSubscriptions = this.pendingSubscriptions.filter((s3) => s3 !== subscription);
423      }
424      startGuaranteeing() {
425        this.stopGuaranteeing();
426        this.retrySubscribing();
427      }
428      stopGuaranteeing() {
429        clearTimeout(this.retryTimeout);
430      }
431      retrySubscribing() {
432        this.retryTimeout = setTimeout(
433          () => {
434            if (this.subscriptions && typeof this.subscriptions.subscribe === "function") {
435              this.pendingSubscriptions.map((subscription) => {
436                logger_default.log(`SubscriptionGuarantor resubscribing ${subscription.identifier}`);
437                this.subscriptions.subscribe(subscription);
438              });
439            }
440          },
441          500
442        );
443      }
444    };
445    subscription_guarantor_default = SubscriptionGuarantor;
446  }
447});
448

449// node_modules/@rails/actioncable/src/subscriptions.js
450var Subscriptions;
451var init_subscriptions = __esm({
452  "node_modules/@rails/actioncable/src/subscriptions.js"() {
453    init_logger();
454    init_subscription();
455    init_subscription_guarantor();
456    Subscriptions = class {
457      constructor(consumer2) {
458        this.consumer = consumer2;
459        this.guarantor = new subscription_guarantor_default(this);
460        this.subscriptions = [];
461      }
462      create(channelName, mixin) {
463        const channel = channelName;
464        const params = typeof channel === "object" ? channel : { channel };
465        const subscription = new Subscription(this.consumer, params, mixin);
466        return this.add(subscription);
467      }
468      // Private
469      add(subscription) {
470        this.subscriptions.push(subscription);
471        this.consumer.ensureActiveConnection();
472        this.notify(subscription, "initialized");
473        this.subscribe(subscription);
474        return subscription;
475      }
476      remove(subscription) {
477        this.forget(subscription);
478        if (!this.findAll(subscription.identifier).length) {
479          this.sendCommand(subscription, "unsubscribe");
480        }
481        return subscription;
482      }
483      reject(identifier) {
484        return this.findAll(identifier).map((subscription) => {
485          this.forget(subscription);
486          this.notify(subscription, "rejected");
487          return subscription;
488        });
489      }
490      forget(subscription) {
491        this.guarantor.forget(subscription);
492        this.subscriptions = this.subscriptions.filter((s3) => s3 !== subscription);
493        return subscription;
494      }
495      findAll(identifier) {
496        return this.subscriptions.filter((s3) => s3.identifier === identifier);
497      }
498      reload() {
499        return this.subscriptions.map((subscription) => this.subscribe(subscription));
500      }
501      notifyAll(callbackName, ...args) {
502        return this.subscriptions.map((subscription) => this.notify(subscription, callbackName, ...args));
503      }
504      notify(subscription, callbackName, ...args) {
505        let subscriptions;
506        if (typeof subscription === "string") {
507          subscriptions = this.findAll(subscription);
508        } else {
509          subscriptions = [subscription];
510        }
511        return subscriptions.map((subscription2) => typeof subscription2[callbackName] === "function" ? subscription2[callbackName](...args) : void 0);
512      }
513      subscribe(subscription) {
514        if (this.sendCommand(subscription, "subscribe")) {
515          this.guarantor.guarantee(subscription);
516        }
517      }
518      confirmSubscription(identifier) {
519        logger_default.log(`Subscription confirmed ${identifier}`);
520        this.findAll(identifier).map((subscription) => this.guarantor.forget(subscription));
521      }
522      sendCommand(subscription, command) {
523        const { identifier } = subscription;
524        return this.consumer.send({ command, identifier });
525      }
526    };
527  }
528});
529

530// node_modules/@rails/actioncable/src/consumer.js
531function createWebSocketURL(url) {
532  if (typeof url === "function") {
533    url = url();
534  }
535  if (url && !/^wss?:/i.test(url)) {
536    const a3 = document.createElement("a");
537    a3.href = url;
538    a3.href = a3.href;
539    a3.protocol = a3.protocol.replace("http", "ws");
540    return a3.href;
541  } else {
542    return url;
543  }
544}
545var Consumer;
546var init_consumer = __esm({
547  "node_modules/@rails/actioncable/src/consumer.js"() {
548    init_connection();
549    init_subscriptions();
550    Consumer = class {
551      constructor(url) {
552        this._url = url;
553        this.subscriptions = new Subscriptions(this);
554        this.connection = new connection_default(this);
555        this.subprotocols = [];
556      }
557      get url() {
558        return createWebSocketURL(this._url);
559      }
560      send(data) {
561        return this.connection.send(data);
562      }
563      connect() {
564        return this.connection.open();
565      }
566      disconnect() {
567        return this.connection.close({ allowReconnect: false });
568      }
569      ensureActiveConnection() {
570        if (!this.connection.isActive()) {
571          return this.connection.open();
572        }
573      }
574      addSubProtocol(subprotocol) {
575        this.subprotocols = [...this.subprotocols, subprotocol];
576      }
577    };
578  }
579});
580

581// node_modules/@rails/actioncable/src/index.js
582var src_exports = {};
583__export(src_exports, {
584  Connection: () => connection_default,
585  ConnectionMonitor: () => connection_monitor_default,
586  Consumer: () => Consumer,
587  INTERNAL: () => internal_default,
588  Subscription: () => Subscription,
589  SubscriptionGuarantor: () => subscription_guarantor_default,
590  Subscriptions: () => Subscriptions,
591  adapters: () => adapters_default,
592  createConsumer: () => createConsumer,
593  createWebSocketURL: () => createWebSocketURL,
594  getConfig: () => getConfig,
595  logger: () => logger_default
596});
597function createConsumer(url = getConfig("url") || internal_default.default_mount_path) {
598  return new Consumer(url);
599}
600function getConfig(name) {
601  const element = document.head.querySelector(`meta[name='action-cable-${name}']`);
602  if (element) {
603    return element.getAttribute("content");
604  }
605}
606var init_src = __esm({
607  "node_modules/@rails/actioncable/src/index.js"() {
608    init_adapters();
609    init_connection();
610    init_connection_monitor();
611    init_consumer();
612    init_internal();
613    init_logger();
614    init_subscription();
615    init_subscription_guarantor();
616    init_subscriptions();
617  }
618});
619

620// node_modules/react/cjs/react.development.js
621var require_react_development = __commonJS({
622  "node_modules/react/cjs/react.development.js"(exports, module) {
623    "use strict";
624    (function() {
625      function defineDeprecationWarning(methodName, info) {
626        Object.defineProperty(Component.prototype, methodName, {
627          get: function() {
628            console.warn(
629              "%s(...) is deprecated in plain JavaScript React classes. %s",
630              info[0],
631              info[1]
632            );
633          }
634        });
635      }
636      function getIteratorFn(maybeIterable) {
637        if (null === maybeIterable || "object" !== typeof maybeIterable)
638          return null;
639        maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
640        return "function" === typeof maybeIterable ? maybeIterable : null;
641      }
642      function warnNoop(publicInstance, callerName) {
643        publicInstance = (publicInstance = publicInstance.constructor) && (publicInstance.displayName || publicInstance.name) || "ReactClass";
644        var warningKey = publicInstance + "." + callerName;
645        didWarnStateUpdateForUnmountedComponent[warningKey] || (console.error(
646          "Can't call %s on a component that is not yet mounted. This is a no-op, but it might indicate a bug in your application. Instead, assign to `this.state` directly or define a `state = {};` class property with the desired state in the %s component.",
647          callerName,
648          publicInstance
649        ), didWarnStateUpdateForUnmountedComponent[warningKey] = true);
650      }
651      function Component(props, context, updater) {
652        this.props = props;
653        this.context = context;
654        this.refs = emptyObject;
655        this.updater = updater || ReactNoopUpdateQueue;
656      }
657      function ComponentDummy() {
658      }
659      function PureComponent(props, context, updater) {
660        this.props = props;
661        this.context = context;
662        this.refs = emptyObject;
663        this.updater = updater || ReactNoopUpdateQueue;
664      }
665      function noop() {
666      }
667      function testStringCoercion(value) {
668        return "" + value;
669      }
670      function checkKeyStringCoercion(value) {
671        try {
672          testStringCoercion(value);
673          var JSCompiler_inline_result = false;
674        } catch (e3) {
675          JSCompiler_inline_result = true;
676        }
677        if (JSCompiler_inline_result) {
678          JSCompiler_inline_result = console;
679          var JSCompiler_temp_const = JSCompiler_inline_result.error;
680          var JSCompiler_inline_result$jscomp$0 = "function" === typeof Symbol && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
681          JSCompiler_temp_const.call(
682            JSCompiler_inline_result,
683            "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
684            JSCompiler_inline_result$jscomp$0
685          );
686          return testStringCoercion(value);
687        }
688      }
689      function getComponentNameFromType(type) {
690        if (null == type) return null;
691        if ("function" === typeof type)
692          return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
693        if ("string" === typeof type) return type;
694        switch (type) {
695          case REACT_FRAGMENT_TYPE:
696            return "Fragment";
697          case REACT_PROFILER_TYPE:
698            return "Profiler";
699          case REACT_STRICT_MODE_TYPE:
700            return "StrictMode";
701          case REACT_SUSPENSE_TYPE:
702            return "Suspense";
703          case REACT_SUSPENSE_LIST_TYPE:
704            return "SuspenseList";
705          case REACT_ACTIVITY_TYPE:
706            return "Activity";
707        }
708        if ("object" === typeof type)
709          switch ("number" === typeof type.tag && console.error(
710            "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
711          ), type.$$typeof) {
712            case REACT_PORTAL_TYPE:
713              return "Portal";
714            case REACT_CONTEXT_TYPE:
715              return type.displayName || "Context";
716            case REACT_CONSUMER_TYPE:
717              return (type._context.displayName || "Context") + ".Consumer";
718            case REACT_FORWARD_REF_TYPE:
719              var innerType = type.render;
720              type = type.displayName;
721              type || (type = innerType.displayName || innerType.name || "", type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef");
722              return type;
723            case REACT_MEMO_TYPE:
724              return innerType = type.displayName || null, null !== innerType ? innerType : getComponentNameFromType(type.type) || "Memo";
725            case REACT_LAZY_TYPE:
726              innerType = type._payload;
727              type = type._init;
728              try {
729                return getComponentNameFromType(type(innerType));
730              } catch (x3) {
731              }
732          }
733        return null;
734      }
735      function getTaskName(type) {
736        if (type === REACT_FRAGMENT_TYPE) return "<>";
737        if ("object" === typeof type && null !== type && type.$$typeof === REACT_LAZY_TYPE)
738          return "<...>";
739        try {
740          var name = getComponentNameFromType(type);
741          return name ? "<" + name + ">" : "<...>";
742        } catch (x3) {
743          return "<...>";
744        }
745      }
746      function getOwner() {
747        var dispatcher = ReactSharedInternals.A;
748        return null === dispatcher ? null : dispatcher.getOwner();
749      }
750      function UnknownOwner() {
751        return Error("react-stack-top-frame");
752      }
753      function hasValidKey(config2) {
754        if (hasOwnProperty.call(config2, "key")) {
755          var getter = Object.getOwnPropertyDescriptor(config2, "key").get;
756          if (getter && getter.isReactWarning) return false;
757        }
758        return void 0 !== config2.key;
759      }
760      function defineKeyPropWarningGetter(props, displayName) {
761        function warnAboutAccessingKey() {
762          specialPropKeyWarningShown || (specialPropKeyWarningShown = true, console.error(
763            "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
764            displayName
765          ));
766        }
767        warnAboutAccessingKey.isReactWarning = true;
768        Object.defineProperty(props, "key", {
769          get: warnAboutAccessingKey,
770          configurable: true
771        });
772      }
773      function elementRefGetterWithDeprecationWarning() {
774        var componentName = getComponentNameFromType(this.type);
775        didWarnAboutElementRef[componentName] || (didWarnAboutElementRef[componentName] = true, console.error(
776          "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
777        ));
778        componentName = this.props.ref;
779        return void 0 !== componentName ? componentName : null;
780      }
781      function ReactElement(type, key, props, owner, debugStack, debugTask) {
782        var refProp = props.ref;
783        type = {
784          $$typeof: REACT_ELEMENT_TYPE,
785          type,
786          key,
787          props,
788          _owner: owner
789        };
790        null !== (void 0 !== refProp ? refProp : null) ? Object.defineProperty(type, "ref", {
791          enumerable: false,
792          get: elementRefGetterWithDeprecationWarning
793        }) : Object.defineProperty(type, "ref", { enumerable: false, value: null });
794        type._store = {};
795        Object.defineProperty(type._store, "validated", {
796          configurable: false,
797          enumerable: false,
798          writable: true,
799          value: 0
800        });
801        Object.defineProperty(type, "_debugInfo", {
802          configurable: false,
803          enumerable: false,
804          writable: true,
805          value: null
806        });
807        Object.defineProperty(type, "_debugStack", {
808          configurable: false,
809          enumerable: false,
810          writable: true,
811          value: debugStack
812        });
813        Object.defineProperty(type, "_debugTask", {
814          configurable: false,
815          enumerable: false,
816          writable: true,
817          value: debugTask
818        });
819        Object.freeze && (Object.freeze(type.props), Object.freeze(type));
820        return type;
821      }
822      function cloneAndReplaceKey(oldElement, newKey) {
823        newKey = ReactElement(
824          oldElement.type,
825          newKey,
826          oldElement.props,
827          oldElement._owner,
828          oldElement._debugStack,
829          oldElement._debugTask
830        );
831        oldElement._store && (newKey._store.validated = oldElement._store.validated);
832        return newKey;
833      }
834      function validateChildKeys(node) {
835        isValidElement(node) ? node._store && (node._store.validated = 1) : "object" === typeof node && null !== node && node.$$typeof === REACT_LAZY_TYPE && ("fulfilled" === node._payload.status ? isValidElement(node._payload.value) && node._payload.value._store && (node._payload.value._store.validated = 1) : node._store && (node._store.validated = 1));
836      }
837      function isValidElement(object) {
838        return "object" === typeof object && null !== object && object.$$typeof === REACT_ELEMENT_TYPE;
839      }
840      function escape(key) {
841        var escaperLookup = { "=": "=0", ":": "=2" };
842        return "$" + key.replace(/[=:]/g, function(match) {
843          return escaperLookup[match];
844        });
845      }
846      function getElementKey(element, index) {
847        return "object" === typeof element && null !== element && null != element.key ? (checkKeyStringCoercion(element.key), escape("" + element.key)) : index.toString(36);
848      }
849      function resolveThenable(thenable) {
850        switch (thenable.status) {
851          case "fulfilled":
852            return thenable.value;
853          case "rejected":
854            throw thenable.reason;
855          default:
856            switch ("string" === typeof thenable.status ? thenable.then(noop, noop) : (thenable.status = "pending", thenable.then(
857              function(fulfilledValue) {
858                "pending" === thenable.status && (thenable.status = "fulfilled", thenable.value = fulfilledValue);
859              },
860              function(error2) {
861                "pending" === thenable.status && (thenable.status = "rejected", thenable.reason = error2);
862              }
863            )), thenable.status) {
864              case "fulfilled":
865                return thenable.value;
866              case "rejected":
867                throw thenable.reason;
868            }
869        }
870        throw thenable;
871      }
872      function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
873        var type = typeof children;
874        if ("undefined" === type || "boolean" === type) children = null;
875        var invokeCallback = false;
876        if (null === children) invokeCallback = true;
877        else
878          switch (type) {
879            case "bigint":
880            case "string":
881            case "number":
882              invokeCallback = true;
883              break;
884            case "object":
885              switch (children.$$typeof) {
886                case REACT_ELEMENT_TYPE:
887                case REACT_PORTAL_TYPE:
888                  invokeCallback = true;
889                  break;
890                case REACT_LAZY_TYPE:
891                  return invokeCallback = children._init, mapIntoArray(
892                    invokeCallback(children._payload),
893                    array,
894                    escapedPrefix,
895                    nameSoFar,
896                    callback
897                  );
898              }
899          }
900        if (invokeCallback) {
901          invokeCallback = children;
902          callback = callback(invokeCallback);
903          var childKey = "" === nameSoFar ? "." + getElementKey(invokeCallback, 0) : nameSoFar;
904          isArrayImpl(callback) ? (escapedPrefix = "", null != childKey && (escapedPrefix = childKey.replace(userProvidedKeyEscapeRegex, "$&/") + "/"), mapIntoArray(callback, array, escapedPrefix, "", function(c3) {
905            return c3;
906          })) : null != callback && (isValidElement(callback) && (null != callback.key && (invokeCallback && invokeCallback.key === callback.key || checkKeyStringCoercion(callback.key)), escapedPrefix = cloneAndReplaceKey(
907            callback,
908            escapedPrefix + (null == callback.key || invokeCallback && invokeCallback.key === callback.key ? "" : ("" + callback.key).replace(
909              userProvidedKeyEscapeRegex,
910              "$&/"
911            ) + "/") + childKey
912          ), "" !== nameSoFar && null != invokeCallback && isValidElement(invokeCallback) && null == invokeCallback.key && invokeCallback._store && !invokeCallback._store.validated && (escapedPrefix._store.validated = 2), callback = escapedPrefix), array.push(callback));
913          return 1;
914        }
915        invokeCallback = 0;
916        childKey = "" === nameSoFar ? "." : nameSoFar + ":";
917        if (isArrayImpl(children))
918          for (var i3 = 0; i3 < children.length; i3++)
919            nameSoFar = children[i3], type = childKey + getElementKey(nameSoFar, i3), invokeCallback += mapIntoArray(
920              nameSoFar,
921              array,
922              escapedPrefix,
923              type,
924              callback
925            );
926        else if (i3 = getIteratorFn(children), "function" === typeof i3)
927          for (i3 === children.entries && (didWarnAboutMaps || console.warn(
928            "Using Maps as children is not supported. Use an array of keyed ReactElements instead."
929          ), didWarnAboutMaps = true), children = i3.call(children), i3 = 0; !(nameSoFar = children.next()).done; )
930            nameSoFar = nameSoFar.value, type = childKey + getElementKey(nameSoFar, i3++), invokeCallback += mapIntoArray(
931              nameSoFar,
932              array,
933              escapedPrefix,
934              type,
935              callback
936            );
937        else if ("object" === type) {
938          if ("function" === typeof children.then)
939            return mapIntoArray(
940              resolveThenable(children),
941              array,
942              escapedPrefix,
943              nameSoFar,
944              callback
945            );
946          array = String(children);
947          throw Error(
948            "Objects are not valid as a React child (found: " + ("[object Object]" === array ? "object with keys {" + Object.keys(children).join(", ") + "}" : array) + "). If you meant to render a collection of children, use an array instead."
949          );
950        }
951        return invokeCallback;
952      }
953      function mapChildren(children, func, context) {
954        if (null == children) return children;
955        var result = [], count = 0;
956        mapIntoArray(children, result, "", "", function(child) {
957          return func.call(context, child, count++);
958        });
959        return result;
960      }
961      function lazyInitializer(payload) {
962        if (-1 === payload._status) {
963          var ioInfo = payload._ioInfo;
964          null != ioInfo && (ioInfo.start = ioInfo.end = performance.now());
965          ioInfo = payload._result;
966          var thenable = ioInfo();
967          thenable.then(
968            function(moduleObject) {
969              if (0 === payload._status || -1 === payload._status) {
970                payload._status = 1;
971                payload._result = moduleObject;
972                var _ioInfo = payload._ioInfo;
973                null != _ioInfo && (_ioInfo.end = performance.now());
974                void 0 === thenable.status && (thenable.status = "fulfilled", thenable.value = moduleObject);
975              }
976            },
977            function(error2) {
978              if (0 === payload._status || -1 === payload._status) {
979                payload._status = 2;
980                payload._result = error2;
981                var _ioInfo2 = payload._ioInfo;
982                null != _ioInfo2 && (_ioInfo2.end = performance.now());
983                void 0 === thenable.status && (thenable.status = "rejected", thenable.reason = error2);
984              }
985            }
986          );
987          ioInfo = payload._ioInfo;
988          if (null != ioInfo) {
989            ioInfo.value = thenable;
990            var displayName = thenable.displayName;
991            "string" === typeof displayName && (ioInfo.name = displayName);
992          }
993          -1 === payload._status && (payload._status = 0, payload._result = thenable);
994        }
995        if (1 === payload._status)
996          return ioInfo = payload._result, void 0 === ioInfo && console.error(
997            "lazy: Expected the result of a dynamic import() call. Instead received: %s\n\nYour code should look like: \n  const MyComponent = lazy(() => import('./MyComponent'))\n\nDid you accidentally put curly braces around the import?",
998            ioInfo
999          ), "default" in ioInfo || console.error(
1000            "lazy: Expected the result of a dynamic import() call. Instead received: %s\n\nYour code should look like: \n  const MyComponent = lazy(() => import('./MyComponent'))",
1001            ioInfo
1002          ), ioInfo.default;
1003        throw payload._result;
1004      }
1005      function resolveDispatcher() {
1006        var dispatcher = ReactSharedInternals.H;
1007        null === dispatcher && console.error(
1008          "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."
1009        );
1010        return dispatcher;
1011      }
1012      function releaseAsyncTransition() {
1013        ReactSharedInternals.asyncTransitions--;
1014      }
1015      function enqueueTask(task) {
1016        if (null === enqueueTaskImpl)
1017          try {
1018            var requireString = ("require" + Math.random()).slice(0, 7);
1019            enqueueTaskImpl = (module && module[requireString]).call(
1020              module,
1021              "timers"
1022            ).setImmediate;
1023          } catch (_err) {
1024            enqueueTaskImpl = function(callback) {
1025              false === didWarnAboutMessageChannel && (didWarnAboutMessageChannel = true, "undefined" === typeof MessageChannel && console.error(
1026                "This browser does not have a MessageChannel implementation, so enqueuing tasks via await act(async () => ...) will fail. Please file an issue at https://github.com/facebook/react/issues if you encounter this warning."
1027              ));
1028              var channel = new MessageChannel();
1029              channel.port1.onmessage = callback;
1030              channel.port2.postMessage(void 0);
1031            };
1032          }
1033        return enqueueTaskImpl(task);
1034      }
1035      function aggregateErrors(errors) {
1036        return 1 < errors.length && "function" === typeof AggregateError ? new AggregateError(errors) : errors[0];
1037      }
1038      function popActScope(prevActQueue, prevActScopeDepth) {
1039        prevActScopeDepth !== actScopeDepth - 1 && console.error(
1040          "You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. "
1041        );
1042        actScopeDepth = prevActScopeDepth;
1043      }
1044      function recursivelyFlushAsyncActWork(returnValue, resolve, reject) {
1045        var queue = ReactSharedInternals.actQueue;
1046        if (null !== queue)
1047          if (0 !== queue.length)
1048            try {
1049              flushActQueue(queue);
1050              enqueueTask(function() {
1051                return recursivelyFlushAsyncActWork(returnValue, resolve, reject);
1052              });
1053              return;
1054            } catch (error2) {
1055              ReactSharedInternals.thrownErrors.push(error2);
1056            }
1057          else ReactSharedInternals.actQueue = null;
1058        0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve(returnValue);
1059      }
1060      function flushActQueue(queue) {
1061        if (!isFlushing) {
1062          isFlushing = true;
1063          var i3 = 0;
1064          try {
1065            for (; i3 < queue.length; i3++) {
1066              var callback = queue[i3];
1067              do {
1068                ReactSharedInternals.didUsePromise = false;
1069                var continuation = callback(false);
1070                if (null !== continuation) {
1071                  if (ReactSharedInternals.didUsePromise) {
1072                    queue[i3] = callback;
1073                    queue.splice(0, i3);
1074                    return;
1075                  }
1076                  callback = continuation;
1077                } else break;
1078              } while (1);
1079            }
1080            queue.length = 0;
1081          } catch (error2) {
1082            queue.splice(0, i3 + 1), ReactSharedInternals.thrownErrors.push(error2);
1083          } finally {
1084            isFlushing = false;
1085          }
1086        }
1087      }
1088      "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
1089      var REACT_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = /* @__PURE__ */ Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = /* @__PURE__ */ Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = /* @__PURE__ */ Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = /* @__PURE__ */ Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = /* @__PURE__ */ Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = /* @__PURE__ */ Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = /* @__PURE__ */ Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = /* @__PURE__ */ Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = /* @__PURE__ */ Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = /* @__PURE__ */ Symbol.for("react.memo"), REACT_LAZY_TYPE = /* @__PURE__ */ Symbol.for("react.lazy"), REACT_ACTIVITY_TYPE = /* @__PURE__ */ Symbol.for("react.activity"), MAYBE_ITERATOR_SYMBOL = Symbol.iterator, didWarnStateUpdateForUnmountedComponent = {}, ReactNoopUpdateQueue = {
1090        isMounted: function() {
1091          return false;
1092        },
1093        enqueueForceUpdate: function(publicInstance) {
1094          warnNoop(publicInstance, "forceUpdate");
1095        },
1096        enqueueReplaceState: function(publicInstance) {
1097          warnNoop(publicInstance, "replaceState");
1098        },
1099        enqueueSetState: function(publicInstance) {
1100          warnNoop(publicInstance, "setState");
1101        }
1102      }, assign = Object.assign, emptyObject = {};
1103      Object.freeze(emptyObject);
1104      Component.prototype.isReactComponent = {};
1105      Component.prototype.setState = function(partialState, callback) {
1106        if ("object" !== typeof partialState && "function" !== typeof partialState && null != partialState)
1107          throw Error(
1108            "takes an object of state variables to update or a function which returns an object of state variables."
1109          );
1110        this.updater.enqueueSetState(this, partialState, callback, "setState");
1111      };
1112      Component.prototype.forceUpdate = function(callback) {
1113        this.updater.enqueueForceUpdate(this, callback, "forceUpdate");
1114      };
1115      var deprecatedAPIs = {
1116        isMounted: [
1117          "isMounted",
1118          "Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks."
1119        ],
1120        replaceState: [
1121          "replaceState",
1122          "Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)."
1123        ]
1124      };
1125      for (fnName in deprecatedAPIs)
1126        deprecatedAPIs.hasOwnProperty(fnName) && defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);
1127      ComponentDummy.prototype = Component.prototype;
1128      deprecatedAPIs = PureComponent.prototype = new ComponentDummy();
1129      deprecatedAPIs.constructor = PureComponent;
1130      assign(deprecatedAPIs, Component.prototype);
1131      deprecatedAPIs.isPureReactComponent = true;
1132      var isArrayImpl = Array.isArray, REACT_CLIENT_REFERENCE = /* @__PURE__ */ Symbol.for("react.client.reference"), ReactSharedInternals = {
1133        H: null,
1134        A: null,
1135        T: null,
1136        S: null,
1137        actQueue: null,
1138        asyncTransitions: 0,
1139        isBatchingLegacy: false,
1140        didScheduleLegacyUpdate: false,
1141        didUsePromise: false,
1142        thrownErrors: [],
1143        getCurrentStack: null,
1144        recentlyCreatedOwnerStacks: 0
1145      }, hasOwnProperty = Object.prototype.hasOwnProperty, createTask = console.createTask ? console.createTask : function() {
1146        return null;
1147      };
1148      deprecatedAPIs = {
1149        react_stack_bottom_frame: function(callStackForError) {
1150          return callStackForError();
1151        }
1152      };
1153      var specialPropKeyWarningShown, didWarnAboutOldJSXRuntime;
1154      var didWarnAboutElementRef = {};
1155      var unknownOwnerDebugStack = deprecatedAPIs.react_stack_bottom_frame.bind(
1156        deprecatedAPIs,
1157        UnknownOwner
1158      )();
1159      var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
1160      var didWarnAboutMaps = false, userProvidedKeyEscapeRegex = /\/+/g, reportGlobalError = "function" === typeof reportError ? reportError : function(error2) {
1161        if ("object" === typeof window && "function" === typeof window.ErrorEvent) {
1162          var event = new window.ErrorEvent("error", {
1163            bubbles: true,
1164            cancelable: true,
1165            message: "object" === typeof error2 && null !== error2 && "string" === typeof error2.message ? String(error2.message) : String(error2),
1166            error: error2
1167          });
1168          if (!window.dispatchEvent(event)) return;
1169        } else if ("object" === typeof process && "function" === typeof process.emit) {
1170          process.emit("uncaughtException", error2);
1171          return;
1172        }
1173        console.error(error2);
1174      }, didWarnAboutMessageChannel = false, enqueueTaskImpl = null, actScopeDepth = 0, didWarnNoAwaitAct = false, isFlushing = false, queueSeveralMicrotasks = "function" === typeof queueMicrotask ? function(callback) {
1175        queueMicrotask(function() {
1176          return queueMicrotask(callback);
1177        });
1178      } : enqueueTask;
1179      deprecatedAPIs = Object.freeze({
1180        __proto__: null,
1181        c: function(size) {
1182          return resolveDispatcher().useMemoCache(size);
1183        }
1184      });
1185      var fnName = {
1186        map: mapChildren,
1187        forEach: function(children, forEachFunc, forEachContext) {
1188          mapChildren(
1189            children,
1190            function() {
1191              forEachFunc.apply(this, arguments);
1192            },
1193            forEachContext
1194          );
1195        },
1196        count: function(children) {
1197          var n3 = 0;
1198          mapChildren(children, function() {
1199            n3++;
1200          });
1201          return n3;
1202        },
1203        toArray: function(children) {
1204          return mapChildren(children, function(child) {
1205            return child;
1206          }) || [];
1207        },
1208        only: function(children) {
1209          if (!isValidElement(children))
1210            throw Error(
1211              "React.Children.only expected to receive a single React element child."
1212            );
1213          return children;
1214        }
1215      };
1216      exports.Activity = REACT_ACTIVITY_TYPE;
1217      exports.Children = fnName;
1218      exports.Component = Component;
1219      exports.Fragment = REACT_FRAGMENT_TYPE;
1220      exports.Profiler = REACT_PROFILER_TYPE;
1221      exports.PureComponent = PureComponent;
1222      exports.StrictMode = REACT_STRICT_MODE_TYPE;
1223      exports.Suspense = REACT_SUSPENSE_TYPE;
1224      exports.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = ReactSharedInternals;
1225      exports.__COMPILER_RUNTIME = deprecatedAPIs;
1226      exports.act = function(callback) {
1227        var prevActQueue = ReactSharedInternals.actQueue, prevActScopeDepth = actScopeDepth;
1228        actScopeDepth++;
1229        var queue = ReactSharedInternals.actQueue = null !== prevActQueue ? prevActQueue : [], didAwaitActCall = false;
1230        try {
1231          var result = callback();
1232        } catch (error2) {
1233          ReactSharedInternals.thrownErrors.push(error2);
1234        }
1235        if (0 < ReactSharedInternals.thrownErrors.length)
1236          throw popActScope(prevActQueue, prevActScopeDepth), callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
1237        if (null !== result && "object" === typeof result && "function" === typeof result.then) {
1238          var thenable = result;
1239          queueSeveralMicrotasks(function() {
1240            didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = true, console.error(
1241              "You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);"
1242            ));
1243          });
1244          return {
1245            then: function(resolve, reject) {
1246              didAwaitActCall = true;
1247              thenable.then(
1248                function(returnValue) {
1249                  popActScope(prevActQueue, prevActScopeDepth);
1250                  if (0 === prevActScopeDepth) {
1251                    try {
1252                      flushActQueue(queue), enqueueTask(function() {
1253                        return recursivelyFlushAsyncActWork(
1254                          returnValue,
1255                          resolve,
1256                          reject
1257                        );
1258                      });
1259                    } catch (error$0) {
1260                      ReactSharedInternals.thrownErrors.push(error$0);
1261                    }
1262                    if (0 < ReactSharedInternals.thrownErrors.length) {
1263                      var _thrownError = aggregateErrors(
1264                        ReactSharedInternals.thrownErrors
1265                      );
1266                      ReactSharedInternals.thrownErrors.length = 0;
1267                      reject(_thrownError);
1268                    }
1269                  } else resolve(returnValue);
1270                },
1271                function(error2) {
1272                  popActScope(prevActQueue, prevActScopeDepth);
1273                  0 < ReactSharedInternals.thrownErrors.length ? (error2 = aggregateErrors(
1274                    ReactSharedInternals.thrownErrors
1275                  ), ReactSharedInternals.thrownErrors.length = 0, reject(error2)) : reject(error2);
1276                }
1277              );
1278            }
1279          };
1280        }
1281        var returnValue$jscomp$0 = result;
1282        popActScope(prevActQueue, prevActScopeDepth);
1283        0 === prevActScopeDepth && (flushActQueue(queue), 0 !== queue.length && queueSeveralMicrotasks(function() {
1284          didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = true, console.error(
1285            "A component suspended inside an `act` scope, but the `act` call was not awaited. When testing React components that depend on asynchronous data, you must await the result:\n\nawait act(() => ...)"
1286          ));
1287        }), ReactSharedInternals.actQueue = null);
1288        if (0 < ReactSharedInternals.thrownErrors.length)
1289          throw callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
1290        return {
1291          then: function(resolve, reject) {
1292            didAwaitActCall = true;
1293            0 === prevActScopeDepth ? (ReactSharedInternals.actQueue = queue, enqueueTask(function() {
1294              return recursivelyFlushAsyncActWork(
1295                returnValue$jscomp$0,
1296                resolve,
1297                reject
1298              );
1299            })) : resolve(returnValue$jscomp$0);
1300          }
1301        };
1302      };
1303      exports.cache = function(fn3) {
1304        return function() {
1305          return fn3.apply(null, arguments);
1306        };
1307      };
1308      exports.cacheSignal = function() {
1309        return null;
1310      };
1311      exports.captureOwnerStack = function() {
1312        var getCurrentStack = ReactSharedInternals.getCurrentStack;
1313        return null === getCurrentStack ? null : getCurrentStack();
1314      };
1315      exports.cloneElement = function(element, config2, children) {
1316        if (null === element || void 0 === element)
1317          throw Error(
1318            "The argument must be a React element, but you passed " + element + "."
1319          );
1320        var props = assign({}, element.props), key = element.key, owner = element._owner;
1321        if (null != config2) {
1322          var JSCompiler_inline_result;
1323          a: {
1324            if (hasOwnProperty.call(config2, "ref") && (JSCompiler_inline_result = Object.getOwnPropertyDescriptor(
1325              config2,
1326              "ref"
1327            ).get) && JSCompiler_inline_result.isReactWarning) {
1328              JSCompiler_inline_result = false;
1329              break a;
1330            }
1331            JSCompiler_inline_result = void 0 !== config2.ref;
1332          }
1333          JSCompiler_inline_result && (owner = getOwner());
1334          hasValidKey(config2) && (checkKeyStringCoercion(config2.key), key = "" + config2.key);
1335          for (propName in config2)
1336            !hasOwnProperty.call(config2, propName) || "key" === propName || "__self" === propName || "__source" === propName || "ref" === propName && void 0 === config2.ref || (props[propName] = config2[propName]);
1337        }
1338        var propName = arguments.length - 2;
1339        if (1 === propName) props.children = children;
1340        else if (1 < propName) {
1341          JSCompiler_inline_result = Array(propName);
1342          for (var i3 = 0; i3 < propName; i3++)
1343            JSCompiler_inline_result[i3] = arguments[i3 + 2];
1344          props.children = JSCompiler_inline_result;
1345        }
1346        props = ReactElement(
1347          element.type,
1348          key,
1349          props,
1350          owner,
1351          element._debugStack,
1352          element._debugTask
1353        );
1354        for (key = 2; key < arguments.length; key++)
1355          validateChildKeys(arguments[key]);
1356        return props;
1357      };
1358      exports.createContext = function(defaultValue) {
1359        defaultValue = {
1360          $$typeof: REACT_CONTEXT_TYPE,
1361          _currentValue: defaultValue,
1362          _currentValue2: defaultValue,
1363          _threadCount: 0,
1364          Provider: null,
1365          Consumer: null
1366        };
1367        defaultValue.Provider = defaultValue;
1368        defaultValue.Consumer = {
1369          $$typeof: REACT_CONSUMER_TYPE,
1370          _context: defaultValue
1371        };
1372        defaultValue._currentRenderer = null;
1373        defaultValue._currentRenderer2 = null;
1374        return defaultValue;
1375      };
1376      exports.createElement = function(type, config2, children) {
1377        for (var i3 = 2; i3 < arguments.length; i3++)
1378          validateChildKeys(arguments[i3]);
1379        i3 = {};
1380        var key = null;
1381        if (null != config2)
1382          for (propName in didWarnAboutOldJSXRuntime || !("__self" in config2) || "key" in config2 || (didWarnAboutOldJSXRuntime = true, console.warn(
1383            "Your app (or one of its dependencies) is using an outdated JSX transform. Update to the modern JSX transform for faster performance: https://react.dev/link/new-jsx-transform"
1384          )), hasValidKey(config2) && (checkKeyStringCoercion(config2.key), key = "" + config2.key), config2)
1385            hasOwnProperty.call(config2, propName) && "key" !== propName && "__self" !== propName && "__source" !== propName && (i3[propName] = config2[propName]);
1386        var childrenLength = arguments.length - 2;
1387        if (1 === childrenLength) i3.children = children;
1388        else if (1 < childrenLength) {
1389          for (var childArray = Array(childrenLength), _i3 = 0; _i3 < childrenLength; _i3++)
1390            childArray[_i3] = arguments[_i3 + 2];
1391          Object.freeze && Object.freeze(childArray);
1392          i3.children = childArray;
1393        }
1394        if (type && type.defaultProps)
1395          for (propName in childrenLength = type.defaultProps, childrenLength)
1396            void 0 === i3[propName] && (i3[propName] = childrenLength[propName]);
1397        key && defineKeyPropWarningGetter(
1398          i3,
1399          "function" === typeof type ? type.displayName || type.name || "Unknown" : type
1400        );
1401        var propName = 1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
1402        return ReactElement(
1403          type,
1404          key,
1405          i3,
1406          getOwner(),
1407          propName ? Error("react-stack-top-frame") : unknownOwnerDebugStack,
1408          propName ? createTask(getTaskName(type)) : unknownOwnerDebugTask
1409        );
1410      };
1411      exports.createRef = function() {
1412        var refObject = { current: null };
1413        Object.seal(refObject);
1414        return refObject;
1415      };
1416      exports.forwardRef = function(render) {
1417        null != render && render.$$typeof === REACT_MEMO_TYPE ? console.error(
1418          "forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...))."
1419        ) : "function" !== typeof render ? console.error(
1420          "forwardRef requires a render function but was given %s.",
1421          null === render ? "null" : typeof render
1422        ) : 0 !== render.length && 2 !== render.length && console.error(
1423          "forwardRef render functions accept exactly two parameters: props and ref. %s",
1424          1 === render.length ? "Did you forget to use the ref parameter?" : "Any additional parameter will be undefined."
1425        );
1426        null != render && null != render.defaultProps && console.error(
1427          "forwardRef render functions do not support defaultProps. Did you accidentally pass a React component?"
1428        );
1429        var elementType2 = { $$typeof: REACT_FORWARD_REF_TYPE, render }, ownName;
1430        Object.defineProperty(elementType2, "displayName", {
1431          enumerable: false,
1432          configurable: true,
1433          get: function() {
1434            return ownName;
1435          },
1436          set: function(name) {
1437            ownName = name;
1438            render.name || render.displayName || (Object.defineProperty(render, "name", { value: name }), render.displayName = name);
1439          }
1440        });
1441        return elementType2;
1442      };
1443      exports.isValidElement = isValidElement;
1444      exports.lazy = function(ctor) {
1445        ctor = { _status: -1, _result: ctor };
1446        var lazyType = {
1447          $$typeof: REACT_LAZY_TYPE,
1448          _payload: ctor,
1449          _init: lazyInitializer
1450        }, ioInfo = {
1451          name: "lazy",
1452          start: -1,
1453          end: -1,
1454          value: null,
1455          owner: null,
1456          debugStack: Error("react-stack-top-frame"),
1457          debugTask: console.createTask ? console.createTask("lazy()") : null
1458        };
1459        ctor._ioInfo = ioInfo;
1460        lazyType._debugInfo = [{ awaited: ioInfo }];
1461        return lazyType;
1462      };
1463      exports.memo = function(type, compare) {
1464        null == type && console.error(
1465          "memo: The first argument must be a component. Instead received: %s",
1466          null === type ? "null" : typeof type
1467        );
1468        compare = {
1469          $$typeof: REACT_MEMO_TYPE,
1470          type,
1471          compare: void 0 === compare ? null : compare
1472        };
1473        var ownName;
1474        Object.defineProperty(compare, "displayName", {
1475          enumerable: false,
1476          configurable: true,
1477          get: function() {
1478            return ownName;
1479          },
1480          set: function(name) {
1481            ownName = name;
1482            type.name || type.displayName || (Object.defineProperty(type, "name", { value: name }), type.displayName = name);
1483          }
1484        });
1485        return compare;
1486      };
1487      exports.startTransition = function(scope) {
1488        var prevTransition = ReactSharedInternals.T, currentTransition = {};
1489        currentTransition._updatedFibers = /* @__PURE__ */ new Set();
1490        ReactSharedInternals.T = currentTransition;
1491        try {
1492          var returnValue = scope(), onStartTransitionFinish = ReactSharedInternals.S;
1493          null !== onStartTransitionFinish && onStartTransitionFinish(currentTransition, returnValue);
1494          "object" === typeof returnValue && null !== returnValue && "function" === typeof returnValue.then && (ReactSharedInternals.asyncTransitions++, returnValue.then(releaseAsyncTransition, releaseAsyncTransition), returnValue.then(noop, reportGlobalError));
1495        } catch (error2) {
1496          reportGlobalError(error2);
1497        } finally {
1498          null === prevTransition && currentTransition._updatedFibers && (scope = currentTransition._updatedFibers.size, currentTransition._updatedFibers.clear(), 10 < scope && console.warn(
1499            "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."
1500          )), null !== prevTransition && null !== currentTransition.types && (null !== prevTransition.types && prevTransition.types !== currentTransition.types && console.error(
1501            "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."
1502          ), prevTransition.types = currentTransition.types), ReactSharedInternals.T = prevTransition;
1503        }
1504      };
1505      exports.unstable_useCacheRefresh = function() {
1506        return resolveDispatcher().useCacheRefresh();
1507      };
1508      exports.use = function(usable) {
1509        return resolveDispatcher().use(usable);
1510      };
1511      exports.useActionState = function(action, initialState, permalink) {
1512        return resolveDispatcher().useActionState(
1513          action,
1514          initialState,
1515          permalink
1516        );
1517      };
1518      exports.useCallback = function(callback, deps) {
1519        return resolveDispatcher().useCallback(callback, deps);
1520      };
1521      exports.useContext = function(Context2) {
1522        var dispatcher = resolveDispatcher();
1523        Context2.$$typeof === REACT_CONSUMER_TYPE && console.error(
1524          "Calling useContext(Context.Consumer) is not supported and will cause bugs. Did you mean to call useContext(Context) instead?"
1525        );
1526        return dispatcher.useContext(Context2);
1527      };
1528      exports.useDebugValue = function(value, formatterFn) {
1529        return resolveDispatcher().useDebugValue(value, formatterFn);
1530      };
1531      exports.useDeferredValue = function(value, initialValue) {
1532        return resolveDispatcher().useDeferredValue(value, initialValue);
1533      };
1534      exports.useEffect = function(create, deps) {
1535        null == create && console.warn(
1536          "React Hook useEffect requires an effect callback. Did you forget to pass a callback to the hook?"
1537        );
1538        return resolveDispatcher().useEffect(create, deps);
1539      };
1540      exports.useEffectEvent = function(callback) {
1541        return resolveDispatcher().useEffectEvent(callback);
1542      };
1543      exports.useId = function() {
1544        return resolveDispatcher().useId();
1545      };
1546      exports.useImperativeHandle = function(ref, create, deps) {
1547        return resolveDispatcher().useImperativeHandle(ref, create, deps);
1548      };
1549      exports.useInsertionEffect = function(create, deps) {
1550        null == create && console.warn(
1551          "React Hook useInsertionEffect requires an effect callback. Did you forget to pass a callback to the hook?"
1552        );
1553        return resolveDispatcher().useInsertionEffect(create, deps);
1554      };
1555      exports.useLayoutEffect = function(create, deps) {
1556        null == create && console.warn(
1557          "React Hook useLayoutEffect requires an effect callback. Did you forget to pass a callback to the hook?"
1558        );
1559        return resolveDispatcher().useLayoutEffect(create, deps);
1560      };
1561      exports.useMemo = function(create, deps) {
1562        return resolveDispatcher().useMemo(create, deps);
1563      };
1564      exports.useOptimistic = function(passthrough, reducer) {
1565        return resolveDispatcher().useOptimistic(passthrough, reducer);
1566      };
1567      exports.useReducer = function(reducer, initialArg, init) {
1568        return resolveDispatcher().useReducer(reducer, initialArg, init);
1569      };
1570      exports.useRef = function(initialValue) {
1571        return resolveDispatcher().useRef(initialValue);
1572      };
1573      exports.useState = function(initialState) {
1574        return resolveDispatcher().useState(initialState);
1575      };
1576      exports.useSyncExternalStore = function(subscribe, getSnapshot, getServerSnapshot) {
1577        return resolveDispatcher().useSyncExternalStore(
1578          subscribe,
1579          getSnapshot,
1580          getServerSnapshot
1581        );
1582      };
1583      exports.useTransition = function() {
1584        return resolveDispatcher().useTransition();
1585      };
1586      exports.version = "19.2.4";
1587      "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
1588    })();
1589  }
1590});
1591

1592// node_modules/react/index.js
1593var require_react = __commonJS({
1594  "node_modules/react/index.js"(exports, module) {
1595    "use strict";
1596    if (false) {
1597      module.exports = null;
1598    } else {
1599      module.exports = require_react_development();
1600    }
1601  }
1602});
1603

1604// node_modules/scheduler/cjs/scheduler.development.js
1605var require_scheduler_development = __commonJS({
1606  "node_modules/scheduler/cjs/scheduler.development.js"(exports) {
1607    "use strict";
1608    (function() {
1609      function performWorkUntilDeadline() {
1610        needsPaint = false;
1611        if (isMessageLoopRunning) {
1612          var currentTime = exports.unstable_now();
1613          startTime = currentTime;
1614          var hasMoreWork = true;
1615          try {
1616            a: {
1617              isHostCallbackScheduled = false;
1618              isHostTimeoutScheduled && (isHostTimeoutScheduled = false, localClearTimeout(taskTimeoutID), taskTimeoutID = -1);
1619              isPerformingWork = true;
1620              var previousPriorityLevel = currentPriorityLevel;
1621              try {
1622                b: {
1623                  advanceTimers(currentTime);
1624                  for (currentTask = peek(taskQueue); null !== currentTask && !(currentTask.expirationTime > currentTime && shouldYieldToHost()); ) {
1625                    var callback = currentTask.callback;
1626                    if ("function" === typeof callback) {
1627                      currentTask.callback = null;
1628                      currentPriorityLevel = currentTask.priorityLevel;
1629                      var continuationCallback = callback(
1630                        currentTask.expirationTime <= currentTime
1631                      );
1632                      currentTime = exports.unstable_now();
1633                      if ("function" === typeof continuationCallback) {
1634                        currentTask.callback = continuationCallback;
1635                        advanceTimers(currentTime);
1636                        hasMoreWork = true;
1637                        break b;
1638                      }
1639                      currentTask === peek(taskQueue) && pop(taskQueue);
1640                      advanceTimers(currentTime);
1641                    } else pop(taskQueue);
1642                    currentTask = peek(taskQueue);
1643                  }
1644                  if (null !== currentTask) hasMoreWork = true;
1645                  else {
1646                    var firstTimer = peek(timerQueue);
1647                    null !== firstTimer && requestHostTimeout(
1648                      handleTimeout,
1649                      firstTimer.startTime - currentTime
1650                    );
1651                    hasMoreWork = false;
1652                  }
1653                }
1654                break a;
1655              } finally {
1656                currentTask = null, currentPriorityLevel = previousPriorityLevel, isPerformingWork = false;
1657              }
1658              hasMoreWork = void 0;
1659            }
1660          } finally {
1661            hasMoreWork ? schedulePerformWorkUntilDeadline() : isMessageLoopRunning = false;
1662          }
1663        }
1664      }
1665      function push(heap, node) {
1666        var index = heap.length;
1667        heap.push(node);
1668        a: for (; 0 < index; ) {
1669          var parentIndex = index - 1 >>> 1, parent = heap[parentIndex];
1670          if (0 < compare(parent, node))
1671            heap[parentIndex] = node, heap[index] = parent, index = parentIndex;
1672          else break a;
1673        }
1674      }
1675      function peek(heap) {
1676        return 0 === heap.length ? null : heap[0];
1677      }
1678      function pop(heap) {
1679        if (0 === heap.length) return null;
1680        var first = heap[0], last = heap.pop();
1681        if (last !== first) {
1682          heap[0] = last;
1683          a: for (var index = 0, length = heap.length, halfLength = length >>> 1; index < halfLength; ) {
1684            var leftIndex = 2 * (index + 1) - 1, left = heap[leftIndex], rightIndex = leftIndex + 1, right = heap[rightIndex];
1685            if (0 > compare(left, last))
1686              rightIndex < length && 0 > compare(right, left) ? (heap[index] = right, heap[rightIndex] = last, index = rightIndex) : (heap[index] = left, heap[leftIndex] = last, index = leftIndex);
1687            else if (rightIndex < length && 0 > compare(right, last))
1688              heap[index] = right, heap[rightIndex] = last, index = rightIndex;
1689            else break a;
1690          }
1691        }
1692        return first;
1693      }
1694      function compare(a3, b3) {
1695        var diff = a3.sortIndex - b3.sortIndex;
1696        return 0 !== diff ? diff : a3.id - b3.id;
1697      }
1698      function advanceTimers(currentTime) {
1699        for (var timer = peek(timerQueue); null !== timer; ) {
1700          if (null === timer.callback) pop(timerQueue);
1701          else if (timer.startTime <= currentTime)
1702            pop(timerQueue), timer.sortIndex = timer.expirationTime, push(taskQueue, timer);
1703          else break;
1704          timer = peek(timerQueue);
1705        }
1706      }
1707      function handleTimeout(currentTime) {
1708        isHostTimeoutScheduled = false;
1709        advanceTimers(currentTime);
1710        if (!isHostCallbackScheduled)
1711          if (null !== peek(taskQueue))
1712            isHostCallbackScheduled = true, isMessageLoopRunning || (isMessageLoopRunning = true, schedulePerformWorkUntilDeadline());
1713          else {
1714            var firstTimer = peek(timerQueue);
1715            null !== firstTimer && requestHostTimeout(
1716              handleTimeout,
1717              firstTimer.startTime - currentTime
1718            );
1719          }
1720      }
1721      function shouldYieldToHost() {
1722        return needsPaint ? true : exports.unstable_now() - startTime < frameInterval ? false : true;
1723      }
1724      function requestHostTimeout(callback, ms3) {
1725        taskTimeoutID = localSetTimeout(function() {
1726          callback(exports.unstable_now());
1727        }, ms3);
1728      }
1729      "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
1730      exports.unstable_now = void 0;
1731      if ("object" === typeof performance && "function" === typeof performance.now) {
1732        var localPerformance = performance;
1733        exports.unstable_now = function() {
1734          return localPerformance.now();
1735        };
1736      } else {
1737        var localDate = Date, initialTime = localDate.now();
1738        exports.unstable_now = function() {
1739          return localDate.now() - initialTime;
1740        };
1741      }
1742      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;
1743      if ("function" === typeof localSetImmediate)
1744        var schedulePerformWorkUntilDeadline = function() {
1745          localSetImmediate(performWorkUntilDeadline);
1746        };
1747      else if ("undefined" !== typeof MessageChannel) {
1748        var channel = new MessageChannel(), port = channel.port2;
1749        channel.port1.onmessage = performWorkUntilDeadline;
1750        schedulePerformWorkUntilDeadline = function() {
1751          port.postMessage(null);
1752        };
1753      } else
1754        schedulePerformWorkUntilDeadline = function() {
1755          localSetTimeout(performWorkUntilDeadline, 0);
1756        };
1757      exports.unstable_IdlePriority = 5;
1758      exports.unstable_ImmediatePriority = 1;
1759      exports.unstable_LowPriority = 4;
1760      exports.unstable_NormalPriority = 3;
1761      exports.unstable_Profiling = null;
1762      exports.unstable_UserBlockingPriority = 2;
1763      exports.unstable_cancelCallback = function(task) {
1764        task.callback = null;
1765      };
1766      exports.unstable_forceFrameRate = function(fps) {
1767        0 > fps || 125 < fps ? console.error(
1768          "forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported"
1769        ) : frameInterval = 0 < fps ? Math.floor(1e3 / fps) : 5;
1770      };
1771      exports.unstable_getCurrentPriorityLevel = function() {
1772        return currentPriorityLevel;
1773      };
1774      exports.unstable_next = function(eventHandler) {
1775        switch (currentPriorityLevel) {
1776          case 1:
1777          case 2:
1778          case 3:
1779            var priorityLevel = 3;
1780            break;
1781          default:
1782            priorityLevel = currentPriorityLevel;
1783        }
1784        var previousPriorityLevel = currentPriorityLevel;
1785        currentPriorityLevel = priorityLevel;
1786        try {
1787          return eventHandler();
1788        } finally {
1789          currentPriorityLevel = previousPriorityLevel;
1790        }
1791      };
1792      exports.unstable_requestPaint = function() {
1793        needsPaint = true;
1794      };
1795      exports.unstable_runWithPriority = function(priorityLevel, eventHandler) {
1796        switch (priorityLevel) {
1797          case 1:
1798          case 2:
1799          case 3:
1800          case 4:
1801          case 5:
1802            break;
1803          default:
1804            priorityLevel = 3;
1805        }
1806        var previousPriorityLevel = currentPriorityLevel;
1807        currentPriorityLevel = priorityLevel;
1808        try {
1809          return eventHandler();
1810        } finally {
1811          currentPriorityLevel = previousPriorityLevel;
1812        }
1813      };
1814      exports.unstable_scheduleCallback = function(priorityLevel, callback, options) {
1815        var currentTime = exports.unstable_now();
1816        "object" === typeof options && null !== options ? (options = options.delay, options = "number" === typeof options && 0 < options ? currentTime + options : currentTime) : options = currentTime;
1817        switch (priorityLevel) {
1818          case 1:
1819            var timeout = -1;
1820            break;
1821          case 2:
1822            timeout = 250;
1823            break;
1824          case 5:
1825            timeout = 1073741823;
1826            break;
1827          case 4:
1828            timeout = 1e4;
1829            break;
1830          default:
1831            timeout = 5e3;
1832        }
1833        timeout = options + timeout;
1834        priorityLevel = {
1835          id: taskIdCounter++,
1836          callback,
1837          priorityLevel,
1838          startTime: options,
1839          expirationTime: timeout,
1840          sortIndex: -1
1841        };
1842        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())));
1843        return priorityLevel;
1844      };
1845      exports.unstable_shouldYield = shouldYieldToHost;
1846      exports.unstable_wrapCallback = function(callback) {
1847        var parentPriorityLevel = currentPriorityLevel;
1848        return function() {
1849          var previousPriorityLevel = currentPriorityLevel;
1850          currentPriorityLevel = parentPriorityLevel;
1851          try {
1852            return callback.apply(this, arguments);
1853          } finally {
1854            currentPriorityLevel = previousPriorityLevel;
1855          }
1856        };
1857      };
1858      "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
1859    })();
1860  }
1861});
1862

1863// node_modules/scheduler/index.js
1864var require_scheduler = __commonJS({
1865  "node_modules/scheduler/index.js"(exports, module) {
1866    "use strict";
1867    if (false) {
1868      module.exports = null;
1869    } else {
1870      module.exports = require_scheduler_development();
1871    }
1872  }
1873});
1874

1875// node_modules/react-dom/cjs/react-dom.development.js
1876var require_react_dom_development = __commonJS({
1877  "node_modules/react-dom/cjs/react-dom.development.js"(exports) {
1878    "use strict";
1879    (function() {
1880      function noop() {
1881      }
1882      function testStringCoercion(value) {
1883        return "" + value;
1884      }
1885      function createPortal$1(children, containerInfo, implementation) {
1886        var key = 3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;
1887        try {
1888          testStringCoercion(key);
1889          var JSCompiler_inline_result = false;
1890        } catch (e3) {
1891          JSCompiler_inline_result = true;
1892        }
1893        JSCompiler_inline_result && (console.error(
1894          "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
1895          "function" === typeof Symbol && Symbol.toStringTag && key[Symbol.toStringTag] || key.constructor.name || "Object"
1896        ), testStringCoercion(key));
1897        return {
1898          $$typeof: REACT_PORTAL_TYPE,
1899          key: null == key ? null : "" + key,
1900          children,
1901          containerInfo,
1902          implementation
1903        };
1904      }
1905      function getCrossOriginStringAs(as3, input) {
1906        if ("font" === as3) return "";
1907        if ("string" === typeof input)
1908          return "use-credentials" === input ? input : "";
1909      }
1910      function getValueDescriptorExpectingObjectForWarning(thing) {
1911        return null === thing ? "`null`" : void 0 === thing ? "`undefined`" : "" === thing ? "an empty string" : 'something with type "' + typeof thing + '"';
1912      }
1913      function getValueDescriptorExpectingEnumForWarning(thing) {
1914        return null === thing ? "`null`" : void 0 === thing ? "`undefined`" : "" === thing ? "an empty string" : "string" === typeof thing ? JSON.stringify(thing) : "number" === typeof thing ? "`" + thing + "`" : 'something with type "' + typeof thing + '"';
1915      }
1916      function resolveDispatcher() {
1917        var dispatcher = ReactSharedInternals.H;
1918        null === dispatcher && console.error(
1919          "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."
1920        );
1921        return dispatcher;
1922      }
1923      "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
1924      var React19 = require_react(), Internals = {
1925        d: {
1926          f: noop,
1927          r: function() {
1928            throw Error(
1929              "Invalid form element. requestFormReset must be passed a form that was rendered by React."
1930            );
1931          },
1932          D: noop,
1933          C: noop,
1934          L: noop,
1935          m: noop,
1936          X: noop,
1937          S: noop,
1938          M: noop
1939        },
1940        p: 0,
1941        findDOMNode: null
1942      }, REACT_PORTAL_TYPE = /* @__PURE__ */ Symbol.for("react.portal"), ReactSharedInternals = React19.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
1943      "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(
1944        "React depends on Map and Set built-in types. Make sure that you load a polyfill in older browsers. https://reactjs.org/link/react-polyfills"
1945      );
1946      exports.__DOM_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = Internals;
1947      exports.createPortal = function(children, container) {
1948        var key = 2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : null;
1949        if (!container || 1 !== container.nodeType && 9 !== container.nodeType && 11 !== container.nodeType)
1950          throw Error("Target container is not a DOM element.");
1951        return createPortal$1(children, container, null, key);
1952      };
1953      exports.flushSync = function(fn3) {
1954        var previousTransition = ReactSharedInternals.T, previousUpdatePriority = Internals.p;
1955        try {
1956          if (ReactSharedInternals.T = null, Internals.p = 2, fn3)
1957            return fn3();
1958        } finally {
1959          ReactSharedInternals.T = previousTransition, Internals.p = previousUpdatePriority, Internals.d.f() && console.error(
1960            "flushSync was called from inside a lifecycle method. React cannot flush when React is already rendering. Consider moving this call to a scheduler task or micro task."
1961          );
1962        }
1963      };
1964      exports.preconnect = function(href, options) {
1965        "string" === typeof href && href ? null != options && "object" !== typeof options ? console.error(
1966          "ReactDOM.preconnect(): Expected the `options` argument (second) to be an object but encountered %s instead. The only supported option at this time is `crossOrigin` which accepts a string.",
1967          getValueDescriptorExpectingEnumForWarning(options)
1968        ) : null != options && "string" !== typeof options.crossOrigin && console.error(
1969          "ReactDOM.preconnect(): Expected the `crossOrigin` option (second argument) to be a string but encountered %s instead. Try removing this option or passing a string value instead.",
1970          getValueDescriptorExpectingObjectForWarning(options.crossOrigin)
1971        ) : console.error(
1972          "ReactDOM.preconnect(): Expected the `href` argument (first) to be a non-empty string but encountered %s instead.",
1973          getValueDescriptorExpectingObjectForWarning(href)
1974        );
1975        "string" === typeof href && (options ? (options = options.crossOrigin, options = "string" === typeof options ? "use-credentials" === options ? options : "" : void 0) : options = null, Internals.d.C(href, options));
1976      };
1977      exports.prefetchDNS = function(href) {
1978        if ("string" !== typeof href || !href)
1979          console.error(
1980            "ReactDOM.prefetchDNS(): Expected the `href` argument (first) to be a non-empty string but encountered %s instead.",
1981            getValueDescriptorExpectingObjectForWarning(href)
1982          );
1983        else if (1 < arguments.length) {
1984          var options = arguments[1];
1985          "object" === typeof options && options.hasOwnProperty("crossOrigin") ? console.error(
1986            "ReactDOM.prefetchDNS(): Expected only one argument, `href`, but encountered %s as a second argument instead. This argument is reserved for future options and is currently disallowed. It looks like the you are attempting to set a crossOrigin property for this DNS lookup hint. Browsers do not perform DNS queries using CORS and setting this attribute on the resource hint has no effect. Try calling ReactDOM.prefetchDNS() with just a single string argument, `href`.",
1987            getValueDescriptorExpectingEnumForWarning(options)
1988          ) : console.error(
1989            "ReactDOM.prefetchDNS(): Expected only one argument, `href`, but encountered %s as a second argument instead. This argument is reserved for future options and is currently disallowed. Try calling ReactDOM.prefetchDNS() with just a single string argument, `href`.",
1990            getValueDescriptorExpectingEnumForWarning(options)
1991          );
1992        }
1993        "string" === typeof href && Internals.d.D(href);
1994      };
1995      exports.preinit = function(href, options) {
1996        "string" === typeof href && href ? null == options || "object" !== typeof options ? console.error(
1997          "ReactDOM.preinit(): Expected the `options` argument (second) to be an object with an `as` property describing the type of resource to be preinitialized but encountered %s instead.",
1998          getValueDescriptorExpectingEnumForWarning(options)
1999        ) : "style" !== options.as && "script" !== options.as && console.error(
2000          'ReactDOM.preinit(): Expected the `as` property in the `options` argument (second) to contain a valid value describing the type of resource to be preinitialized but encountered %s instead. Valid values for `as` are "style" and "script".',
2001          getValueDescriptorExpectingEnumForWarning(options.as)
2002        ) : console.error(
2003          "ReactDOM.preinit(): Expected the `href` argument (first) to be a non-empty string but encountered %s instead.",
2004          getValueDescriptorExpectingObjectForWarning(href)
2005        );
2006        if ("string" === typeof href && options && "string" === typeof options.as) {
2007          var as3 = options.as, crossOrigin = getCrossOriginStringAs(as3, options.crossOrigin), integrity = "string" === typeof options.integrity ? options.integrity : void 0, fetchPriority = "string" === typeof options.fetchPriority ? options.fetchPriority : void 0;
2008          "style" === as3 ? Internals.d.S(
2009            href,
2010            "string" === typeof options.precedence ? options.precedence : void 0,
2011            {
2012              crossOrigin,
2013              integrity,
2014              fetchPriority
2015            }
2016          ) : "script" === as3 && Internals.d.X(href, {
2017            crossOrigin,
2018            integrity,
2019            fetchPriority,
2020            nonce: "string" === typeof options.nonce ? options.nonce : void 0
2021          });
2022        }
2023      };
2024      exports.preinitModule = function(href, options) {
2025        var encountered = "";
2026        "string" === typeof href && href || (encountered += " The `href` argument encountered was " + getValueDescriptorExpectingObjectForWarning(href) + ".");
2027        void 0 !== options && "object" !== typeof options ? encountered += " The `options` argument encountered was " + getValueDescriptorExpectingObjectForWarning(options) + "." : options && "as" in options && "script" !== options.as && (encountered += " The `as` option encountered was " + getValueDescriptorExpectingEnumForWarning(options.as) + ".");
2028        if (encountered)
2029          console.error(
2030            "ReactDOM.preinitModule(): Expected up to two arguments, a non-empty `href` string and, optionally, an `options` object with a valid `as` property.%s",
2031            encountered
2032          );
2033        else
2034          switch (encountered = options && "string" === typeof options.as ? options.as : "script", encountered) {
2035            case "script":
2036              break;
2037            default:
2038              encountered = getValueDescriptorExpectingEnumForWarning(encountered), console.error(
2039                'ReactDOM.preinitModule(): Currently the only supported "as" type for this function is "script" but received "%s" instead. This warning was generated for `href` "%s". In the future other module types will be supported, aligning with the import-attributes proposal. Learn more here: (https://github.com/tc39/proposal-import-attributes)',
2040                encountered,
2041                href
2042              );
2043          }
2044        if ("string" === typeof href)
2045          if ("object" === typeof options && null !== options) {
2046            if (null == options.as || "script" === options.as)
2047              encountered = getCrossOriginStringAs(
2048                options.as,
2049                options.crossOrigin
2050              ), Internals.d.M(href, {
2051                crossOrigin: encountered,
2052                integrity: "string" === typeof options.integrity ? options.integrity : void 0,
2053                nonce: "string" === typeof options.nonce ? options.nonce : void 0
2054              });
2055          } else null == options && Internals.d.M(href);
2056      };
2057      exports.preload = function(href, options) {
2058        var encountered = "";
2059        "string" === typeof href && href || (encountered += " The `href` argument encountered was " + getValueDescriptorExpectingObjectForWarning(href) + ".");
2060        null == options || "object" !== typeof options ? encountered += " The `options` argument encountered was " + getValueDescriptorExpectingObjectForWarning(options) + "." : "string" === typeof options.as && options.as || (encountered += " The `as` option encountered was " + getValueDescriptorExpectingObjectForWarning(options.as) + ".");
2061        encountered && console.error(
2062          'ReactDOM.preload(): Expected two arguments, a non-empty `href` string and an `options` object with an `as` property valid for a `<link rel="preload" as="..." />` tag.%s',
2063          encountered
2064        );
2065        if ("string" === typeof href && "object" === typeof options && null !== options && "string" === typeof options.as) {
2066          encountered = options.as;
2067          var crossOrigin = getCrossOriginStringAs(
2068            encountered,
2069            options.crossOrigin
2070          );
2071          Internals.d.L(href, encountered, {
2072            crossOrigin,
2073            integrity: "string" === typeof options.integrity ? options.integrity : void 0,
2074            nonce: "string" === typeof options.nonce ? options.nonce : void 0,
2075            type: "string" === typeof options.type ? options.type : void 0,
2076            fetchPriority: "string" === typeof options.fetchPriority ? options.fetchPriority : void 0,
2077            referrerPolicy: "string" === typeof options.referrerPolicy ? options.referrerPolicy : void 0,
2078            imageSrcSet: "string" === typeof options.imageSrcSet ? options.imageSrcSet : void 0,
2079            imageSizes: "string" === typeof options.imageSizes ? options.imageSizes : void 0,
2080            media: "string" === typeof options.media ? options.media : void 0
2081          });
2082        }
2083      };
2084      exports.preloadModule = function(href, options) {
2085        var encountered = "";
2086        "string" === typeof href && href || (encountered += " The `href` argument encountered was " + getValueDescriptorExpectingObjectForWarning(href) + ".");
2087        void 0 !== options && "object" !== typeof options ? encountered += " The `options` argument encountered was " + getValueDescriptorExpectingObjectForWarning(options) + "." : options && "as" in options && "string" !== typeof options.as && (encountered += " The `as` option encountered was " + getValueDescriptorExpectingObjectForWarning(options.as) + ".");
2088        encountered && console.error(
2089          'ReactDOM.preloadModule(): Expected two arguments, a non-empty `href` string and, optionally, an `options` object with an `as` property valid for a `<link rel="modulepreload" as="..." />` tag.%s',
2090          encountered
2091        );
2092        "string" === typeof href && (options ? (encountered = getCrossOriginStringAs(
2093          options.as,
2094          options.crossOrigin
2095        ), Internals.d.m(href, {
2096          as: "string" === typeof options.as && "script" !== options.as ? options.as : void 0,
2097          crossOrigin: encountered,
2098          integrity: "string" === typeof options.integrity ? options.integrity : void 0
2099        })) : Internals.d.m(href));
2100      };
2101      exports.requestFormReset = function(form) {
2102        Internals.d.r(form);
2103      };
2104      exports.unstable_batchedUpdates = function(fn3, a3) {
2105        return fn3(a3);
2106      };
2107      exports.useFormState = function(action, initialState, permalink) {
2108        return resolveDispatcher().useFormState(action, initialState, permalink);
2109      };
2110      exports.useFormStatus = function() {
2111        return resolveDispatcher().useHostTransitionStatus();
2112      };
2113      exports.version = "19.2.4";
2114      "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
2115    })();
2116  }
2117});
2118

2119// node_modules/react-dom/index.js
2120var require_react_dom = __commonJS({
2121  "node_modules/react-dom/index.js"(exports, module) {
2122    "use strict";
2123    if (false) {
2124      checkDCE();
2125      module.exports = null;
2126    } else {
2127      module.exports = require_react_dom_development();
2128    }
2129  }
2130});
2131

2132// node_modules/react-dom/cjs/react-dom-client.development.js
2133var require_react_dom_client_development = __commonJS({
2134  "node_modules/react-dom/cjs/react-dom-client.development.js"(exports) {
2135    "use strict";
2136    (function() {
2137      function findHook(fiber, id) {
2138        for (fiber = fiber.memoizedState; null !== fiber && 0 < id; )
2139          fiber = fiber.next, id--;
2140        return fiber;
2141      }
2142      function copyWithSetImpl(obj, path, index, value) {
2143        if (index >= path.length) return value;
2144        var key = path[index], updated = isArrayImpl(obj) ? obj.slice() : assign({}, obj);
2145        updated[key] = copyWithSetImpl(obj[key], path, index + 1, value);
2146        return updated;
2147      }
2148      function copyWithRename(obj, oldPath, newPath) {
2149        if (oldPath.length !== newPath.length)
2150          console.warn("copyWithRename() expects paths of the same length");
2151        else {
2152          for (var i3 = 0; i3 < newPath.length - 1; i3++)
2153            if (oldPath[i3] !== newPath[i3]) {
2154              console.warn(
2155                "copyWithRename() expects paths to be the same except for the deepest key"
2156              );
2157              return;
2158            }
2159          return copyWithRenameImpl(obj, oldPath, newPath, 0);
2160        }
2161      }
2162      function copyWithRenameImpl(obj, oldPath, newPath, index) {
2163        var oldKey = oldPath[index], updated = isArrayImpl(obj) ? obj.slice() : assign({}, obj);
2164        index + 1 === oldPath.length ? (updated[newPath[index]] = updated[oldKey], isArrayImpl(updated) ? updated.splice(oldKey, 1) : delete updated[oldKey]) : updated[oldKey] = copyWithRenameImpl(
2165          obj[oldKey],
2166          oldPath,
2167          newPath,
2168          index + 1
2169        );
2170        return updated;
2171      }
2172      function copyWithDeleteImpl(obj, path, index) {
2173        var key = path[index], updated = isArrayImpl(obj) ? obj.slice() : assign({}, obj);
2174        if (index + 1 === path.length)
2175          return isArrayImpl(updated) ? updated.splice(key, 1) : delete updated[key], updated;
2176        updated[key] = copyWithDeleteImpl(obj[key], path, index + 1);
2177        return updated;
2178      }
2179      function shouldSuspendImpl() {
2180        return false;
2181      }
2182      function shouldErrorImpl() {
2183        return null;
2184      }
2185      function warnInvalidHookAccess() {
2186        console.error(
2187          "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"
2188        );
2189      }
2190      function warnInvalidContextAccess() {
2191        console.error(
2192          "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()."
2193        );
2194      }
2195      function noop() {
2196      }
2197      function warnForMissingKey() {
2198      }
2199      function setToSortedString(set) {
2200        var array = [];
2201        set.forEach(function(value) {
2202          array.push(value);
2203        });
2204        return array.sort().join(", ");
2205      }
2206      function createFiber(tag, pendingProps, key, mode2) {
2207        return new FiberNode(tag, pendingProps, key, mode2);
2208      }
2209      function scheduleRoot(root3, element) {
2210        root3.context === emptyContextObject && (updateContainerImpl(root3.current, 2, element, root3, null, null), flushSyncWork$1());
2211      }
2212      function scheduleRefresh(root3, update) {
2213        if (null !== resolveFamily) {
2214          var staleFamilies = update.staleFamilies;
2215          update = update.updatedFamilies;
2216          flushPendingEffects();
2217          scheduleFibersWithFamiliesRecursively(
2218            root3.current,
2219            update,
2220            staleFamilies
2221          );
2222          flushSyncWork$1();
2223        }
2224      }
2225      function setRefreshHandler(handler) {
2226        resolveFamily = handler;
2227      }
2228      function isValidContainer(node) {
2229        return !(!node || 1 !== node.nodeType && 9 !== node.nodeType && 11 !== node.nodeType);
2230      }
2231      function getNearestMountedFiber(fiber) {
2232        var node = fiber, nearestMounted = fiber;
2233        if (fiber.alternate) for (; node.return; ) node = node.return;
2234        else {
2235          fiber = node;
2236          do
2237            node = fiber, 0 !== (node.flags & 4098) && (nearestMounted = node.return), fiber = node.return;
2238          while (fiber);
2239        }
2240        return 3 === node.tag ? nearestMounted : null;
2241      }
2242      function getSuspenseInstanceFromFiber(fiber) {
2243        if (13 === fiber.tag) {
2244          var suspenseState = fiber.memoizedState;
2245          null === suspenseState && (fiber = fiber.alternate, null !== fiber && (suspenseState = fiber.memoizedState));
2246          if (null !== suspenseState) return suspenseState.dehydrated;
2247        }
2248        return null;
2249      }
2250      function getActivityInstanceFromFiber(fiber) {
2251        if (31 === fiber.tag) {
2252          var activityState = fiber.memoizedState;
2253          null === activityState && (fiber = fiber.alternate, null !== fiber && (activityState = fiber.memoizedState));
2254          if (null !== activityState) return activityState.dehydrated;
2255        }
2256        return null;
2257      }
2258      function assertIsMounted(fiber) {
2259        if (getNearestMountedFiber(fiber) !== fiber)
2260          throw Error("Unable to find node on an unmounted component.");
2261      }
2262      function findCurrentFiberUsingSlowPath(fiber) {
2263        var alternate = fiber.alternate;
2264        if (!alternate) {
2265          alternate = getNearestMountedFiber(fiber);
2266          if (null === alternate)
2267            throw Error("Unable to find node on an unmounted component.");
2268          return alternate !== fiber ? null : fiber;
2269        }
2270        for (var a3 = fiber, b3 = alternate; ; ) {
2271          var parentA = a3.return;
2272          if (null === parentA) break;
2273          var parentB = parentA.alternate;
2274          if (null === parentB) {
2275            b3 = parentA.return;
2276            if (null !== b3) {
2277              a3 = b3;
2278              continue;
2279            }
2280            break;
2281          }
2282          if (parentA.child === parentB.child) {
2283            for (parentB = parentA.child; parentB; ) {
2284              if (parentB === a3) return assertIsMounted(parentA), fiber;
2285              if (parentB === b3) return assertIsMounted(parentA), alternate;
2286              parentB = parentB.sibling;
2287            }
2288            throw Error("Unable to find node on an unmounted component.");
2289          }
2290          if (a3.return !== b3.return) a3 = parentA, b3 = parentB;
2291          else {
2292            for (var didFindChild = false, _child = parentA.child; _child; ) {
2293              if (_child === a3) {
2294                didFindChild = true;
2295                a3 = parentA;
2296                b3 = parentB;
2297                break;
2298              }
2299              if (_child === b3) {
2300                didFindChild = true;
2301                b3 = parentA;
2302                a3 = parentB;
2303                break;
2304              }
2305              _child = _child.sibling;
2306            }
2307            if (!didFindChild) {
2308              for (_child = parentB.child; _child; ) {
2309                if (_child === a3) {
2310                  didFindChild = true;
2311                  a3 = parentB;
2312                  b3 = parentA;
2313                  break;
2314                }
2315                if (_child === b3) {
2316                  didFindChild = true;
2317                  b3 = parentB;
2318                  a3 = parentA;
2319                  break;
2320                }
2321                _child = _child.sibling;
2322              }
2323              if (!didFindChild)
2324                throw Error(
2325                  "Child was not found in either parent set. This indicates a bug in React related to the return pointer. Please file an issue."
2326                );
2327            }
2328          }
2329          if (a3.alternate !== b3)
2330            throw Error(
2331              "Return fibers should always be each others' alternates. This error is likely caused by a bug in React. Please file an issue."
2332            );
2333        }
2334        if (3 !== a3.tag)
2335          throw Error("Unable to find node on an unmounted component.");
2336        return a3.stateNode.current === a3 ? fiber : alternate;
2337      }
2338      function findCurrentHostFiberImpl(node) {
2339        var tag = node.tag;
2340        if (5 === tag || 26 === tag || 27 === tag || 6 === tag) return node;
2341        for (node = node.child; null !== node; ) {
2342          tag = findCurrentHostFiberImpl(node);
2343          if (null !== tag) return tag;
2344          node = node.sibling;
2345        }
2346        return null;
2347      }
2348      function getIteratorFn(maybeIterable) {
2349        if (null === maybeIterable || "object" !== typeof maybeIterable)
2350          return null;
2351        maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
2352        return "function" === typeof maybeIterable ? maybeIterable : null;
2353      }
2354      function getComponentNameFromType(type) {
2355        if (null == type) return null;
2356        if ("function" === typeof type)
2357          return type.$$typeof === REACT_CLIENT_REFERENCE ? null : type.displayName || type.name || null;
2358        if ("string" === typeof type) return type;
2359        switch (type) {
2360          case REACT_FRAGMENT_TYPE:
2361            return "Fragment";
2362          case REACT_PROFILER_TYPE:
2363            return "Profiler";
2364          case REACT_STRICT_MODE_TYPE:
2365            return "StrictMode";
2366          case REACT_SUSPENSE_TYPE:
2367            return "Suspense";
2368          case REACT_SUSPENSE_LIST_TYPE:
2369            return "SuspenseList";
2370          case REACT_ACTIVITY_TYPE:
2371            return "Activity";
2372        }
2373        if ("object" === typeof type)
2374          switch ("number" === typeof type.tag && console.error(
2375            "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
2376          ), type.$$typeof) {
2377            case REACT_PORTAL_TYPE:
2378              return "Portal";
2379            case REACT_CONTEXT_TYPE:
2380              return type.displayName || "Context";
2381            case REACT_CONSUMER_TYPE:
2382              return (type._context.displayName || "Context") + ".Consumer";
2383            case REACT_FORWARD_REF_TYPE:
2384              var innerType = type.render;
2385              type = type.displayName;
2386              type || (type = innerType.displayName || innerType.name || "", type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef");
2387              return type;
2388            case REACT_MEMO_TYPE:
2389              return innerType = type.displayName || null, null !== innerType ? innerType : getComponentNameFromType(type.type) || "Memo";
2390            case REACT_LAZY_TYPE:
2391              innerType = type._payload;
2392              type = type._init;
2393              try {
2394                return getComponentNameFromType(type(innerType));
2395              } catch (x3) {
2396              }
2397          }
2398        return null;
2399      }
2400      function getComponentNameFromOwner(owner) {
2401        return "number" === typeof owner.tag ? getComponentNameFromFiber(owner) : "string" === typeof owner.name ? owner.name : null;
2402      }
2403      function getComponentNameFromFiber(fiber) {
2404        var type = fiber.type;
2405        switch (fiber.tag) {
2406          case 31:
2407            return "Activity";
2408          case 24:
2409            return "Cache";
2410          case 9:
2411            return (type._context.displayName || "Context") + ".Consumer";
2412          case 10:
2413            return type.displayName || "Context";
2414          case 18:
2415            return "DehydratedFragment";
2416          case 11:
2417            return fiber = type.render, fiber = fiber.displayName || fiber.name || "", type.displayName || ("" !== fiber ? "ForwardRef(" + fiber + ")" : "ForwardRef");
2418          case 7:
2419            return "Fragment";
2420          case 26:
2421          case 27:
2422          case 5:
2423            return type;
2424          case 4:
2425            return "Portal";
2426          case 3:
2427            return "Root";
2428          case 6:
2429            return "Text";
2430          case 16:
2431            return getComponentNameFromType(type);
2432          case 8:
2433            return type === REACT_STRICT_MODE_TYPE ? "StrictMode" : "Mode";
2434          case 22:
2435            return "Offscreen";
2436          case 12:
2437            return "Profiler";
2438          case 21:
2439            return "Scope";
2440          case 13:
2441            return "Suspense";
2442          case 19:
2443            return "SuspenseList";
2444          case 25:
2445            return "TracingMarker";
2446          case 1:
2447          case 0:
2448          case 14:
2449          case 15:
2450            if ("function" === typeof type)
2451              return type.displayName || type.name || null;
2452            if ("string" === typeof type) return type;
2453            break;
2454          case 29:
2455            type = fiber._debugInfo;
2456            if (null != type) {
2457              for (var i3 = type.length - 1; 0 <= i3; i3--)
2458                if ("string" === typeof type[i3].name) return type[i3].name;
2459            }
2460            if (null !== fiber.return)
2461              return getComponentNameFromFiber(fiber.return);
2462        }
2463        return null;
2464      }
2465      function createCursor(defaultValue) {
2466        return { current: defaultValue };
2467      }
2468      function pop(cursor, fiber) {
2469        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--);
2470      }
2471      function push(cursor, value, fiber) {
2472        index$jscomp$0++;
2473        valueStack[index$jscomp$0] = cursor.current;
2474        fiberStack[index$jscomp$0] = fiber;
2475        cursor.current = value;
2476      }
2477      function requiredContext(c3) {
2478        null === c3 && console.error(
2479          "Expected host context to exist. This error is likely caused by a bug in React. Please file an issue."
2480        );
2481        return c3;
2482      }
2483      function pushHostContainer(fiber, nextRootInstance) {
2484        push(rootInstanceStackCursor, nextRootInstance, fiber);
2485        push(contextFiberStackCursor, fiber, fiber);
2486        push(contextStackCursor, null, fiber);
2487        var nextRootContext = nextRootInstance.nodeType;
2488        switch (nextRootContext) {
2489          case 9:
2490          case 11:
2491            nextRootContext = 9 === nextRootContext ? "#document" : "#fragment";
2492            nextRootInstance = (nextRootInstance = nextRootInstance.documentElement) ? (nextRootInstance = nextRootInstance.namespaceURI) ? getOwnHostContext(nextRootInstance) : HostContextNamespaceNone : HostContextNamespaceNone;
2493            break;
2494          default:
2495            if (nextRootContext = nextRootInstance.tagName, nextRootInstance = nextRootInstance.namespaceURI)
2496              nextRootInstance = getOwnHostContext(nextRootInstance), nextRootInstance = getChildHostContextProd(
2497                nextRootInstance,
2498                nextRootContext
2499              );
2500            else
2501              switch (nextRootContext) {
2502                case "svg":
2503                  nextRootInstance = HostContextNamespaceSvg;
2504                  break;
2505                case "math":
2506                  nextRootInstance = HostContextNamespaceMath;
2507                  break;
2508                default:
2509                  nextRootInstance = HostContextNamespaceNone;
2510              }
2511        }
2512        nextRootContext = nextRootContext.toLowerCase();
2513        nextRootContext = updatedAncestorInfoDev(null, nextRootContext);
2514        nextRootContext = {
2515          context: nextRootInstance,
2516          ancestorInfo: nextRootContext
2517        };
2518        pop(contextStackCursor, fiber);
2519        push(contextStackCursor, nextRootContext, fiber);
2520      }
2521      function popHostContainer(fiber) {
2522        pop(contextStackCursor, fiber);
2523        pop(contextFiberStackCursor, fiber);
2524        pop(rootInstanceStackCursor, fiber);
2525      }
2526      function getHostContext() {
2527        return requiredContext(contextStackCursor.current);
2528      }
2529      function pushHostContext(fiber) {
2530        null !== fiber.memoizedState && push(hostTransitionProviderCursor, fiber, fiber);
2531        var context = requiredContext(contextStackCursor.current);
2532        var type = fiber.type;
2533        var nextContext = getChildHostContextProd(context.context, type);
2534        type = updatedAncestorInfoDev(context.ancestorInfo, type);
2535        nextContext = { context: nextContext, ancestorInfo: type };
2536        context !== nextContext && (push(contextFiberStackCursor, fiber, fiber), push(contextStackCursor, nextContext, fiber));
2537      }
2538      function popHostContext(fiber) {
2539        contextFiberStackCursor.current === fiber && (pop(contextStackCursor, fiber), pop(contextFiberStackCursor, fiber));
2540        hostTransitionProviderCursor.current === fiber && (pop(hostTransitionProviderCursor, fiber), HostTransitionContext._currentValue = NotPendingTransition);
2541      }
2542      function disabledLog() {
2543      }
2544      function disableLogs() {
2545        if (0 === disabledDepth) {
2546          prevLog = console.log;
2547          prevInfo = console.info;
2548          prevWarn = console.warn;
2549          prevError = console.error;
2550          prevGroup = console.group;
2551          prevGroupCollapsed = console.groupCollapsed;
2552          prevGroupEnd = console.groupEnd;
2553          var props = {
2554            configurable: true,
2555            enumerable: true,
2556            value: disabledLog,
2557            writable: true
2558          };
2559          Object.defineProperties(console, {
2560            info: props,
2561            log: props,
2562            warn: props,
2563            error: props,
2564            group: props,
2565            groupCollapsed: props,
2566            groupEnd: props
2567          });
2568        }
2569        disabledDepth++;
2570      }
2571      function reenableLogs() {
2572        disabledDepth--;
2573        if (0 === disabledDepth) {
2574          var props = { configurable: true, enumerable: true, writable: true };
2575          Object.defineProperties(console, {
2576            log: assign({}, props, { value: prevLog }),
2577            info: assign({}, props, { value: prevInfo }),
2578            warn: assign({}, props, { value: prevWarn }),
2579            error: assign({}, props, { value: prevError }),
2580            group: assign({}, props, { value: prevGroup }),
2581            groupCollapsed: assign({}, props, { value: prevGroupCollapsed }),
2582            groupEnd: assign({}, props, { value: prevGroupEnd })
2583          });
2584        }
2585        0 > disabledDepth && console.error(
2586          "disabledDepth fell below zero. This is a bug in React. Please file an issue."
2587        );
2588      }
2589      function formatOwnerStack(error2) {
2590        var prevPrepareStackTrace = Error.prepareStackTrace;
2591        Error.prepareStackTrace = void 0;
2592        error2 = error2.stack;
2593        Error.prepareStackTrace = prevPrepareStackTrace;
2594        error2.startsWith("Error: react-stack-top-frame\n") && (error2 = error2.slice(29));
2595        prevPrepareStackTrace = error2.indexOf("\n");
2596        -1 !== prevPrepareStackTrace && (error2 = error2.slice(prevPrepareStackTrace + 1));
2597        prevPrepareStackTrace = error2.indexOf("react_stack_bottom_frame");
2598        -1 !== prevPrepareStackTrace && (prevPrepareStackTrace = error2.lastIndexOf(
2599          "\n",
2600          prevPrepareStackTrace
2601        ));
2602        if (-1 !== prevPrepareStackTrace)
2603          error2 = error2.slice(0, prevPrepareStackTrace);
2604        else return "";
2605        return error2;
2606      }
2607      function describeBuiltInComponentFrame(name) {
2608        if (void 0 === prefix)
2609          try {
2610            throw Error();
2611          } catch (x3) {
2612            var match = x3.stack.trim().match(/\n( *(at )?)/);
2613            prefix = match && match[1] || "";
2614            suffix = -1 < x3.stack.indexOf("\n    at") ? " (<anonymous>)" : -1 < x3.stack.indexOf("@") ? "@unknown:0:0" : "";
2615          }
2616        return "\n" + prefix + name + suffix;
2617      }
2618      function describeNativeComponentFrame(fn3, construct) {
2619        if (!fn3 || reentry) return "";
2620        var frame = componentFrameCache.get(fn3);
2621        if (void 0 !== frame) return frame;
2622        reentry = true;
2623        frame = Error.prepareStackTrace;
2624        Error.prepareStackTrace = void 0;
2625        var previousDispatcher2 = null;
2626        previousDispatcher2 = ReactSharedInternals.H;
2627        ReactSharedInternals.H = null;
2628        disableLogs();
2629        try {
2630          var RunInRootFrame = {
2631            DetermineComponentFrameRoot: function() {
2632              try {
2633                if (construct) {
2634                  var Fake = function() {
2635                    throw Error();
2636                  };
2637                  Object.defineProperty(Fake.prototype, "props", {
2638                    set: function() {
2639                      throw Error();
2640                    }
2641                  });
2642                  if ("object" === typeof Reflect && Reflect.construct) {
2643                    try {
2644                      Reflect.construct(Fake, []);
2645                    } catch (x3) {
2646                      var control = x3;
2647                    }
2648                    Reflect.construct(fn3, [], Fake);
2649                  } else {
2650                    try {
2651                      Fake.call();
2652                    } catch (x$0) {
2653                      control = x$0;
2654                    }
2655                    fn3.call(Fake.prototype);
2656                  }
2657                } else {
2658                  try {
2659                    throw Error();
2660                  } catch (x$1) {
2661                    control = x$1;
2662                  }
2663                  (Fake = fn3()) && "function" === typeof Fake.catch && Fake.catch(function() {
2664                  });
2665                }
2666              } catch (sample) {
2667                if (sample && control && "string" === typeof sample.stack)
2668                  return [sample.stack, control.stack];
2669              }
2670              return [null, null];
2671            }
2672          };
2673          RunInRootFrame.DetermineComponentFrameRoot.displayName = "DetermineComponentFrameRoot";
2674          var namePropDescriptor = Object.getOwnPropertyDescriptor(
2675            RunInRootFrame.DetermineComponentFrameRoot,
2676            "name"
2677          );
2678          namePropDescriptor && namePropDescriptor.configurable && Object.defineProperty(
2679            RunInRootFrame.DetermineComponentFrameRoot,
2680            "name",
2681            { value: "DetermineComponentFrameRoot" }
2682          );
2683          var _RunInRootFrame$Deter = RunInRootFrame.DetermineComponentFrameRoot(), sampleStack = _RunInRootFrame$Deter[0], controlStack = _RunInRootFrame$Deter[1];
2684          if (sampleStack && controlStack) {
2685            var sampleLines = sampleStack.split("\n"), controlLines = controlStack.split("\n");
2686            for (_RunInRootFrame$Deter = namePropDescriptor = 0; namePropDescriptor < sampleLines.length && !sampleLines[namePropDescriptor].includes(
2687              "DetermineComponentFrameRoot"
2688            ); )
2689              namePropDescriptor++;
2690            for (; _RunInRootFrame$Deter < controlLines.length && !controlLines[_RunInRootFrame$Deter].includes(
2691              "DetermineComponentFrameRoot"
2692            ); )
2693              _RunInRootFrame$Deter++;
2694            if (namePropDescriptor === sampleLines.length || _RunInRootFrame$Deter === controlLines.length)
2695              for (namePropDescriptor = sampleLines.length - 1, _RunInRootFrame$Deter = controlLines.length - 1; 1 <= namePropDescriptor && 0 <= _RunInRootFrame$Deter && sampleLines[namePropDescriptor] !== controlLines[_RunInRootFrame$Deter]; )
2696                _RunInRootFrame$Deter--;
2697            for (; 1 <= namePropDescriptor && 0 <= _RunInRootFrame$Deter; namePropDescriptor--, _RunInRootFrame$Deter--)
2698              if (sampleLines[namePropDescriptor] !== controlLines[_RunInRootFrame$Deter]) {
2699                if (1 !== namePropDescriptor || 1 !== _RunInRootFrame$Deter) {
2700                  do
2701                    if (namePropDescriptor--, _RunInRootFrame$Deter--, 0 > _RunInRootFrame$Deter || sampleLines[namePropDescriptor] !== controlLines[_RunInRootFrame$Deter]) {
2702                      var _frame = "\n" + sampleLines[namePropDescriptor].replace(
2703                        " at new ",
2704                        " at "
2705                      );
2706                      fn3.displayName && _frame.includes("<anonymous>") && (_frame = _frame.replace("<anonymous>", fn3.displayName));
2707                      "function" === typeof fn3 && componentFrameCache.set(fn3, _frame);
2708                      return _frame;
2709                    }
2710                  while (1 <= namePropDescriptor && 0 <= _RunInRootFrame$Deter);
2711                }
2712                break;
2713              }
2714          }
2715        } finally {
2716          reentry = false, ReactSharedInternals.H = previousDispatcher2, reenableLogs(), Error.prepareStackTrace = frame;
2717        }
2718        sampleLines = (sampleLines = fn3 ? fn3.displayName || fn3.name : "") ? describeBuiltInComponentFrame(sampleLines) : "";
2719        "function" === typeof fn3 && componentFrameCache.set(fn3, sampleLines);
2720        return sampleLines;
2721      }
2722      function describeFiber(fiber, childFiber) {
2723        switch (fiber.tag) {
2724          case 26:
2725          case 27:
2726          case 5:
2727            return describeBuiltInComponentFrame(fiber.type);
2728          case 16:
2729            return describeBuiltInComponentFrame("Lazy");
2730          case 13:
2731            return fiber.child !== childFiber && null !== childFiber ? describeBuiltInComponentFrame("Suspense Fallback") : describeBuiltInComponentFrame("Suspense");
2732          case 19:
2733            return describeBuiltInComponentFrame("SuspenseList");
2734          case 0:
2735          case 15:
2736            return describeNativeComponentFrame(fiber.type, false);
2737          case 11:
2738            return describeNativeComponentFrame(fiber.type.render, false);
2739          case 1:
2740            return describeNativeComponentFrame(fiber.type, true);
2741          case 31:
2742            return describeBuiltInComponentFrame("Activity");
2743          default:
2744            return "";
2745        }
2746      }
2747      function getStackByFiberInDevAndProd(workInProgress2) {
2748        try {
2749          var info = "", previous = null;
2750          do {
2751            info += describeFiber(workInProgress2, previous);
2752            var debugInfo = workInProgress2._debugInfo;
2753            if (debugInfo)
2754              for (var i3 = debugInfo.length - 1; 0 <= i3; i3--) {
2755                var entry = debugInfo[i3];
2756                if ("string" === typeof entry.name) {
2757                  var JSCompiler_temp_const = info;
2758                  a: {
2759                    var name = entry.name, env = entry.env, location2 = entry.debugLocation;
2760                    if (null != location2) {
2761                      var childStack = formatOwnerStack(location2), idx = childStack.lastIndexOf("\n"), lastLine = -1 === idx ? childStack : childStack.slice(idx + 1);
2762                      if (-1 !== lastLine.indexOf(name)) {
2763                        var JSCompiler_inline_result = "\n" + lastLine;
2764                        break a;
2765                      }
2766                    }
2767                    JSCompiler_inline_result = describeBuiltInComponentFrame(
2768                      name + (env ? " [" + env + "]" : "")
2769                    );
2770                  }
2771                  info = JSCompiler_temp_const + JSCompiler_inline_result;
2772                }
2773              }
2774            previous = workInProgress2;
2775            workInProgress2 = workInProgress2.return;
2776          } while (workInProgress2);
2777          return info;
2778        } catch (x3) {
2779          return "\nError generating stack: " + x3.message + "\n" + x3.stack;
2780        }
2781      }
2782      function describeFunctionComponentFrameWithoutLineNumber(fn3) {
2783        return (fn3 = fn3 ? fn3.displayName || fn3.name : "") ? describeBuiltInComponentFrame(fn3) : "";
2784      }
2785      function getCurrentFiberOwnerNameInDevOrNull() {
2786        if (null === current) return null;
2787        var owner = current._debugOwner;
2788        return null != owner ? getComponentNameFromOwner(owner) : null;
2789      }
2790      function getCurrentFiberStackInDev() {
2791        if (null === current) return "";
2792        var workInProgress2 = current;
2793        try {
2794          var info = "";
2795          6 === workInProgress2.tag && (workInProgress2 = workInProgress2.return);
2796          switch (workInProgress2.tag) {
2797            case 26:
2798            case 27:
2799            case 5:
2800              info += describeBuiltInComponentFrame(workInProgress2.type);
2801              break;
2802            case 13:
2803              info += describeBuiltInComponentFrame("Suspense");
2804              break;
2805            case 19:
2806              info += describeBuiltInComponentFrame("SuspenseList");
2807              break;
2808            case 31:
2809              info += describeBuiltInComponentFrame("Activity");
2810              break;
2811            case 30:
2812            case 0:
2813            case 15:
2814            case 1:
2815              workInProgress2._debugOwner || "" !== info || (info += describeFunctionComponentFrameWithoutLineNumber(
2816                workInProgress2.type
2817              ));
2818              break;
2819            case 11:
2820              workInProgress2._debugOwner || "" !== info || (info += describeFunctionComponentFrameWithoutLineNumber(
2821                workInProgress2.type.render
2822              ));
2823          }
2824          for (; workInProgress2; )
2825            if ("number" === typeof workInProgress2.tag) {
2826              var fiber = workInProgress2;
2827              workInProgress2 = fiber._debugOwner;
2828              var debugStack = fiber._debugStack;
2829              if (workInProgress2 && debugStack) {
2830                var formattedStack = formatOwnerStack(debugStack);
2831                "" !== formattedStack && (info += "\n" + formattedStack);
2832              }
2833            } else if (null != workInProgress2.debugStack) {
2834              var ownerStack = workInProgress2.debugStack;
2835              (workInProgress2 = workInProgress2.owner) && ownerStack && (info += "\n" + formatOwnerStack(ownerStack));
2836            } else break;
2837          var JSCompiler_inline_result = info;
2838        } catch (x3) {
2839          JSCompiler_inline_result = "\nError generating stack: " + x3.message + "\n" + x3.stack;
2840        }
2841        return JSCompiler_inline_result;
2842      }
2843      function runWithFiberInDEV(fiber, callback, arg0, arg1, arg2, arg3, arg4) {
2844        var previousFiber = current;
2845        setCurrentFiber(fiber);
2846        try {
2847          return null !== fiber && fiber._debugTask ? fiber._debugTask.run(
2848            callback.bind(null, arg0, arg1, arg2, arg3, arg4)
2849          ) : callback(arg0, arg1, arg2, arg3, arg4);
2850        } finally {
2851          setCurrentFiber(previousFiber);
2852        }
2853        throw Error(
2854          "runWithFiberInDEV should never be called in production. This is a bug in React."
2855        );
2856      }
2857      function setCurrentFiber(fiber) {
2858        ReactSharedInternals.getCurrentStack = null === fiber ? null : getCurrentFiberStackInDev;
2859        isRendering = false;
2860        current = fiber;
2861      }
2862      function typeName(value) {
2863        return "function" === typeof Symbol && Symbol.toStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
2864      }
2865      function willCoercionThrow(value) {
2866        try {
2867          return testStringCoercion(value), false;
2868        } catch (e3) {
2869          return true;
2870        }
2871      }
2872      function testStringCoercion(value) {
2873        return "" + value;
2874      }
2875      function checkAttributeStringCoercion(value, attributeName) {
2876        if (willCoercionThrow(value))
2877          return console.error(
2878            "The provided `%s` attribute is an unsupported type %s. This value must be coerced to a string before using it here.",
2879            attributeName,
2880            typeName(value)
2881          ), testStringCoercion(value);
2882      }
2883      function checkCSSPropertyStringCoercion(value, propName) {
2884        if (willCoercionThrow(value))
2885          return console.error(
2886            "The provided `%s` CSS property is an unsupported type %s. This value must be coerced to a string before using it here.",
2887            propName,
2888            typeName(value)
2889          ), testStringCoercion(value);
2890      }
2891      function checkFormFieldValueStringCoercion(value) {
2892        if (willCoercionThrow(value))
2893          return console.error(
2894            "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.",
2895            typeName(value)
2896          ), testStringCoercion(value);
2897      }
2898      function injectInternals(internals) {
2899        if ("undefined" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__) return false;
2900        var hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
2901        if (hook.isDisabled) return true;
2902        if (!hook.supportsFiber)
2903          return console.error(
2904            "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"
2905          ), true;
2906        try {
2907          rendererID = hook.inject(internals), injectedHook = hook;
2908        } catch (err) {
2909          console.error("React instrumentation encountered an error: %o.", err);
2910        }
2911        return hook.checkDCE ? true : false;
2912      }
2913      function setIsStrictModeForDevtools(newIsStrictMode) {
2914        "function" === typeof log$1 && unstable_setDisableYieldValue(newIsStrictMode);
2915        if (injectedHook && "function" === typeof injectedHook.setStrictMode)
2916          try {
2917            injectedHook.setStrictMode(rendererID, newIsStrictMode);
2918          } catch (err) {
2919            hasLoggedError || (hasLoggedError = true, console.error(
2920              "React instrumentation encountered an error: %o",
2921              err
2922            ));
2923          }
2924      }
2925      function clz32Fallback(x3) {
2926        x3 >>>= 0;
2927        return 0 === x3 ? 32 : 31 - (log(x3) / LN2 | 0) | 0;
2928      }
2929      function getHighestPriorityLanes(lanes) {
2930        var pendingSyncLanes = lanes & 42;
2931        if (0 !== pendingSyncLanes) return pendingSyncLanes;
2932        switch (lanes & -lanes) {
2933          case 1:
2934            return 1;
2935          case 2:
2936            return 2;
2937          case 4:
2938            return 4;
2939          case 8:
2940            return 8;
2941          case 16:
2942            return 16;
2943          case 32:
2944            return 32;
2945          case 64:
2946            return 64;
2947          case 128:
2948            return 128;
2949          case 256:
2950          case 512:
2951          case 1024:
2952          case 2048:
2953          case 4096:
2954          case 8192:
2955          case 16384:
2956          case 32768:
2957          case 65536:
2958          case 131072:
2959            return lanes & 261888;
2960          case 262144:
2961          case 524288:
2962          case 1048576:
2963          case 2097152:
2964            return lanes & 3932160;
2965          case 4194304:
2966          case 8388608:
2967          case 16777216:
2968          case 33554432:
2969            return lanes & 62914560;
2970          case 67108864:
2971            return 67108864;
2972          case 134217728:
2973            return 134217728;
2974          case 268435456:
2975            return 268435456;
2976          case 536870912:
2977            return 536870912;
2978          case 1073741824:
2979            return 0;
2980          default:
2981            return console.error(
2982              "Should have found matching lanes. This is a bug in React."
2983            ), lanes;
2984        }
2985      }
2986      function getNextLanes(root3, wipLanes, rootHasPendingCommit) {
2987        var pendingLanes = root3.pendingLanes;
2988        if (0 === pendingLanes) return 0;
2989        var nextLanes = 0, suspendedLanes = root3.suspendedLanes, pingedLanes = root3.pingedLanes;
2990        root3 = root3.warmLanes;
2991        var nonIdlePendingLanes = pendingLanes & 134217727;
2992        0 !== nonIdlePendingLanes ? (pendingLanes = nonIdlePendingLanes & ~suspendedLanes, 0 !== pendingLanes ? nextLanes = getHighestPriorityLanes(pendingLanes) : (pingedLanes &= nonIdlePendingLanes, 0 !== pingedLanes ? nextLanes = getHighestPriorityLanes(pingedLanes) : rootHasPendingCommit || (rootHasPendingCommit = nonIdlePendingLanes & ~root3, 0 !== rootHasPendingCommit && (nextLanes = getHighestPriorityLanes(rootHasPendingCommit))))) : (nonIdlePendingLanes = pendingLanes & ~suspendedLanes, 0 !== nonIdlePendingLanes ? nextLanes = getHighestPriorityLanes(nonIdlePendingLanes) : 0 !== pingedLanes ? nextLanes = getHighestPriorityLanes(pingedLanes) : rootHasPendingCommit || (rootHasPendingCommit = pendingLanes & ~root3, 0 !== rootHasPendingCommit && (nextLanes = getHighestPriorityLanes(rootHasPendingCommit))));
2993        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;
2994      }
2995      function checkIfRootIsPrerendering(root3, renderLanes2) {
2996        return 0 === (root3.pendingLanes & ~(root3.suspendedLanes & ~root3.pingedLanes) & renderLanes2);
2997      }
2998      function computeExpirationTime(lane, currentTime) {
2999        switch (lane) {
3000          case 1:
3001          case 2:
3002          case 4:
3003          case 8:
3004          case 64:
3005            return currentTime + 250;
3006          case 16:
3007          case 32:
3008          case 128:
3009          case 256:
3010          case 512:
3011          case 1024:
3012          case 2048:
3013          case 4096:
3014          case 8192:
3015          case 16384:
3016          case 32768:
3017          case 65536:
3018          case 131072:
3019          case 262144:
3020          case 524288:
3021          case 1048576:
3022          case 2097152:
3023            return currentTime + 5e3;
3024          case 4194304:
3025          case 8388608:
3026          case 16777216:
3027          case 33554432:
3028            return -1;
3029          case 67108864:
3030          case 134217728:
3031          case 268435456:
3032          case 536870912:
3033          case 1073741824:
3034            return -1;
3035          default:
3036            return console.error(
3037              "Should have found matching lanes. This is a bug in React."
3038            ), -1;
3039        }
3040      }
3041      function claimNextRetryLane() {
3042        var lane = nextRetryLane;
3043        nextRetryLane <<= 1;
3044        0 === (nextRetryLane & 62914560) && (nextRetryLane = 4194304);
3045        return lane;
3046      }
3047      function createLaneMap(initial) {
3048        for (var laneMap = [], i3 = 0; 31 > i3; i3++) laneMap.push(initial);
3049        return laneMap;
3050      }
3051      function markRootUpdated$1(root3, updateLane) {
3052        root3.pendingLanes |= updateLane;
3053        268435456 !== updateLane && (root3.suspendedLanes = 0, root3.pingedLanes = 0, root3.warmLanes = 0);
3054      }
3055      function markRootFinished(root3, finishedLanes, remainingLanes, spawnedLane, updatedLanes, suspendedRetryLanes) {
3056        var previouslyPendingLanes = root3.pendingLanes;
3057        root3.pendingLanes = remainingLanes;
3058        root3.suspendedLanes = 0;
3059        root3.pingedLanes = 0;
3060        root3.warmLanes = 0;
3061        root3.expiredLanes &= remainingLanes;
3062        root3.entangledLanes &= remainingLanes;
3063        root3.errorRecoveryDisabledLanes &= remainingLanes;
3064        root3.shellSuspendCounter = 0;
3065        var entanglements = root3.entanglements, expirationTimes = root3.expirationTimes, hiddenUpdates = root3.hiddenUpdates;
3066        for (remainingLanes = previouslyPendingLanes & ~remainingLanes; 0 < remainingLanes; ) {
3067          var index = 31 - clz32(remainingLanes), lane = 1 << index;
3068          entanglements[index] = 0;
3069          expirationTimes[index] = -1;
3070          var hiddenUpdatesForLane = hiddenUpdates[index];
3071          if (null !== hiddenUpdatesForLane)
3072            for (hiddenUpdates[index] = null, index = 0; index < hiddenUpdatesForLane.length; index++) {
3073              var update = hiddenUpdatesForLane[index];
3074              null !== update && (update.lane &= -536870913);
3075            }
3076          remainingLanes &= ~lane;
3077        }
3078        0 !== spawnedLane && markSpawnedDeferredLane(root3, spawnedLane, 0);
3079        0 !== suspendedRetryLanes && 0 === updatedLanes && 0 !== root3.tag && (root3.suspendedLanes |= suspendedRetryLanes & ~(previouslyPendingLanes & ~finishedLanes));
3080      }
3081      function markSpawnedDeferredLane(root3, spawnedLane, entangledLanes) {
3082        root3.pendingLanes |= spawnedLane;
3083        root3.suspendedLanes &= ~spawnedLane;
3084        var spawnedLaneIndex = 31 - clz32(spawnedLane);
3085        root3.entangledLanes |= spawnedLane;
3086        root3.entanglements[spawnedLaneIndex] = root3.entanglements[spawnedLaneIndex] | 1073741824 | entangledLanes & 261930;
3087      }
3088      function markRootEntangled(root3, entangledLanes) {
3089        var rootEntangledLanes = root3.entangledLanes |= entangledLanes;
3090        for (root3 = root3.entanglements; rootEntangledLanes; ) {
3091          var index = 31 - clz32(rootEntangledLanes), lane = 1 << index;
3092          lane & entangledLanes | root3[index] & entangledLanes && (root3[index] |= entangledLanes);
3093          rootEntangledLanes &= ~lane;
3094        }
3095      }
3096      function getBumpedLaneForHydration(root3, renderLanes2) {
3097        var renderLane = renderLanes2 & -renderLanes2;
3098        renderLane = 0 !== (renderLane & 42) ? 1 : getBumpedLaneForHydrationByLane(renderLane);
3099        return 0 !== (renderLane & (root3.suspendedLanes | renderLanes2)) ? 0 : renderLane;
3100      }
3101      function getBumpedLaneForHydrationByLane(lane) {
3102        switch (lane) {
3103          case 2:
3104            lane = 1;
3105            break;
3106          case 8:
3107            lane = 4;
3108            break;
3109          case 32:
3110            lane = 16;
3111            break;
3112          case 256:
3113          case 512:
3114          case 1024:
3115          case 2048:
3116          case 4096:
3117          case 8192:
3118          case 16384:
3119          case 32768:
3120          case 65536:
3121          case 131072:
3122          case 262144:
3123          case 524288:
3124          case 1048576:
3125          case 2097152:
3126          case 4194304:
3127          case 8388608:
3128          case 16777216:
3129          case 33554432:
3130            lane = 128;
3131            break;
3132          case 268435456:
3133            lane = 134217728;
3134            break;
3135          default:
3136            lane = 0;
3137        }
3138        return lane;
3139      }
3140      function addFiberToLanesMap(root3, fiber, lanes) {
3141        if (isDevToolsPresent)
3142          for (root3 = root3.pendingUpdatersLaneMap; 0 < lanes; ) {
3143            var index = 31 - clz32(lanes), lane = 1 << index;
3144            root3[index].add(fiber);
3145            lanes &= ~lane;
3146          }
3147      }
3148      function movePendingFibersToMemoized(root3, lanes) {
3149        if (isDevToolsPresent)
3150          for (var pendingUpdatersLaneMap = root3.pendingUpdatersLaneMap, memoizedUpdaters = root3.memoizedUpdaters; 0 < lanes; ) {
3151            var index = 31 - clz32(lanes);
3152            root3 = 1 << index;
3153            index = pendingUpdatersLaneMap[index];
3154            0 < index.size && (index.forEach(function(fiber) {
3155              var alternate = fiber.alternate;
3156              null !== alternate && memoizedUpdaters.has(alternate) || memoizedUpdaters.add(fiber);
3157            }), index.clear());
3158            lanes &= ~root3;
3159          }
3160      }
3161      function lanesToEventPriority(lanes) {
3162        lanes &= -lanes;
3163        return 0 !== DiscreteEventPriority && DiscreteEventPriority < lanes ? 0 !== ContinuousEventPriority && ContinuousEventPriority < lanes ? 0 !== (lanes & 134217727) ? DefaultEventPriority : IdleEventPriority : ContinuousEventPriority : DiscreteEventPriority;
3164      }
3165      function resolveUpdatePriority() {
3166        var updatePriority = ReactDOMSharedInternals.p;
3167        if (0 !== updatePriority) return updatePriority;
3168        updatePriority = window.event;
3169        return void 0 === updatePriority ? DefaultEventPriority : getEventPriority(updatePriority.type);
3170      }
3171      function runWithPriority(priority, fn3) {
3172        var previousPriority = ReactDOMSharedInternals.p;
3173        try {
3174          return ReactDOMSharedInternals.p = priority, fn3();
3175        } finally {
3176          ReactDOMSharedInternals.p = previousPriority;
3177        }
3178      }
3179      function detachDeletedInstance(node) {
3180        delete node[internalInstanceKey];
3181        delete node[internalPropsKey];
3182        delete node[internalEventHandlersKey];
3183        delete node[internalEventHandlerListenersKey];
3184        delete node[internalEventHandlesSetKey];
3185      }
3186      function getClosestInstanceFromNode(targetNode) {
3187        var targetInst = targetNode[internalInstanceKey];
3188        if (targetInst) return targetInst;
3189        for (var parentNode = targetNode.parentNode; parentNode; ) {
3190          if (targetInst = parentNode[internalContainerInstanceKey] || parentNode[internalInstanceKey]) {
3191            parentNode = targetInst.alternate;
3192            if (null !== targetInst.child || null !== parentNode && null !== parentNode.child)
3193              for (targetNode = getParentHydrationBoundary(targetNode); null !== targetNode; ) {
3194                if (parentNode = targetNode[internalInstanceKey])
3195                  return parentNode;
3196                targetNode = getParentHydrationBoundary(targetNode);
3197              }
3198            return targetInst;
3199          }
3200          targetNode = parentNode;
3201          parentNode = targetNode.parentNode;
3202        }
3203        return null;
3204      }
3205      function getInstanceFromNode(node) {
3206        if (node = node[internalInstanceKey] || node[internalContainerInstanceKey]) {
3207          var tag = node.tag;
3208          if (5 === tag || 6 === tag || 13 === tag || 31 === tag || 26 === tag || 27 === tag || 3 === tag)
3209            return node;
3210        }
3211        return null;
3212      }
3213      function getNodeFromInstance(inst) {
3214        var tag = inst.tag;
3215        if (5 === tag || 26 === tag || 27 === tag || 6 === tag)
3216          return inst.stateNode;
3217        throw Error("getNodeFromInstance: Invalid argument.");
3218      }
3219      function getResourcesFromRoot(root3) {
3220        var resources = root3[internalRootNodeResourcesKey];
3221        resources || (resources = root3[internalRootNodeResourcesKey] = { hoistableStyles: /* @__PURE__ */ new Map(), hoistableScripts: /* @__PURE__ */ new Map() });
3222        return resources;
3223      }
3224      function markNodeAsHoistable(node) {
3225        node[internalHoistableMarker] = true;
3226      }
3227      function registerTwoPhaseEvent(registrationName, dependencies) {
3228        registerDirectEvent(registrationName, dependencies);
3229        registerDirectEvent(registrationName + "Capture", dependencies);
3230      }
3231      function registerDirectEvent(registrationName, dependencies) {
3232        registrationNameDependencies[registrationName] && console.error(
3233          "EventRegistry: More than one plugin attempted to publish the same registration name, `%s`.",
3234          registrationName
3235        );
3236        registrationNameDependencies[registrationName] = dependencies;
3237        var lowerCasedName = registrationName.toLowerCase();
3238        possibleRegistrationNames[lowerCasedName] = registrationName;
3239        "onDoubleClick" === registrationName && (possibleRegistrationNames.ondblclick = registrationName);
3240        for (registrationName = 0; registrationName < dependencies.length; registrationName++)
3241          allNativeEvents.add(dependencies[registrationName]);
3242      }
3243      function checkControlledValueProps(tagName, props) {
3244        hasReadOnlyValue[props.type] || props.onChange || props.onInput || props.readOnly || props.disabled || null == props.value || ("select" === tagName ? console.error(
3245          "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`."
3246        ) : console.error(
3247          "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`."
3248        ));
3249        props.onChange || props.readOnly || props.disabled || null == props.checked || console.error(
3250          "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`."
3251        );
3252      }
3253      function isAttributeNameSafe(attributeName) {
3254        if (hasOwnProperty.call(validatedAttributeNameCache, attributeName))
3255          return true;
3256        if (hasOwnProperty.call(illegalAttributeNameCache, attributeName))
3257          return false;
3258        if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName))
3259          return validatedAttributeNameCache[attributeName] = true;
3260        illegalAttributeNameCache[attributeName] = true;
3261        console.error("Invalid attribute name: `%s`", attributeName);
3262        return false;
3263      }
3264      function getValueForAttributeOnCustomComponent(node, name, expected) {
3265        if (isAttributeNameSafe(name)) {
3266          if (!node.hasAttribute(name)) {
3267            switch (typeof expected) {
3268              case "symbol":
3269              case "object":
3270                return expected;
3271              case "function":
3272                return expected;
3273              case "boolean":
3274                if (false === expected) return expected;
3275            }
3276            return void 0 === expected ? void 0 : null;
3277          }
3278          node = node.getAttribute(name);
3279          if ("" === node && true === expected) return true;
3280          checkAttributeStringCoercion(expected, name);
3281          return node === "" + expected ? expected : node;
3282        }
3283      }
3284      function setValueForAttribute(node, name, value) {
3285        if (isAttributeNameSafe(name))
3286          if (null === value) node.removeAttribute(name);
3287          else {
3288            switch (typeof value) {
3289              case "undefined":
3290              case "function":
3291              case "symbol":
3292                node.removeAttribute(name);
3293                return;
3294              case "boolean":
3295                var prefix2 = name.toLowerCase().slice(0, 5);
3296                if ("data-" !== prefix2 && "aria-" !== prefix2) {
3297                  node.removeAttribute(name);
3298                  return;
3299                }
3300            }
3301            checkAttributeStringCoercion(value, name);
3302            node.setAttribute(name, "" + value);
3303          }
3304      }
3305      function setValueForKnownAttribute(node, name, value) {
3306        if (null === value) node.removeAttribute(name);
3307        else {
3308          switch (typeof value) {
3309            case "undefined":
3310            case "function":
3311            case "symbol":
3312            case "boolean":
3313              node.removeAttribute(name);
3314              return;
3315          }
3316          checkAttributeStringCoercion(value, name);
3317          node.setAttribute(name, "" + value);
3318        }
3319      }
3320      function setValueForNamespacedAttribute(node, namespace, name, value) {
3321        if (null === value) node.removeAttribute(name);
3322        else {
3323          switch (typeof value) {
3324            case "undefined":
3325            case "function":
3326            case "symbol":
3327            case "boolean":
3328              node.removeAttribute(name);
3329              return;
3330          }
3331          checkAttributeStringCoercion(value, name);
3332          node.setAttributeNS(namespace, name, "" + value);
3333        }
3334      }
3335      function getToStringValue(value) {
3336        switch (typeof value) {
3337          case "bigint":
3338          case "boolean":
3339          case "number":
3340          case "string":
3341          case "undefined":
3342            return value;
3343          case "object":
3344            return checkFormFieldValueStringCoercion(value), value;
3345          default:
3346            return "";
3347        }
3348      }
3349      function isCheckable(elem) {
3350        var type = elem.type;
3351        return (elem = elem.nodeName) && "input" === elem.toLowerCase() && ("checkbox" === type || "radio" === type);
3352      }
3353      function trackValueOnNode(node, valueField, currentValue) {
3354        var descriptor = Object.getOwnPropertyDescriptor(
3355          node.constructor.prototype,
3356          valueField
3357        );
3358        if (!node.hasOwnProperty(valueField) && "undefined" !== typeof descriptor && "function" === typeof descriptor.get && "function" === typeof descriptor.set) {
3359          var get = descriptor.get, set = descriptor.set;
3360          Object.defineProperty(node, valueField, {
3361            configurable: true,
3362            get: function() {
3363              return get.call(this);
3364            },
3365            set: function(value) {
3366              checkFormFieldValueStringCoercion(value);
3367              currentValue = "" + value;
3368              set.call(this, value);
3369            }
3370          });
3371          Object.defineProperty(node, valueField, {
3372            enumerable: descriptor.enumerable
3373          });
3374          return {
3375            getValue: function() {
3376              return currentValue;
3377            },
3378            setValue: function(value) {
3379              checkFormFieldValueStringCoercion(value);
3380              currentValue = "" + value;
3381            },
3382            stopTracking: function() {
3383              node._valueTracker = null;
3384              delete node[valueField];
3385            }
3386          };
3387        }
3388      }
3389      function track2(node) {
3390        if (!node._valueTracker) {
3391          var valueField = isCheckable(node) ? "checked" : "value";
3392          node._valueTracker = trackValueOnNode(
3393            node,
3394            valueField,
3395            "" + node[valueField]
3396          );
3397        }
3398      }
3399      function updateValueIfChanged(node) {
3400        if (!node) return false;
3401        var tracker = node._valueTracker;
3402        if (!tracker) return true;
3403        var lastValue = tracker.getValue();
3404        var value = "";
3405        node && (value = isCheckable(node) ? node.checked ? "true" : "false" : node.value);
3406        node = value;
3407        return node !== lastValue ? (tracker.setValue(node), true) : false;
3408      }
3409      function getActiveElement(doc) {
3410        doc = doc || ("undefined" !== typeof document ? document : void 0);
3411        if ("undefined" === typeof doc) return null;
3412        try {
3413          return doc.activeElement || doc.body;
3414        } catch (e3) {
3415          return doc.body;
3416        }
3417      }
3418      function escapeSelectorAttributeValueInsideDoubleQuotes(value) {
3419        return value.replace(
3420          escapeSelectorAttributeValueInsideDoubleQuotesRegex,
3421          function(ch) {
3422            return "\\" + ch.charCodeAt(0).toString(16) + " ";
3423          }
3424        );
3425      }
3426      function validateInputProps(element, props) {
3427        void 0 === props.checked || void 0 === props.defaultChecked || didWarnCheckedDefaultChecked || (console.error(
3428          "%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",
3429          getCurrentFiberOwnerNameInDevOrNull() || "A component",
3430          props.type
3431        ), didWarnCheckedDefaultChecked = true);
3432        void 0 === props.value || void 0 === props.defaultValue || didWarnValueDefaultValue$1 || (console.error(
3433          "%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",
3434          getCurrentFiberOwnerNameInDevOrNull() || "A component",
3435          props.type
3436        ), didWarnValueDefaultValue$1 = true);
3437      }
3438      function updateInput(element, value, defaultValue, lastDefaultValue, checked, defaultChecked, type, name) {
3439        element.name = "";
3440        null != type && "function" !== typeof type && "symbol" !== typeof type && "boolean" !== typeof type ? (checkAttributeStringCoercion(type, "type"), element.type = type) : element.removeAttribute("type");
3441        if (null != value)
3442          if ("number" === type) {
3443            if (0 === value && "" === element.value || element.value != value)
3444              element.value = "" + getToStringValue(value);
3445          } else
3446            element.value !== "" + getToStringValue(value) && (element.value = "" + getToStringValue(value));
3447        else
3448          "submit" !== type && "reset" !== type || element.removeAttribute("value");
3449        null != value ? setDefaultValue(element, type, getToStringValue(value)) : null != defaultValue ? setDefaultValue(element, type, getToStringValue(defaultValue)) : null != lastDefaultValue && element.removeAttribute("value");
3450        null == checked && null != defaultChecked && (element.defaultChecked = !!defaultChecked);
3451        null != checked && (element.checked = checked && "function" !== typeof checked && "symbol" !== typeof checked);
3452        null != name && "function" !== typeof name && "symbol" !== typeof name && "boolean" !== typeof name ? (checkAttributeStringCoercion(name, "name"), element.name = "" + getToStringValue(name)) : element.removeAttribute("name");
3453      }
3454      function initInput(element, value, defaultValue, checked, defaultChecked, type, name, isHydrating2) {
3455        null != type && "function" !== typeof type && "symbol" !== typeof type && "boolean" !== typeof type && (checkAttributeStringCoercion(type, "type"), element.type = type);
3456        if (null != value || null != defaultValue) {
3457          if (!("submit" !== type && "reset" !== type || void 0 !== value && null !== value)) {
3458            track2(element);
3459            return;
3460          }
3461          defaultValue = null != defaultValue ? "" + getToStringValue(defaultValue) : "";
3462          value = null != value ? "" + getToStringValue(value) : defaultValue;
3463          isHydrating2 || value === element.value || (element.value = value);
3464          element.defaultValue = value;
3465        }
3466        checked = null != checked ? checked : defaultChecked;
3467        checked = "function" !== typeof checked && "symbol" !== typeof checked && !!checked;
3468        element.checked = isHydrating2 ? element.checked : !!checked;
3469        element.defaultChecked = !!checked;
3470        null != name && "function" !== typeof name && "symbol" !== typeof name && "boolean" !== typeof name && (checkAttributeStringCoercion(name, "name"), element.name = name);
3471        track2(element);
3472      }
3473      function setDefaultValue(node, type, value) {
3474        "number" === type && getActiveElement(node.ownerDocument) === node || node.defaultValue === "" + value || (node.defaultValue = "" + value);
3475      }
3476      function validateOptionProps(element, props) {
3477        null == props.value && ("object" === typeof props.children && null !== props.children ? React19.Children.forEach(props.children, function(child) {
3478          null == child || "string" === typeof child || "number" === typeof child || "bigint" === typeof child || didWarnInvalidChild || (didWarnInvalidChild = true, console.error(
3479            "Cannot infer the option value of complex children. Pass a `value` prop or use a plain string as children to <option>."
3480          ));
3481        }) : null == props.dangerouslySetInnerHTML || didWarnInvalidInnerHTML || (didWarnInvalidInnerHTML = true, console.error(
3482          "Pass a `value` prop if you set dangerouslyInnerHTML so React knows which value should be selected."
3483        )));
3484        null == props.selected || didWarnSelectedSetOnOption || (console.error(
3485          "Use the `defaultValue` or `value` props on <select> instead of setting `selected` on <option>."
3486        ), didWarnSelectedSetOnOption = true);
3487      }
3488      function getDeclarationErrorAddendum() {
3489        var ownerName = getCurrentFiberOwnerNameInDevOrNull();
3490        return ownerName ? "\n\nCheck the render method of `" + ownerName + "`." : "";
3491      }
3492      function updateOptions(node, multiple, propValue, setDefaultSelected) {
3493        node = node.options;
3494        if (multiple) {
3495          multiple = {};
3496          for (var i3 = 0; i3 < propValue.length; i3++)
3497            multiple["$" + propValue[i3]] = true;
3498          for (propValue = 0; propValue < node.length; propValue++)
3499            i3 = multiple.hasOwnProperty("$" + node[propValue].value), node[propValue].selected !== i3 && (node[propValue].selected = i3), i3 && setDefaultSelected && (node[propValue].defaultSelected = true);
3500        } else {
3501          propValue = "" + getToStringValue(propValue);
3502          multiple = null;
3503          for (i3 = 0; i3 < node.length; i3++) {
3504            if (node[i3].value === propValue) {
3505              node[i3].selected = true;
3506              setDefaultSelected && (node[i3].defaultSelected = true);
3507              return;
3508            }
3509            null !== multiple || node[i3].disabled || (multiple = node[i3]);
3510          }
3511          null !== multiple && (multiple.selected = true);
3512        }
3513      }
3514      function validateSelectProps(element, props) {
3515        for (element = 0; element < valuePropNames.length; element++) {
3516          var propName = valuePropNames[element];
3517          if (null != props[propName]) {
3518            var propNameIsArray = isArrayImpl(props[propName]);
3519            props.multiple && !propNameIsArray ? console.error(
3520              "The `%s` prop supplied to <select> must be an array if `multiple` is true.%s",
3521              propName,
3522              getDeclarationErrorAddendum()
3523            ) : !props.multiple && propNameIsArray && console.error(
3524              "The `%s` prop supplied to <select> must be a scalar value if `multiple` is false.%s",
3525              propName,
3526              getDeclarationErrorAddendum()
3527            );
3528          }
3529        }
3530        void 0 === props.value || void 0 === props.defaultValue || didWarnValueDefaultValue || (console.error(
3531          "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"
3532        ), didWarnValueDefaultValue = true);
3533      }
3534      function validateTextareaProps(element, props) {
3535        void 0 === props.value || void 0 === props.defaultValue || didWarnValDefaultVal || (console.error(
3536          "%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",
3537          getCurrentFiberOwnerNameInDevOrNull() || "A component"
3538        ), didWarnValDefaultVal = true);
3539        null != props.children && null == props.value && console.error(
3540          "Use the `defaultValue` or `value` props instead of setting children on <textarea>."
3541        );
3542      }
3543      function updateTextarea(element, value, defaultValue) {
3544        if (null != value && (value = "" + getToStringValue(value), value !== element.value && (element.value = value), null == defaultValue)) {
3545          element.defaultValue !== value && (element.defaultValue = value);
3546          return;
3547        }
3548        element.defaultValue = null != defaultValue ? "" + getToStringValue(defaultValue) : "";
3549      }
3550      function initTextarea(element, value, defaultValue, children) {
3551        if (null == value) {
3552          if (null != children) {
3553            if (null != defaultValue)
3554              throw Error(
3555                "If you supply `defaultValue` on a <textarea>, do not pass children."
3556              );
3557            if (isArrayImpl(children)) {
3558              if (1 < children.length)
3559                throw Error("<textarea> can only have at most one child.");
3560              children = children[0];
3561            }
3562            defaultValue = children;
3563          }
3564          null == defaultValue && (defaultValue = "");
3565          value = defaultValue;
3566        }
3567        defaultValue = getToStringValue(value);
3568        element.defaultValue = defaultValue;
3569        children = element.textContent;
3570        children === defaultValue && "" !== children && null !== children && (element.value = children);
3571        track2(element);
3572      }
3573      function findNotableNode(node, indent) {
3574        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;
3575      }
3576      function indentation(indent) {
3577        return "  " + "  ".repeat(indent);
3578      }
3579      function added(indent) {
3580        return "+ " + "  ".repeat(indent);
3581      }
3582      function removed(indent) {
3583        return "- " + "  ".repeat(indent);
3584      }
3585      function describeFiberType(fiber) {
3586        switch (fiber.tag) {
3587          case 26:
3588          case 27:
3589          case 5:
3590            return fiber.type;
3591          case 16:
3592            return "Lazy";
3593          case 31:
3594            return "Activity";
3595          case 13:
3596            return "Suspense";
3597          case 19:
3598            return "SuspenseList";
3599          case 0:
3600          case 15:
3601            return fiber = fiber.type, fiber.displayName || fiber.name || null;
3602          case 11:
3603            return fiber = fiber.type.render, fiber.displayName || fiber.name || null;
3604          case 1:
3605            return fiber = fiber.type, fiber.displayName || fiber.name || null;
3606          default:
3607            return null;
3608        }
3609      }
3610      function describeTextNode(content, maxLength) {
3611        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;
3612      }
3613      function describeTextDiff(clientText, serverProps, indent) {
3614        var maxLength = 120 - 2 * indent;
3615        if (null === serverProps)
3616          return added(indent) + describeTextNode(clientText, maxLength) + "\n";
3617        if ("string" === typeof serverProps) {
3618          for (var firstDiff = 0; firstDiff < serverProps.length && firstDiff < clientText.length && serverProps.charCodeAt(firstDiff) === clientText.charCodeAt(firstDiff); firstDiff++) ;
3619          firstDiff > maxLength - 8 && 10 < firstDiff && (clientText = "..." + clientText.slice(firstDiff - 8), serverProps = "..." + serverProps.slice(firstDiff - 8));
3620          return added(indent) + describeTextNode(clientText, maxLength) + "\n" + removed(indent) + describeTextNode(serverProps, maxLength) + "\n";
3621        }
3622        return indentation(indent) + describeTextNode(clientText, maxLength) + "\n";
3623      }
3624      function objectName(object) {
3625        return Object.prototype.toString.call(object).replace(/^\[object (.*)\]$/, function(m3, p0) {
3626          return p0;
3627        });
3628      }
3629      function describeValue(value, maxLength) {
3630        switch (typeof value) {
3631          case "string":
3632            return value = JSON.stringify(value), value.length > maxLength ? 5 > maxLength ? '"..."' : value.slice(0, maxLength - 4) + '..."' : value;
3633          case "object":
3634            if (null === value) return "null";
3635            if (isArrayImpl(value)) return "[...]";
3636            if (value.$$typeof === REACT_ELEMENT_TYPE)
3637              return (maxLength = getComponentNameFromType(value.type)) ? "<" + maxLength + ">" : "<...>";
3638            var name = objectName(value);
3639            if ("Object" === name) {
3640              name = "";
3641              maxLength -= 2;
3642              for (var propName in value)
3643                if (value.hasOwnProperty(propName)) {
3644                  var jsonPropName = JSON.stringify(propName);
3645                  jsonPropName !== '"' + propName + '"' && (propName = jsonPropName);
3646                  maxLength -= propName.length - 2;
3647                  jsonPropName = describeValue(
3648                    value[propName],
3649                    15 > maxLength ? maxLength : 15
3650                  );
3651                  maxLength -= jsonPropName.length;
3652                  if (0 > maxLength) {
3653                    name += "" === name ? "..." : ", ...";
3654                    break;
3655                  }
3656                  name += ("" === name ? "" : ",") + propName + ":" + jsonPropName;
3657                }
3658              return "{" + name + "}";
3659            }
3660            return name;
3661          case "function":
3662            return (maxLength = value.displayName || value.name) ? "function " + maxLength : "function";
3663          default:
3664            return String(value);
3665        }
3666      }
3667      function describePropValue(value, maxLength) {
3668        return "string" !== typeof value || needsEscaping.test(value) ? "{" + describeValue(value, maxLength - 2) + "}" : value.length > maxLength - 2 ? 5 > maxLength ? '"..."' : '"' + value.slice(0, maxLength - 5) + '..."' : '"' + value + '"';
3669      }
3670      function describeExpandedElement(type, props, rowPrefix) {
3671        var remainingRowLength = 120 - rowPrefix.length - type.length, properties = [], propName;
3672        for (propName in props)
3673          if (props.hasOwnProperty(propName) && "children" !== propName) {
3674            var propValue = describePropValue(
3675              props[propName],
3676              120 - rowPrefix.length - propName.length - 1
3677            );
3678            remainingRowLength -= propName.length + propValue.length + 2;
3679            properties.push(propName + "=" + propValue);
3680          }
3681        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";
3682      }
3683      function describePropertiesDiff(clientObject, serverObject, indent) {
3684        var properties = "", remainingServerProperties = assign({}, serverObject), propName;
3685        for (propName in clientObject)
3686          if (clientObject.hasOwnProperty(propName)) {
3687            delete remainingServerProperties[propName];
3688            var maxLength = 120 - 2 * indent - propName.length - 2, clientPropValue = describeValue(clientObject[propName], maxLength);
3689            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";
3690          }
3691        for (var _propName in remainingServerProperties)
3692          remainingServerProperties.hasOwnProperty(_propName) && (clientObject = describeValue(
3693            remainingServerProperties[_propName],
3694            120 - 2 * indent - _propName.length - 2
3695          ), properties += removed(indent) + _propName + ": " + clientObject + "\n");
3696        return properties;
3697      }
3698      function describeElementDiff(type, clientProps, serverProps, indent) {
3699        var content = "", serverPropNames = /* @__PURE__ */ new Map();
3700        for (propName$jscomp$0 in serverProps)
3701          serverProps.hasOwnProperty(propName$jscomp$0) && serverPropNames.set(
3702            propName$jscomp$0.toLowerCase(),
3703            propName$jscomp$0
3704          );
3705        if (1 === serverPropNames.size && serverPropNames.has("children"))
3706          content += describeExpandedElement(
3707            type,
3708            clientProps,
3709            indentation(indent)
3710          );
3711        else {
3712          for (var _propName2 in clientProps)
3713            if (clientProps.hasOwnProperty(_propName2) && "children" !== _propName2) {
3714              var maxLength$jscomp$0 = 120 - 2 * (indent + 1) - _propName2.length - 1, serverPropName = serverPropNames.get(_propName2.toLowerCase());
3715              if (void 0 !== serverPropName) {
3716                serverPropNames.delete(_propName2.toLowerCase());
3717                var propName$jscomp$0 = clientProps[_propName2];
3718                serverPropName = serverProps[serverPropName];
3719                var clientPropValue = describePropValue(
3720                  propName$jscomp$0,
3721                  maxLength$jscomp$0
3722                );
3723                maxLength$jscomp$0 = describePropValue(
3724                  serverPropName,
3725                  maxLength$jscomp$0
3726                );
3727                "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(
3728                  propName$jscomp$0,
3729                  serverPropName,
3730                  indent + 2
3731                ) + indentation(indent + 1) + "}}\n" : (content += added(indent + 1) + _propName2 + "=" + clientPropValue + "\n", content += removed(indent + 1) + _propName2 + "=" + maxLength$jscomp$0 + "\n");
3732              } else
3733                content += indentation(indent + 1) + _propName2 + "=" + describePropValue(clientProps[_propName2], maxLength$jscomp$0) + "\n";
3734            }
3735          serverPropNames.forEach(function(propName) {
3736            if ("children" !== propName) {
3737              var maxLength = 120 - 2 * (indent + 1) - propName.length - 1;
3738              content += removed(indent + 1) + propName + "=" + describePropValue(serverProps[propName], maxLength) + "\n";
3739            }
3740          });
3741          content = "" === content ? indentation(indent) + "<" + type + ">\n" : indentation(indent) + "<" + type + "\n" + content + indentation(indent) + ">\n";
3742        }
3743        type = serverProps.children;
3744        clientProps = clientProps.children;
3745        if ("string" === typeof type || "number" === typeof type || "bigint" === typeof type) {
3746          serverPropNames = "";
3747          if ("string" === typeof clientProps || "number" === typeof clientProps || "bigint" === typeof clientProps)
3748            serverPropNames = "" + clientProps;
3749          content += describeTextDiff(serverPropNames, "" + type, indent + 1);
3750        } else if ("string" === typeof clientProps || "number" === typeof clientProps || "bigint" === typeof clientProps)
3751          content = null == type ? content + describeTextDiff("" + clientProps, null, indent + 1) : content + describeTextDiff("" + clientProps, void 0, indent + 1);
3752        return content;
3753      }
3754      function describeSiblingFiber(fiber, indent) {
3755        var type = describeFiberType(fiber);
3756        if (null === type) {
3757          type = "";
3758          for (fiber = fiber.child; fiber; )
3759            type += describeSiblingFiber(fiber, indent), fiber = fiber.sibling;
3760          return type;
3761        }
3762        return indentation(indent) + "<" + type + ">\n";
3763      }
3764      function describeNode(node, indent) {
3765        var skipToNode = findNotableNode(node, indent);
3766        if (skipToNode !== node && (1 !== node.children.length || node.children[0] !== skipToNode))
3767          return indentation(indent) + "...\n" + describeNode(skipToNode, indent + 1);
3768        skipToNode = "";
3769        var debugInfo = node.fiber._debugInfo;
3770        if (debugInfo)
3771          for (var i3 = 0; i3 < debugInfo.length; i3++) {
3772            var serverComponentName = debugInfo[i3].name;
3773            "string" === typeof serverComponentName && (skipToNode += indentation(indent) + "<" + serverComponentName + ">\n", indent++);
3774          }
3775        debugInfo = "";
3776        i3 = node.fiber.pendingProps;
3777        if (6 === node.fiber.tag)
3778          debugInfo = describeTextDiff(i3, node.serverProps, indent), indent++;
3779        else if (serverComponentName = describeFiberType(node.fiber), null !== serverComponentName)
3780          if (void 0 === node.serverProps) {
3781            debugInfo = indent;
3782            var maxLength = 120 - 2 * debugInfo - serverComponentName.length - 2, content = "";
3783            for (propName in i3)
3784              if (i3.hasOwnProperty(propName) && "children" !== propName) {
3785                var propValue = describePropValue(i3[propName], 15);
3786                maxLength -= propName.length + propValue.length + 2;
3787                if (0 > maxLength) {
3788                  content += " ...";
3789                  break;
3790                }
3791                content += " " + propName + "=" + propValue;
3792              }
3793            debugInfo = indentation(debugInfo) + "<" + serverComponentName + content + ">\n";
3794            indent++;
3795          } else
3796            null === node.serverProps ? (debugInfo = describeExpandedElement(
3797              serverComponentName,
3798              i3,
3799              added(indent)
3800            ), indent++) : "string" === typeof node.serverProps ? console.error(
3801              "Should not have matched a non HostText fiber to a Text node. This is a bug in React."
3802            ) : (debugInfo = describeElementDiff(
3803              serverComponentName,
3804              i3,
3805              node.serverProps,
3806              indent
3807            ), indent++);
3808        var propName = "";
3809        i3 = node.fiber.child;
3810        for (serverComponentName = 0; i3 && serverComponentName < node.children.length; )
3811          maxLength = node.children[serverComponentName], maxLength.fiber === i3 ? (propName += describeNode(maxLength, indent), serverComponentName++) : propName += describeSiblingFiber(i3, indent), i3 = i3.sibling;
3812        i3 && 0 < node.children.length && (propName += indentation(indent) + "...\n");
3813        i3 = node.serverTail;
3814        null === node.serverProps && indent--;
3815        for (node = 0; node < i3.length; node++)
3816          serverComponentName = i3[node], propName = "string" === typeof serverComponentName ? propName + (removed(indent) + describeTextNode(serverComponentName, 120 - 2 * indent) + "\n") : propName + describeExpandedElement(
3817            serverComponentName.type,
3818            serverComponentName.props,
3819            removed(indent)
3820          );
3821        return skipToNode + debugInfo + propName;
3822      }
3823      function describeDiff(rootNode) {
3824        try {
3825          return "\n\n" + describeNode(rootNode, 0);
3826        } catch (x3) {
3827          return "";
3828        }
3829      }
3830      function describeAncestors(ancestor, child, props) {
3831        for (var fiber = child, node = null, distanceFromLeaf = 0; fiber; )
3832          fiber === ancestor && (distanceFromLeaf = 0), node = {
3833            fiber,
3834            children: null !== node ? [node] : [],
3835            serverProps: fiber === child ? props : fiber === ancestor ? null : void 0,
3836            serverTail: [],
3837            distanceFromLeaf
3838          }, distanceFromLeaf++, fiber = fiber.return;
3839        return null !== node ? describeDiff(node).replaceAll(/^[+-]/gm, ">") : "";
3840      }
3841      function updatedAncestorInfoDev(oldInfo, tag) {
3842        var ancestorInfo = assign({}, oldInfo || emptyAncestorInfoDev), info = { tag };
3843        -1 !== inScopeTags.indexOf(tag) && (ancestorInfo.aTagInScope = null, ancestorInfo.buttonTagInScope = null, ancestorInfo.nobrTagInScope = null);
3844        -1 !== buttonScopeTags.indexOf(tag) && (ancestorInfo.pTagInButtonScope = null);
3845        -1 !== specialTags.indexOf(tag) && "address" !== tag && "div" !== tag && "p" !== tag && (ancestorInfo.listItemTagAutoclosing = null, ancestorInfo.dlItemTagAutoclosing = null);
3846        ancestorInfo.current = info;
3847        "form" === tag && (ancestorInfo.formTag = info);
3848        "a" === tag && (ancestorInfo.aTagInScope = info);
3849        "button" === tag && (ancestorInfo.buttonTagInScope = info);
3850        "nobr" === tag && (ancestorInfo.nobrTagInScope = info);
3851        "p" === tag && (ancestorInfo.pTagInButtonScope = info);
3852        "li" === tag && (ancestorInfo.listItemTagAutoclosing = info);
3853        if ("dd" === tag || "dt" === tag)
3854          ancestorInfo.dlItemTagAutoclosing = info;
3855        "#document" === tag || "html" === tag ? ancestorInfo.containerTagInScope = null : ancestorInfo.containerTagInScope || (ancestorInfo.containerTagInScope = info);
3856        null !== oldInfo || "#document" !== tag && "html" !== tag && "body" !== tag ? true === ancestorInfo.implicitRootScope && (ancestorInfo.implicitRootScope = false) : ancestorInfo.implicitRootScope = true;
3857        return ancestorInfo;
3858      }
3859      function isTagValidWithParent(tag, parentTag, implicitRootScope) {
3860        switch (parentTag) {
3861          case "select":
3862            return "hr" === tag || "option" === tag || "optgroup" === tag || "script" === tag || "template" === tag || "#text" === tag;
3863          case "optgroup":
3864            return "option" === tag || "#text" === tag;
3865          case "option":
3866            return "#text" === tag;
3867          case "tr":
3868            return "th" === tag || "td" === tag || "style" === tag || "script" === tag || "template" === tag;
3869          case "tbody":
3870          case "thead":
3871          case "tfoot":
3872            return "tr" === tag || "style" === tag || "script" === tag || "template" === tag;
3873          case "colgroup":
3874            return "col" === tag || "template" === tag;
3875          case "table":
3876            return "caption" === tag || "colgroup" === tag || "tbody" === tag || "tfoot" === tag || "thead" === tag || "style" === tag || "script" === tag || "template" === tag;
3877          case "head":
3878            return "base" === tag || "basefont" === tag || "bgsound" === tag || "link" === tag || "meta" === tag || "title" === tag || "noscript" === tag || "noframes" === tag || "style" === tag || "script" === tag || "template" === tag;
3879          case "html":
3880            if (implicitRootScope) break;
3881            return "head" === tag || "body" === tag || "frameset" === tag;
3882          case "frameset":
3883            return "frame" === tag;
3884          case "#document":
3885            if (!implicitRootScope) return "html" === tag;
3886        }
3887        switch (tag) {
3888          case "h1":
3889          case "h2":
3890          case "h3":
3891          case "h4":
3892          case "h5":
3893          case "h6":
3894            return "h1" !== parentTag && "h2" !== parentTag && "h3" !== parentTag && "h4" !== parentTag && "h5" !== parentTag && "h6" !== parentTag;
3895          case "rp":
3896          case "rt":
3897            return -1 === impliedEndTags.indexOf(parentTag);
3898          case "caption":
3899          case "col":
3900          case "colgroup":
3901          case "frameset":
3902          case "frame":
3903          case "tbody":
3904          case "td":
3905          case "tfoot":
3906          case "th":
3907          case "thead":
3908          case "tr":
3909            return null == parentTag;
3910          case "head":
3911            return implicitRootScope || null === parentTag;
3912          case "html":
3913            return implicitRootScope && "#document" === parentTag || null === parentTag;
3914          case "body":
3915            return implicitRootScope && ("#document" === parentTag || "html" === parentTag) || null === parentTag;
3916        }
3917        return true;
3918      }
3919      function findInvalidAncestorForTag(tag, ancestorInfo) {
3920        switch (tag) {
3921          case "address":
3922          case "article":
3923          case "aside":
3924          case "blockquote":
3925          case "center":
3926          case "details":
3927          case "dialog":
3928          case "dir":
3929          case "div":
3930          case "dl":
3931          case "fieldset":
3932          case "figcaption":
3933          case "figure":
3934          case "footer":
3935          case "header":
3936          case "hgroup":
3937          case "main":
3938          case "menu":
3939          case "nav":
3940          case "ol":
3941          case "p":
3942          case "section":
3943          case "summary":
3944          case "ul":
3945          case "pre":
3946          case "listing":
3947          case "table":
3948          case "hr":
3949          case "xmp":
3950          case "h1":
3951          case "h2":
3952          case "h3":
3953          case "h4":
3954          case "h5":
3955          case "h6":
3956            return ancestorInfo.pTagInButtonScope;
3957          case "form":
3958            return ancestorInfo.formTag || ancestorInfo.pTagInButtonScope;
3959          case "li":
3960            return ancestorInfo.listItemTagAutoclosing;
3961          case "dd":
3962          case "dt":
3963            return ancestorInfo.dlItemTagAutoclosing;
3964          case "button":
3965            return ancestorInfo.buttonTagInScope;
3966          case "a":
3967            return ancestorInfo.aTagInScope;
3968          case "nobr":
3969            return ancestorInfo.nobrTagInScope;
3970        }
3971        return null;
3972      }
3973      function findAncestor(parent, tagName) {
3974        for (; parent; ) {
3975          switch (parent.tag) {
3976            case 5:
3977            case 26:
3978            case 27:
3979              if (parent.type === tagName) return parent;
3980          }
3981          parent = parent.return;
3982        }
3983        return null;
3984      }
3985      function validateDOMNesting(childTag, ancestorInfo) {
3986        ancestorInfo = ancestorInfo || emptyAncestorInfoDev;
3987        var parentInfo = ancestorInfo.current;
3988        ancestorInfo = (parentInfo = isTagValidWithParent(
3989          childTag,
3990          parentInfo && parentInfo.tag,
3991          ancestorInfo.implicitRootScope
3992        ) ? null : parentInfo) ? null : findInvalidAncestorForTag(childTag, ancestorInfo);
3993        ancestorInfo = parentInfo || ancestorInfo;
3994        if (!ancestorInfo) return true;
3995        var ancestorTag = ancestorInfo.tag;
3996        ancestorInfo = String(!!parentInfo) + "|" + childTag + "|" + ancestorTag;
3997        if (didWarn[ancestorInfo]) return false;
3998        didWarn[ancestorInfo] = true;
3999        var ancestor = (ancestorInfo = current) ? findAncestor(ancestorInfo.return, ancestorTag) : null, ancestorDescription = null !== ancestorInfo && null !== ancestor ? describeAncestors(ancestor, ancestorInfo, null) : "", tagDisplayName = "<" + childTag + ">";
4000        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(
4001          "In HTML, %s cannot be a child of <%s>.%s\nThis will cause a hydration error.%s",
4002          tagDisplayName,
4003          ancestorTag,
4004          parentInfo,
4005          ancestorDescription
4006        )) : console.error(
4007          "In HTML, %s cannot be a descendant of <%s>.\nThis will cause a hydration error.%s",
4008          tagDisplayName,
4009          ancestorTag,
4010          ancestorDescription
4011        );
4012        ancestorInfo && (childTag = ancestorInfo.return, null === ancestor || null === childTag || ancestor === childTag && childTag._debugOwner === ancestorInfo._debugOwner || runWithFiberInDEV(ancestor, function() {
4013          console.error(
4014            "<%s> cannot contain a nested %s.\nSee this log for the ancestor stack trace.",
4015            ancestorTag,
4016            tagDisplayName
4017          );
4018        }));
4019        return false;
4020      }
4021      function validateTextNesting(childText, parentTag, implicitRootScope) {
4022        if (implicitRootScope || isTagValidWithParent("#text", parentTag, false))
4023          return true;
4024        implicitRootScope = "#text|" + parentTag;
4025        if (didWarn[implicitRootScope]) return false;
4026        didWarn[implicitRootScope] = true;
4027        var ancestor = (implicitRootScope = current) ? findAncestor(implicitRootScope, parentTag) : null;
4028        implicitRootScope = null !== implicitRootScope && null !== ancestor ? describeAncestors(
4029          ancestor,
4030          implicitRootScope,
4031          6 !== implicitRootScope.tag ? { children: null } : null
4032        ) : "";
4033        /\S/.test(childText) ? console.error(
4034          "In HTML, text nodes cannot be a child of <%s>.\nThis will cause a hydration error.%s",
4035          parentTag,
4036          implicitRootScope
4037        ) : console.error(
4038          "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",
4039          parentTag,
4040          implicitRootScope
4041        );
4042        return false;
4043      }
4044      function setTextContent(node, text) {
4045        if (text) {
4046          var firstChild = node.firstChild;
4047          if (firstChild && firstChild === node.lastChild && 3 === firstChild.nodeType) {
4048            firstChild.nodeValue = text;
4049            return;
4050          }
4051        }
4052        node.textContent = text;
4053      }
4054      function camelize2(string) {
4055        return string.replace(hyphenPattern, function(_3, character) {
4056          return character.toUpperCase();
4057        });
4058      }
4059      function setValueForStyle(style2, styleName, value) {
4060        var isCustomProperty = 0 === styleName.indexOf("--");
4061        isCustomProperty || (-1 < styleName.indexOf("-") ? warnedStyleNames.hasOwnProperty(styleName) && warnedStyleNames[styleName] || (warnedStyleNames[styleName] = true, console.error(
4062          "Unsupported style property %s. Did you mean %s?",
4063          styleName,
4064          camelize2(styleName.replace(msPattern, "ms-"))
4065        )) : badVendoredStyleNamePattern.test(styleName) ? warnedStyleNames.hasOwnProperty(styleName) && warnedStyleNames[styleName] || (warnedStyleNames[styleName] = true, console.error(
4066          "Unsupported vendor-prefixed style property %s. Did you mean %s?",
4067          styleName,
4068          styleName.charAt(0).toUpperCase() + styleName.slice(1)
4069        )) : !badStyleValueWithSemicolonPattern.test(value) || warnedStyleValues.hasOwnProperty(value) && warnedStyleValues[value] || (warnedStyleValues[value] = true, console.error(
4070          `Style property values shouldn't contain a semicolon. Try "%s: %s" instead.`,
4071          styleName,
4072          value.replace(badStyleValueWithSemicolonPattern, "")
4073        )), "number" === typeof value && (isNaN(value) ? warnedForNaNValue || (warnedForNaNValue = true, console.error(
4074          "`NaN` is an invalid value for the `%s` css style property.",
4075          styleName
4076        )) : isFinite(value) || warnedForInfinityValue || (warnedForInfinityValue = true, console.error(
4077          "`Infinity` is an invalid value for the `%s` css style property.",
4078          styleName
4079        ))));
4080        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";
4081      }
4082      function setValueForStyles(node, styles, prevStyles) {
4083        if (null != styles && "object" !== typeof styles)
4084          throw Error(
4085            "The `style` prop expects a mapping from style properties to values, not a string. For example, style={{marginRight: spacing + 'em'}} when using JSX."
4086          );
4087        styles && Object.freeze(styles);
4088        node = node.style;
4089        if (null != prevStyles) {
4090          if (styles) {
4091            var expandedUpdates = {};
4092            if (prevStyles) {
4093              for (var key in prevStyles)
4094                if (prevStyles.hasOwnProperty(key) && !styles.hasOwnProperty(key))
4095                  for (var longhands = shorthandToLonghand[key] || [key], i3 = 0; i3 < longhands.length; i3++)
4096                    expandedUpdates[longhands[i3]] = key;
4097            }
4098            for (var _key in styles)
4099              if (styles.hasOwnProperty(_key) && (!prevStyles || prevStyles[_key] !== styles[_key]))
4100                for (key = shorthandToLonghand[_key] || [_key], longhands = 0; longhands < key.length; longhands++)
4101                  expandedUpdates[key[longhands]] = _key;
4102            _key = {};
4103            for (var key$jscomp$0 in styles)
4104              for (key = shorthandToLonghand[key$jscomp$0] || [key$jscomp$0], longhands = 0; longhands < key.length; longhands++)
4105                _key[key[longhands]] = key$jscomp$0;
4106            key$jscomp$0 = {};
4107            for (var _key2 in expandedUpdates)
4108              if (key = expandedUpdates[_key2], (longhands = _key[_key2]) && key !== longhands && (i3 = key + "," + longhands, !key$jscomp$0[i3])) {
4109                key$jscomp$0[i3] = true;
4110                i3 = console;
4111                var value = styles[key];
4112                i3.error.call(
4113                  i3,
4114                  "%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.",
4115                  null == value || "boolean" === typeof value || "" === value ? "Removing" : "Updating",
4116                  key,
4117                  longhands
4118                );
4119              }
4120          }
4121          for (var styleName in prevStyles)
4122            !prevStyles.hasOwnProperty(styleName) || null != styles && styles.hasOwnProperty(styleName) || (0 === styleName.indexOf("--") ? node.setProperty(styleName, "") : "float" === styleName ? node.cssFloat = "" : node[styleName] = "");
4123          for (var _styleName in styles)
4124            _key2 = styles[_styleName], styles.hasOwnProperty(_styleName) && prevStyles[_styleName] !== _key2 && setValueForStyle(node, _styleName, _key2);
4125        } else
4126          for (expandedUpdates in styles)
4127            styles.hasOwnProperty(expandedUpdates) && setValueForStyle(node, expandedUpdates, styles[expandedUpdates]);
4128      }
4129      function isCustomElement(tagName) {
4130        if (-1 === tagName.indexOf("-")) return false;
4131        switch (tagName) {
4132          case "annotation-xml":
4133          case "color-profile":
4134          case "font-face":
4135          case "font-face-src":
4136          case "font-face-uri":
4137          case "font-face-format":
4138          case "font-face-name":
4139          case "missing-glyph":
4140            return false;
4141          default:
4142            return true;
4143        }
4144      }
4145      function getAttributeAlias(name) {
4146        return aliases.get(name) || name;
4147      }
4148      function validateProperty$1(tagName, name) {
4149        if (hasOwnProperty.call(warnedProperties$1, name) && warnedProperties$1[name])
4150          return true;
4151        if (rARIACamel$1.test(name)) {
4152          tagName = "aria-" + name.slice(4).toLowerCase();
4153          tagName = ariaProperties.hasOwnProperty(tagName) ? tagName : null;
4154          if (null == tagName)
4155            return console.error(
4156              "Invalid ARIA attribute `%s`. ARIA attributes follow the pattern aria-* and must be lowercase.",
4157              name
4158            ), warnedProperties$1[name] = true;
4159          if (name !== tagName)
4160            return console.error(
4161              "Invalid ARIA attribute `%s`. Did you mean `%s`?",
4162              name,
4163              tagName
4164            ), warnedProperties$1[name] = true;
4165        }
4166        if (rARIA$1.test(name)) {
4167          tagName = name.toLowerCase();
4168          tagName = ariaProperties.hasOwnProperty(tagName) ? tagName : null;
4169          if (null == tagName) return warnedProperties$1[name] = true, false;
4170          name !== tagName && (console.error(
4171            "Unknown ARIA attribute `%s`. Did you mean `%s`?",
4172            name,
4173            tagName
4174          ), warnedProperties$1[name] = true);
4175        }
4176        return true;
4177      }
4178      function validateProperties$2(type, props) {
4179        var invalidProps = [], key;
4180        for (key in props)
4181          validateProperty$1(type, key) || invalidProps.push(key);
4182        props = invalidProps.map(function(prop) {
4183          return "`" + prop + "`";
4184        }).join(", ");
4185        1 === invalidProps.length ? console.error(
4186          "Invalid aria prop %s on <%s> tag. For details, see https://react.dev/link/invalid-aria-props",
4187          props,
4188          type
4189        ) : 1 < invalidProps.length && console.error(
4190          "Invalid aria props %s on <%s> tag. For details, see https://react.dev/link/invalid-aria-props",
4191          props,
4192          type
4193        );
4194      }
4195      function validateProperty(tagName, name, value, eventRegistry) {
4196        if (hasOwnProperty.call(warnedProperties, name) && warnedProperties[name])
4197          return true;
4198        var lowerCasedName = name.toLowerCase();
4199        if ("onfocusin" === lowerCasedName || "onfocusout" === lowerCasedName)
4200          return console.error(
4201            "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."
4202          ), warnedProperties[name] = true;
4203        if ("function" === typeof value && ("form" === tagName && "action" === name || "input" === tagName && "formAction" === name || "button" === tagName && "formAction" === name))
4204          return true;
4205        if (null != eventRegistry) {
4206          tagName = eventRegistry.possibleRegistrationNames;
4207          if (eventRegistry.registrationNameDependencies.hasOwnProperty(name))
4208            return true;
4209          eventRegistry = tagName.hasOwnProperty(lowerCasedName) ? tagName[lowerCasedName] : null;
4210          if (null != eventRegistry)
4211            return console.error(
4212              "Invalid event handler property `%s`. Did you mean `%s`?",
4213              name,
4214              eventRegistry
4215            ), warnedProperties[name] = true;
4216          if (EVENT_NAME_REGEX.test(name))
4217            return console.error(
4218              "Unknown event handler property `%s`. It will be ignored.",
4219              name
4220            ), warnedProperties[name] = true;
4221        } else if (EVENT_NAME_REGEX.test(name))
4222          return INVALID_EVENT_NAME_REGEX.test(name) && console.error(
4223            "Invalid event handler property `%s`. React events use the camelCase naming convention, for example `onClick`.",
4224            name
4225          ), warnedProperties[name] = true;
4226        if (rARIA.test(name) || rARIACamel.test(name)) return true;
4227        if ("innerhtml" === lowerCasedName)
4228          return console.error(
4229            "Directly setting property `innerHTML` is not permitted. For more information, lookup documentation on `dangerouslySetInnerHTML`."
4230          ), warnedProperties[name] = true;
4231        if ("aria" === lowerCasedName)
4232          return console.error(
4233            "The `aria` attribute is reserved for future use in React. Pass individual `aria-` attributes instead."
4234          ), warnedProperties[name] = true;
4235        if ("is" === lowerCasedName && null !== value && void 0 !== value && "string" !== typeof value)
4236          return console.error(
4237            "Received a `%s` for a string attribute `is`. If this is expected, cast the value to a string.",
4238            typeof value
4239          ), warnedProperties[name] = true;
4240        if ("number" === typeof value && isNaN(value))
4241          return console.error(
4242            "Received NaN for the `%s` attribute. If this is expected, cast the value to a string.",
4243            name
4244          ), warnedProperties[name] = true;
4245        if (possibleStandardNames.hasOwnProperty(lowerCasedName)) {
4246          if (lowerCasedName = possibleStandardNames[lowerCasedName], lowerCasedName !== name)
4247            return console.error(
4248              "Invalid DOM property `%s`. Did you mean `%s`?",
4249              name,
4250              lowerCasedName
4251            ), warnedProperties[name] = true;
4252        } else if (name !== lowerCasedName)
4253          return console.error(
4254            "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.",
4255            name,
4256            lowerCasedName
4257          ), warnedProperties[name] = true;
4258        switch (name) {
4259          case "dangerouslySetInnerHTML":
4260          case "children":
4261          case "style":
4262          case "suppressContentEditableWarning":
4263          case "suppressHydrationWarning":
4264          case "defaultValue":
4265          case "defaultChecked":
4266          case "innerHTML":
4267          case "ref":
4268            return true;
4269          case "innerText":
4270          case "textContent":
4271            return true;
4272        }
4273        switch (typeof value) {
4274          case "boolean":
4275            switch (name) {
4276              case "autoFocus":
4277              case "checked":
4278              case "multiple":
4279              case "muted":
4280              case "selected":
4281              case "contentEditable":
4282              case "spellCheck":
4283              case "draggable":
4284              case "value":
4285              case "autoReverse":
4286              case "externalResourcesRequired":
4287              case "focusable":
4288              case "preserveAlpha":
4289              case "allowFullScreen":
4290              case "async":
4291              case "autoPlay":
4292              case "controls":
4293              case "default":
4294              case "defer":
4295              case "disabled":
4296              case "disablePictureInPicture":
4297              case "disableRemotePlayback":
4298              case "formNoValidate":
4299              case "hidden":
4300              case "loop":
4301              case "noModule":
4302              case "noValidate":
4303              case "open":
4304              case "playsInline":
4305              case "readOnly":
4306              case "required":
4307              case "reversed":
4308              case "scoped":
4309              case "seamless":
4310              case "itemScope":
4311              case "capture":
4312              case "download":
4313              case "inert":
4314                return true;
4315              default:
4316                lowerCasedName = name.toLowerCase().slice(0, 5);
4317                if ("data-" === lowerCasedName || "aria-" === lowerCasedName)
4318                  return true;
4319                value ? console.error(
4320                  '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()}.',
4321                  value,
4322                  name,
4323                  name,
4324                  value,
4325                  name
4326                ) : console.error(
4327                  '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.',
4328                  value,
4329                  name,
4330                  name,
4331                  value,
4332                  name,
4333                  name,
4334                  name
4335                );
4336                return warnedProperties[name] = true;
4337            }
4338          case "function":
4339          case "symbol":
4340            return warnedProperties[name] = true, false;
4341          case "string":
4342            if ("false" === value || "true" === value) {
4343              switch (name) {
4344                case "checked":
4345                case "selected":
4346                case "multiple":
4347                case "muted":
4348                case "allowFullScreen":
4349                case "async":
4350                case "autoPlay":
4351                case "controls":
4352                case "default":
4353                case "defer":
4354                case "disabled":
4355                case "disablePictureInPicture":
4356                case "disableRemotePlayback":
4357                case "formNoValidate":
4358                case "hidden":
4359                case "loop":
4360                case "noModule":
4361                case "noValidate":
4362                case "open":
4363                case "playsInline":
4364                case "readOnly":
4365                case "required":
4366                case "reversed":
4367                case "scoped":
4368                case "seamless":
4369                case "itemScope":
4370                case "inert":
4371                  break;
4372                default:
4373                  return true;
4374              }
4375              console.error(
4376                "Received the string `%s` for the boolean attribute `%s`. %s Did you mean %s={%s}?",
4377                value,
4378                name,
4379                "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".',
4380                name,
4381                value
4382              );
4383              warnedProperties[name] = true;
4384            }
4385        }
4386        return true;
4387      }
4388      function warnUnknownProperties(type, props, eventRegistry) {
4389        var unknownProps = [], key;
4390        for (key in props)
4391          validateProperty(type, key, props[key], eventRegistry) || unknownProps.push(key);
4392        props = unknownProps.map(function(prop) {
4393          return "`" + prop + "`";
4394        }).join(", ");
4395        1 === unknownProps.length ? console.error(
4396          "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 ",
4397          props,
4398          type
4399        ) : 1 < unknownProps.length && console.error(
4400          "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 ",
4401          props,
4402          type
4403        );
4404      }
4405      function sanitizeURL(url) {
4406        return isJavaScriptProtocol.test("" + url) ? "javascript:throw new Error('React has blocked a javascript: URL as a security precaution.')" : url;
4407      }
4408      function noop$1() {
4409      }
4410      function getEventTarget(nativeEvent) {
4411        nativeEvent = nativeEvent.target || nativeEvent.srcElement || window;
4412        nativeEvent.correspondingUseElement && (nativeEvent = nativeEvent.correspondingUseElement);
4413        return 3 === nativeEvent.nodeType ? nativeEvent.parentNode : nativeEvent;
4414      }
4415      function restoreStateOfTarget(target) {
4416        var internalInstance = getInstanceFromNode(target);
4417        if (internalInstance && (target = internalInstance.stateNode)) {
4418          var props = target[internalPropsKey] || null;
4419          a: switch (target = internalInstance.stateNode, internalInstance.type) {
4420            case "input":
4421              updateInput(
4422                target,
4423                props.value,
4424                props.defaultValue,
4425                props.defaultValue,
4426                props.checked,
4427                props.defaultChecked,
4428                props.type,
4429                props.name
4430              );
4431              internalInstance = props.name;
4432              if ("radio" === props.type && null != internalInstance) {
4433                for (props = target; props.parentNode; ) props = props.parentNode;
4434                checkAttributeStringCoercion(internalInstance, "name");
4435                props = props.querySelectorAll(
4436                  'input[name="' + escapeSelectorAttributeValueInsideDoubleQuotes(
4437                    "" + internalInstance
4438                  ) + '"][type="radio"]'
4439                );
4440                for (internalInstance = 0; internalInstance < props.length; internalInstance++) {
4441                  var otherNode = props[internalInstance];
4442                  if (otherNode !== target && otherNode.form === target.form) {
4443                    var otherProps = otherNode[internalPropsKey] || null;
4444                    if (!otherProps)
4445                      throw Error(
4446                        "ReactDOMInput: Mixing React and non-React radio inputs with the same `name` is not supported."
4447                      );
4448                    updateInput(
4449                      otherNode,
4450                      otherProps.value,
4451                      otherProps.defaultValue,
4452                      otherProps.defaultValue,
4453                      otherProps.checked,
4454                      otherProps.defaultChecked,
4455                      otherProps.type,
4456                      otherProps.name
4457                    );
4458                  }
4459                }
4460                for (internalInstance = 0; internalInstance < props.length; internalInstance++)
4461                  otherNode = props[internalInstance], otherNode.form === target.form && updateValueIfChanged(otherNode);
4462              }
4463              break a;
4464            case "textarea":
4465              updateTextarea(target, props.value, props.defaultValue);
4466              break a;
4467            case "select":
4468              internalInstance = props.value, null != internalInstance && updateOptions(target, !!props.multiple, internalInstance, false);
4469          }
4470        }
4471      }
4472      function batchedUpdates$1(fn3, a3, b3) {
4473        if (isInsideEventHandler) return fn3(a3, b3);
4474        isInsideEventHandler = true;
4475        try {
4476          var JSCompiler_inline_result = fn3(a3);
4477          return JSCompiler_inline_result;
4478        } finally {
4479          if (isInsideEventHandler = false, null !== restoreTarget || null !== restoreQueue) {
4480            if (flushSyncWork$1(), restoreTarget && (a3 = restoreTarget, fn3 = restoreQueue, restoreQueue = restoreTarget = null, restoreStateOfTarget(a3), fn3))
4481              for (a3 = 0; a3 < fn3.length; a3++) restoreStateOfTarget(fn3[a3]);
4482          }
4483        }
4484      }
4485      function getListener(inst, registrationName) {
4486        var stateNode = inst.stateNode;
4487        if (null === stateNode) return null;
4488        var props = stateNode[internalPropsKey] || null;
4489        if (null === props) return null;
4490        stateNode = props[registrationName];
4491        a: switch (registrationName) {
4492          case "onClick":
4493          case "onClickCapture":
4494          case "onDoubleClick":
4495          case "onDoubleClickCapture":
4496          case "onMouseDown":
4497          case "onMouseDownCapture":
4498          case "onMouseMove":
4499          case "onMouseMoveCapture":
4500          case "onMouseUp":
4501          case "onMouseUpCapture":
4502          case "onMouseEnter":
4503            (props = !props.disabled) || (inst = inst.type, props = !("button" === inst || "input" === inst || "select" === inst || "textarea" === inst));
4504            inst = !props;
4505            break a;
4506          default:
4507            inst = false;
4508        }
4509        if (inst) return null;
4510        if (stateNode && "function" !== typeof stateNode)
4511          throw Error(
4512            "Expected `" + registrationName + "` listener to be a function, instead got a value of `" + typeof stateNode + "` type."
4513          );
4514        return stateNode;
4515      }
4516      function getData() {
4517        if (fallbackText) return fallbackText;
4518        var start2, startValue = startText, startLength = startValue.length, end, endValue = "value" in root2 ? root2.value : root2.textContent, endLength = endValue.length;
4519        for (start2 = 0; start2 < startLength && startValue[start2] === endValue[start2]; start2++) ;
4520        var minEnd = startLength - start2;
4521        for (end = 1; end <= minEnd && startValue[startLength - end] === endValue[endLength - end]; end++) ;
4522        return fallbackText = endValue.slice(start2, 1 < end ? 1 - end : void 0);
4523      }
4524      function getEventCharCode(nativeEvent) {
4525        var keyCode = nativeEvent.keyCode;
4526        "charCode" in nativeEvent ? (nativeEvent = nativeEvent.charCode, 0 === nativeEvent && 13 === keyCode && (nativeEvent = 13)) : nativeEvent = keyCode;
4527        10 === nativeEvent && (nativeEvent = 13);
4528        return 32 <= nativeEvent || 13 === nativeEvent ? nativeEvent : 0;
4529      }
4530      function functionThatReturnsTrue() {
4531        return true;
4532      }
4533      function functionThatReturnsFalse() {
4534        return false;
4535      }
4536      function createSyntheticEvent(Interface) {
4537        function SyntheticBaseEvent(reactName, reactEventType, targetInst, nativeEvent, nativeEventTarget) {
4538          this._reactName = reactName;
4539          this._targetInst = targetInst;
4540          this.type = reactEventType;
4541          this.nativeEvent = nativeEvent;
4542          this.target = nativeEventTarget;
4543          this.currentTarget = null;
4544          for (var propName in Interface)
4545            Interface.hasOwnProperty(propName) && (reactName = Interface[propName], this[propName] = reactName ? reactName(nativeEvent) : nativeEvent[propName]);
4546          this.isDefaultPrevented = (null != nativeEvent.defaultPrevented ? nativeEvent.defaultPrevented : false === nativeEvent.returnValue) ? functionThatReturnsTrue : functionThatReturnsFalse;
4547          this.isPropagationStopped = functionThatReturnsFalse;
4548          return this;
4549        }
4550        assign(SyntheticBaseEvent.prototype, {
4551          preventDefault: function() {
4552            this.defaultPrevented = true;
4553            var event = this.nativeEvent;
4554            event && (event.preventDefault ? event.preventDefault() : "unknown" !== typeof event.returnValue && (event.returnValue = false), this.isDefaultPrevented = functionThatReturnsTrue);
4555          },
4556          stopPropagation: function() {
4557            var event = this.nativeEvent;
4558            event && (event.stopPropagation ? event.stopPropagation() : "unknown" !== typeof event.cancelBubble && (event.cancelBubble = true), this.isPropagationStopped = functionThatReturnsTrue);
4559          },
4560          persist: function() {
4561          },
4562          isPersistent: functionThatReturnsTrue
4563        });
4564        return SyntheticBaseEvent;
4565      }
4566      function modifierStateGetter(keyArg) {
4567        var nativeEvent = this.nativeEvent;
4568        return nativeEvent.getModifierState ? nativeEvent.getModifierState(keyArg) : (keyArg = modifierKeyToProp[keyArg]) ? !!nativeEvent[keyArg] : false;
4569      }
4570      function getEventModifierState() {
4571        return modifierStateGetter;
4572      }
4573      function isFallbackCompositionEnd(domEventName, nativeEvent) {
4574        switch (domEventName) {
4575          case "keyup":
4576            return -1 !== END_KEYCODES.indexOf(nativeEvent.keyCode);
4577          case "keydown":
4578            return nativeEvent.keyCode !== START_KEYCODE;
4579          case "keypress":
4580          case "mousedown":
4581          case "focusout":
4582            return true;
4583          default:
4584            return false;
4585        }
4586      }
4587      function getDataFromCustomEvent(nativeEvent) {
4588        nativeEvent = nativeEvent.detail;
4589        return "object" === typeof nativeEvent && "data" in nativeEvent ? nativeEvent.data : null;
4590      }
4591      function getNativeBeforeInputChars(domEventName, nativeEvent) {
4592        switch (domEventName) {
4593          case "compositionend":
4594            return getDataFromCustomEvent(nativeEvent);
4595          case "keypress":
4596            if (nativeEvent.which !== SPACEBAR_CODE) return null;
4597            hasSpaceKeypress = true;
4598            return SPACEBAR_CHAR;
4599          case "textInput":
4600            return domEventName = nativeEvent.data, domEventName === SPACEBAR_CHAR && hasSpaceKeypress ? null : domEventName;
4601          default:
4602            return null;
4603        }
4604      }
4605      function getFallbackBeforeInputChars(domEventName, nativeEvent) {
4606        if (isComposing)
4607          return "compositionend" === domEventName || !canUseCompositionEvent && isFallbackCompositionEnd(domEventName, nativeEvent) ? (domEventName = getData(), fallbackText = startText = root2 = null, isComposing = false, domEventName) : null;
4608        switch (domEventName) {
4609          case "paste":
4610            return null;
4611          case "keypress":
4612            if (!(nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) || nativeEvent.ctrlKey && nativeEvent.altKey) {
4613              if (nativeEvent.char && 1 < nativeEvent.char.length)
4614                return nativeEvent.char;
4615              if (nativeEvent.which)
4616                return String.fromCharCode(nativeEvent.which);
4617            }
4618            return null;
4619          case "compositionend":
4620            return useFallbackCompositionData && "ko" !== nativeEvent.locale ? null : nativeEvent.data;
4621          default:
4622            return null;
4623        }
4624      }
4625      function isTextInputElement(elem) {
4626        var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
4627        return "input" === nodeName ? !!supportedInputTypes[elem.type] : "textarea" === nodeName ? true : false;
4628      }
4629      function isEventSupported(eventNameSuffix) {
4630        if (!canUseDOM) return false;
4631        eventNameSuffix = "on" + eventNameSuffix;
4632        var isSupported = eventNameSuffix in document;
4633        isSupported || (isSupported = document.createElement("div"), isSupported.setAttribute(eventNameSuffix, "return;"), isSupported = "function" === typeof isSupported[eventNameSuffix]);
4634        return isSupported;
4635      }
4636      function createAndAccumulateChangeEvent(dispatchQueue, inst, nativeEvent, target) {
4637        restoreTarget ? restoreQueue ? restoreQueue.push(target) : restoreQueue = [target] : restoreTarget = target;
4638        inst = accumulateTwoPhaseListeners(inst, "onChange");
4639        0 < inst.length && (nativeEvent = new SyntheticEvent(
4640          "onChange",
4641          "change",
4642          null,
4643          nativeEvent,
4644          target
4645        ), dispatchQueue.push({ event: nativeEvent, listeners: inst }));
4646      }
4647      function runEventInBatch(dispatchQueue) {
4648        processDispatchQueue(dispatchQueue, 0);
4649      }
4650      function getInstIfValueChanged(targetInst) {
4651        var targetNode = getNodeFromInstance(targetInst);
4652        if (updateValueIfChanged(targetNode)) return targetInst;
4653      }
4654      function getTargetInstForChangeEvent(domEventName, targetInst) {
4655        if ("change" === domEventName) return targetInst;
4656      }
4657      function stopWatchingForValueChange() {
4658        activeElement$1 && (activeElement$1.detachEvent("onpropertychange", handlePropertyChange), activeElementInst$1 = activeElement$1 = null);
4659      }
4660      function handlePropertyChange(nativeEvent) {
4661        if ("value" === nativeEvent.propertyName && getInstIfValueChanged(activeElementInst$1)) {
4662          var dispatchQueue = [];
4663          createAndAccumulateChangeEvent(
4664            dispatchQueue,
4665            activeElementInst$1,
4666            nativeEvent,
4667            getEventTarget(nativeEvent)
4668          );
4669          batchedUpdates$1(runEventInBatch, dispatchQueue);
4670        }
4671      }
4672      function handleEventsForInputEventPolyfill(domEventName, target, targetInst) {
4673        "focusin" === domEventName ? (stopWatchingForValueChange(), activeElement$1 = target, activeElementInst$1 = targetInst, activeElement$1.attachEvent("onpropertychange", handlePropertyChange)) : "focusout" === domEventName && stopWatchingForValueChange();
4674      }
4675      function getTargetInstForInputEventPolyfill(domEventName) {
4676        if ("selectionchange" === domEventName || "keyup" === domEventName || "keydown" === domEventName)
4677          return getInstIfValueChanged(activeElementInst$1);
4678      }
4679      function getTargetInstForClickEvent(domEventName, targetInst) {
4680        if ("click" === domEventName) return getInstIfValueChanged(targetInst);
4681      }
4682      function getTargetInstForInputOrChangeEvent(domEventName, targetInst) {
4683        if ("input" === domEventName || "change" === domEventName)
4684          return getInstIfValueChanged(targetInst);
4685      }
4686      function is3(x3, y3) {
4687        return x3 === y3 && (0 !== x3 || 1 / x3 === 1 / y3) || x3 !== x3 && y3 !== y3;
4688      }
4689      function shallowEqual(objA, objB) {
4690        if (objectIs(objA, objB)) return true;
4691        if ("object" !== typeof objA || null === objA || "object" !== typeof objB || null === objB)
4692          return false;
4693        var keysA = Object.keys(objA), keysB = Object.keys(objB);
4694        if (keysA.length !== keysB.length) return false;
4695        for (keysB = 0; keysB < keysA.length; keysB++) {
4696          var currentKey = keysA[keysB];
4697          if (!hasOwnProperty.call(objB, currentKey) || !objectIs(objA[currentKey], objB[currentKey]))
4698            return false;
4699        }
4700        return true;
4701      }
4702      function getLeafNode(node) {
4703        for (; node && node.firstChild; ) node = node.firstChild;
4704        return node;
4705      }
4706      function getNodeForCharacterOffset(root3, offset) {
4707        var node = getLeafNode(root3);
4708        root3 = 0;
4709        for (var nodeEnd; node; ) {
4710          if (3 === node.nodeType) {
4711            nodeEnd = root3 + node.textContent.length;
4712            if (root3 <= offset && nodeEnd >= offset)
4713              return { node, offset: offset - root3 };
4714            root3 = nodeEnd;
4715          }
4716          a: {
4717            for (; node; ) {
4718              if (node.nextSibling) {
4719                node = node.nextSibling;
4720                break a;
4721              }
4722              node = node.parentNode;
4723            }
4724            node = void 0;
4725          }
4726          node = getLeafNode(node);
4727        }
4728      }
4729      function containsNode(outerNode, innerNode) {
4730        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;
4731      }
4732      function getActiveElementDeep(containerInfo) {
4733        containerInfo = null != containerInfo && null != containerInfo.ownerDocument && null != containerInfo.ownerDocument.defaultView ? containerInfo.ownerDocument.defaultView : window;
4734        for (var element = getActiveElement(containerInfo.document); element instanceof containerInfo.HTMLIFrameElement; ) {
4735          try {
4736            var JSCompiler_inline_result = "string" === typeof element.contentWindow.location.href;
4737          } catch (err) {
4738            JSCompiler_inline_result = false;
4739          }
4740          if (JSCompiler_inline_result) containerInfo = element.contentWindow;
4741          else break;
4742          element = getActiveElement(containerInfo.document);
4743        }
4744        return element;
4745      }
4746      function hasSelectionCapabilities(elem) {
4747        var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
4748        return nodeName && ("input" === nodeName && ("text" === elem.type || "search" === elem.type || "tel" === elem.type || "url" === elem.type || "password" === elem.type) || "textarea" === nodeName || "true" === elem.contentEditable);
4749      }
4750      function constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget) {
4751        var doc = nativeEventTarget.window === nativeEventTarget ? nativeEventTarget.document : 9 === nativeEventTarget.nodeType ? nativeEventTarget : nativeEventTarget.ownerDocument;
4752        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 = {
4753          anchorNode: doc.anchorNode,
4754          anchorOffset: doc.anchorOffset,
4755          focusNode: doc.focusNode,
4756          focusOffset: doc.focusOffset
4757        }), lastSelection && shallowEqual(lastSelection, doc) || (lastSelection = doc, doc = accumulateTwoPhaseListeners(activeElementInst, "onSelect"), 0 < doc.length && (nativeEvent = new SyntheticEvent(
4758          "onSelect",
4759          "select",
4760          null,
4761          nativeEvent,
4762          nativeEventTarget
4763        ), dispatchQueue.push({ event: nativeEvent, listeners: doc }), nativeEvent.target = activeElement)));
4764      }
4765      function makePrefixMap(styleProp, eventName) {
4766        var prefixes = {};
4767        prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();
4768        prefixes["Webkit" + styleProp] = "webkit" + eventName;
4769        prefixes["Moz" + styleProp] = "moz" + eventName;
4770        return prefixes;
4771      }
4772      function getVendorPrefixedEventName(eventName) {
4773        if (prefixedEventNames[eventName]) return prefixedEventNames[eventName];
4774        if (!vendorPrefixes[eventName]) return eventName;
4775        var prefixMap = vendorPrefixes[eventName], styleProp;
4776        for (styleProp in prefixMap)
4777          if (prefixMap.hasOwnProperty(styleProp) && styleProp in style)
4778            return prefixedEventNames[eventName] = prefixMap[styleProp];
4779        return eventName;
4780      }
4781      function registerSimpleEvent(domEventName, reactName) {
4782        topLevelEventsToReactNames.set(domEventName, reactName);
4783        registerTwoPhaseEvent(reactName, [domEventName]);
4784      }
4785      function getArrayKind(array) {
4786        for (var kind = EMPTY_ARRAY, i3 = 0; i3 < array.length; i3++) {
4787          var value = array[i3];
4788          if ("object" === typeof value && null !== value)
4789            if (isArrayImpl(value) && 2 === value.length && "string" === typeof value[0]) {
4790              if (kind !== EMPTY_ARRAY && kind !== ENTRIES_ARRAY)
4791                return COMPLEX_ARRAY;
4792              kind = ENTRIES_ARRAY;
4793            } else return COMPLEX_ARRAY;
4794          else {
4795            if ("function" === typeof value || "string" === typeof value && 50 < value.length || kind !== EMPTY_ARRAY && kind !== PRIMITIVE_ARRAY)
4796              return COMPLEX_ARRAY;
4797            kind = PRIMITIVE_ARRAY;
4798          }
4799        }
4800        return kind;
4801      }
4802      function addObjectToProperties(object, properties, indent, prefix2) {
4803        for (var key in object)
4804          hasOwnProperty.call(object, key) && "_" !== key[0] && addValueToProperties(key, object[key], properties, indent, prefix2);
4805      }
4806      function addValueToProperties(propertyName, value, properties, indent, prefix2) {
4807        switch (typeof value) {
4808          case "object":
4809            if (null === value) {
4810              value = "null";
4811              break;
4812            } else {
4813              if (value.$$typeof === REACT_ELEMENT_TYPE) {
4814                var typeName2 = getComponentNameFromType(value.type) || "\u2026", key = value.key;
4815                value = value.props;
4816                var propsKeys = Object.keys(value), propsLength = propsKeys.length;
4817                if (null == key && 0 === propsLength) {
4818                  value = "<" + typeName2 + " />";
4819                  break;
4820                }
4821                if (3 > indent || 1 === propsLength && "children" === propsKeys[0] && null == key) {
4822                  value = "<" + typeName2 + " \u2026 />";
4823                  break;
4824                }
4825                properties.push([
4826                  prefix2 + "\xA0\xA0".repeat(indent) + propertyName,
4827                  "<" + typeName2
4828                ]);
4829                null !== key && addValueToProperties(
4830                  "key",
4831                  key,
4832                  properties,
4833                  indent + 1,
4834                  prefix2
4835                );
4836                propertyName = false;
4837                for (var propKey in value)
4838                  "children" === propKey ? null != value.children && (!isArrayImpl(value.children) || 0 < value.children.length) && (propertyName = true) : hasOwnProperty.call(value, propKey) && "_" !== propKey[0] && addValueToProperties(
4839                    propKey,
4840                    value[propKey],
4841                    properties,
4842                    indent + 1,
4843                    prefix2
4844                  );
4845                properties.push([
4846                  "",
4847                  propertyName ? ">\u2026</" + typeName2 + ">" : "/>"
4848                ]);
4849                return;
4850              }
4851              typeName2 = Object.prototype.toString.call(value);
4852              typeName2 = typeName2.slice(8, typeName2.length - 1);
4853              if ("Array" === typeName2) {
4854                if (propKey = getArrayKind(value), propKey === PRIMITIVE_ARRAY || propKey === EMPTY_ARRAY) {
4855                  value = JSON.stringify(value);
4856                  break;
4857                } else if (propKey === ENTRIES_ARRAY) {
4858                  properties.push([
4859                    prefix2 + "\xA0\xA0".repeat(indent) + propertyName,
4860                    ""
4861                  ]);
4862                  for (propertyName = 0; propertyName < value.length; propertyName++)
4863                    typeName2 = value[propertyName], addValueToProperties(
4864                      typeName2[0],
4865                      typeName2[1],
4866                      properties,
4867                      indent + 1,
4868                      prefix2
4869                    );
4870                  return;
4871                }
4872              }
4873              if ("Promise" === typeName2) {
4874                if ("fulfilled" === value.status) {
4875                  if (typeName2 = properties.length, addValueToProperties(
4876                    propertyName,
4877                    value.value,
4878                    properties,
4879                    indent,
4880                    prefix2
4881                  ), properties.length > typeName2) {
4882                    properties = properties[typeName2];
4883                    properties[1] = "Promise<" + (properties[1] || "Object") + ">";
4884                    return;
4885                  }
4886                } else if ("rejected" === value.status && (typeName2 = properties.length, addValueToProperties(
4887                  propertyName,
4888                  value.reason,
4889                  properties,
4890                  indent,
4891                  prefix2
4892                ), properties.length > typeName2)) {
4893                  properties = properties[typeName2];
4894                  properties[1] = "Rejected Promise<" + properties[1] + ">";
4895                  return;
4896                }
4897                properties.push([
4898                  "\xA0\xA0".repeat(indent) + propertyName,
4899                  "Promise"
4900                ]);
4901                return;
4902              }
4903              "Object" === typeName2 && (propKey = Object.getPrototypeOf(value)) && "function" === typeof propKey.constructor && (typeName2 = propKey.constructor.name);
4904              properties.push([
4905                prefix2 + "\xA0\xA0".repeat(indent) + propertyName,
4906                "Object" === typeName2 ? 3 > indent ? "" : "\u2026" : typeName2
4907              ]);
4908              3 > indent && addObjectToProperties(value, properties, indent + 1, prefix2);
4909              return;
4910            }
4911          case "function":
4912            value = "" === value.name ? "() => {}" : value.name + "() {}";
4913            break;
4914          case "string":
4915            value = value === OMITTED_PROP_ERROR ? "\u2026" : JSON.stringify(value);
4916            break;
4917          case "undefined":
4918            value = "undefined";
4919            break;
4920          case "boolean":
4921            value = value ? "true" : "false";
4922            break;
4923          default:
4924            value = String(value);
4925        }
4926        properties.push([
4927          prefix2 + "\xA0\xA0".repeat(indent) + propertyName,
4928          value
4929        ]);
4930      }
4931      function addObjectDiffToProperties(prev, next, properties, indent) {
4932        var isDeeplyEqual = true;
4933        for (key in prev)
4934          key in next || (properties.push([
4935            REMOVED + "\xA0\xA0".repeat(indent) + key,
4936            "\u2026"
4937          ]), isDeeplyEqual = false);
4938        for (var _key in next)
4939          if (_key in prev) {
4940            var key = prev[_key];
4941            var nextValue = next[_key];
4942            if (key !== nextValue) {
4943              if (0 === indent && "children" === _key)
4944                isDeeplyEqual = "\xA0\xA0".repeat(indent) + _key, properties.push(
4945                  [REMOVED + isDeeplyEqual, "\u2026"],
4946                  [ADDED + isDeeplyEqual, "\u2026"]
4947                );
4948              else {
4949                if (!(3 <= indent)) {
4950                  if ("object" === typeof key && "object" === typeof nextValue && null !== key && null !== nextValue && key.$$typeof === nextValue.$$typeof)
4951                    if (nextValue.$$typeof === REACT_ELEMENT_TYPE) {
4952                      if (key.type === nextValue.type && key.key === nextValue.key) {
4953                        key = getComponentNameFromType(nextValue.type) || "\u2026";
4954                        isDeeplyEqual = "\xA0\xA0".repeat(indent) + _key;
4955                        key = "<" + key + " \u2026 />";
4956                        properties.push(
4957                          [REMOVED + isDeeplyEqual, key],
4958                          [ADDED + isDeeplyEqual, key]
4959                        );
4960                        isDeeplyEqual = false;
4961                        continue;
4962                      }
4963                    } else {
4964                      var prevKind = Object.prototype.toString.call(key), nextKind = Object.prototype.toString.call(nextValue);
4965                      if (prevKind === nextKind && ("[object Object]" === nextKind || "[object Array]" === nextKind)) {
4966                        prevKind = [
4967                          UNCHANGED + "\xA0\xA0".repeat(indent) + _key,
4968                          "[object Array]" === nextKind ? "Array" : ""
4969                        ];
4970                        properties.push(prevKind);
4971                        nextKind = properties.length;
4972                        addObjectDiffToProperties(
4973                          key,
4974                          nextValue,
4975                          properties,
4976                          indent + 1
4977                        ) ? nextKind === properties.length && (prevKind[1] = "Referentially unequal but deeply equal objects. Consider memoization.") : isDeeplyEqual = false;
4978                        continue;
4979                      }
4980                    }
4981                  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)) {
4982                    key = "" === nextValue.name ? "() => {}" : nextValue.name + "() {}";
4983                    properties.push([
4984                      UNCHANGED + "\xA0\xA0".repeat(indent) + _key,
4985                      key + " Referentially unequal function closure. Consider memoization."
4986                    ]);
4987                    continue;
4988                  }
4989                }
4990                addValueToProperties(_key, key, properties, indent, REMOVED);
4991                addValueToProperties(_key, nextValue, properties, indent, ADDED);
4992              }
4993              isDeeplyEqual = false;
4994            }
4995          } else
4996            properties.push([
4997              ADDED + "\xA0\xA0".repeat(indent) + _key,
4998              "\u2026"
4999            ]), isDeeplyEqual = false;
5000        return isDeeplyEqual;
5001      }
5002      function setCurrentTrackFromLanes(lanes) {
5003        currentTrack = lanes & 63 ? "Blocking" : lanes & 64 ? "Gesture" : lanes & 4194176 ? "Transition" : lanes & 62914560 ? "Suspense" : lanes & 2080374784 ? "Idle" : "Other";
5004      }
5005      function logComponentTrigger(fiber, startTime, endTime, trigger) {
5006        supportsUserTiming && (reusableComponentOptions.start = startTime, reusableComponentOptions.end = endTime, reusableComponentDevToolDetails.color = "warning", reusableComponentDevToolDetails.tooltipText = trigger, reusableComponentDevToolDetails.properties = null, (fiber = fiber._debugTask) ? fiber.run(
5007          performance.measure.bind(
5008            performance,
5009            trigger,
5010            reusableComponentOptions
5011          )
5012        ) : performance.measure(trigger, reusableComponentOptions));
5013      }
5014      function logComponentReappeared(fiber, startTime, endTime) {
5015        logComponentTrigger(fiber, startTime, endTime, "Reconnect");
5016      }
5017      function logComponentRender(fiber, startTime, endTime, wasHydrated, committedLanes) {
5018        var name = getComponentNameFromFiber(fiber);
5019        if (null !== name && supportsUserTiming) {
5020          var alternate = fiber.alternate, selfTime = fiber.actualDuration;
5021          if (null === alternate || alternate.child !== fiber.child)
5022            for (var child = fiber.child; null !== child; child = child.sibling)
5023              selfTime -= child.actualDuration;
5024          wasHydrated = 0.5 > selfTime ? wasHydrated ? "tertiary-light" : "primary-light" : 10 > selfTime ? wasHydrated ? "tertiary" : "primary" : 100 > selfTime ? wasHydrated ? "tertiary-dark" : "primary-dark" : "error";
5025          var props = fiber.memoizedProps;
5026          selfTime = fiber._debugTask;
5027          null !== props && null !== alternate && alternate.memoizedProps !== props ? (child = [resuableChangedPropsEntry], props = addObjectDiffToProperties(
5028            alternate.memoizedProps,
5029            props,
5030            child,
5031            0
5032          ), 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(
5033            performance.measure.bind(
5034              performance,
5035              "\u200B" + name,
5036              reusableComponentOptions
5037            )
5038          ) : performance.measure(
5039            "\u200B" + name,
5040            reusableComponentOptions
5041          ))) : null != selfTime ? selfTime.run(
5042            console.timeStamp.bind(
5043              console,
5044              name,
5045              startTime,
5046              endTime,
5047              COMPONENTS_TRACK,
5048              void 0,
5049              wasHydrated
5050            )
5051          ) : console.timeStamp(
5052            name,
5053            startTime,
5054            endTime,
5055            COMPONENTS_TRACK,
5056            void 0,
5057            wasHydrated
5058          );
5059        }
5060      }
5061      function logComponentErrored(fiber, startTime, endTime, errors) {
5062        if (supportsUserTiming) {
5063          var name = getComponentNameFromFiber(fiber);
5064          if (null !== name) {
5065            for (var debugTask = null, properties = [], i3 = 0; i3 < errors.length; i3++) {
5066              var capturedValue = errors[i3];
5067              null == debugTask && null !== capturedValue.source && (debugTask = capturedValue.source._debugTask);
5068              capturedValue = capturedValue.value;
5069              properties.push([
5070                "Error",
5071                "object" === typeof capturedValue && null !== capturedValue && "string" === typeof capturedValue.message ? String(capturedValue.message) : String(capturedValue)
5072              ]);
5073            }
5074            null !== fiber.key && addValueToProperties("key", fiber.key, properties, 0, "");
5075            null !== fiber.memoizedProps && addObjectToProperties(fiber.memoizedProps, properties, 0, "");
5076            null == debugTask && (debugTask = fiber._debugTask);
5077            fiber = {
5078              start: startTime,
5079              end: endTime,
5080              detail: {
5081                devtools: {
5082                  color: "error",
5083                  track: COMPONENTS_TRACK,
5084                  tooltipText: 13 === fiber.tag ? "Hydration failed" : "Error boundary caught an error",
5085                  properties
5086                }
5087              }
5088            };
5089            debugTask ? debugTask.run(
5090              performance.measure.bind(performance, "\u200B" + name, fiber)
5091            ) : performance.measure("\u200B" + name, fiber);
5092          }
5093        }
5094      }
5095      function logComponentEffect(fiber, startTime, endTime, selfTime, errors) {
5096        if (null !== errors) {
5097          if (supportsUserTiming) {
5098            var name = getComponentNameFromFiber(fiber);
5099            if (null !== name) {
5100              selfTime = [];
5101              for (var i3 = 0; i3 < errors.length; i3++) {
5102                var error2 = errors[i3].value;
5103                selfTime.push([
5104                  "Error",
5105                  "object" === typeof error2 && null !== error2 && "string" === typeof error2.message ? String(error2.message) : String(error2)
5106                ]);
5107              }
5108              null !== fiber.key && addValueToProperties("key", fiber.key, selfTime, 0, "");
5109              null !== fiber.memoizedProps && addObjectToProperties(fiber.memoizedProps, selfTime, 0, "");
5110              startTime = {
5111                start: startTime,
5112                end: endTime,
5113                detail: {
5114                  devtools: {
5115                    color: "error",
5116                    track: COMPONENTS_TRACK,
5117                    tooltipText: "A lifecycle or effect errored",
5118                    properties: selfTime
5119                  }
5120                }
5121              };
5122              (fiber = fiber._debugTask) ? fiber.run(
5123                performance.measure.bind(
5124                  performance,
5125                  "\u200B" + name,
5126                  startTime
5127                )
5128              ) : performance.measure("\u200B" + name, startTime);
5129            }
5130          }
5131        } else
5132          name = getComponentNameFromFiber(fiber), null !== name && supportsUserTiming && (errors = 1 > selfTime ? "secondary-light" : 100 > selfTime ? "secondary" : 500 > selfTime ? "secondary-dark" : "error", (fiber = fiber._debugTask) ? fiber.run(
5133            console.timeStamp.bind(
5134              console,
5135              name,
5136              startTime,
5137              endTime,
5138              COMPONENTS_TRACK,
5139              void 0,
5140              errors
5141            )
5142          ) : console.timeStamp(
5143            name,
5144            startTime,
5145            endTime,
5146            COMPONENTS_TRACK,
5147            void 0,
5148            errors
5149          ));
5150      }
5151      function logRenderPhase(startTime, endTime, lanes, debugTask) {
5152        if (supportsUserTiming && !(endTime <= startTime)) {
5153          var color = (lanes & 738197653) === lanes ? "tertiary-dark" : "primary-dark";
5154          lanes = (lanes & 536870912) === lanes ? "Prepared" : (lanes & 201326741) === lanes ? "Hydrated" : "Render";
5155          debugTask ? debugTask.run(
5156            console.timeStamp.bind(
5157              console,
5158              lanes,
5159              startTime,
5160              endTime,
5161              currentTrack,
5162              LANES_TRACK_GROUP,
5163              color
5164            )
5165          ) : console.timeStamp(
5166            lanes,
5167            startTime,
5168            endTime,
5169            currentTrack,
5170            LANES_TRACK_GROUP,
5171            color
5172          );
5173        }
5174      }
5175      function logSuspendedRenderPhase(startTime, endTime, lanes, debugTask) {
5176        !supportsUserTiming || endTime <= startTime || (lanes = (lanes & 738197653) === lanes ? "tertiary-dark" : "primary-dark", debugTask ? debugTask.run(
5177          console.timeStamp.bind(
5178            console,
5179            "Prewarm",
5180            startTime,
5181            endTime,
5182            currentTrack,
5183            LANES_TRACK_GROUP,
5184            lanes
5185          )
5186        ) : console.timeStamp(
5187          "Prewarm",
5188          startTime,
5189          endTime,
5190          currentTrack,
5191          LANES_TRACK_GROUP,
5192          lanes
5193        ));
5194      }
5195      function logSuspendedWithDelayPhase(startTime, endTime, lanes, debugTask) {
5196        !supportsUserTiming || endTime <= startTime || (lanes = (lanes & 738197653) === lanes ? "tertiary-dark" : "primary-dark", debugTask ? debugTask.run(
5197          console.timeStamp.bind(
5198            console,
5199            "Suspended",
5200            startTime,
5201            endTime,
5202            currentTrack,
5203            LANES_TRACK_GROUP,
5204            lanes
5205          )
5206        ) : console.timeStamp(
5207          "Suspended",
5208          startTime,
5209          endTime,
5210          currentTrack,
5211          LANES_TRACK_GROUP,
5212          lanes
5213        ));
5214      }
5215      function logRecoveredRenderPhase(startTime, endTime, lanes, recoverableErrors, hydrationFailed, debugTask) {
5216        if (supportsUserTiming && !(endTime <= startTime)) {
5217          lanes = [];
5218          for (var i3 = 0; i3 < recoverableErrors.length; i3++) {
5219            var error2 = recoverableErrors[i3].value;
5220            lanes.push([
5221              "Recoverable Error",
5222              "object" === typeof error2 && null !== error2 && "string" === typeof error2.message ? String(error2.message) : String(error2)
5223            ]);
5224          }
5225          startTime = {
5226            start: startTime,
5227            end: endTime,
5228            detail: {
5229              devtools: {
5230                color: "primary-dark",
5231                track: currentTrack,
5232                trackGroup: LANES_TRACK_GROUP,
5233                tooltipText: hydrationFailed ? "Hydration Failed" : "Recovered after Error",
5234                properties: lanes
5235              }
5236            }
5237          };
5238          debugTask ? debugTask.run(
5239            performance.measure.bind(performance, "Recovered", startTime)
5240          ) : performance.measure("Recovered", startTime);
5241        }
5242      }
5243      function logErroredRenderPhase(startTime, endTime, lanes, debugTask) {
5244        !supportsUserTiming || endTime <= startTime || (debugTask ? debugTask.run(
5245          console.timeStamp.bind(
5246            console,
5247            "Errored",
5248            startTime,
5249            endTime,
5250            currentTrack,
5251            LANES_TRACK_GROUP,
5252            "error"
5253          )
5254        ) : console.timeStamp(
5255          "Errored",
5256          startTime,
5257          endTime,
5258          currentTrack,
5259          LANES_TRACK_GROUP,
5260          "error"
5261        ));
5262      }
5263      function logSuspendedCommitPhase(startTime, endTime, reason, debugTask) {
5264        !supportsUserTiming || endTime <= startTime || (debugTask ? debugTask.run(
5265          console.timeStamp.bind(
5266            console,
5267            reason,
5268            startTime,
5269            endTime,
5270            currentTrack,
5271            LANES_TRACK_GROUP,
5272            "secondary-light"
5273          )
5274        ) : console.timeStamp(
5275          reason,
5276          startTime,
5277          endTime,
5278          currentTrack,
5279          LANES_TRACK_GROUP,
5280          "secondary-light"
5281        ));
5282      }
5283      function logCommitErrored(startTime, endTime, errors, passive, debugTask) {
5284        if (supportsUserTiming && !(endTime <= startTime)) {
5285          for (var properties = [], i3 = 0; i3 < errors.length; i3++) {
5286            var error2 = errors[i3].value;
5287            properties.push([
5288              "Error",
5289              "object" === typeof error2 && null !== error2 && "string" === typeof error2.message ? String(error2.message) : String(error2)
5290            ]);
5291          }
5292          startTime = {
5293            start: startTime,
5294            end: endTime,
5295            detail: {
5296              devtools: {
5297                color: "error",
5298                track: currentTrack,
5299                trackGroup: LANES_TRACK_GROUP,
5300                tooltipText: passive ? "Remaining Effects Errored" : "Commit Errored",
5301                properties
5302              }
5303            }
5304          };
5305          debugTask ? debugTask.run(
5306            performance.measure.bind(performance, "Errored", startTime)
5307          ) : performance.measure("Errored", startTime);
5308        }
5309      }
5310      function logAnimatingPhase(startTime, endTime, debugTask) {
5311        !supportsUserTiming || endTime <= startTime || (debugTask ? debugTask.run(
5312          console.timeStamp.bind(
5313            console,
5314            "Animating",
5315            startTime,
5316            endTime,
5317            currentTrack,
5318            LANES_TRACK_GROUP,
5319            "secondary-dark"
5320          )
5321        ) : console.timeStamp(
5322          "Animating",
5323          startTime,
5324          endTime,
5325          currentTrack,
5326          LANES_TRACK_GROUP,
5327          "secondary-dark"
5328        ));
5329      }
5330      function finishQueueingConcurrentUpdates() {
5331        for (var endIndex = concurrentQueuesIndex, i3 = concurrentlyUpdatedLanes = concurrentQueuesIndex = 0; i3 < endIndex; ) {
5332          var fiber = concurrentQueues[i3];
5333          concurrentQueues[i3++] = null;
5334          var queue = concurrentQueues[i3];
5335          concurrentQueues[i3++] = null;
5336          var update = concurrentQueues[i3];
5337          concurrentQueues[i3++] = null;
5338          var lane = concurrentQueues[i3];
5339          concurrentQueues[i3++] = null;
5340          if (null !== queue && null !== update) {
5341            var pending = queue.pending;
5342            null === pending ? update.next = update : (update.next = pending.next, pending.next = update);
5343            queue.pending = update;
5344          }
5345          0 !== lane && markUpdateLaneFromFiberToRoot(fiber, update, lane);
5346        }
5347      }
5348      function enqueueUpdate$1(fiber, queue, update, lane) {
5349        concurrentQueues[concurrentQueuesIndex++] = fiber;
5350        concurrentQueues[concurrentQueuesIndex++] = queue;
5351        concurrentQueues[concurrentQueuesIndex++] = update;
5352        concurrentQueues[concurrentQueuesIndex++] = lane;
5353        concurrentlyUpdatedLanes |= lane;
5354        fiber.lanes |= lane;
5355        fiber = fiber.alternate;
5356        null !== fiber && (fiber.lanes |= lane);
5357      }
5358      function enqueueConcurrentHookUpdate(fiber, queue, update, lane) {
5359        enqueueUpdate$1(fiber, queue, update, lane);
5360        return getRootForUpdatedFiber(fiber);
5361      }
5362      function enqueueConcurrentRenderForLane(fiber, lane) {
5363        enqueueUpdate$1(fiber, null, null, lane);
5364        return getRootForUpdatedFiber(fiber);
5365      }
5366      function markUpdateLaneFromFiberToRoot(sourceFiber, update, lane) {
5367        sourceFiber.lanes |= lane;
5368        var alternate = sourceFiber.alternate;
5369        null !== alternate && (alternate.lanes |= lane);
5370        for (var isHidden = false, parent = sourceFiber.return; null !== parent; )
5371          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;
5372        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;
5373      }
5374      function getRootForUpdatedFiber(sourceFiber) {
5375        if (nestedUpdateCount > NESTED_UPDATE_LIMIT)
5376          throw nestedPassiveUpdateCount = nestedUpdateCount = 0, rootWithPassiveNestedUpdates = rootWithNestedUpdates = null, Error(
5377            "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."
5378          );
5379        nestedPassiveUpdateCount > NESTED_PASSIVE_UPDATE_LIMIT && (nestedPassiveUpdateCount = 0, rootWithPassiveNestedUpdates = null, console.error(
5380          "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."
5381        ));
5382        null === sourceFiber.alternate && 0 !== (sourceFiber.flags & 4098) && warnAboutUpdateOnNotYetMountedFiberInDEV(sourceFiber);
5383        for (var node = sourceFiber, parent = node.return; null !== parent; )
5384          null === node.alternate && 0 !== (node.flags & 4098) && warnAboutUpdateOnNotYetMountedFiberInDEV(sourceFiber), node = parent, parent = node.return;
5385        return 3 === node.tag ? node.stateNode : null;
5386      }
5387      function resolveFunctionForHotReloading(type) {
5388        if (null === resolveFamily) return type;
5389        var family = resolveFamily(type);
5390        return void 0 === family ? type : family.current;
5391      }
5392      function resolveForwardRefForHotReloading(type) {
5393        if (null === resolveFamily) return type;
5394        var family = resolveFamily(type);
5395        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;
5396      }
5397      function isCompatibleFamilyForHotReloading(fiber, element) {
5398        if (null === resolveFamily) return false;
5399        var prevType = fiber.elementType;
5400        element = element.type;
5401        var needsCompareFamilies = false, $$typeofNextType = "object" === typeof element && null !== element ? element.$$typeof : null;
5402        switch (fiber.tag) {
5403          case 1:
5404            "function" === typeof element && (needsCompareFamilies = true);
5405            break;
5406          case 0:
5407            "function" === typeof element ? needsCompareFamilies = true : $$typeofNextType === REACT_LAZY_TYPE && (needsCompareFamilies = true);
5408            break;
5409          case 11:
5410            $$typeofNextType === REACT_FORWARD_REF_TYPE ? needsCompareFamilies = true : $$typeofNextType === REACT_LAZY_TYPE && (needsCompareFamilies = true);
5411            break;
5412          case 14:
5413          case 15:
5414            $$typeofNextType === REACT_MEMO_TYPE ? needsCompareFamilies = true : $$typeofNextType === REACT_LAZY_TYPE && (needsCompareFamilies = true);
5415            break;
5416          default:
5417            return false;
5418        }
5419        return needsCompareFamilies && (fiber = resolveFamily(prevType), void 0 !== fiber && fiber === resolveFamily(element)) ? true : false;
5420      }
5421      function markFailedErrorBoundaryForHotReloading(fiber) {
5422        null !== resolveFamily && "function" === typeof WeakSet && (null === failedBoundaries && (failedBoundaries = /* @__PURE__ */ new WeakSet()), failedBoundaries.add(fiber));
5423      }
5424      function scheduleFibersWithFamiliesRecursively(fiber, updatedFamilies, staleFamilies) {
5425        do {
5426          var _fiber = fiber, alternate = _fiber.alternate, child = _fiber.child, sibling = _fiber.sibling, tag = _fiber.tag;
5427          _fiber = _fiber.type;
5428          var candidateType = null;
5429          switch (tag) {
5430            case 0:
5431            case 15:
5432            case 1:
5433              candidateType = _fiber;
5434              break;
5435            case 11:
5436              candidateType = _fiber.render;
5437          }
5438          if (null === resolveFamily)
5439            throw Error("Expected resolveFamily to be set during hot reload.");
5440          var needsRender = false;
5441          _fiber = false;
5442          null !== candidateType && (candidateType = resolveFamily(candidateType), void 0 !== candidateType && (staleFamilies.has(candidateType) ? _fiber = true : updatedFamilies.has(candidateType) && (1 === tag ? _fiber = true : needsRender = true)));
5443          null !== failedBoundaries && (failedBoundaries.has(fiber) || null !== alternate && failedBoundaries.has(alternate)) && (_fiber = true);
5444          _fiber && (fiber._debugNeedsRemount = true);
5445          if (_fiber || needsRender)
5446            alternate = enqueueConcurrentRenderForLane(fiber, 2), null !== alternate && scheduleUpdateOnFiber(alternate, fiber, 2);
5447          null === child || _fiber || scheduleFibersWithFamiliesRecursively(
5448            child,
5449            updatedFamilies,
5450            staleFamilies
5451          );
5452          if (null === sibling) break;
5453          fiber = sibling;
5454        } while (1);
5455      }
5456      function FiberNode(tag, pendingProps, key, mode2) {
5457        this.tag = tag;
5458        this.key = key;
5459        this.sibling = this.child = this.return = this.stateNode = this.type = this.elementType = null;
5460        this.index = 0;
5461        this.refCleanup = this.ref = null;
5462        this.pendingProps = pendingProps;
5463        this.dependencies = this.memoizedState = this.updateQueue = this.memoizedProps = null;
5464        this.mode = mode2;
5465        this.subtreeFlags = this.flags = 0;
5466        this.deletions = null;
5467        this.childLanes = this.lanes = 0;
5468        this.alternate = null;
5469        this.actualDuration = -0;
5470        this.actualStartTime = -1.1;
5471        this.treeBaseDuration = this.selfBaseDuration = -0;
5472        this._debugTask = this._debugStack = this._debugOwner = this._debugInfo = null;
5473        this._debugNeedsRemount = false;
5474        this._debugHookTypes = null;
5475        hasBadMapPolyfill || "function" !== typeof Object.preventExtensions || Object.preventExtensions(this);
5476      }
5477      function shouldConstruct(Component) {
5478        Component = Component.prototype;
5479        return !(!Component || !Component.isReactComponent);
5480      }
5481      function createWorkInProgress(current2, pendingProps) {
5482        var workInProgress2 = current2.alternate;
5483        null === workInProgress2 ? (workInProgress2 = createFiber(
5484          current2.tag,
5485          pendingProps,
5486          current2.key,
5487          current2.mode
5488        ), 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);
5489        workInProgress2.flags = current2.flags & 65011712;
5490        workInProgress2.childLanes = current2.childLanes;
5491        workInProgress2.lanes = current2.lanes;
5492        workInProgress2.child = current2.child;
5493        workInProgress2.memoizedProps = current2.memoizedProps;
5494        workInProgress2.memoizedState = current2.memoizedState;
5495        workInProgress2.updateQueue = current2.updateQueue;
5496        pendingProps = current2.dependencies;
5497        workInProgress2.dependencies = null === pendingProps ? null : {
5498          lanes: pendingProps.lanes,
5499          firstContext: pendingProps.firstContext,
5500          _debugThenableState: pendingProps._debugThenableState
5501        };
5502        workInProgress2.sibling = current2.sibling;
5503        workInProgress2.index = current2.index;
5504        workInProgress2.ref = current2.ref;
5505        workInProgress2.refCleanup = current2.refCleanup;
5506        workInProgress2.selfBaseDuration = current2.selfBaseDuration;
5507        workInProgress2.treeBaseDuration = current2.treeBaseDuration;
5508        workInProgress2._debugInfo = current2._debugInfo;
5509        workInProgress2._debugNeedsRemount = current2._debugNeedsRemount;
5510        switch (workInProgress2.tag) {
5511          case 0:
5512          case 15:
5513            workInProgress2.type = resolveFunctionForHotReloading(current2.type);
5514            break;
5515          case 1:
5516            workInProgress2.type = resolveFunctionForHotReloading(current2.type);
5517            break;
5518          case 11:
5519            workInProgress2.type = resolveForwardRefForHotReloading(current2.type);
5520        }
5521        return workInProgress2;
5522      }
5523      function resetWorkInProgress(workInProgress2, renderLanes2) {
5524        workInProgress2.flags &= 65011714;
5525        var current2 = workInProgress2.alternate;
5526        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 : {
5527          lanes: renderLanes2.lanes,
5528          firstContext: renderLanes2.firstContext,
5529          _debugThenableState: renderLanes2._debugThenableState
5530        }, workInProgress2.selfBaseDuration = current2.selfBaseDuration, workInProgress2.treeBaseDuration = current2.treeBaseDuration);
5531        return workInProgress2;
5532      }
5533      function createFiberFromTypeAndProps(type, key, pendingProps, owner, mode2, lanes) {
5534        var fiberTag = 0, resolvedType = type;
5535        if ("function" === typeof type)
5536          shouldConstruct(type) && (fiberTag = 1), resolvedType = resolveFunctionForHotReloading(resolvedType);
5537        else if ("string" === typeof type)
5538          fiberTag = getHostContext(), fiberTag = isHostHoistableType(type, pendingProps, fiberTag) ? 26 : "html" === type || "head" === type || "body" === type ? 27 : 5;
5539        else
5540          a: switch (type) {
5541            case REACT_ACTIVITY_TYPE:
5542              return key = createFiber(31, pendingProps, key, mode2), key.elementType = REACT_ACTIVITY_TYPE, key.lanes = lanes, key;
5543            case REACT_FRAGMENT_TYPE:
5544              return createFiberFromFragment(
5545                pendingProps.children,
5546                mode2,
5547                lanes,
5548                key
5549              );
5550            case REACT_STRICT_MODE_TYPE:
5551              fiberTag = 8;
5552              mode2 |= StrictLegacyMode;
5553              mode2 |= StrictEffectsMode;
5554              break;
5555            case REACT_PROFILER_TYPE:
5556              return type = pendingProps, owner = mode2, "string" !== typeof type.id && console.error(
5557                'Profiler must specify an "id" of type `string` as a prop. Received the type `%s` instead.',
5558                typeof type.id
5559              ), key = createFiber(12, type, key, owner | ProfileMode), key.elementType = REACT_PROFILER_TYPE, key.lanes = lanes, key.stateNode = { effectDuration: 0, passiveEffectDuration: 0 }, key;
5560            case REACT_SUSPENSE_TYPE:
5561              return key = createFiber(13, pendingProps, key, mode2), key.elementType = REACT_SUSPENSE_TYPE, key.lanes = lanes, key;
5562            case REACT_SUSPENSE_LIST_TYPE:
5563              return key = createFiber(19, pendingProps, key, mode2), key.elementType = REACT_SUSPENSE_LIST_TYPE, key.lanes = lanes, key;
5564            default:
5565              if ("object" === typeof type && null !== type)
5566                switch (type.$$typeof) {
5567                  case REACT_CONTEXT_TYPE:
5568                    fiberTag = 10;
5569                    break a;
5570                  case REACT_CONSUMER_TYPE:
5571                    fiberTag = 9;
5572                    break a;
5573                  case REACT_FORWARD_REF_TYPE:
5574                    fiberTag = 11;
5575                    resolvedType = resolveForwardRefForHotReloading(resolvedType);
5576                    break a;
5577                  case REACT_MEMO_TYPE:
5578                    fiberTag = 14;
5579                    break a;
5580                  case REACT_LAZY_TYPE:
5581                    fiberTag = 16;
5582                    resolvedType = null;
5583                    break a;
5584                }
5585              resolvedType = "";
5586              if (void 0 === type || "object" === typeof type && null !== type && 0 === Object.keys(type).length)
5587                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.";
5588              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;
5589              (fiberTag = owner ? getComponentNameFromOwner(owner) : null) && (resolvedType += "\n\nCheck the render method of `" + fiberTag + "`.");
5590              fiberTag = 29;
5591              pendingProps = Error(
5592                "Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: " + (pendingProps + "." + resolvedType)
5593              );
5594              resolvedType = null;
5595          }
5596        key = createFiber(fiberTag, pendingProps, key, mode2);
5597        key.elementType = type;
5598        key.type = resolvedType;
5599        key.lanes = lanes;
5600        key._debugOwner = owner;
5601        return key;
5602      }
5603      function createFiberFromElement(element, mode2, lanes) {
5604        mode2 = createFiberFromTypeAndProps(
5605          element.type,
5606          element.key,
5607          element.props,
5608          element._owner,
5609          mode2,
5610          lanes
5611        );
5612        mode2._debugOwner = element._owner;
5613        mode2._debugStack = element._debugStack;
5614        mode2._debugTask = element._debugTask;
5615        return mode2;
5616      }
5617      function createFiberFromFragment(elements, mode2, lanes, key) {
5618        elements = createFiber(7, elements, key, mode2);
5619        elements.lanes = lanes;
5620        return elements;
5621      }
5622      function createFiberFromText(content, mode2, lanes) {
5623        content = createFiber(6, content, null, mode2);
5624        content.lanes = lanes;
5625        return content;
5626      }
5627      function createFiberFromDehydratedFragment(dehydratedNode) {
5628        var fiber = createFiber(18, null, null, NoMode);
5629        fiber.stateNode = dehydratedNode;
5630        return fiber;
5631      }
5632      function createFiberFromPortal(portal, mode2, lanes) {
5633        mode2 = createFiber(
5634          4,
5635          null !== portal.children ? portal.children : [],
5636          portal.key,
5637          mode2
5638        );
5639        mode2.lanes = lanes;
5640        mode2.stateNode = {
5641          containerInfo: portal.containerInfo,
5642          pendingChildren: null,
5643          implementation: portal.implementation
5644        };
5645        return mode2;
5646      }
5647      function createCapturedValueAtFiber(value, source) {
5648        if ("object" === typeof value && null !== value) {
5649          var existing = CapturedStacks.get(value);
5650          if (void 0 !== existing) return existing;
5651          source = {
5652            value,
5653            source,
5654            stack: getStackByFiberInDevAndProd(source)
5655          };
5656          CapturedStacks.set(value, source);
5657          return source;
5658        }
5659        return {
5660          value,
5661          source,
5662          stack: getStackByFiberInDevAndProd(source)
5663        };
5664      }
5665      function pushTreeFork(workInProgress2, totalChildren) {
5666        warnIfNotHydrating();
5667        forkStack[forkStackIndex++] = treeForkCount;
5668        forkStack[forkStackIndex++] = treeForkProvider;
5669        treeForkProvider = workInProgress2;
5670        treeForkCount = totalChildren;
5671      }
5672      function pushTreeId(workInProgress2, totalChildren, index) {
5673        warnIfNotHydrating();
5674        idStack[idStackIndex++] = treeContextId;
5675        idStack[idStackIndex++] = treeContextOverflow;
5676        idStack[idStackIndex++] = treeContextProvider;
5677        treeContextProvider = workInProgress2;
5678        var baseIdWithLeadingBit = treeContextId;
5679        workInProgress2 = treeContextOverflow;
5680        var baseLength = 32 - clz32(baseIdWithLeadingBit) - 1;
5681        baseIdWithLeadingBit &= ~(1 << baseLength);
5682        index += 1;
5683        var length = 32 - clz32(totalChildren) + baseLength;
5684        if (30 < length) {
5685          var numberOfOverflowBits = baseLength - baseLength % 5;
5686          length = (baseIdWithLeadingBit & (1 << numberOfOverflowBits) - 1).toString(32);
5687          baseIdWithLeadingBit >>= numberOfOverflowBits;
5688          baseLength -= numberOfOverflowBits;
5689          treeContextId = 1 << 32 - clz32(totalChildren) + baseLength | index << baseLength | baseIdWithLeadingBit;
5690          treeContextOverflow = length + workInProgress2;
5691        } else
5692          treeContextId = 1 << length | index << baseLength | baseIdWithLeadingBit, treeContextOverflow = workInProgress2;
5693      }
5694      function pushMaterializedTreeId(workInProgress2) {
5695        warnIfNotHydrating();
5696        null !== workInProgress2.return && (pushTreeFork(workInProgress2, 1), pushTreeId(workInProgress2, 1, 0));
5697      }
5698      function popTreeContext(workInProgress2) {
5699        for (; workInProgress2 === treeForkProvider; )
5700          treeForkProvider = forkStack[--forkStackIndex], forkStack[forkStackIndex] = null, treeForkCount = forkStack[--forkStackIndex], forkStack[forkStackIndex] = null;
5701        for (; workInProgress2 === treeContextProvider; )
5702          treeContextProvider = idStack[--idStackIndex], idStack[idStackIndex] = null, treeContextOverflow = idStack[--idStackIndex], idStack[idStackIndex] = null, treeContextId = idStack[--idStackIndex], idStack[idStackIndex] = null;
5703      }
5704      function getSuspendedTreeContext() {
5705        warnIfNotHydrating();
5706        return null !== treeContextProvider ? { id: treeContextId, overflow: treeContextOverflow } : null;
5707      }
5708      function restoreSuspendedTreeContext(workInProgress2, suspendedContext) {
5709        warnIfNotHydrating();
5710        idStack[idStackIndex++] = treeContextId;
5711        idStack[idStackIndex++] = treeContextOverflow;
5712        idStack[idStackIndex++] = treeContextProvider;
5713        treeContextId = suspendedContext.id;
5714        treeContextOverflow = suspendedContext.overflow;
5715        treeContextProvider = workInProgress2;
5716      }
5717      function warnIfNotHydrating() {
5718        isHydrating || console.error(
5719          "Expected to be hydrating. This is a bug in React. Please file an issue."
5720        );
5721      }
5722      function buildHydrationDiffNode(fiber, distanceFromLeaf) {
5723        if (null === fiber.return) {
5724          if (null === hydrationDiffRootDEV)
5725            hydrationDiffRootDEV = {
5726              fiber,
5727              children: [],
5728              serverProps: void 0,
5729              serverTail: [],
5730              distanceFromLeaf
5731            };
5732          else {
5733            if (hydrationDiffRootDEV.fiber !== fiber)
5734              throw Error(
5735                "Saw multiple hydration diff roots in a pass. This is a bug in React."
5736              );
5737            hydrationDiffRootDEV.distanceFromLeaf > distanceFromLeaf && (hydrationDiffRootDEV.distanceFromLeaf = distanceFromLeaf);
5738          }
5739          return hydrationDiffRootDEV;
5740        }
5741        var siblings = buildHydrationDiffNode(
5742          fiber.return,
5743          distanceFromLeaf + 1
5744        ).children;
5745        if (0 < siblings.length && siblings[siblings.length - 1].fiber === fiber)
5746          return siblings = siblings[siblings.length - 1], siblings.distanceFromLeaf > distanceFromLeaf && (siblings.distanceFromLeaf = distanceFromLeaf), siblings;
5747        distanceFromLeaf = {
5748          fiber,
5749          children: [],
5750          serverProps: void 0,
5751          serverTail: [],
5752          distanceFromLeaf
5753        };
5754        siblings.push(distanceFromLeaf);
5755        return distanceFromLeaf;
5756      }
5757      function warnIfHydrating() {
5758        isHydrating && console.error(
5759          "We should not be hydrating here. This is a bug in React. Please file a bug."
5760        );
5761      }
5762      function warnNonHydratedInstance(fiber, rejectedCandidate) {
5763        didSuspendOrErrorDEV || (fiber = buildHydrationDiffNode(fiber, 0), fiber.serverProps = null, null !== rejectedCandidate && (rejectedCandidate = describeHydratableInstanceForDevWarnings(rejectedCandidate), fiber.serverTail.push(rejectedCandidate)));
5764      }
5765      function throwOnHydrationMismatch(fiber) {
5766        var fromText = 1 < arguments.length && void 0 !== arguments[1] ? arguments[1] : false, diff = "", diffRoot = hydrationDiffRootDEV;
5767        null !== diffRoot && (hydrationDiffRootDEV = null, diff = describeDiff(diffRoot));
5768        queueHydrationError(
5769          createCapturedValueAtFiber(
5770            Error(
5771              "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
5772            ),
5773            fiber
5774          )
5775        );
5776        throw HydrationMismatchException;
5777      }
5778      function prepareToHydrateHostInstance(fiber) {
5779        var didHydrate = fiber.stateNode;
5780        var type = fiber.type, props = fiber.memoizedProps;
5781        didHydrate[internalInstanceKey] = fiber;
5782        didHydrate[internalPropsKey] = props;
5783        validatePropertiesInDevelopment(type, props);
5784        switch (type) {
5785          case "dialog":
5786            listenToNonDelegatedEvent("cancel", didHydrate);
5787            listenToNonDelegatedEvent("close", didHydrate);
5788            break;
5789          case "iframe":
5790          case "object":
5791          case "embed":
5792            listenToNonDelegatedEvent("load", didHydrate);
5793            break;
5794          case "video":
5795          case "audio":
5796            for (type = 0; type < mediaEventTypes.length; type++)
5797              listenToNonDelegatedEvent(mediaEventTypes[type], didHydrate);
5798            break;
5799          case "source":
5800            listenToNonDelegatedEvent("error", didHydrate);
5801            break;
5802          case "img":
5803          case "image":
5804          case "link":
5805            listenToNonDelegatedEvent("error", didHydrate);
5806            listenToNonDelegatedEvent("load", didHydrate);
5807            break;
5808          case "details":
5809            listenToNonDelegatedEvent("toggle", didHydrate);
5810            break;
5811          case "input":
5812            checkControlledValueProps("input", props);
5813            listenToNonDelegatedEvent("invalid", didHydrate);
5814            validateInputProps(didHydrate, props);
5815            initInput(
5816              didHydrate,
5817              props.value,
5818              props.defaultValue,
5819              props.checked,
5820              props.defaultChecked,
5821              props.type,
5822              props.name,
5823              true
5824            );
5825            break;
5826          case "option":
5827            validateOptionProps(didHydrate, props);
5828            break;
5829          case "select":
5830            checkControlledValueProps("select", props);
5831            listenToNonDelegatedEvent("invalid", didHydrate);
5832            validateSelectProps(didHydrate, props);
5833            break;
5834          case "textarea":
5835            checkControlledValueProps("textarea", props), listenToNonDelegatedEvent("invalid", didHydrate), validateTextareaProps(didHydrate, props), initTextarea(
5836              didHydrate,
5837              props.value,
5838              props.defaultValue,
5839              props.children
5840            );
5841        }
5842        type = props.children;
5843        "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;
5844        didHydrate || throwOnHydrationMismatch(fiber, true);
5845      }
5846      function popToNextHostParent(fiber) {
5847        for (hydrationParentFiber = fiber.return; hydrationParentFiber; )
5848          switch (hydrationParentFiber.tag) {
5849            case 5:
5850            case 31:
5851            case 13:
5852              rootOrSingletonContext = false;
5853              return;
5854            case 27:
5855            case 3:
5856              rootOrSingletonContext = true;
5857              return;
5858            default:
5859              hydrationParentFiber = hydrationParentFiber.return;
5860          }
5861      }
5862      function popHydrationState(fiber) {
5863        if (fiber !== hydrationParentFiber) return false;
5864        if (!isHydrating)
5865          return popToNextHostParent(fiber), isHydrating = true, false;
5866        var tag = fiber.tag, JSCompiler_temp;
5867        if (JSCompiler_temp = 3 !== tag && 27 !== tag) {
5868          if (JSCompiler_temp = 5 === tag)
5869            JSCompiler_temp = fiber.type, JSCompiler_temp = !("form" !== JSCompiler_temp && "button" !== JSCompiler_temp) || shouldSetTextContent(fiber.type, fiber.memoizedProps);
5870          JSCompiler_temp = !JSCompiler_temp;
5871        }
5872        if (JSCompiler_temp && nextHydratableInstance) {
5873          for (JSCompiler_temp = nextHydratableInstance; JSCompiler_temp; ) {
5874            var diffNode = buildHydrationDiffNode(fiber, 0), description = describeHydratableInstanceForDevWarnings(JSCompiler_temp);
5875            diffNode.serverTail.push(description);
5876            JSCompiler_temp = "Suspense" === description.type ? getNextHydratableInstanceAfterHydrationBoundary(JSCompiler_temp) : getNextHydratable(JSCompiler_temp.nextSibling);
5877          }
5878          throwOnHydrationMismatch(fiber);
5879        }
5880        popToNextHostParent(fiber);
5881        if (13 === tag) {
5882          fiber = fiber.memoizedState;
5883          fiber = null !== fiber ? fiber.dehydrated : null;
5884          if (!fiber)
5885            throw Error(
5886              "Expected to have a hydrated suspense instance. This error is likely caused by a bug in React. Please file an issue."
5887            );
5888          nextHydratableInstance = getNextHydratableInstanceAfterHydrationBoundary(fiber);
5889        } else if (31 === tag) {
5890          fiber = fiber.memoizedState;
5891          fiber = null !== fiber ? fiber.dehydrated : null;
5892          if (!fiber)
5893            throw Error(
5894              "Expected to have a hydrated suspense instance. This error is likely caused by a bug in React. Please file an issue."
5895            );
5896          nextHydratableInstance = getNextHydratableInstanceAfterHydrationBoundary(fiber);
5897        } else
5898          27 === tag ? (tag = nextHydratableInstance, isSingletonScope(fiber.type) ? (fiber = previousHydratableOnEnteringScopedSingleton, previousHydratableOnEnteringScopedSingleton = null, nextHydratableInstance = fiber) : nextHydratableInstance = tag) : nextHydratableInstance = hydrationParentFiber ? getNextHydratable(fiber.stateNode.nextSibling) : null;
5899        return true;
5900      }
5901      function resetHydrationState() {
5902        nextHydratableInstance = hydrationParentFiber = null;
5903        didSuspendOrErrorDEV = isHydrating = false;
5904      }
5905      function upgradeHydrationErrorsToRecoverable() {
5906        var queuedErrors = hydrationErrors;
5907        null !== queuedErrors && (null === workInProgressRootRecoverableErrors ? workInProgressRootRecoverableErrors = queuedErrors : workInProgressRootRecoverableErrors.push.apply(
5908          workInProgressRootRecoverableErrors,
5909          queuedErrors
5910        ), hydrationErrors = null);
5911        return queuedErrors;
5912      }
5913      function queueHydrationError(error2) {
5914        null === hydrationErrors ? hydrationErrors = [error2] : hydrationErrors.push(error2);
5915      }
5916      function emitPendingHydrationWarnings() {
5917        var diffRoot = hydrationDiffRootDEV;
5918        if (null !== diffRoot) {
5919          hydrationDiffRootDEV = null;
5920          for (var diff = describeDiff(diffRoot); 0 < diffRoot.children.length; )
5921            diffRoot = diffRoot.children[0];
5922          runWithFiberInDEV(diffRoot.fiber, function() {
5923            console.error(
5924              "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",
5925              "https://react.dev/link/hydration-mismatch",
5926              diff
5927            );
5928          });
5929        }
5930      }
5931      function resetContextDependencies() {
5932        lastContextDependency = currentlyRenderingFiber$1 = null;
5933        isDisallowedContextReadInDEV = false;
5934      }
5935      function pushProvider(providerFiber, context, nextValue) {
5936        push(valueCursor, context._currentValue, providerFiber);
5937        context._currentValue = nextValue;
5938        push(rendererCursorDEV, context._currentRenderer, providerFiber);
5939        void 0 !== context._currentRenderer && null !== context._currentRenderer && context._currentRenderer !== rendererSigil && console.error(
5940          "Detected multiple renderers concurrently rendering the same context provider. This is currently unsupported."
5941        );
5942        context._currentRenderer = rendererSigil;
5943      }
5944      function popProvider(context, providerFiber) {
5945        context._currentValue = valueCursor.current;
5946        var currentRenderer = rendererCursorDEV.current;
5947        pop(rendererCursorDEV, providerFiber);
5948        context._currentRenderer = currentRenderer;
5949        pop(valueCursor, providerFiber);
5950      }
5951      function scheduleContextWorkOnParentPath(parent, renderLanes2, propagationRoot) {
5952        for (; null !== parent; ) {
5953          var alternate = parent.alternate;
5954          (parent.childLanes & renderLanes2) !== renderLanes2 ? (parent.childLanes |= renderLanes2, null !== alternate && (alternate.childLanes |= renderLanes2)) : null !== alternate && (alternate.childLanes & renderLanes2) !== renderLanes2 && (alternate.childLanes |= renderLanes2);
5955          if (parent === propagationRoot) break;
5956          parent = parent.return;
5957        }
5958        parent !== propagationRoot && console.error(
5959          "Expected to find the propagation root when scheduling context work. This error is likely caused by a bug in React. Please file an issue."
5960        );
5961      }
5962      function propagateContextChanges(workInProgress2, contexts, renderLanes2, forcePropagateEntireTree) {
5963        var fiber = workInProgress2.child;
5964        null !== fiber && (fiber.return = workInProgress2);
5965        for (; null !== fiber; ) {
5966          var list = fiber.dependencies;
5967          if (null !== list) {
5968            var nextFiber = fiber.child;
5969            list = list.firstContext;
5970            a: for (; null !== list; ) {
5971              var dependency = list;
5972              list = fiber;
5973              for (var i3 = 0; i3 < contexts.length; i3++)
5974                if (dependency.context === contexts[i3]) {
5975                  list.lanes |= renderLanes2;
5976                  dependency = list.alternate;
5977                  null !== dependency && (dependency.lanes |= renderLanes2);
5978                  scheduleContextWorkOnParentPath(
5979                    list.return,
5980                    renderLanes2,
5981                    workInProgress2
5982                  );
5983                  forcePropagateEntireTree || (nextFiber = null);
5984                  break a;
5985                }
5986              list = dependency.next;
5987            }
5988          } else if (18 === fiber.tag) {
5989            nextFiber = fiber.return;
5990            if (null === nextFiber)
5991              throw Error(
5992                "We just came from a parent so we must have had a parent. This is a bug in React."
5993              );
5994            nextFiber.lanes |= renderLanes2;
5995            list = nextFiber.alternate;
5996            null !== list && (list.lanes |= renderLanes2);
5997            scheduleContextWorkOnParentPath(
5998              nextFiber,
5999              renderLanes2,
6000              workInProgress2
6001            );
6002            nextFiber = null;
6003          } else nextFiber = fiber.child;
6004          if (null !== nextFiber) nextFiber.return = fiber;
6005          else
6006            for (nextFiber = fiber; null !== nextFiber; ) {
6007              if (nextFiber === workInProgress2) {
6008                nextFiber = null;
6009                break;
6010              }
6011              fiber = nextFiber.sibling;
6012              if (null !== fiber) {
6013                fiber.return = nextFiber.return;
6014                nextFiber = fiber;
6015                break;
6016              }
6017              nextFiber = nextFiber.return;
6018            }
6019          fiber = nextFiber;
6020        }
6021      }
6022      function propagateParentContextChanges(current2, workInProgress2, renderLanes2, forcePropagateEntireTree) {
6023        current2 = null;
6024        for (var parent = workInProgress2, isInsidePropagationBailout = false; null !== parent; ) {
6025          if (!isInsidePropagationBailout) {
6026            if (0 !== (parent.flags & 524288)) isInsidePropagationBailout = true;
6027            else if (0 !== (parent.flags & 262144)) break;
6028          }
6029          if (10 === parent.tag) {
6030            var currentParent = parent.alternate;
6031            if (null === currentParent)
6032              throw Error("Should have a current fiber. This is a bug in React.");
6033            currentParent = currentParent.memoizedProps;
6034            if (null !== currentParent) {
6035              var context = parent.type;
6036              objectIs(parent.pendingProps.value, currentParent.value) || (null !== current2 ? current2.push(context) : current2 = [context]);
6037            }
6038          } else if (parent === hostTransitionProviderCursor.current) {
6039            currentParent = parent.alternate;
6040            if (null === currentParent)
6041              throw Error("Should have a current fiber. This is a bug in React.");
6042            currentParent.memoizedState.memoizedState !== parent.memoizedState.memoizedState && (null !== current2 ? current2.push(HostTransitionContext) : current2 = [HostTransitionContext]);
6043          }
6044          parent = parent.return;
6045        }
6046        null !== current2 && propagateContextChanges(
6047          workInProgress2,
6048          current2,
6049          renderLanes2,
6050          forcePropagateEntireTree
6051        );
6052        workInProgress2.flags |= 262144;
6053      }
6054      function checkIfContextChanged(currentDependencies) {
6055        for (currentDependencies = currentDependencies.firstContext; null !== currentDependencies; ) {
6056          if (!objectIs(
6057            currentDependencies.context._currentValue,
6058            currentDependencies.memoizedValue
6059          ))
6060            return true;
6061          currentDependencies = currentDependencies.next;
6062        }
6063        return false;
6064      }
6065      function prepareToReadContext(workInProgress2) {
6066        currentlyRenderingFiber$1 = workInProgress2;
6067        lastContextDependency = null;
6068        workInProgress2 = workInProgress2.dependencies;
6069        null !== workInProgress2 && (workInProgress2.firstContext = null);
6070      }
6071      function readContext(context) {
6072        isDisallowedContextReadInDEV && console.error(
6073          "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()."
6074        );
6075        return readContextForConsumer(currentlyRenderingFiber$1, context);
6076      }
6077      function readContextDuringReconciliation(consumer2, context) {
6078        null === currentlyRenderingFiber$1 && prepareToReadContext(consumer2);
6079        return readContextForConsumer(consumer2, context);
6080      }
6081      function readContextForConsumer(consumer2, context) {
6082        var value = context._currentValue;
6083        context = { context, memoizedValue: value, next: null };
6084        if (null === lastContextDependency) {
6085          if (null === consumer2)
6086            throw Error(
6087              "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()."
6088            );
6089          lastContextDependency = context;
6090          consumer2.dependencies = {
6091            lanes: 0,
6092            firstContext: context,
6093            _debugThenableState: null
6094          };
6095          consumer2.flags |= 524288;
6096        } else lastContextDependency = lastContextDependency.next = context;
6097        return value;
6098      }
6099      function createCache() {
6100        return {
6101          controller: new AbortControllerLocal(),
6102          data: /* @__PURE__ */ new Map(),
6103          refCount: 0
6104        };
6105      }
6106      function retainCache(cache2) {
6107        cache2.controller.signal.aborted && console.warn(
6108          "A cache instance was retained after it was already freed. This likely indicates a bug in React."
6109        );
6110        cache2.refCount++;
6111      }
6112      function releaseCache(cache2) {
6113        cache2.refCount--;
6114        0 > cache2.refCount && console.warn(
6115          "A cache instance was released after it was already freed. This likely indicates a bug in React."
6116        );
6117        0 === cache2.refCount && scheduleCallback$2(NormalPriority, function() {
6118          cache2.controller.abort();
6119        });
6120      }
6121      function startUpdateTimerByLane(lane, method, fiber) {
6122        if (0 !== (lane & 127))
6123          0 > blockingUpdateTime && (blockingUpdateTime = now3(), 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);
6124        else if (0 !== (lane & 4194048) && 0 > transitionUpdateTime && (transitionUpdateTime = now3(), transitionUpdateTask = createTask(method), transitionUpdateMethodName = method, null != fiber && (transitionUpdateComponentName = getComponentNameFromFiber(fiber)), 0 > transitionStartTime)) {
6125          lane = resolveEventTimeStamp();
6126          method = resolveEventType();
6127          if (lane !== transitionEventRepeatTime || method !== transitionEventType)
6128            transitionEventRepeatTime = -1.1;
6129          transitionEventTime = lane;
6130          transitionEventType = method;
6131        }
6132      }
6133      function startHostActionTimer(fiber) {
6134        if (0 > blockingUpdateTime) {
6135          blockingUpdateTime = now3();
6136          blockingUpdateTask = null != fiber._debugTask ? fiber._debugTask : null;
6137          (executionContext & (RenderContext | CommitContext)) !== NoContext && (blockingUpdateType = SPAWNED_UPDATE);
6138          var newEventTime = resolveEventTimeStamp(), newEventType = resolveEventType();
6139          newEventTime !== blockingEventRepeatTime || newEventType !== blockingEventType ? blockingEventRepeatTime = -1.1 : null !== newEventType && (blockingUpdateType = SPAWNED_UPDATE);
6140          blockingEventTime = newEventTime;
6141          blockingEventType = newEventType;
6142        }
6143        if (0 > transitionUpdateTime && (transitionUpdateTime = now3(), transitionUpdateTask = null != fiber._debugTask ? fiber._debugTask : null, 0 > transitionStartTime)) {
6144          fiber = resolveEventTimeStamp();
6145          newEventTime = resolveEventType();
6146          if (fiber !== transitionEventRepeatTime || newEventTime !== transitionEventType)
6147            transitionEventRepeatTime = -1.1;
6148          transitionEventTime = fiber;
6149          transitionEventType = newEventTime;
6150        }
6151      }
6152      function pushNestedEffectDurations() {
6153        var prevEffectDuration = profilerEffectDuration;
6154        profilerEffectDuration = 0;
6155        return prevEffectDuration;
6156      }
6157      function popNestedEffectDurations(prevEffectDuration) {
6158        var elapsedTime = profilerEffectDuration;
6159        profilerEffectDuration = prevEffectDuration;
6160        return elapsedTime;
6161      }
6162      function bubbleNestedEffectDurations(prevEffectDuration) {
6163        var elapsedTime = profilerEffectDuration;
6164        profilerEffectDuration += prevEffectDuration;
6165        return elapsedTime;
6166      }
6167      function resetComponentEffectTimers() {
6168        componentEffectEndTime = componentEffectStartTime = -1.1;
6169      }
6170      function pushComponentEffectStart() {
6171        var prevEffectStart = componentEffectStartTime;
6172        componentEffectStartTime = -1.1;
6173        return prevEffectStart;
6174      }
6175      function popComponentEffectStart(prevEffectStart) {
6176        0 <= prevEffectStart && (componentEffectStartTime = prevEffectStart);
6177      }
6178      function pushComponentEffectDuration() {
6179        var prevEffectDuration = componentEffectDuration;
6180        componentEffectDuration = -0;
6181        return prevEffectDuration;
6182      }
6183      function popComponentEffectDuration(prevEffectDuration) {
6184        0 <= prevEffectDuration && (componentEffectDuration = prevEffectDuration);
6185      }
6186      function pushComponentEffectErrors() {
6187        var prevErrors = componentEffectErrors;
6188        componentEffectErrors = null;
6189        return prevErrors;
6190      }
6191      function pushComponentEffectDidSpawnUpdate() {
6192        var prev = componentEffectSpawnedUpdate;
6193        componentEffectSpawnedUpdate = false;
6194        return prev;
6195      }
6196      function startProfilerTimer(fiber) {
6197        profilerStartTime = now3();
6198        0 > fiber.actualStartTime && (fiber.actualStartTime = profilerStartTime);
6199      }
6200      function stopProfilerTimerIfRunningAndRecordDuration(fiber) {
6201        if (0 <= profilerStartTime) {
6202          var elapsedTime = now3() - profilerStartTime;
6203          fiber.actualDuration += elapsedTime;
6204          fiber.selfBaseDuration = elapsedTime;
6205          profilerStartTime = -1;
6206        }
6207      }
6208      function stopProfilerTimerIfRunningAndRecordIncompleteDuration(fiber) {
6209        if (0 <= profilerStartTime) {
6210          var elapsedTime = now3() - profilerStartTime;
6211          fiber.actualDuration += elapsedTime;
6212          profilerStartTime = -1;
6213        }
6214      }
6215      function recordEffectDuration() {
6216        if (0 <= profilerStartTime) {
6217          var endTime = now3(), elapsedTime = endTime - profilerStartTime;
6218          profilerStartTime = -1;
6219          profilerEffectDuration += elapsedTime;
6220          componentEffectDuration += elapsedTime;
6221          componentEffectEndTime = endTime;
6222        }
6223      }
6224      function recordEffectError(errorInfo) {
6225        null === componentEffectErrors && (componentEffectErrors = []);
6226        componentEffectErrors.push(errorInfo);
6227        null === commitErrors && (commitErrors = []);
6228        commitErrors.push(errorInfo);
6229      }
6230      function startEffectTimer() {
6231        profilerStartTime = now3();
6232        0 > componentEffectStartTime && (componentEffectStartTime = profilerStartTime);
6233      }
6234      function transferActualDuration(fiber) {
6235        for (var child = fiber.child; child; )
6236          fiber.actualDuration += child.actualDuration, child = child.sibling;
6237      }
6238      function entangleAsyncAction(transition, thenable) {
6239        if (null === currentEntangledListeners) {
6240          var entangledListeners = currentEntangledListeners = [];
6241          currentEntangledPendingCount = 0;
6242          currentEntangledLane = requestTransitionLane();
6243          currentEntangledActionThenable = {
6244            status: "pending",
6245            value: void 0,
6246            then: function(resolve) {
6247              entangledListeners.push(resolve);
6248            }
6249          };
6250        }
6251        currentEntangledPendingCount++;
6252        thenable.then(pingEngtangledActionScope, pingEngtangledActionScope);
6253        return thenable;
6254      }
6255      function pingEngtangledActionScope() {
6256        if (0 === --currentEntangledPendingCount && (-1 < transitionUpdateTime || (transitionStartTime = -1.1), null !== currentEntangledListeners)) {
6257          null !== currentEntangledActionThenable && (currentEntangledActionThenable.status = "fulfilled");
6258          var listeners = currentEntangledListeners;
6259          currentEntangledListeners = null;
6260          currentEntangledLane = 0;
6261          currentEntangledActionThenable = null;
6262          for (var i3 = 0; i3 < listeners.length; i3++) (0, listeners[i3])();
6263        }
6264      }
6265      function chainThenableValue(thenable, result) {
6266        var listeners = [], thenableWithOverride = {
6267          status: "pending",
6268          value: null,
6269          reason: null,
6270          then: function(resolve) {
6271            listeners.push(resolve);
6272          }
6273        };
6274        thenable.then(
6275          function() {
6276            thenableWithOverride.status = "fulfilled";
6277            thenableWithOverride.value = result;
6278            for (var i3 = 0; i3 < listeners.length; i3++) (0, listeners[i3])(result);
6279          },
6280          function(error2) {
6281            thenableWithOverride.status = "rejected";
6282            thenableWithOverride.reason = error2;
6283            for (error2 = 0; error2 < listeners.length; error2++)
6284              (0, listeners[error2])(void 0);
6285          }
6286        );
6287        return thenableWithOverride;
6288      }
6289      function peekCacheFromPool() {
6290        var cacheResumedFromPreviousRender = resumedCache.current;
6291        return null !== cacheResumedFromPreviousRender ? cacheResumedFromPreviousRender : workInProgressRoot.pooledCache;
6292      }
6293      function pushTransition(offscreenWorkInProgress, prevCachePool) {
6294        null === prevCachePool ? push(resumedCache, resumedCache.current, offscreenWorkInProgress) : push(resumedCache, prevCachePool.pool, offscreenWorkInProgress);
6295      }
6296      function getSuspendedCache() {
6297        var cacheFromPool = peekCacheFromPool();
6298        return null === cacheFromPool ? null : { parent: CacheContext._currentValue, pool: cacheFromPool };
6299      }
6300      function createThenableState() {
6301        return { didWarnAboutUncachedPromise: false, thenables: [] };
6302      }
6303      function isThenableResolved(thenable) {
6304        thenable = thenable.status;
6305        return "fulfilled" === thenable || "rejected" === thenable;
6306      }
6307      function trackUsedThenable(thenableState2, thenable, index) {
6308        null !== ReactSharedInternals.actQueue && (ReactSharedInternals.didUsePromise = true);
6309        var trackedThenables = thenableState2.thenables;
6310        index = trackedThenables[index];
6311        void 0 === index ? trackedThenables.push(thenable) : index !== thenable && (thenableState2.didWarnAboutUncachedPromise || (thenableState2.didWarnAboutUncachedPromise = true, console.error(
6312          "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."
6313        )), thenable.then(noop$1, noop$1), thenable = index);
6314        if (void 0 === thenable._debugInfo) {
6315          thenableState2 = performance.now();
6316          trackedThenables = thenable.displayName;
6317          var ioInfo = {
6318            name: "string" === typeof trackedThenables ? trackedThenables : "Promise",
6319            start: thenableState2,
6320            end: thenableState2,
6321            value: thenable
6322          };
6323          thenable._debugInfo = [{ awaited: ioInfo }];
6324          "fulfilled" !== thenable.status && "rejected" !== thenable.status && (thenableState2 = function() {
6325            ioInfo.end = performance.now();
6326          }, thenable.then(thenableState2, thenableState2));
6327        }
6328        switch (thenable.status) {
6329          case "fulfilled":
6330            return thenable.value;
6331          case "rejected":
6332            throw thenableState2 = thenable.reason, checkIfUseWrappedInAsyncCatch(thenableState2), thenableState2;
6333          default:
6334            if ("string" === typeof thenable.status)
6335              thenable.then(noop$1, noop$1);
6336            else {
6337              thenableState2 = workInProgressRoot;
6338              if (null !== thenableState2 && 100 < thenableState2.shellSuspendCounter)
6339                throw Error(
6340                  "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."
6341                );
6342              thenableState2 = thenable;
6343              thenableState2.status = "pending";
6344              thenableState2.then(
6345                function(fulfilledValue) {
6346                  if ("pending" === thenable.status) {
6347                    var fulfilledThenable = thenable;
6348                    fulfilledThenable.status = "fulfilled";
6349                    fulfilledThenable.value = fulfilledValue;
6350                  }
6351                },
6352                function(error2) {
6353                  if ("pending" === thenable.status) {
6354                    var rejectedThenable = thenable;
6355                    rejectedThenable.status = "rejected";
6356                    rejectedThenable.reason = error2;
6357                  }
6358                }
6359              );
6360            }
6361            switch (thenable.status) {
6362              case "fulfilled":
6363                return thenable.value;
6364              case "rejected":
6365                throw thenableState2 = thenable.reason, checkIfUseWrappedInAsyncCatch(thenableState2), thenableState2;
6366            }
6367            suspendedThenable = thenable;
6368            needsToResetSuspendedThenableDEV = true;
6369            throw SuspenseException;
6370        }
6371      }
6372      function resolveLazy(lazyType) {
6373        try {
6374          return callLazyInitInDEV(lazyType);
6375        } catch (x3) {
6376          if (null !== x3 && "object" === typeof x3 && "function" === typeof x3.then)
6377            throw suspendedThenable = x3, needsToResetSuspendedThenableDEV = true, SuspenseException;
6378          throw x3;
6379        }
6380      }
6381      function getSuspendedThenable() {
6382        if (null === suspendedThenable)
6383          throw Error(
6384            "Expected a suspended thenable. This is a bug in React. Please file an issue."
6385          );
6386        var thenable = suspendedThenable;
6387        suspendedThenable = null;
6388        needsToResetSuspendedThenableDEV = false;
6389        return thenable;
6390      }
6391      function checkIfUseWrappedInAsyncCatch(rejectedReason) {
6392        if (rejectedReason === SuspenseException || rejectedReason === SuspenseActionException)
6393          throw Error(
6394            "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."
6395          );
6396      }
6397      function pushDebugInfo(debugInfo) {
6398        var previousDebugInfo = currentDebugInfo;
6399        null != debugInfo && (currentDebugInfo = null === previousDebugInfo ? debugInfo : previousDebugInfo.concat(debugInfo));
6400        return previousDebugInfo;
6401      }
6402      function getCurrentDebugTask() {
6403        var debugInfo = currentDebugInfo;
6404        if (null != debugInfo) {
6405          for (var i3 = debugInfo.length - 1; 0 <= i3; i3--)
6406            if (null != debugInfo[i3].name) {
6407              var debugTask = debugInfo[i3].debugTask;
6408              if (null != debugTask) return debugTask;
6409            }
6410        }
6411        return null;
6412      }
6413      function validateFragmentProps(element, fiber, returnFiber) {
6414        for (var keys = Object.keys(element.props), i3 = 0; i3 < keys.length; i3++) {
6415          var key = keys[i3];
6416          if ("children" !== key && "key" !== key) {
6417            null === fiber && (fiber = createFiberFromElement(element, returnFiber.mode, 0), fiber._debugInfo = currentDebugInfo, fiber.return = returnFiber);
6418            runWithFiberInDEV(
6419              fiber,
6420              function(erroredKey) {
6421                console.error(
6422                  "Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.",
6423                  erroredKey
6424                );
6425              },
6426              key
6427            );
6428            break;
6429          }
6430        }
6431      }
6432      function unwrapThenable(thenable) {
6433        var index = thenableIndexCounter$1;
6434        thenableIndexCounter$1 += 1;
6435        null === thenableState$1 && (thenableState$1 = createThenableState());
6436        return trackUsedThenable(thenableState$1, thenable, index);
6437      }
6438      function coerceRef(workInProgress2, element) {
6439        element = element.props.ref;
6440        workInProgress2.ref = void 0 !== element ? element : null;
6441      }
6442      function throwOnInvalidObjectTypeImpl(returnFiber, newChild) {
6443        if (newChild.$$typeof === REACT_LEGACY_ELEMENT_TYPE)
6444          throw Error(
6445            '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.'
6446          );
6447        returnFiber = Object.prototype.toString.call(newChild);
6448        throw Error(
6449          "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."
6450        );
6451      }
6452      function throwOnInvalidObjectType(returnFiber, newChild) {
6453        var debugTask = getCurrentDebugTask();
6454        null !== debugTask ? debugTask.run(
6455          throwOnInvalidObjectTypeImpl.bind(null, returnFiber, newChild)
6456        ) : throwOnInvalidObjectTypeImpl(returnFiber, newChild);
6457      }
6458      function warnOnFunctionTypeImpl(returnFiber, invalidChild) {
6459        var parentName = getComponentNameFromFiber(returnFiber) || "Component";
6460        ownerHasFunctionTypeWarning[parentName] || (ownerHasFunctionTypeWarning[parentName] = true, invalidChild = invalidChild.displayName || invalidChild.name || "Component", 3 === returnFiber.tag ? console.error(
6461          "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)",
6462          invalidChild,
6463          invalidChild,
6464          invalidChild
6465        ) : console.error(
6466          "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>",
6467          invalidChild,
6468          invalidChild,
6469          parentName,
6470          invalidChild,
6471          parentName
6472        ));
6473      }
6474      function warnOnFunctionType(returnFiber, invalidChild) {
6475        var debugTask = getCurrentDebugTask();
6476        null !== debugTask ? debugTask.run(
6477          warnOnFunctionTypeImpl.bind(null, returnFiber, invalidChild)
6478        ) : warnOnFunctionTypeImpl(returnFiber, invalidChild);
6479      }
6480      function warnOnSymbolTypeImpl(returnFiber, invalidChild) {
6481        var parentName = getComponentNameFromFiber(returnFiber) || "Component";
6482        ownerHasSymbolTypeWarning[parentName] || (ownerHasSymbolTypeWarning[parentName] = true, invalidChild = String(invalidChild), 3 === returnFiber.tag ? console.error(
6483          "Symbols are not valid as a React child.\n  root.render(%s)",
6484          invalidChild
6485        ) : console.error(
6486          "Symbols are not valid as a React child.\n  <%s>%s</%s>",
6487          parentName,
6488          invalidChild,
6489          parentName
6490        ));
6491      }
6492      function warnOnSymbolType(returnFiber, invalidChild) {
6493        var debugTask = getCurrentDebugTask();
6494        null !== debugTask ? debugTask.run(
6495          warnOnSymbolTypeImpl.bind(null, returnFiber, invalidChild)
6496        ) : warnOnSymbolTypeImpl(returnFiber, invalidChild);
6497      }
6498      function createChildReconciler(shouldTrackSideEffects) {
6499        function deleteChild(returnFiber, childToDelete) {
6500          if (shouldTrackSideEffects) {
6501            var deletions = returnFiber.deletions;
6502            null === deletions ? (returnFiber.deletions = [childToDelete], returnFiber.flags |= 16) : deletions.push(childToDelete);
6503          }
6504        }
6505        function deleteRemainingChildren(returnFiber, currentFirstChild) {
6506          if (!shouldTrackSideEffects) return null;
6507          for (; null !== currentFirstChild; )
6508            deleteChild(returnFiber, currentFirstChild), currentFirstChild = currentFirstChild.sibling;
6509          return null;
6510        }
6511        function mapRemainingChildren(currentFirstChild) {
6512          for (var existingChildren = /* @__PURE__ */ new Map(); null !== currentFirstChild; )
6513            null !== currentFirstChild.key ? existingChildren.set(currentFirstChild.key, currentFirstChild) : existingChildren.set(currentFirstChild.index, currentFirstChild), currentFirstChild = currentFirstChild.sibling;
6514          return existingChildren;
6515        }
6516        function useFiber(fiber, pendingProps) {
6517          fiber = createWorkInProgress(fiber, pendingProps);
6518          fiber.index = 0;
6519          fiber.sibling = null;
6520          return fiber;
6521        }
6522        function placeChild(newFiber, lastPlacedIndex, newIndex) {
6523          newFiber.index = newIndex;
6524          if (!shouldTrackSideEffects)
6525            return newFiber.flags |= 1048576, lastPlacedIndex;
6526          newIndex = newFiber.alternate;
6527          if (null !== newIndex)
6528            return newIndex = newIndex.index, newIndex < lastPlacedIndex ? (newFiber.flags |= 67108866, lastPlacedIndex) : newIndex;
6529          newFiber.flags |= 67108866;
6530          return lastPlacedIndex;
6531        }
6532        function placeSingleChild(newFiber) {
6533          shouldTrackSideEffects && null === newFiber.alternate && (newFiber.flags |= 67108866);
6534          return newFiber;
6535        }
6536        function updateTextNode(returnFiber, current2, textContent, lanes) {
6537          if (null === current2 || 6 !== current2.tag)
6538            return current2 = createFiberFromText(
6539              textContent,
6540              returnFiber.mode,
6541              lanes
6542            ), current2.return = returnFiber, current2._debugOwner = returnFiber, current2._debugTask = returnFiber._debugTask, current2._debugInfo = currentDebugInfo, current2;
6543          current2 = useFiber(current2, textContent);
6544          current2.return = returnFiber;
6545          current2._debugInfo = currentDebugInfo;
6546          return current2;
6547        }
6548        function updateElement(returnFiber, current2, element, lanes) {
6549          var elementType2 = element.type;
6550          if (elementType2 === REACT_FRAGMENT_TYPE)
6551            return current2 = updateFragment(
6552              returnFiber,
6553              current2,
6554              element.props.children,
6555              lanes,
6556              element.key
6557            ), validateFragmentProps(element, current2, returnFiber), current2;
6558          if (null !== current2 && (current2.elementType === elementType2 || isCompatibleFamilyForHotReloading(current2, element) || "object" === typeof elementType2 && null !== elementType2 && elementType2.$$typeof === REACT_LAZY_TYPE && resolveLazy(elementType2) === current2.type))
6559            return current2 = useFiber(current2, element.props), coerceRef(current2, element), current2.return = returnFiber, current2._debugOwner = element._owner, current2._debugInfo = currentDebugInfo, current2;
6560          current2 = createFiberFromElement(element, returnFiber.mode, lanes);
6561          coerceRef(current2, element);
6562          current2.return = returnFiber;
6563          current2._debugInfo = currentDebugInfo;
6564          return current2;
6565        }
6566        function updatePortal(returnFiber, current2, portal, lanes) {
6567          if (null === current2 || 4 !== current2.tag || current2.stateNode.containerInfo !== portal.containerInfo || current2.stateNode.implementation !== portal.implementation)
6568            return current2 = createFiberFromPortal(portal, returnFiber.mode, lanes), current2.return = returnFiber, current2._debugInfo = currentDebugInfo, current2;
6569          current2 = useFiber(current2, portal.children || []);
6570          current2.return = returnFiber;
6571          current2._debugInfo = currentDebugInfo;
6572          return current2;
6573        }
6574        function updateFragment(returnFiber, current2, fragment, lanes, key) {
6575          if (null === current2 || 7 !== current2.tag)
6576            return current2 = createFiberFromFragment(
6577              fragment,
6578              returnFiber.mode,
6579              lanes,
6580              key
6581            ), current2.return = returnFiber, current2._debugOwner = returnFiber, current2._debugTask = returnFiber._debugTask, current2._debugInfo = currentDebugInfo, current2;
6582          current2 = useFiber(current2, fragment);
6583          current2.return = returnFiber;
6584          current2._debugInfo = currentDebugInfo;
6585          return current2;
6586        }
6587        function createChild(returnFiber, newChild, lanes) {
6588          if ("string" === typeof newChild && "" !== newChild || "number" === typeof newChild || "bigint" === typeof newChild)
6589            return newChild = createFiberFromText(
6590              "" + newChild,
6591              returnFiber.mode,
6592              lanes
6593            ), newChild.return = returnFiber, newChild._debugOwner = returnFiber, newChild._debugTask = returnFiber._debugTask, newChild._debugInfo = currentDebugInfo, newChild;
6594          if ("object" === typeof newChild && null !== newChild) {
6595            switch (newChild.$$typeof) {
6596              case REACT_ELEMENT_TYPE:
6597                return lanes = createFiberFromElement(
6598                  newChild,
6599                  returnFiber.mode,
6600                  lanes
6601                ), coerceRef(lanes, newChild), lanes.return = returnFiber, returnFiber = pushDebugInfo(newChild._debugInfo), lanes._debugInfo = currentDebugInfo, currentDebugInfo = returnFiber, lanes;
6602              case REACT_PORTAL_TYPE:
6603                return newChild = createFiberFromPortal(
6604                  newChild,
6605                  returnFiber.mode,
6606                  lanes
6607                ), newChild.return = returnFiber, newChild._debugInfo = currentDebugInfo, newChild;
6608              case REACT_LAZY_TYPE:
6609                var _prevDebugInfo = pushDebugInfo(newChild._debugInfo);
6610                newChild = resolveLazy(newChild);
6611                returnFiber = createChild(returnFiber, newChild, lanes);
6612                currentDebugInfo = _prevDebugInfo;
6613                return returnFiber;
6614            }
6615            if (isArrayImpl(newChild) || getIteratorFn(newChild))
6616              return lanes = createFiberFromFragment(
6617                newChild,
6618                returnFiber.mode,
6619                lanes,
6620                null
6621              ), lanes.return = returnFiber, lanes._debugOwner = returnFiber, lanes._debugTask = returnFiber._debugTask, returnFiber = pushDebugInfo(newChild._debugInfo), lanes._debugInfo = currentDebugInfo, currentDebugInfo = returnFiber, lanes;
6622            if ("function" === typeof newChild.then)
6623              return _prevDebugInfo = pushDebugInfo(newChild._debugInfo), returnFiber = createChild(
6624                returnFiber,
6625                unwrapThenable(newChild),
6626                lanes
6627              ), currentDebugInfo = _prevDebugInfo, returnFiber;
6628            if (newChild.$$typeof === REACT_CONTEXT_TYPE)
6629              return createChild(
6630                returnFiber,
6631                readContextDuringReconciliation(returnFiber, newChild),
6632                lanes
6633              );
6634            throwOnInvalidObjectType(returnFiber, newChild);
6635          }
6636          "function" === typeof newChild && warnOnFunctionType(returnFiber, newChild);
6637          "symbol" === typeof newChild && warnOnSymbolType(returnFiber, newChild);
6638          return null;
6639        }
6640        function updateSlot(returnFiber, oldFiber, newChild, lanes) {
6641          var key = null !== oldFiber ? oldFiber.key : null;
6642          if ("string" === typeof newChild && "" !== newChild || "number" === typeof newChild || "bigint" === typeof newChild)
6643            return null !== key ? null : updateTextNode(returnFiber, oldFiber, "" + newChild, lanes);
6644          if ("object" === typeof newChild && null !== newChild) {
6645            switch (newChild.$$typeof) {
6646              case REACT_ELEMENT_TYPE:
6647                return newChild.key === key ? (key = pushDebugInfo(newChild._debugInfo), returnFiber = updateElement(
6648                  returnFiber,
6649                  oldFiber,
6650                  newChild,
6651                  lanes
6652                ), currentDebugInfo = key, returnFiber) : null;
6653              case REACT_PORTAL_TYPE:
6654                return newChild.key === key ? updatePortal(returnFiber, oldFiber, newChild, lanes) : null;
6655              case REACT_LAZY_TYPE:
6656                return key = pushDebugInfo(newChild._debugInfo), newChild = resolveLazy(newChild), returnFiber = updateSlot(
6657                  returnFiber,
6658                  oldFiber,
6659                  newChild,
6660                  lanes
6661                ), currentDebugInfo = key, returnFiber;
6662            }
6663            if (isArrayImpl(newChild) || getIteratorFn(newChild)) {
6664              if (null !== key) return null;
6665              key = pushDebugInfo(newChild._debugInfo);
6666              returnFiber = updateFragment(
6667                returnFiber,
6668                oldFiber,
6669                newChild,
6670                lanes,
6671                null
6672              );
6673              currentDebugInfo = key;
6674              return returnFiber;
6675            }
6676            if ("function" === typeof newChild.then)
6677              return key = pushDebugInfo(newChild._debugInfo), returnFiber = updateSlot(
6678                returnFiber,
6679                oldFiber,
6680                unwrapThenable(newChild),
6681                lanes
6682              ), currentDebugInfo = key, returnFiber;
6683            if (newChild.$$typeof === REACT_CONTEXT_TYPE)
6684              return updateSlot(
6685                returnFiber,
6686                oldFiber,
6687                readContextDuringReconciliation(returnFiber, newChild),
6688                lanes
6689              );
6690            throwOnInvalidObjectType(returnFiber, newChild);
6691          }
6692          "function" === typeof newChild && warnOnFunctionType(returnFiber, newChild);
6693          "symbol" === typeof newChild && warnOnSymbolType(returnFiber, newChild);
6694          return null;
6695        }
6696        function updateFromMap(existingChildren, returnFiber, newIdx, newChild, lanes) {
6697          if ("string" === typeof newChild && "" !== newChild || "number" === typeof newChild || "bigint" === typeof newChild)
6698            return existingChildren = existingChildren.get(newIdx) || null, updateTextNode(returnFiber, existingChildren, "" + newChild, lanes);
6699          if ("object" === typeof newChild && null !== newChild) {
6700            switch (newChild.$$typeof) {
6701              case REACT_ELEMENT_TYPE:
6702                return newIdx = existingChildren.get(
6703                  null === newChild.key ? newIdx : newChild.key
6704                ) || null, existingChildren = pushDebugInfo(newChild._debugInfo), returnFiber = updateElement(
6705                  returnFiber,
6706                  newIdx,
6707                  newChild,
6708                  lanes
6709                ), currentDebugInfo = existingChildren, returnFiber;
6710              case REACT_PORTAL_TYPE:
6711                return existingChildren = existingChildren.get(
6712                  null === newChild.key ? newIdx : newChild.key
6713                ) || null, updatePortal(returnFiber, existingChildren, newChild, lanes);
6714              case REACT_LAZY_TYPE:
6715                var _prevDebugInfo7 = pushDebugInfo(newChild._debugInfo);
6716                newChild = resolveLazy(newChild);
6717                returnFiber = updateFromMap(
6718                  existingChildren,
6719                  returnFiber,
6720                  newIdx,
6721                  newChild,
6722                  lanes
6723                );
6724                currentDebugInfo = _prevDebugInfo7;
6725                return returnFiber;
6726            }
6727            if (isArrayImpl(newChild) || getIteratorFn(newChild))
6728              return newIdx = existingChildren.get(newIdx) || null, existingChildren = pushDebugInfo(newChild._debugInfo), returnFiber = updateFragment(
6729                returnFiber,
6730                newIdx,
6731                newChild,
6732                lanes,
6733                null
6734              ), currentDebugInfo = existingChildren, returnFiber;
6735            if ("function" === typeof newChild.then)
6736              return _prevDebugInfo7 = pushDebugInfo(newChild._debugInfo), returnFiber = updateFromMap(
6737                existingChildren,
6738                returnFiber,
6739                newIdx,
6740                unwrapThenable(newChild),
6741                lanes
6742              ), currentDebugInfo = _prevDebugInfo7, returnFiber;
6743            if (newChild.$$typeof === REACT_CONTEXT_TYPE)
6744              return updateFromMap(
6745                existingChildren,
6746                returnFiber,
6747                newIdx,
6748                readContextDuringReconciliation(returnFiber, newChild),
6749                lanes
6750              );
6751            throwOnInvalidObjectType(returnFiber, newChild);
6752          }
6753          "function" === typeof newChild && warnOnFunctionType(returnFiber, newChild);
6754          "symbol" === typeof newChild && warnOnSymbolType(returnFiber, newChild);
6755          return null;
6756        }
6757        function warnOnInvalidKey(returnFiber, workInProgress2, child, knownKeys) {
6758          if ("object" !== typeof child || null === child) return knownKeys;
6759          switch (child.$$typeof) {
6760            case REACT_ELEMENT_TYPE:
6761            case REACT_PORTAL_TYPE:
6762              warnForMissingKey(returnFiber, workInProgress2, child);
6763              var key = child.key;
6764              if ("string" !== typeof key) break;
6765              if (null === knownKeys) {
6766                knownKeys = /* @__PURE__ */ new Set();
6767                knownKeys.add(key);
6768                break;
6769              }
6770              if (!knownKeys.has(key)) {
6771                knownKeys.add(key);
6772                break;
6773              }
6774              runWithFiberInDEV(workInProgress2, function() {
6775                console.error(
6776                  "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 \u2014 the behavior is unsupported and could change in a future version.",
6777                  key
6778                );
6779              });
6780              break;
6781            case REACT_LAZY_TYPE:
6782              child = resolveLazy(child), warnOnInvalidKey(returnFiber, workInProgress2, child, knownKeys);
6783          }
6784          return knownKeys;
6785        }
6786        function reconcileChildrenArray(returnFiber, currentFirstChild, newChildren, lanes) {
6787          for (var knownKeys = null, resultingFirstChild = null, previousNewFiber = null, oldFiber = currentFirstChild, newIdx = currentFirstChild = 0, nextOldFiber = null; null !== oldFiber && newIdx < newChildren.length; newIdx++) {
6788            oldFiber.index > newIdx ? (nextOldFiber = oldFiber, oldFiber = null) : nextOldFiber = oldFiber.sibling;
6789            var newFiber = updateSlot(
6790              returnFiber,
6791              oldFiber,
6792              newChildren[newIdx],
6793              lanes
6794            );
6795            if (null === newFiber) {
6796              null === oldFiber && (oldFiber = nextOldFiber);
6797              break;
6798            }
6799            knownKeys = warnOnInvalidKey(
6800              returnFiber,
6801              newFiber,
6802              newChildren[newIdx],
6803              knownKeys
6804            );
6805            shouldTrackSideEffects && oldFiber && null === newFiber.alternate && deleteChild(returnFiber, oldFiber);
6806            currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
6807            null === previousNewFiber ? resultingFirstChild = newFiber : previousNewFiber.sibling = newFiber;
6808            previousNewFiber = newFiber;
6809            oldFiber = nextOldFiber;
6810          }
6811          if (newIdx === newChildren.length)
6812            return deleteRemainingChildren(returnFiber, oldFiber), isHydrating && pushTreeFork(returnFiber, newIdx), resultingFirstChild;
6813          if (null === oldFiber) {
6814            for (; newIdx < newChildren.length; newIdx++)
6815              oldFiber = createChild(returnFiber, newChildren[newIdx], lanes), null !== oldFiber && (knownKeys = warnOnInvalidKey(
6816                returnFiber,
6817                oldFiber,
6818                newChildren[newIdx],
6819                knownKeys
6820              ), currentFirstChild = placeChild(
6821                oldFiber,
6822                currentFirstChild,
6823                newIdx
6824              ), null === previousNewFiber ? resultingFirstChild = oldFiber : previousNewFiber.sibling = oldFiber, previousNewFiber = oldFiber);
6825            isHydrating && pushTreeFork(returnFiber, newIdx);
6826            return resultingFirstChild;
6827          }
6828          for (oldFiber = mapRemainingChildren(oldFiber); newIdx < newChildren.length; newIdx++)
6829            nextOldFiber = updateFromMap(
6830              oldFiber,
6831              returnFiber,
6832              newIdx,
6833              newChildren[newIdx],
6834              lanes
6835            ), null !== nextOldFiber && (knownKeys = warnOnInvalidKey(
6836              returnFiber,
6837              nextOldFiber,
6838              newChildren[newIdx],
6839              knownKeys
6840            ), shouldTrackSideEffects && null !== nextOldFiber.alternate && oldFiber.delete(
6841              null === nextOldFiber.key ? newIdx : nextOldFiber.key
6842            ), currentFirstChild = placeChild(
6843              nextOldFiber,
6844              currentFirstChild,
6845              newIdx
6846            ), null === previousNewFiber ? resultingFirstChild = nextOldFiber : previousNewFiber.sibling = nextOldFiber, previousNewFiber = nextOldFiber);
6847          shouldTrackSideEffects && oldFiber.forEach(function(child) {
6848            return deleteChild(returnFiber, child);
6849          });
6850          isHydrating && pushTreeFork(returnFiber, newIdx);
6851          return resultingFirstChild;
6852        }
6853        function reconcileChildrenIterator(returnFiber, currentFirstChild, newChildren, lanes) {
6854          if (null == newChildren)
6855            throw Error("An iterable object provided no iterator.");
6856          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()) {
6857            oldFiber.index > newIdx ? (nextOldFiber = oldFiber, oldFiber = null) : nextOldFiber = oldFiber.sibling;
6858            var newFiber = updateSlot(returnFiber, oldFiber, step.value, lanes);
6859            if (null === newFiber) {
6860              null === oldFiber && (oldFiber = nextOldFiber);
6861              break;
6862            }
6863            knownKeys = warnOnInvalidKey(
6864              returnFiber,
6865              newFiber,
6866              step.value,
6867              knownKeys
6868            );
6869            shouldTrackSideEffects && oldFiber && null === newFiber.alternate && deleteChild(returnFiber, oldFiber);
6870            currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
6871            null === previousNewFiber ? resultingFirstChild = newFiber : previousNewFiber.sibling = newFiber;
6872            previousNewFiber = newFiber;
6873            oldFiber = nextOldFiber;
6874          }
6875          if (step.done)
6876            return deleteRemainingChildren(returnFiber, oldFiber), isHydrating && pushTreeFork(returnFiber, newIdx), resultingFirstChild;
6877          if (null === oldFiber) {
6878            for (; !step.done; newIdx++, step = newChildren.next())
6879              oldFiber = createChild(returnFiber, step.value, lanes), null !== oldFiber && (knownKeys = warnOnInvalidKey(
6880                returnFiber,
6881                oldFiber,
6882                step.value,
6883                knownKeys
6884              ), currentFirstChild = placeChild(
6885                oldFiber,
6886                currentFirstChild,
6887                newIdx
6888              ), null === previousNewFiber ? resultingFirstChild = oldFiber : previousNewFiber.sibling = oldFiber, previousNewFiber = oldFiber);
6889            isHydrating && pushTreeFork(returnFiber, newIdx);
6890            return resultingFirstChild;
6891          }
6892          for (oldFiber = mapRemainingChildren(oldFiber); !step.done; newIdx++, step = newChildren.next())
6893            nextOldFiber = updateFromMap(
6894              oldFiber,
6895              returnFiber,
6896              newIdx,
6897              step.value,
6898              lanes
6899            ), null !== nextOldFiber && (knownKeys = warnOnInvalidKey(
6900              returnFiber,
6901              nextOldFiber,
6902              step.value,
6903              knownKeys
6904            ), shouldTrackSideEffects && null !== nextOldFiber.alternate && oldFiber.delete(
6905              null === nextOldFiber.key ? newIdx : nextOldFiber.key
6906            ), currentFirstChild = placeChild(
6907              nextOldFiber,
6908              currentFirstChild,
6909              newIdx
6910            ), null === previousNewFiber ? resultingFirstChild = nextOldFiber : previousNewFiber.sibling = nextOldFiber, previousNewFiber = nextOldFiber);
6911          shouldTrackSideEffects && oldFiber.forEach(function(child) {
6912            return deleteChild(returnFiber, child);
6913          });
6914          isHydrating && pushTreeFork(returnFiber, newIdx);
6915          return resultingFirstChild;
6916        }
6917        function reconcileChildFibersImpl(returnFiber, currentFirstChild, newChild, lanes) {
6918          "object" === typeof newChild && null !== newChild && newChild.type === REACT_FRAGMENT_TYPE && null === newChild.key && (validateFragmentProps(newChild, null, returnFiber), newChild = newChild.props.children);
6919          if ("object" === typeof newChild && null !== newChild) {
6920            switch (newChild.$$typeof) {
6921              case REACT_ELEMENT_TYPE:
6922                var prevDebugInfo = pushDebugInfo(newChild._debugInfo);
6923                a: {
6924                  for (var key = newChild.key; null !== currentFirstChild; ) {
6925                    if (currentFirstChild.key === key) {
6926                      key = newChild.type;
6927                      if (key === REACT_FRAGMENT_TYPE) {
6928                        if (7 === currentFirstChild.tag) {
6929                          deleteRemainingChildren(
6930                            returnFiber,
6931                            currentFirstChild.sibling
6932                          );
6933                          lanes = useFiber(
6934                            currentFirstChild,
6935                            newChild.props.children
6936                          );
6937                          lanes.return = returnFiber;
6938                          lanes._debugOwner = newChild._owner;
6939                          lanes._debugInfo = currentDebugInfo;
6940                          validateFragmentProps(newChild, lanes, returnFiber);
6941                          returnFiber = lanes;
6942                          break a;
6943                        }
6944                      } else if (currentFirstChild.elementType === key || isCompatibleFamilyForHotReloading(
6945                        currentFirstChild,
6946                        newChild
6947                      ) || "object" === typeof key && null !== key && key.$$typeof === REACT_LAZY_TYPE && resolveLazy(key) === currentFirstChild.type) {
6948                        deleteRemainingChildren(
6949                          returnFiber,
6950                          currentFirstChild.sibling
6951                        );
6952                        lanes = useFiber(currentFirstChild, newChild.props);
6953                        coerceRef(lanes, newChild);
6954                        lanes.return = returnFiber;
6955                        lanes._debugOwner = newChild._owner;
6956                        lanes._debugInfo = currentDebugInfo;
6957                        returnFiber = lanes;
6958                        break a;
6959                      }
6960                      deleteRemainingChildren(returnFiber, currentFirstChild);
6961                      break;
6962                    } else deleteChild(returnFiber, currentFirstChild);
6963                    currentFirstChild = currentFirstChild.sibling;
6964                  }
6965                  newChild.type === REACT_FRAGMENT_TYPE ? (lanes = createFiberFromFragment(
6966                    newChild.props.children,
6967                    returnFiber.mode,
6968                    lanes,
6969                    newChild.key
6970                  ), lanes.return = returnFiber, lanes._debugOwner = returnFiber, lanes._debugTask = returnFiber._debugTask, lanes._debugInfo = currentDebugInfo, validateFragmentProps(newChild, lanes, returnFiber), returnFiber = lanes) : (lanes = createFiberFromElement(
6971                    newChild,
6972                    returnFiber.mode,
6973                    lanes
6974                  ), coerceRef(lanes, newChild), lanes.return = returnFiber, lanes._debugInfo = currentDebugInfo, returnFiber = lanes);
6975                }
6976                returnFiber = placeSingleChild(returnFiber);
6977                currentDebugInfo = prevDebugInfo;
6978                return returnFiber;
6979              case REACT_PORTAL_TYPE:
6980                a: {
6981                  prevDebugInfo = newChild;
6982                  for (newChild = prevDebugInfo.key; null !== currentFirstChild; ) {
6983                    if (currentFirstChild.key === newChild)
6984                      if (4 === currentFirstChild.tag && currentFirstChild.stateNode.containerInfo === prevDebugInfo.containerInfo && currentFirstChild.stateNode.implementation === prevDebugInfo.implementation) {
6985                        deleteRemainingChildren(
6986                          returnFiber,
6987                          currentFirstChild.sibling
6988                        );
6989                        lanes = useFiber(
6990                          currentFirstChild,
6991                          prevDebugInfo.children || []
6992                        );
6993                        lanes.return = returnFiber;
6994                        returnFiber = lanes;
6995                        break a;
6996                      } else {
6997                        deleteRemainingChildren(returnFiber, currentFirstChild);
6998                        break;
6999                      }
7000                    else deleteChild(returnFiber, currentFirstChild);
7001                    currentFirstChild = currentFirstChild.sibling;
7002                  }
7003                  lanes = createFiberFromPortal(
7004                    prevDebugInfo,
7005                    returnFiber.mode,
7006                    lanes
7007                  );
7008                  lanes.return = returnFiber;
7009                  returnFiber = lanes;
7010                }
7011                return placeSingleChild(returnFiber);
7012              case REACT_LAZY_TYPE:
7013                return prevDebugInfo = pushDebugInfo(newChild._debugInfo), newChild = resolveLazy(newChild), returnFiber = reconcileChildFibersImpl(
7014                  returnFiber,
7015                  currentFirstChild,
7016                  newChild,
7017                  lanes
7018                ), currentDebugInfo = prevDebugInfo, returnFiber;
7019            }
7020            if (isArrayImpl(newChild))
7021              return prevDebugInfo = pushDebugInfo(newChild._debugInfo), returnFiber = reconcileChildrenArray(
7022                returnFiber,
7023                currentFirstChild,
7024                newChild,
7025                lanes
7026              ), currentDebugInfo = prevDebugInfo, returnFiber;
7027            if (getIteratorFn(newChild)) {
7028              prevDebugInfo = pushDebugInfo(newChild._debugInfo);
7029              key = getIteratorFn(newChild);
7030              if ("function" !== typeof key)
7031                throw Error(
7032                  "An object is not an iterable. This error is likely caused by a bug in React. Please file an issue."
7033                );
7034              var newChildren = key.call(newChild);
7035              if (newChildren === newChild) {
7036                if (0 !== returnFiber.tag || "[object GeneratorFunction]" !== Object.prototype.toString.call(returnFiber.type) || "[object Generator]" !== Object.prototype.toString.call(newChildren))
7037                  didWarnAboutGenerators || console.error(
7038                    "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."
7039                  ), didWarnAboutGenerators = true;
7040              } else
7041                newChild.entries !== key || didWarnAboutMaps || (console.error(
7042                  "Using Maps as children is not supported. Use an array of keyed ReactElements instead."
7043                ), didWarnAboutMaps = true);
7044              returnFiber = reconcileChildrenIterator(
7045                returnFiber,
7046                currentFirstChild,
7047                newChildren,
7048                lanes
7049              );
7050              currentDebugInfo = prevDebugInfo;
7051              return returnFiber;
7052            }
7053            if ("function" === typeof newChild.then)
7054              return prevDebugInfo = pushDebugInfo(newChild._debugInfo), returnFiber = reconcileChildFibersImpl(
7055                returnFiber,
7056                currentFirstChild,
7057                unwrapThenable(newChild),
7058                lanes
7059              ), currentDebugInfo = prevDebugInfo, returnFiber;
7060            if (newChild.$$typeof === REACT_CONTEXT_TYPE)
7061              return reconcileChildFibersImpl(
7062                returnFiber,
7063                currentFirstChild,
7064                readContextDuringReconciliation(returnFiber, newChild),
7065                lanes
7066              );
7067            throwOnInvalidObjectType(returnFiber, newChild);
7068          }
7069          if ("string" === typeof newChild && "" !== newChild || "number" === typeof newChild || "bigint" === typeof newChild)
7070            return prevDebugInfo = "" + newChild, null !== currentFirstChild && 6 === currentFirstChild.tag ? (deleteRemainingChildren(
7071              returnFiber,
7072              currentFirstChild.sibling
7073            ), lanes = useFiber(currentFirstChild, prevDebugInfo), lanes.return = returnFiber, returnFiber = lanes) : (deleteRemainingChildren(returnFiber, currentFirstChild), lanes = createFiberFromText(
7074              prevDebugInfo,
7075              returnFiber.mode,
7076              lanes
7077            ), lanes.return = returnFiber, lanes._debugOwner = returnFiber, lanes._debugTask = returnFiber._debugTask, lanes._debugInfo = currentDebugInfo, returnFiber = lanes), placeSingleChild(returnFiber);
7078          "function" === typeof newChild && warnOnFunctionType(returnFiber, newChild);
7079          "symbol" === typeof newChild && warnOnSymbolType(returnFiber, newChild);
7080          return deleteRemainingChildren(returnFiber, currentFirstChild);
7081        }
7082        return function(returnFiber, currentFirstChild, newChild, lanes) {
7083          var prevDebugInfo = currentDebugInfo;
7084          currentDebugInfo = null;
7085          try {
7086            thenableIndexCounter$1 = 0;
7087            var firstChildFiber = reconcileChildFibersImpl(
7088              returnFiber,
7089              currentFirstChild,
7090              newChild,
7091              lanes
7092            );
7093            thenableState$1 = null;
7094            return firstChildFiber;
7095          } catch (x3) {
7096            if (x3 === SuspenseException || x3 === SuspenseActionException) throw x3;
7097            var fiber = createFiber(29, x3, null, returnFiber.mode);
7098            fiber.lanes = lanes;
7099            fiber.return = returnFiber;
7100            var debugInfo = fiber._debugInfo = currentDebugInfo;
7101            fiber._debugOwner = returnFiber._debugOwner;
7102            fiber._debugTask = returnFiber._debugTask;
7103            if (null != debugInfo) {
7104              for (var i3 = debugInfo.length - 1; 0 <= i3; i3--)
7105                if ("string" === typeof debugInfo[i3].stack) {
7106                  fiber._debugOwner = debugInfo[i3];
7107                  fiber._debugTask = debugInfo[i3].debugTask;
7108                  break;
7109                }
7110            }
7111            return fiber;
7112          } finally {
7113            currentDebugInfo = prevDebugInfo;
7114          }
7115        };
7116      }
7117      function validateSuspenseListNestedChild(childSlot, index) {
7118        var isAnArray = isArrayImpl(childSlot);
7119        childSlot = !isAnArray && "function" === typeof getIteratorFn(childSlot);
7120        return isAnArray || childSlot ? (isAnArray = isAnArray ? "array" : "iterable", console.error(
7121          "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>",
7122          isAnArray,
7123          index,
7124          isAnArray
7125        ), false) : true;
7126      }
7127      function initializeUpdateQueue(fiber) {
7128        fiber.updateQueue = {
7129          baseState: fiber.memoizedState,
7130          firstBaseUpdate: null,
7131          lastBaseUpdate: null,
7132          shared: { pending: null, lanes: 0, hiddenCallbacks: null },
7133          callbacks: null
7134        };
7135      }
7136      function cloneUpdateQueue(current2, workInProgress2) {
7137        current2 = current2.updateQueue;
7138        workInProgress2.updateQueue === current2 && (workInProgress2.updateQueue = {
7139          baseState: current2.baseState,
7140          firstBaseUpdate: current2.firstBaseUpdate,
7141          lastBaseUpdate: current2.lastBaseUpdate,
7142          shared: current2.shared,
7143          callbacks: null
7144        });
7145      }
7146      function createUpdate(lane) {
7147        return {
7148          lane,
7149          tag: UpdateState,
7150          payload: null,
7151          callback: null,
7152          next: null
7153        };
7154      }
7155      function enqueueUpdate(fiber, update, lane) {
7156        var updateQueue = fiber.updateQueue;
7157        if (null === updateQueue) return null;
7158        updateQueue = updateQueue.shared;
7159        if (currentlyProcessingQueue === updateQueue && !didWarnUpdateInsideUpdate) {
7160          var componentName2 = getComponentNameFromFiber(fiber);
7161          console.error(
7162            "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",
7163            componentName2
7164          );
7165          didWarnUpdateInsideUpdate = true;
7166        }
7167        if ((executionContext & RenderContext) !== NoContext)
7168          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;
7169        enqueueUpdate$1(fiber, updateQueue, update, lane);
7170        return getRootForUpdatedFiber(fiber);
7171      }
7172      function entangleTransitions(root3, fiber, lane) {
7173        fiber = fiber.updateQueue;
7174        if (null !== fiber && (fiber = fiber.shared, 0 !== (lane & 4194048))) {
7175          var queueLanes = fiber.lanes;
7176          queueLanes &= root3.pendingLanes;
7177          lane |= queueLanes;
7178          fiber.lanes = lane;
7179          markRootEntangled(root3, lane);
7180        }
7181      }
7182      function enqueueCapturedUpdate(workInProgress2, capturedUpdate) {
7183        var queue = workInProgress2.updateQueue, current2 = workInProgress2.alternate;
7184        if (null !== current2 && (current2 = current2.updateQueue, queue === current2)) {
7185          var newFirst = null, newLast = null;
7186          queue = queue.firstBaseUpdate;
7187          if (null !== queue) {
7188            do {
7189              var clone = {
7190                lane: queue.lane,
7191                tag: queue.tag,
7192                payload: queue.payload,
7193                callback: null,
7194                next: null
7195              };
7196              null === newLast ? newFirst = newLast = clone : newLast = newLast.next = clone;
7197              queue = queue.next;
7198            } while (null !== queue);
7199            null === newLast ? newFirst = newLast = capturedUpdate : newLast = newLast.next = capturedUpdate;
7200          } else newFirst = newLast = capturedUpdate;
7201          queue = {
7202            baseState: current2.baseState,
7203            firstBaseUpdate: newFirst,
7204            lastBaseUpdate: newLast,
7205            shared: current2.shared,
7206            callbacks: current2.callbacks
7207          };
7208          workInProgress2.updateQueue = queue;
7209          return;
7210        }
7211        workInProgress2 = queue.lastBaseUpdate;
7212        null === workInProgress2 ? queue.firstBaseUpdate = capturedUpdate : workInProgress2.next = capturedUpdate;
7213        queue.lastBaseUpdate = capturedUpdate;
7214      }
7215      function suspendIfUpdateReadFromEntangledAsyncAction() {
7216        if (didReadFromEntangledAsyncAction) {
7217          var entangledActionThenable = currentEntangledActionThenable;
7218          if (null !== entangledActionThenable) throw entangledActionThenable;
7219        }
7220      }
7221      function processUpdateQueue(workInProgress2, props, instance$jscomp$0, renderLanes2) {
7222        didReadFromEntangledAsyncAction = false;
7223        var queue = workInProgress2.updateQueue;
7224        hasForceUpdate = false;
7225        currentlyProcessingQueue = queue.shared;
7226        var firstBaseUpdate = queue.firstBaseUpdate, lastBaseUpdate = queue.lastBaseUpdate, pendingQueue = queue.shared.pending;
7227        if (null !== pendingQueue) {
7228          queue.shared.pending = null;
7229          var lastPendingUpdate = pendingQueue, firstPendingUpdate = lastPendingUpdate.next;
7230          lastPendingUpdate.next = null;
7231          null === lastBaseUpdate ? firstBaseUpdate = firstPendingUpdate : lastBaseUpdate.next = firstPendingUpdate;
7232          lastBaseUpdate = lastPendingUpdate;
7233          var current2 = workInProgress2.alternate;
7234          null !== current2 && (current2 = current2.updateQueue, pendingQueue = current2.lastBaseUpdate, pendingQueue !== lastBaseUpdate && (null === pendingQueue ? current2.firstBaseUpdate = firstPendingUpdate : pendingQueue.next = firstPendingUpdate, current2.lastBaseUpdate = lastPendingUpdate));
7235        }
7236        if (null !== firstBaseUpdate) {
7237          var newState = queue.baseState;
7238          lastBaseUpdate = 0;
7239          current2 = firstPendingUpdate = lastPendingUpdate = null;
7240          pendingQueue = firstBaseUpdate;
7241          do {
7242            var updateLane = pendingQueue.lane & -536870913, isHiddenUpdate = updateLane !== pendingQueue.lane;
7243            if (isHiddenUpdate ? (workInProgressRootRenderLanes & updateLane) === updateLane : (renderLanes2 & updateLane) === updateLane) {
7244              0 !== updateLane && updateLane === currentEntangledLane && (didReadFromEntangledAsyncAction = true);
7245              null !== current2 && (current2 = current2.next = {
7246                lane: 0,
7247                tag: pendingQueue.tag,
7248                payload: pendingQueue.payload,
7249                callback: null,
7250                next: null
7251              });
7252              a: {
7253                updateLane = workInProgress2;
7254                var partialState = pendingQueue;
7255                var nextProps = props, instance = instance$jscomp$0;
7256                switch (partialState.tag) {
7257                  case ReplaceState:
7258                    partialState = partialState.payload;
7259                    if ("function" === typeof partialState) {
7260                      isDisallowedContextReadInDEV = true;
7261                      var nextState = partialState.call(
7262                        instance,
7263                        newState,
7264                        nextProps
7265                      );
7266                      if (updateLane.mode & StrictLegacyMode) {
7267                        setIsStrictModeForDevtools(true);
7268                        try {
7269                          partialState.call(instance, newState, nextProps);
7270                        } finally {
7271                          setIsStrictModeForDevtools(false);
7272                        }
7273                      }
7274                      isDisallowedContextReadInDEV = false;
7275                      newState = nextState;
7276                      break a;
7277                    }
7278                    newState = partialState;
7279                    break a;
7280                  case CaptureUpdate:
7281                    updateLane.flags = updateLane.flags & -65537 | 128;
7282                  case UpdateState:
7283                    nextState = partialState.payload;
7284                    if ("function" === typeof nextState) {
7285                      isDisallowedContextReadInDEV = true;
7286                      partialState = nextState.call(
7287                        instance,
7288                        newState,
7289                        nextProps
7290                      );
7291                      if (updateLane.mode & StrictLegacyMode) {
7292                        setIsStrictModeForDevtools(true);
7293                        try {
7294                          nextState.call(instance, newState, nextProps);
7295                        } finally {
7296                          setIsStrictModeForDevtools(false);
7297                        }
7298                      }
7299                      isDisallowedContextReadInDEV = false;
7300                    } else partialState = nextState;
7301                    if (null === partialState || void 0 === partialState) break a;
7302                    newState = assign({}, newState, partialState);
7303                    break a;
7304                  case ForceUpdate:
7305                    hasForceUpdate = true;
7306                }
7307              }
7308              updateLane = pendingQueue.callback;
7309              null !== updateLane && (workInProgress2.flags |= 64, isHiddenUpdate && (workInProgress2.flags |= 8192), isHiddenUpdate = queue.callbacks, null === isHiddenUpdate ? queue.callbacks = [updateLane] : isHiddenUpdate.push(updateLane));
7310            } else
7311              isHiddenUpdate = {
7312                lane: updateLane,
7313                tag: pendingQueue.tag,
7314                payload: pendingQueue.payload,
7315                callback: pendingQueue.callback,
7316                next: null
7317              }, null === current2 ? (firstPendingUpdate = current2 = isHiddenUpdate, lastPendingUpdate = newState) : current2 = current2.next = isHiddenUpdate, lastBaseUpdate |= updateLane;
7318            pendingQueue = pendingQueue.next;
7319            if (null === pendingQueue)
7320              if (pendingQueue = queue.shared.pending, null === pendingQueue)
7321                break;
7322              else
7323                isHiddenUpdate = pendingQueue, pendingQueue = isHiddenUpdate.next, isHiddenUpdate.next = null, queue.lastBaseUpdate = isHiddenUpdate, queue.shared.pending = null;
7324          } while (1);
7325          null === current2 && (lastPendingUpdate = newState);
7326          queue.baseState = lastPendingUpdate;
7327          queue.firstBaseUpdate = firstPendingUpdate;
7328          queue.lastBaseUpdate = current2;
7329          null === firstBaseUpdate && (queue.shared.lanes = 0);
7330          workInProgressRootSkippedLanes |= lastBaseUpdate;
7331          workInProgress2.lanes = lastBaseUpdate;
7332          workInProgress2.memoizedState = newState;
7333        }
7334        currentlyProcessingQueue = null;
7335      }
7336      function callCallback(callback, context) {
7337        if ("function" !== typeof callback)
7338          throw Error(
7339            "Invalid argument passed as callback. Expected a function. Instead received: " + callback
7340          );
7341        callback.call(context);
7342      }
7343      function commitHiddenCallbacks(updateQueue, context) {
7344        var hiddenCallbacks = updateQueue.shared.hiddenCallbacks;
7345        if (null !== hiddenCallbacks)
7346          for (updateQueue.shared.hiddenCallbacks = null, updateQueue = 0; updateQueue < hiddenCallbacks.length; updateQueue++)
7347            callCallback(hiddenCallbacks[updateQueue], context);
7348      }
7349      function commitCallbacks(updateQueue, context) {
7350        var callbacks = updateQueue.callbacks;
7351        if (null !== callbacks)
7352          for (updateQueue.callbacks = null, updateQueue = 0; updateQueue < callbacks.length; updateQueue++)
7353            callCallback(callbacks[updateQueue], context);
7354      }
7355      function pushHiddenContext(fiber, context) {
7356        var prevEntangledRenderLanes = entangledRenderLanes;
7357        push(prevEntangledRenderLanesCursor, prevEntangledRenderLanes, fiber);
7358        push(currentTreeHiddenStackCursor, context, fiber);
7359        entangledRenderLanes = prevEntangledRenderLanes | context.baseLanes;
7360      }
7361      function reuseHiddenContextOnStack(fiber) {
7362        push(prevEntangledRenderLanesCursor, entangledRenderLanes, fiber);
7363        push(
7364          currentTreeHiddenStackCursor,
7365          currentTreeHiddenStackCursor.current,
7366          fiber
7367        );
7368      }
7369      function popHiddenContext(fiber) {
7370        entangledRenderLanes = prevEntangledRenderLanesCursor.current;
7371        pop(currentTreeHiddenStackCursor, fiber);
7372        pop(prevEntangledRenderLanesCursor, fiber);
7373      }
7374      function pushPrimaryTreeSuspenseHandler(handler) {
7375        var current2 = handler.alternate;
7376        push(
7377          suspenseStackCursor,
7378          suspenseStackCursor.current & SubtreeSuspenseContextMask,
7379          handler
7380        );
7381        push(suspenseHandlerStackCursor, handler, handler);
7382        null === shellBoundary && (null === current2 || null !== currentTreeHiddenStackCursor.current ? shellBoundary = handler : null !== current2.memoizedState && (shellBoundary = handler));
7383      }
7384      function pushDehydratedActivitySuspenseHandler(fiber) {
7385        push(suspenseStackCursor, suspenseStackCursor.current, fiber);
7386        push(suspenseHandlerStackCursor, fiber, fiber);
7387        null === shellBoundary && (shellBoundary = fiber);
7388      }
7389      function pushOffscreenSuspenseHandler(fiber) {
7390        22 === fiber.tag ? (push(suspenseStackCursor, suspenseStackCursor.current, fiber), push(suspenseHandlerStackCursor, fiber, fiber), null === shellBoundary && (shellBoundary = fiber)) : reuseSuspenseHandlerOnStack(fiber);
7391      }
7392      function reuseSuspenseHandlerOnStack(fiber) {
7393        push(suspenseStackCursor, suspenseStackCursor.current, fiber);
7394        push(
7395          suspenseHandlerStackCursor,
7396          suspenseHandlerStackCursor.current,
7397          fiber
7398        );
7399      }
7400      function popSuspenseHandler(fiber) {
7401        pop(suspenseHandlerStackCursor, fiber);
7402        shellBoundary === fiber && (shellBoundary = null);
7403        pop(suspenseStackCursor, fiber);
7404      }
7405      function findFirstSuspended(row) {
7406        for (var node = row; null !== node; ) {
7407          if (13 === node.tag) {
7408            var state = node.memoizedState;
7409            if (null !== state && (state = state.dehydrated, null === state || isSuspenseInstancePending(state) || isSuspenseInstanceFallback(state)))
7410              return node;
7411          } else if (19 === node.tag && ("forwards" === node.memoizedProps.revealOrder || "backwards" === node.memoizedProps.revealOrder || "unstable_legacy-backwards" === node.memoizedProps.revealOrder || "together" === node.memoizedProps.revealOrder)) {
7412            if (0 !== (node.flags & 128)) return node;
7413          } else if (null !== node.child) {
7414            node.child.return = node;
7415            node = node.child;
7416            continue;
7417          }
7418          if (node === row) break;
7419          for (; null === node.sibling; ) {
7420            if (null === node.return || node.return === row) return null;
7421            node = node.return;
7422          }
7423          node.sibling.return = node.return;
7424          node = node.sibling;
7425        }
7426        return null;
7427      }
7428      function mountHookTypesDev() {
7429        var hookName = currentHookNameInDev;
7430        null === hookTypesDev ? hookTypesDev = [hookName] : hookTypesDev.push(hookName);
7431      }
7432      function updateHookTypesDev() {
7433        var hookName = currentHookNameInDev;
7434        if (null !== hookTypesDev && (hookTypesUpdateIndexDev++, hookTypesDev[hookTypesUpdateIndexDev] !== hookName)) {
7435          var componentName2 = getComponentNameFromFiber(currentlyRenderingFiber);
7436          if (!didWarnAboutMismatchedHooksForComponent.has(componentName2) && (didWarnAboutMismatchedHooksForComponent.add(componentName2), null !== hookTypesDev)) {
7437            for (var table = "", i3 = 0; i3 <= hookTypesUpdateIndexDev; i3++) {
7438              var oldHookName = hookTypesDev[i3], newHookName = i3 === hookTypesUpdateIndexDev ? hookName : oldHookName;
7439              for (oldHookName = i3 + 1 + ". " + oldHookName; 30 > oldHookName.length; )
7440                oldHookName += " ";
7441              oldHookName += newHookName + "\n";
7442              table += oldHookName;
7443            }
7444            console.error(
7445              "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",
7446              componentName2,
7447              table
7448            );
7449          }
7450        }
7451      }
7452      function checkDepsAreArrayDev(deps) {
7453        void 0 === deps || null === deps || isArrayImpl(deps) || console.error(
7454          "%s received a final argument that is not an array (instead, received `%s`). When specified, the final argument must be an array.",
7455          currentHookNameInDev,
7456          typeof deps
7457        );
7458      }
7459      function warnOnUseFormStateInDev() {
7460        var componentName2 = getComponentNameFromFiber(currentlyRenderingFiber);
7461        didWarnAboutUseFormState.has(componentName2) || (didWarnAboutUseFormState.add(componentName2), console.error(
7462          "ReactDOM.useFormState has been renamed to React.useActionState. Please update %s to use React.useActionState.",
7463          componentName2
7464        ));
7465      }
7466      function throwInvalidHookError() {
7467        throw Error(
7468          "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."
7469        );
7470      }
7471      function areHookInputsEqual(nextDeps, prevDeps) {
7472        if (ignorePreviousDependencies) return false;
7473        if (null === prevDeps)
7474          return console.error(
7475            "%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.",
7476            currentHookNameInDev
7477          ), false;
7478        nextDeps.length !== prevDeps.length && console.error(
7479          "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",
7480          currentHookNameInDev,
7481          "[" + prevDeps.join(", ") + "]",
7482          "[" + nextDeps.join(", ") + "]"
7483        );
7484        for (var i3 = 0; i3 < prevDeps.length && i3 < nextDeps.length; i3++)
7485          if (!objectIs(nextDeps[i3], prevDeps[i3])) return false;
7486        return true;
7487      }
7488      function renderWithHooks(current2, workInProgress2, Component, props, secondArg, nextRenderLanes) {
7489        renderLanes = nextRenderLanes;
7490        currentlyRenderingFiber = workInProgress2;
7491        hookTypesDev = null !== current2 ? current2._debugHookTypes : null;
7492        hookTypesUpdateIndexDev = -1;
7493        ignorePreviousDependencies = null !== current2 && current2.type !== workInProgress2.type;
7494        if ("[object AsyncFunction]" === Object.prototype.toString.call(Component) || "[object AsyncGeneratorFunction]" === Object.prototype.toString.call(Component))
7495          nextRenderLanes = getComponentNameFromFiber(currentlyRenderingFiber), didWarnAboutAsyncClientComponent.has(nextRenderLanes) || (didWarnAboutAsyncClientComponent.add(nextRenderLanes), console.error(
7496            "%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.",
7497            null === nextRenderLanes ? "An unknown Component" : "<" + nextRenderLanes + ">"
7498          ));
7499        workInProgress2.memoizedState = null;
7500        workInProgress2.updateQueue = null;
7501        workInProgress2.lanes = 0;
7502        ReactSharedInternals.H = null !== current2 && null !== current2.memoizedState ? HooksDispatcherOnUpdateInDEV : null !== hookTypesDev ? HooksDispatcherOnMountWithHookTypesInDEV : HooksDispatcherOnMountInDEV;
7503        shouldDoubleInvokeUserFnsInHooksDEV = nextRenderLanes = (workInProgress2.mode & StrictLegacyMode) !== NoMode;
7504        var children = callComponentInDEV(Component, props, secondArg);
7505        shouldDoubleInvokeUserFnsInHooksDEV = false;
7506        didScheduleRenderPhaseUpdateDuringThisPass && (children = renderWithHooksAgain(
7507          workInProgress2,
7508          Component,
7509          props,
7510          secondArg
7511        ));
7512        if (nextRenderLanes) {
7513          setIsStrictModeForDevtools(true);
7514          try {
7515            children = renderWithHooksAgain(
7516              workInProgress2,
7517              Component,
7518              props,
7519              secondArg
7520            );
7521          } finally {
7522            setIsStrictModeForDevtools(false);
7523          }
7524        }
7525        finishRenderingHooks(current2, workInProgress2);
7526        return children;
7527      }
7528      function finishRenderingHooks(current2, workInProgress2) {
7529        workInProgress2._debugHookTypes = hookTypesDev;
7530        null === workInProgress2.dependencies ? null !== thenableState && (workInProgress2.dependencies = {
7531          lanes: 0,
7532          firstContext: null,
7533          _debugThenableState: thenableState
7534        }) : workInProgress2.dependencies._debugThenableState = thenableState;
7535        ReactSharedInternals.H = ContextOnlyDispatcher;
7536        var didRenderTooFewHooks = null !== currentHook && null !== currentHook.next;
7537        renderLanes = 0;
7538        hookTypesDev = currentHookNameInDev = workInProgressHook = currentHook = currentlyRenderingFiber = null;
7539        hookTypesUpdateIndexDev = -1;
7540        null !== current2 && (current2.flags & 65011712) !== (workInProgress2.flags & 65011712) && console.error(
7541          "Internal React error: Expected static flag was missing. Please notify the React team."
7542        );
7543        didScheduleRenderPhaseUpdate = false;
7544        thenableIndexCounter = 0;
7545        thenableState = null;
7546        if (didRenderTooFewHooks)
7547          throw Error(
7548            "Rendered fewer hooks than expected. This may be caused by an accidental early return statement."
7549          );
7550        null === current2 || didReceiveUpdate || (current2 = current2.dependencies, null !== current2 && checkIfContextChanged(current2) && (didReceiveUpdate = true));
7551        needsToResetSuspendedThenableDEV ? (needsToResetSuspendedThenableDEV = false, current2 = true) : current2 = false;
7552        current2 && (workInProgress2 = getComponentNameFromFiber(workInProgress2) || "Unknown", didWarnAboutUseWrappedInTryCatch.has(workInProgress2) || didWarnAboutAsyncClientComponent.has(workInProgress2) || (didWarnAboutUseWrappedInTryCatch.add(workInProgress2), console.error(
7553          "`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."
7554        )));
7555      }
7556      function renderWithHooksAgain(workInProgress2, Component, props, secondArg) {
7557        currentlyRenderingFiber = workInProgress2;
7558        var numberOfReRenders = 0;
7559        do {
7560          didScheduleRenderPhaseUpdateDuringThisPass && (thenableState = null);
7561          thenableIndexCounter = 0;
7562          didScheduleRenderPhaseUpdateDuringThisPass = false;
7563          if (numberOfReRenders >= RE_RENDER_LIMIT)
7564            throw Error(
7565              "Too many re-renders. React limits the number of renders to prevent an infinite loop."
7566            );
7567          numberOfReRenders += 1;
7568          ignorePreviousDependencies = false;
7569          workInProgressHook = currentHook = null;
7570          if (null != workInProgress2.updateQueue) {
7571            var children = workInProgress2.updateQueue;
7572            children.lastEffect = null;
7573            children.events = null;
7574            children.stores = null;
7575            null != children.memoCache && (children.memoCache.index = 0);
7576          }
7577          hookTypesUpdateIndexDev = -1;
7578          ReactSharedInternals.H = HooksDispatcherOnRerenderInDEV;
7579          children = callComponentInDEV(Component, props, secondArg);
7580        } while (didScheduleRenderPhaseUpdateDuringThisPass);
7581        return children;
7582      }
7583      function TransitionAwareHostComponent() {
7584        var dispatcher = ReactSharedInternals.H, maybeThenable = dispatcher.useState()[0];
7585        maybeThenable = "function" === typeof maybeThenable.then ? useThenable(maybeThenable) : maybeThenable;
7586        dispatcher = dispatcher.useState()[0];
7587        (null !== currentHook ? currentHook.memoizedState : null) !== dispatcher && (currentlyRenderingFiber.flags |= 1024);
7588        return maybeThenable;
7589      }
7590      function checkDidRenderIdHook() {
7591        var didRenderIdHook = 0 !== localIdCounter;
7592        localIdCounter = 0;
7593        return didRenderIdHook;
7594      }
7595      function bailoutHooks(current2, workInProgress2, lanes) {
7596        workInProgress2.updateQueue = current2.updateQueue;
7597        workInProgress2.flags = (workInProgress2.mode & StrictEffectsMode) !== NoMode ? workInProgress2.flags & -402655237 : workInProgress2.flags & -2053;
7598        current2.lanes &= ~lanes;
7599      }
7600      function resetHooksOnUnwind(workInProgress2) {
7601        if (didScheduleRenderPhaseUpdate) {
7602          for (workInProgress2 = workInProgress2.memoizedState; null !== workInProgress2; ) {
7603            var queue = workInProgress2.queue;
7604            null !== queue && (queue.pending = null);
7605            workInProgress2 = workInProgress2.next;
7606          }
7607          didScheduleRenderPhaseUpdate = false;
7608        }
7609        renderLanes = 0;
7610        hookTypesDev = workInProgressHook = currentHook = currentlyRenderingFiber = null;
7611        hookTypesUpdateIndexDev = -1;
7612        currentHookNameInDev = null;
7613        didScheduleRenderPhaseUpdateDuringThisPass = false;
7614        thenableIndexCounter = localIdCounter = 0;
7615        thenableState = null;
7616      }
7617      function mountWorkInProgressHook() {
7618        var hook = {
7619          memoizedState: null,
7620          baseState: null,
7621          baseQueue: null,
7622          queue: null,
7623          next: null
7624        };
7625        null === workInProgressHook ? currentlyRenderingFiber.memoizedState = workInProgressHook = hook : workInProgressHook = workInProgressHook.next = hook;
7626        return workInProgressHook;
7627      }
7628      function updateWorkInProgressHook() {
7629        if (null === currentHook) {
7630          var nextCurrentHook = currentlyRenderingFiber.alternate;
7631          nextCurrentHook = null !== nextCurrentHook ? nextCurrentHook.memoizedState : null;
7632        } else nextCurrentHook = currentHook.next;
7633        var nextWorkInProgressHook = null === workInProgressHook ? currentlyRenderingFiber.memoizedState : workInProgressHook.next;
7634        if (null !== nextWorkInProgressHook)
7635          workInProgressHook = nextWorkInProgressHook, currentHook = nextCurrentHook;
7636        else {
7637          if (null === nextCurrentHook) {
7638            if (null === currentlyRenderingFiber.alternate)
7639              throw Error(
7640                "Update hook called on initial render. This is likely a bug in React. Please file an issue."
7641              );
7642            throw Error("Rendered more hooks than during the previous render.");
7643          }
7644          currentHook = nextCurrentHook;
7645          nextCurrentHook = {
7646            memoizedState: currentHook.memoizedState,
7647            baseState: currentHook.baseState,
7648            baseQueue: currentHook.baseQueue,
7649            queue: currentHook.queue,
7650            next: null
7651          };
7652          null === workInProgressHook ? currentlyRenderingFiber.memoizedState = workInProgressHook = nextCurrentHook : workInProgressHook = workInProgressHook.next = nextCurrentHook;
7653        }
7654        return workInProgressHook;
7655      }
7656      function createFunctionComponentUpdateQueue() {
7657        return { lastEffect: null, events: null, stores: null, memoCache: null };
7658      }
7659      function useThenable(thenable) {
7660        var index = thenableIndexCounter;
7661        thenableIndexCounter += 1;
7662        null === thenableState && (thenableState = createThenableState());
7663        thenable = trackUsedThenable(thenableState, thenable, index);
7664        index = currentlyRenderingFiber;
7665        null === (null === workInProgressHook ? index.memoizedState : workInProgressHook.next) && (index = index.alternate, ReactSharedInternals.H = null !== index && null !== index.memoizedState ? HooksDispatcherOnUpdateInDEV : HooksDispatcherOnMountInDEV);
7666        return thenable;
7667      }
7668      function use(usable) {
7669        if (null !== usable && "object" === typeof usable) {
7670          if ("function" === typeof usable.then) return useThenable(usable);
7671          if (usable.$$typeof === REACT_CONTEXT_TYPE) return readContext(usable);
7672        }
7673        throw Error("An unsupported type was passed to use(): " + String(usable));
7674      }
7675      function useMemoCache(size) {
7676        var memoCache = null, updateQueue = currentlyRenderingFiber.updateQueue;
7677        null !== updateQueue && (memoCache = updateQueue.memoCache);
7678        if (null == memoCache) {
7679          var current2 = currentlyRenderingFiber.alternate;
7680          null !== current2 && (current2 = current2.updateQueue, null !== current2 && (current2 = current2.memoCache, null != current2 && (memoCache = {
7681            data: current2.data.map(function(array) {
7682              return array.slice();
7683            }),
7684            index: 0
7685          })));
7686        }
7687        null == memoCache && (memoCache = { data: [], index: 0 });
7688        null === updateQueue && (updateQueue = createFunctionComponentUpdateQueue(), currentlyRenderingFiber.updateQueue = updateQueue);
7689        updateQueue.memoCache = memoCache;
7690        updateQueue = memoCache.data[memoCache.index];
7691        if (void 0 === updateQueue || ignorePreviousDependencies)
7692          for (updateQueue = memoCache.data[memoCache.index] = Array(size), current2 = 0; current2 < size; current2++)
7693            updateQueue[current2] = REACT_MEMO_CACHE_SENTINEL;
7694        else
7695          updateQueue.length !== size && console.error(
7696            "Expected a constant size argument for each invocation of useMemoCache. The previous cache was allocated with size %s but size %s was requested.",
7697            updateQueue.length,
7698            size
7699          );
7700        memoCache.index++;
7701        return updateQueue;
7702      }
7703      function basicStateReducer(state, action) {
7704        return "function" === typeof action ? action(state) : action;
7705      }
7706      function mountReducer(reducer, initialArg, init) {
7707        var hook = mountWorkInProgressHook();
7708        if (void 0 !== init) {
7709          var initialState = init(initialArg);
7710          if (shouldDoubleInvokeUserFnsInHooksDEV) {
7711            setIsStrictModeForDevtools(true);
7712            try {
7713              init(initialArg);
7714            } finally {
7715              setIsStrictModeForDevtools(false);
7716            }
7717          }
7718        } else initialState = initialArg;
7719        hook.memoizedState = hook.baseState = initialState;
7720        reducer = {
7721          pending: null,
7722          lanes: 0,
7723          dispatch: null,
7724          lastRenderedReducer: reducer,
7725          lastRenderedState: initialState
7726        };
7727        hook.queue = reducer;
7728        reducer = reducer.dispatch = dispatchReducerAction.bind(
7729          null,
7730          currentlyRenderingFiber,
7731          reducer
7732        );
7733        return [hook.memoizedState, reducer];
7734      }
7735      function updateReducer(reducer) {
7736        var hook = updateWorkInProgressHook();
7737        return updateReducerImpl(hook, currentHook, reducer);
7738      }
7739      function updateReducerImpl(hook, current2, reducer) {
7740        var queue = hook.queue;
7741        if (null === queue)
7742          throw Error(
7743            "Should have a queue. You are likely calling Hooks conditionally, which is not allowed. (https://react.dev/link/invalid-hook-call)"
7744          );
7745        queue.lastRenderedReducer = reducer;
7746        var baseQueue = hook.baseQueue, pendingQueue = queue.pending;
7747        if (null !== pendingQueue) {
7748          if (null !== baseQueue) {
7749            var baseFirst = baseQueue.next;
7750            baseQueue.next = pendingQueue.next;
7751            pendingQueue.next = baseFirst;
7752          }
7753          current2.baseQueue !== baseQueue && console.error(
7754            "Internal error: Expected work-in-progress queue to be a clone. This is a bug in React."
7755          );
7756          current2.baseQueue = baseQueue = pendingQueue;
7757          queue.pending = null;
7758        }
7759        pendingQueue = hook.baseState;
7760        if (null === baseQueue) hook.memoizedState = pendingQueue;
7761        else {
7762          current2 = baseQueue.next;
7763          var newBaseQueueFirst = baseFirst = null, newBaseQueueLast = null, update = current2, didReadFromEntangledAsyncAction2 = false;
7764          do {
7765            var updateLane = update.lane & -536870913;
7766            if (updateLane !== update.lane ? (workInProgressRootRenderLanes & updateLane) === updateLane : (renderLanes & updateLane) === updateLane) {
7767              var revertLane = update.revertLane;
7768              if (0 === revertLane)
7769                null !== newBaseQueueLast && (newBaseQueueLast = newBaseQueueLast.next = {
7770                  lane: 0,
7771                  revertLane: 0,
7772                  gesture: null,
7773                  action: update.action,
7774                  hasEagerState: update.hasEagerState,
7775                  eagerState: update.eagerState,
7776                  next: null
7777                }), updateLane === currentEntangledLane && (didReadFromEntangledAsyncAction2 = true);
7778              else if ((renderLanes & revertLane) === revertLane) {
7779                update = update.next;
7780                revertLane === currentEntangledLane && (didReadFromEntangledAsyncAction2 = true);
7781                continue;
7782              } else
7783                updateLane = {
7784                  lane: 0,
7785                  revertLane: update.revertLane,
7786                  gesture: null,
7787                  action: update.action,
7788                  hasEagerState: update.hasEagerState,
7789                  eagerState: update.eagerState,
7790                  next: null
7791                }, null === newBaseQueueLast ? (newBaseQueueFirst = newBaseQueueLast = updateLane, baseFirst = pendingQueue) : newBaseQueueLast = newBaseQueueLast.next = updateLane, currentlyRenderingFiber.lanes |= revertLane, workInProgressRootSkippedLanes |= revertLane;
7792              updateLane = update.action;
7793              shouldDoubleInvokeUserFnsInHooksDEV && reducer(pendingQueue, updateLane);
7794              pendingQueue = update.hasEagerState ? update.eagerState : reducer(pendingQueue, updateLane);
7795            } else
7796              revertLane = {
7797                lane: updateLane,
7798                revertLane: update.revertLane,
7799                gesture: update.gesture,
7800                action: update.action,
7801                hasEagerState: update.hasEagerState,
7802                eagerState: update.eagerState,
7803                next: null
7804              }, null === newBaseQueueLast ? (newBaseQueueFirst = newBaseQueueLast = revertLane, baseFirst = pendingQueue) : newBaseQueueLast = newBaseQueueLast.next = revertLane, currentlyRenderingFiber.lanes |= updateLane, workInProgressRootSkippedLanes |= updateLane;
7805            update = update.next;
7806          } while (null !== update && update !== current2);
7807          null === newBaseQueueLast ? baseFirst = pendingQueue : newBaseQueueLast.next = newBaseQueueFirst;
7808          if (!objectIs(pendingQueue, hook.memoizedState) && (didReceiveUpdate = true, didReadFromEntangledAsyncAction2 && (reducer = currentEntangledActionThenable, null !== reducer)))
7809            throw reducer;
7810          hook.memoizedState = pendingQueue;
7811          hook.baseState = baseFirst;
7812          hook.baseQueue = newBaseQueueLast;
7813          queue.lastRenderedState = pendingQueue;
7814        }
7815        null === baseQueue && (queue.lanes = 0);
7816        return [hook.memoizedState, queue.dispatch];
7817      }
7818      function rerenderReducer(reducer) {
7819        var hook = updateWorkInProgressHook(), queue = hook.queue;
7820        if (null === queue)
7821          throw Error(
7822            "Should have a queue. You are likely calling Hooks conditionally, which is not allowed. (https://react.dev/link/invalid-hook-call)"
7823          );
7824        queue.lastRenderedReducer = reducer;
7825        var dispatch2 = queue.dispatch, lastRenderPhaseUpdate = queue.pending, newState = hook.memoizedState;
7826        if (null !== lastRenderPhaseUpdate) {
7827          queue.pending = null;
7828          var update = lastRenderPhaseUpdate = lastRenderPhaseUpdate.next;
7829          do
7830            newState = reducer(newState, update.action), update = update.next;
7831          while (update !== lastRenderPhaseUpdate);
7832          objectIs(newState, hook.memoizedState) || (didReceiveUpdate = true);
7833          hook.memoizedState = newState;
7834          null === hook.baseQueue && (hook.baseState = newState);
7835          queue.lastRenderedState = newState;
7836        }
7837        return [newState, dispatch2];
7838      }
7839      function mountSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
7840        var fiber = currentlyRenderingFiber, hook = mountWorkInProgressHook();
7841        if (isHydrating) {
7842          if (void 0 === getServerSnapshot)
7843            throw Error(
7844              "Missing getServerSnapshot, which is required for server-rendered content. Will revert to client rendering."
7845            );
7846          var nextSnapshot = getServerSnapshot();
7847          didWarnUncachedGetSnapshot || nextSnapshot === getServerSnapshot() || (console.error(
7848            "The result of getServerSnapshot should be cached to avoid an infinite loop"
7849          ), didWarnUncachedGetSnapshot = true);
7850        } else {
7851          nextSnapshot = getSnapshot();
7852          didWarnUncachedGetSnapshot || (getServerSnapshot = getSnapshot(), objectIs(nextSnapshot, getServerSnapshot) || (console.error(
7853            "The result of getSnapshot should be cached to avoid an infinite loop"
7854          ), didWarnUncachedGetSnapshot = true));
7855          if (null === workInProgressRoot)
7856            throw Error(
7857              "Expected a work-in-progress root. This is a bug in React. Please file an issue."
7858            );
7859          0 !== (workInProgressRootRenderLanes & 127) || pushStoreConsistencyCheck(fiber, getSnapshot, nextSnapshot);
7860        }
7861        hook.memoizedState = nextSnapshot;
7862        getServerSnapshot = { value: nextSnapshot, getSnapshot };
7863        hook.queue = getServerSnapshot;
7864        mountEffect(
7865          subscribeToStore.bind(null, fiber, getServerSnapshot, subscribe),
7866          [subscribe]
7867        );
7868        fiber.flags |= 2048;
7869        pushSimpleEffect(
7870          HasEffect | Passive,
7871          { destroy: void 0 },
7872          updateStoreInstance.bind(
7873            null,
7874            fiber,
7875            getServerSnapshot,
7876            nextSnapshot,
7877            getSnapshot
7878          ),
7879          null
7880        );
7881        return nextSnapshot;
7882      }
7883      function updateSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
7884        var fiber = currentlyRenderingFiber, hook = updateWorkInProgressHook(), isHydrating$jscomp$0 = isHydrating;
7885        if (isHydrating$jscomp$0) {
7886          if (void 0 === getServerSnapshot)
7887            throw Error(
7888              "Missing getServerSnapshot, which is required for server-rendered content. Will revert to client rendering."
7889            );
7890          getServerSnapshot = getServerSnapshot();
7891        } else if (getServerSnapshot = getSnapshot(), !didWarnUncachedGetSnapshot) {
7892          var cachedSnapshot = getSnapshot();
7893          objectIs(getServerSnapshot, cachedSnapshot) || (console.error(
7894            "The result of getSnapshot should be cached to avoid an infinite loop"
7895          ), didWarnUncachedGetSnapshot = true);
7896        }
7897        if (cachedSnapshot = !objectIs(
7898          (currentHook || hook).memoizedState,
7899          getServerSnapshot
7900        ))
7901          hook.memoizedState = getServerSnapshot, didReceiveUpdate = true;
7902        hook = hook.queue;
7903        var create = subscribeToStore.bind(null, fiber, hook, subscribe);
7904        updateEffectImpl(2048, Passive, create, [subscribe]);
7905        if (hook.getSnapshot !== getSnapshot || cachedSnapshot || null !== workInProgressHook && workInProgressHook.memoizedState.tag & HasEffect) {
7906          fiber.flags |= 2048;
7907          pushSimpleEffect(
7908            HasEffect | Passive,
7909            { destroy: void 0 },
7910            updateStoreInstance.bind(
7911              null,
7912              fiber,
7913              hook,
7914              getServerSnapshot,
7915              getSnapshot
7916            ),
7917            null
7918          );
7919          if (null === workInProgressRoot)
7920            throw Error(
7921              "Expected a work-in-progress root. This is a bug in React. Please file an issue."
7922            );
7923          isHydrating$jscomp$0 || 0 !== (renderLanes & 127) || pushStoreConsistencyCheck(fiber, getSnapshot, getServerSnapshot);
7924        }
7925        return getServerSnapshot;
7926      }
7927      function pushStoreConsistencyCheck(fiber, getSnapshot, renderedSnapshot) {
7928        fiber.flags |= 16384;
7929        fiber = { getSnapshot, value: renderedSnapshot };
7930        getSnapshot = currentlyRenderingFiber.updateQueue;
7931        null === getSnapshot ? (getSnapshot = createFunctionComponentUpdateQueue(), currentlyRenderingFiber.updateQueue = getSnapshot, getSnapshot.stores = [fiber]) : (renderedSnapshot = getSnapshot.stores, null === renderedSnapshot ? getSnapshot.stores = [fiber] : renderedSnapshot.push(fiber));
7932      }
7933      function updateStoreInstance(fiber, inst, nextSnapshot, getSnapshot) {
7934        inst.value = nextSnapshot;
7935        inst.getSnapshot = getSnapshot;
7936        checkIfSnapshotChanged(inst) && forceStoreRerender(fiber);
7937      }
7938      function subscribeToStore(fiber, inst, subscribe) {
7939        return subscribe(function() {
7940          checkIfSnapshotChanged(inst) && (startUpdateTimerByLane(2, "updateSyncExternalStore()", fiber), forceStoreRerender(fiber));
7941        });
7942      }
7943      function checkIfSnapshotChanged(inst) {
7944        var latestGetSnapshot = inst.getSnapshot;
7945        inst = inst.value;
7946        try {
7947          var nextValue = latestGetSnapshot();
7948          return !objectIs(inst, nextValue);
7949        } catch (error2) {
7950          return true;
7951        }
7952      }
7953      function forceStoreRerender(fiber) {
7954        var root3 = enqueueConcurrentRenderForLane(fiber, 2);
7955        null !== root3 && scheduleUpdateOnFiber(root3, fiber, 2);
7956      }
7957      function mountStateImpl(initialState) {
7958        var hook = mountWorkInProgressHook();
7959        if ("function" === typeof initialState) {
7960          var initialStateInitializer = initialState;
7961          initialState = initialStateInitializer();
7962          if (shouldDoubleInvokeUserFnsInHooksDEV) {
7963            setIsStrictModeForDevtools(true);
7964            try {
7965              initialStateInitializer();
7966            } finally {
7967              setIsStrictModeForDevtools(false);
7968            }
7969          }
7970        }
7971        hook.memoizedState = hook.baseState = initialState;
7972        hook.queue = {
7973          pending: null,
7974          lanes: 0,
7975          dispatch: null,
7976          lastRenderedReducer: basicStateReducer,
7977          lastRenderedState: initialState
7978        };
7979        return hook;
7980      }
7981      function mountState(initialState) {
7982        initialState = mountStateImpl(initialState);
7983        var queue = initialState.queue, dispatch2 = dispatchSetState.bind(null, currentlyRenderingFiber, queue);
7984        queue.dispatch = dispatch2;
7985        return [initialState.memoizedState, dispatch2];
7986      }
7987      function mountOptimistic(passthrough) {
7988        var hook = mountWorkInProgressHook();
7989        hook.memoizedState = hook.baseState = passthrough;
7990        var queue = {
7991          pending: null,
7992          lanes: 0,
7993          dispatch: null,
7994          lastRenderedReducer: null,
7995          lastRenderedState: null
7996        };
7997        hook.queue = queue;
7998        hook = dispatchOptimisticSetState.bind(
7999          null,
8000          currentlyRenderingFiber,
8001          true,
8002          queue
8003        );
8004        queue.dispatch = hook;
8005        return [passthrough, hook];
8006      }
8007      function updateOptimistic(passthrough, reducer) {
8008        var hook = updateWorkInProgressHook();
8009        return updateOptimisticImpl(hook, currentHook, passthrough, reducer);
8010      }
8011      function updateOptimisticImpl(hook, current2, passthrough, reducer) {
8012        hook.baseState = passthrough;
8013        return updateReducerImpl(
8014          hook,
8015          currentHook,
8016          "function" === typeof reducer ? reducer : basicStateReducer
8017        );
8018      }
8019      function rerenderOptimistic(passthrough, reducer) {
8020        var hook = updateWorkInProgressHook();
8021        if (null !== currentHook)
8022          return updateOptimisticImpl(hook, currentHook, passthrough, reducer);
8023        hook.baseState = passthrough;
8024        return [passthrough, hook.queue.dispatch];
8025      }
8026      function dispatchActionState(fiber, actionQueue, setPendingState, setState, payload) {
8027        if (isRenderPhaseUpdate(fiber))
8028          throw Error("Cannot update form state while rendering.");
8029        fiber = actionQueue.action;
8030        if (null !== fiber) {
8031          var actionNode = {
8032            payload,
8033            action: fiber,
8034            next: null,
8035            isTransition: true,
8036            status: "pending",
8037            value: null,
8038            reason: null,
8039            listeners: [],
8040            then: function(listener) {
8041              actionNode.listeners.push(listener);
8042            }
8043          };
8044          null !== ReactSharedInternals.T ? setPendingState(true) : actionNode.isTransition = false;
8045          setState(actionNode);
8046          setPendingState = actionQueue.pending;
8047          null === setPendingState ? (actionNode.next = actionQueue.pending = actionNode, runActionStateAction(actionQueue, actionNode)) : (actionNode.next = setPendingState.next, actionQueue.pending = setPendingState.next = actionNode);
8048        }
8049      }
8050      function runActionStateAction(actionQueue, node) {
8051        var action = node.action, payload = node.payload, prevState = actionQueue.state;
8052        if (node.isTransition) {
8053          var prevTransition = ReactSharedInternals.T, currentTransition = {};
8054          currentTransition._updatedFibers = /* @__PURE__ */ new Set();
8055          ReactSharedInternals.T = currentTransition;
8056          try {
8057            var returnValue = action(prevState, payload), onStartTransitionFinish = ReactSharedInternals.S;
8058            null !== onStartTransitionFinish && onStartTransitionFinish(currentTransition, returnValue);
8059            handleActionReturnValue(actionQueue, node, returnValue);
8060          } catch (error2) {
8061            onActionError(actionQueue, node, error2);
8062          } finally {
8063            null !== prevTransition && null !== currentTransition.types && (null !== prevTransition.types && prevTransition.types !== currentTransition.types && console.error(
8064              "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."
8065            ), prevTransition.types = currentTransition.types), ReactSharedInternals.T = prevTransition, null === prevTransition && currentTransition._updatedFibers && (actionQueue = currentTransition._updatedFibers.size, currentTransition._updatedFibers.clear(), 10 < actionQueue && console.warn(
8066              "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."
8067            ));
8068          }
8069        } else
8070          try {
8071            currentTransition = action(prevState, payload), handleActionReturnValue(actionQueue, node, currentTransition);
8072          } catch (error$4) {
8073            onActionError(actionQueue, node, error$4);
8074          }
8075      }
8076      function handleActionReturnValue(actionQueue, node, returnValue) {
8077        null !== returnValue && "object" === typeof returnValue && "function" === typeof returnValue.then ? (ReactSharedInternals.asyncTransitions++, returnValue.then(releaseAsyncTransition, releaseAsyncTransition), returnValue.then(
8078          function(nextState) {
8079            onActionSuccess(actionQueue, node, nextState);
8080          },
8081          function(error2) {
8082            return onActionError(actionQueue, node, error2);
8083          }
8084        ), node.isTransition || console.error(
8085          "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."
8086        )) : onActionSuccess(actionQueue, node, returnValue);
8087      }
8088      function onActionSuccess(actionQueue, actionNode, nextState) {
8089        actionNode.status = "fulfilled";
8090        actionNode.value = nextState;
8091        notifyActionListeners(actionNode);
8092        actionQueue.state = nextState;
8093        actionNode = actionQueue.pending;
8094        null !== actionNode && (nextState = actionNode.next, nextState === actionNode ? actionQueue.pending = null : (nextState = nextState.next, actionNode.next = nextState, runActionStateAction(actionQueue, nextState)));
8095      }
8096      function onActionError(actionQueue, actionNode, error2) {
8097        var last = actionQueue.pending;
8098        actionQueue.pending = null;
8099        if (null !== last) {
8100          last = last.next;
8101          do
8102            actionNode.status = "rejected", actionNode.reason = error2, notifyActionListeners(actionNode), actionNode = actionNode.next;
8103          while (actionNode !== last);
8104        }
8105        actionQueue.action = null;
8106      }
8107      function notifyActionListeners(actionNode) {
8108        actionNode = actionNode.listeners;
8109        for (var i3 = 0; i3 < actionNode.length; i3++) (0, actionNode[i3])();
8110      }
8111      function actionStateReducer(oldState, newState) {
8112        return newState;
8113      }
8114      function mountActionState(action, initialStateProp) {
8115        if (isHydrating) {
8116          var ssrFormState = workInProgressRoot.formState;
8117          if (null !== ssrFormState) {
8118            a: {
8119              var isMatching = currentlyRenderingFiber;
8120              if (isHydrating) {
8121                if (nextHydratableInstance) {
8122                  b: {
8123                    var markerInstance = nextHydratableInstance;
8124                    for (var inRootOrSingleton = rootOrSingletonContext; 8 !== markerInstance.nodeType; ) {
8125                      if (!inRootOrSingleton) {
8126                        markerInstance = null;
8127                        break b;
8128                      }
8129                      markerInstance = getNextHydratable(
8130                        markerInstance.nextSibling
8131                      );
8132                      if (null === markerInstance) {
8133                        markerInstance = null;
8134                        break b;
8135                      }
8136                    }
8137                    inRootOrSingleton = markerInstance.data;
8138                    markerInstance = inRootOrSingleton === FORM_STATE_IS_MATCHING || inRootOrSingleton === FORM_STATE_IS_NOT_MATCHING ? markerInstance : null;
8139                  }
8140                  if (markerInstance) {
8141                    nextHydratableInstance = getNextHydratable(
8142                      markerInstance.nextSibling
8143                    );
8144                    isMatching = markerInstance.data === FORM_STATE_IS_MATCHING;
8145                    break a;
8146                  }
8147                }
8148                throwOnHydrationMismatch(isMatching);
8149              }
8150              isMatching = false;
8151            }
8152            isMatching && (initialStateProp = ssrFormState[0]);
8153          }
8154        }
8155        ssrFormState = mountWorkInProgressHook();
8156        ssrFormState.memoizedState = ssrFormState.baseState = initialStateProp;
8157        isMatching = {
8158          pending: null,
8159          lanes: 0,
8160          dispatch: null,
8161          lastRenderedReducer: actionStateReducer,
8162          lastRenderedState: initialStateProp
8163        };
8164        ssrFormState.queue = isMatching;
8165        ssrFormState = dispatchSetState.bind(
8166          null,
8167          currentlyRenderingFiber,
8168          isMatching
8169        );
8170        isMatching.dispatch = ssrFormState;
8171        isMatching = mountStateImpl(false);
8172        inRootOrSingleton = dispatchOptimisticSetState.bind(
8173          null,
8174          currentlyRenderingFiber,
8175          false,
8176          isMatching.queue
8177        );
8178        isMatching = mountWorkInProgressHook();
8179        markerInstance = {
8180          state: initialStateProp,
8181          dispatch: null,
8182          action,
8183          pending: null
8184        };
8185        isMatching.queue = markerInstance;
8186        ssrFormState = dispatchActionState.bind(
8187          null,
8188          currentlyRenderingFiber,
8189          markerInstance,
8190          inRootOrSingleton,
8191          ssrFormState
8192        );
8193        markerInstance.dispatch = ssrFormState;
8194        isMatching.memoizedState = action;
8195        return [initialStateProp, ssrFormState, false];
8196      }
8197      function updateActionState(action) {
8198        var stateHook = updateWorkInProgressHook();
8199        return updateActionStateImpl(stateHook, currentHook, action);
8200      }
8201      function updateActionStateImpl(stateHook, currentStateHook, action) {
8202        currentStateHook = updateReducerImpl(
8203          stateHook,
8204          currentStateHook,
8205          actionStateReducer
8206        )[0];
8207        stateHook = updateReducer(basicStateReducer)[0];
8208        if ("object" === typeof currentStateHook && null !== currentStateHook && "function" === typeof currentStateHook.then)
8209          try {
8210            var state = useThenable(currentStateHook);
8211          } catch (x3) {
8212            if (x3 === SuspenseException) throw SuspenseActionException;
8213            throw x3;
8214          }
8215        else state = currentStateHook;
8216        currentStateHook = updateWorkInProgressHook();
8217        var actionQueue = currentStateHook.queue, dispatch2 = actionQueue.dispatch;
8218        action !== currentStateHook.memoizedState && (currentlyRenderingFiber.flags |= 2048, pushSimpleEffect(
8219          HasEffect | Passive,
8220          { destroy: void 0 },
8221          actionStateActionEffect.bind(null, actionQueue, action),
8222          null
8223        ));
8224        return [state, dispatch2, stateHook];
8225      }
8226      function actionStateActionEffect(actionQueue, action) {
8227        actionQueue.action = action;
8228      }
8229      function rerenderActionState(action) {
8230        var stateHook = updateWorkInProgressHook(), currentStateHook = currentHook;
8231        if (null !== currentStateHook)
8232          return updateActionStateImpl(stateHook, currentStateHook, action);
8233        updateWorkInProgressHook();
8234        stateHook = stateHook.memoizedState;
8235        currentStateHook = updateWorkInProgressHook();
8236        var dispatch2 = currentStateHook.queue.dispatch;
8237        currentStateHook.memoizedState = action;
8238        return [stateHook, dispatch2, false];
8239      }
8240      function pushSimpleEffect(tag, inst, create, deps) {
8241        tag = { tag, create, deps, inst, next: null };
8242        inst = currentlyRenderingFiber.updateQueue;
8243        null === inst && (inst = createFunctionComponentUpdateQueue(), currentlyRenderingFiber.updateQueue = inst);
8244        create = inst.lastEffect;
8245        null === create ? inst.lastEffect = tag.next = tag : (deps = create.next, create.next = tag, tag.next = deps, inst.lastEffect = tag);
8246        return tag;
8247      }
8248      function mountRef(initialValue) {
8249        var hook = mountWorkInProgressHook();
8250        initialValue = { current: initialValue };
8251        return hook.memoizedState = initialValue;
8252      }
8253      function mountEffectImpl(fiberFlags, hookFlags, create, deps) {
8254        var hook = mountWorkInProgressHook();
8255        currentlyRenderingFiber.flags |= fiberFlags;
8256        hook.memoizedState = pushSimpleEffect(
8257          HasEffect | hookFlags,
8258          { destroy: void 0 },
8259          create,
8260          void 0 === deps ? null : deps
8261        );
8262      }
8263      function updateEffectImpl(fiberFlags, hookFlags, create, deps) {
8264        var hook = updateWorkInProgressHook();
8265        deps = void 0 === deps ? null : deps;
8266        var inst = hook.memoizedState.inst;
8267        null !== currentHook && null !== deps && areHookInputsEqual(deps, currentHook.memoizedState.deps) ? hook.memoizedState = pushSimpleEffect(hookFlags, inst, create, deps) : (currentlyRenderingFiber.flags |= fiberFlags, hook.memoizedState = pushSimpleEffect(
8268          HasEffect | hookFlags,
8269          inst,
8270          create,
8271          deps
8272        ));
8273      }
8274      function mountEffect(create, deps) {
8275        (currentlyRenderingFiber.mode & StrictEffectsMode) !== NoMode ? mountEffectImpl(276826112, Passive, create, deps) : mountEffectImpl(8390656, Passive, create, deps);
8276      }
8277      function useEffectEventImpl(payload) {
8278        currentlyRenderingFiber.flags |= 4;
8279        var componentUpdateQueue = currentlyRenderingFiber.updateQueue;
8280        if (null === componentUpdateQueue)
8281          componentUpdateQueue = createFunctionComponentUpdateQueue(), currentlyRenderingFiber.updateQueue = componentUpdateQueue, componentUpdateQueue.events = [payload];
8282        else {
8283          var events = componentUpdateQueue.events;
8284          null === events ? componentUpdateQueue.events = [payload] : events.push(payload);
8285        }
8286      }
8287      function mountEvent(callback) {
8288        var hook = mountWorkInProgressHook(), ref = { impl: callback };
8289        hook.memoizedState = ref;
8290        return function() {
8291          if ((executionContext & RenderContext) !== NoContext)
8292            throw Error(
8293              "A function wrapped in useEffectEvent can't be called during rendering."
8294            );
8295          return ref.impl.apply(void 0, arguments);
8296        };
8297      }
8298      function updateEvent(callback) {
8299        var ref = updateWorkInProgressHook().memoizedState;
8300        useEffectEventImpl({ ref, nextImpl: callback });
8301        return function() {
8302          if ((executionContext & RenderContext) !== NoContext)
8303            throw Error(
8304              "A function wrapped in useEffectEvent can't be called during rendering."
8305            );
8306          return ref.impl.apply(void 0, arguments);
8307        };
8308      }
8309      function mountLayoutEffect(create, deps) {
8310        var fiberFlags = 4194308;
8311        (currentlyRenderingFiber.mode & StrictEffectsMode) !== NoMode && (fiberFlags |= 134217728);
8312        return mountEffectImpl(fiberFlags, Layout, create, deps);
8313      }
8314      function imperativeHandleEffect(create, ref) {
8315        if ("function" === typeof ref) {
8316          create = create();
8317          var refCleanup = ref(create);
8318          return function() {
8319            "function" === typeof refCleanup ? refCleanup() : ref(null);
8320          };
8321        }
8322        if (null !== ref && void 0 !== ref)
8323          return ref.hasOwnProperty("current") || console.error(
8324            "Expected useImperativeHandle() first argument to either be a ref callback or React.createRef() object. Instead received: %s.",
8325            "an object with keys {" + Object.keys(ref).join(", ") + "}"
8326          ), create = create(), ref.current = create, function() {
8327            ref.current = null;
8328          };
8329      }
8330      function mountImperativeHandle(ref, create, deps) {
8331        "function" !== typeof create && console.error(
8332          "Expected useImperativeHandle() second argument to be a function that creates a handle. Instead received: %s.",
8333          null !== create ? typeof create : "null"
8334        );
8335        deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
8336        var fiberFlags = 4194308;
8337        (currentlyRenderingFiber.mode & StrictEffectsMode) !== NoMode && (fiberFlags |= 134217728);
8338        mountEffectImpl(
8339          fiberFlags,
8340          Layout,
8341          imperativeHandleEffect.bind(null, create, ref),
8342          deps
8343        );
8344      }
8345      function updateImperativeHandle(ref, create, deps) {
8346        "function" !== typeof create && console.error(
8347          "Expected useImperativeHandle() second argument to be a function that creates a handle. Instead received: %s.",
8348          null !== create ? typeof create : "null"
8349        );
8350        deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
8351        updateEffectImpl(
8352          4,
8353          Layout,
8354          imperativeHandleEffect.bind(null, create, ref),
8355          deps
8356        );
8357      }
8358      function mountCallback(callback, deps) {
8359        mountWorkInProgressHook().memoizedState = [
8360          callback,
8361          void 0 === deps ? null : deps
8362        ];
8363        return callback;
8364      }
8365      function updateCallback(callback, deps) {
8366        var hook = updateWorkInProgressHook();
8367        deps = void 0 === deps ? null : deps;
8368        var prevState = hook.memoizedState;
8369        if (null !== deps && areHookInputsEqual(deps, prevState[1]))
8370          return prevState[0];
8371        hook.memoizedState = [callback, deps];
8372        return callback;
8373      }
8374      function mountMemo(nextCreate, deps) {
8375        var hook = mountWorkInProgressHook();
8376        deps = void 0 === deps ? null : deps;
8377        var nextValue = nextCreate();
8378        if (shouldDoubleInvokeUserFnsInHooksDEV) {
8379          setIsStrictModeForDevtools(true);
8380          try {
8381            nextCreate();
8382          } finally {
8383            setIsStrictModeForDevtools(false);
8384          }
8385        }
8386        hook.memoizedState = [nextValue, deps];
8387        return nextValue;
8388      }
8389      function updateMemo(nextCreate, deps) {
8390        var hook = updateWorkInProgressHook();
8391        deps = void 0 === deps ? null : deps;
8392        var prevState = hook.memoizedState;
8393        if (null !== deps && areHookInputsEqual(deps, prevState[1]))
8394          return prevState[0];
8395        prevState = nextCreate();
8396        if (shouldDoubleInvokeUserFnsInHooksDEV) {
8397          setIsStrictModeForDevtools(true);
8398          try {
8399            nextCreate();
8400          } finally {
8401            setIsStrictModeForDevtools(false);
8402          }
8403        }
8404        hook.memoizedState = [prevState, deps];
8405        return prevState;
8406      }
8407      function mountDeferredValue(value, initialValue) {
8408        var hook = mountWorkInProgressHook();
8409        return mountDeferredValueImpl(hook, value, initialValue);
8410      }
8411      function updateDeferredValue(value, initialValue) {
8412        var hook = updateWorkInProgressHook();
8413        return updateDeferredValueImpl(
8414          hook,
8415          currentHook.memoizedState,
8416          value,
8417          initialValue
8418        );
8419      }
8420      function rerenderDeferredValue(value, initialValue) {
8421        var hook = updateWorkInProgressHook();
8422        return null === currentHook ? mountDeferredValueImpl(hook, value, initialValue) : updateDeferredValueImpl(
8423          hook,
8424          currentHook.memoizedState,
8425          value,
8426          initialValue
8427        );
8428      }
8429      function mountDeferredValueImpl(hook, value, initialValue) {
8430        if (void 0 === initialValue || 0 !== (renderLanes & 1073741824) && 0 === (workInProgressRootRenderLanes & 261930))
8431          return hook.memoizedState = value;
8432        hook.memoizedState = initialValue;
8433        hook = requestDeferredLane();
8434        currentlyRenderingFiber.lanes |= hook;
8435        workInProgressRootSkippedLanes |= hook;
8436        return initialValue;
8437      }
8438      function updateDeferredValueImpl(hook, prevValue, value, initialValue) {
8439        if (objectIs(value, prevValue)) return value;
8440        if (null !== currentTreeHiddenStackCursor.current)
8441          return hook = mountDeferredValueImpl(hook, value, initialValue), objectIs(hook, prevValue) || (didReceiveUpdate = true), hook;
8442        if (0 === (renderLanes & 42) || 0 !== (renderLanes & 1073741824) && 0 === (workInProgressRootRenderLanes & 261930))
8443          return didReceiveUpdate = true, hook.memoizedState = value;
8444        hook = requestDeferredLane();
8445        currentlyRenderingFiber.lanes |= hook;
8446        workInProgressRootSkippedLanes |= hook;
8447        return prevValue;
8448      }
8449      function releaseAsyncTransition() {
8450        ReactSharedInternals.asyncTransitions--;
8451      }
8452      function startTransition(fiber, queue, pendingState, finishedState, callback) {
8453        var previousPriority = ReactDOMSharedInternals.p;
8454        ReactDOMSharedInternals.p = 0 !== previousPriority && previousPriority < ContinuousEventPriority ? previousPriority : ContinuousEventPriority;
8455        var prevTransition = ReactSharedInternals.T, currentTransition = {};
8456        currentTransition._updatedFibers = /* @__PURE__ */ new Set();
8457        ReactSharedInternals.T = currentTransition;
8458        dispatchOptimisticSetState(fiber, false, queue, pendingState);
8459        try {
8460          var returnValue = callback(), onStartTransitionFinish = ReactSharedInternals.S;
8461          null !== onStartTransitionFinish && onStartTransitionFinish(currentTransition, returnValue);
8462          if (null !== returnValue && "object" === typeof returnValue && "function" === typeof returnValue.then) {
8463            ReactSharedInternals.asyncTransitions++;
8464            returnValue.then(releaseAsyncTransition, releaseAsyncTransition);
8465            var thenableForFinishedState = chainThenableValue(
8466              returnValue,
8467              finishedState
8468            );
8469            dispatchSetStateInternal(
8470              fiber,
8471              queue,
8472              thenableForFinishedState,
8473              requestUpdateLane(fiber)
8474            );
8475          } else
8476            dispatchSetStateInternal(
8477              fiber,
8478              queue,
8479              finishedState,
8480              requestUpdateLane(fiber)
8481            );
8482        } catch (error2) {
8483          dispatchSetStateInternal(
8484            fiber,
8485            queue,
8486            { then: function() {
8487            }, status: "rejected", reason: error2 },
8488            requestUpdateLane(fiber)
8489          );
8490        } finally {
8491          ReactDOMSharedInternals.p = previousPriority, null !== prevTransition && null !== currentTransition.types && (null !== prevTransition.types && prevTransition.types !== currentTransition.types && console.error(
8492            "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."
8493          ), prevTransition.types = currentTransition.types), ReactSharedInternals.T = prevTransition, null === prevTransition && currentTransition._updatedFibers && (fiber = currentTransition._updatedFibers.size, currentTransition._updatedFibers.clear(), 10 < fiber && console.warn(
8494            "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."
8495          ));
8496        }
8497      }
8498      function startHostTransition(formFiber, pendingState, action, formData) {
8499        if (5 !== formFiber.tag)
8500          throw Error(
8501            "Expected the form instance to be a HostComponent. This is a bug in React."
8502          );
8503        var queue = ensureFormComponentIsStateful(formFiber).queue;
8504        startHostActionTimer(formFiber);
8505        startTransition(
8506          formFiber,
8507          queue,
8508          pendingState,
8509          NotPendingTransition,
8510          null === action ? noop : function() {
8511            requestFormReset$1(formFiber);
8512            return action(formData);
8513          }
8514        );
8515      }
8516      function ensureFormComponentIsStateful(formFiber) {
8517        var existingStateHook = formFiber.memoizedState;
8518        if (null !== existingStateHook) return existingStateHook;
8519        existingStateHook = {
8520          memoizedState: NotPendingTransition,
8521          baseState: NotPendingTransition,
8522          baseQueue: null,
8523          queue: {
8524            pending: null,
8525            lanes: 0,
8526            dispatch: null,
8527            lastRenderedReducer: basicStateReducer,
8528            lastRenderedState: NotPendingTransition
8529          },
8530          next: null
8531        };
8532        var initialResetState = {};
8533        existingStateHook.next = {
8534          memoizedState: initialResetState,
8535          baseState: initialResetState,
8536          baseQueue: null,
8537          queue: {
8538            pending: null,
8539            lanes: 0,
8540            dispatch: null,
8541            lastRenderedReducer: basicStateReducer,
8542            lastRenderedState: initialResetState
8543          },
8544          next: null
8545        };
8546        formFiber.memoizedState = existingStateHook;
8547        formFiber = formFiber.alternate;
8548        null !== formFiber && (formFiber.memoizedState = existingStateHook);
8549        return existingStateHook;
8550      }
8551      function requestFormReset$1(formFiber) {
8552        null === ReactSharedInternals.T && console.error(
8553          "requestFormReset was called outside a transition or action. To fix, move to an action, or wrap with startTransition."
8554        );
8555        var stateHook = ensureFormComponentIsStateful(formFiber);
8556        null === stateHook.next && (stateHook = formFiber.alternate.memoizedState);
8557        dispatchSetStateInternal(
8558          formFiber,
8559          stateHook.next.queue,
8560          {},
8561          requestUpdateLane(formFiber)
8562        );
8563      }
8564      function mountTransition() {
8565        var stateHook = mountStateImpl(false);
8566        stateHook = startTransition.bind(
8567          null,
8568          currentlyRenderingFiber,
8569          stateHook.queue,
8570          true,
8571          false
8572        );
8573        mountWorkInProgressHook().memoizedState = stateHook;
8574        return [false, stateHook];
8575      }
8576      function updateTransition() {
8577        var booleanOrThenable = updateReducer(basicStateReducer)[0], start2 = updateWorkInProgressHook().memoizedState;
8578        return [
8579          "boolean" === typeof booleanOrThenable ? booleanOrThenable : useThenable(booleanOrThenable),
8580          start2
8581        ];
8582      }
8583      function rerenderTransition() {
8584        var booleanOrThenable = rerenderReducer(basicStateReducer)[0], start2 = updateWorkInProgressHook().memoizedState;
8585        return [
8586          "boolean" === typeof booleanOrThenable ? booleanOrThenable : useThenable(booleanOrThenable),
8587          start2
8588        ];
8589      }
8590      function useHostTransitionStatus() {
8591        return readContext(HostTransitionContext);
8592      }
8593      function mountId() {
8594        var hook = mountWorkInProgressHook(), identifierPrefix = workInProgressRoot.identifierPrefix;
8595        if (isHydrating) {
8596          var treeId = treeContextOverflow;
8597          var idWithLeadingBit = treeContextId;
8598          treeId = (idWithLeadingBit & ~(1 << 32 - clz32(idWithLeadingBit) - 1)).toString(32) + treeId;
8599          identifierPrefix = "_" + identifierPrefix + "R_" + treeId;
8600          treeId = localIdCounter++;
8601          0 < treeId && (identifierPrefix += "H" + treeId.toString(32));
8602          identifierPrefix += "_";
8603        } else
8604          treeId = globalClientIdCounter++, identifierPrefix = "_" + identifierPrefix + "r_" + treeId.toString(32) + "_";
8605        return hook.memoizedState = identifierPrefix;
8606      }
8607      function mountRefresh() {
8608        return mountWorkInProgressHook().memoizedState = refreshCache.bind(
8609          null,
8610          currentlyRenderingFiber
8611        );
8612      }
8613      function refreshCache(fiber, seedKey) {
8614        for (var provider = fiber.return; null !== provider; ) {
8615          switch (provider.tag) {
8616            case 24:
8617            case 3:
8618              var lane = requestUpdateLane(provider), refreshUpdate = createUpdate(lane), root3 = enqueueUpdate(provider, refreshUpdate, lane);
8619              null !== root3 && (startUpdateTimerByLane(lane, "refresh()", fiber), scheduleUpdateOnFiber(root3, provider, lane), entangleTransitions(root3, provider, lane));
8620              fiber = createCache();
8621              null !== seedKey && void 0 !== seedKey && null !== root3 && console.error(
8622                "The seed argument is not enabled outside experimental channels."
8623              );
8624              refreshUpdate.payload = { cache: fiber };
8625              return;
8626          }
8627          provider = provider.return;
8628        }
8629      }
8630      function dispatchReducerAction(fiber, queue, action) {
8631        var args = arguments;
8632        "function" === typeof args[3] && console.error(
8633          "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()."
8634        );
8635        args = requestUpdateLane(fiber);
8636        var update = {
8637          lane: args,
8638          revertLane: 0,
8639          gesture: null,
8640          action,
8641          hasEagerState: false,
8642          eagerState: null,
8643          next: null
8644        };
8645        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)));
8646      }
8647      function dispatchSetState(fiber, queue, action) {
8648        var args = arguments;
8649        "function" === typeof args[3] && console.error(
8650          "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()."
8651        );
8652        args = requestUpdateLane(fiber);
8653        dispatchSetStateInternal(fiber, queue, action, args) && startUpdateTimerByLane(args, "setState()", fiber);
8654      }
8655      function dispatchSetStateInternal(fiber, queue, action, lane) {
8656        var update = {
8657          lane,
8658          revertLane: 0,
8659          gesture: null,
8660          action,
8661          hasEagerState: false,
8662          eagerState: null,
8663          next: null
8664        };
8665        if (isRenderPhaseUpdate(fiber)) enqueueRenderPhaseUpdate(queue, update);
8666        else {
8667          var alternate = fiber.alternate;
8668          if (0 === fiber.lanes && (null === alternate || 0 === alternate.lanes) && (alternate = queue.lastRenderedReducer, null !== alternate)) {
8669            var prevDispatcher = ReactSharedInternals.H;
8670            ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
8671            try {
8672              var currentState = queue.lastRenderedState, eagerState = alternate(currentState, action);
8673              update.hasEagerState = true;
8674              update.eagerState = eagerState;
8675              if (objectIs(eagerState, currentState))
8676                return enqueueUpdate$1(fiber, queue, update, 0), null === workInProgressRoot && finishQueueingConcurrentUpdates(), false;
8677            } catch (error2) {
8678            } finally {
8679              ReactSharedInternals.H = prevDispatcher;
8680            }
8681          }
8682          action = enqueueConcurrentHookUpdate(fiber, queue, update, lane);
8683          if (null !== action)
8684            return scheduleUpdateOnFiber(action, fiber, lane), entangleTransitionUpdate(action, queue, lane), true;
8685        }
8686        return false;
8687      }
8688      function dispatchOptimisticSetState(fiber, throwIfDuringRender, queue, action) {
8689        null === ReactSharedInternals.T && 0 === currentEntangledLane && console.error(
8690          "An optimistic state update occurred outside a transition or action. To fix, move the update to an action, or wrap with startTransition."
8691        );
8692        action = {
8693          lane: 2,
8694          revertLane: requestTransitionLane(),
8695          gesture: null,
8696          action,
8697          hasEagerState: false,
8698          eagerState: null,
8699          next: null
8700        };
8701        if (isRenderPhaseUpdate(fiber)) {
8702          if (throwIfDuringRender)
8703            throw Error("Cannot update optimistic state while rendering.");
8704          console.error("Cannot call startTransition while rendering.");
8705        } else
8706          throwIfDuringRender = enqueueConcurrentHookUpdate(
8707            fiber,
8708            queue,
8709            action,
8710            2
8711          ), null !== throwIfDuringRender && (startUpdateTimerByLane(2, "setOptimistic()", fiber), scheduleUpdateOnFiber(throwIfDuringRender, fiber, 2));
8712      }
8713      function isRenderPhaseUpdate(fiber) {
8714        var alternate = fiber.alternate;
8715        return fiber === currentlyRenderingFiber || null !== alternate && alternate === currentlyRenderingFiber;
8716      }
8717      function enqueueRenderPhaseUpdate(queue, update) {
8718        didScheduleRenderPhaseUpdateDuringThisPass = didScheduleRenderPhaseUpdate = true;
8719        var pending = queue.pending;
8720        null === pending ? update.next = update : (update.next = pending.next, pending.next = update);
8721        queue.pending = update;
8722      }
8723      function entangleTransitionUpdate(root3, queue, lane) {
8724        if (0 !== (lane & 4194048)) {
8725          var queueLanes = queue.lanes;
8726          queueLanes &= root3.pendingLanes;
8727          lane |= queueLanes;
8728          queue.lanes = lane;
8729          markRootEntangled(root3, lane);
8730        }
8731      }
8732      function warnOnInvalidCallback(callback) {
8733        if (null !== callback && "function" !== typeof callback) {
8734          var key = String(callback);
8735          didWarnOnInvalidCallback.has(key) || (didWarnOnInvalidCallback.add(key), console.error(
8736            "Expected the last optional `callback` argument to be a function. Instead received: %s.",
8737            callback
8738          ));
8739        }
8740      }
8741      function applyDerivedStateFromProps(workInProgress2, ctor, getDerivedStateFromProps, nextProps) {
8742        var prevState = workInProgress2.memoizedState, partialState = getDerivedStateFromProps(nextProps, prevState);
8743        if (workInProgress2.mode & StrictLegacyMode) {
8744          setIsStrictModeForDevtools(true);
8745          try {
8746            partialState = getDerivedStateFromProps(nextProps, prevState);
8747          } finally {
8748            setIsStrictModeForDevtools(false);
8749          }
8750        }
8751        void 0 === partialState && (ctor = getComponentNameFromType(ctor) || "Component", didWarnAboutUndefinedDerivedState.has(ctor) || (didWarnAboutUndefinedDerivedState.add(ctor), console.error(
8752          "%s.getDerivedStateFromProps(): A valid state object (or null) must be returned. You have returned undefined.",
8753          ctor
8754        )));
8755        prevState = null === partialState || void 0 === partialState ? prevState : assign({}, prevState, partialState);
8756        workInProgress2.memoizedState = prevState;
8757        0 === workInProgress2.lanes && (workInProgress2.updateQueue.baseState = prevState);
8758      }
8759      function checkShouldComponentUpdate(workInProgress2, ctor, oldProps, newProps, oldState, newState, nextContext) {
8760        var instance = workInProgress2.stateNode;
8761        if ("function" === typeof instance.shouldComponentUpdate) {
8762          oldProps = instance.shouldComponentUpdate(
8763            newProps,
8764            newState,
8765            nextContext
8766          );
8767          if (workInProgress2.mode & StrictLegacyMode) {
8768            setIsStrictModeForDevtools(true);
8769            try {
8770              oldProps = instance.shouldComponentUpdate(
8771                newProps,
8772                newState,
8773                nextContext
8774              );
8775            } finally {
8776              setIsStrictModeForDevtools(false);
8777            }
8778          }
8779          void 0 === oldProps && console.error(
8780            "%s.shouldComponentUpdate(): Returned undefined instead of a boolean value. Make sure to return true or false.",
8781            getComponentNameFromType(ctor) || "Component"
8782          );
8783          return oldProps;
8784        }
8785        return ctor.prototype && ctor.prototype.isPureReactComponent ? !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState) : true;
8786      }
8787      function callComponentWillReceiveProps(workInProgress2, instance, newProps, nextContext) {
8788        var oldState = instance.state;
8789        "function" === typeof instance.componentWillReceiveProps && instance.componentWillReceiveProps(newProps, nextContext);
8790        "function" === typeof instance.UNSAFE_componentWillReceiveProps && instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
8791        instance.state !== oldState && (workInProgress2 = getComponentNameFromFiber(workInProgress2) || "Component", didWarnAboutStateAssignmentForComponent.has(workInProgress2) || (didWarnAboutStateAssignmentForComponent.add(workInProgress2), console.error(
8792          "%s.componentWillReceiveProps(): Assigning directly to this.state is deprecated (except inside a component's constructor). Use setState instead.",
8793          workInProgress2
8794        )), classComponentUpdater.enqueueReplaceState(
8795          instance,
8796          instance.state,
8797          null
8798        ));
8799      }
8800      function resolveClassComponentProps(Component, baseProps) {
8801        var newProps = baseProps;
8802        if ("ref" in baseProps) {
8803          newProps = {};
8804          for (var propName in baseProps)
8805            "ref" !== propName && (newProps[propName] = baseProps[propName]);
8806        }
8807        if (Component = Component.defaultProps) {
8808          newProps === baseProps && (newProps = assign({}, newProps));
8809          for (var _propName in Component)
8810            void 0 === newProps[_propName] && (newProps[_propName] = Component[_propName]);
8811        }
8812        return newProps;
8813      }
8814      function defaultOnUncaughtError(error2) {
8815        reportGlobalError(error2);
8816        console.warn(
8817          "%s\n\n%s\n",
8818          componentName ? "An error occurred in the <" + componentName + "> component." : "An error occurred in one of your React components.",
8819          "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."
8820        );
8821      }
8822      function defaultOnCaughtError(error2) {
8823        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") + ".");
8824        if ("object" === typeof error2 && null !== error2 && "string" === typeof error2.environmentName) {
8825          var JSCompiler_inline_result = error2.environmentName;
8826          error2 = [
8827            "%o\n\n%s\n\n%s\n",
8828            error2,
8829            componentNameMessage,
8830            recreateMessage
8831          ].slice(0);
8832          "string" === typeof error2[0] ? error2.splice(
8833            0,
8834            1,
8835            badgeFormat + " " + error2[0],
8836            badgeStyle,
8837            pad + JSCompiler_inline_result + pad,
8838            resetStyle
8839          ) : error2.splice(
8840            0,
8841            0,
8842            badgeFormat,
8843            badgeStyle,
8844            pad + JSCompiler_inline_result + pad,
8845            resetStyle
8846          );
8847          error2.unshift(console);
8848          JSCompiler_inline_result = bind.apply(console.error, error2);
8849          JSCompiler_inline_result();
8850        } else
8851          console.error(
8852            "%o\n\n%s\n\n%s\n",
8853            error2,
8854            componentNameMessage,
8855            recreateMessage
8856          );
8857      }
8858      function defaultOnRecoverableError(error2) {
8859        reportGlobalError(error2);
8860      }
8861      function logUncaughtError(root3, errorInfo) {
8862        try {
8863          componentName = errorInfo.source ? getComponentNameFromFiber(errorInfo.source) : null;
8864          errorBoundaryName = null;
8865          var error2 = errorInfo.value;
8866          if (null !== ReactSharedInternals.actQueue)
8867            ReactSharedInternals.thrownErrors.push(error2);
8868          else {
8869            var onUncaughtError = root3.onUncaughtError;
8870            onUncaughtError(error2, { componentStack: errorInfo.stack });
8871          }
8872        } catch (e$5) {
8873          setTimeout(function() {
8874            throw e$5;
8875          });
8876        }
8877      }
8878      function logCaughtError(root3, boundary, errorInfo) {
8879        try {
8880          componentName = errorInfo.source ? getComponentNameFromFiber(errorInfo.source) : null;
8881          errorBoundaryName = getComponentNameFromFiber(boundary);
8882          var onCaughtError = root3.onCaughtError;
8883          onCaughtError(errorInfo.value, {
8884            componentStack: errorInfo.stack,
8885            errorBoundary: 1 === boundary.tag ? boundary.stateNode : null
8886          });
8887        } catch (e$6) {
8888          setTimeout(function() {
8889            throw e$6;
8890          });
8891        }
8892      }
8893      function createRootErrorUpdate(root3, errorInfo, lane) {
8894        lane = createUpdate(lane);
8895        lane.tag = CaptureUpdate;
8896        lane.payload = { element: null };
8897        lane.callback = function() {
8898          runWithFiberInDEV(errorInfo.source, logUncaughtError, root3, errorInfo);
8899        };
8900        return lane;
8901      }
8902      function createClassErrorUpdate(lane) {
8903        lane = createUpdate(lane);
8904        lane.tag = CaptureUpdate;
8905        return lane;
8906      }
8907      function initializeClassErrorUpdate(update, root3, fiber, errorInfo) {
8908        var getDerivedStateFromError = fiber.type.getDerivedStateFromError;
8909        if ("function" === typeof getDerivedStateFromError) {
8910          var error2 = errorInfo.value;
8911          update.payload = function() {
8912            return getDerivedStateFromError(error2);
8913          };
8914          update.callback = function() {
8915            markFailedErrorBoundaryForHotReloading(fiber);
8916            runWithFiberInDEV(
8917              errorInfo.source,
8918              logCaughtError,
8919              root3,
8920              fiber,
8921              errorInfo
8922            );
8923          };
8924        }
8925        var inst = fiber.stateNode;
8926        null !== inst && "function" === typeof inst.componentDidCatch && (update.callback = function() {
8927          markFailedErrorBoundaryForHotReloading(fiber);
8928          runWithFiberInDEV(
8929            errorInfo.source,
8930            logCaughtError,
8931            root3,
8932            fiber,
8933            errorInfo
8934          );
8935          "function" !== typeof getDerivedStateFromError && (null === legacyErrorBoundariesThatAlreadyFailed ? legacyErrorBoundariesThatAlreadyFailed = /* @__PURE__ */ new Set([this]) : legacyErrorBoundariesThatAlreadyFailed.add(this));
8936          callComponentDidCatchInDEV(this, errorInfo);
8937          "function" === typeof getDerivedStateFromError || 0 === (fiber.lanes & 2) && console.error(
8938            "%s: Error boundaries should implement getDerivedStateFromError(). In that method, return a state update to display an error message or fallback UI.",
8939            getComponentNameFromFiber(fiber) || "Unknown"
8940          );
8941        });
8942      }
8943      function throwException(root3, returnFiber, sourceFiber, value, rootRenderLanes) {
8944        sourceFiber.flags |= 32768;
8945        isDevToolsPresent && restorePendingUpdaters(root3, rootRenderLanes);
8946        if (null !== value && "object" === typeof value && "function" === typeof value.then) {
8947          returnFiber = sourceFiber.alternate;
8948          null !== returnFiber && propagateParentContextChanges(
8949            returnFiber,
8950            sourceFiber,
8951            rootRenderLanes,
8952            true
8953          );
8954          isHydrating && (didSuspendOrErrorDEV = true);
8955          sourceFiber = suspenseHandlerStackCursor.current;
8956          if (null !== sourceFiber) {
8957            switch (sourceFiber.tag) {
8958              case 31:
8959              case 13:
8960                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(root3, value, rootRenderLanes)), false;
8961              case 22:
8962                return sourceFiber.flags |= 65536, value === noopSuspenseyCommitThenable ? sourceFiber.flags |= 16384 : (returnFiber = sourceFiber.updateQueue, null === returnFiber ? (returnFiber = {
8963                  transitions: null,
8964                  markerInstances: null,
8965                  retryQueue: /* @__PURE__ */ new Set([value])
8966                }, sourceFiber.updateQueue = returnFiber) : (sourceFiber = returnFiber.retryQueue, null === sourceFiber ? returnFiber.retryQueue = /* @__PURE__ */ new Set([value]) : sourceFiber.add(value)), attachPingListener(root3, value, rootRenderLanes)), false;
8967            }
8968            throw Error(
8969              "Unexpected Suspense handler tag (" + sourceFiber.tag + "). This is a bug in React."
8970            );
8971          }
8972          attachPingListener(root3, value, rootRenderLanes);
8973          renderDidSuspendDelayIfPossible();
8974          return false;
8975        }
8976        if (isHydrating)
8977          return didSuspendOrErrorDEV = true, returnFiber = suspenseHandlerStackCursor.current, null !== returnFiber ? (0 === (returnFiber.flags & 65536) && (returnFiber.flags |= 256), returnFiber.flags |= 65536, returnFiber.lanes = rootRenderLanes, value !== HydrationMismatchException && queueHydrationError(
8978            createCapturedValueAtFiber(
8979              Error(
8980                "There was an error while hydrating but React was able to recover by instead client rendering from the nearest Suspense boundary.",
8981                { cause: value }
8982              ),
8983              sourceFiber
8984            )
8985          )) : (value !== HydrationMismatchException && queueHydrationError(
8986            createCapturedValueAtFiber(
8987              Error(
8988                "There was an error while hydrating but React was able to recover by instead client rendering the entire root.",
8989                { cause: value }
8990              ),
8991              sourceFiber
8992            )
8993          ), root3 = root3.current.alternate, root3.flags |= 65536, rootRenderLanes &= -rootRenderLanes, root3.lanes |= rootRenderLanes, value = createCapturedValueAtFiber(value, sourceFiber), rootRenderLanes = createRootErrorUpdate(
8994            root3.stateNode,
8995            value,
8996            rootRenderLanes
8997          ), enqueueCapturedUpdate(root3, rootRenderLanes), workInProgressRootExitStatus !== RootSuspendedWithDelay && (workInProgressRootExitStatus = RootErrored)), false;
8998        var error2 = createCapturedValueAtFiber(
8999          Error(
9000            "There was an error during concurrent rendering but React was able to recover by instead synchronously rendering the entire root.",
9001            { cause: value }
9002          ),
9003          sourceFiber
9004        );
9005        null === workInProgressRootConcurrentErrors ? workInProgressRootConcurrentErrors = [error2] : workInProgressRootConcurrentErrors.push(error2);
9006        workInProgressRootExitStatus !== RootSuspendedWithDelay && (workInProgressRootExitStatus = RootErrored);
9007        if (null === returnFiber) return true;
9008        value = createCapturedValueAtFiber(value, sourceFiber);
9009        sourceFiber = returnFiber;
9010        do {
9011          switch (sourceFiber.tag) {
9012            case 3:
9013              return sourceFiber.flags |= 65536, root3 = rootRenderLanes & -rootRenderLanes, sourceFiber.lanes |= root3, root3 = createRootErrorUpdate(
9014                sourceFiber.stateNode,
9015                value,
9016                root3
9017              ), enqueueCapturedUpdate(sourceFiber, root3), false;
9018            case 1:
9019              if (returnFiber = sourceFiber.type, error2 = sourceFiber.stateNode, 0 === (sourceFiber.flags & 128) && ("function" === typeof returnFiber.getDerivedStateFromError || null !== error2 && "function" === typeof error2.componentDidCatch && (null === legacyErrorBoundariesThatAlreadyFailed || !legacyErrorBoundariesThatAlreadyFailed.has(error2))))
9020                return sourceFiber.flags |= 65536, rootRenderLanes &= -rootRenderLanes, sourceFiber.lanes |= rootRenderLanes, rootRenderLanes = createClassErrorUpdate(rootRenderLanes), initializeClassErrorUpdate(
9021                  rootRenderLanes,
9022                  root3,
9023                  sourceFiber,
9024                  value
9025                ), enqueueCapturedUpdate(sourceFiber, rootRenderLanes), false;
9026          }
9027          sourceFiber = sourceFiber.return;
9028        } while (null !== sourceFiber);
9029        return false;
9030      }
9031      function reconcileChildren(current2, workInProgress2, nextChildren, renderLanes2) {
9032        workInProgress2.child = null === current2 ? mountChildFibers(workInProgress2, null, nextChildren, renderLanes2) : reconcileChildFibers(
9033          workInProgress2,
9034          current2.child,
9035          nextChildren,
9036          renderLanes2
9037        );
9038      }
9039      function updateForwardRef(current2, workInProgress2, Component, nextProps, renderLanes2) {
9040        Component = Component.render;
9041        var ref = workInProgress2.ref;
9042        if ("ref" in nextProps) {
9043          var propsWithoutRef = {};
9044          for (var key in nextProps)
9045            "ref" !== key && (propsWithoutRef[key] = nextProps[key]);
9046        } else propsWithoutRef = nextProps;
9047        prepareToReadContext(workInProgress2);
9048        nextProps = renderWithHooks(
9049          current2,
9050          workInProgress2,
9051          Component,
9052          propsWithoutRef,
9053          ref,
9054          renderLanes2
9055        );
9056        key = checkDidRenderIdHook();
9057        if (null !== current2 && !didReceiveUpdate)
9058          return bailoutHooks(current2, workInProgress2, renderLanes2), bailoutOnAlreadyFinishedWork(current2, workInProgress2, renderLanes2);
9059        isHydrating && key && pushMaterializedTreeId(workInProgress2);
9060        workInProgress2.flags |= 1;
9061        reconcileChildren(current2, workInProgress2, nextProps, renderLanes2);
9062        return workInProgress2.child;
9063      }
9064      function updateMemoComponent(current2, workInProgress2, Component, nextProps, renderLanes2) {
9065        if (null === current2) {
9066          var type = Component.type;
9067          if ("function" === typeof type && !shouldConstruct(type) && void 0 === type.defaultProps && null === Component.compare)
9068            return Component = resolveFunctionForHotReloading(type), workInProgress2.tag = 15, workInProgress2.type = Component, validateFunctionComponentInDev(workInProgress2, type), updateSimpleMemoComponent(
9069              current2,
9070              workInProgress2,
9071              Component,
9072              nextProps,
9073              renderLanes2
9074            );
9075          current2 = createFiberFromTypeAndProps(
9076            Component.type,
9077            null,
9078            nextProps,
9079            workInProgress2,
9080            workInProgress2.mode,
9081            renderLanes2
9082          );
9083          current2.ref = workInProgress2.ref;
9084          current2.return = workInProgress2;
9085          return workInProgress2.child = current2;
9086        }
9087        type = current2.child;
9088        if (!checkScheduledUpdateOrContext(current2, renderLanes2)) {
9089          var prevProps = type.memoizedProps;
9090          Component = Component.compare;
9091          Component = null !== Component ? Component : shallowEqual;
9092          if (Component(prevProps, nextProps) && current2.ref === workInProgress2.ref)
9093            return bailoutOnAlreadyFinishedWork(
9094              current2,
9095              workInProgress2,
9096              renderLanes2
9097            );
9098        }
9099        workInProgress2.flags |= 1;
9100        current2 = createWorkInProgress(type, nextProps);
9101        current2.ref = workInProgress2.ref;
9102        current2.return = workInProgress2;
9103        return workInProgress2.child = current2;
9104      }
9105      function updateSimpleMemoComponent(current2, workInProgress2, Component, nextProps, renderLanes2) {
9106        if (null !== current2) {
9107          var prevProps = current2.memoizedProps;
9108          if (shallowEqual(prevProps, nextProps) && current2.ref === workInProgress2.ref && workInProgress2.type === current2.type)
9109            if (didReceiveUpdate = false, workInProgress2.pendingProps = nextProps = prevProps, checkScheduledUpdateOrContext(current2, renderLanes2))
9110              0 !== (current2.flags & 131072) && (didReceiveUpdate = true);
9111            else
9112              return workInProgress2.lanes = current2.lanes, bailoutOnAlreadyFinishedWork(current2, workInProgress2, renderLanes2);
9113        }
9114        return updateFunctionComponent(
9115          current2,
9116          workInProgress2,
9117          Component,
9118          nextProps,
9119          renderLanes2
9120        );
9121      }
9122      function updateOffscreenComponent(current2, workInProgress2, renderLanes2, nextProps) {
9123        var nextChildren = nextProps.children, prevState = null !== current2 ? current2.memoizedState : null;
9124        null === current2 && null === workInProgress2.stateNode && (workInProgress2.stateNode = {
9125          _visibility: OffscreenVisible,
9126          _pendingMarkers: null,
9127          _retryCache: null,
9128          _transitions: null
9129        });
9130        if ("hidden" === nextProps.mode) {
9131          if (0 !== (workInProgress2.flags & 128)) {
9132            prevState = null !== prevState ? prevState.baseLanes | renderLanes2 : renderLanes2;
9133            if (null !== current2) {
9134              nextProps = workInProgress2.child = current2.child;
9135              for (nextChildren = 0; null !== nextProps; )
9136                nextChildren = nextChildren | nextProps.lanes | nextProps.childLanes, nextProps = nextProps.sibling;
9137              nextProps = nextChildren & ~prevState;
9138            } else nextProps = 0, workInProgress2.child = null;
9139            return deferHiddenOffscreenComponent(
9140              current2,
9141              workInProgress2,
9142              prevState,
9143              renderLanes2,
9144              nextProps
9145            );
9146          }
9147          if (0 !== (renderLanes2 & 536870912))
9148            workInProgress2.memoizedState = { baseLanes: 0, cachePool: null }, null !== current2 && pushTransition(
9149              workInProgress2,
9150              null !== prevState ? prevState.cachePool : null
9151            ), null !== prevState ? pushHiddenContext(workInProgress2, prevState) : reuseHiddenContextOnStack(workInProgress2), pushOffscreenSuspenseHandler(workInProgress2);
9152          else
9153            return nextProps = workInProgress2.lanes = 536870912, deferHiddenOffscreenComponent(
9154              current2,
9155              workInProgress2,
9156              null !== prevState ? prevState.baseLanes | renderLanes2 : renderLanes2,
9157              renderLanes2,
9158              nextProps
9159            );
9160        } else
9161          null !== prevState ? (pushTransition(workInProgress2, prevState.cachePool), pushHiddenContext(workInProgress2, prevState), reuseSuspenseHandlerOnStack(workInProgress2), workInProgress2.memoizedState = null) : (null !== current2 && pushTransition(workInProgress2, null), reuseHiddenContextOnStack(workInProgress2), reuseSuspenseHandlerOnStack(workInProgress2));
9162        reconcileChildren(current2, workInProgress2, nextChildren, renderLanes2);
9163        return workInProgress2.child;
9164      }
9165      function bailoutOffscreenComponent(current2, workInProgress2) {
9166        null !== current2 && 22 === current2.tag || null !== workInProgress2.stateNode || (workInProgress2.stateNode = {
9167          _visibility: OffscreenVisible,
9168          _pendingMarkers: null,
9169          _retryCache: null,
9170          _transitions: null
9171        });
9172        return workInProgress2.sibling;
9173      }
9174      function deferHiddenOffscreenComponent(current2, workInProgress2, nextBaseLanes, renderLanes2, remainingChildLanes) {
9175        var JSCompiler_inline_result = peekCacheFromPool();
9176        JSCompiler_inline_result = null === JSCompiler_inline_result ? null : {
9177          parent: CacheContext._currentValue,
9178          pool: JSCompiler_inline_result
9179        };
9180        workInProgress2.memoizedState = {
9181          baseLanes: nextBaseLanes,
9182          cachePool: JSCompiler_inline_result
9183        };
9184        null !== current2 && pushTransition(workInProgress2, null);
9185        reuseHiddenContextOnStack(workInProgress2);
9186        pushOffscreenSuspenseHandler(workInProgress2);
9187        null !== current2 && propagateParentContextChanges(current2, workInProgress2, renderLanes2, true);
9188        workInProgress2.childLanes = remainingChildLanes;
9189        return null;
9190      }
9191      function mountActivityChildren(workInProgress2, nextProps) {
9192        var hiddenProp = nextProps.hidden;
9193        void 0 !== hiddenProp && console.error(
9194          `<Activity> doesn't accept a hidden prop. Use mode="hidden" instead.
9195- <Activity %s>
9196+ <Activity %s>`,
9197          true === hiddenProp ? "hidden" : false === hiddenProp ? "hidden={false}" : "hidden={...}",
9198          hiddenProp ? 'mode="hidden"' : 'mode="visible"'
9199        );
9200        nextProps = mountWorkInProgressOffscreenFiber(
9201          { mode: nextProps.mode, children: nextProps.children },
9202          workInProgress2.mode
9203        );
9204        nextProps.ref = workInProgress2.ref;
9205        workInProgress2.child = nextProps;
9206        nextProps.return = workInProgress2;
9207        return nextProps;
9208      }
9209      function retryActivityComponentWithoutHydrating(current2, workInProgress2, renderLanes2) {
9210        reconcileChildFibers(workInProgress2, current2.child, null, renderLanes2);
9211        current2 = mountActivityChildren(
9212          workInProgress2,
9213          workInProgress2.pendingProps
9214        );
9215        current2.flags |= 2;
9216        popSuspenseHandler(workInProgress2);
9217        workInProgress2.memoizedState = null;
9218        return current2;
9219      }
9220      function updateActivityComponent(current2, workInProgress2, renderLanes2) {
9221        var nextProps = workInProgress2.pendingProps, didSuspend = 0 !== (workInProgress2.flags & 128);
9222        workInProgress2.flags &= -129;
9223        if (null === current2) {
9224          if (isHydrating) {
9225            if ("hidden" === nextProps.mode)
9226              return current2 = mountActivityChildren(workInProgress2, nextProps), workInProgress2.lanes = 536870912, bailoutOffscreenComponent(null, current2);
9227            pushDehydratedActivitySuspenseHandler(workInProgress2);
9228            (current2 = nextHydratableInstance) ? (renderLanes2 = canHydrateHydrationBoundary(
9229              current2,
9230              rootOrSingletonContext
9231            ), renderLanes2 = null !== renderLanes2 && renderLanes2.data === ACTIVITY_START_DATA ? renderLanes2 : null, null !== renderLanes2 && (nextProps = {
9232              dehydrated: renderLanes2,
9233              treeContext: getSuspendedTreeContext(),
9234              retryLane: 536870912,
9235              hydrationErrors: null
9236            }, workInProgress2.memoizedState = nextProps, nextProps = createFiberFromDehydratedFragment(renderLanes2), nextProps.return = workInProgress2, workInProgress2.child = nextProps, hydrationParentFiber = workInProgress2, nextHydratableInstance = null)) : renderLanes2 = null;
9237            if (null === renderLanes2)
9238              throw warnNonHydratedInstance(workInProgress2, current2), throwOnHydrationMismatch(workInProgress2);
9239            workInProgress2.lanes = 536870912;
9240            return null;
9241          }
9242          return mountActivityChildren(workInProgress2, nextProps);
9243        }
9244        var prevState = current2.memoizedState;
9245        if (null !== prevState) {
9246          var activityInstance = prevState.dehydrated;
9247          pushDehydratedActivitySuspenseHandler(workInProgress2);
9248          if (didSuspend)
9249            if (workInProgress2.flags & 256)
9250              workInProgress2.flags &= -257, workInProgress2 = retryActivityComponentWithoutHydrating(
9251                current2,
9252                workInProgress2,
9253                renderLanes2
9254              );
9255            else if (null !== workInProgress2.memoizedState)
9256              workInProgress2.child = current2.child, workInProgress2.flags |= 128, workInProgress2 = null;
9257            else
9258              throw Error(
9259                "Client rendering an Activity suspended it again. This is a bug in React."
9260              );
9261          else if (warnIfHydrating(), 0 !== (renderLanes2 & 536870912) && markRenderDerivedCause(workInProgress2), didReceiveUpdate || propagateParentContextChanges(
9262            current2,
9263            workInProgress2,
9264            renderLanes2,
9265            false
9266          ), didSuspend = 0 !== (renderLanes2 & current2.childLanes), didReceiveUpdate || didSuspend) {
9267            nextProps = workInProgressRoot;
9268            if (null !== nextProps && (activityInstance = getBumpedLaneForHydration(
9269              nextProps,
9270              renderLanes2
9271            ), 0 !== activityInstance && activityInstance !== prevState.retryLane))
9272              throw prevState.retryLane = activityInstance, enqueueConcurrentRenderForLane(current2, activityInstance), scheduleUpdateOnFiber(nextProps, current2, activityInstance), SelectiveHydrationException;
9273            renderDidSuspendDelayIfPossible();
9274            workInProgress2 = retryActivityComponentWithoutHydrating(
9275              current2,
9276              workInProgress2,
9277              renderLanes2
9278            );
9279          } else
9280            current2 = prevState.treeContext, nextHydratableInstance = getNextHydratable(
9281              activityInstance.nextSibling
9282            ), hydrationParentFiber = workInProgress2, isHydrating = true, hydrationErrors = null, didSuspendOrErrorDEV = false, hydrationDiffRootDEV = null, rootOrSingletonContext = false, null !== current2 && restoreSuspendedTreeContext(workInProgress2, current2), workInProgress2 = mountActivityChildren(workInProgress2, nextProps), workInProgress2.flags |= 4096;
9283          return workInProgress2;
9284        }
9285        prevState = current2.child;
9286        nextProps = { mode: nextProps.mode, children: nextProps.children };
9287        0 !== (renderLanes2 & 536870912) && 0 !== (renderLanes2 & current2.lanes) && markRenderDerivedCause(workInProgress2);
9288        current2 = createWorkInProgress(prevState, nextProps);
9289        current2.ref = workInProgress2.ref;
9290        workInProgress2.child = current2;
9291        current2.return = workInProgress2;
9292        return current2;
9293      }
9294      function markRef(current2, workInProgress2) {
9295        var ref = workInProgress2.ref;
9296        if (null === ref)
9297          null !== current2 && null !== current2.ref && (workInProgress2.flags |= 4194816);
9298        else {
9299          if ("function" !== typeof ref && "object" !== typeof ref)
9300            throw Error(
9301              "Expected ref to be a function, an object returned by React.createRef(), or undefined/null."
9302            );
9303          if (null === current2 || current2.ref !== ref)
9304            workInProgress2.flags |= 4194816;
9305        }
9306      }
9307      function updateFunctionComponent(current2, workInProgress2, Component, nextProps, renderLanes2) {
9308        if (Component.prototype && "function" === typeof Component.prototype.render) {
9309          var componentName2 = getComponentNameFromType(Component) || "Unknown";
9310          didWarnAboutBadClass[componentName2] || (console.error(
9311            "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.",
9312            componentName2,
9313            componentName2
9314          ), didWarnAboutBadClass[componentName2] = true);
9315        }
9316        workInProgress2.mode & StrictLegacyMode && ReactStrictModeWarnings.recordLegacyContextWarning(
9317          workInProgress2,
9318          null
9319        );
9320        null === current2 && (validateFunctionComponentInDev(workInProgress2, workInProgress2.type), Component.contextTypes && (componentName2 = getComponentNameFromType(Component) || "Unknown", didWarnAboutContextTypes[componentName2] || (didWarnAboutContextTypes[componentName2] = true, console.error(
9321          "%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)",
9322          componentName2
9323        ))));
9324        prepareToReadContext(workInProgress2);
9325        Component = renderWithHooks(
9326          current2,
9327          workInProgress2,
9328          Component,
9329          nextProps,
9330          void 0,
9331          renderLanes2
9332        );
9333        nextProps = checkDidRenderIdHook();
9334        if (null !== current2 && !didReceiveUpdate)
9335          return bailoutHooks(current2, workInProgress2, renderLanes2), bailoutOnAlreadyFinishedWork(current2, workInProgress2, renderLanes2);
9336        isHydrating && nextProps && pushMaterializedTreeId(workInProgress2);
9337        workInProgress2.flags |= 1;
9338        reconcileChildren(current2, workInProgress2, Component, renderLanes2);
9339        return workInProgress2.child;
9340      }
9341      function replayFunctionComponent(current2, workInProgress2, nextProps, Component, secondArg, renderLanes2) {
9342        prepareToReadContext(workInProgress2);
9343        hookTypesUpdateIndexDev = -1;
9344        ignorePreviousDependencies = null !== current2 && current2.type !== workInProgress2.type;
9345        workInProgress2.updateQueue = null;
9346        nextProps = renderWithHooksAgain(
9347          workInProgress2,
9348          Component,
9349          nextProps,
9350          secondArg
9351        );
9352        finishRenderingHooks(current2, workInProgress2);
9353        Component = checkDidRenderIdHook();
9354        if (null !== current2 && !didReceiveUpdate)
9355          return bailoutHooks(current2, workInProgress2, renderLanes2), bailoutOnAlreadyFinishedWork(current2, workInProgress2, renderLanes2);
9356        isHydrating && Component && pushMaterializedTreeId(workInProgress2);
9357        workInProgress2.flags |= 1;
9358        reconcileChildren(current2, workInProgress2, nextProps, renderLanes2);
9359        return workInProgress2.child;
9360      }
9361      function updateClassComponent(current2, workInProgress2, Component, nextProps, renderLanes2) {
9362        switch (shouldErrorImpl(workInProgress2)) {
9363          case false:
9364            var _instance = workInProgress2.stateNode, state = new workInProgress2.type(
9365              workInProgress2.memoizedProps,
9366              _instance.context
9367            ).state;
9368            _instance.updater.enqueueSetState(_instance, state, null);
9369            break;
9370          case true:
9371            workInProgress2.flags |= 128;
9372            workInProgress2.flags |= 65536;
9373            _instance = Error("Simulated error coming from DevTools");
9374            var lane = renderLanes2 & -renderLanes2;
9375            workInProgress2.lanes |= lane;
9376            state = workInProgressRoot;
9377            if (null === state)
9378              throw Error(
9379                "Expected a work-in-progress root. This is a bug in React. Please file an issue."
9380              );
9381            lane = createClassErrorUpdate(lane);
9382            initializeClassErrorUpdate(
9383              lane,
9384              state,
9385              workInProgress2,
9386              createCapturedValueAtFiber(_instance, workInProgress2)
9387            );
9388            enqueueCapturedUpdate(workInProgress2, lane);
9389        }
9390        prepareToReadContext(workInProgress2);
9391        if (null === workInProgress2.stateNode) {
9392          state = emptyContextObject;
9393          _instance = Component.contextType;
9394          "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(
9395            "%s defines an invalid contextType. contextType should point to the Context object returned by React.createContext().%s",
9396            getComponentNameFromType(Component) || "Component",
9397            lane
9398          ));
9399          "object" === typeof _instance && null !== _instance && (state = readContext(_instance));
9400          _instance = new Component(nextProps, state);
9401          if (workInProgress2.mode & StrictLegacyMode) {
9402            setIsStrictModeForDevtools(true);
9403            try {
9404              _instance = new Component(nextProps, state);
9405            } finally {
9406              setIsStrictModeForDevtools(false);
9407            }
9408          }
9409          state = workInProgress2.memoizedState = null !== _instance.state && void 0 !== _instance.state ? _instance.state : null;
9410          _instance.updater = classComponentUpdater;
9411          workInProgress2.stateNode = _instance;
9412          _instance._reactInternals = workInProgress2;
9413          _instance._reactInternalInstance = fakeInternalInstance;
9414          "function" === typeof Component.getDerivedStateFromProps && null === state && (state = getComponentNameFromType(Component) || "Component", didWarnAboutUninitializedState.has(state) || (didWarnAboutUninitializedState.add(state), console.error(
9415            "`%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.",
9416            state,
9417            null === _instance.state ? "null" : "undefined",
9418            state
9419          )));
9420          if ("function" === typeof Component.getDerivedStateFromProps || "function" === typeof _instance.getSnapshotBeforeUpdate) {
9421            var foundWillUpdateName = lane = state = null;
9422            "function" === typeof _instance.componentWillMount && true !== _instance.componentWillMount.__suppressDeprecationWarning ? state = "componentWillMount" : "function" === typeof _instance.UNSAFE_componentWillMount && (state = "UNSAFE_componentWillMount");
9423            "function" === typeof _instance.componentWillReceiveProps && true !== _instance.componentWillReceiveProps.__suppressDeprecationWarning ? lane = "componentWillReceiveProps" : "function" === typeof _instance.UNSAFE_componentWillReceiveProps && (lane = "UNSAFE_componentWillReceiveProps");
9424            "function" === typeof _instance.componentWillUpdate && true !== _instance.componentWillUpdate.__suppressDeprecationWarning ? foundWillUpdateName = "componentWillUpdate" : "function" === typeof _instance.UNSAFE_componentWillUpdate && (foundWillUpdateName = "UNSAFE_componentWillUpdate");
9425            if (null !== state || null !== lane || null !== foundWillUpdateName) {
9426              _instance = getComponentNameFromType(Component) || "Component";
9427              var newApiName = "function" === typeof Component.getDerivedStateFromProps ? "getDerivedStateFromProps()" : "getSnapshotBeforeUpdate()";
9428              didWarnAboutLegacyLifecyclesAndDerivedState.has(_instance) || (didWarnAboutLegacyLifecyclesAndDerivedState.add(_instance), console.error(
9429                "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",
9430                _instance,
9431                newApiName,
9432                null !== state ? "\n  " + state : "",
9433                null !== lane ? "\n  " + lane : "",
9434                null !== foundWillUpdateName ? "\n  " + foundWillUpdateName : ""
9435              ));
9436            }
9437          }
9438          _instance = workInProgress2.stateNode;
9439          state = getComponentNameFromType(Component) || "Component";
9440          _instance.render || (Component.prototype && "function" === typeof Component.prototype.render ? console.error(
9441            "No `render` method found on the %s instance: did you accidentally return an object from the constructor?",
9442            state
9443          ) : console.error(
9444            "No `render` method found on the %s instance: you may have forgotten to define `render`.",
9445            state
9446          ));
9447          !_instance.getInitialState || _instance.getInitialState.isReactClassApproved || _instance.state || console.error(
9448            "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?",
9449            state
9450          );
9451          _instance.getDefaultProps && !_instance.getDefaultProps.isReactClassApproved && console.error(
9452            "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.",
9453            state
9454          );
9455          _instance.contextType && console.error(
9456            "contextType was defined as an instance property on %s. Use a static property to define contextType instead.",
9457            state
9458          );
9459          Component.childContextTypes && !didWarnAboutChildContextTypes.has(Component) && (didWarnAboutChildContextTypes.add(Component), console.error(
9460            "%s uses the legacy childContextTypes API which was removed in React 19. Use React.createContext() instead. (https://react.dev/link/legacy-context)",
9461            state
9462          ));
9463          Component.contextTypes && !didWarnAboutContextTypes$1.has(Component) && (didWarnAboutContextTypes$1.add(Component), console.error(
9464            "%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)",
9465            state
9466          ));
9467          "function" === typeof _instance.componentShouldUpdate && console.error(
9468            "%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.",
9469            state
9470          );
9471          Component.prototype && Component.prototype.isPureReactComponent && "undefined" !== typeof _instance.shouldComponentUpdate && console.error(
9472            "%s has a method called shouldComponentUpdate(). shouldComponentUpdate should not be used when extending React.PureComponent. Please extend React.Component if shouldComponentUpdate is used.",
9473            getComponentNameFromType(Component) || "A pure component"
9474          );
9475          "function" === typeof _instance.componentDidUnmount && console.error(
9476            "%s has a method called componentDidUnmount(). But there is no such lifecycle method. Did you mean componentWillUnmount()?",
9477            state
9478          );
9479          "function" === typeof _instance.componentDidReceiveProps && console.error(
9480            "%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().",
9481            state
9482          );
9483          "function" === typeof _instance.componentWillRecieveProps && console.error(
9484            "%s has a method called componentWillRecieveProps(). Did you mean componentWillReceiveProps()?",
9485            state
9486          );
9487          "function" === typeof _instance.UNSAFE_componentWillRecieveProps && console.error(
9488            "%s has a method called UNSAFE_componentWillRecieveProps(). Did you mean UNSAFE_componentWillReceiveProps()?",
9489            state
9490          );
9491          lane = _instance.props !== nextProps;
9492          void 0 !== _instance.props && lane && console.error(
9493            "When calling super() in `%s`, make sure to pass up the same props that your component's constructor was passed.",
9494            state
9495          );
9496          _instance.defaultProps && console.error(
9497            "Setting defaultProps as an instance property on %s is not supported and will be ignored. Instead, define defaultProps as a static property on %s.",
9498            state,
9499            state
9500          );
9501          "function" !== typeof _instance.getSnapshotBeforeUpdate || "function" === typeof _instance.componentDidUpdate || didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.has(Component) || (didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.add(Component), console.error(
9502            "%s: getSnapshotBeforeUpdate() should be used with componentDidUpdate(). This component defines getSnapshotBeforeUpdate() only.",
9503            getComponentNameFromType(Component)
9504          ));
9505          "function" === typeof _instance.getDerivedStateFromProps && console.error(
9506            "%s: getDerivedStateFromProps() is defined as an instance method and will be ignored. Instead, declare it as a static method.",
9507            state
9508          );
9509          "function" === typeof _instance.getDerivedStateFromError && console.error(
9510            "%s: getDerivedStateFromError() is defined as an instance method and will be ignored. Instead, declare it as a static method.",
9511            state
9512          );
9513          "function" === typeof Component.getSnapshotBeforeUpdate && console.error(
9514            "%s: getSnapshotBeforeUpdate() is defined as a static method and will be ignored. Instead, declare it as an instance method.",
9515            state
9516          );
9517          (lane = _instance.state) && ("object" !== typeof lane || isArrayImpl(lane)) && console.error("%s.state: must be set to an object or null", state);
9518          "function" === typeof _instance.getChildContext && "object" !== typeof Component.childContextTypes && console.error(
9519            "%s.getChildContext(): childContextTypes must be defined in order to use getChildContext().",
9520            state
9521          );
9522          _instance = workInProgress2.stateNode;
9523          _instance.props = nextProps;
9524          _instance.state = workInProgress2.memoizedState;
9525          _instance.refs = {};
9526          initializeUpdateQueue(workInProgress2);
9527          state = Component.contextType;
9528          _instance.context = "object" === typeof state && null !== state ? readContext(state) : emptyContextObject;
9529          _instance.state === nextProps && (state = getComponentNameFromType(Component) || "Component", didWarnAboutDirectlyAssigningPropsToState.has(state) || (didWarnAboutDirectlyAssigningPropsToState.add(state), console.error(
9530            "%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.",
9531            state
9532          )));
9533          workInProgress2.mode & StrictLegacyMode && ReactStrictModeWarnings.recordLegacyContextWarning(
9534            workInProgress2,
9535            _instance
9536          );
9537          ReactStrictModeWarnings.recordUnsafeLifecycleWarnings(
9538            workInProgress2,
9539            _instance
9540          );
9541          _instance.state = workInProgress2.memoizedState;
9542          state = Component.getDerivedStateFromProps;
9543          "function" === typeof state && (applyDerivedStateFromProps(
9544            workInProgress2,
9545            Component,
9546            state,
9547            nextProps
9548          ), _instance.state = workInProgress2.memoizedState);
9549          "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(
9550            "%s.componentWillMount(): Assigning directly to this.state is deprecated (except inside a component's constructor). Use setState instead.",
9551            getComponentNameFromFiber(workInProgress2) || "Component"
9552          ), classComponentUpdater.enqueueReplaceState(
9553            _instance,
9554            _instance.state,
9555            null
9556          )), processUpdateQueue(workInProgress2, nextProps, _instance, renderLanes2), suspendIfUpdateReadFromEntangledAsyncAction(), _instance.state = workInProgress2.memoizedState);
9557          "function" === typeof _instance.componentDidMount && (workInProgress2.flags |= 4194308);
9558          (workInProgress2.mode & StrictEffectsMode) !== NoMode && (workInProgress2.flags |= 134217728);
9559          _instance = true;
9560        } else if (null === current2) {
9561          _instance = workInProgress2.stateNode;
9562          var unresolvedOldProps = workInProgress2.memoizedProps;
9563          lane = resolveClassComponentProps(Component, unresolvedOldProps);
9564          _instance.props = lane;
9565          var oldContext = _instance.context;
9566          foundWillUpdateName = Component.contextType;
9567          state = emptyContextObject;
9568          "object" === typeof foundWillUpdateName && null !== foundWillUpdateName && (state = readContext(foundWillUpdateName));
9569          newApiName = Component.getDerivedStateFromProps;
9570          foundWillUpdateName = "function" === typeof newApiName || "function" === typeof _instance.getSnapshotBeforeUpdate;
9571          unresolvedOldProps = workInProgress2.pendingProps !== unresolvedOldProps;
9572          foundWillUpdateName || "function" !== typeof _instance.UNSAFE_componentWillReceiveProps && "function" !== typeof _instance.componentWillReceiveProps || (unresolvedOldProps || oldContext !== state) && callComponentWillReceiveProps(
9573            workInProgress2,
9574            _instance,
9575            nextProps,
9576            state
9577          );
9578          hasForceUpdate = false;
9579          var oldState = workInProgress2.memoizedState;
9580          _instance.state = oldState;
9581          processUpdateQueue(workInProgress2, nextProps, _instance, renderLanes2);
9582          suspendIfUpdateReadFromEntangledAsyncAction();
9583          oldContext = workInProgress2.memoizedState;
9584          unresolvedOldProps || oldState !== oldContext || hasForceUpdate ? ("function" === typeof newApiName && (applyDerivedStateFromProps(
9585            workInProgress2,
9586            Component,
9587            newApiName,
9588            nextProps
9589          ), oldContext = workInProgress2.memoizedState), (lane = hasForceUpdate || checkShouldComponentUpdate(
9590            workInProgress2,
9591            Component,
9592            lane,
9593            nextProps,
9594            oldState,
9595            oldContext,
9596            state
9597          )) ? (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);
9598        } else {
9599          _instance = workInProgress2.stateNode;
9600          cloneUpdateQueue(current2, workInProgress2);
9601          state = workInProgress2.memoizedProps;
9602          foundWillUpdateName = resolveClassComponentProps(Component, state);
9603          _instance.props = foundWillUpdateName;
9604          newApiName = workInProgress2.pendingProps;
9605          oldState = _instance.context;
9606          oldContext = Component.contextType;
9607          lane = emptyContextObject;
9608          "object" === typeof oldContext && null !== oldContext && (lane = readContext(oldContext));
9609          unresolvedOldProps = Component.getDerivedStateFromProps;
9610          (oldContext = "function" === typeof unresolvedOldProps || "function" === typeof _instance.getSnapshotBeforeUpdate) || "function" !== typeof _instance.UNSAFE_componentWillReceiveProps && "function" !== typeof _instance.componentWillReceiveProps || (state !== newApiName || oldState !== lane) && callComponentWillReceiveProps(
9611            workInProgress2,
9612            _instance,
9613            nextProps,
9614            lane
9615          );
9616          hasForceUpdate = false;
9617          oldState = workInProgress2.memoizedState;
9618          _instance.state = oldState;
9619          processUpdateQueue(workInProgress2, nextProps, _instance, renderLanes2);
9620          suspendIfUpdateReadFromEntangledAsyncAction();
9621          var newState = workInProgress2.memoizedState;
9622          state !== newApiName || oldState !== newState || hasForceUpdate || null !== current2 && null !== current2.dependencies && checkIfContextChanged(current2.dependencies) ? ("function" === typeof unresolvedOldProps && (applyDerivedStateFromProps(
9623            workInProgress2,
9624            Component,
9625            unresolvedOldProps,
9626            nextProps
9627          ), newState = workInProgress2.memoizedState), (foundWillUpdateName = hasForceUpdate || checkShouldComponentUpdate(
9628            workInProgress2,
9629            Component,
9630            foundWillUpdateName,
9631            nextProps,
9632            oldState,
9633            newState,
9634            lane
9635          ) || 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(
9636            nextProps,
9637            newState,
9638            lane
9639          )), "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);
9640        }
9641        lane = _instance;
9642        markRef(current2, workInProgress2);
9643        state = 0 !== (workInProgress2.flags & 128);
9644        if (lane || state) {
9645          lane = workInProgress2.stateNode;
9646          setCurrentFiber(workInProgress2);
9647          if (state && "function" !== typeof Component.getDerivedStateFromError)
9648            Component = null, profilerStartTime = -1;
9649          else if (Component = callRenderInDEV(lane), workInProgress2.mode & StrictLegacyMode) {
9650            setIsStrictModeForDevtools(true);
9651            try {
9652              callRenderInDEV(lane);
9653            } finally {
9654              setIsStrictModeForDevtools(false);
9655            }
9656          }
9657          workInProgress2.flags |= 1;
9658          null !== current2 && state ? (workInProgress2.child = reconcileChildFibers(
9659            workInProgress2,
9660            current2.child,
9661            null,
9662            renderLanes2
9663          ), workInProgress2.child = reconcileChildFibers(
9664            workInProgress2,
9665            null,
9666            Component,
9667            renderLanes2
9668          )) : reconcileChildren(current2, workInProgress2, Component, renderLanes2);
9669          workInProgress2.memoizedState = lane.state;
9670          current2 = workInProgress2.child;
9671        } else
9672          current2 = bailoutOnAlreadyFinishedWork(
9673            current2,
9674            workInProgress2,
9675            renderLanes2
9676          );
9677        renderLanes2 = workInProgress2.stateNode;
9678        _instance && renderLanes2.props !== nextProps && (didWarnAboutReassigningProps || console.error(
9679          "It looks like %s is reassigning its own `this.props` while rendering. This is not supported and can lead to confusing bugs.",
9680          getComponentNameFromFiber(workInProgress2) || "a component"
9681        ), didWarnAboutReassigningProps = true);
9682        return current2;
9683      }
9684      function mountHostRootWithoutHydrating(current2, workInProgress2, nextChildren, renderLanes2) {
9685        resetHydrationState();
9686        workInProgress2.flags |= 256;
9687        reconcileChildren(current2, workInProgress2, nextChildren, renderLanes2);
9688        return workInProgress2.child;
9689      }
9690      function validateFunctionComponentInDev(workInProgress2, Component) {
9691        Component && Component.childContextTypes && console.error(
9692          "childContextTypes cannot be defined on a function component.\n  %s.childContextTypes = ...",
9693          Component.displayName || Component.name || "Component"
9694        );
9695        "function" === typeof Component.getDerivedStateFromProps && (workInProgress2 = getComponentNameFromType(Component) || "Unknown", didWarnAboutGetDerivedStateOnFunctionComponent[workInProgress2] || (console.error(
9696          "%s: Function components do not support getDerivedStateFromProps.",
9697          workInProgress2
9698        ), didWarnAboutGetDerivedStateOnFunctionComponent[workInProgress2] = true));
9699        "object" === typeof Component.contextType && null !== Component.contextType && (Component = getComponentNameFromType(Component) || "Unknown", didWarnAboutContextTypeOnFunctionComponent[Component] || (console.error(
9700          "%s: Function components do not support contextType.",
9701          Component
9702        ), didWarnAboutContextTypeOnFunctionComponent[Component] = true));
9703      }
9704      function mountSuspenseOffscreenState(renderLanes2) {
9705        return { baseLanes: renderLanes2, cachePool: getSuspendedCache() };
9706      }
9707      function getRemainingWorkInPrimaryTree(current2, primaryTreeDidDefer, renderLanes2) {
9708        current2 = null !== current2 ? current2.childLanes & ~renderLanes2 : 0;
9709        primaryTreeDidDefer && (current2 |= workInProgressDeferredLane);
9710        return current2;
9711      }
9712      function updateSuspenseComponent(current2, workInProgress2, renderLanes2) {
9713        var JSCompiler_object_inline_digest_2724;
9714        var JSCompiler_object_inline_stack_2725 = workInProgress2.pendingProps;
9715        shouldSuspendImpl(workInProgress2) && (workInProgress2.flags |= 128);
9716        var JSCompiler_object_inline_message_2723 = false;
9717        var didSuspend = 0 !== (workInProgress2.flags & 128);
9718        (JSCompiler_object_inline_digest_2724 = didSuspend) || (JSCompiler_object_inline_digest_2724 = null !== current2 && null === current2.memoizedState ? false : 0 !== (suspenseStackCursor.current & ForceSuspenseFallback));
9719        JSCompiler_object_inline_digest_2724 && (JSCompiler_object_inline_message_2723 = true, workInProgress2.flags &= -129);
9720        JSCompiler_object_inline_digest_2724 = 0 !== (workInProgress2.flags & 32);
9721        workInProgress2.flags &= -33;
9722        if (null === current2) {
9723          if (isHydrating) {
9724            JSCompiler_object_inline_message_2723 ? pushPrimaryTreeSuspenseHandler(workInProgress2) : reuseSuspenseHandlerOnStack(workInProgress2);
9725            (current2 = nextHydratableInstance) ? (renderLanes2 = canHydrateHydrationBoundary(
9726              current2,
9727              rootOrSingletonContext
9728            ), renderLanes2 = null !== renderLanes2 && renderLanes2.data !== ACTIVITY_START_DATA ? renderLanes2 : null, null !== renderLanes2 && (JSCompiler_object_inline_digest_2724 = {
9729              dehydrated: renderLanes2,
9730              treeContext: getSuspendedTreeContext(),
9731              retryLane: 536870912,
9732              hydrationErrors: null
9733            }, 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;
9734            if (null === renderLanes2)
9735              throw warnNonHydratedInstance(workInProgress2, current2), throwOnHydrationMismatch(workInProgress2);
9736            isSuspenseInstanceFallback(renderLanes2) ? workInProgress2.lanes = 32 : workInProgress2.lanes = 536870912;
9737            return null;
9738          }
9739          var nextPrimaryChildren = JSCompiler_object_inline_stack_2725.children;
9740          JSCompiler_object_inline_stack_2725 = JSCompiler_object_inline_stack_2725.fallback;
9741          if (JSCompiler_object_inline_message_2723) {
9742            reuseSuspenseHandlerOnStack(workInProgress2);
9743            var mode2 = workInProgress2.mode;
9744            nextPrimaryChildren = mountWorkInProgressOffscreenFiber(
9745              { mode: "hidden", children: nextPrimaryChildren },
9746              mode2
9747            );
9748            JSCompiler_object_inline_stack_2725 = createFiberFromFragment(
9749              JSCompiler_object_inline_stack_2725,
9750              mode2,
9751              renderLanes2,
9752              null
9753            );
9754            nextPrimaryChildren.return = workInProgress2;
9755            JSCompiler_object_inline_stack_2725.return = workInProgress2;
9756            nextPrimaryChildren.sibling = JSCompiler_object_inline_stack_2725;
9757            workInProgress2.child = nextPrimaryChildren;
9758            JSCompiler_object_inline_stack_2725 = workInProgress2.child;
9759            JSCompiler_object_inline_stack_2725.memoizedState = mountSuspenseOffscreenState(renderLanes2);
9760            JSCompiler_object_inline_stack_2725.childLanes = getRemainingWorkInPrimaryTree(
9761              current2,
9762              JSCompiler_object_inline_digest_2724,
9763              renderLanes2
9764            );
9765            workInProgress2.memoizedState = SUSPENDED_MARKER;
9766            return bailoutOffscreenComponent(
9767              null,
9768              JSCompiler_object_inline_stack_2725
9769            );
9770          }
9771          pushPrimaryTreeSuspenseHandler(workInProgress2);
9772          return mountSuspensePrimaryChildren(
9773            workInProgress2,
9774            nextPrimaryChildren
9775          );
9776        }
9777        var prevState = current2.memoizedState;
9778        if (null !== prevState) {
9779          var JSCompiler_object_inline_componentStack_2726 = prevState.dehydrated;
9780          if (null !== JSCompiler_object_inline_componentStack_2726) {
9781            if (didSuspend)
9782              workInProgress2.flags & 256 ? (pushPrimaryTreeSuspenseHandler(workInProgress2), workInProgress2.flags &= -257, workInProgress2 = retrySuspenseComponentWithoutHydrating(
9783                current2,
9784                workInProgress2,
9785                renderLanes2
9786              )) : null !== workInProgress2.memoizedState ? (reuseSuspenseHandlerOnStack(workInProgress2), workInProgress2.child = current2.child, workInProgress2.flags |= 128, workInProgress2 = null) : (reuseSuspenseHandlerOnStack(workInProgress2), nextPrimaryChildren = JSCompiler_object_inline_stack_2725.fallback, mode2 = workInProgress2.mode, JSCompiler_object_inline_stack_2725 = mountWorkInProgressOffscreenFiber(
9787                {
9788                  mode: "visible",
9789                  children: JSCompiler_object_inline_stack_2725.children
9790                },
9791                mode2
9792              ), nextPrimaryChildren = createFiberFromFragment(
9793                nextPrimaryChildren,
9794                mode2,
9795                renderLanes2,
9796                null
9797              ), 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(
9798                workInProgress2,
9799                current2.child,
9800                null,
9801                renderLanes2
9802              ), JSCompiler_object_inline_stack_2725 = workInProgress2.child, JSCompiler_object_inline_stack_2725.memoizedState = mountSuspenseOffscreenState(renderLanes2), JSCompiler_object_inline_stack_2725.childLanes = getRemainingWorkInPrimaryTree(
9803                current2,
9804                JSCompiler_object_inline_digest_2724,
9805                renderLanes2
9806              ), workInProgress2.memoizedState = SUSPENDED_MARKER, workInProgress2 = bailoutOffscreenComponent(
9807                null,
9808                JSCompiler_object_inline_stack_2725
9809              ));
9810            else if (pushPrimaryTreeSuspenseHandler(workInProgress2), warnIfHydrating(), 0 !== (renderLanes2 & 536870912) && markRenderDerivedCause(workInProgress2), isSuspenseInstanceFallback(
9811              JSCompiler_object_inline_componentStack_2726
9812            )) {
9813              JSCompiler_object_inline_digest_2724 = JSCompiler_object_inline_componentStack_2726.nextSibling && JSCompiler_object_inline_componentStack_2726.nextSibling.dataset;
9814              if (JSCompiler_object_inline_digest_2724) {
9815                nextPrimaryChildren = JSCompiler_object_inline_digest_2724.dgst;
9816                var message = JSCompiler_object_inline_digest_2724.msg;
9817                mode2 = JSCompiler_object_inline_digest_2724.stck;
9818                var componentStack = JSCompiler_object_inline_digest_2724.cstck;
9819              }
9820              JSCompiler_object_inline_message_2723 = message;
9821              JSCompiler_object_inline_digest_2724 = nextPrimaryChildren;
9822              JSCompiler_object_inline_stack_2725 = mode2;
9823              JSCompiler_object_inline_componentStack_2726 = componentStack;
9824              nextPrimaryChildren = JSCompiler_object_inline_message_2723;
9825              mode2 = JSCompiler_object_inline_componentStack_2726;
9826              nextPrimaryChildren = nextPrimaryChildren ? Error(nextPrimaryChildren) : Error(
9827                "The server could not finish this Suspense boundary, likely due to an error during server rendering. Switched to client rendering."
9828              );
9829              nextPrimaryChildren.stack = JSCompiler_object_inline_stack_2725 || "";
9830              nextPrimaryChildren.digest = JSCompiler_object_inline_digest_2724;
9831              JSCompiler_object_inline_digest_2724 = void 0 === mode2 ? null : mode2;
9832              JSCompiler_object_inline_stack_2725 = {
9833                value: nextPrimaryChildren,
9834                source: null,
9835                stack: JSCompiler_object_inline_digest_2724
9836              };
9837              "string" === typeof JSCompiler_object_inline_digest_2724 && CapturedStacks.set(
9838                nextPrimaryChildren,
9839                JSCompiler_object_inline_stack_2725
9840              );
9841              queueHydrationError(JSCompiler_object_inline_stack_2725);
9842              workInProgress2 = retrySuspenseComponentWithoutHydrating(
9843                current2,
9844                workInProgress2,
9845                renderLanes2
9846              );
9847            } else if (didReceiveUpdate || propagateParentContextChanges(
9848              current2,
9849              workInProgress2,
9850              renderLanes2,
9851              false
9852            ), JSCompiler_object_inline_digest_2724 = 0 !== (renderLanes2 & current2.childLanes), didReceiveUpdate || JSCompiler_object_inline_digest_2724) {
9853              JSCompiler_object_inline_digest_2724 = workInProgressRoot;
9854              if (null !== JSCompiler_object_inline_digest_2724 && (JSCompiler_object_inline_stack_2725 = getBumpedLaneForHydration(
9855                JSCompiler_object_inline_digest_2724,
9856                renderLanes2
9857              ), 0 !== JSCompiler_object_inline_stack_2725 && JSCompiler_object_inline_stack_2725 !== prevState.retryLane))
9858                throw prevState.retryLane = JSCompiler_object_inline_stack_2725, enqueueConcurrentRenderForLane(
9859                  current2,
9860                  JSCompiler_object_inline_stack_2725
9861                ), scheduleUpdateOnFiber(
9862                  JSCompiler_object_inline_digest_2724,
9863                  current2,
9864                  JSCompiler_object_inline_stack_2725
9865                ), SelectiveHydrationException;
9866              isSuspenseInstancePending(
9867                JSCompiler_object_inline_componentStack_2726
9868              ) || renderDidSuspendDelayIfPossible();
9869              workInProgress2 = retrySuspenseComponentWithoutHydrating(
9870                current2,
9871                workInProgress2,
9872                renderLanes2
9873              );
9874            } else
9875              isSuspenseInstancePending(
9876                JSCompiler_object_inline_componentStack_2726
9877              ) ? (workInProgress2.flags |= 192, workInProgress2.child = current2.child, workInProgress2 = null) : (current2 = prevState.treeContext, nextHydratableInstance = getNextHydratable(
9878                JSCompiler_object_inline_componentStack_2726.nextSibling
9879              ), hydrationParentFiber = workInProgress2, isHydrating = true, hydrationErrors = null, didSuspendOrErrorDEV = false, hydrationDiffRootDEV = null, rootOrSingletonContext = false, null !== current2 && restoreSuspendedTreeContext(workInProgress2, current2), workInProgress2 = mountSuspensePrimaryChildren(
9880                workInProgress2,
9881                JSCompiler_object_inline_stack_2725.children
9882              ), workInProgress2.flags |= 4096);
9883            return workInProgress2;
9884          }
9885        }
9886        if (JSCompiler_object_inline_message_2723)
9887          return reuseSuspenseHandlerOnStack(workInProgress2), nextPrimaryChildren = JSCompiler_object_inline_stack_2725.fallback, mode2 = workInProgress2.mode, componentStack = current2.child, JSCompiler_object_inline_componentStack_2726 = componentStack.sibling, JSCompiler_object_inline_stack_2725 = createWorkInProgress(
9888            componentStack,
9889            {
9890              mode: "hidden",
9891              children: JSCompiler_object_inline_stack_2725.children
9892            }
9893          ), JSCompiler_object_inline_stack_2725.subtreeFlags = componentStack.subtreeFlags & 65011712, null !== JSCompiler_object_inline_componentStack_2726 ? nextPrimaryChildren = createWorkInProgress(
9894            JSCompiler_object_inline_componentStack_2726,
9895            nextPrimaryChildren
9896          ) : (nextPrimaryChildren = createFiberFromFragment(
9897            nextPrimaryChildren,
9898            mode2,
9899            renderLanes2,
9900            null
9901          ), 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) : (mode2 = nextPrimaryChildren.cachePool, null !== mode2 ? (componentStack = CacheContext._currentValue, mode2 = mode2.parent !== componentStack ? { parent: componentStack, pool: componentStack } : mode2) : mode2 = getSuspendedCache(), nextPrimaryChildren = {
9902            baseLanes: nextPrimaryChildren.baseLanes | renderLanes2,
9903            cachePool: mode2
9904          }), JSCompiler_object_inline_stack_2725.memoizedState = nextPrimaryChildren, JSCompiler_object_inline_stack_2725.childLanes = getRemainingWorkInPrimaryTree(
9905            current2,
9906            JSCompiler_object_inline_digest_2724,
9907            renderLanes2
9908          ), workInProgress2.memoizedState = SUSPENDED_MARKER, bailoutOffscreenComponent(
9909            current2.child,
9910            JSCompiler_object_inline_stack_2725
9911          );
9912        null !== prevState && (renderLanes2 & 62914560) === renderLanes2 && 0 !== (renderLanes2 & current2.lanes) && markRenderDerivedCause(workInProgress2);
9913        pushPrimaryTreeSuspenseHandler(workInProgress2);
9914        renderLanes2 = current2.child;
9915        current2 = renderLanes2.sibling;
9916        renderLanes2 = createWorkInProgress(renderLanes2, {
9917          mode: "visible",
9918          children: JSCompiler_object_inline_stack_2725.children
9919        });
9920        renderLanes2.return = workInProgress2;
9921        renderLanes2.sibling = null;
9922        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));
9923        workInProgress2.child = renderLanes2;
9924        workInProgress2.memoizedState = null;
9925        return renderLanes2;
9926      }
9927      function mountSuspensePrimaryChildren(workInProgress2, primaryChildren) {
9928        primaryChildren = mountWorkInProgressOffscreenFiber(
9929          { mode: "visible", children: primaryChildren },
9930          workInProgress2.mode
9931        );
9932        primaryChildren.return = workInProgress2;
9933        return workInProgress2.child = primaryChildren;
9934      }
9935      function mountWorkInProgressOffscreenFiber(offscreenProps, mode2) {
9936        offscreenProps = createFiber(22, offscreenProps, null, mode2);
9937        offscreenProps.lanes = 0;
9938        return offscreenProps;
9939      }
9940      function retrySuspenseComponentWithoutHydrating(current2, workInProgress2, renderLanes2) {
9941        reconcileChildFibers(workInProgress2, current2.child, null, renderLanes2);
9942        current2 = mountSuspensePrimaryChildren(
9943          workInProgress2,
9944          workInProgress2.pendingProps.children
9945        );
9946        current2.flags |= 2;
9947        workInProgress2.memoizedState = null;
9948        return current2;
9949      }
9950      function scheduleSuspenseWorkOnFiber(fiber, renderLanes2, propagationRoot) {
9951        fiber.lanes |= renderLanes2;
9952        var alternate = fiber.alternate;
9953        null !== alternate && (alternate.lanes |= renderLanes2);
9954        scheduleContextWorkOnParentPath(
9955          fiber.return,
9956          renderLanes2,
9957          propagationRoot
9958        );
9959      }
9960      function initSuspenseListRenderState(workInProgress2, isBackwards, tail, lastContentRow, tailMode, treeForkCount2) {
9961        var renderState = workInProgress2.memoizedState;
9962        null === renderState ? workInProgress2.memoizedState = {
9963          isBackwards,
9964          rendering: null,
9965          renderingStartTime: 0,
9966          last: lastContentRow,
9967          tail,
9968          tailMode,
9969          treeForkCount: treeForkCount2
9970        } : (renderState.isBackwards = isBackwards, renderState.rendering = null, renderState.renderingStartTime = 0, renderState.last = lastContentRow, renderState.tail = tail, renderState.tailMode = tailMode, renderState.treeForkCount = treeForkCount2);
9971      }
9972      function updateSuspenseListComponent(current2, workInProgress2, renderLanes2) {
9973        var nextProps = workInProgress2.pendingProps, revealOrder = nextProps.revealOrder, tailMode = nextProps.tail, newChildren = nextProps.children, suspenseContext = suspenseStackCursor.current;
9974        (nextProps = 0 !== (suspenseContext & ForceSuspenseFallback)) ? (suspenseContext = suspenseContext & SubtreeSuspenseContextMask | ForceSuspenseFallback, workInProgress2.flags |= 128) : suspenseContext &= SubtreeSuspenseContextMask;
9975        push(suspenseStackCursor, suspenseContext, workInProgress2);
9976        suspenseContext = null == revealOrder ? "null" : revealOrder;
9977        if ("forwards" !== revealOrder && "unstable_legacy-backwards" !== revealOrder && "together" !== revealOrder && "independent" !== revealOrder && !didWarnAboutRevealOrder[suspenseContext])
9978          if (didWarnAboutRevealOrder[suspenseContext] = true, null == revealOrder)
9979            console.error(
9980              '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".'
9981            );
9982          else if ("backwards" === revealOrder)
9983            console.error(
9984              'The rendering order of <SuspenseList revealOrder="backwards"> is changing. To be future compatible you must specify revealOrder="legacy_unstable-backwards" instead.'
9985            );
9986          else if ("string" === typeof revealOrder)
9987            switch (revealOrder.toLowerCase()) {
9988              case "together":
9989              case "forwards":
9990              case "backwards":
9991              case "independent":
9992                console.error(
9993                  '"%s" is not a valid value for revealOrder on <SuspenseList />. Use lowercase "%s" instead.',
9994                  revealOrder,
9995                  revealOrder.toLowerCase()
9996                );
9997                break;
9998              case "forward":
9999              case "backward":
10000                console.error(
10001                  '"%s" is not a valid value for revealOrder on <SuspenseList />. React uses the -s suffix in the spelling. Use "%ss" instead.',
10002                  revealOrder,
10003                  revealOrder.toLowerCase()
10004                );
10005                break;
10006              default:
10007                console.error(
10008                  '"%s" is not a supported revealOrder on <SuspenseList />. Did you mean "independent", "together", "forwards" or "backwards"?',
10009                  revealOrder
10010                );
10011            }
10012          else
10013            console.error(
10014              '%s is not a supported value for revealOrder on <SuspenseList />. Did you mean "independent", "together", "forwards" or "backwards"?',
10015              revealOrder
10016            );
10017        suspenseContext = null == tailMode ? "null" : tailMode;
10018        if (!didWarnAboutTailOptions[suspenseContext])
10019          if (null == tailMode) {
10020            if ("forwards" === revealOrder || "backwards" === revealOrder || "unstable_legacy-backwards" === revealOrder)
10021              didWarnAboutTailOptions[suspenseContext] = true, console.error(
10022                '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".'
10023              );
10024          } else
10025            "visible" !== tailMode && "collapsed" !== tailMode && "hidden" !== tailMode ? (didWarnAboutTailOptions[suspenseContext] = true, console.error(
10026              '"%s" is not a supported value for tail on <SuspenseList />. Did you mean "visible", "collapsed" or "hidden"?',
10027              tailMode
10028            )) : "forwards" !== revealOrder && "backwards" !== revealOrder && "unstable_legacy-backwards" !== revealOrder && (didWarnAboutTailOptions[suspenseContext] = true, console.error(
10029              '<SuspenseList tail="%s" /> is only valid if revealOrder is "forwards" or "backwards". Did you mean to specify revealOrder="forwards"?',
10030              tailMode
10031            ));
10032        a: if (("forwards" === revealOrder || "backwards" === revealOrder || "unstable_legacy-backwards" === revealOrder) && void 0 !== newChildren && null !== newChildren && false !== newChildren)
10033          if (isArrayImpl(newChildren))
10034            for (suspenseContext = 0; suspenseContext < newChildren.length; suspenseContext++) {
10035              if (!validateSuspenseListNestedChild(
10036                newChildren[suspenseContext],
10037                suspenseContext
10038              ))
10039                break a;
10040            }
10041          else if (suspenseContext = getIteratorFn(newChildren), "function" === typeof suspenseContext) {
10042            if (suspenseContext = suspenseContext.call(newChildren))
10043              for (var step = suspenseContext.next(), _i3 = 0; !step.done; step = suspenseContext.next()) {
10044                if (!validateSuspenseListNestedChild(step.value, _i3)) break a;
10045                _i3++;
10046              }
10047          } else
10048            console.error(
10049              '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?',
10050              revealOrder
10051            );
10052        reconcileChildren(current2, workInProgress2, newChildren, renderLanes2);
10053        isHydrating ? (warnIfNotHydrating(), newChildren = treeForkCount) : newChildren = 0;
10054        if (!nextProps && null !== current2 && 0 !== (current2.flags & 128))
10055          a: for (current2 = workInProgress2.child; null !== current2; ) {
10056            if (13 === current2.tag)
10057              null !== current2.memoizedState && scheduleSuspenseWorkOnFiber(current2, renderLanes2, workInProgress2);
10058            else if (19 === current2.tag)
10059              scheduleSuspenseWorkOnFiber(current2, renderLanes2, workInProgress2);
10060            else if (null !== current2.child) {
10061              current2.child.return = current2;
10062              current2 = current2.child;
10063              continue;
10064            }
10065            if (current2 === workInProgress2) break a;
10066            for (; null === current2.sibling; ) {
10067              if (null === current2.return || current2.return === workInProgress2)
10068                break a;
10069              current2 = current2.return;
10070            }
10071            current2.sibling.return = current2.return;
10072            current2 = current2.sibling;
10073          }
10074        switch (revealOrder) {
10075          case "forwards":
10076            renderLanes2 = workInProgress2.child;
10077            for (revealOrder = null; null !== renderLanes2; )
10078              current2 = renderLanes2.alternate, null !== current2 && null === findFirstSuspended(current2) && (revealOrder = renderLanes2), renderLanes2 = renderLanes2.sibling;
10079            renderLanes2 = revealOrder;
10080            null === renderLanes2 ? (revealOrder = workInProgress2.child, workInProgress2.child = null) : (revealOrder = renderLanes2.sibling, renderLanes2.sibling = null);
10081            initSuspenseListRenderState(
10082              workInProgress2,
10083              false,
10084              revealOrder,
10085              renderLanes2,
10086              tailMode,
10087              newChildren
10088            );
10089            break;
10090          case "backwards":
10091          case "unstable_legacy-backwards":
10092            renderLanes2 = null;
10093            revealOrder = workInProgress2.child;
10094            for (workInProgress2.child = null; null !== revealOrder; ) {
10095              current2 = revealOrder.alternate;
10096              if (null !== current2 && null === findFirstSuspended(current2)) {
10097                workInProgress2.child = revealOrder;
10098                break;
10099              }
10100              current2 = revealOrder.sibling;
10101              revealOrder.sibling = renderLanes2;
10102              renderLanes2 = revealOrder;
10103              revealOrder = current2;
10104            }
10105            initSuspenseListRenderState(
10106              workInProgress2,
10107              true,
10108              renderLanes2,
10109              null,
10110              tailMode,
10111              newChildren
10112            );
10113            break;
10114          case "together":
10115            initSuspenseListRenderState(
10116              workInProgress2,
10117              false,
10118              null,
10119              null,
10120              void 0,
10121              newChildren
10122            );
10123            break;
10124          default:
10125            workInProgress2.memoizedState = null;
10126        }
10127        return workInProgress2.child;
10128      }
10129      function bailoutOnAlreadyFinishedWork(current2, workInProgress2, renderLanes2) {
10130        null !== current2 && (workInProgress2.dependencies = current2.dependencies);
10131        profilerStartTime = -1;
10132        workInProgressRootSkippedLanes |= workInProgress2.lanes;
10133        if (0 === (renderLanes2 & workInProgress2.childLanes))
10134          if (null !== current2) {
10135            if (propagateParentContextChanges(
10136              current2,
10137              workInProgress2,
10138              renderLanes2,
10139              false
10140            ), 0 === (renderLanes2 & workInProgress2.childLanes))
10141              return null;
10142          } else return null;
10143        if (null !== current2 && workInProgress2.child !== current2.child)
10144          throw Error("Resuming work not yet implemented.");
10145        if (null !== workInProgress2.child) {
10146          current2 = workInProgress2.child;
10147          renderLanes2 = createWorkInProgress(current2, current2.pendingProps);
10148          workInProgress2.child = renderLanes2;
10149          for (renderLanes2.return = workInProgress2; null !== current2.sibling; )
10150            current2 = current2.sibling, renderLanes2 = renderLanes2.sibling = createWorkInProgress(current2, current2.pendingProps), renderLanes2.return = workInProgress2;
10151          renderLanes2.sibling = null;
10152        }
10153        return workInProgress2.child;
10154      }
10155      function checkScheduledUpdateOrContext(current2, renderLanes2) {
10156        if (0 !== (current2.lanes & renderLanes2)) return true;
10157        current2 = current2.dependencies;
10158        return null !== current2 && checkIfContextChanged(current2) ? true : false;
10159      }
10160      function attemptEarlyBailoutIfNoScheduledUpdate(current2, workInProgress2, renderLanes2) {
10161        switch (workInProgress2.tag) {
10162          case 3:
10163            pushHostContainer(
10164              workInProgress2,
10165              workInProgress2.stateNode.containerInfo
10166            );
10167            pushProvider(
10168              workInProgress2,
10169              CacheContext,
10170              current2.memoizedState.cache
10171            );
10172            resetHydrationState();
10173            break;
10174          case 27:
10175          case 5:
10176            pushHostContext(workInProgress2);
10177            break;
10178          case 4:
10179            pushHostContainer(
10180              workInProgress2,
10181              workInProgress2.stateNode.containerInfo
10182            );
10183            break;
10184          case 10:
10185            pushProvider(
10186              workInProgress2,
10187              workInProgress2.type,
10188              workInProgress2.memoizedProps.value
10189            );
10190            break;
10191          case 12:
10192            0 !== (renderLanes2 & workInProgress2.childLanes) && (workInProgress2.flags |= 4);
10193            workInProgress2.flags |= 2048;
10194            var stateNode = workInProgress2.stateNode;
10195            stateNode.effectDuration = -0;
10196            stateNode.passiveEffectDuration = -0;
10197            break;
10198          case 31:
10199            if (null !== workInProgress2.memoizedState)
10200              return workInProgress2.flags |= 128, pushDehydratedActivitySuspenseHandler(workInProgress2), null;
10201            break;
10202          case 13:
10203            stateNode = workInProgress2.memoizedState;
10204            if (null !== stateNode) {
10205              if (null !== stateNode.dehydrated)
10206                return pushPrimaryTreeSuspenseHandler(workInProgress2), workInProgress2.flags |= 128, null;
10207              if (0 !== (renderLanes2 & workInProgress2.child.childLanes))
10208                return updateSuspenseComponent(
10209                  current2,
10210                  workInProgress2,
10211                  renderLanes2
10212                );
10213              pushPrimaryTreeSuspenseHandler(workInProgress2);
10214              current2 = bailoutOnAlreadyFinishedWork(
10215                current2,
10216                workInProgress2,
10217                renderLanes2
10218              );
10219              return null !== current2 ? current2.sibling : null;
10220            }
10221            pushPrimaryTreeSuspenseHandler(workInProgress2);
10222            break;
10223          case 19:
10224            var didSuspendBefore = 0 !== (current2.flags & 128);
10225            stateNode = 0 !== (renderLanes2 & workInProgress2.childLanes);
10226            stateNode || (propagateParentContextChanges(
10227              current2,
10228              workInProgress2,
10229              renderLanes2,
10230              false
10231            ), stateNode = 0 !== (renderLanes2 & workInProgress2.childLanes));
10232            if (didSuspendBefore) {
10233              if (stateNode)
10234                return updateSuspenseListComponent(
10235                  current2,
10236                  workInProgress2,
10237                  renderLanes2
10238                );
10239              workInProgress2.flags |= 128;
10240            }
10241            didSuspendBefore = workInProgress2.memoizedState;
10242            null !== didSuspendBefore && (didSuspendBefore.rendering = null, didSuspendBefore.tail = null, didSuspendBefore.lastEffect = null);
10243            push(
10244              suspenseStackCursor,
10245              suspenseStackCursor.current,
10246              workInProgress2
10247            );
10248            if (stateNode) break;
10249            else return null;
10250          case 22:
10251            return workInProgress2.lanes = 0, updateOffscreenComponent(
10252              current2,
10253              workInProgress2,
10254              renderLanes2,
10255              workInProgress2.pendingProps
10256            );
10257          case 24:
10258            pushProvider(
10259              workInProgress2,
10260              CacheContext,
10261              current2.memoizedState.cache
10262            );
10263        }
10264        return bailoutOnAlreadyFinishedWork(current2, workInProgress2, renderLanes2);
10265      }
10266      function beginWork(current2, workInProgress2, renderLanes2) {
10267        if (workInProgress2._debugNeedsRemount && null !== current2) {
10268          renderLanes2 = createFiberFromTypeAndProps(
10269            workInProgress2.type,
10270            workInProgress2.key,
10271            workInProgress2.pendingProps,
10272            workInProgress2._debugOwner || null,
10273            workInProgress2.mode,
10274            workInProgress2.lanes
10275          );
10276          renderLanes2._debugStack = workInProgress2._debugStack;
10277          renderLanes2._debugTask = workInProgress2._debugTask;
10278          var returnFiber = workInProgress2.return;
10279          if (null === returnFiber) throw Error("Cannot swap the root fiber.");
10280          current2.alternate = null;
10281          workInProgress2.alternate = null;
10282          renderLanes2.index = workInProgress2.index;
10283          renderLanes2.sibling = workInProgress2.sibling;
10284          renderLanes2.return = workInProgress2.return;
10285          renderLanes2.ref = workInProgress2.ref;
10286          renderLanes2._debugInfo = workInProgress2._debugInfo;
10287          if (workInProgress2 === returnFiber.child)
10288            returnFiber.child = renderLanes2;
10289          else {
10290            var prevSibling = returnFiber.child;
10291            if (null === prevSibling)
10292              throw Error("Expected parent to have a child.");
10293            for (; prevSibling.sibling !== workInProgress2; )
10294              if (prevSibling = prevSibling.sibling, null === prevSibling)
10295                throw Error("Expected to find the previous sibling.");
10296            prevSibling.sibling = renderLanes2;
10297          }
10298          workInProgress2 = returnFiber.deletions;
10299          null === workInProgress2 ? (returnFiber.deletions = [current2], returnFiber.flags |= 16) : workInProgress2.push(current2);
10300          renderLanes2.flags |= 2;
10301          return renderLanes2;
10302        }
10303        if (null !== current2)
10304          if (current2.memoizedProps !== workInProgress2.pendingProps || workInProgress2.type !== current2.type)
10305            didReceiveUpdate = true;
10306          else {
10307            if (!checkScheduledUpdateOrContext(current2, renderLanes2) && 0 === (workInProgress2.flags & 128))
10308              return didReceiveUpdate = false, attemptEarlyBailoutIfNoScheduledUpdate(
10309                current2,
10310                workInProgress2,
10311                renderLanes2
10312              );
10313            didReceiveUpdate = 0 !== (current2.flags & 131072) ? true : false;
10314          }
10315        else {
10316          didReceiveUpdate = false;
10317          if (returnFiber = isHydrating)
10318            warnIfNotHydrating(), returnFiber = 0 !== (workInProgress2.flags & 1048576);
10319          returnFiber && (returnFiber = workInProgress2.index, warnIfNotHydrating(), pushTreeId(workInProgress2, treeForkCount, returnFiber));
10320        }
10321        workInProgress2.lanes = 0;
10322        switch (workInProgress2.tag) {
10323          case 16:
10324            a: if (returnFiber = workInProgress2.pendingProps, current2 = resolveLazy(workInProgress2.elementType), workInProgress2.type = current2, "function" === typeof current2)
10325              shouldConstruct(current2) ? (returnFiber = resolveClassComponentProps(
10326                current2,
10327                returnFiber
10328              ), workInProgress2.tag = 1, workInProgress2.type = current2 = resolveFunctionForHotReloading(current2), workInProgress2 = updateClassComponent(
10329                null,
10330                workInProgress2,
10331                current2,
10332                returnFiber,
10333                renderLanes2
10334              )) : (workInProgress2.tag = 0, validateFunctionComponentInDev(workInProgress2, current2), workInProgress2.type = current2 = resolveFunctionForHotReloading(current2), workInProgress2 = updateFunctionComponent(
10335                null,
10336                workInProgress2,
10337                current2,
10338                returnFiber,
10339                renderLanes2
10340              ));
10341            else {
10342              if (void 0 !== current2 && null !== current2) {
10343                if (prevSibling = current2.$$typeof, prevSibling === REACT_FORWARD_REF_TYPE) {
10344                  workInProgress2.tag = 11;
10345                  workInProgress2.type = current2 = resolveForwardRefForHotReloading(current2);
10346                  workInProgress2 = updateForwardRef(
10347                    null,
10348                    workInProgress2,
10349                    current2,
10350                    returnFiber,
10351                    renderLanes2
10352                  );
10353                  break a;
10354                } else if (prevSibling === REACT_MEMO_TYPE) {
10355                  workInProgress2.tag = 14;
10356                  workInProgress2 = updateMemoComponent(
10357                    null,
10358                    workInProgress2,
10359                    current2,
10360                    returnFiber,
10361                    renderLanes2
10362                  );
10363                  break a;
10364                }
10365              }
10366              workInProgress2 = "";
10367              null !== current2 && "object" === typeof current2 && current2.$$typeof === REACT_LAZY_TYPE && (workInProgress2 = " Did you wrap a component in React.lazy() more than once?");
10368              renderLanes2 = getComponentNameFromType(current2) || current2;
10369              throw Error(
10370                "Element type is invalid. Received a promise that resolves to: " + renderLanes2 + ". Lazy element type must resolve to a class or function." + workInProgress2
10371              );
10372            }
10373            return workInProgress2;
10374          case 0:
10375            return updateFunctionComponent(
10376              current2,
10377              workInProgress2,
10378              workInProgress2.type,
10379              workInProgress2.pendingProps,
10380              renderLanes2
10381            );
10382          case 1:
10383            return returnFiber = workInProgress2.type, prevSibling = resolveClassComponentProps(
10384              returnFiber,
10385              workInProgress2.pendingProps
10386            ), updateClassComponent(
10387              current2,
10388              workInProgress2,
10389              returnFiber,
10390              prevSibling,
10391              renderLanes2
10392            );
10393          case 3:
10394            a: {
10395              pushHostContainer(
10396                workInProgress2,
10397                workInProgress2.stateNode.containerInfo
10398              );
10399              if (null === current2)
10400                throw Error(
10401                  "Should have a current fiber. This is a bug in React."
10402                );
10403              returnFiber = workInProgress2.pendingProps;
10404              var prevState = workInProgress2.memoizedState;
10405              prevSibling = prevState.element;
10406              cloneUpdateQueue(current2, workInProgress2);
10407              processUpdateQueue(workInProgress2, returnFiber, null, renderLanes2);
10408              var nextState = workInProgress2.memoizedState;
10409              returnFiber = nextState.cache;
10410              pushProvider(workInProgress2, CacheContext, returnFiber);
10411              returnFiber !== prevState.cache && propagateContextChanges(
10412                workInProgress2,
10413                [CacheContext],
10414                renderLanes2,
10415                true
10416              );
10417              suspendIfUpdateReadFromEntangledAsyncAction();
10418              returnFiber = nextState.element;
10419              if (prevState.isDehydrated)
10420                if (prevState = {
10421                  element: returnFiber,
10422                  isDehydrated: false,
10423                  cache: nextState.cache
10424                }, workInProgress2.updateQueue.baseState = prevState, workInProgress2.memoizedState = prevState, workInProgress2.flags & 256) {
10425                  workInProgress2 = mountHostRootWithoutHydrating(
10426                    current2,
10427                    workInProgress2,
10428                    returnFiber,
10429                    renderLanes2
10430                  );
10431                  break a;
10432                } else if (returnFiber !== prevSibling) {
10433                  prevSibling = createCapturedValueAtFiber(
10434                    Error(
10435                      "This root received an early update, before anything was able hydrate. Switched the entire root to client rendering."
10436                    ),
10437                    workInProgress2
10438                  );
10439                  queueHydrationError(prevSibling);
10440                  workInProgress2 = mountHostRootWithoutHydrating(
10441                    current2,
10442                    workInProgress2,
10443                    returnFiber,
10444                    renderLanes2
10445                  );
10446                  break a;
10447                } else {
10448                  current2 = workInProgress2.stateNode.containerInfo;
10449                  switch (current2.nodeType) {
10450                    case 9:
10451                      current2 = current2.body;
10452                      break;
10453                    default:
10454                      current2 = "HTML" === current2.nodeName ? current2.ownerDocument.body : current2;
10455                  }
10456                  nextHydratableInstance = getNextHydratable(current2.firstChild);
10457                  hydrationParentFiber = workInProgress2;
10458                  isHydrating = true;
10459                  hydrationErrors = null;
10460                  didSuspendOrErrorDEV = false;
10461                  hydrationDiffRootDEV = null;
10462                  rootOrSingletonContext = true;
10463                  renderLanes2 = mountChildFibers(
10464                    workInProgress2,
10465                    null,
10466                    returnFiber,
10467                    renderLanes2
10468                  );
10469                  for (workInProgress2.child = renderLanes2; renderLanes2; )
10470                    renderLanes2.flags = renderLanes2.flags & -3 | 4096, renderLanes2 = renderLanes2.sibling;
10471                }
10472              else {
10473                resetHydrationState();
10474                if (returnFiber === prevSibling) {
10475                  workInProgress2 = bailoutOnAlreadyFinishedWork(
10476                    current2,
10477                    workInProgress2,
10478                    renderLanes2
10479                  );
10480                  break a;
10481                }
10482                reconcileChildren(
10483                  current2,
10484                  workInProgress2,
10485                  returnFiber,
10486                  renderLanes2
10487                );
10488              }
10489              workInProgress2 = workInProgress2.child;
10490            }
10491            return workInProgress2;
10492          case 26:
10493            return markRef(current2, workInProgress2), null === current2 ? (renderLanes2 = getResource(
10494              workInProgress2.type,
10495              null,
10496              workInProgress2.pendingProps,
10497              null
10498            )) ? workInProgress2.memoizedState = renderLanes2 : isHydrating || (renderLanes2 = workInProgress2.type, current2 = workInProgress2.pendingProps, returnFiber = requiredContext(
10499              rootInstanceStackCursor.current
10500            ), returnFiber = getOwnerDocumentFromRootContainer(
10501              returnFiber
10502            ).createElement(renderLanes2), returnFiber[internalInstanceKey] = workInProgress2, returnFiber[internalPropsKey] = current2, setInitialProperties(returnFiber, renderLanes2, current2), markNodeAsHoistable(returnFiber), workInProgress2.stateNode = returnFiber) : workInProgress2.memoizedState = getResource(
10503              workInProgress2.type,
10504              current2.memoizedProps,
10505              workInProgress2.pendingProps,
10506              current2.memoizedState
10507            ), null;
10508          case 27:
10509            return pushHostContext(workInProgress2), null === current2 && isHydrating && (returnFiber = requiredContext(rootInstanceStackCursor.current), prevSibling = getHostContext(), returnFiber = workInProgress2.stateNode = resolveSingletonInstance(
10510              workInProgress2.type,
10511              workInProgress2.pendingProps,
10512              returnFiber,
10513              prevSibling,
10514              false
10515            ), didSuspendOrErrorDEV || (prevSibling = diffHydratedProperties(
10516              returnFiber,
10517              workInProgress2.type,
10518              workInProgress2.pendingProps,
10519              prevSibling
10520            ), null !== prevSibling && (buildHydrationDiffNode(workInProgress2, 0).serverProps = prevSibling)), hydrationParentFiber = workInProgress2, rootOrSingletonContext = true, prevSibling = nextHydratableInstance, isSingletonScope(workInProgress2.type) ? (previousHydratableOnEnteringScopedSingleton = prevSibling, nextHydratableInstance = getNextHydratable(
10521              returnFiber.firstChild
10522            )) : nextHydratableInstance = prevSibling), reconcileChildren(
10523              current2,
10524              workInProgress2,
10525              workInProgress2.pendingProps.children,
10526              renderLanes2
10527            ), markRef(current2, workInProgress2), null === current2 && (workInProgress2.flags |= 4194304), workInProgress2.child;
10528          case 5:
10529            return null === current2 && isHydrating && (prevState = getHostContext(), returnFiber = validateDOMNesting(
10530              workInProgress2.type,
10531              prevState.ancestorInfo
10532            ), prevSibling = nextHydratableInstance, (nextState = !prevSibling) || (nextState = canHydrateInstance(
10533              prevSibling,
10534              workInProgress2.type,
10535              workInProgress2.pendingProps,
10536              rootOrSingletonContext
10537            ), null !== nextState ? (workInProgress2.stateNode = nextState, didSuspendOrErrorDEV || (prevState = diffHydratedProperties(
10538              nextState,
10539              workInProgress2.type,
10540              workInProgress2.pendingProps,
10541              prevState
10542            ), null !== prevState && (buildHydrationDiffNode(workInProgress2, 0).serverProps = prevState)), hydrationParentFiber = workInProgress2, nextHydratableInstance = getNextHydratable(
10543              nextState.firstChild
10544            ), 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(
10545              current2,
10546              workInProgress2,
10547              TransitionAwareHostComponent,
10548              null,
10549              null,
10550              renderLanes2
10551            ), HostTransitionContext._currentValue = prevSibling), markRef(current2, workInProgress2), reconcileChildren(
10552              current2,
10553              workInProgress2,
10554              returnFiber,
10555              renderLanes2
10556            ), workInProgress2.child;
10557          case 6:
10558            return null === current2 && isHydrating && (renderLanes2 = workInProgress2.pendingProps, current2 = getHostContext(), returnFiber = current2.ancestorInfo.current, renderLanes2 = null != returnFiber ? validateTextNesting(
10559              renderLanes2,
10560              returnFiber.tag,
10561              current2.ancestorInfo.implicitRootScope
10562            ) : true, current2 = nextHydratableInstance, (returnFiber = !current2) || (returnFiber = canHydrateTextInstance(
10563              current2,
10564              workInProgress2.pendingProps,
10565              rootOrSingletonContext
10566            ), null !== returnFiber ? (workInProgress2.stateNode = returnFiber, hydrationParentFiber = workInProgress2, nextHydratableInstance = null, returnFiber = true) : returnFiber = false, returnFiber = !returnFiber), returnFiber && (renderLanes2 && warnNonHydratedInstance(workInProgress2, current2), throwOnHydrationMismatch(workInProgress2))), null;
10567          case 13:
10568            return updateSuspenseComponent(current2, workInProgress2, renderLanes2);
10569          case 4:
10570            return pushHostContainer(
10571              workInProgress2,
10572              workInProgress2.stateNode.containerInfo
10573            ), returnFiber = workInProgress2.pendingProps, null === current2 ? workInProgress2.child = reconcileChildFibers(
10574              workInProgress2,
10575              null,
10576              returnFiber,
10577              renderLanes2
10578            ) : reconcileChildren(
10579              current2,
10580              workInProgress2,
10581              returnFiber,
10582              renderLanes2
10583            ), workInProgress2.child;
10584          case 11:
10585            return updateForwardRef(
10586              current2,
10587              workInProgress2,
10588              workInProgress2.type,
10589              workInProgress2.pendingProps,
10590              renderLanes2
10591            );
10592          case 7:
10593            return reconcileChildren(
10594              current2,
10595              workInProgress2,
10596              workInProgress2.pendingProps,
10597              renderLanes2
10598            ), workInProgress2.child;
10599          case 8:
10600            return reconcileChildren(
10601              current2,
10602              workInProgress2,
10603              workInProgress2.pendingProps.children,
10604              renderLanes2
10605            ), workInProgress2.child;
10606          case 12:
10607            return workInProgress2.flags |= 4, workInProgress2.flags |= 2048, returnFiber = workInProgress2.stateNode, returnFiber.effectDuration = -0, returnFiber.passiveEffectDuration = -0, reconcileChildren(
10608              current2,
10609              workInProgress2,
10610              workInProgress2.pendingProps.children,
10611              renderLanes2
10612            ), workInProgress2.child;
10613          case 10:
10614            return returnFiber = workInProgress2.type, prevSibling = workInProgress2.pendingProps, prevState = prevSibling.value, "value" in prevSibling || hasWarnedAboutUsingNoValuePropOnContextProvider || (hasWarnedAboutUsingNoValuePropOnContextProvider = true, console.error(
10615              "The `value` prop is required for the `<Context.Provider>`. Did you misspell it or forget to pass it?"
10616            )), pushProvider(workInProgress2, returnFiber, prevState), reconcileChildren(
10617              current2,
10618              workInProgress2,
10619              prevSibling.children,
10620              renderLanes2
10621            ), workInProgress2.child;
10622          case 9:
10623            return prevSibling = workInProgress2.type._context, returnFiber = workInProgress2.pendingProps.children, "function" !== typeof returnFiber && console.error(
10624              "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."
10625            ), prepareToReadContext(workInProgress2), prevSibling = readContext(prevSibling), returnFiber = callComponentInDEV(
10626              returnFiber,
10627              prevSibling,
10628              void 0
10629            ), workInProgress2.flags |= 1, reconcileChildren(
10630              current2,
10631              workInProgress2,
10632              returnFiber,
10633              renderLanes2
10634            ), workInProgress2.child;
10635          case 14:
10636            return updateMemoComponent(
10637              current2,
10638              workInProgress2,
10639              workInProgress2.type,
10640              workInProgress2.pendingProps,
10641              renderLanes2
10642            );
10643          case 15:
10644            return updateSimpleMemoComponent(
10645              current2,
10646              workInProgress2,
10647              workInProgress2.type,
10648              workInProgress2.pendingProps,
10649              renderLanes2
10650            );
10651          case 19:
10652            return updateSuspenseListComponent(
10653              current2,
10654              workInProgress2,
10655              renderLanes2
10656            );
10657          case 31:
10658            return updateActivityComponent(current2, workInProgress2, renderLanes2);
10659          case 22:
10660            return updateOffscreenComponent(
10661              current2,
10662              workInProgress2,
10663              renderLanes2,
10664              workInProgress2.pendingProps
10665            );
10666          case 24:
10667            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 = {
10668              parent: returnFiber,
10669              cache: prevSibling
10670            }, 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 = {
10671              parent: returnFiber,
10672              cache: returnFiber
10673            }, 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(
10674              workInProgress2,
10675              [CacheContext],
10676              renderLanes2,
10677              true
10678            ))), reconcileChildren(
10679              current2,
10680              workInProgress2,
10681              workInProgress2.pendingProps.children,
10682              renderLanes2
10683            ), workInProgress2.child;
10684          case 29:
10685            throw workInProgress2.pendingProps;
10686        }
10687        throw Error(
10688          "Unknown unit of work tag (" + workInProgress2.tag + "). This error is likely caused by a bug in React. Please file an issue."
10689        );
10690      }
10691      function markUpdate(workInProgress2) {
10692        workInProgress2.flags |= 4;
10693      }
10694      function preloadInstanceAndSuspendIfNeeded(workInProgress2, type, oldProps, newProps, renderLanes2) {
10695        if (type = (workInProgress2.mode & SuspenseyImagesMode) !== NoMode)
10696          type = false;
10697        if (type) {
10698          if (workInProgress2.flags |= 16777216, (renderLanes2 & 335544128) === renderLanes2)
10699            if (workInProgress2.stateNode.complete) workInProgress2.flags |= 8192;
10700            else if (shouldRemainOnPreviousScreen()) workInProgress2.flags |= 8192;
10701            else
10702              throw suspendedThenable = noopSuspenseyCommitThenable, SuspenseyCommitException;
10703        } else workInProgress2.flags &= -16777217;
10704      }
10705      function preloadResourceAndSuspendIfNeeded(workInProgress2, resource) {
10706        if ("stylesheet" !== resource.type || (resource.state.loading & Inserted) !== NotLoaded)
10707          workInProgress2.flags &= -16777217;
10708        else if (workInProgress2.flags |= 16777216, !preloadResource(resource))
10709          if (shouldRemainOnPreviousScreen()) workInProgress2.flags |= 8192;
10710          else
10711            throw suspendedThenable = noopSuspenseyCommitThenable, SuspenseyCommitException;
10712      }
10713      function scheduleRetryEffect(workInProgress2, retryQueue) {
10714        null !== retryQueue && (workInProgress2.flags |= 4);
10715        workInProgress2.flags & 16384 && (retryQueue = 22 !== workInProgress2.tag ? claimNextRetryLane() : 536870912, workInProgress2.lanes |= retryQueue, workInProgressSuspendedRetryLanes |= retryQueue);
10716      }
10717      function cutOffTailIfNeeded(renderState, hasRenderedATailFallback) {
10718        if (!isHydrating)
10719          switch (renderState.tailMode) {
10720            case "hidden":
10721              hasRenderedATailFallback = renderState.tail;
10722              for (var lastTailNode = null; null !== hasRenderedATailFallback; )
10723                null !== hasRenderedATailFallback.alternate && (lastTailNode = hasRenderedATailFallback), hasRenderedATailFallback = hasRenderedATailFallback.sibling;
10724              null === lastTailNode ? renderState.tail = null : lastTailNode.sibling = null;
10725              break;
10726            case "collapsed":
10727              lastTailNode = renderState.tail;
10728              for (var _lastTailNode = null; null !== lastTailNode; )
10729                null !== lastTailNode.alternate && (_lastTailNode = lastTailNode), lastTailNode = lastTailNode.sibling;
10730              null === _lastTailNode ? hasRenderedATailFallback || null === renderState.tail ? renderState.tail = null : renderState.tail.sibling = null : _lastTailNode.sibling = null;
10731          }
10732      }
10733      function bubbleProperties(completedWork) {
10734        var didBailout = null !== completedWork.alternate && completedWork.alternate.child === completedWork.child, newChildLanes = 0, subtreeFlags = 0;
10735        if (didBailout)
10736          if ((completedWork.mode & ProfileMode) !== NoMode) {
10737            for (var _treeBaseDuration = completedWork.selfBaseDuration, _child2 = completedWork.child; null !== _child2; )
10738              newChildLanes |= _child2.lanes | _child2.childLanes, subtreeFlags |= _child2.subtreeFlags & 65011712, subtreeFlags |= _child2.flags & 65011712, _treeBaseDuration += _child2.treeBaseDuration, _child2 = _child2.sibling;
10739            completedWork.treeBaseDuration = _treeBaseDuration;
10740          } else
10741            for (_treeBaseDuration = completedWork.child; null !== _treeBaseDuration; )
10742              newChildLanes |= _treeBaseDuration.lanes | _treeBaseDuration.childLanes, subtreeFlags |= _treeBaseDuration.subtreeFlags & 65011712, subtreeFlags |= _treeBaseDuration.flags & 65011712, _treeBaseDuration.return = completedWork, _treeBaseDuration = _treeBaseDuration.sibling;
10743        else if ((completedWork.mode & ProfileMode) !== NoMode) {
10744          _treeBaseDuration = completedWork.actualDuration;
10745          _child2 = completedWork.selfBaseDuration;
10746          for (var child = completedWork.child; null !== child; )
10747            newChildLanes |= child.lanes | child.childLanes, subtreeFlags |= child.subtreeFlags, subtreeFlags |= child.flags, _treeBaseDuration += child.actualDuration, _child2 += child.treeBaseDuration, child = child.sibling;
10748          completedWork.actualDuration = _treeBaseDuration;
10749          completedWork.treeBaseDuration = _child2;
10750        } else
10751          for (_treeBaseDuration = completedWork.child; null !== _treeBaseDuration; )
10752            newChildLanes |= _treeBaseDuration.lanes | _treeBaseDuration.childLanes, subtreeFlags |= _treeBaseDuration.subtreeFlags, subtreeFlags |= _treeBaseDuration.flags, _treeBaseDuration.return = completedWork, _treeBaseDuration = _treeBaseDuration.sibling;
10753        completedWork.subtreeFlags |= subtreeFlags;
10754        completedWork.childLanes = newChildLanes;
10755        return didBailout;
10756      }
10757      function completeWork(current2, workInProgress2, renderLanes2) {
10758        var newProps = workInProgress2.pendingProps;
10759        popTreeContext(workInProgress2);
10760        switch (workInProgress2.tag) {
10761          case 16:
10762          case 15:
10763          case 0:
10764          case 11:
10765          case 7:
10766          case 8:
10767          case 12:
10768          case 9:
10769          case 14:
10770            return bubbleProperties(workInProgress2), null;
10771          case 1:
10772            return bubbleProperties(workInProgress2), null;
10773          case 3:
10774            renderLanes2 = workInProgress2.stateNode;
10775            newProps = null;
10776            null !== current2 && (newProps = current2.memoizedState.cache);
10777            workInProgress2.memoizedState.cache !== newProps && (workInProgress2.flags |= 2048);
10778            popProvider(CacheContext, workInProgress2);
10779            popHostContainer(workInProgress2);
10780            renderLanes2.pendingContext && (renderLanes2.context = renderLanes2.pendingContext, renderLanes2.pendingContext = null);
10781            if (null === current2 || null === current2.child)
10782              popHydrationState(workInProgress2) ? (emitPendingHydrationWarnings(), markUpdate(workInProgress2)) : null === current2 || current2.memoizedState.isDehydrated && 0 === (workInProgress2.flags & 256) || (workInProgress2.flags |= 1024, upgradeHydrationErrorsToRecoverable());
10783            bubbleProperties(workInProgress2);
10784            return null;
10785          case 26:
10786            var type = workInProgress2.type, nextResource = workInProgress2.memoizedState;
10787            null === current2 ? (markUpdate(workInProgress2), null !== nextResource ? (bubbleProperties(workInProgress2), preloadResourceAndSuspendIfNeeded(
10788              workInProgress2,
10789              nextResource
10790            )) : (bubbleProperties(workInProgress2), preloadInstanceAndSuspendIfNeeded(
10791              workInProgress2,
10792              type,
10793              null,
10794              newProps,
10795              renderLanes2
10796            ))) : nextResource ? nextResource !== current2.memoizedState ? (markUpdate(workInProgress2), bubbleProperties(workInProgress2), preloadResourceAndSuspendIfNeeded(
10797              workInProgress2,
10798              nextResource
10799            )) : (bubbleProperties(workInProgress2), workInProgress2.flags &= -16777217) : (current2 = current2.memoizedProps, current2 !== newProps && markUpdate(workInProgress2), bubbleProperties(workInProgress2), preloadInstanceAndSuspendIfNeeded(
10800              workInProgress2,
10801              type,
10802              current2,
10803              newProps,
10804              renderLanes2
10805            ));
10806            return null;
10807          case 27:
10808            popHostContext(workInProgress2);
10809            renderLanes2 = requiredContext(rootInstanceStackCursor.current);
10810            type = workInProgress2.type;
10811            if (null !== current2 && null != workInProgress2.stateNode)
10812              current2.memoizedProps !== newProps && markUpdate(workInProgress2);
10813            else {
10814              if (!newProps) {
10815                if (null === workInProgress2.stateNode)
10816                  throw Error(
10817                    "We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue."
10818                  );
10819                bubbleProperties(workInProgress2);
10820                return null;
10821              }
10822              current2 = getHostContext();
10823              popHydrationState(workInProgress2) ? prepareToHydrateHostInstance(workInProgress2, current2) : (current2 = resolveSingletonInstance(
10824                type,
10825                newProps,
10826                renderLanes2,
10827                current2,
10828                true
10829              ), workInProgress2.stateNode = current2, markUpdate(workInProgress2));
10830            }
10831            bubbleProperties(workInProgress2);
10832            return null;
10833          case 5:
10834            popHostContext(workInProgress2);
10835            type = workInProgress2.type;
10836            if (null !== current2 && null != workInProgress2.stateNode)
10837              current2.memoizedProps !== newProps && markUpdate(workInProgress2);
10838            else {
10839              if (!newProps) {
10840                if (null === workInProgress2.stateNode)
10841                  throw Error(
10842                    "We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue."
10843                  );
10844                bubbleProperties(workInProgress2);
10845                return null;
10846              }
10847              var _currentHostContext = getHostContext();
10848              if (popHydrationState(workInProgress2))
10849                prepareToHydrateHostInstance(workInProgress2, _currentHostContext);
10850              else {
10851                nextResource = requiredContext(rootInstanceStackCursor.current);
10852                validateDOMNesting(type, _currentHostContext.ancestorInfo);
10853                _currentHostContext = _currentHostContext.context;
10854                nextResource = getOwnerDocumentFromRootContainer(nextResource);
10855                switch (_currentHostContext) {
10856                  case HostContextNamespaceSvg:
10857                    nextResource = nextResource.createElementNS(
10858                      SVG_NAMESPACE,
10859                      type
10860                    );
10861                    break;
10862                  case HostContextNamespaceMath:
10863                    nextResource = nextResource.createElementNS(
10864                      MATH_NAMESPACE,
10865                      type
10866                    );
10867                    break;
10868                  default:
10869                    switch (type) {
10870                      case "svg":
10871                        nextResource = nextResource.createElementNS(
10872                          SVG_NAMESPACE,
10873                          type
10874                        );
10875                        break;
10876                      case "math":
10877                        nextResource = nextResource.createElementNS(
10878                          MATH_NAMESPACE,
10879                          type
10880                        );
10881                        break;
10882                      case "script":
10883                        nextResource = nextResource.createElement("div");
10884                        nextResource.innerHTML = "<script><\/script>";
10885                        nextResource = nextResource.removeChild(
10886                          nextResource.firstChild
10887                        );
10888                        break;
10889                      case "select":
10890                        nextResource = "string" === typeof newProps.is ? nextResource.createElement("select", {
10891                          is: newProps.is
10892                        }) : nextResource.createElement("select");
10893                        newProps.multiple ? nextResource.multiple = true : newProps.size && (nextResource.size = newProps.size);
10894                        break;
10895                      default:
10896                        nextResource = "string" === typeof newProps.is ? nextResource.createElement(type, {
10897                          is: newProps.is
10898                        }) : nextResource.createElement(type), -1 === type.indexOf("-") && (type !== type.toLowerCase() && console.error(
10899                          "<%s /> is using incorrect casing. Use PascalCase for React components, or lowercase for HTML elements.",
10900                          type
10901                        ), "[object HTMLUnknownElement]" !== Object.prototype.toString.call(nextResource) || hasOwnProperty.call(warnedUnknownTags, type) || (warnedUnknownTags[type] = true, console.error(
10902                          "The tag <%s> is unrecognized in this browser. If you meant to render a React component, start its name with an uppercase letter.",
10903                          type
10904                        )));
10905                    }
10906                }
10907                nextResource[internalInstanceKey] = workInProgress2;
10908                nextResource[internalPropsKey] = newProps;
10909                a: for (_currentHostContext = workInProgress2.child; null !== _currentHostContext; ) {
10910                  if (5 === _currentHostContext.tag || 6 === _currentHostContext.tag)
10911                    nextResource.appendChild(_currentHostContext.stateNode);
10912                  else if (4 !== _currentHostContext.tag && 27 !== _currentHostContext.tag && null !== _currentHostContext.child) {
10913                    _currentHostContext.child.return = _currentHostContext;
10914                    _currentHostContext = _currentHostContext.child;
10915                    continue;
10916                  }
10917                  if (_currentHostContext === workInProgress2) break a;
10918                  for (; null === _currentHostContext.sibling; ) {
10919                    if (null === _currentHostContext.return || _currentHostContext.return === workInProgress2)
10920                      break a;
10921                    _currentHostContext = _currentHostContext.return;
10922                  }
10923                  _currentHostContext.sibling.return = _currentHostContext.return;
10924                  _currentHostContext = _currentHostContext.sibling;
10925                }
10926                workInProgress2.stateNode = nextResource;
10927                a: switch (setInitialProperties(nextResource, type, newProps), type) {
10928                  case "button":
10929                  case "input":
10930                  case "select":
10931                  case "textarea":
10932                    newProps = !!newProps.autoFocus;
10933                    break a;
10934                  case "img":
10935                    newProps = true;
10936                    break a;
10937                  default:
10938                    newProps = false;
10939                }
10940                newProps && markUpdate(workInProgress2);
10941              }
10942            }
10943            bubbleProperties(workInProgress2);
10944            preloadInstanceAndSuspendIfNeeded(
10945              workInProgress2,
10946              workInProgress2.type,
10947              null === current2 ? null : current2.memoizedProps,
10948              workInProgress2.pendingProps,
10949              renderLanes2
10950            );
10951            return null;
10952          case 6:
10953            if (current2 && null != workInProgress2.stateNode)
10954              current2.memoizedProps !== newProps && markUpdate(workInProgress2);
10955            else {
10956              if ("string" !== typeof newProps && null === workInProgress2.stateNode)
10957                throw Error(
10958                  "We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue."
10959                );
10960              current2 = requiredContext(rootInstanceStackCursor.current);
10961              renderLanes2 = getHostContext();
10962              if (popHydrationState(workInProgress2)) {
10963                current2 = workInProgress2.stateNode;
10964                renderLanes2 = workInProgress2.memoizedProps;
10965                type = !didSuspendOrErrorDEV;
10966                newProps = null;
10967                nextResource = hydrationParentFiber;
10968                if (null !== nextResource)
10969                  switch (nextResource.tag) {
10970                    case 3:
10971                      type && (type = diffHydratedTextForDevWarnings(
10972                        current2,
10973                        renderLanes2,
10974                        newProps
10975                      ), null !== type && (buildHydrationDiffNode(workInProgress2, 0).serverProps = type));
10976                      break;
10977                    case 27:
10978                    case 5:
10979                      newProps = nextResource.memoizedProps, type && (type = diffHydratedTextForDevWarnings(
10980                        current2,
10981                        renderLanes2,
10982                        newProps
10983                      ), null !== type && (buildHydrationDiffNode(
10984                        workInProgress2,
10985                        0
10986                      ).serverProps = type));
10987                  }
10988                current2[internalInstanceKey] = workInProgress2;
10989                current2 = current2.nodeValue === renderLanes2 || null !== newProps && true === newProps.suppressHydrationWarning || checkForUnmatchedText(current2.nodeValue, renderLanes2) ? true : false;
10990                current2 || throwOnHydrationMismatch(workInProgress2, true);
10991              } else
10992                type = renderLanes2.ancestorInfo.current, null != type && validateTextNesting(
10993                  newProps,
10994                  type.tag,
10995                  renderLanes2.ancestorInfo.implicitRootScope
10996                ), current2 = getOwnerDocumentFromRootContainer(current2).createTextNode(
10997                  newProps
10998                ), current2[internalInstanceKey] = workInProgress2, workInProgress2.stateNode = current2;
10999            }
11000            bubbleProperties(workInProgress2);
11001            return null;
11002          case 31:
11003            renderLanes2 = workInProgress2.memoizedState;
11004            if (null === current2 || null !== current2.memoizedState) {
11005              newProps = popHydrationState(workInProgress2);
11006              if (null !== renderLanes2) {
11007                if (null === current2) {
11008                  if (!newProps)
11009                    throw Error(
11010                      "A dehydrated suspense component was completed without a hydrated node. This is probably a bug in React."
11011                    );
11012                  current2 = workInProgress2.memoizedState;
11013                  current2 = null !== current2 ? current2.dehydrated : null;
11014                  if (!current2)
11015                    throw Error(
11016                      "Expected to have a hydrated activity instance. This error is likely caused by a bug in React. Please file an issue."
11017                    );
11018                  current2[internalInstanceKey] = workInProgress2;
11019                  bubbleProperties(workInProgress2);
11020                  (workInProgress2.mode & ProfileMode) !== NoMode && null !== renderLanes2 && (current2 = workInProgress2.child, null !== current2 && (workInProgress2.treeBaseDuration -= current2.treeBaseDuration));
11021                } else
11022                  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));
11023                current2 = false;
11024              } else
11025                renderLanes2 = upgradeHydrationErrorsToRecoverable(), null !== current2 && null !== current2.memoizedState && (current2.memoizedState.hydrationErrors = renderLanes2), current2 = true;
11026              if (!current2) {
11027                if (workInProgress2.flags & 256)
11028                  return popSuspenseHandler(workInProgress2), workInProgress2;
11029                popSuspenseHandler(workInProgress2);
11030                return null;
11031              }
11032              if (0 !== (workInProgress2.flags & 128))
11033                throw Error(
11034                  "Client rendering an Activity suspended it again. This is a bug in React."
11035                );
11036            }
11037            bubbleProperties(workInProgress2);
11038            return null;
11039          case 13:
11040            newProps = workInProgress2.memoizedState;
11041            if (null === current2 || null !== current2.memoizedState && null !== current2.memoizedState.dehydrated) {
11042              type = newProps;
11043              nextResource = popHydrationState(workInProgress2);
11044              if (null !== type && null !== type.dehydrated) {
11045                if (null === current2) {
11046                  if (!nextResource)
11047                    throw Error(
11048                      "A dehydrated suspense component was completed without a hydrated node. This is probably a bug in React."
11049                    );
11050                  nextResource = workInProgress2.memoizedState;
11051                  nextResource = null !== nextResource ? nextResource.dehydrated : null;
11052                  if (!nextResource)
11053                    throw Error(
11054                      "Expected to have a hydrated suspense instance. This error is likely caused by a bug in React. Please file an issue."
11055                    );
11056                  nextResource[internalInstanceKey] = workInProgress2;
11057                  bubbleProperties(workInProgress2);
11058                  (workInProgress2.mode & ProfileMode) !== NoMode && null !== type && (type = workInProgress2.child, null !== type && (workInProgress2.treeBaseDuration -= type.treeBaseDuration));
11059                } else
11060                  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));
11061                type = false;
11062              } else
11063                type = upgradeHydrationErrorsToRecoverable(), null !== current2 && null !== current2.memoizedState && (current2.memoizedState.hydrationErrors = type), type = true;
11064              if (!type) {
11065                if (workInProgress2.flags & 256)
11066                  return popSuspenseHandler(workInProgress2), workInProgress2;
11067                popSuspenseHandler(workInProgress2);
11068                return null;
11069              }
11070            }
11071            popSuspenseHandler(workInProgress2);
11072            if (0 !== (workInProgress2.flags & 128))
11073              return workInProgress2.lanes = renderLanes2, (workInProgress2.mode & ProfileMode) !== NoMode && transferActualDuration(workInProgress2), workInProgress2;
11074            renderLanes2 = null !== newProps;
11075            current2 = null !== current2 && null !== current2.memoizedState;
11076            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));
11077            renderLanes2 !== current2 && renderLanes2 && (workInProgress2.child.flags |= 8192);
11078            scheduleRetryEffect(workInProgress2, workInProgress2.updateQueue);
11079            bubbleProperties(workInProgress2);
11080            (workInProgress2.mode & ProfileMode) !== NoMode && renderLanes2 && (current2 = workInProgress2.child, null !== current2 && (workInProgress2.treeBaseDuration -= current2.treeBaseDuration));
11081            return null;
11082          case 4:
11083            return popHostContainer(workInProgress2), null === current2 && listenToAllSupportedEvents(
11084              workInProgress2.stateNode.containerInfo
11085            ), bubbleProperties(workInProgress2), null;
11086          case 10:
11087            return popProvider(workInProgress2.type, workInProgress2), bubbleProperties(workInProgress2), null;
11088          case 19:
11089            pop(suspenseStackCursor, workInProgress2);
11090            newProps = workInProgress2.memoizedState;
11091            if (null === newProps) return bubbleProperties(workInProgress2), null;
11092            type = 0 !== (workInProgress2.flags & 128);
11093            nextResource = newProps.rendering;
11094            if (null === nextResource)
11095              if (type) cutOffTailIfNeeded(newProps, false);
11096              else {
11097                if (workInProgressRootExitStatus !== RootInProgress || null !== current2 && 0 !== (current2.flags & 128))
11098                  for (current2 = workInProgress2.child; null !== current2; ) {
11099                    nextResource = findFirstSuspended(current2);
11100                    if (null !== nextResource) {
11101                      workInProgress2.flags |= 128;
11102                      cutOffTailIfNeeded(newProps, false);
11103                      current2 = nextResource.updateQueue;
11104                      workInProgress2.updateQueue = current2;
11105                      scheduleRetryEffect(workInProgress2, current2);
11106                      workInProgress2.subtreeFlags = 0;
11107                      current2 = renderLanes2;
11108                      for (renderLanes2 = workInProgress2.child; null !== renderLanes2; )
11109                        resetWorkInProgress(renderLanes2, current2), renderLanes2 = renderLanes2.sibling;
11110                      push(
11111                        suspenseStackCursor,
11112                        suspenseStackCursor.current & SubtreeSuspenseContextMask | ForceSuspenseFallback,
11113                        workInProgress2
11114                      );
11115                      isHydrating && pushTreeFork(workInProgress2, newProps.treeForkCount);
11116                      return workInProgress2.child;
11117                    }
11118                    current2 = current2.sibling;
11119                  }
11120                null !== newProps.tail && now$1() > workInProgressRootRenderTargetTime && (workInProgress2.flags |= 128, type = true, cutOffTailIfNeeded(newProps, false), workInProgress2.lanes = 4194304);
11121              }
11122            else {
11123              if (!type)
11124                if (current2 = findFirstSuspended(nextResource), null !== current2) {
11125                  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)
11126                    return bubbleProperties(workInProgress2), null;
11127                } else
11128                  2 * now$1() - newProps.renderingStartTime > workInProgressRootRenderTargetTime && 536870912 !== renderLanes2 && (workInProgress2.flags |= 128, type = true, cutOffTailIfNeeded(newProps, false), workInProgress2.lanes = 4194304);
11129              newProps.isBackwards ? (nextResource.sibling = workInProgress2.child, workInProgress2.child = nextResource) : (current2 = newProps.last, null !== current2 ? current2.sibling = nextResource : workInProgress2.child = nextResource, newProps.last = nextResource);
11130            }
11131            if (null !== newProps.tail)
11132              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;
11133            bubbleProperties(workInProgress2);
11134            return null;
11135          case 22:
11136          case 23:
11137            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;
11138          case 24:
11139            return renderLanes2 = null, null !== current2 && (renderLanes2 = current2.memoizedState.cache), workInProgress2.memoizedState.cache !== renderLanes2 && (workInProgress2.flags |= 2048), popProvider(CacheContext, workInProgress2), bubbleProperties(workInProgress2), null;
11140          case 25:
11141            return null;
11142          case 30:
11143            return null;
11144        }
11145        throw Error(
11146          "Unknown unit of work tag (" + workInProgress2.tag + "). This error is likely caused by a bug in React. Please file an issue."
11147        );
11148      }
11149      function unwindWork(current2, workInProgress2) {
11150        popTreeContext(workInProgress2);
11151        switch (workInProgress2.tag) {
11152          case 1:
11153            return current2 = workInProgress2.flags, current2 & 65536 ? (workInProgress2.flags = current2 & -65537 | 128, (workInProgress2.mode & ProfileMode) !== NoMode && transferActualDuration(workInProgress2), workInProgress2) : null;
11154          case 3:
11155            return popProvider(CacheContext, workInProgress2), popHostContainer(workInProgress2), current2 = workInProgress2.flags, 0 !== (current2 & 65536) && 0 === (current2 & 128) ? (workInProgress2.flags = current2 & -65537 | 128, workInProgress2) : null;
11156          case 26:
11157          case 27:
11158          case 5:
11159            return popHostContext(workInProgress2), null;
11160          case 31:
11161            if (null !== workInProgress2.memoizedState) {
11162              popSuspenseHandler(workInProgress2);
11163              if (null === workInProgress2.alternate)
11164                throw Error(
11165                  "Threw in newly mounted dehydrated component. This is likely a bug in React. Please file an issue."
11166                );
11167              resetHydrationState();
11168            }
11169            current2 = workInProgress2.flags;
11170            return current2 & 65536 ? (workInProgress2.flags = current2 & -65537 | 128, (workInProgress2.mode & ProfileMode) !== NoMode && transferActualDuration(workInProgress2), workInProgress2) : null;
11171          case 13:
11172            popSuspenseHandler(workInProgress2);
11173            current2 = workInProgress2.memoizedState;
11174            if (null !== current2 && null !== current2.dehydrated) {
11175              if (null === workInProgress2.alternate)
11176                throw Error(
11177                  "Threw in newly mounted dehydrated component. This is likely a bug in React. Please file an issue."
11178                );
11179              resetHydrationState();
11180            }
11181            current2 = workInProgress2.flags;
11182            return current2 & 65536 ? (workInProgress2.flags = current2 & -65537 | 128, (workInProgress2.mode & ProfileMode) !== NoMode && transferActualDuration(workInProgress2), workInProgress2) : null;
11183          case 19:
11184            return pop(suspenseStackCursor, workInProgress2), null;
11185          case 4:
11186            return popHostContainer(workInProgress2), null;
11187          case 10:
11188            return popProvider(workInProgress2.type, workInProgress2), null;
11189          case 22:
11190          case 23:
11191            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;
11192          case 24:
11193            return popProvider(CacheContext, workInProgress2), null;
11194          case 25:
11195            return null;
11196          default:
11197            return null;
11198        }
11199      }
11200      function unwindInterruptedWork(current2, interruptedWork) {
11201        popTreeContext(interruptedWork);
11202        switch (interruptedWork.tag) {
11203          case 3:
11204            popProvider(CacheContext, interruptedWork);
11205            popHostContainer(interruptedWork);
11206            break;
11207          case 26:
11208          case 27:
11209          case 5:
11210            popHostContext(interruptedWork);
11211            break;
11212          case 4:
11213            popHostContainer(interruptedWork);
11214            break;
11215          case 31:
11216            null !== interruptedWork.memoizedState && popSuspenseHandler(interruptedWork);
11217            break;
11218          case 13:
11219            popSuspenseHandler(interruptedWork);
11220            break;
11221          case 19:
11222            pop(suspenseStackCursor, interruptedWork);
11223            break;
11224          case 10:
11225            popProvider(interruptedWork.type, interruptedWork);
11226            break;
11227          case 22:
11228          case 23:
11229            popSuspenseHandler(interruptedWork);
11230            popHiddenContext(interruptedWork);
11231            null !== current2 && pop(resumedCache, interruptedWork);
11232            break;
11233          case 24:
11234            popProvider(CacheContext, interruptedWork);
11235        }
11236      }
11237      function shouldProfile(current2) {
11238        return (current2.mode & ProfileMode) !== NoMode;
11239      }
11240      function commitHookLayoutEffects(finishedWork, hookFlags) {
11241        shouldProfile(finishedWork) ? (startEffectTimer(), commitHookEffectListMount(hookFlags, finishedWork), recordEffectDuration()) : commitHookEffectListMount(hookFlags, finishedWork);
11242      }
11243      function commitHookLayoutUnmountEffects(finishedWork, nearestMountedAncestor, hookFlags) {
11244        shouldProfile(finishedWork) ? (startEffectTimer(), commitHookEffectListUnmount(
11245          hookFlags,
11246          finishedWork,
11247          nearestMountedAncestor
11248        ), recordEffectDuration()) : commitHookEffectListUnmount(
11249          hookFlags,
11250          finishedWork,
11251          nearestMountedAncestor
11252        );
11253      }
11254      function commitHookEffectListMount(flags, finishedWork) {
11255        try {
11256          var updateQueue = finishedWork.updateQueue, lastEffect = null !== updateQueue ? updateQueue.lastEffect : null;
11257          if (null !== lastEffect) {
11258            var firstEffect = lastEffect.next;
11259            updateQueue = firstEffect;
11260            do {
11261              if ((updateQueue.tag & flags) === flags && (lastEffect = void 0, (flags & Insertion) !== NoFlags && (isRunningInsertionEffect = true), lastEffect = runWithFiberInDEV(
11262                finishedWork,
11263                callCreateInDEV,
11264                updateQueue
11265              ), (flags & Insertion) !== NoFlags && (isRunningInsertionEffect = false), void 0 !== lastEffect && "function" !== typeof lastEffect)) {
11266                var hookName = void 0;
11267                hookName = 0 !== (updateQueue.tag & Layout) ? "useLayoutEffect" : 0 !== (updateQueue.tag & Insertion) ? "useInsertionEffect" : "useEffect";
11268                var addendum = void 0;
11269                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;
11270                runWithFiberInDEV(
11271                  finishedWork,
11272                  function(n3, a3) {
11273                    console.error(
11274                      "%s must not return anything besides a function, which is used for clean-up.%s",
11275                      n3,
11276                      a3
11277                    );
11278                  },
11279                  hookName,
11280                  addendum
11281                );
11282              }
11283              updateQueue = updateQueue.next;
11284            } while (updateQueue !== firstEffect);
11285          }
11286        } catch (error2) {
11287          captureCommitPhaseError(finishedWork, finishedWork.return, error2);
11288        }
11289      }
11290      function commitHookEffectListUnmount(flags, finishedWork, nearestMountedAncestor) {
11291        try {
11292          var updateQueue = finishedWork.updateQueue, lastEffect = null !== updateQueue ? updateQueue.lastEffect : null;
11293          if (null !== lastEffect) {
11294            var firstEffect = lastEffect.next;
11295            updateQueue = firstEffect;
11296            do {
11297              if ((updateQueue.tag & flags) === flags) {
11298                var inst = updateQueue.inst, destroy = inst.destroy;
11299                void 0 !== destroy && (inst.destroy = void 0, (flags & Insertion) !== NoFlags && (isRunningInsertionEffect = true), lastEffect = finishedWork, runWithFiberInDEV(
11300                  lastEffect,
11301                  callDestroyInDEV,
11302                  lastEffect,
11303                  nearestMountedAncestor,
11304                  destroy
11305                ), (flags & Insertion) !== NoFlags && (isRunningInsertionEffect = false));
11306              }
11307              updateQueue = updateQueue.next;
11308            } while (updateQueue !== firstEffect);
11309          }
11310        } catch (error2) {
11311          captureCommitPhaseError(finishedWork, finishedWork.return, error2);
11312        }
11313      }
11314      function commitHookPassiveMountEffects(finishedWork, hookFlags) {
11315        shouldProfile(finishedWork) ? (startEffectTimer(), commitHookEffectListMount(hookFlags, finishedWork), recordEffectDuration()) : commitHookEffectListMount(hookFlags, finishedWork);
11316      }
11317      function commitHookPassiveUnmountEffects(finishedWork, nearestMountedAncestor, hookFlags) {
11318        shouldProfile(finishedWork) ? (startEffectTimer(), commitHookEffectListUnmount(
11319          hookFlags,
11320          finishedWork,
11321          nearestMountedAncestor
11322        ), recordEffectDuration()) : commitHookEffectListUnmount(
11323          hookFlags,
11324          finishedWork,
11325          nearestMountedAncestor
11326        );
11327      }
11328      function commitClassCallbacks(finishedWork) {
11329        var updateQueue = finishedWork.updateQueue;
11330        if (null !== updateQueue) {
11331          var instance = finishedWork.stateNode;
11332          finishedWork.type.defaultProps || "ref" in finishedWork.memoizedProps || didWarnAboutReassigningProps || (instance.props !== finishedWork.memoizedProps && console.error(
11333            "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.",
11334            getComponentNameFromFiber(finishedWork) || "instance"
11335          ), instance.state !== finishedWork.memoizedState && console.error(
11336            "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.",
11337            getComponentNameFromFiber(finishedWork) || "instance"
11338          ));
11339          try {
11340            runWithFiberInDEV(
11341              finishedWork,
11342              commitCallbacks,
11343              updateQueue,
11344              instance
11345            );
11346          } catch (error2) {
11347            captureCommitPhaseError(finishedWork, finishedWork.return, error2);
11348          }
11349        }
11350      }
11351      function callGetSnapshotBeforeUpdates(instance, prevProps, prevState) {
11352        return instance.getSnapshotBeforeUpdate(prevProps, prevState);
11353      }
11354      function commitClassSnapshot(finishedWork, current2) {
11355        var prevProps = current2.memoizedProps, prevState = current2.memoizedState;
11356        current2 = finishedWork.stateNode;
11357        finishedWork.type.defaultProps || "ref" in finishedWork.memoizedProps || didWarnAboutReassigningProps || (current2.props !== finishedWork.memoizedProps && console.error(
11358          "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.",
11359          getComponentNameFromFiber(finishedWork) || "instance"
11360        ), current2.state !== finishedWork.memoizedState && console.error(
11361          "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.",
11362          getComponentNameFromFiber(finishedWork) || "instance"
11363        ));
11364        try {
11365          var resolvedPrevProps = resolveClassComponentProps(
11366            finishedWork.type,
11367            prevProps
11368          );
11369          var snapshot = runWithFiberInDEV(
11370            finishedWork,
11371            callGetSnapshotBeforeUpdates,
11372            current2,
11373            resolvedPrevProps,
11374            prevState
11375          );
11376          prevProps = didWarnAboutUndefinedSnapshotBeforeUpdate;
11377          void 0 !== snapshot || prevProps.has(finishedWork.type) || (prevProps.add(finishedWork.type), runWithFiberInDEV(finishedWork, function() {
11378            console.error(
11379              "%s.getSnapshotBeforeUpdate(): A snapshot value (or null) must be returned. You have returned undefined.",
11380              getComponentNameFromFiber(finishedWork)
11381            );
11382          }));
11383          current2.__reactInternalSnapshotBeforeUpdate = snapshot;
11384        } catch (error2) {
11385          captureCommitPhaseError(finishedWork, finishedWork.return, error2);
11386        }
11387      }
11388      function safelyCallComponentWillUnmount(current2, nearestMountedAncestor, instance) {
11389        instance.props = resolveClassComponentProps(
11390          current2.type,
11391          current2.memoizedProps
11392        );
11393        instance.state = current2.memoizedState;
11394        shouldProfile(current2) ? (startEffectTimer(), runWithFiberInDEV(
11395          current2,
11396          callComponentWillUnmountInDEV,
11397          current2,
11398          nearestMountedAncestor,
11399          instance
11400        ), recordEffectDuration()) : runWithFiberInDEV(
11401          current2,
11402          callComponentWillUnmountInDEV,
11403          current2,
11404          nearestMountedAncestor,
11405          instance
11406        );
11407      }
11408      function commitAttachRef(finishedWork) {
11409        var ref = finishedWork.ref;
11410        if (null !== ref) {
11411          switch (finishedWork.tag) {
11412            case 26:
11413            case 27:
11414            case 5:
11415              var instanceToUse = finishedWork.stateNode;
11416              break;
11417            case 30:
11418              instanceToUse = finishedWork.stateNode;
11419              break;
11420            default:
11421              instanceToUse = finishedWork.stateNode;
11422          }
11423          if ("function" === typeof ref)
11424            if (shouldProfile(finishedWork))
11425              try {
11426                startEffectTimer(), finishedWork.refCleanup = ref(instanceToUse);
11427              } finally {
11428                recordEffectDuration();
11429              }
11430            else finishedWork.refCleanup = ref(instanceToUse);
11431          else
11432            "string" === typeof ref ? console.error("String refs are no longer supported.") : ref.hasOwnProperty("current") || console.error(
11433              "Unexpected ref object provided for %s. Use either a ref-setter function or React.createRef().",
11434              getComponentNameFromFiber(finishedWork)
11435            ), ref.current = instanceToUse;
11436        }
11437      }
11438      function safelyAttachRef(current2, nearestMountedAncestor) {
11439        try {
11440          runWithFiberInDEV(current2, commitAttachRef, current2);
11441        } catch (error2) {
11442          captureCommitPhaseError(current2, nearestMountedAncestor, error2);
11443        }
11444      }
11445      function safelyDetachRef(current2, nearestMountedAncestor) {
11446        var ref = current2.ref, refCleanup = current2.refCleanup;
11447        if (null !== ref)
11448          if ("function" === typeof refCleanup)
11449            try {
11450              if (shouldProfile(current2))
11451                try {
11452                  startEffectTimer(), runWithFiberInDEV(current2, refCleanup);
11453                } finally {
11454                  recordEffectDuration(current2);
11455                }
11456              else runWithFiberInDEV(current2, refCleanup);
11457            } catch (error2) {
11458              captureCommitPhaseError(current2, nearestMountedAncestor, error2);
11459            } finally {
11460              current2.refCleanup = null, current2 = current2.alternate, null != current2 && (current2.refCleanup = null);
11461            }
11462          else if ("function" === typeof ref)
11463            try {
11464              if (shouldProfile(current2))
11465                try {
11466                  startEffectTimer(), runWithFiberInDEV(current2, ref, null);
11467                } finally {
11468                  recordEffectDuration(current2);
11469                }
11470              else runWithFiberInDEV(current2, ref, null);
11471            } catch (error$7) {
11472              captureCommitPhaseError(current2, nearestMountedAncestor, error$7);
11473            }
11474          else ref.current = null;
11475      }
11476      function commitProfiler(finishedWork, current2, commitStartTime2, effectDuration) {
11477        var _finishedWork$memoize = finishedWork.memoizedProps, id = _finishedWork$memoize.id, onCommit = _finishedWork$memoize.onCommit;
11478        _finishedWork$memoize = _finishedWork$memoize.onRender;
11479        current2 = null === current2 ? "mount" : "update";
11480        currentUpdateIsNested && (current2 = "nested-update");
11481        "function" === typeof _finishedWork$memoize && _finishedWork$memoize(
11482          id,
11483          current2,
11484          finishedWork.actualDuration,
11485          finishedWork.treeBaseDuration,
11486          finishedWork.actualStartTime,
11487          commitStartTime2
11488        );
11489        "function" === typeof onCommit && onCommit(id, current2, effectDuration, commitStartTime2);
11490      }
11491      function commitProfilerPostCommitImpl(finishedWork, current2, commitStartTime2, passiveEffectDuration) {
11492        var _finishedWork$memoize2 = finishedWork.memoizedProps;
11493        finishedWork = _finishedWork$memoize2.id;
11494        _finishedWork$memoize2 = _finishedWork$memoize2.onPostCommit;
11495        current2 = null === current2 ? "mount" : "update";
11496        currentUpdateIsNested && (current2 = "nested-update");
11497        "function" === typeof _finishedWork$memoize2 && _finishedWork$memoize2(
11498          finishedWork,
11499          current2,
11500          passiveEffectDuration,
11501          commitStartTime2
11502        );
11503      }
11504      function commitHostMount(finishedWork) {
11505        var type = finishedWork.type, props = finishedWork.memoizedProps, instance = finishedWork.stateNode;
11506        try {
11507          runWithFiberInDEV(
11508            finishedWork,
11509            commitMount,
11510            instance,
11511            type,
11512            props,
11513            finishedWork
11514          );
11515        } catch (error2) {
11516          captureCommitPhaseError(finishedWork, finishedWork.return, error2);
11517        }
11518      }
11519      function commitHostUpdate(finishedWork, newProps, oldProps) {
11520        try {
11521          runWithFiberInDEV(
11522            finishedWork,
11523            commitUpdate,
11524            finishedWork.stateNode,
11525            finishedWork.type,
11526            oldProps,
11527            newProps,
11528            finishedWork
11529          );
11530        } catch (error2) {
11531          captureCommitPhaseError(finishedWork, finishedWork.return, error2);
11532        }
11533      }
11534      function isHostParent(fiber) {
11535        return 5 === fiber.tag || 3 === fiber.tag || 26 === fiber.tag || 27 === fiber.tag && isSingletonScope(fiber.type) || 4 === fiber.tag;
11536      }
11537      function getHostSibling(fiber) {
11538        a: for (; ; ) {
11539          for (; null === fiber.sibling; ) {
11540            if (null === fiber.return || isHostParent(fiber.return)) return null;
11541            fiber = fiber.return;
11542          }
11543          fiber.sibling.return = fiber.return;
11544          for (fiber = fiber.sibling; 5 !== fiber.tag && 6 !== fiber.tag && 18 !== fiber.tag; ) {
11545            if (27 === fiber.tag && isSingletonScope(fiber.type)) continue a;
11546            if (fiber.flags & 2) continue a;
11547            if (null === fiber.child || 4 === fiber.tag) continue a;
11548            else fiber.child.return = fiber, fiber = fiber.child;
11549          }
11550          if (!(fiber.flags & 2)) return fiber.stateNode;
11551        }
11552      }
11553      function insertOrAppendPlacementNodeIntoContainer(node, before, parent) {
11554        var tag = node.tag;
11555        if (5 === tag || 6 === tag)
11556          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));
11557        else if (4 !== tag && (27 === tag && isSingletonScope(node.type) && (parent = node.stateNode, before = null), node = node.child, null !== node))
11558          for (insertOrAppendPlacementNodeIntoContainer(node, before, parent), node = node.sibling; null !== node; )
11559            insertOrAppendPlacementNodeIntoContainer(node, before, parent), node = node.sibling;
11560      }
11561      function insertOrAppendPlacementNode(node, before, parent) {
11562        var tag = node.tag;
11563        if (5 === tag || 6 === tag)
11564          node = node.stateNode, before ? parent.insertBefore(node, before) : parent.appendChild(node);
11565        else if (4 !== tag && (27 === tag && isSingletonScope(node.type) && (parent = node.stateNode), node = node.child, null !== node))
11566          for (insertOrAppendPlacementNode(node, before, parent), node = node.sibling; null !== node; )
11567            insertOrAppendPlacementNode(node, before, parent), node = node.sibling;
11568      }
11569      function commitPlacement(finishedWork) {
11570        for (var hostParentFiber, parentFiber = finishedWork.return; null !== parentFiber; ) {
11571          if (isHostParent(parentFiber)) {
11572            hostParentFiber = parentFiber;
11573            break;
11574          }
11575          parentFiber = parentFiber.return;
11576        }
11577        if (null == hostParentFiber)
11578          throw Error(
11579            "Expected to find a host parent. This error is likely caused by a bug in React. Please file an issue."
11580          );
11581        switch (hostParentFiber.tag) {
11582          case 27:
11583            hostParentFiber = hostParentFiber.stateNode;
11584            parentFiber = getHostSibling(finishedWork);
11585            insertOrAppendPlacementNode(
11586              finishedWork,
11587              parentFiber,
11588              hostParentFiber
11589            );
11590            break;
11591          case 5:
11592            parentFiber = hostParentFiber.stateNode;
11593            hostParentFiber.flags & 32 && (resetTextContent(parentFiber), hostParentFiber.flags &= -33);
11594            hostParentFiber = getHostSibling(finishedWork);
11595            insertOrAppendPlacementNode(
11596              finishedWork,
11597              hostParentFiber,
11598              parentFiber
11599            );
11600            break;
11601          case 3:
11602          case 4:
11603            hostParentFiber = hostParentFiber.stateNode.containerInfo;
11604            parentFiber = getHostSibling(finishedWork);
11605            insertOrAppendPlacementNodeIntoContainer(
11606              finishedWork,
11607              parentFiber,
11608              hostParentFiber
11609            );
11610            break;
11611          default:
11612            throw Error(
11613              "Invalid host parent fiber. This error is likely caused by a bug in React. Please file an issue."
11614            );
11615        }
11616      }
11617      function commitHostSingletonAcquisition(finishedWork) {
11618        var singleton = finishedWork.stateNode, props = finishedWork.memoizedProps;
11619        try {
11620          runWithFiberInDEV(
11621            finishedWork,
11622            acquireSingletonInstance,
11623            finishedWork.type,
11624            props,
11625            singleton,
11626            finishedWork
11627          );
11628        } catch (error2) {
11629          captureCommitPhaseError(finishedWork, finishedWork.return, error2);
11630        }
11631      }
11632      function isHydratingParent(current2, finishedWork) {
11633        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;
11634      }
11635      function commitBeforeMutationEffects(root3, firstChild) {
11636        root3 = root3.containerInfo;
11637        eventsEnabled = _enabled;
11638        root3 = getActiveElementDeep(root3);
11639        if (hasSelectionCapabilities(root3)) {
11640          if ("selectionStart" in root3)
11641            var JSCompiler_temp = {
11642              start: root3.selectionStart,
11643              end: root3.selectionEnd
11644            };
11645          else
11646            a: {
11647              JSCompiler_temp = (JSCompiler_temp = root3.ownerDocument) && JSCompiler_temp.defaultView || window;
11648              var selection = JSCompiler_temp.getSelection && JSCompiler_temp.getSelection();
11649              if (selection && 0 !== selection.rangeCount) {
11650                JSCompiler_temp = selection.anchorNode;
11651                var anchorOffset = selection.anchorOffset, focusNode = selection.focusNode;
11652                selection = selection.focusOffset;
11653                try {
11654                  JSCompiler_temp.nodeType, focusNode.nodeType;
11655                } catch (e$2) {
11656                  JSCompiler_temp = null;
11657                  break a;
11658                }
11659                var length = 0, start2 = -1, end = -1, indexWithinAnchor = 0, indexWithinFocus = 0, node = root3, parentNode = null;
11660                b: for (; ; ) {
11661                  for (var next; ; ) {
11662                    node !== JSCompiler_temp || 0 !== anchorOffset && 3 !== node.nodeType || (start2 = length + anchorOffset);
11663                    node !== focusNode || 0 !== selection && 3 !== node.nodeType || (end = length + selection);
11664                    3 === node.nodeType && (length += node.nodeValue.length);
11665                    if (null === (next = node.firstChild)) break;
11666                    parentNode = node;
11667                    node = next;
11668                  }
11669                  for (; ; ) {
11670                    if (node === root3) break b;
11671                    parentNode === JSCompiler_temp && ++indexWithinAnchor === anchorOffset && (start2 = length);
11672                    parentNode === focusNode && ++indexWithinFocus === selection && (end = length);
11673                    if (null !== (next = node.nextSibling)) break;
11674                    node = parentNode;
11675                    parentNode = node.parentNode;
11676                  }
11677                  node = next;
11678                }
11679                JSCompiler_temp = -1 === start2 || -1 === end ? null : { start: start2, end };
11680              } else JSCompiler_temp = null;
11681            }
11682          JSCompiler_temp = JSCompiler_temp || { start: 0, end: 0 };
11683        } else JSCompiler_temp = null;
11684        selectionInformation = {
11685          focusedElem: root3,
11686          selectionRange: JSCompiler_temp
11687        };
11688        _enabled = false;
11689        for (nextEffect = firstChild; null !== nextEffect; )
11690          if (firstChild = nextEffect, root3 = firstChild.child, 0 !== (firstChild.subtreeFlags & 1028) && null !== root3)
11691            root3.return = firstChild, nextEffect = root3;
11692          else
11693            for (; null !== nextEffect; ) {
11694              root3 = firstChild = nextEffect;
11695              JSCompiler_temp = root3.alternate;
11696              anchorOffset = root3.flags;
11697              switch (root3.tag) {
11698                case 0:
11699                  if (0 !== (anchorOffset & 4) && (root3 = root3.updateQueue, root3 = null !== root3 ? root3.events : null, null !== root3))
11700                    for (JSCompiler_temp = 0; JSCompiler_temp < root3.length; JSCompiler_temp++)
11701                      anchorOffset = root3[JSCompiler_temp], anchorOffset.ref.impl = anchorOffset.nextImpl;
11702                  break;
11703                case 11:
11704                case 15:
11705                  break;
11706                case 1:
11707                  0 !== (anchorOffset & 1024) && null !== JSCompiler_temp && commitClassSnapshot(root3, JSCompiler_temp);
11708                  break;
11709                case 3:
11710                  if (0 !== (anchorOffset & 1024)) {
11711                    if (root3 = root3.stateNode.containerInfo, JSCompiler_temp = root3.nodeType, 9 === JSCompiler_temp)
11712                      clearContainerSparingly(root3);
11713                    else if (1 === JSCompiler_temp)
11714                      switch (root3.nodeName) {
11715                        case "HEAD":
11716                        case "HTML":
11717                        case "BODY":
11718                          clearContainerSparingly(root3);
11719                          break;
11720                        default:
11721                          root3.textContent = "";
11722                      }
11723                  }
11724                  break;
11725                case 5:
11726                case 26:
11727                case 27:
11728                case 6:
11729                case 4:
11730                case 17:
11731                  break;
11732                default:
11733                  if (0 !== (anchorOffset & 1024))
11734                    throw Error(
11735                      "This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue."
11736                    );
11737              }
11738              root3 = firstChild.sibling;
11739              if (null !== root3) {
11740                root3.return = firstChild.return;
11741                nextEffect = root3;
11742                break;
11743              }
11744              nextEffect = firstChild.return;
11745            }
11746      }
11747      function commitLayoutEffectOnFiber(finishedRoot, current2, finishedWork) {
11748        var prevEffectStart = pushComponentEffectStart(), prevEffectDuration = pushComponentEffectDuration(), prevEffectErrors = pushComponentEffectErrors(), prevEffectDidSpawnUpdate = pushComponentEffectDidSpawnUpdate(), flags = finishedWork.flags;
11749        switch (finishedWork.tag) {
11750          case 0:
11751          case 11:
11752          case 15:
11753            recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
11754            flags & 4 && commitHookLayoutEffects(finishedWork, Layout | HasEffect);
11755            break;
11756          case 1:
11757            recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
11758            if (flags & 4)
11759              if (finishedRoot = finishedWork.stateNode, null === current2)
11760                finishedWork.type.defaultProps || "ref" in finishedWork.memoizedProps || didWarnAboutReassigningProps || (finishedRoot.props !== finishedWork.memoizedProps && console.error(
11761                  "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.",
11762                  getComponentNameFromFiber(finishedWork) || "instance"
11763                ), finishedRoot.state !== finishedWork.memoizedState && console.error(
11764                  "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.",
11765                  getComponentNameFromFiber(finishedWork) || "instance"
11766                )), shouldProfile(finishedWork) ? (startEffectTimer(), runWithFiberInDEV(
11767                  finishedWork,
11768                  callComponentDidMountInDEV,
11769                  finishedWork,
11770                  finishedRoot
11771                ), recordEffectDuration()) : runWithFiberInDEV(
11772                  finishedWork,
11773                  callComponentDidMountInDEV,
11774                  finishedWork,
11775                  finishedRoot
11776                );
11777              else {
11778                var prevProps = resolveClassComponentProps(
11779                  finishedWork.type,
11780                  current2.memoizedProps
11781                );
11782                current2 = current2.memoizedState;
11783                finishedWork.type.defaultProps || "ref" in finishedWork.memoizedProps || didWarnAboutReassigningProps || (finishedRoot.props !== finishedWork.memoizedProps && console.error(
11784                  "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.",
11785                  getComponentNameFromFiber(finishedWork) || "instance"
11786                ), finishedRoot.state !== finishedWork.memoizedState && console.error(
11787                  "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.",
11788                  getComponentNameFromFiber(finishedWork) || "instance"
11789                ));
11790                shouldProfile(finishedWork) ? (startEffectTimer(), runWithFiberInDEV(
11791                  finishedWork,
11792                  callComponentDidUpdateInDEV,
11793                  finishedWork,
11794                  finishedRoot,
11795                  prevProps,
11796                  current2,
11797                  finishedRoot.__reactInternalSnapshotBeforeUpdate
11798                ), recordEffectDuration()) : runWithFiberInDEV(
11799                  finishedWork,
11800                  callComponentDidUpdateInDEV,
11801                  finishedWork,
11802                  finishedRoot,
11803                  prevProps,
11804                  current2,
11805                  finishedRoot.__reactInternalSnapshotBeforeUpdate
11806                );
11807              }
11808            flags & 64 && commitClassCallbacks(finishedWork);
11809            flags & 512 && safelyAttachRef(finishedWork, finishedWork.return);
11810            break;
11811          case 3:
11812            current2 = pushNestedEffectDurations();
11813            recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
11814            if (flags & 64 && (flags = finishedWork.updateQueue, null !== flags)) {
11815              prevProps = null;
11816              if (null !== finishedWork.child)
11817                switch (finishedWork.child.tag) {
11818                  case 27:
11819                  case 5:
11820                    prevProps = finishedWork.child.stateNode;
11821                    break;
11822                  case 1:
11823                    prevProps = finishedWork.child.stateNode;
11824                }
11825              try {
11826                runWithFiberInDEV(
11827                  finishedWork,
11828                  commitCallbacks,
11829                  flags,
11830                  prevProps
11831                );
11832              } catch (error2) {
11833                captureCommitPhaseError(finishedWork, finishedWork.return, error2);
11834              }
11835            }
11836            finishedRoot.effectDuration += popNestedEffectDurations(current2);
11837            break;
11838          case 27:
11839            null === current2 && flags & 4 && commitHostSingletonAcquisition(finishedWork);
11840          case 26:
11841          case 5:
11842            recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
11843            if (null === current2) {
11844              if (flags & 4) commitHostMount(finishedWork);
11845              else if (flags & 64) {
11846                finishedRoot = finishedWork.type;
11847                current2 = finishedWork.memoizedProps;
11848                prevProps = finishedWork.stateNode;
11849                try {
11850                  runWithFiberInDEV(
11851                    finishedWork,
11852                    commitHydratedInstance,
11853                    prevProps,
11854                    finishedRoot,
11855                    current2,
11856                    finishedWork
11857                  );
11858                } catch (error2) {
11859                  captureCommitPhaseError(
11860                    finishedWork,
11861                    finishedWork.return,
11862                    error2
11863                  );
11864                }
11865              }
11866            }
11867            flags & 512 && safelyAttachRef(finishedWork, finishedWork.return);
11868            break;
11869          case 12:
11870            if (flags & 4) {
11871              flags = pushNestedEffectDurations();
11872              recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
11873              finishedRoot = finishedWork.stateNode;
11874              finishedRoot.effectDuration += bubbleNestedEffectDurations(flags);
11875              try {
11876                runWithFiberInDEV(
11877                  finishedWork,
11878                  commitProfiler,
11879                  finishedWork,
11880                  current2,
11881                  commitStartTime,
11882                  finishedRoot.effectDuration
11883                );
11884              } catch (error2) {
11885                captureCommitPhaseError(finishedWork, finishedWork.return, error2);
11886              }
11887            } else recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
11888            break;
11889          case 31:
11890            recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
11891            flags & 4 && commitActivityHydrationCallbacks(finishedRoot, finishedWork);
11892            break;
11893          case 13:
11894            recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
11895            flags & 4 && commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
11896            flags & 64 && (finishedRoot = finishedWork.memoizedState, null !== finishedRoot && (finishedRoot = finishedRoot.dehydrated, null !== finishedRoot && (flags = retryDehydratedSuspenseBoundary.bind(
11897              null,
11898              finishedWork
11899            ), registerSuspenseInstanceRetry(finishedRoot, flags))));
11900            break;
11901          case 22:
11902            flags = null !== finishedWork.memoizedState || offscreenSubtreeIsHidden;
11903            if (!flags) {
11904              current2 = null !== current2 && null !== current2.memoizedState || offscreenSubtreeWasHidden;
11905              prevProps = offscreenSubtreeIsHidden;
11906              var prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
11907              offscreenSubtreeIsHidden = flags;
11908              (offscreenSubtreeWasHidden = current2) && !prevOffscreenSubtreeWasHidden ? (recursivelyTraverseReappearLayoutEffects(
11909                finishedRoot,
11910                finishedWork,
11911                0 !== (finishedWork.subtreeFlags & 8772)
11912              ), (finishedWork.mode & ProfileMode) !== NoMode && 0 <= componentEffectStartTime && 0 <= componentEffectEndTime && 0.05 < componentEffectEndTime - componentEffectStartTime && logComponentReappeared(
11913                finishedWork,
11914                componentEffectStartTime,
11915                componentEffectEndTime
11916              )) : recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
11917              offscreenSubtreeIsHidden = prevProps;
11918              offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
11919            }
11920            break;
11921          case 30:
11922            break;
11923          default:
11924            recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
11925        }
11926        (finishedWork.mode & ProfileMode) !== NoMode && 0 <= componentEffectStartTime && 0 <= componentEffectEndTime && ((componentEffectSpawnedUpdate || 0.05 < componentEffectDuration) && logComponentEffect(
11927          finishedWork,
11928          componentEffectStartTime,
11929          componentEffectEndTime,
11930          componentEffectDuration,
11931          componentEffectErrors
11932        ), null === finishedWork.alternate && null !== finishedWork.return && null !== finishedWork.return.alternate && 0.05 < componentEffectEndTime - componentEffectStartTime && (isHydratingParent(
11933          finishedWork.return.alternate,
11934          finishedWork.return
11935        ) || logComponentTrigger(
11936          finishedWork,
11937          componentEffectStartTime,
11938          componentEffectEndTime,
11939          "Mount"
11940        )));
11941        popComponentEffectStart(prevEffectStart);
11942        popComponentEffectDuration(prevEffectDuration);
11943        componentEffectErrors = prevEffectErrors;
11944        componentEffectSpawnedUpdate = prevEffectDidSpawnUpdate;
11945      }
11946      function detachFiberAfterEffects(fiber) {
11947        var alternate = fiber.alternate;
11948        null !== alternate && (fiber.alternate = null, detachFiberAfterEffects(alternate));
11949        fiber.child = null;
11950        fiber.deletions = null;
11951        fiber.sibling = null;
11952        5 === fiber.tag && (alternate = fiber.stateNode, null !== alternate && detachDeletedInstance(alternate));
11953        fiber.stateNode = null;
11954        fiber._debugOwner = null;
11955        fiber.return = null;
11956        fiber.dependencies = null;
11957        fiber.memoizedProps = null;
11958        fiber.memoizedState = null;
11959        fiber.pendingProps = null;
11960        fiber.stateNode = null;
11961        fiber.updateQueue = null;
11962      }
11963      function recursivelyTraverseDeletionEffects(finishedRoot, nearestMountedAncestor, parent) {
11964        for (parent = parent.child; null !== parent; )
11965          commitDeletionEffectsOnFiber(
11966            finishedRoot,
11967            nearestMountedAncestor,
11968            parent
11969          ), parent = parent.sibling;
11970      }
11971      function commitDeletionEffectsOnFiber(finishedRoot, nearestMountedAncestor, deletedFiber) {
11972        if (injectedHook && "function" === typeof injectedHook.onCommitFiberUnmount)
11973          try {
11974            injectedHook.onCommitFiberUnmount(rendererID, deletedFiber);
11975          } catch (err) {
11976            hasLoggedError || (hasLoggedError = true, console.error(
11977              "React instrumentation encountered an error: %o",
11978              err
11979            ));
11980          }
11981        var prevEffectStart = pushComponentEffectStart(), prevEffectDuration = pushComponentEffectDuration(), prevEffectErrors = pushComponentEffectErrors(), prevEffectDidSpawnUpdate = pushComponentEffectDidSpawnUpdate();
11982        switch (deletedFiber.tag) {
11983          case 26:
11984            offscreenSubtreeWasHidden || safelyDetachRef(deletedFiber, nearestMountedAncestor);
11985            recursivelyTraverseDeletionEffects(
11986              finishedRoot,
11987              nearestMountedAncestor,
11988              deletedFiber
11989            );
11990            deletedFiber.memoizedState ? deletedFiber.memoizedState.count-- : deletedFiber.stateNode && (finishedRoot = deletedFiber.stateNode, finishedRoot.parentNode.removeChild(finishedRoot));
11991            break;
11992          case 27:
11993            offscreenSubtreeWasHidden || safelyDetachRef(deletedFiber, nearestMountedAncestor);
11994            var prevHostParent = hostParent, prevHostParentIsContainer = hostParentIsContainer;
11995            isSingletonScope(deletedFiber.type) && (hostParent = deletedFiber.stateNode, hostParentIsContainer = false);
11996            recursivelyTraverseDeletionEffects(
11997              finishedRoot,
11998              nearestMountedAncestor,
11999              deletedFiber
12000            );
12001            runWithFiberInDEV(
12002              deletedFiber,
12003              releaseSingletonInstance,
12004              deletedFiber.stateNode
12005            );
12006            hostParent = prevHostParent;
12007            hostParentIsContainer = prevHostParentIsContainer;
12008            break;
12009          case 5:
12010            offscreenSubtreeWasHidden || safelyDetachRef(deletedFiber, nearestMountedAncestor);
12011          case 6:
12012            prevHostParent = hostParent;
12013            prevHostParentIsContainer = hostParentIsContainer;
12014            hostParent = null;
12015            recursivelyTraverseDeletionEffects(
12016              finishedRoot,
12017              nearestMountedAncestor,
12018              deletedFiber
12019            );
12020            hostParent = prevHostParent;
12021            hostParentIsContainer = prevHostParentIsContainer;
12022            if (null !== hostParent)
12023              if (hostParentIsContainer)
12024                try {
12025                  runWithFiberInDEV(
12026                    deletedFiber,
12027                    removeChildFromContainer,
12028                    hostParent,
12029                    deletedFiber.stateNode
12030                  );
12031                } catch (error2) {
12032                  captureCommitPhaseError(
12033                    deletedFiber,
12034                    nearestMountedAncestor,
12035                    error2
12036                  );
12037                }
12038              else
12039                try {
12040                  runWithFiberInDEV(
12041                    deletedFiber,
12042                    removeChild,
12043                    hostParent,
12044                    deletedFiber.stateNode
12045                  );
12046                } catch (error2) {
12047                  captureCommitPhaseError(
12048                    deletedFiber,
12049                    nearestMountedAncestor,
12050                    error2
12051                  );
12052                }
12053            break;
12054          case 18:
12055            null !== hostParent && (hostParentIsContainer ? (finishedRoot = hostParent, clearHydrationBoundary(
12056              9 === finishedRoot.nodeType ? finishedRoot.body : "HTML" === finishedRoot.nodeName ? finishedRoot.ownerDocument.body : finishedRoot,
12057              deletedFiber.stateNode
12058            ), retryIfBlockedOn(finishedRoot)) : clearHydrationBoundary(hostParent, deletedFiber.stateNode));
12059            break;
12060          case 4:
12061            prevHostParent = hostParent;
12062            prevHostParentIsContainer = hostParentIsContainer;
12063            hostParent = deletedFiber.stateNode.containerInfo;
12064            hostParentIsContainer = true;
12065            recursivelyTraverseDeletionEffects(
12066              finishedRoot,
12067              nearestMountedAncestor,
12068              deletedFiber
12069            );
12070            hostParent = prevHostParent;
12071            hostParentIsContainer = prevHostParentIsContainer;
12072            break;
12073          case 0:
12074          case 11:
12075          case 14:
12076          case 15:
12077            commitHookEffectListUnmount(
12078              Insertion,
12079              deletedFiber,
12080              nearestMountedAncestor
12081            );
12082            offscreenSubtreeWasHidden || commitHookLayoutUnmountEffects(
12083              deletedFiber,
12084              nearestMountedAncestor,
12085              Layout
12086            );
12087            recursivelyTraverseDeletionEffects(
12088              finishedRoot,
12089              nearestMountedAncestor,
12090              deletedFiber
12091            );
12092            break;
12093          case 1:
12094            offscreenSubtreeWasHidden || (safelyDetachRef(deletedFiber, nearestMountedAncestor), prevHostParent = deletedFiber.stateNode, "function" === typeof prevHostParent.componentWillUnmount && safelyCallComponentWillUnmount(
12095              deletedFiber,
12096              nearestMountedAncestor,
12097              prevHostParent
12098            ));
12099            recursivelyTraverseDeletionEffects(
12100              finishedRoot,
12101              nearestMountedAncestor,
12102              deletedFiber
12103            );
12104            break;
12105          case 21:
12106            recursivelyTraverseDeletionEffects(
12107              finishedRoot,
12108              nearestMountedAncestor,
12109              deletedFiber
12110            );
12111            break;
12112          case 22:
12113            offscreenSubtreeWasHidden = (prevHostParent = offscreenSubtreeWasHidden) || null !== deletedFiber.memoizedState;
12114            recursivelyTraverseDeletionEffects(
12115              finishedRoot,
12116              nearestMountedAncestor,
12117              deletedFiber
12118            );
12119            offscreenSubtreeWasHidden = prevHostParent;
12120            break;
12121          default:
12122            recursivelyTraverseDeletionEffects(
12123              finishedRoot,
12124              nearestMountedAncestor,
12125              deletedFiber
12126            );
12127        }
12128        (deletedFiber.mode & ProfileMode) !== NoMode && 0 <= componentEffectStartTime && 0 <= componentEffectEndTime && (componentEffectSpawnedUpdate || 0.05 < componentEffectDuration) && logComponentEffect(
12129          deletedFiber,
12130          componentEffectStartTime,
12131          componentEffectEndTime,
12132          componentEffectDuration,
12133          componentEffectErrors
12134        );
12135        popComponentEffectStart(prevEffectStart);
12136        popComponentEffectDuration(prevEffectDuration);
12137        componentEffectErrors = prevEffectErrors;
12138        componentEffectSpawnedUpdate = prevEffectDidSpawnUpdate;
12139      }
12140      function commitActivityHydrationCallbacks(finishedRoot, finishedWork) {
12141        if (null === finishedWork.memoizedState && (finishedRoot = finishedWork.alternate, null !== finishedRoot && (finishedRoot = finishedRoot.memoizedState, null !== finishedRoot))) {
12142          finishedRoot = finishedRoot.dehydrated;
12143          try {
12144            runWithFiberInDEV(
12145              finishedWork,
12146              commitHydratedActivityInstance,
12147              finishedRoot
12148            );
12149          } catch (error2) {
12150            captureCommitPhaseError(finishedWork, finishedWork.return, error2);
12151          }
12152        }
12153      }
12154      function commitSuspenseHydrationCallbacks(finishedRoot, finishedWork) {
12155        if (null === finishedWork.memoizedState && (finishedRoot = finishedWork.alternate, null !== finishedRoot && (finishedRoot = finishedRoot.memoizedState, null !== finishedRoot && (finishedRoot = finishedRoot.dehydrated, null !== finishedRoot))))
12156          try {
12157            runWithFiberInDEV(
12158              finishedWork,
12159              commitHydratedSuspenseInstance,
12160              finishedRoot
12161            );
12162          } catch (error2) {
12163            captureCommitPhaseError(finishedWork, finishedWork.return, error2);
12164          }
12165      }
12166      function getRetryCache(finishedWork) {
12167        switch (finishedWork.tag) {
12168          case 31:
12169          case 13:
12170          case 19:
12171            var retryCache = finishedWork.stateNode;
12172            null === retryCache && (retryCache = finishedWork.stateNode = new PossiblyWeakSet());
12173            return retryCache;
12174          case 22:
12175            return finishedWork = finishedWork.stateNode, retryCache = finishedWork._retryCache, null === retryCache && (retryCache = finishedWork._retryCache = new PossiblyWeakSet()), retryCache;
12176          default:
12177            throw Error(
12178              "Unexpected Suspense handler tag (" + finishedWork.tag + "). This is a bug in React."
12179            );
12180        }
12181      }
12182      function attachSuspenseRetryListeners(finishedWork, wakeables) {
12183        var retryCache = getRetryCache(finishedWork);
12184        wakeables.forEach(function(wakeable) {
12185          if (!retryCache.has(wakeable)) {
12186            retryCache.add(wakeable);
12187            if (isDevToolsPresent)
12188              if (null !== inProgressLanes && null !== inProgressRoot)
12189                restorePendingUpdaters(inProgressRoot, inProgressLanes);
12190              else
12191                throw Error(
12192                  "Expected finished root and lanes to be set. This is a bug in React."
12193                );
12194            var retry = resolveRetryWakeable.bind(null, finishedWork, wakeable);
12195            wakeable.then(retry, retry);
12196          }
12197        });
12198      }
12199      function recursivelyTraverseMutationEffects(root$jscomp$0, parentFiber) {
12200        var deletions = parentFiber.deletions;
12201        if (null !== deletions)
12202          for (var i3 = 0; i3 < deletions.length; i3++) {
12203            var root3 = root$jscomp$0, returnFiber = parentFiber, deletedFiber = deletions[i3], prevEffectStart = pushComponentEffectStart(), parent = returnFiber;
12204            a: for (; null !== parent; ) {
12205              switch (parent.tag) {
12206                case 27:
12207                  if (isSingletonScope(parent.type)) {
12208                    hostParent = parent.stateNode;
12209                    hostParentIsContainer = false;
12210                    break a;
12211                  }
12212                  break;
12213                case 5:
12214                  hostParent = parent.stateNode;
12215                  hostParentIsContainer = false;
12216                  break a;
12217                case 3:
12218                case 4:
12219                  hostParent = parent.stateNode.containerInfo;
12220                  hostParentIsContainer = true;
12221                  break a;
12222              }
12223              parent = parent.return;
12224            }
12225            if (null === hostParent)
12226              throw Error(
12227                "Expected to find a host parent. This error is likely caused by a bug in React. Please file an issue."
12228              );
12229            commitDeletionEffectsOnFiber(root3, returnFiber, deletedFiber);
12230            hostParent = null;
12231            hostParentIsContainer = false;
12232            (deletedFiber.mode & ProfileMode) !== NoMode && 0 <= componentEffectStartTime && 0 <= componentEffectEndTime && 0.05 < componentEffectEndTime - componentEffectStartTime && logComponentTrigger(
12233              deletedFiber,
12234              componentEffectStartTime,
12235              componentEffectEndTime,
12236              "Unmount"
12237            );
12238            popComponentEffectStart(prevEffectStart);
12239            root3 = deletedFiber;
12240            returnFiber = root3.alternate;
12241            null !== returnFiber && (returnFiber.return = null);
12242            root3.return = null;
12243          }
12244        if (parentFiber.subtreeFlags & 13886)
12245          for (parentFiber = parentFiber.child; null !== parentFiber; )
12246            commitMutationEffectsOnFiber(parentFiber, root$jscomp$0), parentFiber = parentFiber.sibling;
12247      }
12248      function commitMutationEffectsOnFiber(finishedWork, root3) {
12249        var prevEffectStart = pushComponentEffectStart(), prevEffectDuration = pushComponentEffectDuration(), prevEffectErrors = pushComponentEffectErrors(), prevEffectDidSpawnUpdate = pushComponentEffectDidSpawnUpdate(), current2 = finishedWork.alternate, flags = finishedWork.flags;
12250        switch (finishedWork.tag) {
12251          case 0:
12252          case 11:
12253          case 14:
12254          case 15:
12255            recursivelyTraverseMutationEffects(root3, finishedWork);
12256            commitReconciliationEffects(finishedWork);
12257            flags & 4 && (commitHookEffectListUnmount(
12258              Insertion | HasEffect,
12259              finishedWork,
12260              finishedWork.return
12261            ), commitHookEffectListMount(Insertion | HasEffect, finishedWork), commitHookLayoutUnmountEffects(
12262              finishedWork,
12263              finishedWork.return,
12264              Layout | HasEffect
12265            ));
12266            break;
12267          case 1:
12268            recursivelyTraverseMutationEffects(root3, finishedWork);
12269            commitReconciliationEffects(finishedWork);
12270            flags & 512 && (offscreenSubtreeWasHidden || null === current2 || safelyDetachRef(current2, current2.return));
12271            if (flags & 64 && offscreenSubtreeIsHidden && (flags = finishedWork.updateQueue, null !== flags && (current2 = flags.callbacks, null !== current2))) {
12272              var existingHiddenCallbacks = flags.shared.hiddenCallbacks;
12273              flags.shared.hiddenCallbacks = null === existingHiddenCallbacks ? current2 : existingHiddenCallbacks.concat(current2);
12274            }
12275            break;
12276          case 26:
12277            existingHiddenCallbacks = currentHoistableRoot;
12278            recursivelyTraverseMutationEffects(root3, finishedWork);
12279            commitReconciliationEffects(finishedWork);
12280            flags & 512 && (offscreenSubtreeWasHidden || null === current2 || safelyDetachRef(current2, current2.return));
12281            if (flags & 4) {
12282              var currentResource = null !== current2 ? current2.memoizedState : null;
12283              flags = finishedWork.memoizedState;
12284              if (null === current2)
12285                if (null === flags)
12286                  if (null === finishedWork.stateNode) {
12287                    a: {
12288                      flags = finishedWork.type;
12289                      current2 = finishedWork.memoizedProps;
12290                      existingHiddenCallbacks = existingHiddenCallbacks.ownerDocument || existingHiddenCallbacks;
12291                      b: switch (flags) {
12292                        case "title":
12293                          currentResource = existingHiddenCallbacks.getElementsByTagName(
12294                            "title"
12295                          )[0];
12296                          if (!currentResource || currentResource[internalHoistableMarker] || currentResource[internalInstanceKey] || currentResource.namespaceURI === SVG_NAMESPACE || currentResource.hasAttribute("itemprop"))
12297                            currentResource = existingHiddenCallbacks.createElement(flags), existingHiddenCallbacks.head.insertBefore(
12298                              currentResource,
12299                              existingHiddenCallbacks.querySelector(
12300                                "head > title"
12301                              )
12302                            );
12303                          setInitialProperties(currentResource, flags, current2);
12304                          currentResource[internalInstanceKey] = finishedWork;
12305                          markNodeAsHoistable(currentResource);
12306                          flags = currentResource;
12307                          break a;
12308                        case "link":
12309                          var maybeNodes = getHydratableHoistableCache(
12310                            "link",
12311                            "href",
12312                            existingHiddenCallbacks
12313                          ).get(flags + (current2.href || ""));
12314                          if (maybeNodes) {
12315                            for (var i3 = 0; i3 < maybeNodes.length; i3++)
12316                              if (currentResource = maybeNodes[i3], 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)) {
12317                                maybeNodes.splice(i3, 1);
12318                                break b;
12319                              }
12320                          }
12321                          currentResource = existingHiddenCallbacks.createElement(flags);
12322                          setInitialProperties(currentResource, flags, current2);
12323                          existingHiddenCallbacks.head.appendChild(
12324                            currentResource
12325                          );
12326                          break;
12327                        case "meta":
12328                          if (maybeNodes = getHydratableHoistableCache(
12329                            "meta",
12330                            "content",
12331                            existingHiddenCallbacks
12332                          ).get(flags + (current2.content || ""))) {
12333                            for (i3 = 0; i3 < maybeNodes.length; i3++)
12334                              if (currentResource = maybeNodes[i3], checkAttributeStringCoercion(
12335                                current2.content,
12336                                "content"
12337                              ), 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)) {
12338                                maybeNodes.splice(i3, 1);
12339                                break b;
12340                              }
12341                          }
12342                          currentResource = existingHiddenCallbacks.createElement(flags);
12343                          setInitialProperties(currentResource, flags, current2);
12344                          existingHiddenCallbacks.head.appendChild(
12345                            currentResource
12346                          );
12347                          break;
12348                        default:
12349                          throw Error(
12350                            'getNodesForType encountered a type it did not expect: "' + flags + '". This is a bug in React.'
12351                          );
12352                      }
12353                      currentResource[internalInstanceKey] = finishedWork;
12354                      markNodeAsHoistable(currentResource);
12355                      flags = currentResource;
12356                    }
12357                    finishedWork.stateNode = flags;
12358                  } else
12359                    mountHoistable(
12360                      existingHiddenCallbacks,
12361                      finishedWork.type,
12362                      finishedWork.stateNode
12363                    );
12364                else
12365                  finishedWork.stateNode = acquireResource(
12366                    existingHiddenCallbacks,
12367                    flags,
12368                    finishedWork.memoizedProps
12369                  );
12370              else
12371                currentResource !== flags ? (null === currentResource ? null !== current2.stateNode && (current2 = current2.stateNode, current2.parentNode.removeChild(current2)) : currentResource.count--, null === flags ? mountHoistable(
12372                  existingHiddenCallbacks,
12373                  finishedWork.type,
12374                  finishedWork.stateNode
12375                ) : acquireResource(
12376                  existingHiddenCallbacks,
12377                  flags,
12378                  finishedWork.memoizedProps
12379                )) : null === flags && null !== finishedWork.stateNode && commitHostUpdate(
12380                  finishedWork,
12381                  finishedWork.memoizedProps,
12382                  current2.memoizedProps
12383                );
12384            }
12385            break;
12386          case 27:
12387            recursivelyTraverseMutationEffects(root3, finishedWork);
12388            commitReconciliationEffects(finishedWork);
12389            flags & 512 && (offscreenSubtreeWasHidden || null === current2 || safelyDetachRef(current2, current2.return));
12390            null !== current2 && flags & 4 && commitHostUpdate(
12391              finishedWork,
12392              finishedWork.memoizedProps,
12393              current2.memoizedProps
12394            );
12395            break;
12396          case 5:
12397            recursivelyTraverseMutationEffects(root3, finishedWork);
12398            commitReconciliationEffects(finishedWork);
12399            flags & 512 && (offscreenSubtreeWasHidden || null === current2 || safelyDetachRef(current2, current2.return));
12400            if (finishedWork.flags & 32) {
12401              existingHiddenCallbacks = finishedWork.stateNode;
12402              try {
12403                runWithFiberInDEV(
12404                  finishedWork,
12405                  resetTextContent,
12406                  existingHiddenCallbacks
12407                );
12408              } catch (error2) {
12409                captureCommitPhaseError(finishedWork, finishedWork.return, error2);
12410              }
12411            }
12412            flags & 4 && null != finishedWork.stateNode && (existingHiddenCallbacks = finishedWork.memoizedProps, commitHostUpdate(
12413              finishedWork,
12414              existingHiddenCallbacks,
12415              null !== current2 ? current2.memoizedProps : existingHiddenCallbacks
12416            ));
12417            flags & 1024 && (needsFormReset = true, "form" !== finishedWork.type && console.error(
12418              "Unexpected host component type. Expected a form. This is a bug in React."
12419            ));
12420            break;
12421          case 6:
12422            recursivelyTraverseMutationEffects(root3, finishedWork);
12423            commitReconciliationEffects(finishedWork);
12424            if (flags & 4) {
12425              if (null === finishedWork.stateNode)
12426                throw Error(
12427                  "This should have a text node initialized. This error is likely caused by a bug in React. Please file an issue."
12428                );
12429              flags = finishedWork.memoizedProps;
12430              current2 = null !== current2 ? current2.memoizedProps : flags;
12431              existingHiddenCallbacks = finishedWork.stateNode;
12432              try {
12433                runWithFiberInDEV(
12434                  finishedWork,
12435                  commitTextUpdate,
12436                  existingHiddenCallbacks,
12437                  current2,
12438                  flags
12439                );
12440              } catch (error2) {
12441                captureCommitPhaseError(finishedWork, finishedWork.return, error2);
12442              }
12443            }
12444            break;
12445          case 3:
12446            existingHiddenCallbacks = pushNestedEffectDurations();
12447            tagCaches = null;
12448            currentResource = currentHoistableRoot;
12449            currentHoistableRoot = getHoistableRoot(root3.containerInfo);
12450            recursivelyTraverseMutationEffects(root3, finishedWork);
12451            currentHoistableRoot = currentResource;
12452            commitReconciliationEffects(finishedWork);
12453            if (flags & 4 && null !== current2 && current2.memoizedState.isDehydrated)
12454              try {
12455                runWithFiberInDEV(
12456                  finishedWork,
12457                  commitHydratedContainer,
12458                  root3.containerInfo
12459                );
12460              } catch (error2) {
12461                captureCommitPhaseError(finishedWork, finishedWork.return, error2);
12462              }
12463            needsFormReset && (needsFormReset = false, recursivelyResetForms(finishedWork));
12464            root3.effectDuration += popNestedEffectDurations(
12465              existingHiddenCallbacks
12466            );
12467            break;
12468          case 4:
12469            flags = currentHoistableRoot;
12470            currentHoistableRoot = getHoistableRoot(
12471              finishedWork.stateNode.containerInfo
12472            );
12473            recursivelyTraverseMutationEffects(root3, finishedWork);
12474            commitReconciliationEffects(finishedWork);
12475            currentHoistableRoot = flags;
12476            break;
12477          case 12:
12478            flags = pushNestedEffectDurations();
12479            recursivelyTraverseMutationEffects(root3, finishedWork);
12480            commitReconciliationEffects(finishedWork);
12481            finishedWork.stateNode.effectDuration += bubbleNestedEffectDurations(flags);
12482            break;
12483          case 31:
12484            recursivelyTraverseMutationEffects(root3, finishedWork);
12485            commitReconciliationEffects(finishedWork);
12486            flags & 4 && (flags = finishedWork.updateQueue, null !== flags && (finishedWork.updateQueue = null, attachSuspenseRetryListeners(finishedWork, flags)));
12487            break;
12488          case 13:
12489            recursivelyTraverseMutationEffects(root3, finishedWork);
12490            commitReconciliationEffects(finishedWork);
12491            finishedWork.child.flags & 8192 && null !== finishedWork.memoizedState !== (null !== current2 && null !== current2.memoizedState) && (globalMostRecentFallbackTime = now$1());
12492            flags & 4 && (flags = finishedWork.updateQueue, null !== flags && (finishedWork.updateQueue = null, attachSuspenseRetryListeners(finishedWork, flags)));
12493            break;
12494          case 22:
12495            existingHiddenCallbacks = null !== finishedWork.memoizedState;
12496            var wasHidden = null !== current2 && null !== current2.memoizedState, prevOffscreenSubtreeIsHidden = offscreenSubtreeIsHidden, prevOffscreenSubtreeWasHidden = offscreenSubtreeWasHidden;
12497            offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden || existingHiddenCallbacks;
12498            offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden || wasHidden;
12499            recursivelyTraverseMutationEffects(root3, finishedWork);
12500            offscreenSubtreeWasHidden = prevOffscreenSubtreeWasHidden;
12501            offscreenSubtreeIsHidden = prevOffscreenSubtreeIsHidden;
12502            wasHidden && !existingHiddenCallbacks && !prevOffscreenSubtreeIsHidden && !prevOffscreenSubtreeWasHidden && (finishedWork.mode & ProfileMode) !== NoMode && 0 <= componentEffectStartTime && 0 <= componentEffectEndTime && 0.05 < componentEffectEndTime - componentEffectStartTime && logComponentReappeared(
12503              finishedWork,
12504              componentEffectStartTime,
12505              componentEffectEndTime
12506            );
12507            commitReconciliationEffects(finishedWork);
12508            if (flags & 8192)
12509              a: for (root3 = finishedWork.stateNode, root3._visibility = existingHiddenCallbacks ? root3._visibility & ~OffscreenVisible : root3._visibility | OffscreenVisible, !existingHiddenCallbacks || null === current2 || wasHidden || offscreenSubtreeIsHidden || offscreenSubtreeWasHidden || (recursivelyTraverseDisappearLayoutEffects(finishedWork), (finishedWork.mode & ProfileMode) !== NoMode && 0 <= componentEffectStartTime && 0 <= componentEffectEndTime && 0.05 < componentEffectEndTime - componentEffectStartTime && logComponentTrigger(
12510                finishedWork,
12511                componentEffectStartTime,
12512                componentEffectEndTime,
12513                "Disconnect"
12514              )), current2 = null, root3 = finishedWork; ; ) {
12515                if (5 === root3.tag || 26 === root3.tag) {
12516                  if (null === current2) {
12517                    wasHidden = current2 = root3;
12518                    try {
12519                      currentResource = wasHidden.stateNode, existingHiddenCallbacks ? runWithFiberInDEV(
12520                        wasHidden,
12521                        hideInstance,
12522                        currentResource
12523                      ) : runWithFiberInDEV(
12524                        wasHidden,
12525                        unhideInstance,
12526                        wasHidden.stateNode,
12527                        wasHidden.memoizedProps
12528                      );
12529                    } catch (error2) {
12530                      captureCommitPhaseError(wasHidden, wasHidden.return, error2);
12531                    }
12532                  }
12533                } else if (6 === root3.tag) {
12534                  if (null === current2) {
12535                    wasHidden = root3;
12536                    try {
12537                      maybeNodes = wasHidden.stateNode, existingHiddenCallbacks ? runWithFiberInDEV(
12538                        wasHidden,
12539                        hideTextInstance,
12540                        maybeNodes
12541                      ) : runWithFiberInDEV(
12542                        wasHidden,
12543                        unhideTextInstance,
12544                        maybeNodes,
12545                        wasHidden.memoizedProps
12546                      );
12547                    } catch (error2) {
12548                      captureCommitPhaseError(wasHidden, wasHidden.return, error2);
12549                    }
12550                  }
12551                } else if (18 === root3.tag) {
12552                  if (null === current2) {
12553                    wasHidden = root3;
12554                    try {
12555                      i3 = wasHidden.stateNode, existingHiddenCallbacks ? runWithFiberInDEV(
12556                        wasHidden,
12557                        hideDehydratedBoundary,
12558                        i3
12559                      ) : runWithFiberInDEV(
12560                        wasHidden,
12561                        unhideDehydratedBoundary,
12562                        wasHidden.stateNode
12563                      );
12564                    } catch (error2) {
12565                      captureCommitPhaseError(wasHidden, wasHidden.return, error2);
12566                    }
12567                  }
12568                } else if ((22 !== root3.tag && 23 !== root3.tag || null === root3.memoizedState || root3 === finishedWork) && null !== root3.child) {
12569                  root3.child.return = root3;
12570                  root3 = root3.child;
12571                  continue;
12572                }
12573                if (root3 === finishedWork) break a;
12574                for (; null === root3.sibling; ) {
12575                  if (null === root3.return || root3.return === finishedWork)
12576                    break a;
12577                  current2 === root3 && (current2 = null);
12578                  root3 = root3.return;
12579                }
12580                current2 === root3 && (current2 = null);
12581                root3.sibling.return = root3.return;
12582                root3 = root3.sibling;
12583              }
12584            flags & 4 && (flags = finishedWork.updateQueue, null !== flags && (current2 = flags.retryQueue, null !== current2 && (flags.retryQueue = null, attachSuspenseRetryListeners(finishedWork, current2))));
12585            break;
12586          case 19:
12587            recursivelyTraverseMutationEffects(root3, finishedWork);
12588            commitReconciliationEffects(finishedWork);
12589            flags & 4 && (flags = finishedWork.updateQueue, null !== flags && (finishedWork.updateQueue = null, attachSuspenseRetryListeners(finishedWork, flags)));
12590            break;
12591          case 30:
12592            break;
12593          case 21:
12594            break;
12595          default:
12596            recursivelyTraverseMutationEffects(root3, finishedWork), commitReconciliationEffects(finishedWork);
12597        }
12598        (finishedWork.mode & ProfileMode) !== NoMode && 0 <= componentEffectStartTime && 0 <= componentEffectEndTime && ((componentEffectSpawnedUpdate || 0.05 < componentEffectDuration) && logComponentEffect(
12599          finishedWork,
12600          componentEffectStartTime,
12601          componentEffectEndTime,
12602          componentEffectDuration,
12603          componentEffectErrors
12604        ), null === finishedWork.alternate && null !== finishedWork.return && null !== finishedWork.return.alternate && 0.05 < componentEffectEndTime - componentEffectStartTime && (isHydratingParent(
12605          finishedWork.return.alternate,
12606          finishedWork.return
12607        ) || logComponentTrigger(
12608          finishedWork,
12609          componentEffectStartTime,
12610          componentEffectEndTime,
12611          "Mount"
12612        )));
12613        popComponentEffectStart(prevEffectStart);
12614        popComponentEffectDuration(prevEffectDuration);
12615        componentEffectErrors = prevEffectErrors;
12616        componentEffectSpawnedUpdate = prevEffectDidSpawnUpdate;
12617      }
12618      function commitReconciliationEffects(finishedWork) {
12619        var flags = finishedWork.flags;
12620        if (flags & 2) {
12621          try {
12622            runWithFiberInDEV(finishedWork, commitPlacement, finishedWork);
12623          } catch (error2) {
12624            captureCommitPhaseError(finishedWork, finishedWork.return, error2);
12625          }
12626          finishedWork.flags &= -3;
12627        }
12628        flags & 4096 && (finishedWork.flags &= -4097);
12629      }
12630      function recursivelyResetForms(parentFiber) {
12631        if (parentFiber.subtreeFlags & 1024)
12632          for (parentFiber = parentFiber.child; null !== parentFiber; ) {
12633            var fiber = parentFiber;
12634            recursivelyResetForms(fiber);
12635            5 === fiber.tag && fiber.flags & 1024 && fiber.stateNode.reset();
12636            parentFiber = parentFiber.sibling;
12637          }
12638      }
12639      function recursivelyTraverseLayoutEffects(root3, parentFiber) {
12640        if (parentFiber.subtreeFlags & 8772)
12641          for (parentFiber = parentFiber.child; null !== parentFiber; )
12642            commitLayoutEffectOnFiber(root3, parentFiber.alternate, parentFiber), parentFiber = parentFiber.sibling;
12643      }
12644      function disappearLayoutEffects(finishedWork) {
12645        var prevEffectStart = pushComponentEffectStart(), prevEffectDuration = pushComponentEffectDuration(), prevEffectErrors = pushComponentEffectErrors(), prevEffectDidSpawnUpdate = pushComponentEffectDidSpawnUpdate();
12646        switch (finishedWork.tag) {
12647          case 0:
12648          case 11:
12649          case 14:
12650          case 15:
12651            commitHookLayoutUnmountEffects(
12652              finishedWork,
12653              finishedWork.return,
12654              Layout
12655            );
12656            recursivelyTraverseDisappearLayoutEffects(finishedWork);
12657            break;
12658          case 1:
12659            safelyDetachRef(finishedWork, finishedWork.return);
12660            var instance = finishedWork.stateNode;
12661            "function" === typeof instance.componentWillUnmount && safelyCallComponentWillUnmount(
12662              finishedWork,
12663              finishedWork.return,
12664              instance
12665            );
12666            recursivelyTraverseDisappearLayoutEffects(finishedWork);
12667            break;
12668          case 27:
12669            runWithFiberInDEV(
12670              finishedWork,
12671              releaseSingletonInstance,
12672              finishedWork.stateNode
12673            );
12674          case 26:
12675          case 5:
12676            safelyDetachRef(finishedWork, finishedWork.return);
12677            recursivelyTraverseDisappearLayoutEffects(finishedWork);
12678            break;
12679          case 22:
12680            null === finishedWork.memoizedState && recursivelyTraverseDisappearLayoutEffects(finishedWork);
12681            break;
12682          case 30:
12683            recursivelyTraverseDisappearLayoutEffects(finishedWork);
12684            break;
12685          default:
12686            recursivelyTraverseDisappearLayoutEffects(finishedWork);
12687        }
12688        (finishedWork.mode & ProfileMode) !== NoMode && 0 <= componentEffectStartTime && 0 <= componentEffectEndTime && (componentEffectSpawnedUpdate || 0.05 < componentEffectDuration) && logComponentEffect(
12689          finishedWork,
12690          componentEffectStartTime,
12691          componentEffectEndTime,
12692          componentEffectDuration,
12693          componentEffectErrors
12694        );
12695        popComponentEffectStart(prevEffectStart);
12696        popComponentEffectDuration(prevEffectDuration);
12697        componentEffectErrors = prevEffectErrors;
12698        componentEffectSpawnedUpdate = prevEffectDidSpawnUpdate;
12699      }
12700      function recursivelyTraverseDisappearLayoutEffects(parentFiber) {
12701        for (parentFiber = parentFiber.child; null !== parentFiber; )
12702          disappearLayoutEffects(parentFiber), parentFiber = parentFiber.sibling;
12703      }
12704      function reappearLayoutEffects(finishedRoot, current2, finishedWork, includeWorkInProgressEffects) {
12705        var prevEffectStart = pushComponentEffectStart(), prevEffectDuration = pushComponentEffectDuration(), prevEffectErrors = pushComponentEffectErrors(), prevEffectDidSpawnUpdate = pushComponentEffectDidSpawnUpdate(), flags = finishedWork.flags;
12706        switch (finishedWork.tag) {
12707          case 0:
12708          case 11:
12709          case 15:
12710            recursivelyTraverseReappearLayoutEffects(
12711              finishedRoot,
12712              finishedWork,
12713              includeWorkInProgressEffects
12714            );
12715            commitHookLayoutEffects(finishedWork, Layout);
12716            break;
12717          case 1:
12718            recursivelyTraverseReappearLayoutEffects(
12719              finishedRoot,
12720              finishedWork,
12721              includeWorkInProgressEffects
12722            );
12723            current2 = finishedWork.stateNode;
12724            "function" === typeof current2.componentDidMount && runWithFiberInDEV(
12725              finishedWork,
12726              callComponentDidMountInDEV,
12727              finishedWork,
12728              current2
12729            );
12730            current2 = finishedWork.updateQueue;
12731            if (null !== current2) {
12732              finishedRoot = finishedWork.stateNode;
12733              try {
12734                runWithFiberInDEV(
12735                  finishedWork,
12736                  commitHiddenCallbacks,
12737                  current2,
12738                  finishedRoot
12739                );
12740              } catch (error2) {
12741                captureCommitPhaseError(finishedWork, finishedWork.return, error2);
12742              }
12743            }
12744            includeWorkInProgressEffects && flags & 64 && commitClassCallbacks(finishedWork);
12745            safelyAttachRef(finishedWork, finishedWork.return);
12746            break;
12747          case 27:
12748            commitHostSingletonAcquisition(finishedWork);
12749          case 26:
12750          case 5:
12751            recursivelyTraverseReappearLayoutEffects(
12752              finishedRoot,
12753              finishedWork,
12754              includeWorkInProgressEffects
12755            );
12756            includeWorkInProgressEffects && null === current2 && flags & 4 && commitHostMount(finishedWork);
12757            safelyAttachRef(finishedWork, finishedWork.return);
12758            break;
12759          case 12:
12760            if (includeWorkInProgressEffects && flags & 4) {
12761              flags = pushNestedEffectDurations();
12762              recursivelyTraverseReappearLayoutEffects(
12763                finishedRoot,
12764                finishedWork,
12765                includeWorkInProgressEffects
12766              );
12767              includeWorkInProgressEffects = finishedWork.stateNode;
12768              includeWorkInProgressEffects.effectDuration += bubbleNestedEffectDurations(flags);
12769              try {
12770                runWithFiberInDEV(
12771                  finishedWork,
12772                  commitProfiler,
12773                  finishedWork,
12774                  current2,
12775                  commitStartTime,
12776                  includeWorkInProgressEffects.effectDuration
12777                );
12778              } catch (error2) {
12779                captureCommitPhaseError(finishedWork, finishedWork.return, error2);
12780              }
12781            } else
12782              recursivelyTraverseReappearLayoutEffects(
12783                finishedRoot,
12784                finishedWork,
12785                includeWorkInProgressEffects
12786              );
12787            break;
12788          case 31:
12789            recursivelyTraverseReappearLayoutEffects(
12790              finishedRoot,
12791              finishedWork,
12792              includeWorkInProgressEffects
12793            );
12794            includeWorkInProgressEffects && flags & 4 && commitActivityHydrationCallbacks(finishedRoot, finishedWork);
12795            break;
12796          case 13:
12797            recursivelyTraverseReappearLayoutEffects(
12798              finishedRoot,
12799              finishedWork,
12800              includeWorkInProgressEffects
12801            );
12802            includeWorkInProgressEffects && flags & 4 && commitSuspenseHydrationCallbacks(finishedRoot, finishedWork);
12803            break;
12804          case 22:
12805            null === finishedWork.memoizedState && recursivelyTraverseReappearLayoutEffects(
12806              finishedRoot,
12807              finishedWork,
12808              includeWorkInProgressEffects
12809            );
12810            safelyAttachRef(finishedWork, finishedWork.return);
12811            break;
12812          case 30:
12813            break;
12814          default:
12815            recursivelyTraverseReappearLayoutEffects(
12816              finishedRoot,
12817              finishedWork,
12818              includeWorkInProgressEffects
12819            );
12820        }
12821        (finishedWork.mode & ProfileMode) !== NoMode && 0 <= componentEffectStartTime && 0 <= componentEffectEndTime && (componentEffectSpawnedUpdate || 0.05 < componentEffectDuration) && logComponentEffect(
12822          finishedWork,
12823          componentEffectStartTime,
12824          componentEffectEndTime,
12825          componentEffectDuration,
12826          componentEffectErrors
12827        );
12828        popComponentEffectStart(prevEffectStart);
12829        popComponentEffectDuration(prevEffectDuration);
12830        componentEffectErrors = prevEffectErrors;
12831        componentEffectSpawnedUpdate = prevEffectDidSpawnUpdate;
12832      }
12833      function recursivelyTraverseReappearLayoutEffects(finishedRoot, parentFiber, includeWorkInProgressEffects) {
12834        includeWorkInProgressEffects = includeWorkInProgressEffects && 0 !== (parentFiber.subtreeFlags & 8772);
12835        for (parentFiber = parentFiber.child; null !== parentFiber; )
12836          reappearLayoutEffects(
12837            finishedRoot,
12838            parentFiber.alternate,
12839            parentFiber,
12840            includeWorkInProgressEffects
12841          ), parentFiber = parentFiber.sibling;
12842      }
12843      function commitOffscreenPassiveMountEffects(current2, finishedWork) {
12844        var previousCache = null;
12845        null !== current2 && null !== current2.memoizedState && null !== current2.memoizedState.cachePool && (previousCache = current2.memoizedState.cachePool.pool);
12846        current2 = null;
12847        null !== finishedWork.memoizedState && null !== finishedWork.memoizedState.cachePool && (current2 = finishedWork.memoizedState.cachePool.pool);
12848        current2 !== previousCache && (null != current2 && retainCache(current2), null != previousCache && releaseCache(previousCache));
12849      }
12850      function commitCachePassiveMountEffect(current2, finishedWork) {
12851        current2 = null;
12852        null !== finishedWork.alternate && (current2 = finishedWork.alternate.memoizedState.cache);
12853        finishedWork = finishedWork.memoizedState.cache;
12854        finishedWork !== current2 && (retainCache(finishedWork), null != current2 && releaseCache(current2));
12855      }
12856      function recursivelyTraversePassiveMountEffects(root3, parentFiber, committedLanes, committedTransitions, endTime) {
12857        if (parentFiber.subtreeFlags & 10256 || 0 !== parentFiber.actualDuration && (null === parentFiber.alternate || parentFiber.alternate.child !== parentFiber.child))
12858          for (parentFiber = parentFiber.child; null !== parentFiber; ) {
12859            var nextSibling = parentFiber.sibling;
12860            commitPassiveMountOnFiber(
12861              root3,
12862              parentFiber,
12863              committedLanes,
12864              committedTransitions,
12865              null !== nextSibling ? nextSibling.actualStartTime : endTime
12866            );
12867            parentFiber = nextSibling;
12868          }
12869      }
12870      function commitPassiveMountOnFiber(finishedRoot, finishedWork, committedLanes, committedTransitions, endTime) {
12871        var prevEffectStart = pushComponentEffectStart(), prevEffectDuration = pushComponentEffectDuration(), prevEffectErrors = pushComponentEffectErrors(), prevEffectDidSpawnUpdate = pushComponentEffectDidSpawnUpdate(), prevDeepEquality = alreadyWarnedForDeepEquality, flags = finishedWork.flags;
12872        switch (finishedWork.tag) {
12873          case 0:
12874          case 11:
12875          case 15:
12876            (finishedWork.mode & ProfileMode) !== NoMode && 0 < finishedWork.actualStartTime && 0 !== (finishedWork.flags & 1) && logComponentRender(
12877              finishedWork,
12878              finishedWork.actualStartTime,
12879              endTime,
12880              inHydratedSubtree,
12881              committedLanes
12882            );
12883            recursivelyTraversePassiveMountEffects(
12884              finishedRoot,
12885              finishedWork,
12886              committedLanes,
12887              committedTransitions,
12888              endTime
12889            );
12890            flags & 2048 && commitHookPassiveMountEffects(finishedWork, Passive | HasEffect);
12891            break;
12892          case 1:
12893            (finishedWork.mode & ProfileMode) !== NoMode && 0 < finishedWork.actualStartTime && (0 !== (finishedWork.flags & 128) ? logComponentErrored(
12894              finishedWork,
12895              finishedWork.actualStartTime,
12896              endTime,
12897              []
12898            ) : 0 !== (finishedWork.flags & 1) && logComponentRender(
12899              finishedWork,
12900              finishedWork.actualStartTime,
12901              endTime,
12902              inHydratedSubtree,
12903              committedLanes
12904            ));
12905            recursivelyTraversePassiveMountEffects(
12906              finishedRoot,
12907              finishedWork,
12908              committedLanes,
12909              committedTransitions,
12910              endTime
12911            );
12912            break;
12913          case 3:
12914            var prevProfilerEffectDuration = pushNestedEffectDurations(), wasInHydratedSubtree = inHydratedSubtree;
12915            inHydratedSubtree = null !== finishedWork.alternate && finishedWork.alternate.memoizedState.isDehydrated && 0 === (finishedWork.flags & 256);
12916            recursivelyTraversePassiveMountEffects(
12917              finishedRoot,
12918              finishedWork,
12919              committedLanes,
12920              committedTransitions,
12921              endTime
12922            );
12923            inHydratedSubtree = wasInHydratedSubtree;
12924            flags & 2048 && (committedLanes = null, null !== finishedWork.alternate && (committedLanes = finishedWork.alternate.memoizedState.cache), committedTransitions = finishedWork.memoizedState.cache, committedTransitions !== committedLanes && (retainCache(committedTransitions), null != committedLanes && releaseCache(committedLanes)));
12925            finishedRoot.passiveEffectDuration += popNestedEffectDurations(
12926              prevProfilerEffectDuration
12927            );
12928            break;
12929          case 12:
12930            if (flags & 2048) {
12931              flags = pushNestedEffectDurations();
12932              recursivelyTraversePassiveMountEffects(
12933                finishedRoot,
12934                finishedWork,
12935                committedLanes,
12936                committedTransitions,
12937                endTime
12938              );
12939              finishedRoot = finishedWork.stateNode;
12940              finishedRoot.passiveEffectDuration += bubbleNestedEffectDurations(flags);
12941              try {
12942                runWithFiberInDEV(
12943                  finishedWork,
12944                  commitProfilerPostCommitImpl,
12945                  finishedWork,
12946                  finishedWork.alternate,
12947                  commitStartTime,
12948                  finishedRoot.passiveEffectDuration
12949                );
12950              } catch (error2) {
12951                captureCommitPhaseError(finishedWork, finishedWork.return, error2);
12952              }
12953            } else
12954              recursivelyTraversePassiveMountEffects(
12955                finishedRoot,
12956                finishedWork,
12957                committedLanes,
12958                committedTransitions,
12959                endTime
12960              );
12961            break;
12962          case 31:
12963            flags = inHydratedSubtree;
12964            prevProfilerEffectDuration = null !== finishedWork.alternate ? finishedWork.alternate.memoizedState : null;
12965            wasInHydratedSubtree = finishedWork.memoizedState;
12966            null !== prevProfilerEffectDuration && null === wasInHydratedSubtree ? (wasInHydratedSubtree = finishedWork.deletions, null !== wasInHydratedSubtree && 0 < wasInHydratedSubtree.length && 18 === wasInHydratedSubtree[0].tag ? (inHydratedSubtree = false, prevProfilerEffectDuration = prevProfilerEffectDuration.hydrationErrors, null !== prevProfilerEffectDuration && logComponentErrored(
12967              finishedWork,
12968              finishedWork.actualStartTime,
12969              endTime,
12970              prevProfilerEffectDuration
12971            )) : inHydratedSubtree = true) : inHydratedSubtree = false;
12972            recursivelyTraversePassiveMountEffects(
12973              finishedRoot,
12974              finishedWork,
12975              committedLanes,
12976              committedTransitions,
12977              endTime
12978            );
12979            inHydratedSubtree = flags;
12980            break;
12981          case 13:
12982            flags = inHydratedSubtree;
12983            prevProfilerEffectDuration = null !== finishedWork.alternate ? finishedWork.alternate.memoizedState : null;
12984            wasInHydratedSubtree = finishedWork.memoizedState;
12985            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(
12986              finishedWork,
12987              finishedWork.actualStartTime,
12988              endTime,
12989              prevProfilerEffectDuration
12990            )) : inHydratedSubtree = true);
12991            recursivelyTraversePassiveMountEffects(
12992              finishedRoot,
12993              finishedWork,
12994              committedLanes,
12995              committedTransitions,
12996              endTime
12997            );
12998            inHydratedSubtree = flags;
12999            break;
13000          case 23:
13001            break;
13002          case 22:
13003            wasInHydratedSubtree = finishedWork.stateNode;
13004            prevProfilerEffectDuration = finishedWork.alternate;
13005            null !== finishedWork.memoizedState ? wasInHydratedSubtree._visibility & OffscreenPassiveEffectsConnected ? recursivelyTraversePassiveMountEffects(
13006              finishedRoot,
13007              finishedWork,
13008              committedLanes,
13009              committedTransitions,
13010              endTime
13011            ) : recursivelyTraverseAtomicPassiveEffects(
13012              finishedRoot,
13013              finishedWork,
13014              committedLanes,
13015              committedTransitions,
13016              endTime
13017            ) : wasInHydratedSubtree._visibility & OffscreenPassiveEffectsConnected ? recursivelyTraversePassiveMountEffects(
13018              finishedRoot,
13019              finishedWork,
13020              committedLanes,
13021              committedTransitions,
13022              endTime
13023            ) : (wasInHydratedSubtree._visibility |= OffscreenPassiveEffectsConnected, recursivelyTraverseReconnectPassiveEffects(
13024              finishedRoot,
13025              finishedWork,
13026              committedLanes,
13027              committedTransitions,
13028              0 !== (finishedWork.subtreeFlags & 10256) || 0 !== finishedWork.actualDuration && (null === finishedWork.alternate || finishedWork.alternate.child !== finishedWork.child),
13029              endTime
13030            ), (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(
13031              finishedWork,
13032              componentEffectStartTime,
13033              componentEffectEndTime
13034            )));
13035            flags & 2048 && commitOffscreenPassiveMountEffects(
13036              prevProfilerEffectDuration,
13037              finishedWork
13038            );
13039            break;
13040          case 24:
13041            recursivelyTraversePassiveMountEffects(
13042              finishedRoot,
13043              finishedWork,
13044              committedLanes,
13045              committedTransitions,
13046              endTime
13047            );
13048            flags & 2048 && commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
13049            break;
13050          default:
13051            recursivelyTraversePassiveMountEffects(
13052              finishedRoot,
13053              finishedWork,
13054              committedLanes,
13055              committedTransitions,
13056              endTime
13057            );
13058        }
13059        if ((finishedWork.mode & ProfileMode) !== NoMode) {
13060          if (finishedRoot = !inHydratedSubtree && null === finishedWork.alternate && null !== finishedWork.return && null !== finishedWork.return.alternate)
13061            committedLanes = finishedWork.actualStartTime, 0 <= committedLanes && 0.05 < endTime - committedLanes && logComponentTrigger(
13062              finishedWork,
13063              committedLanes,
13064              endTime,
13065              "Mount"
13066            );
13067          0 <= componentEffectStartTime && 0 <= componentEffectEndTime && ((componentEffectSpawnedUpdate || 0.05 < componentEffectDuration) && logComponentEffect(
13068            finishedWork,
13069            componentEffectStartTime,
13070            componentEffectEndTime,
13071            componentEffectDuration,
13072            componentEffectErrors
13073          ), finishedRoot && 0.05 < componentEffectEndTime - componentEffectStartTime && logComponentTrigger(
13074            finishedWork,
13075            componentEffectStartTime,
13076            componentEffectEndTime,
13077            "Mount"
13078          ));
13079        }
13080        popComponentEffectStart(prevEffectStart);
13081        popComponentEffectDuration(prevEffectDuration);
13082        componentEffectErrors = prevEffectErrors;
13083        componentEffectSpawnedUpdate = prevEffectDidSpawnUpdate;
13084        alreadyWarnedForDeepEquality = prevDeepEquality;
13085      }
13086      function recursivelyTraverseReconnectPassiveEffects(finishedRoot, parentFiber, committedLanes, committedTransitions, includeWorkInProgressEffects, endTime) {
13087        includeWorkInProgressEffects = includeWorkInProgressEffects && (0 !== (parentFiber.subtreeFlags & 10256) || 0 !== parentFiber.actualDuration && (null === parentFiber.alternate || parentFiber.alternate.child !== parentFiber.child));
13088        for (parentFiber = parentFiber.child; null !== parentFiber; ) {
13089          var nextSibling = parentFiber.sibling;
13090          reconnectPassiveEffects(
13091            finishedRoot,
13092            parentFiber,
13093            committedLanes,
13094            committedTransitions,
13095            includeWorkInProgressEffects,
13096            null !== nextSibling ? nextSibling.actualStartTime : endTime
13097          );
13098          parentFiber = nextSibling;
13099        }
13100      }
13101      function reconnectPassiveEffects(finishedRoot, finishedWork, committedLanes, committedTransitions, includeWorkInProgressEffects, endTime) {
13102        var prevEffectStart = pushComponentEffectStart(), prevEffectDuration = pushComponentEffectDuration(), prevEffectErrors = pushComponentEffectErrors(), prevEffectDidSpawnUpdate = pushComponentEffectDidSpawnUpdate(), prevDeepEquality = alreadyWarnedForDeepEquality;
13103        includeWorkInProgressEffects && (finishedWork.mode & ProfileMode) !== NoMode && 0 < finishedWork.actualStartTime && 0 !== (finishedWork.flags & 1) && logComponentRender(
13104          finishedWork,
13105          finishedWork.actualStartTime,
13106          endTime,
13107          inHydratedSubtree,
13108          committedLanes
13109        );
13110        var flags = finishedWork.flags;
13111        switch (finishedWork.tag) {
13112          case 0:
13113          case 11:
13114          case 15:
13115            recursivelyTraverseReconnectPassiveEffects(
13116              finishedRoot,
13117              finishedWork,
13118              committedLanes,
13119              committedTransitions,
13120              includeWorkInProgressEffects,
13121              endTime
13122            );
13123            commitHookPassiveMountEffects(finishedWork, Passive);
13124            break;
13125          case 23:
13126            break;
13127          case 22:
13128            var _instance2 = finishedWork.stateNode;
13129            null !== finishedWork.memoizedState ? _instance2._visibility & OffscreenPassiveEffectsConnected ? recursivelyTraverseReconnectPassiveEffects(
13130              finishedRoot,
13131              finishedWork,
13132              committedLanes,
13133              committedTransitions,
13134              includeWorkInProgressEffects,
13135              endTime
13136            ) : recursivelyTraverseAtomicPassiveEffects(
13137              finishedRoot,
13138              finishedWork,
13139              committedLanes,
13140              committedTransitions,
13141              endTime
13142            ) : (_instance2._visibility |= OffscreenPassiveEffectsConnected, recursivelyTraverseReconnectPassiveEffects(
13143              finishedRoot,
13144              finishedWork,
13145              committedLanes,
13146              committedTransitions,
13147              includeWorkInProgressEffects,
13148              endTime
13149            ));
13150            includeWorkInProgressEffects && flags & 2048 && commitOffscreenPassiveMountEffects(
13151              finishedWork.alternate,
13152              finishedWork
13153            );
13154            break;
13155          case 24:
13156            recursivelyTraverseReconnectPassiveEffects(
13157              finishedRoot,
13158              finishedWork,
13159              committedLanes,
13160              committedTransitions,
13161              includeWorkInProgressEffects,
13162              endTime
13163            );
13164            includeWorkInProgressEffects && flags & 2048 && commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
13165            break;
13166          default:
13167            recursivelyTraverseReconnectPassiveEffects(
13168              finishedRoot,
13169              finishedWork,
13170              committedLanes,
13171              committedTransitions,
13172              includeWorkInProgressEffects,
13173              endTime
13174            );
13175        }
13176        (finishedWork.mode & ProfileMode) !== NoMode && 0 <= componentEffectStartTime && 0 <= componentEffectEndTime && (componentEffectSpawnedUpdate || 0.05 < componentEffectDuration) && logComponentEffect(
13177          finishedWork,
13178          componentEffectStartTime,
13179          componentEffectEndTime,
13180          componentEffectDuration,
13181          componentEffectErrors
13182        );
13183        popComponentEffectStart(prevEffectStart);
13184        popComponentEffectDuration(prevEffectDuration);
13185        componentEffectErrors = prevEffectErrors;
13186        componentEffectSpawnedUpdate = prevEffectDidSpawnUpdate;
13187        alreadyWarnedForDeepEquality = prevDeepEquality;
13188      }
13189      function recursivelyTraverseAtomicPassiveEffects(finishedRoot$jscomp$0, parentFiber, committedLanes$jscomp$0, committedTransitions$jscomp$0, endTime$jscomp$0) {
13190        if (parentFiber.subtreeFlags & 10256 || 0 !== parentFiber.actualDuration && (null === parentFiber.alternate || parentFiber.alternate.child !== parentFiber.child))
13191          for (var child = parentFiber.child; null !== child; ) {
13192            parentFiber = child.sibling;
13193            var finishedRoot = finishedRoot$jscomp$0, committedLanes = committedLanes$jscomp$0, committedTransitions = committedTransitions$jscomp$0, endTime = null !== parentFiber ? parentFiber.actualStartTime : endTime$jscomp$0, prevDeepEquality = alreadyWarnedForDeepEquality;
13194            (child.mode & ProfileMode) !== NoMode && 0 < child.actualStartTime && 0 !== (child.flags & 1) && logComponentRender(
13195              child,
13196              child.actualStartTime,
13197              endTime,
13198              inHydratedSubtree,
13199              committedLanes
13200            );
13201            var flags = child.flags;
13202            switch (child.tag) {
13203              case 22:
13204                recursivelyTraverseAtomicPassiveEffects(
13205                  finishedRoot,
13206                  child,
13207                  committedLanes,
13208                  committedTransitions,
13209                  endTime
13210                );
13211                flags & 2048 && commitOffscreenPassiveMountEffects(child.alternate, child);
13212                break;
13213              case 24:
13214                recursivelyTraverseAtomicPassiveEffects(
13215                  finishedRoot,
13216                  child,
13217                  committedLanes,
13218                  committedTransitions,
13219                  endTime
13220                );
13221                flags & 2048 && commitCachePassiveMountEffect(child.alternate, child);
13222                break;
13223              default:
13224                recursivelyTraverseAtomicPassiveEffects(
13225                  finishedRoot,
13226                  child,
13227                  committedLanes,
13228                  committedTransitions,
13229                  endTime
13230                );
13231            }
13232            alreadyWarnedForDeepEquality = prevDeepEquality;
13233            child = parentFiber;
13234          }
13235      }
13236      function recursivelyAccumulateSuspenseyCommit(parentFiber, committedLanes, suspendedState) {
13237        if (parentFiber.subtreeFlags & suspenseyCommitFlag)
13238          for (parentFiber = parentFiber.child; null !== parentFiber; )
13239            accumulateSuspenseyCommitOnFiber(
13240              parentFiber,
13241              committedLanes,
13242              suspendedState
13243            ), parentFiber = parentFiber.sibling;
13244      }
13245      function accumulateSuspenseyCommitOnFiber(fiber, committedLanes, suspendedState) {
13246        switch (fiber.tag) {
13247          case 26:
13248            recursivelyAccumulateSuspenseyCommit(
13249              fiber,
13250              committedLanes,
13251              suspendedState
13252            );
13253            fiber.flags & suspenseyCommitFlag && null !== fiber.memoizedState && suspendResource(
13254              suspendedState,
13255              currentHoistableRoot,
13256              fiber.memoizedState,
13257              fiber.memoizedProps
13258            );
13259            break;
13260          case 5:
13261            recursivelyAccumulateSuspenseyCommit(
13262              fiber,
13263              committedLanes,
13264              suspendedState
13265            );
13266            break;
13267          case 3:
13268          case 4:
13269            var previousHoistableRoot = currentHoistableRoot;
13270            currentHoistableRoot = getHoistableRoot(
13271              fiber.stateNode.containerInfo
13272            );
13273            recursivelyAccumulateSuspenseyCommit(
13274              fiber,
13275              committedLanes,
13276              suspendedState
13277            );
13278            currentHoistableRoot = previousHoistableRoot;
13279            break;
13280          case 22:
13281            null === fiber.memoizedState && (previousHoistableRoot = fiber.alternate, null !== previousHoistableRoot && null !== previousHoistableRoot.memoizedState ? (previousHoistableRoot = suspenseyCommitFlag, suspenseyCommitFlag = 16777216, recursivelyAccumulateSuspenseyCommit(
13282              fiber,
13283              committedLanes,
13284              suspendedState
13285            ), suspenseyCommitFlag = previousHoistableRoot) : recursivelyAccumulateSuspenseyCommit(
13286              fiber,
13287              committedLanes,
13288              suspendedState
13289            ));
13290            break;
13291          default:
13292            recursivelyAccumulateSuspenseyCommit(
13293              fiber,
13294              committedLanes,
13295              suspendedState
13296            );
13297        }
13298      }
13299      function detachAlternateSiblings(parentFiber) {
13300        var previousFiber = parentFiber.alternate;
13301        if (null !== previousFiber && (parentFiber = previousFiber.child, null !== parentFiber)) {
13302          previousFiber.child = null;
13303          do
13304            previousFiber = parentFiber.sibling, parentFiber.sibling = null, parentFiber = previousFiber;
13305          while (null !== parentFiber);
13306        }
13307      }
13308      function recursivelyTraversePassiveUnmountEffects(parentFiber) {
13309        var deletions = parentFiber.deletions;
13310        if (0 !== (parentFiber.flags & 16)) {
13311          if (null !== deletions)
13312            for (var i3 = 0; i3 < deletions.length; i3++) {
13313              var childToDelete = deletions[i3], prevEffectStart = pushComponentEffectStart();
13314              nextEffect = childToDelete;
13315              commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
13316                childToDelete,
13317                parentFiber
13318              );
13319              (childToDelete.mode & ProfileMode) !== NoMode && 0 <= componentEffectStartTime && 0 <= componentEffectEndTime && 0.05 < componentEffectEndTime - componentEffectStartTime && logComponentTrigger(
13320                childToDelete,
13321                componentEffectStartTime,
13322                componentEffectEndTime,
13323                "Unmount"
13324              );
13325              popComponentEffectStart(prevEffectStart);
13326            }
13327          detachAlternateSiblings(parentFiber);
13328        }
13329        if (parentFiber.subtreeFlags & 10256)
13330          for (parentFiber = parentFiber.child; null !== parentFiber; )
13331            commitPassiveUnmountOnFiber(parentFiber), parentFiber = parentFiber.sibling;
13332      }
13333      function commitPassiveUnmountOnFiber(finishedWork) {
13334        var prevEffectStart = pushComponentEffectStart(), prevEffectDuration = pushComponentEffectDuration(), prevEffectErrors = pushComponentEffectErrors(), prevEffectDidSpawnUpdate = pushComponentEffectDidSpawnUpdate();
13335        switch (finishedWork.tag) {
13336          case 0:
13337          case 11:
13338          case 15:
13339            recursivelyTraversePassiveUnmountEffects(finishedWork);
13340            finishedWork.flags & 2048 && commitHookPassiveUnmountEffects(
13341              finishedWork,
13342              finishedWork.return,
13343              Passive | HasEffect
13344            );
13345            break;
13346          case 3:
13347            var prevProfilerEffectDuration = pushNestedEffectDurations();
13348            recursivelyTraversePassiveUnmountEffects(finishedWork);
13349            finishedWork.stateNode.passiveEffectDuration += popNestedEffectDurations(prevProfilerEffectDuration);
13350            break;
13351          case 12:
13352            prevProfilerEffectDuration = pushNestedEffectDurations();
13353            recursivelyTraversePassiveUnmountEffects(finishedWork);
13354            finishedWork.stateNode.passiveEffectDuration += bubbleNestedEffectDurations(prevProfilerEffectDuration);
13355            break;
13356          case 22:
13357            prevProfilerEffectDuration = finishedWork.stateNode;
13358            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(
13359              finishedWork,
13360              componentEffectStartTime,
13361              componentEffectEndTime,
13362              "Disconnect"
13363            )) : recursivelyTraversePassiveUnmountEffects(finishedWork);
13364            break;
13365          default:
13366            recursivelyTraversePassiveUnmountEffects(finishedWork);
13367        }
13368        (finishedWork.mode & ProfileMode) !== NoMode && 0 <= componentEffectStartTime && 0 <= componentEffectEndTime && (componentEffectSpawnedUpdate || 0.05 < componentEffectDuration) && logComponentEffect(
13369          finishedWork,
13370          componentEffectStartTime,
13371          componentEffectEndTime,
13372          componentEffectDuration,
13373          componentEffectErrors
13374        );
13375        popComponentEffectStart(prevEffectStart);
13376        popComponentEffectDuration(prevEffectDuration);
13377        componentEffectSpawnedUpdate = prevEffectDidSpawnUpdate;
13378        componentEffectErrors = prevEffectErrors;
13379      }
13380      function recursivelyTraverseDisconnectPassiveEffects(parentFiber) {
13381        var deletions = parentFiber.deletions;
13382        if (0 !== (parentFiber.flags & 16)) {
13383          if (null !== deletions)
13384            for (var i3 = 0; i3 < deletions.length; i3++) {
13385              var childToDelete = deletions[i3], prevEffectStart = pushComponentEffectStart();
13386              nextEffect = childToDelete;
13387              commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
13388                childToDelete,
13389                parentFiber
13390              );
13391              (childToDelete.mode & ProfileMode) !== NoMode && 0 <= componentEffectStartTime && 0 <= componentEffectEndTime && 0.05 < componentEffectEndTime - componentEffectStartTime && logComponentTrigger(
13392                childToDelete,
13393                componentEffectStartTime,
13394                componentEffectEndTime,
13395                "Unmount"
13396              );
13397              popComponentEffectStart(prevEffectStart);
13398            }
13399          detachAlternateSiblings(parentFiber);
13400        }
13401        for (parentFiber = parentFiber.child; null !== parentFiber; )
13402          disconnectPassiveEffect(parentFiber), parentFiber = parentFiber.sibling;
13403      }
13404      function disconnectPassiveEffect(finishedWork) {
13405        var prevEffectStart = pushComponentEffectStart(), prevEffectDuration = pushComponentEffectDuration(), prevEffectErrors = pushComponentEffectErrors(), prevEffectDidSpawnUpdate = pushComponentEffectDidSpawnUpdate();
13406        switch (finishedWork.tag) {
13407          case 0:
13408          case 11:
13409          case 15:
13410            commitHookPassiveUnmountEffects(
13411              finishedWork,
13412              finishedWork.return,
13413              Passive
13414            );
13415            recursivelyTraverseDisconnectPassiveEffects(finishedWork);
13416            break;
13417          case 22:
13418            var instance = finishedWork.stateNode;
13419            instance._visibility & OffscreenPassiveEffectsConnected && (instance._visibility &= ~OffscreenPassiveEffectsConnected, recursivelyTraverseDisconnectPassiveEffects(finishedWork));
13420            break;
13421          default:
13422            recursivelyTraverseDisconnectPassiveEffects(finishedWork);
13423        }
13424        (finishedWork.mode & ProfileMode) !== NoMode && 0 <= componentEffectStartTime && 0 <= componentEffectEndTime && (componentEffectSpawnedUpdate || 0.05 < componentEffectDuration) && logComponentEffect(
13425          finishedWork,
13426          componentEffectStartTime,
13427          componentEffectEndTime,
13428          componentEffectDuration,
13429          componentEffectErrors
13430        );
13431        popComponentEffectStart(prevEffectStart);
13432        popComponentEffectDuration(prevEffectDuration);
13433        componentEffectSpawnedUpdate = prevEffectDidSpawnUpdate;
13434        componentEffectErrors = prevEffectErrors;
13435      }
13436      function commitPassiveUnmountEffectsInsideOfDeletedTree_begin(deletedSubtreeRoot, nearestMountedAncestor$jscomp$0) {
13437        for (; null !== nextEffect; ) {
13438          var fiber = nextEffect, current2 = fiber, nearestMountedAncestor = nearestMountedAncestor$jscomp$0, prevEffectStart = pushComponentEffectStart(), prevEffectDuration = pushComponentEffectDuration(), prevEffectErrors = pushComponentEffectErrors(), prevEffectDidSpawnUpdate = pushComponentEffectDidSpawnUpdate();
13439          switch (current2.tag) {
13440            case 0:
13441            case 11:
13442            case 15:
13443              commitHookPassiveUnmountEffects(
13444                current2,
13445                nearestMountedAncestor,
13446                Passive
13447              );
13448              break;
13449            case 23:
13450            case 22:
13451              null !== current2.memoizedState && null !== current2.memoizedState.cachePool && (nearestMountedAncestor = current2.memoizedState.cachePool.pool, null != nearestMountedAncestor && retainCache(nearestMountedAncestor));
13452              break;
13453            case 24:
13454              releaseCache(current2.memoizedState.cache);
13455          }
13456          (current2.mode & ProfileMode) !== NoMode && 0 <= componentEffectStartTime && 0 <= componentEffectEndTime && (componentEffectSpawnedUpdate || 0.05 < componentEffectDuration) && logComponentEffect(
13457            current2,
13458            componentEffectStartTime,
13459            componentEffectEndTime,
13460            componentEffectDuration,
13461            componentEffectErrors
13462          );
13463          popComponentEffectStart(prevEffectStart);
13464          popComponentEffectDuration(prevEffectDuration);
13465          componentEffectSpawnedUpdate = prevEffectDidSpawnUpdate;
13466          componentEffectErrors = prevEffectErrors;
13467          current2 = fiber.child;
13468          if (null !== current2) current2.return = fiber, nextEffect = current2;
13469          else
13470            a: for (fiber = deletedSubtreeRoot; null !== nextEffect; ) {
13471              current2 = nextEffect;
13472              prevEffectStart = current2.sibling;
13473              prevEffectDuration = current2.return;
13474              detachFiberAfterEffects(current2);
13475              if (current2 === fiber) {
13476                nextEffect = null;
13477                break a;
13478              }
13479              if (null !== prevEffectStart) {
13480                prevEffectStart.return = prevEffectDuration;
13481                nextEffect = prevEffectStart;
13482                break a;
13483              }
13484              nextEffect = prevEffectDuration;
13485            }
13486        }
13487      }
13488      function onCommitRoot() {
13489        commitHooks.forEach(function(commitHook) {
13490          return commitHook();
13491        });
13492      }
13493      function isConcurrentActEnvironment() {
13494        var isReactActEnvironmentGlobal = "undefined" !== typeof IS_REACT_ACT_ENVIRONMENT ? IS_REACT_ACT_ENVIRONMENT : void 0;
13495        isReactActEnvironmentGlobal || null === ReactSharedInternals.actQueue || console.error(
13496          "The current testing environment is not configured to support act(...)"
13497        );
13498        return isReactActEnvironmentGlobal;
13499      }
13500      function requestUpdateLane(fiber) {
13501        if ((executionContext & RenderContext) !== NoContext && 0 !== workInProgressRootRenderLanes)
13502          return workInProgressRootRenderLanes & -workInProgressRootRenderLanes;
13503        var transition = ReactSharedInternals.T;
13504        return null !== transition ? (transition._updatedFibers || (transition._updatedFibers = /* @__PURE__ */ new Set()), transition._updatedFibers.add(fiber), requestTransitionLane()) : resolveUpdatePriority();
13505      }
13506      function requestDeferredLane() {
13507        if (0 === workInProgressDeferredLane)
13508          if (0 === (workInProgressRootRenderLanes & 536870912) || isHydrating) {
13509            var lane = nextTransitionDeferredLane;
13510            nextTransitionDeferredLane <<= 1;
13511            0 === (nextTransitionDeferredLane & 3932160) && (nextTransitionDeferredLane = 262144);
13512            workInProgressDeferredLane = lane;
13513          } else workInProgressDeferredLane = 536870912;
13514        lane = suspenseHandlerStackCursor.current;
13515        null !== lane && (lane.flags |= 32);
13516        return workInProgressDeferredLane;
13517      }
13518      function scheduleUpdateOnFiber(root3, fiber, lane) {
13519        isRunningInsertionEffect && console.error("useInsertionEffect must not schedule updates.");
13520        isFlushingPassiveEffects && (didScheduleUpdateDuringPassiveEffects = true);
13521        if (root3 === workInProgressRoot && (workInProgressSuspendedReason === SuspendedOnData || workInProgressSuspendedReason === SuspendedOnAction) || null !== root3.cancelPendingCommit)
13522          prepareFreshStack(root3, 0), markRootSuspended(
13523            root3,
13524            workInProgressRootRenderLanes,
13525            workInProgressDeferredLane,
13526            false
13527          );
13528        markRootUpdated$1(root3, lane);
13529        if ((executionContext & RenderContext) !== NoContext && root3 === workInProgressRoot) {
13530          if (isRendering)
13531            switch (fiber.tag) {
13532              case 0:
13533              case 11:
13534              case 15:
13535                root3 = workInProgress && getComponentNameFromFiber(workInProgress) || "Unknown";
13536                didWarnAboutUpdateInRenderForAnotherComponent.has(root3) || (didWarnAboutUpdateInRenderForAnotherComponent.add(root3), fiber = getComponentNameFromFiber(fiber) || "Unknown", console.error(
13537                  "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",
13538                  fiber,
13539                  root3,
13540                  root3
13541                ));
13542                break;
13543              case 1:
13544                didWarnAboutUpdateInRender || (console.error(
13545                  "Cannot update during an existing state transition (such as within `render`). Render methods should be a pure function of props and state."
13546                ), didWarnAboutUpdateInRender = true);
13547            }
13548        } else
13549          isDevToolsPresent && addFiberToLanesMap(root3, fiber, lane), warnIfUpdatesNotWrappedWithActDEV(fiber), root3 === workInProgressRoot && ((executionContext & RenderContext) === NoContext && (workInProgressRootInterleavedUpdatedLanes |= lane), workInProgressRootExitStatus === RootSuspendedWithDelay && markRootSuspended(
13550            root3,
13551            workInProgressRootRenderLanes,
13552            workInProgressDeferredLane,
13553            false
13554          )), ensureRootIsScheduled(root3);
13555      }
13556      function performWorkOnRoot(root3, lanes, forceSync) {
13557        if ((executionContext & (RenderContext | CommitContext)) !== NoContext)
13558          throw Error("Should not already be working.");
13559        if (0 !== workInProgressRootRenderLanes && null !== workInProgress) {
13560          var yieldedFiber = workInProgress, yieldEndTime = now$1();
13561          switch (yieldReason) {
13562            case SuspendedOnImmediate:
13563            case SuspendedOnData:
13564              var startTime = yieldStartTime;
13565              supportsUserTiming && ((yieldedFiber = yieldedFiber._debugTask) ? yieldedFiber.run(
13566                console.timeStamp.bind(
13567                  console,
13568                  "Suspended",
13569                  startTime,
13570                  yieldEndTime,
13571                  COMPONENTS_TRACK,
13572                  void 0,
13573                  "primary-light"
13574                )
13575              ) : console.timeStamp(
13576                "Suspended",
13577                startTime,
13578                yieldEndTime,
13579                COMPONENTS_TRACK,
13580                void 0,
13581                "primary-light"
13582              ));
13583              break;
13584            case SuspendedOnAction:
13585              startTime = yieldStartTime;
13586              supportsUserTiming && ((yieldedFiber = yieldedFiber._debugTask) ? yieldedFiber.run(
13587                console.timeStamp.bind(
13588                  console,
13589                  "Action",
13590                  startTime,
13591                  yieldEndTime,
13592                  COMPONENTS_TRACK,
13593                  void 0,
13594                  "primary-light"
13595                )
13596              ) : console.timeStamp(
13597                "Action",
13598                startTime,
13599                yieldEndTime,
13600                COMPONENTS_TRACK,
13601                void 0,
13602                "primary-light"
13603              ));
13604              break;
13605            default:
13606              supportsUserTiming && (yieldedFiber = yieldEndTime - yieldStartTime, 3 > yieldedFiber || console.timeStamp(
13607                "Blocked",
13608                yieldStartTime,
13609                yieldEndTime,
13610                COMPONENTS_TRACK,
13611                void 0,
13612                5 > yieldedFiber ? "primary-light" : 10 > yieldedFiber ? "primary" : 100 > yieldedFiber ? "primary-dark" : "error"
13613              ));
13614          }
13615        }
13616        startTime = (forceSync = !forceSync && 0 === (lanes & 127) && 0 === (lanes & root3.expiredLanes) || checkIfRootIsPrerendering(root3, lanes)) ? renderRootConcurrent(root3, lanes) : renderRootSync(root3, lanes, true);
13617        var renderWasConcurrent = forceSync;
13618        do {
13619          if (startTime === RootInProgress) {
13620            workInProgressRootIsPrerendering && !forceSync && markRootSuspended(root3, lanes, 0, false);
13621            lanes = workInProgressSuspendedReason;
13622            yieldStartTime = now3();
13623            yieldReason = lanes;
13624            break;
13625          } else {
13626            yieldedFiber = now$1();
13627            yieldEndTime = root3.current.alternate;
13628            if (renderWasConcurrent && !isRenderConsistentWithExternalStores(yieldEndTime)) {
13629              setCurrentTrackFromLanes(lanes);
13630              yieldEndTime = renderStartTime;
13631              startTime = yieldedFiber;
13632              !supportsUserTiming || startTime <= yieldEndTime || (workInProgressUpdateTask ? workInProgressUpdateTask.run(
13633                console.timeStamp.bind(
13634                  console,
13635                  "Teared Render",
13636                  yieldEndTime,
13637                  startTime,
13638                  currentTrack,
13639                  LANES_TRACK_GROUP,
13640                  "error"
13641                )
13642              ) : console.timeStamp(
13643                "Teared Render",
13644                yieldEndTime,
13645                startTime,
13646                currentTrack,
13647                LANES_TRACK_GROUP,
13648                "error"
13649              ));
13650              finalizeRender(lanes, yieldedFiber);
13651              startTime = renderRootSync(root3, lanes, false);
13652              renderWasConcurrent = false;
13653              continue;
13654            }
13655            if (startTime === RootErrored) {
13656              renderWasConcurrent = lanes;
13657              if (root3.errorRecoveryDisabledLanes & renderWasConcurrent)
13658                var errorRetryLanes = 0;
13659              else
13660                errorRetryLanes = root3.pendingLanes & -536870913, errorRetryLanes = 0 !== errorRetryLanes ? errorRetryLanes : errorRetryLanes & 536870912 ? 536870912 : 0;
13661              if (0 !== errorRetryLanes) {
13662                setCurrentTrackFromLanes(lanes);
13663                logErroredRenderPhase(
13664                  renderStartTime,
13665                  yieldedFiber,
13666                  lanes,
13667                  workInProgressUpdateTask
13668                );
13669                finalizeRender(lanes, yieldedFiber);
13670                lanes = errorRetryLanes;
13671                a: {
13672                  yieldedFiber = root3;
13673                  startTime = renderWasConcurrent;
13674                  renderWasConcurrent = workInProgressRootConcurrentErrors;
13675                  var wasRootDehydrated = yieldedFiber.current.memoizedState.isDehydrated;
13676                  wasRootDehydrated && (prepareFreshStack(yieldedFiber, errorRetryLanes).flags |= 256);
13677                  errorRetryLanes = renderRootSync(
13678                    yieldedFiber,
13679                    errorRetryLanes,
13680                    false
13681                  );
13682                  if (errorRetryLanes !== RootErrored) {
13683                    if (workInProgressRootDidAttachPingListener && !wasRootDehydrated) {
13684                      yieldedFiber.errorRecoveryDisabledLanes |= startTime;
13685                      workInProgressRootInterleavedUpdatedLanes |= startTime;
13686                      startTime = RootSuspendedWithDelay;
13687                      break a;
13688                    }
13689                    yieldedFiber = workInProgressRootRecoverableErrors;
13690                    workInProgressRootRecoverableErrors = renderWasConcurrent;
13691                    null !== yieldedFiber && (null === workInProgressRootRecoverableErrors ? workInProgressRootRecoverableErrors = yieldedFiber : workInProgressRootRecoverableErrors.push.apply(
13692                      workInProgressRootRecoverableErrors,
13693                      yieldedFiber
13694                    ));
13695                  }
13696                  startTime = errorRetryLanes;
13697                }
13698                renderWasConcurrent = false;
13699                if (startTime !== RootErrored) continue;
13700                else yieldedFiber = now$1();
13701              }
13702            }
13703            if (startTime === RootFatalErrored) {
13704              setCurrentTrackFromLanes(lanes);
13705              logErroredRenderPhase(
13706                renderStartTime,
13707                yieldedFiber,
13708                lanes,
13709                workInProgressUpdateTask
13710              );
13711              finalizeRender(lanes, yieldedFiber);
13712              prepareFreshStack(root3, 0);
13713              markRootSuspended(root3, lanes, 0, true);
13714              break;
13715            }
13716            a: {
13717              forceSync = root3;
13718              switch (startTime) {
13719                case RootInProgress:
13720                case RootFatalErrored:
13721                  throw Error("Root did not complete. This is a bug in React.");
13722                case RootSuspendedWithDelay:
13723                  if ((lanes & 4194048) !== lanes) break;
13724                case RootSuspendedAtTheShell:
13725                  setCurrentTrackFromLanes(lanes);
13726                  logSuspendedRenderPhase(
13727                    renderStartTime,
13728                    yieldedFiber,
13729                    lanes,
13730                    workInProgressUpdateTask
13731                  );
13732                  finalizeRender(lanes, yieldedFiber);
13733                  yieldEndTime = lanes;
13734                  0 !== (yieldEndTime & 127) ? blockingSuspendedTime = yieldedFiber : 0 !== (yieldEndTime & 4194048) && (transitionSuspendedTime = yieldedFiber);
13735                  markRootSuspended(
13736                    forceSync,
13737                    lanes,
13738                    workInProgressDeferredLane,
13739                    !workInProgressRootDidSkipSuspendedSiblings
13740                  );
13741                  break a;
13742                case RootErrored:
13743                  workInProgressRootRecoverableErrors = null;
13744                  break;
13745                case RootSuspended:
13746                case RootCompleted:
13747                  break;
13748                default:
13749                  throw Error("Unknown root exit status.");
13750              }
13751              if (null !== ReactSharedInternals.actQueue)
13752                commitRoot(
13753                  forceSync,
13754                  yieldEndTime,
13755                  lanes,
13756                  workInProgressRootRecoverableErrors,
13757                  workInProgressTransitions,
13758                  workInProgressRootDidIncludeRecursiveRenderUpdate,
13759                  workInProgressDeferredLane,
13760                  workInProgressRootInterleavedUpdatedLanes,
13761                  workInProgressSuspendedRetryLanes,
13762                  startTime,
13763                  null,
13764                  null,
13765                  renderStartTime,
13766                  yieldedFiber
13767                );
13768              else {
13769                if ((lanes & 62914560) === lanes && (renderWasConcurrent = globalMostRecentFallbackTime + FALLBACK_THROTTLE_MS - now$1(), 10 < renderWasConcurrent)) {
13770                  markRootSuspended(
13771                    forceSync,
13772                    lanes,
13773                    workInProgressDeferredLane,
13774                    !workInProgressRootDidSkipSuspendedSiblings
13775                  );
13776                  if (0 !== getNextLanes(forceSync, 0, true)) break a;
13777                  pendingEffectsLanes = lanes;
13778                  forceSync.timeoutHandle = scheduleTimeout(
13779                    commitRootWhenReady.bind(
13780                      null,
13781                      forceSync,
13782                      yieldEndTime,
13783                      workInProgressRootRecoverableErrors,
13784                      workInProgressTransitions,
13785                      workInProgressRootDidIncludeRecursiveRenderUpdate,
13786                      lanes,
13787                      workInProgressDeferredLane,
13788                      workInProgressRootInterleavedUpdatedLanes,
13789                      workInProgressSuspendedRetryLanes,
13790                      workInProgressRootDidSkipSuspendedSiblings,
13791                      startTime,
13792                      "Throttled",
13793                      renderStartTime,
13794                      yieldedFiber
13795                    ),
13796                    renderWasConcurrent
13797                  );
13798                  break a;
13799                }
13800                commitRootWhenReady(
13801                  forceSync,
13802                  yieldEndTime,
13803                  workInProgressRootRecoverableErrors,
13804                  workInProgressTransitions,
13805                  workInProgressRootDidIncludeRecursiveRenderUpdate,
13806                  lanes,
13807                  workInProgressDeferredLane,
13808                  workInProgressRootInterleavedUpdatedLanes,
13809                  workInProgressSuspendedRetryLanes,
13810                  workInProgressRootDidSkipSuspendedSiblings,
13811                  startTime,
13812                  null,
13813                  renderStartTime,
13814                  yieldedFiber
13815                );
13816              }
13817            }
13818          }
13819          break;
13820        } while (1);
13821        ensureRootIsScheduled(root3);
13822      }
13823      function commitRootWhenReady(root3, finishedWork, recoverableErrors, transitions, didIncludeRenderPhaseUpdate, lanes, spawnedLane, updatedLanes, suspendedRetryLanes, didSkipSuspendedSiblings, exitStatus, suspendedCommitReason, completedRenderStartTime, completedRenderEndTime) {
13824        root3.timeoutHandle = noTimeout;
13825        var subtreeFlags = finishedWork.subtreeFlags, suspendedState = null;
13826        if (subtreeFlags & 8192 || 16785408 === (subtreeFlags & 16785408)) {
13827          if (suspendedState = {
13828            stylesheets: null,
13829            count: 0,
13830            imgCount: 0,
13831            imgBytes: 0,
13832            suspenseyImages: [],
13833            waitingForImages: true,
13834            waitingForViewTransition: false,
13835            unsuspend: noop$1
13836          }, accumulateSuspenseyCommitOnFiber(finishedWork, lanes, suspendedState), subtreeFlags = (lanes & 62914560) === lanes ? globalMostRecentFallbackTime - now$1() : (lanes & 4194048) === lanes ? globalMostRecentTransitionTime - now$1() : 0, subtreeFlags = waitForCommitToBeReady(suspendedState, subtreeFlags), null !== subtreeFlags) {
13837            pendingEffectsLanes = lanes;
13838            root3.cancelPendingCommit = subtreeFlags(
13839              commitRoot.bind(
13840                null,
13841                root3,
13842                finishedWork,
13843                lanes,
13844                recoverableErrors,
13845                transitions,
13846                didIncludeRenderPhaseUpdate,
13847                spawnedLane,
13848                updatedLanes,
13849                suspendedRetryLanes,
13850                exitStatus,
13851                suspendedState,
13852                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,
13853                completedRenderStartTime,
13854                completedRenderEndTime
13855              )
13856            );
13857            markRootSuspended(
13858              root3,
13859              lanes,
13860              spawnedLane,
13861              !didSkipSuspendedSiblings
13862            );
13863            return;
13864          }
13865        }
13866        commitRoot(
13867          root3,
13868          finishedWork,
13869          lanes,
13870          recoverableErrors,
13871          transitions,
13872          didIncludeRenderPhaseUpdate,
13873          spawnedLane,
13874          updatedLanes,
13875          suspendedRetryLanes,
13876          exitStatus,
13877          suspendedState,
13878          suspendedCommitReason,
13879          completedRenderStartTime,
13880          completedRenderEndTime
13881        );
13882      }
13883      function isRenderConsistentWithExternalStores(finishedWork) {
13884        for (var node = finishedWork; ; ) {
13885          var tag = node.tag;
13886          if ((0 === tag || 11 === tag || 15 === tag) && node.flags & 16384 && (tag = node.updateQueue, null !== tag && (tag = tag.stores, null !== tag)))
13887            for (var i3 = 0; i3 < tag.length; i3++) {
13888              var check = tag[i3], getSnapshot = check.getSnapshot;
13889              check = check.value;
13890              try {
13891                if (!objectIs(getSnapshot(), check)) return false;
13892              } catch (error2) {
13893                return false;
13894              }
13895            }
13896          tag = node.child;
13897          if (node.subtreeFlags & 16384 && null !== tag)
13898            tag.return = node, node = tag;
13899          else {
13900            if (node === finishedWork) break;
13901            for (; null === node.sibling; ) {
13902              if (null === node.return || node.return === finishedWork) return true;
13903              node = node.return;
13904            }
13905            node.sibling.return = node.return;
13906            node = node.sibling;
13907          }
13908        }
13909        return true;
13910      }
13911      function markRootSuspended(root3, suspendedLanes, spawnedLane, didAttemptEntireTree) {
13912        suspendedLanes &= ~workInProgressRootPingedLanes;
13913        suspendedLanes &= ~workInProgressRootInterleavedUpdatedLanes;
13914        root3.suspendedLanes |= suspendedLanes;
13915        root3.pingedLanes &= ~suspendedLanes;
13916        didAttemptEntireTree && (root3.warmLanes |= suspendedLanes);
13917        didAttemptEntireTree = root3.expirationTimes;
13918        for (var lanes = suspendedLanes; 0 < lanes; ) {
13919          var index = 31 - clz32(lanes), lane = 1 << index;
13920          didAttemptEntireTree[index] = -1;
13921          lanes &= ~lane;
13922        }
13923        0 !== spawnedLane && markSpawnedDeferredLane(root3, spawnedLane, suspendedLanes);
13924      }
13925      function flushSyncWork$1() {
13926        return (executionContext & (RenderContext | CommitContext)) === NoContext ? (flushSyncWorkAcrossRoots_impl(0, false), false) : true;
13927      }
13928      function resetWorkInProgressStack() {
13929        if (null !== workInProgress) {
13930          if (workInProgressSuspendedReason === NotSuspended)
13931            var interruptedWork = workInProgress.return;
13932          else
13933            interruptedWork = workInProgress, resetContextDependencies(), resetHooksOnUnwind(interruptedWork), thenableState$1 = null, thenableIndexCounter$1 = 0, interruptedWork = workInProgress;
13934          for (; null !== interruptedWork; )
13935            unwindInterruptedWork(interruptedWork.alternate, interruptedWork), interruptedWork = interruptedWork.return;
13936          workInProgress = null;
13937        }
13938      }
13939      function finalizeRender(lanes, finalizationTime) {
13940        0 !== (lanes & 127) && (blockingClampTime = finalizationTime);
13941        0 !== (lanes & 4194048) && (transitionClampTime = finalizationTime);
13942        0 !== (lanes & 62914560) && (retryClampTime = finalizationTime);
13943        0 !== (lanes & 2080374784) && (idleClampTime = finalizationTime);
13944      }
13945      function prepareFreshStack(root3, lanes) {
13946        supportsUserTiming && (console.timeStamp(
13947          "Blocking Track",
13948          3e-3,
13949          3e-3,
13950          "Blocking",
13951          LANES_TRACK_GROUP,
13952          "primary-light"
13953        ), console.timeStamp(
13954          "Transition Track",
13955          3e-3,
13956          3e-3,
13957          "Transition",
13958          LANES_TRACK_GROUP,
13959          "primary-light"
13960        ), console.timeStamp(
13961          "Suspense Track",
13962          3e-3,
13963          3e-3,
13964          "Suspense",
13965          LANES_TRACK_GROUP,
13966          "primary-light"
13967        ), console.timeStamp(
13968          "Idle Track",
13969          3e-3,
13970          3e-3,
13971          "Idle",
13972          LANES_TRACK_GROUP,
13973          "primary-light"
13974        ));
13975        var previousRenderStartTime = renderStartTime;
13976        renderStartTime = now3();
13977        if (0 !== workInProgressRootRenderLanes && 0 < previousRenderStartTime) {
13978          setCurrentTrackFromLanes(workInProgressRootRenderLanes);
13979          if (workInProgressRootExitStatus === RootSuspended || workInProgressRootExitStatus === RootSuspendedWithDelay)
13980            logSuspendedRenderPhase(
13981              previousRenderStartTime,
13982              renderStartTime,
13983              lanes,
13984              workInProgressUpdateTask
13985            );
13986          else {
13987            var endTime = renderStartTime, debugTask = workInProgressUpdateTask;
13988            if (supportsUserTiming && !(endTime <= previousRenderStartTime)) {
13989              var color = (lanes & 738197653) === lanes ? "tertiary-dark" : "primary-dark", label = (lanes & 536870912) === lanes ? "Prewarm" : (lanes & 201326741) === lanes ? "Interrupted Hydration" : "Interrupted Render";
13990              debugTask ? debugTask.run(
13991                console.timeStamp.bind(
13992                  console,
13993                  label,
13994                  previousRenderStartTime,
13995                  endTime,
13996                  currentTrack,
13997                  LANES_TRACK_GROUP,
13998                  color
13999                )
14000              ) : console.timeStamp(
14001                label,
14002                previousRenderStartTime,
14003                endTime,
14004                currentTrack,
14005                LANES_TRACK_GROUP,
14006                color
14007              );
14008            }
14009          }
14010          finalizeRender(workInProgressRootRenderLanes, renderStartTime);
14011        }
14012        previousRenderStartTime = workInProgressUpdateTask;
14013        workInProgressUpdateTask = null;
14014        if (0 !== (lanes & 127)) {
14015          workInProgressUpdateTask = blockingUpdateTask;
14016          debugTask = 0 <= blockingUpdateTime && blockingUpdateTime < blockingClampTime ? blockingClampTime : blockingUpdateTime;
14017          endTime = 0 <= blockingEventTime && blockingEventTime < blockingClampTime ? blockingClampTime : blockingEventTime;
14018          color = 0 <= endTime ? endTime : 0 <= debugTask ? debugTask : renderStartTime;
14019          0 <= blockingSuspendedTime ? (setCurrentTrackFromLanes(2), logSuspendedWithDelayPhase(
14020            blockingSuspendedTime,
14021            color,
14022            lanes,
14023            previousRenderStartTime
14024          )) : 0 !== (animatingLanes & 127) && (setCurrentTrackFromLanes(2), logAnimatingPhase(blockingClampTime, color, animatingTask));
14025          previousRenderStartTime = debugTask;
14026          var eventTime = endTime, eventType = blockingEventType, eventIsRepeat = 0 < blockingEventRepeatTime, isSpawnedUpdate = blockingUpdateType === SPAWNED_UPDATE, isPingedUpdate = blockingUpdateType === PINGED_UPDATE;
14027          debugTask = renderStartTime;
14028          endTime = blockingUpdateTask;
14029          color = blockingUpdateMethodName;
14030          label = blockingUpdateComponentName;
14031          if (supportsUserTiming) {
14032            currentTrack = "Blocking";
14033            0 < previousRenderStartTime ? previousRenderStartTime > debugTask && (previousRenderStartTime = debugTask) : previousRenderStartTime = debugTask;
14034            0 < eventTime ? eventTime > previousRenderStartTime && (eventTime = previousRenderStartTime) : eventTime = previousRenderStartTime;
14035            if (null !== eventType && previousRenderStartTime > eventTime) {
14036              var color$jscomp$0 = eventIsRepeat ? "secondary-light" : "warning";
14037              endTime ? endTime.run(
14038                console.timeStamp.bind(
14039                  console,
14040                  eventIsRepeat ? "Consecutive" : "Event: " + eventType,
14041                  eventTime,
14042                  previousRenderStartTime,
14043                  currentTrack,
14044                  LANES_TRACK_GROUP,
14045                  color$jscomp$0
14046                )
14047              ) : console.timeStamp(
14048                eventIsRepeat ? "Consecutive" : "Event: " + eventType,
14049                eventTime,
14050                previousRenderStartTime,
14051                currentTrack,
14052                LANES_TRACK_GROUP,
14053                color$jscomp$0
14054              );
14055            }
14056            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 = {
14057              start: previousRenderStartTime,
14058              end: debugTask,
14059              detail: {
14060                devtools: {
14061                  properties: isPingedUpdate,
14062                  track: currentTrack,
14063                  trackGroup: LANES_TRACK_GROUP,
14064                  color: eventTime
14065                }
14066              }
14067            }, endTime ? endTime.run(
14068              performance.measure.bind(
14069                performance,
14070                isSpawnedUpdate,
14071                previousRenderStartTime
14072              )
14073            ) : performance.measure(isSpawnedUpdate, previousRenderStartTime));
14074          }
14075          blockingUpdateTime = -1.1;
14076          blockingUpdateType = 0;
14077          blockingUpdateComponentName = blockingUpdateMethodName = null;
14078          blockingSuspendedTime = -1.1;
14079          blockingEventRepeatTime = blockingEventTime;
14080          blockingEventTime = -1.1;
14081          blockingClampTime = now3();
14082        }
14083        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(
14084          transitionSuspendedTime,
14085          color,
14086          lanes,
14087          workInProgressUpdateTask
14088        )) : 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(
14089          console.timeStamp.bind(
14090            console,
14091            eventType ? "Consecutive" : "Event: " + eventTime,
14092            isPingedUpdate,
14093            debugTask,
14094            currentTrack,
14095            LANES_TRACK_GROUP,
14096            color$jscomp$0
14097          )
14098        ) : console.timeStamp(
14099          eventType ? "Consecutive" : "Event: " + eventTime,
14100          isPingedUpdate,
14101          debugTask,
14102          currentTrack,
14103          LANES_TRACK_GROUP,
14104          color$jscomp$0
14105        )), previousRenderStartTime > debugTask && (endTime ? endTime.run(
14106          console.timeStamp.bind(
14107            console,
14108            "Action",
14109            debugTask,
14110            previousRenderStartTime,
14111            currentTrack,
14112            LANES_TRACK_GROUP,
14113            "primary-dark"
14114          )
14115        ) : console.timeStamp(
14116          "Action",
14117          debugTask,
14118          previousRenderStartTime,
14119          currentTrack,
14120          LANES_TRACK_GROUP,
14121          "primary-dark"
14122        )), 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 = {
14123          start: previousRenderStartTime,
14124          end: color,
14125          detail: {
14126            devtools: {
14127              properties: isPingedUpdate,
14128              track: currentTrack,
14129              trackGroup: LANES_TRACK_GROUP,
14130              color: "primary-light"
14131            }
14132          }
14133        }, endTime ? endTime.run(
14134          performance.measure.bind(
14135            performance,
14136            debugTask,
14137            previousRenderStartTime
14138          )
14139        ) : performance.measure(debugTask, previousRenderStartTime))), transitionUpdateTime = transitionStartTime = -1.1, transitionUpdateType = 0, transitionSuspendedTime = -1.1, transitionEventRepeatTime = transitionEventTime, transitionEventTime = -1.1, transitionClampTime = now3());
14140        0 !== (lanes & 62914560) && 0 !== (animatingLanes & 62914560) && (setCurrentTrackFromLanes(4194304), logAnimatingPhase(retryClampTime, renderStartTime, animatingTask));
14141        0 !== (lanes & 2080374784) && 0 !== (animatingLanes & 2080374784) && (setCurrentTrackFromLanes(268435456), logAnimatingPhase(idleClampTime, renderStartTime, animatingTask));
14142        previousRenderStartTime = root3.timeoutHandle;
14143        previousRenderStartTime !== noTimeout && (root3.timeoutHandle = noTimeout, cancelTimeout(previousRenderStartTime));
14144        previousRenderStartTime = root3.cancelPendingCommit;
14145        null !== previousRenderStartTime && (root3.cancelPendingCommit = null, previousRenderStartTime());
14146        pendingEffectsLanes = 0;
14147        resetWorkInProgressStack();
14148        workInProgressRoot = root3;
14149        workInProgress = previousRenderStartTime = createWorkInProgress(
14150          root3.current,
14151          null
14152        );
14153        workInProgressRootRenderLanes = lanes;
14154        workInProgressSuspendedReason = NotSuspended;
14155        workInProgressThrownValue = null;
14156        workInProgressRootDidSkipSuspendedSiblings = false;
14157        workInProgressRootIsPrerendering = checkIfRootIsPrerendering(root3, lanes);
14158        workInProgressRootDidAttachPingListener = false;
14159        workInProgressRootExitStatus = RootInProgress;
14160        workInProgressSuspendedRetryLanes = workInProgressDeferredLane = workInProgressRootPingedLanes = workInProgressRootInterleavedUpdatedLanes = workInProgressRootSkippedLanes = 0;
14161        workInProgressRootRecoverableErrors = workInProgressRootConcurrentErrors = null;
14162        workInProgressRootDidIncludeRecursiveRenderUpdate = false;
14163        0 !== (lanes & 8) && (lanes |= lanes & 32);
14164        endTime = root3.entangledLanes;
14165        if (0 !== endTime)
14166          for (root3 = root3.entanglements, endTime &= lanes; 0 < endTime; )
14167            debugTask = 31 - clz32(endTime), color = 1 << debugTask, lanes |= root3[debugTask], endTime &= ~color;
14168        entangledRenderLanes = lanes;
14169        finishQueueingConcurrentUpdates();
14170        root3 = getCurrentTime();
14171        1e3 < root3 - lastResetTime && (ReactSharedInternals.recentlyCreatedOwnerStacks = 0, lastResetTime = root3);
14172        ReactStrictModeWarnings.discardPendingWarnings();
14173        return previousRenderStartTime;
14174      }
14175      function handleThrow(root3, thrownValue) {
14176        currentlyRenderingFiber = null;
14177        ReactSharedInternals.H = ContextOnlyDispatcher;
14178        ReactSharedInternals.getCurrentStack = null;
14179        isRendering = false;
14180        current = null;
14181        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;
14182        workInProgressThrownValue = thrownValue;
14183        var erroredWork = workInProgress;
14184        null === erroredWork ? (workInProgressRootExitStatus = RootFatalErrored, logUncaughtError(
14185          root3,
14186          createCapturedValueAtFiber(thrownValue, root3.current)
14187        )) : erroredWork.mode & ProfileMode && stopProfilerTimerIfRunningAndRecordDuration(erroredWork);
14188      }
14189      function shouldRemainOnPreviousScreen() {
14190        var handler = suspenseHandlerStackCursor.current;
14191        return null === handler ? true : (workInProgressRootRenderLanes & 4194048) === workInProgressRootRenderLanes ? null === shellBoundary ? true : false : (workInProgressRootRenderLanes & 62914560) === workInProgressRootRenderLanes || 0 !== (workInProgressRootRenderLanes & 536870912) ? handler === shellBoundary : false;
14192      }
14193      function pushDispatcher() {
14194        var prevDispatcher = ReactSharedInternals.H;
14195        ReactSharedInternals.H = ContextOnlyDispatcher;
14196        return null === prevDispatcher ? ContextOnlyDispatcher : prevDispatcher;
14197      }
14198      function pushAsyncDispatcher() {
14199        var prevAsyncDispatcher = ReactSharedInternals.A;
14200        ReactSharedInternals.A = DefaultAsyncDispatcher;
14201        return prevAsyncDispatcher;
14202      }
14203      function markRenderDerivedCause(fiber) {
14204        null === workInProgressUpdateTask && (workInProgressUpdateTask = null == fiber._debugTask ? null : fiber._debugTask);
14205      }
14206      function renderDidSuspendDelayIfPossible() {
14207        workInProgressRootExitStatus = RootSuspendedWithDelay;
14208        workInProgressRootDidSkipSuspendedSiblings || (workInProgressRootRenderLanes & 4194048) !== workInProgressRootRenderLanes && null !== suspenseHandlerStackCursor.current || (workInProgressRootIsPrerendering = true);
14209        0 === (workInProgressRootSkippedLanes & 134217727) && 0 === (workInProgressRootInterleavedUpdatedLanes & 134217727) || null === workInProgressRoot || markRootSuspended(
14210          workInProgressRoot,
14211          workInProgressRootRenderLanes,
14212          workInProgressDeferredLane,
14213          false
14214        );
14215      }
14216      function renderRootSync(root3, lanes, shouldYieldForPrerendering) {
14217        var prevExecutionContext = executionContext;
14218        executionContext |= RenderContext;
14219        var prevDispatcher = pushDispatcher(), prevAsyncDispatcher = pushAsyncDispatcher();
14220        if (workInProgressRoot !== root3 || workInProgressRootRenderLanes !== lanes) {
14221          if (isDevToolsPresent) {
14222            var memoizedUpdaters = root3.memoizedUpdaters;
14223            0 < memoizedUpdaters.size && (restorePendingUpdaters(root3, workInProgressRootRenderLanes), memoizedUpdaters.clear());
14224            movePendingFibersToMemoized(root3, lanes);
14225          }
14226          workInProgressTransitions = null;
14227          prepareFreshStack(root3, lanes);
14228        }
14229        lanes = false;
14230        memoizedUpdaters = workInProgressRootExitStatus;
14231        a: do
14232          try {
14233            if (workInProgressSuspendedReason !== NotSuspended && null !== workInProgress) {
14234              var unitOfWork = workInProgress, thrownValue = workInProgressThrownValue;
14235              switch (workInProgressSuspendedReason) {
14236                case SuspendedOnHydration:
14237                  resetWorkInProgressStack();
14238                  memoizedUpdaters = RootSuspendedAtTheShell;
14239                  break a;
14240                case SuspendedOnImmediate:
14241                case SuspendedOnData:
14242                case SuspendedOnAction:
14243                case SuspendedOnDeprecatedThrowPromise:
14244                  null === suspenseHandlerStackCursor.current && (lanes = true);
14245                  var reason = workInProgressSuspendedReason;
14246                  workInProgressSuspendedReason = NotSuspended;
14247                  workInProgressThrownValue = null;
14248                  throwAndUnwindWorkLoop(root3, unitOfWork, thrownValue, reason);
14249                  if (shouldYieldForPrerendering && workInProgressRootIsPrerendering) {
14250                    memoizedUpdaters = RootInProgress;
14251                    break a;
14252                  }
14253                  break;
14254                default:
14255                  reason = workInProgressSuspendedReason, workInProgressSuspendedReason = NotSuspended, workInProgressThrownValue = null, throwAndUnwindWorkLoop(root3, unitOfWork, thrownValue, reason);
14256              }
14257            }
14258            workLoopSync();
14259            memoizedUpdaters = workInProgressRootExitStatus;
14260            break;
14261          } catch (thrownValue$8) {
14262            handleThrow(root3, thrownValue$8);
14263          }
14264        while (1);
14265        lanes && root3.shellSuspendCounter++;
14266        resetContextDependencies();
14267        executionContext = prevExecutionContext;
14268        ReactSharedInternals.H = prevDispatcher;
14269        ReactSharedInternals.A = prevAsyncDispatcher;
14270        null === workInProgress && (workInProgressRoot = null, workInProgressRootRenderLanes = 0, finishQueueingConcurrentUpdates());
14271        return memoizedUpdaters;
14272      }
14273      function workLoopSync() {
14274        for (; null !== workInProgress; ) performUnitOfWork(workInProgress);
14275      }
14276      function renderRootConcurrent(root3, lanes) {
14277        var prevExecutionContext = executionContext;
14278        executionContext |= RenderContext;
14279        var prevDispatcher = pushDispatcher(), prevAsyncDispatcher = pushAsyncDispatcher();
14280        if (workInProgressRoot !== root3 || workInProgressRootRenderLanes !== lanes) {
14281          if (isDevToolsPresent) {
14282            var memoizedUpdaters = root3.memoizedUpdaters;
14283            0 < memoizedUpdaters.size && (restorePendingUpdaters(root3, workInProgressRootRenderLanes), memoizedUpdaters.clear());
14284            movePendingFibersToMemoized(root3, lanes);
14285          }
14286          workInProgressTransitions = null;
14287          workInProgressRootRenderTargetTime = now$1() + RENDER_TIMEOUT_MS;
14288          prepareFreshStack(root3, lanes);
14289        } else
14290          workInProgressRootIsPrerendering = checkIfRootIsPrerendering(
14291            root3,
14292            lanes
14293          );
14294        a: do
14295          try {
14296            if (workInProgressSuspendedReason !== NotSuspended && null !== workInProgress)
14297              b: switch (lanes = workInProgress, memoizedUpdaters = workInProgressThrownValue, workInProgressSuspendedReason) {
14298                case SuspendedOnError:
14299                  workInProgressSuspendedReason = NotSuspended;
14300                  workInProgressThrownValue = null;
14301                  throwAndUnwindWorkLoop(
14302                    root3,
14303                    lanes,
14304                    memoizedUpdaters,
14305                    SuspendedOnError
14306                  );
14307                  break;
14308                case SuspendedOnData:
14309                case SuspendedOnAction:
14310                  if (isThenableResolved(memoizedUpdaters)) {
14311                    workInProgressSuspendedReason = NotSuspended;
14312                    workInProgressThrownValue = null;
14313                    replaySuspendedUnitOfWork(lanes);
14314                    break;
14315                  }
14316                  lanes = function() {
14317                    workInProgressSuspendedReason !== SuspendedOnData && workInProgressSuspendedReason !== SuspendedOnAction || workInProgressRoot !== root3 || (workInProgressSuspendedReason = SuspendedAndReadyToContinue);
14318                    ensureRootIsScheduled(root3);
14319                  };
14320                  memoizedUpdaters.then(lanes, lanes);
14321                  break a;
14322                case SuspendedOnImmediate:
14323                  workInProgressSuspendedReason = SuspendedAndReadyToContinue;
14324                  break a;
14325                case SuspendedOnInstance:
14326                  workInProgressSuspendedReason = SuspendedOnInstanceAndReadyToContinue;
14327                  break a;
14328                case SuspendedAndReadyToContinue:
14329                  isThenableResolved(memoizedUpdaters) ? (workInProgressSuspendedReason = NotSuspended, workInProgressThrownValue = null, replaySuspendedUnitOfWork(lanes)) : (workInProgressSuspendedReason = NotSuspended, workInProgressThrownValue = null, throwAndUnwindWorkLoop(
14330                    root3,
14331                    lanes,
14332                    memoizedUpdaters,
14333                    SuspendedAndReadyToContinue
14334                  ));
14335                  break;
14336                case SuspendedOnInstanceAndReadyToContinue:
14337                  var resource = null;
14338                  switch (workInProgress.tag) {
14339                    case 26:
14340                      resource = workInProgress.memoizedState;
14341                    case 5:
14342                    case 27:
14343                      var hostFiber = workInProgress;
14344                      if (resource ? preloadResource(resource) : hostFiber.stateNode.complete) {
14345                        workInProgressSuspendedReason = NotSuspended;
14346                        workInProgressThrownValue = null;
14347                        var sibling = hostFiber.sibling;
14348                        if (null !== sibling) workInProgress = sibling;
14349                        else {
14350                          var returnFiber = hostFiber.return;
14351                          null !== returnFiber ? (workInProgress = returnFiber, completeUnitOfWork(returnFiber)) : workInProgress = null;
14352                        }
14353                        break b;
14354                      }
14355                      break;
14356                    default:
14357                      console.error(
14358                        "Unexpected type of fiber triggered a suspensey commit. This is a bug in React."
14359                      );
14360                  }
14361                  workInProgressSuspendedReason = NotSuspended;
14362                  workInProgressThrownValue = null;
14363                  throwAndUnwindWorkLoop(
14364                    root3,
14365                    lanes,
14366                    memoizedUpdaters,
14367                    SuspendedOnInstanceAndReadyToContinue
14368                  );
14369                  break;
14370                case SuspendedOnDeprecatedThrowPromise:
14371                  workInProgressSuspendedReason = NotSuspended;
14372                  workInProgressThrownValue = null;
14373                  throwAndUnwindWorkLoop(
14374                    root3,
14375                    lanes,
14376                    memoizedUpdaters,
14377                    SuspendedOnDeprecatedThrowPromise
14378                  );
14379                  break;
14380                case SuspendedOnHydration:
14381                  resetWorkInProgressStack();
14382                  workInProgressRootExitStatus = RootSuspendedAtTheShell;
14383                  break a;
14384                default:
14385                  throw Error(
14386                    "Unexpected SuspendedReason. This is a bug in React."
14387                  );
14388              }
14389            null !== ReactSharedInternals.actQueue ? workLoopSync() : workLoopConcurrentByScheduler();
14390            break;
14391          } catch (thrownValue$9) {
14392            handleThrow(root3, thrownValue$9);
14393          }
14394        while (1);
14395        resetContextDependencies();
14396        ReactSharedInternals.H = prevDispatcher;
14397        ReactSharedInternals.A = prevAsyncDispatcher;
14398        executionContext = prevExecutionContext;
14399        if (null !== workInProgress) return RootInProgress;
14400        workInProgressRoot = null;
14401        workInProgressRootRenderLanes = 0;
14402        finishQueueingConcurrentUpdates();
14403        return workInProgressRootExitStatus;
14404      }
14405      function workLoopConcurrentByScheduler() {
14406        for (; null !== workInProgress && !shouldYield(); )
14407          performUnitOfWork(workInProgress);
14408      }
14409      function performUnitOfWork(unitOfWork) {
14410        var current2 = unitOfWork.alternate;
14411        (unitOfWork.mode & ProfileMode) !== NoMode ? (startProfilerTimer(unitOfWork), current2 = runWithFiberInDEV(
14412          unitOfWork,
14413          beginWork,
14414          current2,
14415          unitOfWork,
14416          entangledRenderLanes
14417        ), stopProfilerTimerIfRunningAndRecordDuration(unitOfWork)) : current2 = runWithFiberInDEV(
14418          unitOfWork,
14419          beginWork,
14420          current2,
14421          unitOfWork,
14422          entangledRenderLanes
14423        );
14424        unitOfWork.memoizedProps = unitOfWork.pendingProps;
14425        null === current2 ? completeUnitOfWork(unitOfWork) : workInProgress = current2;
14426      }
14427      function replaySuspendedUnitOfWork(unitOfWork) {
14428        var next = runWithFiberInDEV(unitOfWork, replayBeginWork, unitOfWork);
14429        unitOfWork.memoizedProps = unitOfWork.pendingProps;
14430        null === next ? completeUnitOfWork(unitOfWork) : workInProgress = next;
14431      }
14432      function replayBeginWork(unitOfWork) {
14433        var current2 = unitOfWork.alternate, isProfilingMode = (unitOfWork.mode & ProfileMode) !== NoMode;
14434        isProfilingMode && startProfilerTimer(unitOfWork);
14435        switch (unitOfWork.tag) {
14436          case 15:
14437          case 0:
14438            current2 = replayFunctionComponent(
14439              current2,
14440              unitOfWork,
14441              unitOfWork.pendingProps,
14442              unitOfWork.type,
14443              void 0,
14444              workInProgressRootRenderLanes
14445            );
14446            break;
14447          case 11:
14448            current2 = replayFunctionComponent(
14449              current2,
14450              unitOfWork,
14451              unitOfWork.pendingProps,
14452              unitOfWork.type.render,
14453              unitOfWork.ref,
14454              workInProgressRootRenderLanes
14455            );
14456            break;
14457          case 5:
14458            resetHooksOnUnwind(unitOfWork);
14459          default:
14460            unwindInterruptedWork(current2, unitOfWork), unitOfWork = workInProgress = resetWorkInProgress(unitOfWork, entangledRenderLanes), current2 = beginWork(current2, unitOfWork, entangledRenderLanes);
14461        }
14462        isProfilingMode && stopProfilerTimerIfRunningAndRecordDuration(unitOfWork);
14463        return current2;
14464      }
14465      function throwAndUnwindWorkLoop(root3, unitOfWork, thrownValue, suspendedReason) {
14466        resetContextDependencies();
14467        resetHooksOnUnwind(unitOfWork);
14468        thenableState$1 = null;
14469        thenableIndexCounter$1 = 0;
14470        var returnFiber = unitOfWork.return;
14471        try {
14472          if (throwException(
14473            root3,
14474            returnFiber,
14475            unitOfWork,
14476            thrownValue,
14477            workInProgressRootRenderLanes
14478          )) {
14479            workInProgressRootExitStatus = RootFatalErrored;
14480            logUncaughtError(
14481              root3,
14482              createCapturedValueAtFiber(thrownValue, root3.current)
14483            );
14484            workInProgress = null;
14485            return;
14486          }
14487        } catch (error2) {
14488          if (null !== returnFiber) throw workInProgress = returnFiber, error2;
14489          workInProgressRootExitStatus = RootFatalErrored;
14490          logUncaughtError(
14491            root3,
14492            createCapturedValueAtFiber(thrownValue, root3.current)
14493          );
14494          workInProgress = null;
14495          return;
14496        }
14497        if (unitOfWork.flags & 32768) {
14498          if (isHydrating || suspendedReason === SuspendedOnError) root3 = true;
14499          else if (workInProgressRootIsPrerendering || 0 !== (workInProgressRootRenderLanes & 536870912))
14500            root3 = false;
14501          else if (workInProgressRootDidSkipSuspendedSiblings = root3 = true, suspendedReason === SuspendedOnData || suspendedReason === SuspendedOnAction || suspendedReason === SuspendedOnImmediate || suspendedReason === SuspendedOnDeprecatedThrowPromise)
14502            suspendedReason = suspenseHandlerStackCursor.current, null !== suspendedReason && 13 === suspendedReason.tag && (suspendedReason.flags |= 16384);
14503          unwindUnitOfWork(unitOfWork, root3);
14504        } else completeUnitOfWork(unitOfWork);
14505      }
14506      function completeUnitOfWork(unitOfWork) {
14507        var completedWork = unitOfWork;
14508        do {
14509          if (0 !== (completedWork.flags & 32768)) {
14510            unwindUnitOfWork(
14511              completedWork,
14512              workInProgressRootDidSkipSuspendedSiblings
14513            );
14514            return;
14515          }
14516          var current2 = completedWork.alternate;
14517          unitOfWork = completedWork.return;
14518          startProfilerTimer(completedWork);
14519          current2 = runWithFiberInDEV(
14520            completedWork,
14521            completeWork,
14522            current2,
14523            completedWork,
14524            entangledRenderLanes
14525          );
14526          (completedWork.mode & ProfileMode) !== NoMode && stopProfilerTimerIfRunningAndRecordIncompleteDuration(completedWork);
14527          if (null !== current2) {
14528            workInProgress = current2;
14529            return;
14530          }
14531          completedWork = completedWork.sibling;
14532          if (null !== completedWork) {
14533            workInProgress = completedWork;
14534            return;
14535          }
14536          workInProgress = completedWork = unitOfWork;
14537        } while (null !== completedWork);
14538        workInProgressRootExitStatus === RootInProgress && (workInProgressRootExitStatus = RootCompleted);
14539      }
14540      function unwindUnitOfWork(unitOfWork, skipSiblings) {
14541        do {
14542          var next = unwindWork(unitOfWork.alternate, unitOfWork);
14543          if (null !== next) {
14544            next.flags &= 32767;
14545            workInProgress = next;
14546            return;
14547          }
14548          if ((unitOfWork.mode & ProfileMode) !== NoMode) {
14549            stopProfilerTimerIfRunningAndRecordIncompleteDuration(unitOfWork);
14550            next = unitOfWork.actualDuration;
14551            for (var child = unitOfWork.child; null !== child; )
14552              next += child.actualDuration, child = child.sibling;
14553            unitOfWork.actualDuration = next;
14554          }
14555          next = unitOfWork.return;
14556          null !== next && (next.flags |= 32768, next.subtreeFlags = 0, next.deletions = null);
14557          if (!skipSiblings && (unitOfWork = unitOfWork.sibling, null !== unitOfWork)) {
14558            workInProgress = unitOfWork;
14559            return;
14560          }
14561          workInProgress = unitOfWork = next;
14562        } while (null !== unitOfWork);
14563        workInProgressRootExitStatus = RootSuspendedAtTheShell;
14564        workInProgress = null;
14565      }
14566      function commitRoot(root3, finishedWork, lanes, recoverableErrors, transitions, didIncludeRenderPhaseUpdate, spawnedLane, updatedLanes, suspendedRetryLanes, exitStatus, suspendedState, suspendedCommitReason, completedRenderStartTime, completedRenderEndTime) {
14567        root3.cancelPendingCommit = null;
14568        do
14569          flushPendingEffects();
14570        while (pendingEffectsStatus !== NO_PENDING_EFFECTS);
14571        ReactStrictModeWarnings.flushLegacyContextWarning();
14572        ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings();
14573        if ((executionContext & (RenderContext | CommitContext)) !== NoContext)
14574          throw Error("Should not already be working.");
14575        setCurrentTrackFromLanes(lanes);
14576        exitStatus === RootErrored ? logErroredRenderPhase(
14577          completedRenderStartTime,
14578          completedRenderEndTime,
14579          lanes,
14580          workInProgressUpdateTask
14581        ) : null !== recoverableErrors ? logRecoveredRenderPhase(
14582          completedRenderStartTime,
14583          completedRenderEndTime,
14584          lanes,
14585          recoverableErrors,
14586          null !== finishedWork && null !== finishedWork.alternate && finishedWork.alternate.memoizedState.isDehydrated && 0 !== (finishedWork.flags & 256),
14587          workInProgressUpdateTask
14588        ) : logRenderPhase(
14589          completedRenderStartTime,
14590          completedRenderEndTime,
14591          lanes,
14592          workInProgressUpdateTask
14593        );
14594        if (null !== finishedWork) {
14595          0 === lanes && console.error(
14596            "finishedLanes should not be empty during a commit. This is a bug in React."
14597          );
14598          if (finishedWork === root3.current)
14599            throw Error(
14600              "Cannot commit the same tree as before. This error is likely caused by a bug in React. Please file an issue."
14601            );
14602          didIncludeRenderPhaseUpdate = finishedWork.lanes | finishedWork.childLanes;
14603          didIncludeRenderPhaseUpdate |= concurrentlyUpdatedLanes;
14604          markRootFinished(
14605            root3,
14606            lanes,
14607            didIncludeRenderPhaseUpdate,
14608            spawnedLane,
14609            updatedLanes,
14610            suspendedRetryLanes
14611          );
14612          root3 === workInProgressRoot && (workInProgress = workInProgressRoot = null, workInProgressRootRenderLanes = 0);
14613          pendingFinishedWork = finishedWork;
14614          pendingEffectsRoot = root3;
14615          pendingEffectsLanes = lanes;
14616          pendingEffectsRemainingLanes = didIncludeRenderPhaseUpdate;
14617          pendingPassiveTransitions = transitions;
14618          pendingRecoverableErrors = recoverableErrors;
14619          pendingEffectsRenderEndTime = completedRenderEndTime;
14620          pendingSuspendedCommitReason = suspendedCommitReason;
14621          pendingDelayedCommitReason = IMMEDIATE_COMMIT;
14622          pendingSuspendedViewTransitionReason = null;
14623          0 !== finishedWork.actualDuration || 0 !== (finishedWork.subtreeFlags & 10256) || 0 !== (finishedWork.flags & 10256) ? (root3.callbackNode = null, root3.callbackPriority = 0, scheduleCallback$1(NormalPriority$1, function() {
14624            schedulerEvent = window.event;
14625            pendingDelayedCommitReason === IMMEDIATE_COMMIT && (pendingDelayedCommitReason = DELAYED_PASSIVE_COMMIT);
14626            flushPassiveEffects();
14627            return null;
14628          })) : (root3.callbackNode = null, root3.callbackPriority = 0);
14629          commitErrors = null;
14630          commitStartTime = now3();
14631          null !== suspendedCommitReason && logSuspendedCommitPhase(
14632            completedRenderEndTime,
14633            commitStartTime,
14634            suspendedCommitReason,
14635            workInProgressUpdateTask
14636          );
14637          recoverableErrors = 0 !== (finishedWork.flags & 13878);
14638          if (0 !== (finishedWork.subtreeFlags & 13878) || recoverableErrors) {
14639            recoverableErrors = ReactSharedInternals.T;
14640            ReactSharedInternals.T = null;
14641            transitions = ReactDOMSharedInternals.p;
14642            ReactDOMSharedInternals.p = DiscreteEventPriority;
14643            spawnedLane = executionContext;
14644            executionContext |= CommitContext;
14645            try {
14646              commitBeforeMutationEffects(root3, finishedWork, lanes);
14647            } finally {
14648              executionContext = spawnedLane, ReactDOMSharedInternals.p = transitions, ReactSharedInternals.T = recoverableErrors;
14649            }
14650          }
14651          pendingEffectsStatus = PENDING_MUTATION_PHASE;
14652          flushMutationEffects();
14653          flushLayoutEffects();
14654          flushSpawnedWork();
14655        }
14656      }
14657      function flushMutationEffects() {
14658        if (pendingEffectsStatus === PENDING_MUTATION_PHASE) {
14659          pendingEffectsStatus = NO_PENDING_EFFECTS;
14660          var root3 = pendingEffectsRoot, finishedWork = pendingFinishedWork, lanes = pendingEffectsLanes, rootMutationHasEffect = 0 !== (finishedWork.flags & 13878);
14661          if (0 !== (finishedWork.subtreeFlags & 13878) || rootMutationHasEffect) {
14662            rootMutationHasEffect = ReactSharedInternals.T;
14663            ReactSharedInternals.T = null;
14664            var previousPriority = ReactDOMSharedInternals.p;
14665            ReactDOMSharedInternals.p = DiscreteEventPriority;
14666            var prevExecutionContext = executionContext;
14667            executionContext |= CommitContext;
14668            try {
14669              inProgressLanes = lanes;
14670              inProgressRoot = root3;
14671              resetComponentEffectTimers();
14672              commitMutationEffectsOnFiber(finishedWork, root3);
14673              inProgressRoot = inProgressLanes = null;
14674              lanes = selectionInformation;
14675              var curFocusedElem = getActiveElementDeep(root3.containerInfo), priorFocusedElem = lanes.focusedElem, priorSelectionRange = lanes.selectionRange;
14676              if (curFocusedElem !== priorFocusedElem && priorFocusedElem && priorFocusedElem.ownerDocument && containsNode(
14677                priorFocusedElem.ownerDocument.documentElement,
14678                priorFocusedElem
14679              )) {
14680                if (null !== priorSelectionRange && hasSelectionCapabilities(priorFocusedElem)) {
14681                  var start2 = priorSelectionRange.start, end = priorSelectionRange.end;
14682                  void 0 === end && (end = start2);
14683                  if ("selectionStart" in priorFocusedElem)
14684                    priorFocusedElem.selectionStart = start2, priorFocusedElem.selectionEnd = Math.min(
14685                      end,
14686                      priorFocusedElem.value.length
14687                    );
14688                  else {
14689                    var doc = priorFocusedElem.ownerDocument || document, win = doc && doc.defaultView || window;
14690                    if (win.getSelection) {
14691                      var selection = win.getSelection(), length = priorFocusedElem.textContent.length, start$jscomp$0 = Math.min(
14692                        priorSelectionRange.start,
14693                        length
14694                      ), end$jscomp$0 = void 0 === priorSelectionRange.end ? start$jscomp$0 : Math.min(priorSelectionRange.end, length);
14695                      !selection.extend && start$jscomp$0 > end$jscomp$0 && (curFocusedElem = end$jscomp$0, end$jscomp$0 = start$jscomp$0, start$jscomp$0 = curFocusedElem);
14696                      var startMarker = getNodeForCharacterOffset(
14697                        priorFocusedElem,
14698                        start$jscomp$0
14699                      ), endMarker = getNodeForCharacterOffset(
14700                        priorFocusedElem,
14701                        end$jscomp$0
14702                      );
14703                      if (startMarker && endMarker && (1 !== selection.rangeCount || selection.anchorNode !== startMarker.node || selection.anchorOffset !== startMarker.offset || selection.focusNode !== endMarker.node || selection.focusOffset !== endMarker.offset)) {
14704                        var range = doc.createRange();
14705                        range.setStart(startMarker.node, startMarker.offset);
14706                        selection.removeAllRanges();
14707                        start$jscomp$0 > end$jscomp$0 ? (selection.addRange(range), selection.extend(endMarker.node, endMarker.offset)) : (range.setEnd(endMarker.node, endMarker.offset), selection.addRange(range));
14708                      }
14709                    }
14710                  }
14711                }
14712                doc = [];
14713                for (selection = priorFocusedElem; selection = selection.parentNode; )
14714                  1 === selection.nodeType && doc.push({
14715                    element: selection,
14716                    left: selection.scrollLeft,
14717                    top: selection.scrollTop
14718                  });
14719                "function" === typeof priorFocusedElem.focus && priorFocusedElem.focus();
14720                for (priorFocusedElem = 0; priorFocusedElem < doc.length; priorFocusedElem++) {
14721                  var info = doc[priorFocusedElem];
14722                  info.element.scrollLeft = info.left;
14723                  info.element.scrollTop = info.top;
14724                }
14725              }
14726              _enabled = !!eventsEnabled;
14727              selectionInformation = eventsEnabled = null;
14728            } finally {
14729              executionContext = prevExecutionContext, ReactDOMSharedInternals.p = previousPriority, ReactSharedInternals.T = rootMutationHasEffect;
14730            }
14731          }
14732          root3.current = finishedWork;
14733          pendingEffectsStatus = PENDING_LAYOUT_PHASE;
14734        }
14735      }
14736      function flushLayoutEffects() {
14737        if (pendingEffectsStatus === PENDING_LAYOUT_PHASE) {
14738          pendingEffectsStatus = NO_PENDING_EFFECTS;
14739          var suspendedViewTransitionReason = pendingSuspendedViewTransitionReason;
14740          if (null !== suspendedViewTransitionReason) {
14741            commitStartTime = now3();
14742            var startTime = commitEndTime, endTime = commitStartTime;
14743            !supportsUserTiming || endTime <= startTime || (animatingTask ? animatingTask.run(
14744              console.timeStamp.bind(
14745                console,
14746                suspendedViewTransitionReason,
14747                startTime,
14748                endTime,
14749                currentTrack,
14750                LANES_TRACK_GROUP,
14751                "secondary-light"
14752              )
14753            ) : console.timeStamp(
14754              suspendedViewTransitionReason,
14755              startTime,
14756              endTime,
14757              currentTrack,
14758              LANES_TRACK_GROUP,
14759              "secondary-light"
14760            ));
14761          }
14762          suspendedViewTransitionReason = pendingEffectsRoot;
14763          startTime = pendingFinishedWork;
14764          endTime = pendingEffectsLanes;
14765          var rootHasLayoutEffect = 0 !== (startTime.flags & 8772);
14766          if (0 !== (startTime.subtreeFlags & 8772) || rootHasLayoutEffect) {
14767            rootHasLayoutEffect = ReactSharedInternals.T;
14768            ReactSharedInternals.T = null;
14769            var _previousPriority = ReactDOMSharedInternals.p;
14770            ReactDOMSharedInternals.p = DiscreteEventPriority;
14771            var _prevExecutionContext = executionContext;
14772            executionContext |= CommitContext;
14773            try {
14774              inProgressLanes = endTime, inProgressRoot = suspendedViewTransitionReason, resetComponentEffectTimers(), commitLayoutEffectOnFiber(
14775                suspendedViewTransitionReason,
14776                startTime.alternate,
14777                startTime
14778              ), inProgressRoot = inProgressLanes = null;
14779            } finally {
14780              executionContext = _prevExecutionContext, ReactDOMSharedInternals.p = _previousPriority, ReactSharedInternals.T = rootHasLayoutEffect;
14781            }
14782          }
14783          suspendedViewTransitionReason = pendingEffectsRenderEndTime;
14784          startTime = pendingSuspendedCommitReason;
14785          commitEndTime = now3();
14786          suspendedViewTransitionReason = null === startTime ? suspendedViewTransitionReason : commitStartTime;
14787          startTime = commitEndTime;
14788          endTime = pendingDelayedCommitReason === ABORTED_VIEW_TRANSITION_COMMIT;
14789          rootHasLayoutEffect = workInProgressUpdateTask;
14790          null !== commitErrors ? logCommitErrored(
14791            suspendedViewTransitionReason,
14792            startTime,
14793            commitErrors,
14794            false,
14795            rootHasLayoutEffect
14796          ) : !supportsUserTiming || startTime <= suspendedViewTransitionReason || (rootHasLayoutEffect ? rootHasLayoutEffect.run(
14797            console.timeStamp.bind(
14798              console,
14799              endTime ? "Commit Interrupted View Transition" : "Commit",
14800              suspendedViewTransitionReason,
14801              startTime,
14802              currentTrack,
14803              LANES_TRACK_GROUP,
14804              endTime ? "error" : "secondary-dark"
14805            )
14806          ) : console.timeStamp(
14807            endTime ? "Commit Interrupted View Transition" : "Commit",
14808            suspendedViewTransitionReason,
14809            startTime,
14810            currentTrack,
14811            LANES_TRACK_GROUP,
14812            endTime ? "error" : "secondary-dark"
14813          ));
14814          pendingEffectsStatus = PENDING_AFTER_MUTATION_PHASE;
14815        }
14816      }
14817      function flushSpawnedWork() {
14818        if (pendingEffectsStatus === PENDING_SPAWNED_WORK || pendingEffectsStatus === PENDING_AFTER_MUTATION_PHASE) {
14819          if (pendingEffectsStatus === PENDING_SPAWNED_WORK) {
14820            var startViewTransitionStartTime = commitEndTime;
14821            commitEndTime = now3();
14822            var endTime = commitEndTime, abortedViewTransition = pendingDelayedCommitReason === ABORTED_VIEW_TRANSITION_COMMIT;
14823            !supportsUserTiming || endTime <= startViewTransitionStartTime || (animatingTask ? animatingTask.run(
14824              console.timeStamp.bind(
14825                console,
14826                abortedViewTransition ? "Interrupted View Transition" : "Starting Animation",
14827                startViewTransitionStartTime,
14828                endTime,
14829                currentTrack,
14830                LANES_TRACK_GROUP,
14831                abortedViewTransition ? "error" : "secondary-light"
14832              )
14833            ) : console.timeStamp(
14834              abortedViewTransition ? "Interrupted View Transition" : "Starting Animation",
14835              startViewTransitionStartTime,
14836              endTime,
14837              currentTrack,
14838              LANES_TRACK_GROUP,
14839              abortedViewTransition ? " error" : "secondary-light"
14840            ));
14841            pendingDelayedCommitReason !== ABORTED_VIEW_TRANSITION_COMMIT && (pendingDelayedCommitReason = ANIMATION_STARTED_COMMIT);
14842          }
14843          pendingEffectsStatus = NO_PENDING_EFFECTS;
14844          requestPaint();
14845          startViewTransitionStartTime = pendingEffectsRoot;
14846          var finishedWork = pendingFinishedWork;
14847          endTime = pendingEffectsLanes;
14848          abortedViewTransition = pendingRecoverableErrors;
14849          var rootDidHavePassiveEffects = 0 !== finishedWork.actualDuration || 0 !== (finishedWork.subtreeFlags & 10256) || 0 !== (finishedWork.flags & 10256);
14850          rootDidHavePassiveEffects ? pendingEffectsStatus = PENDING_PASSIVE_PHASE : (pendingEffectsStatus = NO_PENDING_EFFECTS, pendingFinishedWork = pendingEffectsRoot = null, releaseRootPooledCache(
14851            startViewTransitionStartTime,
14852            startViewTransitionStartTime.pendingLanes
14853          ), nestedPassiveUpdateCount = 0, rootWithPassiveNestedUpdates = null);
14854          var remainingLanes = startViewTransitionStartTime.pendingLanes;
14855          0 === remainingLanes && (legacyErrorBoundariesThatAlreadyFailed = null);
14856          rootDidHavePassiveEffects || commitDoubleInvokeEffectsInDEV(startViewTransitionStartTime);
14857          remainingLanes = lanesToEventPriority(endTime);
14858          finishedWork = finishedWork.stateNode;
14859          if (injectedHook && "function" === typeof injectedHook.onCommitFiberRoot)
14860            try {
14861              var didError = 128 === (finishedWork.current.flags & 128);
14862              switch (remainingLanes) {
14863                case DiscreteEventPriority:
14864                  var schedulerPriority = ImmediatePriority;
14865                  break;
14866                case ContinuousEventPriority:
14867                  schedulerPriority = UserBlockingPriority;
14868                  break;
14869                case DefaultEventPriority:
14870                  schedulerPriority = NormalPriority$1;
14871                  break;
14872                case IdleEventPriority:
14873                  schedulerPriority = IdlePriority;
14874                  break;
14875                default:
14876                  schedulerPriority = NormalPriority$1;
14877              }
14878              injectedHook.onCommitFiberRoot(
14879                rendererID,
14880                finishedWork,
14881                schedulerPriority,
14882                didError
14883              );
14884            } catch (err) {
14885              hasLoggedError || (hasLoggedError = true, console.error(
14886                "React instrumentation encountered an error: %o",
14887                err
14888              ));
14889            }
14890          isDevToolsPresent && startViewTransitionStartTime.memoizedUpdaters.clear();
14891          onCommitRoot();
14892          if (null !== abortedViewTransition) {
14893            didError = ReactSharedInternals.T;
14894            schedulerPriority = ReactDOMSharedInternals.p;
14895            ReactDOMSharedInternals.p = DiscreteEventPriority;
14896            ReactSharedInternals.T = null;
14897            try {
14898              var onRecoverableError = startViewTransitionStartTime.onRecoverableError;
14899              for (finishedWork = 0; finishedWork < abortedViewTransition.length; finishedWork++) {
14900                var recoverableError = abortedViewTransition[finishedWork], errorInfo = makeErrorInfo(recoverableError.stack);
14901                runWithFiberInDEV(
14902                  recoverableError.source,
14903                  onRecoverableError,
14904                  recoverableError.value,
14905                  errorInfo
14906                );
14907              }
14908            } finally {
14909              ReactSharedInternals.T = didError, ReactDOMSharedInternals.p = schedulerPriority;
14910            }
14911          }
14912          0 !== (pendingEffectsLanes & 3) && flushPendingEffects();
14913          ensureRootIsScheduled(startViewTransitionStartTime);
14914          remainingLanes = startViewTransitionStartTime.pendingLanes;
14915          0 !== (endTime & 261930) && 0 !== (remainingLanes & 42) ? (nestedUpdateScheduled = true, startViewTransitionStartTime === rootWithNestedUpdates ? nestedUpdateCount++ : (nestedUpdateCount = 0, rootWithNestedUpdates = startViewTransitionStartTime)) : nestedUpdateCount = 0;
14916          rootDidHavePassiveEffects || finalizeRender(endTime, commitEndTime);
14917          flushSyncWorkAcrossRoots_impl(0, false);
14918        }
14919      }
14920      function makeErrorInfo(componentStack) {
14921        componentStack = { componentStack };
14922        Object.defineProperty(componentStack, "digest", {
14923          get: function() {
14924            console.error(
14925              '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.'
14926            );
14927          }
14928        });
14929        return componentStack;
14930      }
14931      function releaseRootPooledCache(root3, remainingLanes) {
14932        0 === (root3.pooledCacheLanes &= remainingLanes) && (remainingLanes = root3.pooledCache, null != remainingLanes && (root3.pooledCache = null, releaseCache(remainingLanes)));
14933      }
14934      function flushPendingEffects() {
14935        flushMutationEffects();
14936        flushLayoutEffects();
14937        flushSpawnedWork();
14938        return flushPassiveEffects();
14939      }
14940      function flushPassiveEffects() {
14941        if (pendingEffectsStatus !== PENDING_PASSIVE_PHASE) return false;
14942        var root3 = pendingEffectsRoot, remainingLanes = pendingEffectsRemainingLanes;
14943        pendingEffectsRemainingLanes = 0;
14944        var renderPriority = lanesToEventPriority(pendingEffectsLanes), priority = 0 === DefaultEventPriority || DefaultEventPriority > renderPriority ? DefaultEventPriority : renderPriority;
14945        renderPriority = ReactSharedInternals.T;
14946        var previousPriority = ReactDOMSharedInternals.p;
14947        try {
14948          ReactDOMSharedInternals.p = priority;
14949          ReactSharedInternals.T = null;
14950          var transitions = pendingPassiveTransitions;
14951          pendingPassiveTransitions = null;
14952          priority = pendingEffectsRoot;
14953          var lanes = pendingEffectsLanes;
14954          pendingEffectsStatus = NO_PENDING_EFFECTS;
14955          pendingFinishedWork = pendingEffectsRoot = null;
14956          pendingEffectsLanes = 0;
14957          if ((executionContext & (RenderContext | CommitContext)) !== NoContext)
14958            throw Error("Cannot flush passive effects while already rendering.");
14959          setCurrentTrackFromLanes(lanes);
14960          isFlushingPassiveEffects = true;
14961          didScheduleUpdateDuringPassiveEffects = false;
14962          var passiveEffectStartTime = 0;
14963          commitErrors = null;
14964          passiveEffectStartTime = now$1();
14965          if (pendingDelayedCommitReason === ANIMATION_STARTED_COMMIT)
14966            logAnimatingPhase(
14967              commitEndTime,
14968              passiveEffectStartTime,
14969              animatingTask
14970            );
14971          else {
14972            var startTime = commitEndTime, endTime = passiveEffectStartTime, delayedUntilPaint = pendingDelayedCommitReason === DELAYED_PASSIVE_COMMIT;
14973            !supportsUserTiming || endTime <= startTime || (workInProgressUpdateTask ? workInProgressUpdateTask.run(
14974              console.timeStamp.bind(
14975                console,
14976                delayedUntilPaint ? "Waiting for Paint" : "Waiting",
14977                startTime,
14978                endTime,
14979                currentTrack,
14980                LANES_TRACK_GROUP,
14981                "secondary-light"
14982              )
14983            ) : console.timeStamp(
14984              delayedUntilPaint ? "Waiting for Paint" : "Waiting",
14985              startTime,
14986              endTime,
14987              currentTrack,
14988              LANES_TRACK_GROUP,
14989              "secondary-light"
14990            ));
14991          }
14992          startTime = executionContext;
14993          executionContext |= CommitContext;
14994          var finishedWork = priority.current;
14995          resetComponentEffectTimers();
14996          commitPassiveUnmountOnFiber(finishedWork);
14997          var finishedWork$jscomp$0 = priority.current;
14998          finishedWork = pendingEffectsRenderEndTime;
14999          resetComponentEffectTimers();
15000          commitPassiveMountOnFiber(
15001            priority,
15002            finishedWork$jscomp$0,
15003            lanes,
15004            transitions,
15005            finishedWork
15006          );
15007          commitDoubleInvokeEffectsInDEV(priority);
15008          executionContext = startTime;
15009          var passiveEffectsEndTime = now$1();
15010          finishedWork$jscomp$0 = passiveEffectStartTime;
15011          finishedWork = workInProgressUpdateTask;
15012          null !== commitErrors ? logCommitErrored(
15013            finishedWork$jscomp$0,
15014            passiveEffectsEndTime,
15015            commitErrors,
15016            true,
15017            finishedWork
15018          ) : !supportsUserTiming || passiveEffectsEndTime <= finishedWork$jscomp$0 || (finishedWork ? finishedWork.run(
15019            console.timeStamp.bind(
15020              console,
15021              "Remaining Effects",
15022              finishedWork$jscomp$0,
15023              passiveEffectsEndTime,
15024              currentTrack,
15025              LANES_TRACK_GROUP,
15026              "secondary-dark"
15027            )
15028          ) : console.timeStamp(
15029            "Remaining Effects",
15030            finishedWork$jscomp$0,
15031            passiveEffectsEndTime,
15032            currentTrack,
15033            LANES_TRACK_GROUP,
15034            "secondary-dark"
15035          ));
15036          finalizeRender(lanes, passiveEffectsEndTime);
15037          flushSyncWorkAcrossRoots_impl(0, false);
15038          didScheduleUpdateDuringPassiveEffects ? priority === rootWithPassiveNestedUpdates ? nestedPassiveUpdateCount++ : (nestedPassiveUpdateCount = 0, rootWithPassiveNestedUpdates = priority) : nestedPassiveUpdateCount = 0;
15039          didScheduleUpdateDuringPassiveEffects = isFlushingPassiveEffects = false;
15040          if (injectedHook && "function" === typeof injectedHook.onPostCommitFiberRoot)
15041            try {
15042              injectedHook.onPostCommitFiberRoot(rendererID, priority);
15043            } catch (err) {
15044              hasLoggedError || (hasLoggedError = true, console.error(
15045                "React instrumentation encountered an error: %o",
15046                err
15047              ));
15048            }
15049          var stateNode = priority.current.stateNode;
15050          stateNode.effectDuration = 0;
15051          stateNode.passiveEffectDuration = 0;
15052          return true;
15053        } finally {
15054          ReactDOMSharedInternals.p = previousPriority, ReactSharedInternals.T = renderPriority, releaseRootPooledCache(root3, remainingLanes);
15055        }
15056      }
15057      function captureCommitPhaseErrorOnRoot(rootFiber, sourceFiber, error2) {
15058        sourceFiber = createCapturedValueAtFiber(error2, sourceFiber);
15059        recordEffectError(sourceFiber);
15060        sourceFiber = createRootErrorUpdate(rootFiber.stateNode, sourceFiber, 2);
15061        rootFiber = enqueueUpdate(rootFiber, sourceFiber, 2);
15062        null !== rootFiber && (markRootUpdated$1(rootFiber, 2), ensureRootIsScheduled(rootFiber));
15063      }
15064      function captureCommitPhaseError(sourceFiber, nearestMountedAncestor, error2) {
15065        isRunningInsertionEffect = false;
15066        if (3 === sourceFiber.tag)
15067          captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error2);
15068        else {
15069          for (; null !== nearestMountedAncestor; ) {
15070            if (3 === nearestMountedAncestor.tag) {
15071              captureCommitPhaseErrorOnRoot(
15072                nearestMountedAncestor,
15073                sourceFiber,
15074                error2
15075              );
15076              return;
15077            }
15078            if (1 === nearestMountedAncestor.tag) {
15079              var instance = nearestMountedAncestor.stateNode;
15080              if ("function" === typeof nearestMountedAncestor.type.getDerivedStateFromError || "function" === typeof instance.componentDidCatch && (null === legacyErrorBoundariesThatAlreadyFailed || !legacyErrorBoundariesThatAlreadyFailed.has(instance))) {
15081                sourceFiber = createCapturedValueAtFiber(error2, sourceFiber);
15082                recordEffectError(sourceFiber);
15083                error2 = createClassErrorUpdate(2);
15084                instance = enqueueUpdate(nearestMountedAncestor, error2, 2);
15085                null !== instance && (initializeClassErrorUpdate(
15086                  error2,
15087                  instance,
15088                  nearestMountedAncestor,
15089                  sourceFiber
15090                ), markRootUpdated$1(instance, 2), ensureRootIsScheduled(instance));
15091                return;
15092              }
15093            }
15094            nearestMountedAncestor = nearestMountedAncestor.return;
15095          }
15096          console.error(
15097            "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",
15098            error2
15099          );
15100        }
15101      }
15102      function attachPingListener(root3, wakeable, lanes) {
15103        var pingCache = root3.pingCache;
15104        if (null === pingCache) {
15105          pingCache = root3.pingCache = new PossiblyWeakMap();
15106          var threadIDs = /* @__PURE__ */ new Set();
15107          pingCache.set(wakeable, threadIDs);
15108        } else
15109          threadIDs = pingCache.get(wakeable), void 0 === threadIDs && (threadIDs = /* @__PURE__ */ new Set(), pingCache.set(wakeable, threadIDs));
15110        threadIDs.has(lanes) || (workInProgressRootDidAttachPingListener = true, threadIDs.add(lanes), pingCache = pingSuspendedRoot.bind(null, root3, wakeable, lanes), isDevToolsPresent && restorePendingUpdaters(root3, lanes), wakeable.then(pingCache, pingCache));
15111      }
15112      function pingSuspendedRoot(root3, wakeable, pingedLanes) {
15113        var pingCache = root3.pingCache;
15114        null !== pingCache && pingCache.delete(wakeable);
15115        root3.pingedLanes |= root3.suspendedLanes & pingedLanes;
15116        root3.warmLanes &= ~pingedLanes;
15117        0 !== (pingedLanes & 127) ? 0 > blockingUpdateTime && (blockingClampTime = blockingUpdateTime = now3(), blockingUpdateTask = createTask("Promise Resolved"), blockingUpdateType = PINGED_UPDATE) : 0 !== (pingedLanes & 4194048) && 0 > transitionUpdateTime && (transitionClampTime = transitionUpdateTime = now3(), transitionUpdateTask = createTask("Promise Resolved"), transitionUpdateType = PINGED_UPDATE);
15118        isConcurrentActEnvironment() && null === ReactSharedInternals.actQueue && console.error(
15119          "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"
15120        );
15121        workInProgressRoot === root3 && (workInProgressRootRenderLanes & pingedLanes) === pingedLanes && (workInProgressRootExitStatus === RootSuspendedWithDelay || workInProgressRootExitStatus === RootSuspended && (workInProgressRootRenderLanes & 62914560) === workInProgressRootRenderLanes && now$1() - globalMostRecentFallbackTime < FALLBACK_THROTTLE_MS ? (executionContext & RenderContext) === NoContext && prepareFreshStack(root3, 0) : workInProgressRootPingedLanes |= pingedLanes, workInProgressSuspendedRetryLanes === workInProgressRootRenderLanes && (workInProgressSuspendedRetryLanes = 0));
15122        ensureRootIsScheduled(root3);
15123      }
15124      function retryTimedOutBoundary(boundaryFiber, retryLane) {
15125        0 === retryLane && (retryLane = claimNextRetryLane());
15126        boundaryFiber = enqueueConcurrentRenderForLane(boundaryFiber, retryLane);
15127        null !== boundaryFiber && (markRootUpdated$1(boundaryFiber, retryLane), ensureRootIsScheduled(boundaryFiber));
15128      }
15129      function retryDehydratedSuspenseBoundary(boundaryFiber) {
15130        var suspenseState = boundaryFiber.memoizedState, retryLane = 0;
15131        null !== suspenseState && (retryLane = suspenseState.retryLane);
15132        retryTimedOutBoundary(boundaryFiber, retryLane);
15133      }
15134      function resolveRetryWakeable(boundaryFiber, wakeable) {
15135        var retryLane = 0;
15136        switch (boundaryFiber.tag) {
15137          case 31:
15138          case 13:
15139            var retryCache = boundaryFiber.stateNode;
15140            var suspenseState = boundaryFiber.memoizedState;
15141            null !== suspenseState && (retryLane = suspenseState.retryLane);
15142            break;
15143          case 19:
15144            retryCache = boundaryFiber.stateNode;
15145            break;
15146          case 22:
15147            retryCache = boundaryFiber.stateNode._retryCache;
15148            break;
15149          default:
15150            throw Error(
15151              "Pinged unknown suspense boundary type. This is probably a bug in React."
15152            );
15153        }
15154        null !== retryCache && retryCache.delete(wakeable);
15155        retryTimedOutBoundary(boundaryFiber, retryLane);
15156      }
15157      function recursivelyTraverseAndDoubleInvokeEffectsInDEV(root$jscomp$0, parentFiber, isInStrictMode) {
15158        if (0 !== (parentFiber.subtreeFlags & 67117056))
15159          for (parentFiber = parentFiber.child; null !== parentFiber; ) {
15160            var root3 = root$jscomp$0, fiber = parentFiber, isStrictModeFiber = fiber.type === REACT_STRICT_MODE_TYPE;
15161            isStrictModeFiber = isInStrictMode || isStrictModeFiber;
15162            22 !== fiber.tag ? fiber.flags & 67108864 ? isStrictModeFiber && runWithFiberInDEV(
15163              fiber,
15164              doubleInvokeEffectsOnFiber,
15165              root3,
15166              fiber
15167            ) : recursivelyTraverseAndDoubleInvokeEffectsInDEV(
15168              root3,
15169              fiber,
15170              isStrictModeFiber
15171            ) : null === fiber.memoizedState && (isStrictModeFiber && fiber.flags & 8192 ? runWithFiberInDEV(
15172              fiber,
15173              doubleInvokeEffectsOnFiber,
15174              root3,
15175              fiber
15176            ) : fiber.subtreeFlags & 67108864 && runWithFiberInDEV(
15177              fiber,
15178              recursivelyTraverseAndDoubleInvokeEffectsInDEV,
15179              root3,
15180              fiber,
15181              isStrictModeFiber
15182            ));
15183            parentFiber = parentFiber.sibling;
15184          }
15185      }
15186      function doubleInvokeEffectsOnFiber(root3, fiber) {
15187        setIsStrictModeForDevtools(true);
15188        try {
15189          disappearLayoutEffects(fiber), disconnectPassiveEffect(fiber), reappearLayoutEffects(root3, fiber.alternate, fiber, false), reconnectPassiveEffects(root3, fiber, 0, null, false, 0);
15190        } finally {
15191          setIsStrictModeForDevtools(false);
15192        }
15193      }
15194      function commitDoubleInvokeEffectsInDEV(root3) {
15195        var doubleInvokeEffects = true;
15196        root3.current.mode & (StrictLegacyMode | StrictEffectsMode) || (doubleInvokeEffects = false);
15197        recursivelyTraverseAndDoubleInvokeEffectsInDEV(
15198          root3,
15199          root3.current,
15200          doubleInvokeEffects
15201        );
15202      }
15203      function warnAboutUpdateOnNotYetMountedFiberInDEV(fiber) {
15204        if ((executionContext & RenderContext) === NoContext) {
15205          var tag = fiber.tag;
15206          if (3 === tag || 1 === tag || 0 === tag || 11 === tag || 14 === tag || 15 === tag) {
15207            tag = getComponentNameFromFiber(fiber) || "ReactComponent";
15208            if (null !== didWarnStateUpdateForNotYetMountedComponent) {
15209              if (didWarnStateUpdateForNotYetMountedComponent.has(tag)) return;
15210              didWarnStateUpdateForNotYetMountedComponent.add(tag);
15211            } else didWarnStateUpdateForNotYetMountedComponent = /* @__PURE__ */ new Set([tag]);
15212            runWithFiberInDEV(fiber, function() {
15213              console.error(
15214                "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."
15215              );
15216            });
15217          }
15218        }
15219      }
15220      function restorePendingUpdaters(root3, lanes) {
15221        isDevToolsPresent && root3.memoizedUpdaters.forEach(function(schedulingFiber) {
15222          addFiberToLanesMap(root3, schedulingFiber, lanes);
15223        });
15224      }
15225      function scheduleCallback$1(priorityLevel, callback) {
15226        var actQueue = ReactSharedInternals.actQueue;
15227        return null !== actQueue ? (actQueue.push(callback), fakeActCallbackNode$1) : scheduleCallback$3(priorityLevel, callback);
15228      }
15229      function warnIfUpdatesNotWrappedWithActDEV(fiber) {
15230        isConcurrentActEnvironment() && null === ReactSharedInternals.actQueue && runWithFiberInDEV(fiber, function() {
15231          console.error(
15232            "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",
15233            getComponentNameFromFiber(fiber)
15234          );
15235        });
15236      }
15237      function ensureRootIsScheduled(root3) {
15238        root3 !== lastScheduledRoot && null === root3.next && (null === lastScheduledRoot ? firstScheduledRoot = lastScheduledRoot = root3 : lastScheduledRoot = lastScheduledRoot.next = root3);
15239        mightHavePendingSyncWork = true;
15240        null !== ReactSharedInternals.actQueue ? didScheduleMicrotask_act || (didScheduleMicrotask_act = true, scheduleImmediateRootScheduleTask()) : didScheduleMicrotask || (didScheduleMicrotask = true, scheduleImmediateRootScheduleTask());
15241      }
15242      function flushSyncWorkAcrossRoots_impl(syncTransitionLanes, onlyLegacy) {
15243        if (!isFlushingWork && mightHavePendingSyncWork) {
15244          isFlushingWork = true;
15245          do {
15246            var didPerformSomeWork = false;
15247            for (var root3 = firstScheduledRoot; null !== root3; ) {
15248              if (!onlyLegacy)
15249                if (0 !== syncTransitionLanes) {
15250                  var pendingLanes = root3.pendingLanes;
15251                  if (0 === pendingLanes) var nextLanes = 0;
15252                  else {
15253                    var suspendedLanes = root3.suspendedLanes, pingedLanes = root3.pingedLanes;
15254                    nextLanes = (1 << 31 - clz32(42 | syncTransitionLanes) + 1) - 1;
15255                    nextLanes &= pendingLanes & ~(suspendedLanes & ~pingedLanes);
15256                    nextLanes = nextLanes & 201326741 ? nextLanes & 201326741 | 1 : nextLanes ? nextLanes | 2 : 0;
15257                  }
15258                  0 !== nextLanes && (didPerformSomeWork = true, performSyncWorkOnRoot(root3, nextLanes));
15259                } else
15260                  nextLanes = workInProgressRootRenderLanes, nextLanes = getNextLanes(
15261                    root3,
15262                    root3 === workInProgressRoot ? nextLanes : 0,
15263                    null !== root3.cancelPendingCommit || root3.timeoutHandle !== noTimeout
15264                  ), 0 === (nextLanes & 3) || checkIfRootIsPrerendering(root3, nextLanes) || (didPerformSomeWork = true, performSyncWorkOnRoot(root3, nextLanes));
15265              root3 = root3.next;
15266            }
15267          } while (didPerformSomeWork);
15268          isFlushingWork = false;
15269        }
15270      }
15271      function processRootScheduleInImmediateTask() {
15272        schedulerEvent = window.event;
15273        processRootScheduleInMicrotask();
15274      }
15275      function processRootScheduleInMicrotask() {
15276        mightHavePendingSyncWork = didScheduleMicrotask_act = didScheduleMicrotask = false;
15277        var syncTransitionLanes = 0;
15278        0 !== currentEventTransitionLane && shouldAttemptEagerTransition() && (syncTransitionLanes = currentEventTransitionLane);
15279        for (var currentTime = now$1(), prev = null, root3 = firstScheduledRoot; null !== root3; ) {
15280          var next = root3.next, nextLanes = scheduleTaskForRootDuringMicrotask(root3, currentTime);
15281          if (0 === nextLanes)
15282            root3.next = null, null === prev ? firstScheduledRoot = next : prev.next = next, null === next && (lastScheduledRoot = prev);
15283          else if (prev = root3, 0 !== syncTransitionLanes || 0 !== (nextLanes & 3))
15284            mightHavePendingSyncWork = true;
15285          root3 = next;
15286        }
15287        pendingEffectsStatus !== NO_PENDING_EFFECTS && pendingEffectsStatus !== PENDING_PASSIVE_PHASE || flushSyncWorkAcrossRoots_impl(syncTransitionLanes, false);
15288        0 !== currentEventTransitionLane && (currentEventTransitionLane = 0);
15289      }
15290      function scheduleTaskForRootDuringMicrotask(root3, currentTime) {
15291        for (var suspendedLanes = root3.suspendedLanes, pingedLanes = root3.pingedLanes, expirationTimes = root3.expirationTimes, lanes = root3.pendingLanes & -62914561; 0 < lanes; ) {
15292          var index = 31 - clz32(lanes), lane = 1 << index, expirationTime = expirationTimes[index];
15293          if (-1 === expirationTime) {
15294            if (0 === (lane & suspendedLanes) || 0 !== (lane & pingedLanes))
15295              expirationTimes[index] = computeExpirationTime(lane, currentTime);
15296          } else expirationTime <= currentTime && (root3.expiredLanes |= lane);
15297          lanes &= ~lane;
15298        }
15299        currentTime = workInProgressRoot;
15300        suspendedLanes = workInProgressRootRenderLanes;
15301        suspendedLanes = getNextLanes(
15302          root3,
15303          root3 === currentTime ? suspendedLanes : 0,
15304          null !== root3.cancelPendingCommit || root3.timeoutHandle !== noTimeout
15305        );
15306        pingedLanes = root3.callbackNode;
15307        if (0 === suspendedLanes || root3 === currentTime && (workInProgressSuspendedReason === SuspendedOnData || workInProgressSuspendedReason === SuspendedOnAction) || null !== root3.cancelPendingCommit)
15308          return null !== pingedLanes && cancelCallback(pingedLanes), root3.callbackNode = null, root3.callbackPriority = 0;
15309        if (0 === (suspendedLanes & 3) || checkIfRootIsPrerendering(root3, suspendedLanes)) {
15310          currentTime = suspendedLanes & -suspendedLanes;
15311          if (currentTime !== root3.callbackPriority || null !== ReactSharedInternals.actQueue && pingedLanes !== fakeActCallbackNode)
15312            cancelCallback(pingedLanes);
15313          else return currentTime;
15314          switch (lanesToEventPriority(suspendedLanes)) {
15315            case DiscreteEventPriority:
15316            case ContinuousEventPriority:
15317              suspendedLanes = UserBlockingPriority;
15318              break;
15319            case DefaultEventPriority:
15320              suspendedLanes = NormalPriority$1;
15321              break;
15322            case IdleEventPriority:
15323              suspendedLanes = IdlePriority;
15324              break;
15325            default:
15326              suspendedLanes = NormalPriority$1;
15327          }
15328          pingedLanes = performWorkOnRootViaSchedulerTask.bind(null, root3);
15329          null !== ReactSharedInternals.actQueue ? (ReactSharedInternals.actQueue.push(pingedLanes), suspendedLanes = fakeActCallbackNode) : suspendedLanes = scheduleCallback$3(suspendedLanes, pingedLanes);
15330          root3.callbackPriority = currentTime;
15331          root3.callbackNode = suspendedLanes;
15332          return currentTime;
15333        }
15334        null !== pingedLanes && cancelCallback(pingedLanes);
15335        root3.callbackPriority = 2;
15336        root3.callbackNode = null;
15337        return 2;
15338      }
15339      function performWorkOnRootViaSchedulerTask(root3, didTimeout) {
15340        nestedUpdateScheduled = currentUpdateIsNested = false;
15341        schedulerEvent = window.event;
15342        if (pendingEffectsStatus !== NO_PENDING_EFFECTS && pendingEffectsStatus !== PENDING_PASSIVE_PHASE)
15343          return root3.callbackNode = null, root3.callbackPriority = 0, null;
15344        var originalCallbackNode = root3.callbackNode;
15345        pendingDelayedCommitReason === IMMEDIATE_COMMIT && (pendingDelayedCommitReason = DELAYED_PASSIVE_COMMIT);
15346        if (flushPendingEffects() && root3.callbackNode !== originalCallbackNode)
15347          return null;
15348        var workInProgressRootRenderLanes$jscomp$0 = workInProgressRootRenderLanes;
15349        workInProgressRootRenderLanes$jscomp$0 = getNextLanes(
15350          root3,
15351          root3 === workInProgressRoot ? workInProgressRootRenderLanes$jscomp$0 : 0,
15352          null !== root3.cancelPendingCommit || root3.timeoutHandle !== noTimeout
15353        );
15354        if (0 === workInProgressRootRenderLanes$jscomp$0) return null;
15355        performWorkOnRoot(
15356          root3,
15357          workInProgressRootRenderLanes$jscomp$0,
15358          didTimeout
15359        );
15360        scheduleTaskForRootDuringMicrotask(root3, now$1());
15361        return null != root3.callbackNode && root3.callbackNode === originalCallbackNode ? performWorkOnRootViaSchedulerTask.bind(null, root3) : null;
15362      }
15363      function performSyncWorkOnRoot(root3, lanes) {
15364        if (flushPendingEffects()) return null;
15365        currentUpdateIsNested = nestedUpdateScheduled;
15366        nestedUpdateScheduled = false;
15367        performWorkOnRoot(root3, lanes, true);
15368      }
15369      function cancelCallback(callbackNode) {
15370        callbackNode !== fakeActCallbackNode && null !== callbackNode && cancelCallback$1(callbackNode);
15371      }
15372      function scheduleImmediateRootScheduleTask() {
15373        null !== ReactSharedInternals.actQueue && ReactSharedInternals.actQueue.push(function() {
15374          processRootScheduleInMicrotask();
15375          return null;
15376        });
15377        scheduleMicrotask(function() {
15378          (executionContext & (RenderContext | CommitContext)) !== NoContext ? scheduleCallback$3(
15379            ImmediatePriority,
15380            processRootScheduleInImmediateTask
15381          ) : processRootScheduleInMicrotask();
15382        });
15383      }
15384      function requestTransitionLane() {
15385        if (0 === currentEventTransitionLane) {
15386          var actionScopeLane = currentEntangledLane;
15387          0 === actionScopeLane && (actionScopeLane = nextTransitionUpdateLane, nextTransitionUpdateLane <<= 1, 0 === (nextTransitionUpdateLane & 261888) && (nextTransitionUpdateLane = 256));
15388          currentEventTransitionLane = actionScopeLane;
15389        }
15390        return currentEventTransitionLane;
15391      }
15392      function coerceFormActionProp(actionProp) {
15393        if (null == actionProp || "symbol" === typeof actionProp || "boolean" === typeof actionProp)
15394          return null;
15395        if ("function" === typeof actionProp) return actionProp;
15396        checkAttributeStringCoercion(actionProp, "action");
15397        return sanitizeURL("" + actionProp);
15398      }
15399      function createFormDataWithSubmitter(form, submitter2) {
15400        var temp = submitter2.ownerDocument.createElement("input");
15401        temp.name = submitter2.name;
15402        temp.value = submitter2.value;
15403        form.id && temp.setAttribute("form", form.id);
15404        submitter2.parentNode.insertBefore(temp, submitter2);
15405        form = new FormData(form);
15406        temp.parentNode.removeChild(temp);
15407        return form;
15408      }
15409      function extractEvents$1(dispatchQueue, domEventName, maybeTargetInst, nativeEvent, nativeEventTarget) {
15410        if ("submit" === domEventName && maybeTargetInst && maybeTargetInst.stateNode === nativeEventTarget) {
15411          var action = coerceFormActionProp(
15412            (nativeEventTarget[internalPropsKey] || null).action
15413          ), submitter2 = nativeEvent.submitter;
15414          submitter2 && (domEventName = (domEventName = submitter2[internalPropsKey] || null) ? coerceFormActionProp(domEventName.formAction) : submitter2.getAttribute("formAction"), null !== domEventName && (action = domEventName, submitter2 = null));
15415          var event = new SyntheticEvent(
15416            "action",
15417            "action",
15418            null,
15419            nativeEvent,
15420            nativeEventTarget
15421          );
15422          dispatchQueue.push({
15423            event,
15424            listeners: [
15425              {
15426                instance: null,
15427                listener: function() {
15428                  if (nativeEvent.defaultPrevented) {
15429                    if (0 !== currentEventTransitionLane) {
15430                      var formData = submitter2 ? createFormDataWithSubmitter(
15431                        nativeEventTarget,
15432                        submitter2
15433                      ) : new FormData(nativeEventTarget), pendingState = {
15434                        pending: true,
15435                        data: formData,
15436                        method: nativeEventTarget.method,
15437                        action
15438                      };
15439                      Object.freeze(pendingState);
15440                      startHostTransition(
15441                        maybeTargetInst,
15442                        pendingState,
15443                        null,
15444                        formData
15445                      );
15446                    }
15447                  } else
15448                    "function" === typeof action && (event.preventDefault(), formData = submitter2 ? createFormDataWithSubmitter(
15449                      nativeEventTarget,
15450                      submitter2
15451                    ) : new FormData(nativeEventTarget), pendingState = {
15452                      pending: true,
15453                      data: formData,
15454                      method: nativeEventTarget.method,
15455                      action
15456                    }, Object.freeze(pendingState), startHostTransition(
15457                      maybeTargetInst,
15458                      pendingState,
15459                      action,
15460                      formData
15461                    ));
15462                },
15463                currentTarget: nativeEventTarget
15464              }
15465            ]
15466          });
15467        }
15468      }
15469      function executeDispatch(event, listener, currentTarget) {
15470        event.currentTarget = currentTarget;
15471        try {
15472          listener(event);
15473        } catch (error2) {
15474          reportGlobalError(error2);
15475        }
15476        event.currentTarget = null;
15477      }
15478      function processDispatchQueue(dispatchQueue, eventSystemFlags) {
15479        eventSystemFlags = 0 !== (eventSystemFlags & 4);
15480        for (var i3 = 0; i3 < dispatchQueue.length; i3++) {
15481          var _dispatchQueue$i = dispatchQueue[i3];
15482          a: {
15483            var previousInstance = void 0, event = _dispatchQueue$i.event;
15484            _dispatchQueue$i = _dispatchQueue$i.listeners;
15485            if (eventSystemFlags)
15486              for (var i$jscomp$0 = _dispatchQueue$i.length - 1; 0 <= i$jscomp$0; i$jscomp$0--) {
15487                var _dispatchListeners$i = _dispatchQueue$i[i$jscomp$0], instance = _dispatchListeners$i.instance, currentTarget = _dispatchListeners$i.currentTarget;
15488                _dispatchListeners$i = _dispatchListeners$i.listener;
15489                if (instance !== previousInstance && event.isPropagationStopped())
15490                  break a;
15491                null !== instance ? runWithFiberInDEV(
15492                  instance,
15493                  executeDispatch,
15494                  event,
15495                  _dispatchListeners$i,
15496                  currentTarget
15497                ) : executeDispatch(event, _dispatchListeners$i, currentTarget);
15498                previousInstance = instance;
15499              }
15500            else
15501              for (i$jscomp$0 = 0; i$jscomp$0 < _dispatchQueue$i.length; i$jscomp$0++) {
15502                _dispatchListeners$i = _dispatchQueue$i[i$jscomp$0];
15503                instance = _dispatchListeners$i.instance;
15504                currentTarget = _dispatchListeners$i.currentTarget;
15505                _dispatchListeners$i = _dispatchListeners$i.listener;
15506                if (instance !== previousInstance && event.isPropagationStopped())
15507                  break a;
15508                null !== instance ? runWithFiberInDEV(
15509                  instance,
15510                  executeDispatch,
15511                  event,
15512                  _dispatchListeners$i,
15513                  currentTarget
15514                ) : executeDispatch(event, _dispatchListeners$i, currentTarget);
15515                previousInstance = instance;
15516              }
15517          }
15518        }
15519      }
15520      function listenToNonDelegatedEvent(domEventName, targetElement) {
15521        nonDelegatedEvents.has(domEventName) || console.error(
15522          'Did not expect a listenToNonDelegatedEvent() call for "%s". This is a bug in React. Please file an issue.',
15523          domEventName
15524        );
15525        var listenerSet = targetElement[internalEventHandlersKey];
15526        void 0 === listenerSet && (listenerSet = targetElement[internalEventHandlersKey] = /* @__PURE__ */ new Set());
15527        var listenerSetKey = domEventName + "__bubble";
15528        listenerSet.has(listenerSetKey) || (addTrappedEventListener(targetElement, domEventName, 2, false), listenerSet.add(listenerSetKey));
15529      }
15530      function listenToNativeEvent(domEventName, isCapturePhaseListener, target) {
15531        nonDelegatedEvents.has(domEventName) && !isCapturePhaseListener && console.error(
15532          'Did not expect a listenToNativeEvent() call for "%s" in the bubble phase. This is a bug in React. Please file an issue.',
15533          domEventName
15534        );
15535        var eventSystemFlags = 0;
15536        isCapturePhaseListener && (eventSystemFlags |= 4);
15537        addTrappedEventListener(
15538          target,
15539          domEventName,
15540          eventSystemFlags,
15541          isCapturePhaseListener
15542        );
15543      }
15544      function listenToAllSupportedEvents(rootContainerElement) {
15545        if (!rootContainerElement[listeningMarker]) {
15546          rootContainerElement[listeningMarker] = true;
15547          allNativeEvents.forEach(function(domEventName) {
15548            "selectionchange" !== domEventName && (nonDelegatedEvents.has(domEventName) || listenToNativeEvent(domEventName, false, rootContainerElement), listenToNativeEvent(domEventName, true, rootContainerElement));
15549          });
15550          var ownerDocument = 9 === rootContainerElement.nodeType ? rootContainerElement : rootContainerElement.ownerDocument;
15551          null === ownerDocument || ownerDocument[listeningMarker] || (ownerDocument[listeningMarker] = true, listenToNativeEvent("selectionchange", false, ownerDocument));
15552        }
15553      }
15554      function addTrappedEventListener(targetContainer, domEventName, eventSystemFlags, isCapturePhaseListener) {
15555        switch (getEventPriority(domEventName)) {
15556          case DiscreteEventPriority:
15557            var listenerWrapper = dispatchDiscreteEvent;
15558            break;
15559          case ContinuousEventPriority:
15560            listenerWrapper = dispatchContinuousEvent;
15561            break;
15562          default:
15563            listenerWrapper = dispatchEvent;
15564        }
15565        eventSystemFlags = listenerWrapper.bind(
15566          null,
15567          domEventName,
15568          eventSystemFlags,
15569          targetContainer
15570        );
15571        listenerWrapper = void 0;
15572        !passiveBrowserEventsSupported || "touchstart" !== domEventName && "touchmove" !== domEventName && "wheel" !== domEventName || (listenerWrapper = true);
15573        isCapturePhaseListener ? void 0 !== listenerWrapper ? targetContainer.addEventListener(domEventName, eventSystemFlags, {
15574          capture: true,
15575          passive: listenerWrapper
15576        }) : targetContainer.addEventListener(domEventName, eventSystemFlags, true) : void 0 !== listenerWrapper ? targetContainer.addEventListener(domEventName, eventSystemFlags, {
15577          passive: listenerWrapper
15578        }) : targetContainer.addEventListener(
15579          domEventName,
15580          eventSystemFlags,
15581          false
15582        );
15583      }
15584      function dispatchEventForPluginEventSystem(domEventName, eventSystemFlags, nativeEvent, targetInst$jscomp$0, targetContainer) {
15585        var ancestorInst = targetInst$jscomp$0;
15586        if (0 === (eventSystemFlags & 1) && 0 === (eventSystemFlags & 2) && null !== targetInst$jscomp$0)
15587          a: for (; ; ) {
15588            if (null === targetInst$jscomp$0) return;
15589            var nodeTag = targetInst$jscomp$0.tag;
15590            if (3 === nodeTag || 4 === nodeTag) {
15591              var container = targetInst$jscomp$0.stateNode.containerInfo;
15592              if (container === targetContainer) break;
15593              if (4 === nodeTag)
15594                for (nodeTag = targetInst$jscomp$0.return; null !== nodeTag; ) {
15595                  var grandTag = nodeTag.tag;
15596                  if ((3 === grandTag || 4 === grandTag) && nodeTag.stateNode.containerInfo === targetContainer)
15597                    return;
15598                  nodeTag = nodeTag.return;
15599                }
15600              for (; null !== container; ) {
15601                nodeTag = getClosestInstanceFromNode(container);
15602                if (null === nodeTag) return;
15603                grandTag = nodeTag.tag;
15604                if (5 === grandTag || 6 === grandTag || 26 === grandTag || 27 === grandTag) {
15605                  targetInst$jscomp$0 = ancestorInst = nodeTag;
15606                  continue a;
15607                }
15608                container = container.parentNode;
15609              }
15610            }
15611            targetInst$jscomp$0 = targetInst$jscomp$0.return;
15612          }
15613        batchedUpdates$1(function() {
15614          var targetInst = ancestorInst, nativeEventTarget = getEventTarget(nativeEvent), dispatchQueue = [];
15615          a: {
15616            var reactName = topLevelEventsToReactNames.get(domEventName);
15617            if (void 0 !== reactName) {
15618              var SyntheticEventCtor = SyntheticEvent, reactEventType = domEventName;
15619              switch (domEventName) {
15620                case "keypress":
15621                  if (0 === getEventCharCode(nativeEvent)) break a;
15622                case "keydown":
15623                case "keyup":
15624                  SyntheticEventCtor = SyntheticKeyboardEvent;
15625                  break;
15626                case "focusin":
15627                  reactEventType = "focus";
15628                  SyntheticEventCtor = SyntheticFocusEvent;
15629                  break;
15630                case "focusout":
15631                  reactEventType = "blur";
15632                  SyntheticEventCtor = SyntheticFocusEvent;
15633                  break;
15634                case "beforeblur":
15635                case "afterblur":
15636                  SyntheticEventCtor = SyntheticFocusEvent;
15637                  break;
15638                case "click":
15639                  if (2 === nativeEvent.button) break a;
15640                case "auxclick":
15641                case "dblclick":
15642                case "mousedown":
15643                case "mousemove":
15644                case "mouseup":
15645                case "mouseout":
15646                case "mouseover":
15647                case "contextmenu":
15648                  SyntheticEventCtor = SyntheticMouseEvent;
15649                  break;
15650                case "drag":
15651                case "dragend":
15652                case "dragenter":
15653                case "dragexit":
15654                case "dragleave":
15655                case "dragover":
15656                case "dragstart":
15657                case "drop":
15658                  SyntheticEventCtor = SyntheticDragEvent;
15659                  break;
15660                case "touchcancel":
15661                case "touchend":
15662                case "touchmove":
15663                case "touchstart":
15664                  SyntheticEventCtor = SyntheticTouchEvent;
15665                  break;
15666                case ANIMATION_END:
15667                case ANIMATION_ITERATION:
15668                case ANIMATION_START:
15669                  SyntheticEventCtor = SyntheticAnimationEvent;
15670                  break;
15671                case TRANSITION_END:
15672                  SyntheticEventCtor = SyntheticTransitionEvent;
15673                  break;
15674                case "scroll":
15675                case "scrollend":
15676                  SyntheticEventCtor = SyntheticUIEvent;
15677                  break;
15678                case "wheel":
15679                  SyntheticEventCtor = SyntheticWheelEvent;
15680                  break;
15681                case "copy":
15682                case "cut":
15683                case "paste":
15684                  SyntheticEventCtor = SyntheticClipboardEvent;
15685                  break;
15686                case "gotpointercapture":
15687                case "lostpointercapture":
15688                case "pointercancel":
15689                case "pointerdown":
15690                case "pointermove":
15691                case "pointerout":
15692                case "pointerover":
15693                case "pointerup":
15694                  SyntheticEventCtor = SyntheticPointerEvent;
15695                  break;
15696                case "toggle":
15697                case "beforetoggle":
15698                  SyntheticEventCtor = SyntheticToggleEvent;
15699              }
15700              var inCapturePhase = 0 !== (eventSystemFlags & 4), accumulateTargetOnly = !inCapturePhase && ("scroll" === domEventName || "scrollend" === domEventName), reactEventName = inCapturePhase ? null !== reactName ? reactName + "Capture" : null : reactName;
15701              inCapturePhase = [];
15702              for (var instance = targetInst, lastHostComponent; null !== instance; ) {
15703                var _instance2 = instance;
15704                lastHostComponent = _instance2.stateNode;
15705                _instance2 = _instance2.tag;
15706                5 !== _instance2 && 26 !== _instance2 && 27 !== _instance2 || null === lastHostComponent || null === reactEventName || (_instance2 = getListener(instance, reactEventName), null != _instance2 && inCapturePhase.push(
15707                  createDispatchListener(
15708                    instance,
15709                    _instance2,
15710                    lastHostComponent
15711                  )
15712                ));
15713                if (accumulateTargetOnly) break;
15714                instance = instance.return;
15715              }
15716              0 < inCapturePhase.length && (reactName = new SyntheticEventCtor(
15717                reactName,
15718                reactEventType,
15719                null,
15720                nativeEvent,
15721                nativeEventTarget
15722              ), dispatchQueue.push({
15723                event: reactName,
15724                listeners: inCapturePhase
15725              }));
15726            }
15727          }
15728          if (0 === (eventSystemFlags & 7)) {
15729            a: {
15730              reactName = "mouseover" === domEventName || "pointerover" === domEventName;
15731              SyntheticEventCtor = "mouseout" === domEventName || "pointerout" === domEventName;
15732              if (reactName && nativeEvent !== currentReplayingEvent && (reactEventType = nativeEvent.relatedTarget || nativeEvent.fromElement) && (getClosestInstanceFromNode(reactEventType) || reactEventType[internalContainerInstanceKey]))
15733                break a;
15734              if (SyntheticEventCtor || reactName) {
15735                reactName = nativeEventTarget.window === nativeEventTarget ? nativeEventTarget : (reactName = nativeEventTarget.ownerDocument) ? reactName.defaultView || reactName.parentWindow : window;
15736                if (SyntheticEventCtor) {
15737                  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))
15738                    reactEventType = null;
15739                } else SyntheticEventCtor = null, reactEventType = targetInst;
15740                if (SyntheticEventCtor !== reactEventType) {
15741                  inCapturePhase = SyntheticMouseEvent;
15742                  _instance2 = "onMouseLeave";
15743                  reactEventName = "onMouseEnter";
15744                  instance = "mouse";
15745                  if ("pointerout" === domEventName || "pointerover" === domEventName)
15746                    inCapturePhase = SyntheticPointerEvent, _instance2 = "onPointerLeave", reactEventName = "onPointerEnter", instance = "pointer";
15747                  accumulateTargetOnly = null == SyntheticEventCtor ? reactName : getNodeFromInstance(SyntheticEventCtor);
15748                  lastHostComponent = null == reactEventType ? reactName : getNodeFromInstance(reactEventType);
15749                  reactName = new inCapturePhase(
15750                    _instance2,
15751                    instance + "leave",
15752                    SyntheticEventCtor,
15753                    nativeEvent,
15754                    nativeEventTarget
15755                  );
15756                  reactName.target = accumulateTargetOnly;
15757                  reactName.relatedTarget = lastHostComponent;
15758                  _instance2 = null;
15759                  getClosestInstanceFromNode(nativeEventTarget) === targetInst && (inCapturePhase = new inCapturePhase(
15760                    reactEventName,
15761                    instance + "enter",
15762                    reactEventType,
15763                    nativeEvent,
15764                    nativeEventTarget
15765                  ), inCapturePhase.target = lastHostComponent, inCapturePhase.relatedTarget = accumulateTargetOnly, _instance2 = inCapturePhase);
15766                  accumulateTargetOnly = _instance2;
15767                  if (SyntheticEventCtor && reactEventType)
15768                    b: {
15769                      inCapturePhase = getParent;
15770                      reactEventName = SyntheticEventCtor;
15771                      instance = reactEventType;
15772                      lastHostComponent = 0;
15773                      for (_instance2 = reactEventName; _instance2; _instance2 = inCapturePhase(_instance2))
15774                        lastHostComponent++;
15775                      _instance2 = 0;
15776                      for (var tempB = instance; tempB; tempB = inCapturePhase(tempB))
15777                        _instance2++;
15778                      for (; 0 < lastHostComponent - _instance2; )
15779                        reactEventName = inCapturePhase(reactEventName), lastHostComponent--;
15780                      for (; 0 < _instance2 - lastHostComponent; )
15781                        instance = inCapturePhase(instance), _instance2--;
15782                      for (; lastHostComponent--; ) {
15783                        if (reactEventName === instance || null !== instance && reactEventName === instance.alternate) {
15784                          inCapturePhase = reactEventName;
15785                          break b;
15786                        }
15787                        reactEventName = inCapturePhase(reactEventName);
15788                        instance = inCapturePhase(instance);
15789                      }
15790                      inCapturePhase = null;
15791                    }
15792                  else inCapturePhase = null;
15793                  null !== SyntheticEventCtor && accumulateEnterLeaveListenersForEvent(
15794                    dispatchQueue,
15795                    reactName,
15796                    SyntheticEventCtor,
15797                    inCapturePhase,
15798                    false
15799                  );
15800                  null !== reactEventType && null !== accumulateTargetOnly && accumulateEnterLeaveListenersForEvent(
15801                    dispatchQueue,
15802                    accumulateTargetOnly,
15803                    reactEventType,
15804                    inCapturePhase,
15805                    true
15806                  );
15807                }
15808              }
15809            }
15810            a: {
15811              reactName = targetInst ? getNodeFromInstance(targetInst) : window;
15812              SyntheticEventCtor = reactName.nodeName && reactName.nodeName.toLowerCase();
15813              if ("select" === SyntheticEventCtor || "input" === SyntheticEventCtor && "file" === reactName.type)
15814                var getTargetInstFunc = getTargetInstForChangeEvent;
15815              else if (isTextInputElement(reactName))
15816                if (isInputEventSupported)
15817                  getTargetInstFunc = getTargetInstForInputOrChangeEvent;
15818                else {
15819                  getTargetInstFunc = getTargetInstForInputEventPolyfill;
15820                  var handleEventFunc = handleEventsForInputEventPolyfill;
15821                }
15822              else
15823                SyntheticEventCtor = reactName.nodeName, !SyntheticEventCtor || "input" !== SyntheticEventCtor.toLowerCase() || "checkbox" !== reactName.type && "radio" !== reactName.type ? targetInst && isCustomElement(targetInst.elementType) && (getTargetInstFunc = getTargetInstForChangeEvent) : getTargetInstFunc = getTargetInstForClickEvent;
15824              if (getTargetInstFunc && (getTargetInstFunc = getTargetInstFunc(domEventName, targetInst))) {
15825                createAndAccumulateChangeEvent(
15826                  dispatchQueue,
15827                  getTargetInstFunc,
15828                  nativeEvent,
15829                  nativeEventTarget
15830                );
15831                break a;
15832              }
15833              handleEventFunc && handleEventFunc(domEventName, reactName, targetInst);
15834              "focusout" === domEventName && targetInst && "number" === reactName.type && null != targetInst.memoizedProps.value && setDefaultValue(reactName, "number", reactName.value);
15835            }
15836            handleEventFunc = targetInst ? getNodeFromInstance(targetInst) : window;
15837            switch (domEventName) {
15838              case "focusin":
15839                if (isTextInputElement(handleEventFunc) || "true" === handleEventFunc.contentEditable)
15840                  activeElement = handleEventFunc, activeElementInst = targetInst, lastSelection = null;
15841                break;
15842              case "focusout":
15843                lastSelection = activeElementInst = activeElement = null;
15844                break;
15845              case "mousedown":
15846                mouseDown = true;
15847                break;
15848              case "contextmenu":
15849              case "mouseup":
15850              case "dragend":
15851                mouseDown = false;
15852                constructSelectEvent(
15853                  dispatchQueue,
15854                  nativeEvent,
15855                  nativeEventTarget
15856                );
15857                break;
15858              case "selectionchange":
15859                if (skipSelectionChangeEvent) break;
15860              case "keydown":
15861              case "keyup":
15862                constructSelectEvent(
15863                  dispatchQueue,
15864                  nativeEvent,
15865                  nativeEventTarget
15866                );
15867            }
15868            var fallbackData;
15869            if (canUseCompositionEvent)
15870              b: {
15871                switch (domEventName) {
15872                  case "compositionstart":
15873                    var eventType = "onCompositionStart";
15874                    break b;
15875                  case "compositionend":
15876                    eventType = "onCompositionEnd";
15877                    break b;
15878                  case "compositionupdate":
15879                    eventType = "onCompositionUpdate";
15880                    break b;
15881                }
15882                eventType = void 0;
15883              }
15884            else
15885              isComposing ? isFallbackCompositionEnd(domEventName, nativeEvent) && (eventType = "onCompositionEnd") : "keydown" === domEventName && nativeEvent.keyCode === START_KEYCODE && (eventType = "onCompositionStart");
15886            eventType && (useFallbackCompositionData && "ko" !== nativeEvent.locale && (isComposing || "onCompositionStart" !== eventType ? "onCompositionEnd" === eventType && isComposing && (fallbackData = getData()) : (root2 = nativeEventTarget, startText = "value" in root2 ? root2.value : root2.textContent, isComposing = true)), handleEventFunc = accumulateTwoPhaseListeners(
15887              targetInst,
15888              eventType
15889            ), 0 < handleEventFunc.length && (eventType = new SyntheticCompositionEvent(
15890              eventType,
15891              domEventName,
15892              null,
15893              nativeEvent,
15894              nativeEventTarget
15895            ), dispatchQueue.push({
15896              event: eventType,
15897              listeners: handleEventFunc
15898            }), fallbackData ? eventType.data = fallbackData : (fallbackData = getDataFromCustomEvent(nativeEvent), null !== fallbackData && (eventType.data = fallbackData))));
15899            if (fallbackData = canUseTextInputEvent ? getNativeBeforeInputChars(domEventName, nativeEvent) : getFallbackBeforeInputChars(domEventName, nativeEvent))
15900              eventType = accumulateTwoPhaseListeners(
15901                targetInst,
15902                "onBeforeInput"
15903              ), 0 < eventType.length && (handleEventFunc = new SyntheticInputEvent(
15904                "onBeforeInput",
15905                "beforeinput",
15906                null,
15907                nativeEvent,
15908                nativeEventTarget
15909              ), dispatchQueue.push({
15910                event: handleEventFunc,
15911                listeners: eventType
15912              }), handleEventFunc.data = fallbackData);
15913            extractEvents$1(
15914              dispatchQueue,
15915              domEventName,
15916              targetInst,
15917              nativeEvent,
15918              nativeEventTarget
15919            );
15920          }
15921          processDispatchQueue(dispatchQueue, eventSystemFlags);
15922        });
15923      }
15924      function createDispatchListener(instance, listener, currentTarget) {
15925        return {
15926          instance,
15927          listener,
15928          currentTarget
15929        };
15930      }
15931      function accumulateTwoPhaseListeners(targetFiber, reactName) {
15932        for (var captureName = reactName + "Capture", listeners = []; null !== targetFiber; ) {
15933          var _instance3 = targetFiber, stateNode = _instance3.stateNode;
15934          _instance3 = _instance3.tag;
15935          5 !== _instance3 && 26 !== _instance3 && 27 !== _instance3 || null === stateNode || (_instance3 = getListener(targetFiber, captureName), null != _instance3 && listeners.unshift(
15936            createDispatchListener(targetFiber, _instance3, stateNode)
15937          ), _instance3 = getListener(targetFiber, reactName), null != _instance3 && listeners.push(
15938            createDispatchListener(targetFiber, _instance3, stateNode)
15939          ));
15940          if (3 === targetFiber.tag) return listeners;
15941          targetFiber = targetFiber.return;
15942        }
15943        return [];
15944      }
15945      function getParent(inst) {
15946        if (null === inst) return null;
15947        do
15948          inst = inst.return;
15949        while (inst && 5 !== inst.tag && 27 !== inst.tag);
15950        return inst ? inst : null;
15951      }
15952      function accumulateEnterLeaveListenersForEvent(dispatchQueue, event, target, common, inCapturePhase) {
15953        for (var registrationName = event._reactName, listeners = []; null !== target && target !== common; ) {
15954          var _instance4 = target, alternate = _instance4.alternate, stateNode = _instance4.stateNode;
15955          _instance4 = _instance4.tag;
15956          if (null !== alternate && alternate === common) break;
15957          5 !== _instance4 && 26 !== _instance4 && 27 !== _instance4 || null === stateNode || (alternate = stateNode, inCapturePhase ? (stateNode = getListener(target, registrationName), null != stateNode && listeners.unshift(
15958            createDispatchListener(target, stateNode, alternate)
15959          )) : inCapturePhase || (stateNode = getListener(target, registrationName), null != stateNode && listeners.push(
15960            createDispatchListener(target, stateNode, alternate)
15961          )));
15962          target = target.return;
15963        }
15964        0 !== listeners.length && dispatchQueue.push({ event, listeners });
15965      }
15966      function validatePropertiesInDevelopment(type, props) {
15967        validateProperties$2(type, props);
15968        "input" !== type && "textarea" !== type && "select" !== type || null == props || null !== props.value || didWarnValueNull || (didWarnValueNull = true, "select" === type && props.multiple ? console.error(
15969          "`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.",
15970          type
15971        ) : console.error(
15972          "`value` prop on `%s` should not be null. Consider using an empty string to clear the component or `undefined` for uncontrolled components.",
15973          type
15974        ));
15975        var eventRegistry = {
15976          registrationNameDependencies,
15977          possibleRegistrationNames
15978        };
15979        isCustomElement(type) || "string" === typeof props.is || warnUnknownProperties(type, props, eventRegistry);
15980        props.contentEditable && !props.suppressContentEditableWarning && null != props.children && console.error(
15981          "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."
15982        );
15983      }
15984      function warnForPropDifference(propName, serverValue, clientValue, serverDifferences) {
15985        serverValue !== clientValue && (clientValue = normalizeMarkupForTextOrAttribute(clientValue), normalizeMarkupForTextOrAttribute(serverValue) !== clientValue && (serverDifferences[propName] = serverValue));
15986      }
15987      function warnForExtraAttributes(domElement, attributeNames, serverDifferences) {
15988        attributeNames.forEach(function(attributeName) {
15989          serverDifferences[getPropNameFromAttributeName(attributeName)] = "style" === attributeName ? getStylesObjectFromElement(domElement) : domElement.getAttribute(attributeName);
15990        });
15991      }
15992      function warnForInvalidEventListener(registrationName, listener) {
15993        false === listener ? console.error(
15994          "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.",
15995          registrationName,
15996          registrationName,
15997          registrationName
15998        ) : console.error(
15999          "Expected `%s` listener to be a function, instead got a value of `%s` type.",
16000          registrationName,
16001          typeof listener
16002        );
16003      }
16004      function normalizeHTML(parent, html) {
16005        parent = parent.namespaceURI === MATH_NAMESPACE || parent.namespaceURI === SVG_NAMESPACE ? parent.ownerDocument.createElementNS(
16006          parent.namespaceURI,
16007          parent.tagName
16008        ) : parent.ownerDocument.createElement(parent.tagName);
16009        parent.innerHTML = html;
16010        return parent.innerHTML;
16011      }
16012      function normalizeMarkupForTextOrAttribute(markup) {
16013        willCoercionThrow(markup) && (console.error(
16014          "The provided HTML markup uses a value of unsupported type %s. This value must be coerced to a string before using it here.",
16015          typeName(markup)
16016        ), testStringCoercion(markup));
16017        return ("string" === typeof markup ? markup : "" + markup).replace(NORMALIZE_NEWLINES_REGEX, "\n").replace(NORMALIZE_NULL_AND_REPLACEMENT_REGEX, "");
16018      }
16019      function checkForUnmatchedText(serverText, clientText) {
16020        clientText = normalizeMarkupForTextOrAttribute(clientText);
16021        return normalizeMarkupForTextOrAttribute(serverText) === clientText ? true : false;
16022      }
16023      function setProp(domElement, tag, key, value, props, prevValue) {
16024        switch (key) {
16025          case "children":
16026            if ("string" === typeof value)
16027              validateTextNesting(value, tag, false), "body" === tag || "textarea" === tag && "" === value || setTextContent(domElement, value);
16028            else if ("number" === typeof value || "bigint" === typeof value)
16029              validateTextNesting("" + value, tag, false), "body" !== tag && setTextContent(domElement, "" + value);
16030            break;
16031          case "className":
16032            setValueForKnownAttribute(domElement, "class", value);
16033            break;
16034          case "tabIndex":
16035            setValueForKnownAttribute(domElement, "tabindex", value);
16036            break;
16037          case "dir":
16038          case "role":
16039          case "viewBox":
16040          case "width":
16041          case "height":
16042            setValueForKnownAttribute(domElement, key, value);
16043            break;
16044          case "style":
16045            setValueForStyles(domElement, value, prevValue);
16046            break;
16047          case "data":
16048            if ("object" !== tag) {
16049              setValueForKnownAttribute(domElement, "data", value);
16050              break;
16051            }
16052          case "src":
16053          case "href":
16054            if ("" === value && ("a" !== tag || "href" !== key)) {
16055              "src" === key ? console.error(
16056                '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.',
16057                key,
16058                key
16059              ) : console.error(
16060                '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.',
16061                key,
16062                key
16063              );
16064              domElement.removeAttribute(key);
16065              break;
16066            }
16067            if (null == value || "function" === typeof value || "symbol" === typeof value || "boolean" === typeof value) {
16068              domElement.removeAttribute(key);
16069              break;
16070            }
16071            checkAttributeStringCoercion(value, key);
16072            value = sanitizeURL("" + value);
16073            domElement.setAttribute(key, value);
16074            break;
16075          case "action":
16076          case "formAction":
16077            null != value && ("form" === tag ? "formAction" === key ? console.error(
16078              "You can only pass the formAction prop to <input> or <button>. Use the action prop on <form>."
16079            ) : "function" === typeof value && (null == props.encType && null == props.method || didWarnFormActionMethod || (didWarnFormActionMethod = true, console.error(
16080              "Cannot specify a encType or method for a form that specifies a function as the action. React provides those automatically. They will get overridden."
16081            )), null == props.target || didWarnFormActionTarget || (didWarnFormActionTarget = true, console.error(
16082              "Cannot specify a target for a form that specifies a function as the action. The function will always be executed in the same window."
16083            ))) : "input" === tag || "button" === tag ? "action" === key ? console.error(
16084              "You can only pass the action prop to <form>. Use the formAction prop on <input> or <button>."
16085            ) : "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(
16086              '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.'
16087            )), null == props.formEncType && null == props.formMethod || didWarnFormActionMethod || (didWarnFormActionMethod = true, console.error(
16088              "Cannot specify a formEncType or formMethod for a button that specifies a function as a formAction. React provides those automatically. They will get overridden."
16089            )), null == props.formTarget || didWarnFormActionTarget || (didWarnFormActionTarget = true, console.error(
16090              "Cannot specify a formTarget for a button that specifies a function as a formAction. The function will always be executed in the same window."
16091            ))) : (didWarnFormActionType = true, console.error(
16092              'A button can only specify a formAction along with type="submit" or no type.'
16093            )) : (didWarnFormActionType = true, console.error(
16094              'An input can only specify a formAction along with type="submit" or type="image".'
16095            )) : "action" === key ? console.error(
16096              "You can only pass the action prop to <form>."
16097            ) : console.error(
16098              "You can only pass the formAction prop to <input> or <button>."
16099            ));
16100            if ("function" === typeof value) {
16101              domElement.setAttribute(
16102                key,
16103                "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().')"
16104              );
16105              break;
16106            } else
16107              "function" === typeof prevValue && ("formAction" === key ? ("input" !== tag && setProp(domElement, tag, "name", props.name, props, null), setProp(
16108                domElement,
16109                tag,
16110                "formEncType",
16111                props.formEncType,
16112                props,
16113                null
16114              ), setProp(
16115                domElement,
16116                tag,
16117                "formMethod",
16118                props.formMethod,
16119                props,
16120                null
16121              ), setProp(
16122                domElement,
16123                tag,
16124                "formTarget",
16125                props.formTarget,
16126                props,
16127                null
16128              )) : (setProp(
16129                domElement,
16130                tag,
16131                "encType",
16132                props.encType,
16133                props,
16134                null
16135              ), setProp(domElement, tag, "method", props.method, props, null), setProp(
16136                domElement,
16137                tag,
16138                "target",
16139                props.target,
16140                props,
16141                null
16142              )));
16143            if (null == value || "symbol" === typeof value || "boolean" === typeof value) {
16144              domElement.removeAttribute(key);
16145              break;
16146            }
16147            checkAttributeStringCoercion(value, key);
16148            value = sanitizeURL("" + value);
16149            domElement.setAttribute(key, value);
16150            break;
16151          case "onClick":
16152            null != value && ("function" !== typeof value && warnForInvalidEventListener(key, value), domElement.onclick = noop$1);
16153            break;
16154          case "onScroll":
16155            null != value && ("function" !== typeof value && warnForInvalidEventListener(key, value), listenToNonDelegatedEvent("scroll", domElement));
16156            break;
16157          case "onScrollEnd":
16158            null != value && ("function" !== typeof value && warnForInvalidEventListener(key, value), listenToNonDelegatedEvent("scrollend", domElement));
16159            break;
16160          case "dangerouslySetInnerHTML":
16161            if (null != value) {
16162              if ("object" !== typeof value || !("__html" in value))
16163                throw Error(
16164                  "`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. Please visit https://react.dev/link/dangerously-set-inner-html for more information."
16165                );
16166              key = value.__html;
16167              if (null != key) {
16168                if (null != props.children)
16169                  throw Error(
16170                    "Can only set one of `children` or `props.dangerouslySetInnerHTML`."
16171                  );
16172                domElement.innerHTML = key;
16173              }
16174            }
16175            break;
16176          case "multiple":
16177            domElement.multiple = value && "function" !== typeof value && "symbol" !== typeof value;
16178            break;
16179          case "muted":
16180            domElement.muted = value && "function" !== typeof value && "symbol" !== typeof value;
16181            break;
16182          case "suppressContentEditableWarning":
16183          case "suppressHydrationWarning":
16184          case "defaultValue":
16185          case "defaultChecked":
16186          case "innerHTML":
16187          case "ref":
16188            break;
16189          case "autoFocus":
16190            break;
16191          case "xlinkHref":
16192            if (null == value || "function" === typeof value || "boolean" === typeof value || "symbol" === typeof value) {
16193              domElement.removeAttribute("xlink:href");
16194              break;
16195            }
16196            checkAttributeStringCoercion(value, key);
16197            key = sanitizeURL("" + value);
16198            domElement.setAttributeNS(xlinkNamespace, "xlink:href", key);
16199            break;
16200          case "contentEditable":
16201          case "spellCheck":
16202          case "draggable":
16203          case "value":
16204          case "autoReverse":
16205          case "externalResourcesRequired":
16206          case "focusable":
16207          case "preserveAlpha":
16208            null != value && "function" !== typeof value && "symbol" !== typeof value ? (checkAttributeStringCoercion(value, key), domElement.setAttribute(key, "" + value)) : domElement.removeAttribute(key);
16209            break;
16210          case "inert":
16211            "" !== value || didWarnForNewBooleanPropsWithEmptyValue[key] || (didWarnForNewBooleanPropsWithEmptyValue[key] = true, console.error(
16212              "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.",
16213              key
16214            ));
16215          case "allowFullScreen":
16216          case "async":
16217          case "autoPlay":
16218          case "controls":
16219          case "default":
16220          case "defer":
16221          case "disabled":
16222          case "disablePictureInPicture":
16223          case "disableRemotePlayback":
16224          case "formNoValidate":
16225          case "hidden":
16226          case "loop":
16227          case "noModule":
16228          case "noValidate":
16229          case "open":
16230          case "playsInline":
16231          case "readOnly":
16232          case "required":
16233          case "reversed":
16234          case "scoped":
16235          case "seamless":
16236          case "itemScope":
16237            value && "function" !== typeof value && "symbol" !== typeof value ? domElement.setAttribute(key, "") : domElement.removeAttribute(key);
16238            break;
16239          case "capture":
16240          case "download":
16241            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);
16242            break;
16243          case "cols":
16244          case "rows":
16245          case "size":
16246          case "span":
16247            null != value && "function" !== typeof value && "symbol" !== typeof value && !isNaN(value) && 1 <= value ? (checkAttributeStringCoercion(value, key), domElement.setAttribute(key, value)) : domElement.removeAttribute(key);
16248            break;
16249          case "rowSpan":
16250          case "start":
16251            null == value || "function" === typeof value || "symbol" === typeof value || isNaN(value) ? domElement.removeAttribute(key) : (checkAttributeStringCoercion(value, key), domElement.setAttribute(key, value));
16252            break;
16253          case "popover":
16254            listenToNonDelegatedEvent("beforetoggle", domElement);
16255            listenToNonDelegatedEvent("toggle", domElement);
16256            setValueForAttribute(domElement, "popover", value);
16257            break;
16258          case "xlinkActuate":
16259            setValueForNamespacedAttribute(
16260              domElement,
16261              xlinkNamespace,
16262              "xlink:actuate",
16263              value
16264            );
16265            break;
16266          case "xlinkArcrole":
16267            setValueForNamespacedAttribute(
16268              domElement,
16269              xlinkNamespace,
16270              "xlink:arcrole",
16271              value
16272            );
16273            break;
16274          case "xlinkRole":
16275            setValueForNamespacedAttribute(
16276              domElement,
16277              xlinkNamespace,
16278              "xlink:role",
16279              value
16280            );
16281            break;
16282          case "xlinkShow":
16283            setValueForNamespacedAttribute(
16284              domElement,
16285              xlinkNamespace,
16286              "xlink:show",
16287              value
16288            );
16289            break;
16290          case "xlinkTitle":
16291            setValueForNamespacedAttribute(
16292              domElement,
16293              xlinkNamespace,
16294              "xlink:title",
16295              value
16296            );
16297            break;
16298          case "xlinkType":
16299            setValueForNamespacedAttribute(
16300              domElement,
16301              xlinkNamespace,
16302              "xlink:type",
16303              value
16304            );
16305            break;
16306          case "xmlBase":
16307            setValueForNamespacedAttribute(
16308              domElement,
16309              xmlNamespace,
16310              "xml:base",
16311              value
16312            );
16313            break;
16314          case "xmlLang":
16315            setValueForNamespacedAttribute(
16316              domElement,
16317              xmlNamespace,
16318              "xml:lang",
16319              value
16320            );
16321            break;
16322          case "xmlSpace":
16323            setValueForNamespacedAttribute(
16324              domElement,
16325              xmlNamespace,
16326              "xml:space",
16327              value
16328            );
16329            break;
16330          case "is":
16331            null != prevValue && console.error(
16332              'Cannot update the "is" prop after it has been initialized.'
16333            );
16334            setValueForAttribute(domElement, "is", value);
16335            break;
16336          case "innerText":
16337          case "textContent":
16338            break;
16339          case "popoverTarget":
16340            didWarnPopoverTargetObject || null == value || "object" !== typeof value || (didWarnPopoverTargetObject = true, console.error(
16341              "The `popoverTarget` prop expects the ID of an Element as a string. Received %s instead.",
16342              value
16343            ));
16344          default:
16345            !(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);
16346        }
16347      }
16348      function setPropOnCustomElement(domElement, tag, key, value, props, prevValue) {
16349        switch (key) {
16350          case "style":
16351            setValueForStyles(domElement, value, prevValue);
16352            break;
16353          case "dangerouslySetInnerHTML":
16354            if (null != value) {
16355              if ("object" !== typeof value || !("__html" in value))
16356                throw Error(
16357                  "`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. Please visit https://react.dev/link/dangerously-set-inner-html for more information."
16358                );
16359              key = value.__html;
16360              if (null != key) {
16361                if (null != props.children)
16362                  throw Error(
16363                    "Can only set one of `children` or `props.dangerouslySetInnerHTML`."
16364                  );
16365                domElement.innerHTML = key;
16366              }
16367            }
16368            break;
16369          case "children":
16370            "string" === typeof value ? setTextContent(domElement, value) : ("number" === typeof value || "bigint" === typeof value) && setTextContent(domElement, "" + value);
16371            break;
16372          case "onScroll":
16373            null != value && ("function" !== typeof value && warnForInvalidEventListener(key, value), listenToNonDelegatedEvent("scroll", domElement));
16374            break;
16375          case "onScrollEnd":
16376            null != value && ("function" !== typeof value && warnForInvalidEventListener(key, value), listenToNonDelegatedEvent("scrollend", domElement));
16377            break;
16378          case "onClick":
16379            null != value && ("function" !== typeof value && warnForInvalidEventListener(key, value), domElement.onclick = noop$1);
16380            break;
16381          case "suppressContentEditableWarning":
16382          case "suppressHydrationWarning":
16383          case "innerHTML":
16384          case "ref":
16385            break;
16386          case "innerText":
16387          case "textContent":
16388            break;
16389          default:
16390            if (registrationNameDependencies.hasOwnProperty(key))
16391              null != value && "function" !== typeof value && warnForInvalidEventListener(key, value);
16392            else
16393              a: {
16394                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)) {
16395                  "function" !== typeof prevValue && null !== prevValue && (key in domElement ? domElement[key] = null : domElement.hasAttribute(key) && domElement.removeAttribute(key));
16396                  domElement.addEventListener(tag, value, props);
16397                  break a;
16398                }
16399                key in domElement ? domElement[key] = value : true === value ? domElement.setAttribute(key, "") : setValueForAttribute(domElement, key, value);
16400              }
16401        }
16402      }
16403      function setInitialProperties(domElement, tag, props) {
16404        validatePropertiesInDevelopment(tag, props);
16405        switch (tag) {
16406          case "div":
16407          case "span":
16408          case "svg":
16409          case "path":
16410          case "a":
16411          case "g":
16412          case "p":
16413          case "li":
16414            break;
16415          case "img":
16416            listenToNonDelegatedEvent("error", domElement);
16417            listenToNonDelegatedEvent("load", domElement);
16418            var hasSrc = false, hasSrcSet = false, propKey;
16419            for (propKey in props)
16420              if (props.hasOwnProperty(propKey)) {
16421                var propValue = props[propKey];
16422                if (null != propValue)
16423                  switch (propKey) {
16424                    case "src":
16425                      hasSrc = true;
16426                      break;
16427                    case "srcSet":
16428                      hasSrcSet = true;
16429                      break;
16430                    case "children":
16431                    case "dangerouslySetInnerHTML":
16432                      throw Error(
16433                        tag + " is a void element tag and must neither have `children` nor use `dangerouslySetInnerHTML`."
16434                      );
16435                    default:
16436                      setProp(domElement, tag, propKey, propValue, props, null);
16437                  }
16438              }
16439            hasSrcSet && setProp(domElement, tag, "srcSet", props.srcSet, props, null);
16440            hasSrc && setProp(domElement, tag, "src", props.src, props, null);
16441            return;
16442          case "input":
16443            checkControlledValueProps("input", props);
16444            listenToNonDelegatedEvent("invalid", domElement);
16445            var defaultValue = propKey = propValue = hasSrcSet = null, checked = null, defaultChecked = null;
16446            for (hasSrc in props)
16447              if (props.hasOwnProperty(hasSrc)) {
16448                var _propValue = props[hasSrc];
16449                if (null != _propValue)
16450                  switch (hasSrc) {
16451                    case "name":
16452                      hasSrcSet = _propValue;
16453                      break;
16454                    case "type":
16455                      propValue = _propValue;
16456                      break;
16457                    case "checked":
16458                      checked = _propValue;
16459                      break;
16460                    case "defaultChecked":
16461                      defaultChecked = _propValue;
16462                      break;
16463                    case "value":
16464                      propKey = _propValue;
16465                      break;
16466                    case "defaultValue":
16467                      defaultValue = _propValue;
16468                      break;
16469                    case "children":
16470                    case "dangerouslySetInnerHTML":
16471                      if (null != _propValue)
16472                        throw Error(
16473                          tag + " is a void element tag and must neither have `children` nor use `dangerouslySetInnerHTML`."
16474                        );
16475                      break;
16476                    default:
16477                      setProp(domElement, tag, hasSrc, _propValue, props, null);
16478                  }
16479              }
16480            validateInputProps(domElement, props);
16481            initInput(
16482              domElement,
16483              propKey,
16484              defaultValue,
16485              checked,
16486              defaultChecked,
16487              propValue,
16488              hasSrcSet,
16489              false
16490            );
16491            return;
16492          case "select":
16493            checkControlledValueProps("select", props);
16494            listenToNonDelegatedEvent("invalid", domElement);
16495            hasSrc = propValue = propKey = null;
16496            for (hasSrcSet in props)
16497              if (props.hasOwnProperty(hasSrcSet) && (defaultValue = props[hasSrcSet], null != defaultValue))
16498                switch (hasSrcSet) {
16499                  case "value":
16500                    propKey = defaultValue;
16501                    break;
16502                  case "defaultValue":
16503                    propValue = defaultValue;
16504                    break;
16505                  case "multiple":
16506                    hasSrc = defaultValue;
16507                  default:
16508                    setProp(
16509                      domElement,
16510                      tag,
16511                      hasSrcSet,
16512                      defaultValue,
16513                      props,
16514                      null
16515                    );
16516                }
16517            validateSelectProps(domElement, props);
16518            tag = propKey;
16519            props = propValue;
16520            domElement.multiple = !!hasSrc;
16521            null != tag ? updateOptions(domElement, !!hasSrc, tag, false) : null != props && updateOptions(domElement, !!hasSrc, props, true);
16522            return;
16523          case "textarea":
16524            checkControlledValueProps("textarea", props);
16525            listenToNonDelegatedEvent("invalid", domElement);
16526            propKey = hasSrcSet = hasSrc = null;
16527            for (propValue in props)
16528              if (props.hasOwnProperty(propValue) && (defaultValue = props[propValue], null != defaultValue))
16529                switch (propValue) {
16530                  case "value":
16531                    hasSrc = defaultValue;
16532                    break;
16533                  case "defaultValue":
16534                    hasSrcSet = defaultValue;
16535                    break;
16536                  case "children":
16537                    propKey = defaultValue;
16538                    break;
16539                  case "dangerouslySetInnerHTML":
16540                    if (null != defaultValue)
16541                      throw Error(
16542                        "`dangerouslySetInnerHTML` does not make sense on <textarea>."
16543                      );
16544                    break;
16545                  default:
16546                    setProp(
16547                      domElement,
16548                      tag,
16549                      propValue,
16550                      defaultValue,
16551                      props,
16552                      null
16553                    );
16554                }
16555            validateTextareaProps(domElement, props);
16556            initTextarea(domElement, hasSrc, hasSrcSet, propKey);
16557            return;
16558          case "option":
16559            validateOptionProps(domElement, props);
16560            for (checked in props)
16561              if (props.hasOwnProperty(checked) && (hasSrc = props[checked], null != hasSrc))
16562                switch (checked) {
16563                  case "selected":
16564                    domElement.selected = hasSrc && "function" !== typeof hasSrc && "symbol" !== typeof hasSrc;
16565                    break;
16566                  default:
16567                    setProp(domElement, tag, checked, hasSrc, props, null);
16568                }
16569            return;
16570          case "dialog":
16571            listenToNonDelegatedEvent("beforetoggle", domElement);
16572            listenToNonDelegatedEvent("toggle", domElement);
16573            listenToNonDelegatedEvent("cancel", domElement);
16574            listenToNonDelegatedEvent("close", domElement);
16575            break;
16576          case "iframe":
16577          case "object":
16578            listenToNonDelegatedEvent("load", domElement);
16579            break;
16580          case "video":
16581          case "audio":
16582            for (hasSrc = 0; hasSrc < mediaEventTypes.length; hasSrc++)
16583              listenToNonDelegatedEvent(mediaEventTypes[hasSrc], domElement);
16584            break;
16585          case "image":
16586            listenToNonDelegatedEvent("error", domElement);
16587            listenToNonDelegatedEvent("load", domElement);
16588            break;
16589          case "details":
16590            listenToNonDelegatedEvent("toggle", domElement);
16591            break;
16592          case "embed":
16593          case "source":
16594          case "link":
16595            listenToNonDelegatedEvent("error", domElement), listenToNonDelegatedEvent("load", domElement);
16596          case "area":
16597          case "base":
16598          case "br":
16599          case "col":
16600          case "hr":
16601          case "keygen":
16602          case "meta":
16603          case "param":
16604          case "track":
16605          case "wbr":
16606          case "menuitem":
16607            for (defaultChecked in props)
16608              if (props.hasOwnProperty(defaultChecked) && (hasSrc = props[defaultChecked], null != hasSrc))
16609                switch (defaultChecked) {
16610                  case "children":
16611                  case "dangerouslySetInnerHTML":
16612                    throw Error(
16613                      tag + " is a void element tag and must neither have `children` nor use `dangerouslySetInnerHTML`."
16614                    );
16615                  default:
16616                    setProp(domElement, tag, defaultChecked, hasSrc, props, null);
16617                }
16618            return;
16619          default:
16620            if (isCustomElement(tag)) {
16621              for (_propValue in props)
16622                props.hasOwnProperty(_propValue) && (hasSrc = props[_propValue], void 0 !== hasSrc && setPropOnCustomElement(
16623                  domElement,
16624                  tag,
16625                  _propValue,
16626                  hasSrc,
16627                  props,
16628                  void 0
16629                ));
16630              return;
16631            }
16632        }
16633        for (defaultValue in props)
16634          props.hasOwnProperty(defaultValue) && (hasSrc = props[defaultValue], null != hasSrc && setProp(domElement, tag, defaultValue, hasSrc, props, null));
16635      }
16636      function updateProperties(domElement, tag, lastProps, nextProps) {
16637        validatePropertiesInDevelopment(tag, nextProps);
16638        switch (tag) {
16639          case "div":
16640          case "span":
16641          case "svg":
16642          case "path":
16643          case "a":
16644          case "g":
16645          case "p":
16646          case "li":
16647            break;
16648          case "input":
16649            var name = null, type = null, value = null, defaultValue = null, lastDefaultValue = null, checked = null, defaultChecked = null;
16650            for (propKey in lastProps) {
16651              var lastProp = lastProps[propKey];
16652              if (lastProps.hasOwnProperty(propKey) && null != lastProp)
16653                switch (propKey) {
16654                  case "checked":
16655                    break;
16656                  case "value":
16657                    break;
16658                  case "defaultValue":
16659                    lastDefaultValue = lastProp;
16660                  default:
16661                    nextProps.hasOwnProperty(propKey) || setProp(
16662                      domElement,
16663                      tag,
16664                      propKey,
16665                      null,
16666                      nextProps,
16667                      lastProp
16668                    );
16669                }
16670            }
16671            for (var _propKey8 in nextProps) {
16672              var propKey = nextProps[_propKey8];
16673              lastProp = lastProps[_propKey8];
16674              if (nextProps.hasOwnProperty(_propKey8) && (null != propKey || null != lastProp))
16675                switch (_propKey8) {
16676                  case "type":
16677                    type = propKey;
16678                    break;
16679                  case "name":
16680                    name = propKey;
16681                    break;
16682                  case "checked":
16683                    checked = propKey;
16684                    break;
16685                  case "defaultChecked":
16686                    defaultChecked = propKey;
16687                    break;
16688                  case "value":
16689                    value = propKey;
16690                    break;
16691                  case "defaultValue":
16692                    defaultValue = propKey;
16693                    break;
16694                  case "children":
16695                  case "dangerouslySetInnerHTML":
16696                    if (null != propKey)
16697                      throw Error(
16698                        tag + " is a void element tag and must neither have `children` nor use `dangerouslySetInnerHTML`."
16699                      );
16700                    break;
16701                  default:
16702                    propKey !== lastProp && setProp(
16703                      domElement,
16704                      tag,
16705                      _propKey8,
16706                      propKey,
16707                      nextProps,
16708                      lastProp
16709                    );
16710                }
16711            }
16712            tag = "checkbox" === lastProps.type || "radio" === lastProps.type ? null != lastProps.checked : null != lastProps.value;
16713            nextProps = "checkbox" === nextProps.type || "radio" === nextProps.type ? null != nextProps.checked : null != nextProps.value;
16714            tag || !nextProps || didWarnUncontrolledToControlled || (console.error(
16715              "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"
16716            ), didWarnUncontrolledToControlled = true);
16717            !tag || nextProps || didWarnControlledToUncontrolled || (console.error(
16718              "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"
16719            ), didWarnControlledToUncontrolled = true);
16720            updateInput(
16721              domElement,
16722              value,
16723              defaultValue,
16724              lastDefaultValue,
16725              checked,
16726              defaultChecked,
16727              type,
16728              name
16729            );
16730            return;
16731          case "select":
16732            propKey = value = defaultValue = _propKey8 = null;
16733            for (type in lastProps)
16734              if (lastDefaultValue = lastProps[type], lastProps.hasOwnProperty(type) && null != lastDefaultValue)
16735                switch (type) {
16736                  case "value":
16737                    break;
16738                  case "multiple":
16739                    propKey = lastDefaultValue;
16740                  default:
16741                    nextProps.hasOwnProperty(type) || setProp(
16742                      domElement,
16743                      tag,
16744                      type,
16745                      null,
16746                      nextProps,
16747                      lastDefaultValue
16748                    );
16749                }
16750            for (name in nextProps)
16751              if (type = nextProps[name], lastDefaultValue = lastProps[name], nextProps.hasOwnProperty(name) && (null != type || null != lastDefaultValue))
16752                switch (name) {
16753                  case "value":
16754                    _propKey8 = type;
16755                    break;
16756                  case "defaultValue":
16757                    defaultValue = type;
16758                    break;
16759                  case "multiple":
16760                    value = type;
16761                  default:
16762                    type !== lastDefaultValue && setProp(
16763                      domElement,
16764                      tag,
16765                      name,
16766                      type,
16767                      nextProps,
16768                      lastDefaultValue
16769                    );
16770                }
16771            nextProps = defaultValue;
16772            tag = value;
16773            lastProps = propKey;
16774            null != _propKey8 ? updateOptions(domElement, !!tag, _propKey8, false) : !!lastProps !== !!tag && (null != nextProps ? updateOptions(domElement, !!tag, nextProps, true) : updateOptions(domElement, !!tag, tag ? [] : "", false));
16775            return;
16776          case "textarea":
16777            propKey = _propKey8 = null;
16778            for (defaultValue in lastProps)
16779              if (name = lastProps[defaultValue], lastProps.hasOwnProperty(defaultValue) && null != name && !nextProps.hasOwnProperty(defaultValue))
16780                switch (defaultValue) {
16781                  case "value":
16782                    break;
16783                  case "children":
16784                    break;
16785                  default:
16786                    setProp(domElement, tag, defaultValue, null, nextProps, name);
16787                }
16788            for (value in nextProps)
16789              if (name = nextProps[value], type = lastProps[value], nextProps.hasOwnProperty(value) && (null != name || null != type))
16790                switch (value) {
16791                  case "value":
16792                    _propKey8 = name;
16793                    break;
16794                  case "defaultValue":
16795                    propKey = name;
16796                    break;
16797                  case "children":
16798                    break;
16799                  case "dangerouslySetInnerHTML":
16800                    if (null != name)
16801                      throw Error(
16802                        "`dangerouslySetInnerHTML` does not make sense on <textarea>."
16803                      );
16804                    break;
16805                  default:
16806                    name !== type && setProp(domElement, tag, value, name, nextProps, type);
16807                }
16808            updateTextarea(domElement, _propKey8, propKey);
16809            return;
16810          case "option":
16811            for (var _propKey13 in lastProps)
16812              if (_propKey8 = lastProps[_propKey13], lastProps.hasOwnProperty(_propKey13) && null != _propKey8 && !nextProps.hasOwnProperty(_propKey13))
16813                switch (_propKey13) {
16814                  case "selected":
16815                    domElement.selected = false;
16816                    break;
16817                  default:
16818                    setProp(
16819                      domElement,
16820                      tag,
16821                      _propKey13,
16822                      null,
16823                      nextProps,
16824                      _propKey8
16825                    );
16826                }
16827            for (lastDefaultValue in nextProps)
16828              if (_propKey8 = nextProps[lastDefaultValue], propKey = lastProps[lastDefaultValue], nextProps.hasOwnProperty(lastDefaultValue) && _propKey8 !== propKey && (null != _propKey8 || null != propKey))
16829                switch (lastDefaultValue) {
16830                  case "selected":
16831                    domElement.selected = _propKey8 && "function" !== typeof _propKey8 && "symbol" !== typeof _propKey8;
16832                    break;
16833                  default:
16834                    setProp(
16835                      domElement,
16836                      tag,
16837                      lastDefaultValue,
16838                      _propKey8,
16839                      nextProps,
16840                      propKey
16841                    );
16842                }
16843            return;
16844          case "img":
16845          case "link":
16846          case "area":
16847          case "base":
16848          case "br":
16849          case "col":
16850          case "embed":
16851          case "hr":
16852          case "keygen":
16853          case "meta":
16854          case "param":
16855          case "source":
16856          case "track":
16857          case "wbr":
16858          case "menuitem":
16859            for (var _propKey15 in lastProps)
16860              _propKey8 = lastProps[_propKey15], lastProps.hasOwnProperty(_propKey15) && null != _propKey8 && !nextProps.hasOwnProperty(_propKey15) && setProp(
16861                domElement,
16862                tag,
16863                _propKey15,
16864                null,
16865                nextProps,
16866                _propKey8
16867              );
16868            for (checked in nextProps)
16869              if (_propKey8 = nextProps[checked], propKey = lastProps[checked], nextProps.hasOwnProperty(checked) && _propKey8 !== propKey && (null != _propKey8 || null != propKey))
16870                switch (checked) {
16871                  case "children":
16872                  case "dangerouslySetInnerHTML":
16873                    if (null != _propKey8)
16874                      throw Error(
16875                        tag + " is a void element tag and must neither have `children` nor use `dangerouslySetInnerHTML`."
16876                      );
16877                    break;
16878                  default:
16879                    setProp(
16880                      domElement,
16881                      tag,
16882                      checked,
16883                      _propKey8,
16884                      nextProps,
16885                      propKey
16886                    );
16887                }
16888            return;
16889          default:
16890            if (isCustomElement(tag)) {
16891              for (var _propKey17 in lastProps)
16892                _propKey8 = lastProps[_propKey17], lastProps.hasOwnProperty(_propKey17) && void 0 !== _propKey8 && !nextProps.hasOwnProperty(_propKey17) && setPropOnCustomElement(
16893                  domElement,
16894                  tag,
16895                  _propKey17,
16896                  void 0,
16897                  nextProps,
16898                  _propKey8
16899                );
16900              for (defaultChecked in nextProps)
16901                _propKey8 = nextProps[defaultChecked], propKey = lastProps[defaultChecked], !nextProps.hasOwnProperty(defaultChecked) || _propKey8 === propKey || void 0 === _propKey8 && void 0 === propKey || setPropOnCustomElement(
16902                  domElement,
16903                  tag,
16904                  defaultChecked,
16905                  _propKey8,
16906                  nextProps,
16907                  propKey
16908                );
16909              return;
16910            }
16911        }
16912        for (var _propKey19 in lastProps)
16913          _propKey8 = lastProps[_propKey19], lastProps.hasOwnProperty(_propKey19) && null != _propKey8 && !nextProps.hasOwnProperty(_propKey19) && setProp(domElement, tag, _propKey19, null, nextProps, _propKey8);
16914        for (lastProp in nextProps)
16915          _propKey8 = nextProps[lastProp], propKey = lastProps[lastProp], !nextProps.hasOwnProperty(lastProp) || _propKey8 === propKey || null == _propKey8 && null == propKey || setProp(domElement, tag, lastProp, _propKey8, nextProps, propKey);
16916      }
16917      function getPropNameFromAttributeName(attrName) {
16918        switch (attrName) {
16919          case "class":
16920            return "className";
16921          case "for":
16922            return "htmlFor";
16923          default:
16924            return attrName;
16925        }
16926      }
16927      function getStylesObjectFromElement(domElement) {
16928        var serverValueInObjectForm = {};
16929        domElement = domElement.style;
16930        for (var i3 = 0; i3 < domElement.length; i3++) {
16931          var styleName = domElement[i3];
16932          serverValueInObjectForm[styleName] = domElement.getPropertyValue(styleName);
16933        }
16934        return serverValueInObjectForm;
16935      }
16936      function diffHydratedStyles(domElement, value$jscomp$0, serverDifferences) {
16937        if (null != value$jscomp$0 && "object" !== typeof value$jscomp$0)
16938          console.error(
16939            "The `style` prop expects a mapping from style properties to values, not a string. For example, style={{marginRight: spacing + 'em'}} when using JSX."
16940          );
16941        else {
16942          var clientValue;
16943          var delimiter = clientValue = "", styleName;
16944          for (styleName in value$jscomp$0)
16945            if (value$jscomp$0.hasOwnProperty(styleName)) {
16946              var value = value$jscomp$0[styleName];
16947              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 = ";");
16948            }
16949          clientValue = clientValue || null;
16950          value$jscomp$0 = domElement.getAttribute("style");
16951          value$jscomp$0 !== clientValue && (clientValue = normalizeMarkupForTextOrAttribute(clientValue), normalizeMarkupForTextOrAttribute(value$jscomp$0) !== clientValue && (serverDifferences.style = getStylesObjectFromElement(domElement)));
16952        }
16953      }
16954      function hydrateAttribute(domElement, propKey, attributeName, value, extraAttributes, serverDifferences) {
16955        extraAttributes.delete(attributeName);
16956        domElement = domElement.getAttribute(attributeName);
16957        if (null === domElement)
16958          switch (typeof value) {
16959            case "undefined":
16960            case "function":
16961            case "symbol":
16962            case "boolean":
16963              return;
16964          }
16965        else if (null != value)
16966          switch (typeof value) {
16967            case "function":
16968            case "symbol":
16969            case "boolean":
16970              break;
16971            default:
16972              if (checkAttributeStringCoercion(value, propKey), domElement === "" + value)
16973                return;
16974          }
16975        warnForPropDifference(propKey, domElement, value, serverDifferences);
16976      }
16977      function hydrateBooleanAttribute(domElement, propKey, attributeName, value, extraAttributes, serverDifferences) {
16978        extraAttributes.delete(attributeName);
16979        domElement = domElement.getAttribute(attributeName);
16980        if (null === domElement) {
16981          switch (typeof value) {
16982            case "function":
16983            case "symbol":
16984              return;
16985          }
16986          if (!value) return;
16987        } else
16988          switch (typeof value) {
16989            case "function":
16990            case "symbol":
16991              break;
16992            default:
16993              if (value) return;
16994          }
16995        warnForPropDifference(propKey, domElement, value, serverDifferences);
16996      }
16997      function hydrateBooleanishAttribute(domElement, propKey, attributeName, value, extraAttributes, serverDifferences) {
16998        extraAttributes.delete(attributeName);
16999        domElement = domElement.getAttribute(attributeName);
17000        if (null === domElement)
17001          switch (typeof value) {
17002            case "undefined":
17003            case "function":
17004            case "symbol":
17005              return;
17006          }
17007        else if (null != value)
17008          switch (typeof value) {
17009            case "function":
17010            case "symbol":
17011              break;
17012            default:
17013              if (checkAttributeStringCoercion(value, attributeName), domElement === "" + value)
17014                return;
17015          }
17016        warnForPropDifference(propKey, domElement, value, serverDifferences);
17017      }
17018      function hydrateNumericAttribute(domElement, propKey, attributeName, value, extraAttributes, serverDifferences) {
17019        extraAttributes.delete(attributeName);
17020        domElement = domElement.getAttribute(attributeName);
17021        if (null === domElement)
17022          switch (typeof value) {
17023            case "undefined":
17024            case "function":
17025            case "symbol":
17026            case "boolean":
17027              return;
17028            default:
17029              if (isNaN(value)) return;
17030          }
17031        else if (null != value)
17032          switch (typeof value) {
17033            case "function":
17034            case "symbol":
17035            case "boolean":
17036              break;
17037            default:
17038              if (!isNaN(value) && (checkAttributeStringCoercion(value, propKey), domElement === "" + value))
17039                return;
17040          }
17041        warnForPropDifference(propKey, domElement, value, serverDifferences);
17042      }
17043      function hydrateSanitizedAttribute(domElement, propKey, attributeName, value, extraAttributes, serverDifferences) {
17044        extraAttributes.delete(attributeName);
17045        domElement = domElement.getAttribute(attributeName);
17046        if (null === domElement)
17047          switch (typeof value) {
17048            case "undefined":
17049            case "function":
17050            case "symbol":
17051            case "boolean":
17052              return;
17053          }
17054        else if (null != value)
17055          switch (typeof value) {
17056            case "function":
17057            case "symbol":
17058            case "boolean":
17059              break;
17060            default:
17061              if (checkAttributeStringCoercion(value, propKey), attributeName = sanitizeURL("" + value), domElement === attributeName)
17062                return;
17063          }
17064        warnForPropDifference(propKey, domElement, value, serverDifferences);
17065      }
17066      function diffHydratedProperties(domElement, tag, props, hostContext) {
17067        for (var serverDifferences = {}, extraAttributes = /* @__PURE__ */ new Set(), attributes = domElement.attributes, i3 = 0; i3 < attributes.length; i3++)
17068          switch (attributes[i3].name.toLowerCase()) {
17069            case "value":
17070              break;
17071            case "checked":
17072              break;
17073            case "selected":
17074              break;
17075            default:
17076              extraAttributes.add(attributes[i3].name);
17077          }
17078        if (isCustomElement(tag))
17079          for (var propKey in props) {
17080            if (props.hasOwnProperty(propKey)) {
17081              var value = props[propKey];
17082              if (null != value) {
17083                if (registrationNameDependencies.hasOwnProperty(propKey))
17084                  "function" !== typeof value && warnForInvalidEventListener(propKey, value);
17085                else if (true !== props.suppressHydrationWarning)
17086                  switch (propKey) {
17087                    case "children":
17088                      "string" !== typeof value && "number" !== typeof value || warnForPropDifference(
17089                        "children",
17090                        domElement.textContent,
17091                        value,
17092                        serverDifferences
17093                      );
17094                      continue;
17095                    case "suppressContentEditableWarning":
17096                    case "suppressHydrationWarning":
17097                    case "defaultValue":
17098                    case "defaultChecked":
17099                    case "innerHTML":
17100                    case "ref":
17101                      continue;
17102                    case "dangerouslySetInnerHTML":
17103                      attributes = domElement.innerHTML;
17104                      value = value ? value.__html : void 0;
17105                      null != value && (value = normalizeHTML(domElement, value), warnForPropDifference(
17106                        propKey,
17107                        attributes,
17108                        value,
17109                        serverDifferences
17110                      ));
17111                      continue;
17112                    case "style":
17113                      extraAttributes.delete(propKey);
17114                      diffHydratedStyles(domElement, value, serverDifferences);
17115                      continue;
17116                    case "offsetParent":
17117                    case "offsetTop":
17118                    case "offsetLeft":
17119                    case "offsetWidth":
17120                    case "offsetHeight":
17121                    case "isContentEditable":
17122                    case "outerText":
17123                    case "outerHTML":
17124                      extraAttributes.delete(propKey.toLowerCase());
17125                      console.error(
17126                        "Assignment to read-only property will result in a no-op: `%s`",
17127                        propKey
17128                      );
17129                      continue;
17130                    case "className":
17131                      extraAttributes.delete("class");
17132                      attributes = getValueForAttributeOnCustomComponent(
17133                        domElement,
17134                        "class",
17135                        value
17136                      );
17137                      warnForPropDifference(
17138                        "className",
17139                        attributes,
17140                        value,
17141                        serverDifferences
17142                      );
17143                      continue;
17144                    default:
17145                      hostContext.context === HostContextNamespaceNone && "svg" !== tag && "math" !== tag ? extraAttributes.delete(propKey.toLowerCase()) : extraAttributes.delete(propKey), attributes = getValueForAttributeOnCustomComponent(
17146                        domElement,
17147                        propKey,
17148                        value
17149                      ), warnForPropDifference(
17150                        propKey,
17151                        attributes,
17152                        value,
17153                        serverDifferences
17154                      );
17155                  }
17156              }
17157            }
17158          }
17159        else
17160          for (value in props)
17161            if (props.hasOwnProperty(value) && (propKey = props[value], null != propKey)) {
17162              if (registrationNameDependencies.hasOwnProperty(value))
17163                "function" !== typeof propKey && warnForInvalidEventListener(value, propKey);
17164              else if (true !== props.suppressHydrationWarning)
17165                switch (value) {
17166                  case "children":
17167                    "string" !== typeof propKey && "number" !== typeof propKey || warnForPropDifference(
17168                      "children",
17169                      domElement.textContent,
17170                      propKey,
17171                      serverDifferences
17172                    );
17173                    continue;
17174                  case "suppressContentEditableWarning":
17175                  case "suppressHydrationWarning":
17176                  case "value":
17177                  case "checked":
17178                  case "selected":
17179                  case "defaultValue":
17180                  case "defaultChecked":
17181                  case "innerHTML":
17182                  case "ref":
17183                    continue;
17184                  case "dangerouslySetInnerHTML":
17185                    attributes = domElement.innerHTML;
17186                    propKey = propKey ? propKey.__html : void 0;
17187                    null != propKey && (propKey = normalizeHTML(domElement, propKey), attributes !== propKey && (serverDifferences[value] = { __html: attributes }));
17188                    continue;
17189                  case "className":
17190                    hydrateAttribute(
17191                      domElement,
17192                      value,
17193                      "class",
17194                      propKey,
17195                      extraAttributes,
17196                      serverDifferences
17197                    );
17198                    continue;
17199                  case "tabIndex":
17200                    hydrateAttribute(
17201                      domElement,
17202                      value,
17203                      "tabindex",
17204                      propKey,
17205                      extraAttributes,
17206                      serverDifferences
17207                    );
17208                    continue;
17209                  case "style":
17210                    extraAttributes.delete(value);
17211                    diffHydratedStyles(domElement, propKey, serverDifferences);
17212                    continue;
17213                  case "multiple":
17214                    extraAttributes.delete(value);
17215                    warnForPropDifference(
17216                      value,
17217                      domElement.multiple,
17218                      propKey,
17219                      serverDifferences
17220                    );
17221                    continue;
17222                  case "muted":
17223                    extraAttributes.delete(value);
17224                    warnForPropDifference(
17225                      value,
17226                      domElement.muted,
17227                      propKey,
17228                      serverDifferences
17229                    );
17230                    continue;
17231                  case "autoFocus":
17232                    extraAttributes.delete("autofocus");
17233                    warnForPropDifference(
17234                      value,
17235                      domElement.autofocus,
17236                      propKey,
17237                      serverDifferences
17238                    );
17239                    continue;
17240                  case "data":
17241                    if ("object" !== tag) {
17242                      extraAttributes.delete(value);
17243                      attributes = domElement.getAttribute("data");
17244                      warnForPropDifference(
17245                        value,
17246                        attributes,
17247                        propKey,
17248                        serverDifferences
17249                      );
17250                      continue;
17251                    }
17252                  case "src":
17253                  case "href":
17254                    if (!("" !== propKey || "a" === tag && "href" === value || "object" === tag && "data" === value)) {
17255                      "src" === value ? console.error(
17256                        '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.',
17257                        value,
17258                        value
17259                      ) : console.error(
17260                        '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.',
17261                        value,
17262                        value
17263                      );
17264                      continue;
17265                    }
17266                    hydrateSanitizedAttribute(
17267                      domElement,
17268                      value,
17269                      value,
17270                      propKey,
17271                      extraAttributes,
17272                      serverDifferences
17273                    );
17274                    continue;
17275                  case "action":
17276                  case "formAction":
17277                    attributes = domElement.getAttribute(value);
17278                    if ("function" === typeof propKey) {
17279                      extraAttributes.delete(value.toLowerCase());
17280                      "formAction" === value ? (extraAttributes.delete("name"), extraAttributes.delete("formenctype"), extraAttributes.delete("formmethod"), extraAttributes.delete("formtarget")) : (extraAttributes.delete("enctype"), extraAttributes.delete("method"), extraAttributes.delete("target"));
17281                      continue;
17282                    } else if (attributes === EXPECTED_FORM_ACTION_URL) {
17283                      extraAttributes.delete(value.toLowerCase());
17284                      warnForPropDifference(
17285                        value,
17286                        "function",
17287                        propKey,
17288                        serverDifferences
17289                      );
17290                      continue;
17291                    }
17292                    hydrateSanitizedAttribute(
17293                      domElement,
17294                      value,
17295                      value.toLowerCase(),
17296                      propKey,
17297                      extraAttributes,
17298                      serverDifferences
17299                    );
17300                    continue;
17301                  case "xlinkHref":
17302                    hydrateSanitizedAttribute(
17303                      domElement,
17304                      value,
17305                      "xlink:href",
17306                      propKey,
17307                      extraAttributes,
17308                      serverDifferences
17309                    );
17310                    continue;
17311                  case "contentEditable":
17312                    hydrateBooleanishAttribute(
17313                      domElement,
17314                      value,
17315                      "contenteditable",
17316                      propKey,
17317                      extraAttributes,
17318                      serverDifferences
17319                    );
17320                    continue;
17321                  case "spellCheck":
17322                    hydrateBooleanishAttribute(
17323                      domElement,
17324                      value,
17325                      "spellcheck",
17326                      propKey,
17327                      extraAttributes,
17328                      serverDifferences
17329                    );
17330                    continue;
17331                  case "draggable":
17332                  case "autoReverse":
17333                  case "externalResourcesRequired":
17334                  case "focusable":
17335                  case "preserveAlpha":
17336                    hydrateBooleanishAttribute(
17337                      domElement,
17338                      value,
17339                      value,
17340                      propKey,
17341                      extraAttributes,
17342                      serverDifferences
17343                    );
17344                    continue;
17345                  case "allowFullScreen":
17346                  case "async":
17347                  case "autoPlay":
17348                  case "controls":
17349                  case "default":
17350                  case "defer":
17351                  case "disabled":
17352                  case "disablePictureInPicture":
17353                  case "disableRemotePlayback":
17354                  case "formNoValidate":
17355                  case "hidden":
17356                  case "loop":
17357                  case "noModule":
17358                  case "noValidate":
17359                  case "open":
17360                  case "playsInline":
17361                  case "readOnly":
17362                  case "required":
17363                  case "reversed":
17364                  case "scoped":
17365                  case "seamless":
17366                  case "itemScope":
17367                    hydrateBooleanAttribute(
17368                      domElement,
17369                      value,
17370                      value.toLowerCase(),
17371                      propKey,
17372                      extraAttributes,
17373                      serverDifferences
17374                    );
17375                    continue;
17376                  case "capture":
17377                  case "download":
17378                    a: {
17379                      i3 = domElement;
17380                      var attributeName = attributes = value, serverDifferences$jscomp$0 = serverDifferences;
17381                      extraAttributes.delete(attributeName);
17382                      i3 = i3.getAttribute(attributeName);
17383                      if (null === i3)
17384                        switch (typeof propKey) {
17385                          case "undefined":
17386                          case "function":
17387                          case "symbol":
17388                            break a;
17389                          default:
17390                            if (false === propKey) break a;
17391                        }
17392                      else if (null != propKey)
17393                        switch (typeof propKey) {
17394                          case "function":
17395                          case "symbol":
17396                            break;
17397                          case "boolean":
17398                            if (true === propKey && "" === i3) break a;
17399                            break;
17400                          default:
17401                            if (checkAttributeStringCoercion(propKey, attributes), i3 === "" + propKey)
17402                              break a;
17403                        }
17404                      warnForPropDifference(
17405                        attributes,
17406                        i3,
17407                        propKey,
17408                        serverDifferences$jscomp$0
17409                      );
17410                    }
17411                    continue;
17412                  case "cols":
17413                  case "rows":
17414                  case "size":
17415                  case "span":
17416                    a: {
17417                      i3 = domElement;
17418                      attributeName = attributes = value;
17419                      serverDifferences$jscomp$0 = serverDifferences;
17420                      extraAttributes.delete(attributeName);
17421                      i3 = i3.getAttribute(attributeName);
17422                      if (null === i3)
17423                        switch (typeof propKey) {
17424                          case "undefined":
17425                          case "function":
17426                          case "symbol":
17427                          case "boolean":
17428                            break a;
17429                          default:
17430                            if (isNaN(propKey) || 1 > propKey) break a;
17431                        }
17432                      else if (null != propKey)
17433                        switch (typeof propKey) {
17434                          case "function":
17435                          case "symbol":
17436                          case "boolean":
17437                            break;
17438                          default:
17439                            if (!(isNaN(propKey) || 1 > propKey) && (checkAttributeStringCoercion(propKey, attributes), i3 === "" + propKey))
17440                              break a;
17441                        }
17442                      warnForPropDifference(
17443                        attributes,
17444                        i3,
17445                        propKey,
17446                        serverDifferences$jscomp$0
17447                      );
17448                    }
17449                    continue;
17450                  case "rowSpan":
17451                    hydrateNumericAttribute(
17452                      domElement,
17453                      value,
17454                      "rowspan",
17455                      propKey,
17456                      extraAttributes,
17457                      serverDifferences
17458                    );
17459                    continue;
17460                  case "start":
17461                    hydrateNumericAttribute(
17462                      domElement,
17463                      value,
17464                      value,
17465                      propKey,
17466                      extraAttributes,
17467                      serverDifferences
17468                    );
17469                    continue;
17470                  case "xHeight":
17471                    hydrateAttribute(
17472                      domElement,
17473                      value,
17474                      "x-height",
17475                      propKey,
17476                      extraAttributes,
17477                      serverDifferences
17478                    );
17479                    continue;
17480                  case "xlinkActuate":
17481                    hydrateAttribute(
17482                      domElement,
17483                      value,
17484                      "xlink:actuate",
17485                      propKey,
17486                      extraAttributes,
17487                      serverDifferences
17488                    );
17489                    continue;
17490                  case "xlinkArcrole":
17491                    hydrateAttribute(
17492                      domElement,
17493                      value,
17494                      "xlink:arcrole",
17495                      propKey,
17496                      extraAttributes,
17497                      serverDifferences
17498                    );
17499                    continue;
17500                  case "xlinkRole":
17501                    hydrateAttribute(
17502                      domElement,
17503                      value,
17504                      "xlink:role",
17505                      propKey,
17506                      extraAttributes,
17507                      serverDifferences
17508                    );
17509                    continue;
17510                  case "xlinkShow":
17511                    hydrateAttribute(
17512                      domElement,
17513                      value,
17514                      "xlink:show",
17515                      propKey,
17516                      extraAttributes,
17517                      serverDifferences
17518                    );
17519                    continue;
17520                  case "xlinkTitle":
17521                    hydrateAttribute(
17522                      domElement,
17523                      value,
17524                      "xlink:title",
17525                      propKey,
17526                      extraAttributes,
17527                      serverDifferences
17528                    );
17529                    continue;
17530                  case "xlinkType":
17531                    hydrateAttribute(
17532                      domElement,
17533                      value,
17534                      "xlink:type",
17535                      propKey,
17536                      extraAttributes,
17537                      serverDifferences
17538                    );
17539                    continue;
17540                  case "xmlBase":
17541                    hydrateAttribute(
17542                      domElement,
17543                      value,
17544                      "xml:base",
17545                      propKey,
17546                      extraAttributes,
17547                      serverDifferences
17548                    );
17549                    continue;
17550                  case "xmlLang":
17551                    hydrateAttribute(
17552                      domElement,
17553                      value,
17554                      "xml:lang",
17555                      propKey,
17556                      extraAttributes,
17557                      serverDifferences
17558                    );
17559                    continue;
17560                  case "xmlSpace":
17561                    hydrateAttribute(
17562                      domElement,
17563                      value,
17564                      "xml:space",
17565                      propKey,
17566                      extraAttributes,
17567                      serverDifferences
17568                    );
17569                    continue;
17570                  case "inert":
17571                    "" !== propKey || didWarnForNewBooleanPropsWithEmptyValue[value] || (didWarnForNewBooleanPropsWithEmptyValue[value] = true, console.error(
17572                      "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.",
17573                      value
17574                    ));
17575                    hydrateBooleanAttribute(
17576                      domElement,
17577                      value,
17578                      value,
17579                      propKey,
17580                      extraAttributes,
17581                      serverDifferences
17582                    );
17583                    continue;
17584                  default:
17585                    if (!(2 < value.length) || "o" !== value[0] && "O" !== value[0] || "n" !== value[1] && "N" !== value[1]) {
17586                      i3 = getAttributeAlias(value);
17587                      attributes = false;
17588                      hostContext.context === HostContextNamespaceNone && "svg" !== tag && "math" !== tag ? extraAttributes.delete(i3.toLowerCase()) : (attributeName = value.toLowerCase(), attributeName = possibleStandardNames.hasOwnProperty(
17589                        attributeName
17590                      ) ? possibleStandardNames[attributeName] || null : null, null !== attributeName && attributeName !== value && (attributes = true, extraAttributes.delete(attributeName)), extraAttributes.delete(i3));
17591                      a: if (attributeName = domElement, serverDifferences$jscomp$0 = i3, i3 = propKey, isAttributeNameSafe(serverDifferences$jscomp$0))
17592                        if (attributeName.hasAttribute(serverDifferences$jscomp$0))
17593                          attributeName = attributeName.getAttribute(
17594                            serverDifferences$jscomp$0
17595                          ), checkAttributeStringCoercion(
17596                            i3,
17597                            serverDifferences$jscomp$0
17598                          ), i3 = attributeName === "" + i3 ? i3 : attributeName;
17599                        else {
17600                          switch (typeof i3) {
17601                            case "function":
17602                            case "symbol":
17603                              break a;
17604                            case "boolean":
17605                              if (attributeName = serverDifferences$jscomp$0.toLowerCase().slice(0, 5), "data-" !== attributeName && "aria-" !== attributeName)
17606                                break a;
17607                          }
17608                          i3 = void 0 === i3 ? void 0 : null;
17609                        }
17610                      else i3 = void 0;
17611                      attributes || warnForPropDifference(
17612                        value,
17613                        i3,
17614                        propKey,
17615                        serverDifferences
17616                      );
17617                    }
17618                }
17619            }
17620        0 < extraAttributes.size && true !== props.suppressHydrationWarning && warnForExtraAttributes(domElement, extraAttributes, serverDifferences);
17621        return 0 === Object.keys(serverDifferences).length ? null : serverDifferences;
17622      }
17623      function propNamesListJoin(list, combinator) {
17624        switch (list.length) {
17625          case 0:
17626            return "";
17627          case 1:
17628            return list[0];
17629          case 2:
17630            return list[0] + " " + combinator + " " + list[1];
17631          default:
17632            return list.slice(0, -1).join(", ") + ", " + combinator + " " + list[list.length - 1];
17633        }
17634      }
17635      function isLikelyStaticResource(initiatorType) {
17636        switch (initiatorType) {
17637          case "css":
17638          case "script":
17639          case "font":
17640          case "img":
17641          case "image":
17642          case "input":
17643          case "link":
17644            return true;
17645          default:
17646            return false;
17647        }
17648      }
17649      function estimateBandwidth() {
17650        if ("function" === typeof performance.getEntriesByType) {
17651          for (var count = 0, bits = 0, resourceEntries = performance.getEntriesByType("resource"), i3 = 0; i3 < resourceEntries.length; i3++) {
17652            var entry = resourceEntries[i3], transferSize = entry.transferSize, initiatorType = entry.initiatorType, duration = entry.duration;
17653            if (transferSize && duration && isLikelyStaticResource(initiatorType)) {
17654              initiatorType = 0;
17655              duration = entry.responseEnd;
17656              for (i3 += 1; i3 < resourceEntries.length; i3++) {
17657                var overlapEntry = resourceEntries[i3], overlapStartTime = overlapEntry.startTime;
17658                if (overlapStartTime > duration) break;
17659                var overlapTransferSize = overlapEntry.transferSize, overlapInitiatorType = overlapEntry.initiatorType;
17660                overlapTransferSize && isLikelyStaticResource(overlapInitiatorType) && (overlapEntry = overlapEntry.responseEnd, initiatorType += overlapTransferSize * (overlapEntry < duration ? 1 : (duration - overlapStartTime) / (overlapEntry - overlapStartTime)));
17661              }
17662              --i3;
17663              bits += 8 * (transferSize + initiatorType) / (entry.duration / 1e3);
17664              count++;
17665              if (10 < count) break;
17666            }
17667          }
17668          if (0 < count) return bits / count / 1e6;
17669        }
17670        return navigator.connection && (count = navigator.connection.downlink, "number" === typeof count) ? count : 5;
17671      }
17672      function getOwnerDocumentFromRootContainer(rootContainerElement) {
17673        return 9 === rootContainerElement.nodeType ? rootContainerElement : rootContainerElement.ownerDocument;
17674      }
17675      function getOwnHostContext(namespaceURI) {
17676        switch (namespaceURI) {
17677          case SVG_NAMESPACE:
17678            return HostContextNamespaceSvg;
17679          case MATH_NAMESPACE:
17680            return HostContextNamespaceMath;
17681          default:
17682            return HostContextNamespaceNone;
17683        }
17684      }
17685      function getChildHostContextProd(parentNamespace, type) {
17686        if (parentNamespace === HostContextNamespaceNone)
17687          switch (type) {
17688            case "svg":
17689              return HostContextNamespaceSvg;
17690            case "math":
17691              return HostContextNamespaceMath;
17692            default:
17693              return HostContextNamespaceNone;
17694          }
17695        return parentNamespace === HostContextNamespaceSvg && "foreignObject" === type ? HostContextNamespaceNone : parentNamespace;
17696      }
17697      function shouldSetTextContent(type, props) {
17698        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;
17699      }
17700      function shouldAttemptEagerTransition() {
17701        var event = window.event;
17702        if (event && "popstate" === event.type) {
17703          if (event === currentPopstateTransitionEvent) return false;
17704          currentPopstateTransitionEvent = event;
17705          return true;
17706        }
17707        currentPopstateTransitionEvent = null;
17708        return false;
17709      }
17710      function resolveEventType() {
17711        var event = window.event;
17712        return event && event !== schedulerEvent ? event.type : null;
17713      }
17714      function resolveEventTimeStamp() {
17715        var event = window.event;
17716        return event && event !== schedulerEvent ? event.timeStamp : -1.1;
17717      }
17718      function handleErrorInNextTick(error2) {
17719        setTimeout(function() {
17720          throw error2;
17721        });
17722      }
17723      function commitMount(domElement, type, newProps) {
17724        switch (type) {
17725          case "button":
17726          case "input":
17727          case "select":
17728          case "textarea":
17729            newProps.autoFocus && domElement.focus();
17730            break;
17731          case "img":
17732            newProps.src ? domElement.src = newProps.src : newProps.srcSet && (domElement.srcset = newProps.srcSet);
17733        }
17734      }
17735      function commitHydratedInstance() {
17736      }
17737      function commitUpdate(domElement, type, oldProps, newProps) {
17738        updateProperties(domElement, type, oldProps, newProps);
17739        domElement[internalPropsKey] = newProps;
17740      }
17741      function resetTextContent(domElement) {
17742        setTextContent(domElement, "");
17743      }
17744      function commitTextUpdate(textInstance, oldText, newText) {
17745        textInstance.nodeValue = newText;
17746      }
17747      function warnForReactChildrenConflict(container) {
17748        if (!container.__reactWarnedAboutChildrenConflict) {
17749          var props = container[internalPropsKey] || null;
17750          if (null !== props) {
17751            var fiber = getInstanceFromNode(container);
17752            null !== fiber && ("string" === typeof props.children || "number" === typeof props.children ? (container.__reactWarnedAboutChildrenConflict = true, runWithFiberInDEV(fiber, function() {
17753              console.error(
17754                '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.'
17755              );
17756            })) : null != props.dangerouslySetInnerHTML && (container.__reactWarnedAboutChildrenConflict = true, runWithFiberInDEV(fiber, function() {
17757              console.error(
17758                '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.'
17759              );
17760            })));
17761          }
17762        }
17763      }
17764      function isSingletonScope(type) {
17765        return "head" === type;
17766      }
17767      function removeChild(parentInstance, child) {
17768        parentInstance.removeChild(child);
17769      }
17770      function removeChildFromContainer(container, child) {
17771        (9 === container.nodeType ? container.body : "HTML" === container.nodeName ? container.ownerDocument.body : container).removeChild(child);
17772      }
17773      function clearHydrationBoundary(parentInstance, hydrationInstance) {
17774        var node = hydrationInstance, depth = 0;
17775        do {
17776          var nextNode = node.nextSibling;
17777          parentInstance.removeChild(node);
17778          if (nextNode && 8 === nextNode.nodeType)
17779            if (node = nextNode.data, node === SUSPENSE_END_DATA || node === ACTIVITY_END_DATA) {
17780              if (0 === depth) {
17781                parentInstance.removeChild(nextNode);
17782                retryIfBlockedOn(hydrationInstance);
17783                return;
17784              }
17785              depth--;
17786            } 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)
17787              depth++;
17788            else if (node === PREAMBLE_CONTRIBUTION_HTML)
17789              releaseSingletonInstance(
17790                parentInstance.ownerDocument.documentElement
17791              );
17792            else if (node === PREAMBLE_CONTRIBUTION_HEAD) {
17793              node = parentInstance.ownerDocument.head;
17794              releaseSingletonInstance(node);
17795              for (var node$jscomp$0 = node.firstChild; node$jscomp$0; ) {
17796                var nextNode$jscomp$0 = node$jscomp$0.nextSibling, nodeName = node$jscomp$0.nodeName;
17797                node$jscomp$0[internalHoistableMarker] || "SCRIPT" === nodeName || "STYLE" === nodeName || "LINK" === nodeName && "stylesheet" === node$jscomp$0.rel.toLowerCase() || node.removeChild(node$jscomp$0);
17798                node$jscomp$0 = nextNode$jscomp$0;
17799              }
17800            } else
17801              node === PREAMBLE_CONTRIBUTION_BODY && releaseSingletonInstance(parentInstance.ownerDocument.body);
17802          node = nextNode;
17803        } while (node);
17804        retryIfBlockedOn(hydrationInstance);
17805      }
17806      function hideOrUnhideDehydratedBoundary(suspenseInstance, isHidden) {
17807        var node = suspenseInstance;
17808        suspenseInstance = 0;
17809        do {
17810          var nextNode = node.nextSibling;
17811          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 || "");
17812          if (nextNode && 8 === nextNode.nodeType)
17813            if (node = nextNode.data, node === SUSPENSE_END_DATA)
17814              if (0 === suspenseInstance) break;
17815              else suspenseInstance--;
17816            else
17817              node !== SUSPENSE_START_DATA && node !== SUSPENSE_PENDING_START_DATA && node !== SUSPENSE_QUEUED_START_DATA && node !== SUSPENSE_FALLBACK_START_DATA || suspenseInstance++;
17818          node = nextNode;
17819        } while (node);
17820      }
17821      function hideDehydratedBoundary(suspenseInstance) {
17822        hideOrUnhideDehydratedBoundary(suspenseInstance, true);
17823      }
17824      function hideInstance(instance) {
17825        instance = instance.style;
17826        "function" === typeof instance.setProperty ? instance.setProperty("display", "none", "important") : instance.display = "none";
17827      }
17828      function hideTextInstance(textInstance) {
17829        textInstance.nodeValue = "";
17830      }
17831      function unhideDehydratedBoundary(dehydratedInstance) {
17832        hideOrUnhideDehydratedBoundary(dehydratedInstance, false);
17833      }
17834      function unhideInstance(instance, props) {
17835        props = props[STYLE];
17836        props = void 0 !== props && null !== props && props.hasOwnProperty("display") ? props.display : null;
17837        instance.style.display = null == props || "boolean" === typeof props ? "" : ("" + props).trim();
17838      }
17839      function unhideTextInstance(textInstance, text) {
17840        textInstance.nodeValue = text;
17841      }
17842      function clearContainerSparingly(container) {
17843        var nextNode = container.firstChild;
17844        nextNode && 10 === nextNode.nodeType && (nextNode = nextNode.nextSibling);
17845        for (; nextNode; ) {
17846          var node = nextNode;
17847          nextNode = nextNode.nextSibling;
17848          switch (node.nodeName) {
17849            case "HTML":
17850            case "HEAD":
17851            case "BODY":
17852              clearContainerSparingly(node);
17853              detachDeletedInstance(node);
17854              continue;
17855            case "SCRIPT":
17856            case "STYLE":
17857              continue;
17858            case "LINK":
17859              if ("stylesheet" === node.rel.toLowerCase()) continue;
17860          }
17861          container.removeChild(node);
17862        }
17863      }
17864      function canHydrateInstance(instance, type, props, inRootOrSingleton) {
17865        for (; 1 === instance.nodeType; ) {
17866          var anyProps = props;
17867          if (instance.nodeName.toLowerCase() !== type.toLowerCase()) {
17868            if (!inRootOrSingleton && ("INPUT" !== instance.nodeName || "hidden" !== instance.type))
17869              break;
17870          } else if (!inRootOrSingleton)
17871            if ("input" === type && "hidden" === instance.type) {
17872              checkAttributeStringCoercion(anyProps.name, "name");
17873              var name = null == anyProps.name ? null : "" + anyProps.name;
17874              if ("hidden" === anyProps.type && instance.getAttribute("name") === name)
17875                return instance;
17876            } else return instance;
17877          else if (!instance[internalHoistableMarker])
17878            switch (type) {
17879              case "meta":
17880                if (!instance.hasAttribute("itemprop")) break;
17881                return instance;
17882              case "link":
17883                name = instance.getAttribute("rel");
17884                if ("stylesheet" === name && instance.hasAttribute("data-precedence"))
17885                  break;
17886                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))
17887                  break;
17888                return instance;
17889              case "style":
17890                if (instance.hasAttribute("data-precedence")) break;
17891                return instance;
17892              case "script":
17893                name = instance.getAttribute("src");
17894                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"))
17895                  break;
17896                return instance;
17897              default:
17898                return instance;
17899            }
17900          instance = getNextHydratable(instance.nextSibling);
17901          if (null === instance) break;
17902        }
17903        return null;
17904      }
17905      function canHydrateTextInstance(instance, text, inRootOrSingleton) {
17906        if ("" === text) return null;
17907        for (; 3 !== instance.nodeType; ) {
17908          if ((1 !== instance.nodeType || "INPUT" !== instance.nodeName || "hidden" !== instance.type) && !inRootOrSingleton)
17909            return null;
17910          instance = getNextHydratable(instance.nextSibling);
17911          if (null === instance) return null;
17912        }
17913        return instance;
17914      }
17915      function canHydrateHydrationBoundary(instance, inRootOrSingleton) {
17916        for (; 8 !== instance.nodeType; ) {
17917          if ((1 !== instance.nodeType || "INPUT" !== instance.nodeName || "hidden" !== instance.type) && !inRootOrSingleton)
17918            return null;
17919          instance = getNextHydratable(instance.nextSibling);
17920          if (null === instance) return null;
17921        }
17922        return instance;
17923      }
17924      function isSuspenseInstancePending(instance) {
17925        return instance.data === SUSPENSE_PENDING_START_DATA || instance.data === SUSPENSE_QUEUED_START_DATA;
17926      }
17927      function isSuspenseInstanceFallback(instance) {
17928        return instance.data === SUSPENSE_FALLBACK_START_DATA || instance.data === SUSPENSE_PENDING_START_DATA && instance.ownerDocument.readyState !== DOCUMENT_READY_STATE_LOADING;
17929      }
17930      function registerSuspenseInstanceRetry(instance, callback) {
17931        var ownerDocument = instance.ownerDocument;
17932        if (instance.data === SUSPENSE_QUEUED_START_DATA)
17933          instance._reactRetry = callback;
17934        else if (instance.data !== SUSPENSE_PENDING_START_DATA || ownerDocument.readyState !== DOCUMENT_READY_STATE_LOADING)
17935          callback();
17936        else {
17937          var listener = function() {
17938            callback();
17939            ownerDocument.removeEventListener("DOMContentLoaded", listener);
17940          };
17941          ownerDocument.addEventListener("DOMContentLoaded", listener);
17942          instance._reactRetry = listener;
17943        }
17944      }
17945      function getNextHydratable(node) {
17946        for (; null != node; node = node.nextSibling) {
17947          var nodeType = node.nodeType;
17948          if (1 === nodeType || 3 === nodeType) break;
17949          if (8 === nodeType) {
17950            nodeType = node.data;
17951            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)
17952              break;
17953            if (nodeType === SUSPENSE_END_DATA || nodeType === ACTIVITY_END_DATA)
17954              return null;
17955          }
17956        }
17957        return node;
17958      }
17959      function describeHydratableInstanceForDevWarnings(instance) {
17960        if (1 === instance.nodeType) {
17961          for (var JSCompiler_temp_const = instance.nodeName.toLowerCase(), serverDifferences = {}, attributes = instance.attributes, i3 = 0; i3 < attributes.length; i3++) {
17962            var attr = attributes[i3];
17963            serverDifferences[getPropNameFromAttributeName(attr.name)] = "style" === attr.name.toLowerCase() ? getStylesObjectFromElement(instance) : attr.value;
17964          }
17965          return { type: JSCompiler_temp_const, props: serverDifferences };
17966        }
17967        return 8 === instance.nodeType ? instance.data === ACTIVITY_START_DATA ? { type: "Activity", props: {} } : { type: "Suspense", props: {} } : instance.nodeValue;
17968      }
17969      function diffHydratedTextForDevWarnings(textInstance, text, parentProps) {
17970        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;
17971      }
17972      function getNextHydratableInstanceAfterHydrationBoundary(hydrationInstance) {
17973        hydrationInstance = hydrationInstance.nextSibling;
17974        for (var depth = 0; hydrationInstance; ) {
17975          if (8 === hydrationInstance.nodeType) {
17976            var data = hydrationInstance.data;
17977            if (data === SUSPENSE_END_DATA || data === ACTIVITY_END_DATA) {
17978              if (0 === depth)
17979                return getNextHydratable(hydrationInstance.nextSibling);
17980              depth--;
17981            } else
17982              data !== SUSPENSE_START_DATA && data !== SUSPENSE_FALLBACK_START_DATA && data !== SUSPENSE_PENDING_START_DATA && data !== SUSPENSE_QUEUED_START_DATA && data !== ACTIVITY_START_DATA || depth++;
17983          }
17984          hydrationInstance = hydrationInstance.nextSibling;
17985        }
17986        return null;
17987      }
17988      function getParentHydrationBoundary(targetInstance) {
17989        targetInstance = targetInstance.previousSibling;
17990        for (var depth = 0; targetInstance; ) {
17991          if (8 === targetInstance.nodeType) {
17992            var data = targetInstance.data;
17993            if (data === SUSPENSE_START_DATA || data === SUSPENSE_FALLBACK_START_DATA || data === SUSPENSE_PENDING_START_DATA || data === SUSPENSE_QUEUED_START_DATA || data === ACTIVITY_START_DATA) {
17994              if (0 === depth) return targetInstance;
17995              depth--;
17996            } else
17997              data !== SUSPENSE_END_DATA && data !== ACTIVITY_END_DATA || depth++;
17998          }
17999          targetInstance = targetInstance.previousSibling;
18000        }
18001        return null;
18002      }
18003      function commitHydratedContainer(container) {
18004        retryIfBlockedOn(container);
18005      }
18006      function commitHydratedActivityInstance(activityInstance) {
18007        retryIfBlockedOn(activityInstance);
18008      }
18009      function commitHydratedSuspenseInstance(suspenseInstance) {
18010        retryIfBlockedOn(suspenseInstance);
18011      }
18012      function resolveSingletonInstance(type, props, rootContainerInstance, hostContext, validateDOMNestingDev) {
18013        validateDOMNestingDev && validateDOMNesting(type, hostContext.ancestorInfo);
18014        props = getOwnerDocumentFromRootContainer(rootContainerInstance);
18015        switch (type) {
18016          case "html":
18017            type = props.documentElement;
18018            if (!type)
18019              throw Error(
18020                "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."
18021              );
18022            return type;
18023          case "head":
18024            type = props.head;
18025            if (!type)
18026              throw Error(
18027                "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."
18028              );
18029            return type;
18030          case "body":
18031            type = props.body;
18032            if (!type)
18033              throw Error(
18034                "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."
18035              );
18036            return type;
18037          default:
18038            throw Error(
18039              "resolveSingletonInstance was called with an element type that is not supported. This is a bug in React."
18040            );
18041        }
18042      }
18043      function acquireSingletonInstance(type, props, instance, internalInstanceHandle) {
18044        if (!instance[internalContainerInstanceKey] && getInstanceFromNode(instance)) {
18045          var tagName = instance.tagName.toLowerCase();
18046          console.error(
18047            "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.",
18048            tagName,
18049            tagName,
18050            tagName
18051          );
18052        }
18053        switch (type) {
18054          case "html":
18055          case "head":
18056          case "body":
18057            break;
18058          default:
18059            console.error(
18060              "acquireSingletonInstance was called with an element type that is not supported. This is a bug in React."
18061            );
18062        }
18063        for (tagName = instance.attributes; tagName.length; )
18064          instance.removeAttributeNode(tagName[0]);
18065        setInitialProperties(instance, type, props);
18066        instance[internalInstanceKey] = internalInstanceHandle;
18067        instance[internalPropsKey] = props;
18068      }
18069      function releaseSingletonInstance(instance) {
18070        for (var attributes = instance.attributes; attributes.length; )
18071          instance.removeAttributeNode(attributes[0]);
18072        detachDeletedInstance(instance);
18073      }
18074      function getHoistableRoot(container) {
18075        return "function" === typeof container.getRootNode ? container.getRootNode() : 9 === container.nodeType ? container : container.ownerDocument;
18076      }
18077      function preconnectAs(rel, href, crossOrigin) {
18078        var ownerDocument = globalDocument;
18079        if (ownerDocument && "string" === typeof href && href) {
18080          var limitedEscapedHref = escapeSelectorAttributeValueInsideDoubleQuotes(href);
18081          limitedEscapedHref = 'link[rel="' + rel + '"][href="' + limitedEscapedHref + '"]';
18082          "string" === typeof crossOrigin && (limitedEscapedHref += '[crossorigin="' + crossOrigin + '"]');
18083          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)));
18084        }
18085      }
18086      function getResource(type, currentProps, pendingProps, currentResource) {
18087        var resourceRoot = (resourceRoot = rootInstanceStackCursor.current) ? getHoistableRoot(resourceRoot) : null;
18088        if (!resourceRoot)
18089          throw Error(
18090            '"resourceRoot" was expected to exist. This is a bug in React.'
18091          );
18092        switch (type) {
18093          case "meta":
18094          case "title":
18095            return null;
18096          case "style":
18097            return "string" === typeof pendingProps.precedence && "string" === typeof pendingProps.href ? (pendingProps = getStyleKey(pendingProps.href), currentProps = getResourcesFromRoot(resourceRoot).hoistableStyles, currentResource = currentProps.get(pendingProps), currentResource || (currentResource = {
18098              type: "style",
18099              instance: null,
18100              count: 0,
18101              state: null
18102            }, currentProps.set(pendingProps, currentResource)), currentResource) : { type: "void", instance: null, count: 0, state: null };
18103          case "link":
18104            if ("stylesheet" === pendingProps.rel && "string" === typeof pendingProps.href && "string" === typeof pendingProps.precedence) {
18105              type = getStyleKey(pendingProps.href);
18106              var _styles = getResourcesFromRoot(resourceRoot).hoistableStyles, _resource = _styles.get(type);
18107              if (!_resource && (resourceRoot = resourceRoot.ownerDocument || resourceRoot, _resource = {
18108                type: "stylesheet",
18109                instance: null,
18110                count: 0,
18111                state: { loading: NotLoaded, preload: null }
18112              }, _styles.set(type, _resource), (_styles = resourceRoot.querySelector(
18113                getStylesheetSelectorFromKey(type)
18114              )) && !_styles._p && (_resource.instance = _styles, _resource.state.loading = Loaded | Inserted), !preloadPropsMap.has(type))) {
18115                var preloadProps = {
18116                  rel: "preload",
18117                  as: "style",
18118                  href: pendingProps.href,
18119                  crossOrigin: pendingProps.crossOrigin,
18120                  integrity: pendingProps.integrity,
18121                  media: pendingProps.media,
18122                  hrefLang: pendingProps.hrefLang,
18123                  referrerPolicy: pendingProps.referrerPolicy
18124                };
18125                preloadPropsMap.set(type, preloadProps);
18126                _styles || preloadStylesheet(
18127                  resourceRoot,
18128                  type,
18129                  preloadProps,
18130                  _resource.state
18131                );
18132              }
18133              if (currentProps && null === currentResource)
18134                throw pendingProps = "\n\n  - " + describeLinkForResourceErrorDEV(currentProps) + "\n  + " + describeLinkForResourceErrorDEV(pendingProps), Error(
18135                  "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
18136                );
18137              return _resource;
18138            }
18139            if (currentProps && null !== currentResource)
18140              throw pendingProps = "\n\n  - " + describeLinkForResourceErrorDEV(currentProps) + "\n  + " + describeLinkForResourceErrorDEV(pendingProps), Error(
18141                "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
18142              );
18143            return null;
18144          case "script":
18145            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 = {
18146              type: "script",
18147              instance: null,
18148              count: 0,
18149              state: null
18150            }, currentProps.set(pendingProps, currentResource)), currentResource) : { type: "void", instance: null, count: 0, state: null };
18151          default:
18152            throw Error(
18153              'getResource encountered a type it did not expect: "' + type + '". this is a bug in React.'
18154            );
18155        }
18156      }
18157      function describeLinkForResourceErrorDEV(props) {
18158        var describedProps = 0, description = "<link";
18159        "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) + '"');
18160        "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) + '"');
18161        "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) + "}");
18162        Object.getOwnPropertyNames(props).length > describedProps && (description += " ...");
18163        return description + " />";
18164      }
18165      function getStyleKey(href) {
18166        return 'href="' + escapeSelectorAttributeValueInsideDoubleQuotes(href) + '"';
18167      }
18168      function getStylesheetSelectorFromKey(key) {
18169        return 'link[rel="stylesheet"][' + key + "]";
18170      }
18171      function stylesheetPropsFromRawProps(rawProps) {
18172        return assign({}, rawProps, {
18173          "data-precedence": rawProps.precedence,
18174          precedence: null
18175        });
18176      }
18177      function preloadStylesheet(ownerDocument, key, preloadProps, state) {
18178        ownerDocument.querySelector(
18179          'link[rel="preload"][as="style"][' + key + "]"
18180        ) ? state.loading = Loaded : (key = ownerDocument.createElement("link"), state.preload = key, key.addEventListener("load", function() {
18181          return state.loading |= Loaded;
18182        }), key.addEventListener("error", function() {
18183          return state.loading |= Errored;
18184        }), setInitialProperties(key, "link", preloadProps), markNodeAsHoistable(key), ownerDocument.head.appendChild(key));
18185      }
18186      function getScriptKey(src) {
18187        return '[src="' + escapeSelectorAttributeValueInsideDoubleQuotes(src) + '"]';
18188      }
18189      function getScriptSelectorFromKey(key) {
18190        return "script[async]" + key;
18191      }
18192      function acquireResource(hoistableRoot, resource, props) {
18193        resource.count++;
18194        if (null === resource.instance)
18195          switch (resource.type) {
18196            case "style":
18197              var instance = hoistableRoot.querySelector(
18198                'style[data-href~="' + escapeSelectorAttributeValueInsideDoubleQuotes(props.href) + '"]'
18199              );
18200              if (instance)
18201                return resource.instance = instance, markNodeAsHoistable(instance), instance;
18202              var styleProps = assign({}, props, {
18203                "data-href": props.href,
18204                "data-precedence": props.precedence,
18205                href: null,
18206                precedence: null
18207              });
18208              instance = (hoistableRoot.ownerDocument || hoistableRoot).createElement("style");
18209              markNodeAsHoistable(instance);
18210              setInitialProperties(instance, "style", styleProps);
18211              insertStylesheet(instance, props.precedence, hoistableRoot);
18212              return resource.instance = instance;
18213            case "stylesheet":
18214              styleProps = getStyleKey(props.href);
18215              var _instance = hoistableRoot.querySelector(
18216                getStylesheetSelectorFromKey(styleProps)
18217              );
18218              if (_instance)
18219                return resource.state.loading |= Inserted, resource.instance = _instance, markNodeAsHoistable(_instance), _instance;
18220              instance = stylesheetPropsFromRawProps(props);
18221              (styleProps = preloadPropsMap.get(styleProps)) && adoptPreloadPropsForStylesheet(instance, styleProps);
18222              _instance = (hoistableRoot.ownerDocument || hoistableRoot).createElement("link");
18223              markNodeAsHoistable(_instance);
18224              var linkInstance = _instance;
18225              linkInstance._p = new Promise(function(resolve, reject) {
18226                linkInstance.onload = resolve;
18227                linkInstance.onerror = reject;
18228              });
18229              setInitialProperties(_instance, "link", instance);
18230              resource.state.loading |= Inserted;
18231              insertStylesheet(_instance, props.precedence, hoistableRoot);
18232              return resource.instance = _instance;
18233            case "script":
18234              _instance = getScriptKey(props.src);
18235              if (styleProps = hoistableRoot.querySelector(
18236                getScriptSelectorFromKey(_instance)
18237              ))
18238                return resource.instance = styleProps, markNodeAsHoistable(styleProps), styleProps;
18239              instance = props;
18240              if (styleProps = preloadPropsMap.get(_instance))
18241                instance = assign({}, props), adoptPreloadPropsForScript(instance, styleProps);
18242              hoistableRoot = hoistableRoot.ownerDocument || hoistableRoot;
18243              styleProps = hoistableRoot.createElement("script");
18244              markNodeAsHoistable(styleProps);
18245              setInitialProperties(styleProps, "link", instance);
18246              hoistableRoot.head.appendChild(styleProps);
18247              return resource.instance = styleProps;
18248            case "void":
18249              return null;
18250            default:
18251              throw Error(
18252                'acquireResource encountered a resource type it did not expect: "' + resource.type + '". this is a bug in React.'
18253              );
18254          }
18255        else
18256          "stylesheet" === resource.type && (resource.state.loading & Inserted) === NotLoaded && (instance = resource.instance, resource.state.loading |= Inserted, insertStylesheet(instance, props.precedence, hoistableRoot));
18257        return resource.instance;
18258      }
18259      function insertStylesheet(instance, precedence, root3) {
18260        for (var nodes = root3.querySelectorAll(
18261          'link[rel="stylesheet"][data-precedence],style[data-precedence]'
18262        ), last = nodes.length ? nodes[nodes.length - 1] : null, prior = last, i3 = 0; i3 < nodes.length; i3++) {
18263          var node = nodes[i3];
18264          if (node.dataset.precedence === precedence) prior = node;
18265          else if (prior !== last) break;
18266        }
18267        prior ? prior.parentNode.insertBefore(instance, prior.nextSibling) : (precedence = 9 === root3.nodeType ? root3.head : root3, precedence.insertBefore(instance, precedence.firstChild));
18268      }
18269      function adoptPreloadPropsForStylesheet(stylesheetProps, preloadProps) {
18270        null == stylesheetProps.crossOrigin && (stylesheetProps.crossOrigin = preloadProps.crossOrigin);
18271        null == stylesheetProps.referrerPolicy && (stylesheetProps.referrerPolicy = preloadProps.referrerPolicy);
18272        null == stylesheetProps.title && (stylesheetProps.title = preloadProps.title);
18273      }
18274      function adoptPreloadPropsForScript(scriptProps, preloadProps) {
18275        null == scriptProps.crossOrigin && (scriptProps.crossOrigin = preloadProps.crossOrigin);
18276        null == scriptProps.referrerPolicy && (scriptProps.referrerPolicy = preloadProps.referrerPolicy);
18277        null == scriptProps.integrity && (scriptProps.integrity = preloadProps.integrity);
18278      }
18279      function getHydratableHoistableCache(type, keyAttribute, ownerDocument) {
18280        if (null === tagCaches) {
18281          var cache2 = /* @__PURE__ */ new Map();
18282          var caches = tagCaches = /* @__PURE__ */ new Map();
18283          caches.set(ownerDocument, cache2);
18284        } else
18285          caches = tagCaches, cache2 = caches.get(ownerDocument), cache2 || (cache2 = /* @__PURE__ */ new Map(), caches.set(ownerDocument, cache2));
18286        if (cache2.has(type)) return cache2;
18287        cache2.set(type, null);
18288        ownerDocument = ownerDocument.getElementsByTagName(type);
18289        for (caches = 0; caches < ownerDocument.length; caches++) {
18290          var node = ownerDocument[caches];
18291          if (!(node[internalHoistableMarker] || node[internalInstanceKey] || "link" === type && "stylesheet" === node.getAttribute("rel")) && node.namespaceURI !== SVG_NAMESPACE) {
18292            var nodeKey = node.getAttribute(keyAttribute) || "";
18293            nodeKey = type + nodeKey;
18294            var existing = cache2.get(nodeKey);
18295            existing ? existing.push(node) : cache2.set(nodeKey, [node]);
18296          }
18297        }
18298        return cache2;
18299      }
18300      function mountHoistable(hoistableRoot, type, instance) {
18301        hoistableRoot = hoistableRoot.ownerDocument || hoistableRoot;
18302        hoistableRoot.head.insertBefore(
18303          instance,
18304          "title" === type ? hoistableRoot.querySelector("head > title") : null
18305        );
18306      }
18307      function isHostHoistableType(type, props, hostContext) {
18308        var outsideHostContainerContext = !hostContext.ancestorInfo.containerTagInScope;
18309        if (hostContext.context === HostContextNamespaceSvg || null != props.itemProp)
18310          return !outsideHostContainerContext || null == props.itemProp || "meta" !== type && "title" !== type && "style" !== type && "link" !== type && "script" !== type || console.error(
18311            "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.",
18312            type,
18313            type
18314          ), false;
18315        switch (type) {
18316          case "meta":
18317          case "title":
18318            return true;
18319          case "style":
18320            if ("string" !== typeof props.precedence || "string" !== typeof props.href || "" === props.href) {
18321              outsideHostContainerContext && console.error(
18322                '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"`.'
18323              );
18324              break;
18325            }
18326            return true;
18327          case "link":
18328            if ("string" !== typeof props.rel || "string" !== typeof props.href || "" === props.href || props.onLoad || props.onError) {
18329              if ("stylesheet" === props.rel && "string" === typeof props.precedence) {
18330                type = props.href;
18331                var onError = props.onError, disabled = props.disabled;
18332                hostContext = [];
18333                props.onLoad && hostContext.push("`onLoad`");
18334                onError && hostContext.push("`onError`");
18335                null != disabled && hostContext.push("`disabled`");
18336                onError = propNamesListJoin(hostContext, "and");
18337                onError += 1 === hostContext.length ? " prop" : " props";
18338                disabled = 1 === hostContext.length ? "an " + onError : "the " + onError;
18339                hostContext.length && console.error(
18340                  '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.',
18341                  type,
18342                  disabled,
18343                  onError
18344                );
18345              }
18346              outsideHostContainerContext && ("string" !== typeof props.rel || "string" !== typeof props.href || "" === props.href ? console.error(
18347                "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"
18348              ) : (props.onError || props.onLoad) && console.error(
18349                "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>."
18350              ));
18351              break;
18352            }
18353            switch (props.rel) {
18354              case "stylesheet":
18355                return type = props.precedence, props = props.disabled, "string" !== typeof type && outsideHostContainerContext && console.error(
18356                  '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.'
18357                ), "string" === typeof type && null == props;
18358              default:
18359                return true;
18360            }
18361          case "script":
18362            type = props.async && "function" !== typeof props.async && "symbol" !== typeof props.async;
18363            if (!type || props.onLoad || props.onError || !props.src || "string" !== typeof props.src) {
18364              outsideHostContainerContext && (type ? props.onLoad || props.onError ? console.error(
18365                "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>."
18366              ) : console.error(
18367                "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>."
18368              ) : console.error(
18369                '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.'
18370              ));
18371              break;
18372            }
18373            return true;
18374          case "noscript":
18375          case "template":
18376            outsideHostContainerContext && console.error(
18377              "Cannot render <%s> outside the main document. Try moving it into the root <head> tag.",
18378              type
18379            );
18380        }
18381        return false;
18382      }
18383      function preloadResource(resource) {
18384        return "stylesheet" === resource.type && (resource.state.loading & Settled) === NotLoaded ? false : true;
18385      }
18386      function suspendResource(state, hoistableRoot, resource, props) {
18387        if ("stylesheet" === resource.type && ("string" !== typeof props.media || false !== matchMedia(props.media).matches) && (resource.state.loading & Inserted) === NotLoaded) {
18388          if (null === resource.instance) {
18389            var key = getStyleKey(props.href), instance = hoistableRoot.querySelector(
18390              getStylesheetSelectorFromKey(key)
18391            );
18392            if (instance) {
18393              hoistableRoot = instance._p;
18394              null !== hoistableRoot && "object" === typeof hoistableRoot && "function" === typeof hoistableRoot.then && (state.count++, state = onUnsuspend.bind(state), hoistableRoot.then(state, state));
18395              resource.state.loading |= Inserted;
18396              resource.instance = instance;
18397              markNodeAsHoistable(instance);
18398              return;
18399            }
18400            instance = hoistableRoot.ownerDocument || hoistableRoot;
18401            props = stylesheetPropsFromRawProps(props);
18402            (key = preloadPropsMap.get(key)) && adoptPreloadPropsForStylesheet(props, key);
18403            instance = instance.createElement("link");
18404            markNodeAsHoistable(instance);
18405            var linkInstance = instance;
18406            linkInstance._p = new Promise(function(resolve, reject) {
18407              linkInstance.onload = resolve;
18408              linkInstance.onerror = reject;
18409            });
18410            setInitialProperties(instance, "link", props);
18411            resource.instance = instance;
18412          }
18413          null === state.stylesheets && (state.stylesheets = /* @__PURE__ */ new Map());
18414          state.stylesheets.set(resource, hoistableRoot);
18415          (hoistableRoot = resource.state.preload) && (resource.state.loading & Settled) === NotLoaded && (state.count++, resource = onUnsuspend.bind(state), hoistableRoot.addEventListener("load", resource), hoistableRoot.addEventListener("error", resource));
18416        }
18417      }
18418      function waitForCommitToBeReady(state, timeoutOffset) {
18419        state.stylesheets && 0 === state.count && insertSuspendedStylesheets(state, state.stylesheets);
18420        return 0 < state.count || 0 < state.imgCount ? function(commit) {
18421          var stylesheetTimer = setTimeout(function() {
18422            state.stylesheets && insertSuspendedStylesheets(state, state.stylesheets);
18423            if (state.unsuspend) {
18424              var unsuspend = state.unsuspend;
18425              state.unsuspend = null;
18426              unsuspend();
18427            }
18428          }, SUSPENSEY_STYLESHEET_TIMEOUT + timeoutOffset);
18429          0 < state.imgBytes && 0 === estimatedBytesWithinLimit && (estimatedBytesWithinLimit = 125 * estimateBandwidth() * SUSPENSEY_IMAGE_TIME_ESTIMATE);
18430          var imgTimer = setTimeout(
18431            function() {
18432              state.waitingForImages = false;
18433              if (0 === state.count && (state.stylesheets && insertSuspendedStylesheets(state, state.stylesheets), state.unsuspend)) {
18434                var unsuspend = state.unsuspend;
18435                state.unsuspend = null;
18436                unsuspend();
18437              }
18438            },
18439            (state.imgBytes > estimatedBytesWithinLimit ? 50 : SUSPENSEY_IMAGE_TIMEOUT) + timeoutOffset
18440          );
18441          state.unsuspend = commit;
18442          return function() {
18443            state.unsuspend = null;
18444            clearTimeout(stylesheetTimer);
18445            clearTimeout(imgTimer);
18446          };
18447        } : null;
18448      }
18449      function onUnsuspend() {
18450        this.count--;
18451        if (0 === this.count && (0 === this.imgCount || !this.waitingForImages)) {
18452          if (this.stylesheets)
18453            insertSuspendedStylesheets(this, this.stylesheets);
18454          else if (this.unsuspend) {
18455            var unsuspend = this.unsuspend;
18456            this.unsuspend = null;
18457            unsuspend();
18458          }
18459        }
18460      }
18461      function insertSuspendedStylesheets(state, resources) {
18462        state.stylesheets = null;
18463        null !== state.unsuspend && (state.count++, precedencesByRoot = /* @__PURE__ */ new Map(), resources.forEach(insertStylesheetIntoRoot, state), precedencesByRoot = null, onUnsuspend.call(state));
18464      }
18465      function insertStylesheetIntoRoot(root3, resource) {
18466        if (!(resource.state.loading & Inserted)) {
18467          var precedences = precedencesByRoot.get(root3);
18468          if (precedences) var last = precedences.get(LAST_PRECEDENCE);
18469          else {
18470            precedences = /* @__PURE__ */ new Map();
18471            precedencesByRoot.set(root3, precedences);
18472            for (var nodes = root3.querySelectorAll(
18473              "link[data-precedence],style[data-precedence]"
18474            ), i3 = 0; i3 < nodes.length; i3++) {
18475              var node = nodes[i3];
18476              if ("LINK" === node.nodeName || "not all" !== node.getAttribute("media"))
18477                precedences.set(node.dataset.precedence, node), last = node;
18478            }
18479            last && precedences.set(LAST_PRECEDENCE, last);
18480          }
18481          nodes = resource.instance;
18482          node = nodes.getAttribute("data-precedence");
18483          i3 = precedences.get(node) || last;
18484          i3 === last && precedences.set(LAST_PRECEDENCE, nodes);
18485          precedences.set(node, nodes);
18486          this.count++;
18487          last = onUnsuspend.bind(this);
18488          nodes.addEventListener("load", last);
18489          nodes.addEventListener("error", last);
18490          i3 ? i3.parentNode.insertBefore(nodes, i3.nextSibling) : (root3 = 9 === root3.nodeType ? root3.head : root3, root3.insertBefore(nodes, root3.firstChild));
18491          resource.state.loading |= Inserted;
18492        }
18493      }
18494      function FiberRootNode(containerInfo, tag, hydrate, identifierPrefix, onUncaughtError, onCaughtError, onRecoverableError, onDefaultTransitionIndicator, formState) {
18495        this.tag = 1;
18496        this.containerInfo = containerInfo;
18497        this.pingCache = this.current = this.pendingChildren = null;
18498        this.timeoutHandle = noTimeout;
18499        this.callbackNode = this.next = this.pendingContext = this.context = this.cancelPendingCommit = null;
18500        this.callbackPriority = 0;
18501        this.expirationTimes = createLaneMap(-1);
18502        this.entangledLanes = this.shellSuspendCounter = this.errorRecoveryDisabledLanes = this.expiredLanes = this.warmLanes = this.pingedLanes = this.suspendedLanes = this.pendingLanes = 0;
18503        this.entanglements = createLaneMap(0);
18504        this.hiddenUpdates = createLaneMap(null);
18505        this.identifierPrefix = identifierPrefix;
18506        this.onUncaughtError = onUncaughtError;
18507        this.onCaughtError = onCaughtError;
18508        this.onRecoverableError = onRecoverableError;
18509        this.pooledCache = null;
18510        this.pooledCacheLanes = 0;
18511        this.formState = formState;
18512        this.incompleteTransitions = /* @__PURE__ */ new Map();
18513        this.passiveEffectDuration = this.effectDuration = -0;
18514        this.memoizedUpdaters = /* @__PURE__ */ new Set();
18515        containerInfo = this.pendingUpdatersLaneMap = [];
18516        for (tag = 0; 31 > tag; tag++) containerInfo.push(/* @__PURE__ */ new Set());
18517        this._debugRootType = hydrate ? "hydrateRoot()" : "createRoot()";
18518      }
18519      function createFiberRoot(containerInfo, tag, hydrate, initialChildren, hydrationCallbacks, isStrictMode, identifierPrefix, formState, onUncaughtError, onCaughtError, onRecoverableError, onDefaultTransitionIndicator) {
18520        containerInfo = new FiberRootNode(
18521          containerInfo,
18522          tag,
18523          hydrate,
18524          identifierPrefix,
18525          onUncaughtError,
18526          onCaughtError,
18527          onRecoverableError,
18528          onDefaultTransitionIndicator,
18529          formState
18530        );
18531        tag = ConcurrentMode;
18532        true === isStrictMode && (tag |= StrictLegacyMode | StrictEffectsMode);
18533        tag |= ProfileMode;
18534        isStrictMode = createFiber(3, null, null, tag);
18535        containerInfo.current = isStrictMode;
18536        isStrictMode.stateNode = containerInfo;
18537        tag = createCache();
18538        retainCache(tag);
18539        containerInfo.pooledCache = tag;
18540        retainCache(tag);
18541        isStrictMode.memoizedState = {
18542          element: initialChildren,
18543          isDehydrated: hydrate,
18544          cache: tag
18545        };
18546        initializeUpdateQueue(isStrictMode);
18547        return containerInfo;
18548      }
18549      function getContextForSubtree(parentComponent) {
18550        if (!parentComponent) return emptyContextObject;
18551        parentComponent = emptyContextObject;
18552        return parentComponent;
18553      }
18554      function updateContainerImpl(rootFiber, lane, element, container, parentComponent, callback) {
18555        if (injectedHook && "function" === typeof injectedHook.onScheduleFiberRoot)
18556          try {
18557            injectedHook.onScheduleFiberRoot(rendererID, container, element);
18558          } catch (err) {
18559            hasLoggedError || (hasLoggedError = true, console.error(
18560              "React instrumentation encountered an error: %o",
18561              err
18562            ));
18563          }
18564        parentComponent = getContextForSubtree(parentComponent);
18565        null === container.context ? container.context = parentComponent : container.pendingContext = parentComponent;
18566        isRendering && null !== current && !didWarnAboutNestedUpdates && (didWarnAboutNestedUpdates = true, console.error(
18567          "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.",
18568          getComponentNameFromFiber(current) || "Unknown"
18569        ));
18570        container = createUpdate(lane);
18571        container.payload = { element };
18572        callback = void 0 === callback ? null : callback;
18573        null !== callback && ("function" !== typeof callback && console.error(
18574          "Expected the last optional `callback` argument to be a function. Instead received: %s.",
18575          callback
18576        ), container.callback = callback);
18577        element = enqueueUpdate(rootFiber, container, lane);
18578        null !== element && (startUpdateTimerByLane(lane, "root.render()", null), scheduleUpdateOnFiber(element, rootFiber, lane), entangleTransitions(element, rootFiber, lane));
18579      }
18580      function markRetryLaneImpl(fiber, retryLane) {
18581        fiber = fiber.memoizedState;
18582        if (null !== fiber && null !== fiber.dehydrated) {
18583          var a3 = fiber.retryLane;
18584          fiber.retryLane = 0 !== a3 && a3 < retryLane ? a3 : retryLane;
18585        }
18586      }
18587      function markRetryLaneIfNotHydrated(fiber, retryLane) {
18588        markRetryLaneImpl(fiber, retryLane);
18589        (fiber = fiber.alternate) && markRetryLaneImpl(fiber, retryLane);
18590      }
18591      function attemptContinuousHydration(fiber) {
18592        if (13 === fiber.tag || 31 === fiber.tag) {
18593          var root3 = enqueueConcurrentRenderForLane(fiber, 67108864);
18594          null !== root3 && scheduleUpdateOnFiber(root3, fiber, 67108864);
18595          markRetryLaneIfNotHydrated(fiber, 67108864);
18596        }
18597      }
18598      function attemptHydrationAtCurrentPriority(fiber) {
18599        if (13 === fiber.tag || 31 === fiber.tag) {
18600          var lane = requestUpdateLane(fiber);
18601          lane = getBumpedLaneForHydrationByLane(lane);
18602          var root3 = enqueueConcurrentRenderForLane(fiber, lane);
18603          null !== root3 && scheduleUpdateOnFiber(root3, fiber, lane);
18604          markRetryLaneIfNotHydrated(fiber, lane);
18605        }
18606      }
18607      function getCurrentFiberForDevTools() {
18608        return current;
18609      }
18610      function dispatchDiscreteEvent(domEventName, eventSystemFlags, container, nativeEvent) {
18611        var prevTransition = ReactSharedInternals.T;
18612        ReactSharedInternals.T = null;
18613        var previousPriority = ReactDOMSharedInternals.p;
18614        try {
18615          ReactDOMSharedInternals.p = DiscreteEventPriority, dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
18616        } finally {
18617          ReactDOMSharedInternals.p = previousPriority, ReactSharedInternals.T = prevTransition;
18618        }
18619      }
18620      function dispatchContinuousEvent(domEventName, eventSystemFlags, container, nativeEvent) {
18621        var prevTransition = ReactSharedInternals.T;
18622        ReactSharedInternals.T = null;
18623        var previousPriority = ReactDOMSharedInternals.p;
18624        try {
18625          ReactDOMSharedInternals.p = ContinuousEventPriority, dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
18626        } finally {
18627          ReactDOMSharedInternals.p = previousPriority, ReactSharedInternals.T = prevTransition;
18628        }
18629      }
18630      function dispatchEvent(domEventName, eventSystemFlags, targetContainer, nativeEvent) {
18631        if (_enabled) {
18632          var blockedOn = findInstanceBlockingEvent(nativeEvent);
18633          if (null === blockedOn)
18634            dispatchEventForPluginEventSystem(
18635              domEventName,
18636              eventSystemFlags,
18637              nativeEvent,
18638              return_targetInst,
18639              targetContainer
18640            ), clearIfContinuousEvent(domEventName, nativeEvent);
18641          else if (queueIfContinuousEvent(
18642            blockedOn,
18643            domEventName,
18644            eventSystemFlags,
18645            targetContainer,
18646            nativeEvent
18647          ))
18648            nativeEvent.stopPropagation();
18649          else if (clearIfContinuousEvent(domEventName, nativeEvent), eventSystemFlags & 4 && -1 < discreteReplayableEvents.indexOf(domEventName)) {
18650            for (; null !== blockedOn; ) {
18651              var fiber = getInstanceFromNode(blockedOn);
18652              if (null !== fiber)
18653                switch (fiber.tag) {
18654                  case 3:
18655                    fiber = fiber.stateNode;
18656                    if (fiber.current.memoizedState.isDehydrated) {
18657                      var lanes = getHighestPriorityLanes(fiber.pendingLanes);
18658                      if (0 !== lanes) {
18659                        var root3 = fiber;
18660                        root3.pendingLanes |= 2;
18661                        for (root3.entangledLanes |= 2; lanes; ) {
18662                          var lane = 1 << 31 - clz32(lanes);
18663                          root3.entanglements[1] |= lane;
18664                          lanes &= ~lane;
18665                        }
18666                        ensureRootIsScheduled(fiber);
18667                        (executionContext & (RenderContext | CommitContext)) === NoContext && (workInProgressRootRenderTargetTime = now$1() + RENDER_TIMEOUT_MS, flushSyncWorkAcrossRoots_impl(0, false));
18668                      }
18669                    }
18670                    break;
18671                  case 31:
18672                  case 13:
18673                    root3 = enqueueConcurrentRenderForLane(fiber, 2), null !== root3 && scheduleUpdateOnFiber(root3, fiber, 2), flushSyncWork$1(), markRetryLaneIfNotHydrated(fiber, 2);
18674                }
18675              fiber = findInstanceBlockingEvent(nativeEvent);
18676              null === fiber && dispatchEventForPluginEventSystem(
18677                domEventName,
18678                eventSystemFlags,
18679                nativeEvent,
18680                return_targetInst,
18681                targetContainer
18682              );
18683              if (fiber === blockedOn) break;
18684              blockedOn = fiber;
18685            }
18686            null !== blockedOn && nativeEvent.stopPropagation();
18687          } else
18688            dispatchEventForPluginEventSystem(
18689              domEventName,
18690              eventSystemFlags,
18691              nativeEvent,
18692              null,
18693              targetContainer
18694            );
18695        }
18696      }
18697      function findInstanceBlockingEvent(nativeEvent) {
18698        nativeEvent = getEventTarget(nativeEvent);
18699        return findInstanceBlockingTarget(nativeEvent);
18700      }
18701      function findInstanceBlockingTarget(targetNode) {
18702        return_targetInst = null;
18703        targetNode = getClosestInstanceFromNode(targetNode);
18704        if (null !== targetNode) {
18705          var nearestMounted = getNearestMountedFiber(targetNode);
18706          if (null === nearestMounted) targetNode = null;
18707          else {
18708            var tag = nearestMounted.tag;
18709            if (13 === tag) {
18710              targetNode = getSuspenseInstanceFromFiber(nearestMounted);
18711              if (null !== targetNode) return targetNode;
18712              targetNode = null;
18713            } else if (31 === tag) {
18714              targetNode = getActivityInstanceFromFiber(nearestMounted);
18715              if (null !== targetNode) return targetNode;
18716              targetNode = null;
18717            } else if (3 === tag) {
18718              if (nearestMounted.stateNode.current.memoizedState.isDehydrated)
18719                return 3 === nearestMounted.tag ? nearestMounted.stateNode.containerInfo : null;
18720              targetNode = null;
18721            } else nearestMounted !== targetNode && (targetNode = null);
18722          }
18723        }
18724        return_targetInst = targetNode;
18725        return null;
18726      }
18727      function getEventPriority(domEventName) {
18728        switch (domEventName) {
18729          case "beforetoggle":
18730          case "cancel":
18731          case "click":
18732          case "close":
18733          case "contextmenu":
18734          case "copy":
18735          case "cut":
18736          case "auxclick":
18737          case "dblclick":
18738          case "dragend":
18739          case "dragstart":
18740          case "drop":
18741          case "focusin":
18742          case "focusout":
18743          case "input":
18744          case "invalid":
18745          case "keydown":
18746          case "keypress":
18747          case "keyup":
18748          case "mousedown":
18749          case "mouseup":
18750          case "paste":
18751          case "pause":
18752          case "play":
18753          case "pointercancel":
18754          case "pointerdown":
18755          case "pointerup":
18756          case "ratechange":
18757          case "reset":
18758          case "resize":
18759          case "seeked":
18760          case "submit":
18761          case "toggle":
18762          case "touchcancel":
18763          case "touchend":
18764          case "touchstart":
18765          case "volumechange":
18766          case "change":
18767          case "selectionchange":
18768          case "textInput":
18769          case "compositionstart":
18770          case "compositionend":
18771          case "compositionupdate":
18772          case "beforeblur":
18773          case "afterblur":
18774          case "beforeinput":
18775          case "blur":
18776          case "fullscreenchange":
18777          case "focus":
18778          case "hashchange":
18779          case "popstate":
18780          case "select":
18781          case "selectstart":
18782            return DiscreteEventPriority;
18783          case "drag":
18784          case "dragenter":
18785          case "dragexit":
18786          case "dragleave":
18787          case "dragover":
18788          case "mousemove":
18789          case "mouseout":
18790          case "mouseover":
18791          case "pointermove":
18792          case "pointerout":
18793          case "pointerover":
18794          case "scroll":
18795          case "touchmove":
18796          case "wheel":
18797          case "mouseenter":
18798          case "mouseleave":
18799          case "pointerenter":
18800          case "pointerleave":
18801            return ContinuousEventPriority;
18802          case "message":
18803            switch (getCurrentPriorityLevel()) {
18804              case ImmediatePriority:
18805                return DiscreteEventPriority;
18806              case UserBlockingPriority:
18807                return ContinuousEventPriority;
18808              case NormalPriority$1:
18809              case LowPriority:
18810                return DefaultEventPriority;
18811              case IdlePriority:
18812                return IdleEventPriority;
18813              default:
18814                return DefaultEventPriority;
18815            }
18816          default:
18817            return DefaultEventPriority;
18818        }
18819      }
18820      function clearIfContinuousEvent(domEventName, nativeEvent) {
18821        switch (domEventName) {
18822          case "focusin":
18823          case "focusout":
18824            queuedFocus = null;
18825            break;
18826          case "dragenter":
18827          case "dragleave":
18828            queuedDrag = null;
18829            break;
18830          case "mouseover":
18831          case "mouseout":
18832            queuedMouse = null;
18833            break;
18834          case "pointerover":
18835          case "pointerout":
18836            queuedPointers.delete(nativeEvent.pointerId);
18837            break;
18838          case "gotpointercapture":
18839          case "lostpointercapture":
18840            queuedPointerCaptures.delete(nativeEvent.pointerId);
18841        }
18842      }
18843      function accumulateOrCreateContinuousQueuedReplayableEvent(existingQueuedEvent, blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent) {
18844        if (null === existingQueuedEvent || existingQueuedEvent.nativeEvent !== nativeEvent)
18845          return existingQueuedEvent = {
18846            blockedOn,
18847            domEventName,
18848            eventSystemFlags,
18849            nativeEvent,
18850            targetContainers: [targetContainer]
18851          }, null !== blockedOn && (blockedOn = getInstanceFromNode(blockedOn), null !== blockedOn && attemptContinuousHydration(blockedOn)), existingQueuedEvent;
18852        existingQueuedEvent.eventSystemFlags |= eventSystemFlags;
18853        blockedOn = existingQueuedEvent.targetContainers;
18854        null !== targetContainer && -1 === blockedOn.indexOf(targetContainer) && blockedOn.push(targetContainer);
18855        return existingQueuedEvent;
18856      }
18857      function queueIfContinuousEvent(blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent) {
18858        switch (domEventName) {
18859          case "focusin":
18860            return queuedFocus = accumulateOrCreateContinuousQueuedReplayableEvent(
18861              queuedFocus,
18862              blockedOn,
18863              domEventName,
18864              eventSystemFlags,
18865              targetContainer,
18866              nativeEvent
18867            ), true;
18868          case "dragenter":
18869            return queuedDrag = accumulateOrCreateContinuousQueuedReplayableEvent(
18870              queuedDrag,
18871              blockedOn,
18872              domEventName,
18873              eventSystemFlags,
18874              targetContainer,
18875              nativeEvent
18876            ), true;
18877          case "mouseover":
18878            return queuedMouse = accumulateOrCreateContinuousQueuedReplayableEvent(
18879              queuedMouse,
18880              blockedOn,
18881              domEventName,
18882              eventSystemFlags,
18883              targetContainer,
18884              nativeEvent
18885            ), true;
18886          case "pointerover":
18887            var pointerId = nativeEvent.pointerId;
18888            queuedPointers.set(
18889              pointerId,
18890              accumulateOrCreateContinuousQueuedReplayableEvent(
18891                queuedPointers.get(pointerId) || null,
18892                blockedOn,
18893                domEventName,
18894                eventSystemFlags,
18895                targetContainer,
18896                nativeEvent
18897              )
18898            );
18899            return true;
18900          case "gotpointercapture":
18901            return pointerId = nativeEvent.pointerId, queuedPointerCaptures.set(
18902              pointerId,
18903              accumulateOrCreateContinuousQueuedReplayableEvent(
18904                queuedPointerCaptures.get(pointerId) || null,
18905                blockedOn,
18906                domEventName,
18907                eventSystemFlags,
18908                targetContainer,
18909                nativeEvent
18910              )
18911            ), true;
18912        }
18913        return false;
18914      }
18915      function attemptExplicitHydrationTarget(queuedTarget) {
18916        var targetInst = getClosestInstanceFromNode(queuedTarget.target);
18917        if (null !== targetInst) {
18918          var nearestMounted = getNearestMountedFiber(targetInst);
18919          if (null !== nearestMounted) {
18920            if (targetInst = nearestMounted.tag, 13 === targetInst) {
18921              if (targetInst = getSuspenseInstanceFromFiber(nearestMounted), null !== targetInst) {
18922                queuedTarget.blockedOn = targetInst;
18923                runWithPriority(queuedTarget.priority, function() {
18924                  attemptHydrationAtCurrentPriority(nearestMounted);
18925                });
18926                return;
18927              }
18928            } else if (31 === targetInst) {
18929              if (targetInst = getActivityInstanceFromFiber(nearestMounted), null !== targetInst) {
18930                queuedTarget.blockedOn = targetInst;
18931                runWithPriority(queuedTarget.priority, function() {
18932                  attemptHydrationAtCurrentPriority(nearestMounted);
18933                });
18934                return;
18935              }
18936            } else if (3 === targetInst && nearestMounted.stateNode.current.memoizedState.isDehydrated) {
18937              queuedTarget.blockedOn = 3 === nearestMounted.tag ? nearestMounted.stateNode.containerInfo : null;
18938              return;
18939            }
18940          }
18941        }
18942        queuedTarget.blockedOn = null;
18943      }
18944      function attemptReplayContinuousQueuedEvent(queuedEvent) {
18945        if (null !== queuedEvent.blockedOn) return false;
18946        for (var targetContainers = queuedEvent.targetContainers; 0 < targetContainers.length; ) {
18947          var nextBlockedOn = findInstanceBlockingEvent(queuedEvent.nativeEvent);
18948          if (null === nextBlockedOn) {
18949            nextBlockedOn = queuedEvent.nativeEvent;
18950            var nativeEventClone = new nextBlockedOn.constructor(
18951              nextBlockedOn.type,
18952              nextBlockedOn
18953            ), event = nativeEventClone;
18954            null !== currentReplayingEvent && console.error(
18955              "Expected currently replaying event to be null. This error is likely caused by a bug in React. Please file an issue."
18956            );
18957            currentReplayingEvent = event;
18958            nextBlockedOn.target.dispatchEvent(nativeEventClone);
18959            null === currentReplayingEvent && console.error(
18960              "Expected currently replaying event to not be null. This error is likely caused by a bug in React. Please file an issue."
18961            );
18962            currentReplayingEvent = null;
18963          } else
18964            return targetContainers = getInstanceFromNode(nextBlockedOn), null !== targetContainers && attemptContinuousHydration(targetContainers), queuedEvent.blockedOn = nextBlockedOn, false;
18965          targetContainers.shift();
18966        }
18967        return true;
18968      }
18969      function attemptReplayContinuousQueuedEventInMap(queuedEvent, key, map) {
18970        attemptReplayContinuousQueuedEvent(queuedEvent) && map.delete(key);
18971      }
18972      function replayUnblockedEvents() {
18973        hasScheduledReplayAttempt = false;
18974        null !== queuedFocus && attemptReplayContinuousQueuedEvent(queuedFocus) && (queuedFocus = null);
18975        null !== queuedDrag && attemptReplayContinuousQueuedEvent(queuedDrag) && (queuedDrag = null);
18976        null !== queuedMouse && attemptReplayContinuousQueuedEvent(queuedMouse) && (queuedMouse = null);
18977        queuedPointers.forEach(attemptReplayContinuousQueuedEventInMap);
18978        queuedPointerCaptures.forEach(attemptReplayContinuousQueuedEventInMap);
18979      }
18980      function scheduleCallbackIfUnblocked(queuedEvent, unblocked) {
18981        queuedEvent.blockedOn === unblocked && (queuedEvent.blockedOn = null, hasScheduledReplayAttempt || (hasScheduledReplayAttempt = true, Scheduler.unstable_scheduleCallback(
18982          Scheduler.unstable_NormalPriority,
18983          replayUnblockedEvents
18984        )));
18985      }
18986      function scheduleReplayQueueIfNeeded(formReplayingQueue) {
18987        lastScheduledReplayQueue !== formReplayingQueue && (lastScheduledReplayQueue = formReplayingQueue, Scheduler.unstable_scheduleCallback(
18988          Scheduler.unstable_NormalPriority,
18989          function() {
18990            lastScheduledReplayQueue === formReplayingQueue && (lastScheduledReplayQueue = null);
18991            for (var i3 = 0; i3 < formReplayingQueue.length; i3 += 3) {
18992              var form = formReplayingQueue[i3], submitterOrAction = formReplayingQueue[i3 + 1], formData = formReplayingQueue[i3 + 2];
18993              if ("function" !== typeof submitterOrAction)
18994                if (null === findInstanceBlockingTarget(submitterOrAction || form))
18995                  continue;
18996                else break;
18997              var formInst = getInstanceFromNode(form);
18998              null !== formInst && (formReplayingQueue.splice(i3, 3), i3 -= 3, form = {
18999                pending: true,
19000                data: formData,
19001                method: form.method,
19002                action: submitterOrAction
19003              }, Object.freeze(form), startHostTransition(
19004                formInst,
19005                form,
19006                submitterOrAction,
19007                formData
19008              ));
19009            }
19010          }
19011        ));
19012      }
19013      function retryIfBlockedOn(unblocked) {
19014        function unblock(queuedEvent) {
19015          return scheduleCallbackIfUnblocked(queuedEvent, unblocked);
19016        }
19017        null !== queuedFocus && scheduleCallbackIfUnblocked(queuedFocus, unblocked);
19018        null !== queuedDrag && scheduleCallbackIfUnblocked(queuedDrag, unblocked);
19019        null !== queuedMouse && scheduleCallbackIfUnblocked(queuedMouse, unblocked);
19020        queuedPointers.forEach(unblock);
19021        queuedPointerCaptures.forEach(unblock);
19022        for (var i3 = 0; i3 < queuedExplicitHydrationTargets.length; i3++) {
19023          var queuedTarget = queuedExplicitHydrationTargets[i3];
19024          queuedTarget.blockedOn === unblocked && (queuedTarget.blockedOn = null);
19025        }
19026        for (; 0 < queuedExplicitHydrationTargets.length && (i3 = queuedExplicitHydrationTargets[0], null === i3.blockedOn); )
19027          attemptExplicitHydrationTarget(i3), null === i3.blockedOn && queuedExplicitHydrationTargets.shift();
19028        i3 = (unblocked.ownerDocument || unblocked).$$reactFormReplay;
19029        if (null != i3)
19030          for (queuedTarget = 0; queuedTarget < i3.length; queuedTarget += 3) {
19031            var form = i3[queuedTarget], submitterOrAction = i3[queuedTarget + 1], formProps = form[internalPropsKey] || null;
19032            if ("function" === typeof submitterOrAction)
19033              formProps || scheduleReplayQueueIfNeeded(i3);
19034            else if (formProps) {
19035              var action = null;
19036              if (submitterOrAction && submitterOrAction.hasAttribute("formAction"))
19037                if (form = submitterOrAction, formProps = submitterOrAction[internalPropsKey] || null)
19038                  action = formProps.formAction;
19039                else {
19040                  if (null !== findInstanceBlockingTarget(form)) continue;
19041                }
19042              else action = formProps.action;
19043              "function" === typeof action ? i3[queuedTarget + 1] = action : (i3.splice(queuedTarget, 3), queuedTarget -= 3);
19044              scheduleReplayQueueIfNeeded(i3);
19045            }
19046          }
19047      }
19048      function defaultOnDefaultTransitionIndicator() {
19049        function handleNavigate(event) {
19050          event.canIntercept && "react-transition" === event.info && event.intercept({
19051            handler: function() {
19052              return new Promise(function(resolve) {
19053                return pendingResolve = resolve;
19054              });
19055            },
19056            focusReset: "manual",
19057            scroll: "manual"
19058          });
19059        }
19060        function handleNavigateComplete() {
19061          null !== pendingResolve && (pendingResolve(), pendingResolve = null);
19062          isCancelled || setTimeout(startFakeNavigation, 20);
19063        }
19064        function startFakeNavigation() {
19065          if (!isCancelled && !navigation.transition) {
19066            var currentEntry = navigation.currentEntry;
19067            currentEntry && null != currentEntry.url && navigation.navigate(currentEntry.url, {
19068              state: currentEntry.getState(),
19069              info: "react-transition",
19070              history: "replace"
19071            });
19072          }
19073        }
19074        if ("object" === typeof navigation) {
19075          var isCancelled = false, pendingResolve = null;
19076          navigation.addEventListener("navigate", handleNavigate);
19077          navigation.addEventListener("navigatesuccess", handleNavigateComplete);
19078          navigation.addEventListener("navigateerror", handleNavigateComplete);
19079          setTimeout(startFakeNavigation, 100);
19080          return function() {
19081            isCancelled = true;
19082            navigation.removeEventListener("navigate", handleNavigate);
19083            navigation.removeEventListener(
19084              "navigatesuccess",
19085              handleNavigateComplete
19086            );
19087            navigation.removeEventListener(
19088              "navigateerror",
19089              handleNavigateComplete
19090            );
19091            null !== pendingResolve && (pendingResolve(), pendingResolve = null);
19092          };
19093        }
19094      }
19095      function ReactDOMRoot(internalRoot) {
19096        this._internalRoot = internalRoot;
19097      }
19098      function ReactDOMHydrationRoot(internalRoot) {
19099        this._internalRoot = internalRoot;
19100      }
19101      function warnIfReactDOMContainerInDEV(container) {
19102        container[internalContainerInstanceKey] && (container._reactRootContainer ? console.error(
19103          "You are calling ReactDOMClient.createRoot() on a container that was previously passed to ReactDOM.render(). This is not supported."
19104        ) : console.error(
19105          "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."
19106        ));
19107      }
19108      "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
19109      var Scheduler = require_scheduler(), React19 = require_react(), ReactDOM = require_react_dom(), assign = Object.assign, REACT_LEGACY_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("react.element"), REACT_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = /* @__PURE__ */ Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = /* @__PURE__ */ Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = /* @__PURE__ */ Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = /* @__PURE__ */ Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = /* @__PURE__ */ Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = /* @__PURE__ */ Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = /* @__PURE__ */ Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = /* @__PURE__ */ Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = /* @__PURE__ */ Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = /* @__PURE__ */ Symbol.for("react.memo"), REACT_LAZY_TYPE = /* @__PURE__ */ Symbol.for("react.lazy");
19110      /* @__PURE__ */ Symbol.for("react.scope");
19111      var REACT_ACTIVITY_TYPE = /* @__PURE__ */ Symbol.for("react.activity");
19112      /* @__PURE__ */ Symbol.for("react.legacy_hidden");
19113      /* @__PURE__ */ Symbol.for("react.tracing_marker");
19114      var REACT_MEMO_CACHE_SENTINEL = /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel");
19115      /* @__PURE__ */ Symbol.for("react.view_transition");
19116      var MAYBE_ITERATOR_SYMBOL = Symbol.iterator, REACT_CLIENT_REFERENCE = /* @__PURE__ */ Symbol.for("react.client.reference"), isArrayImpl = Array.isArray, ReactSharedInternals = React19.__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({
19117        pending: false,
19118        data: null,
19119        method: null,
19120        action: null
19121      }), valueStack = [];
19122      var fiberStack = [];
19123      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;
19124      disabledLog.__reactDisabledLog = true;
19125      var prefix, suffix, reentry = false;
19126      var componentFrameCache = new ("function" === typeof WeakMap ? WeakMap : Map)();
19127      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 = {
19128        button: true,
19129        checkbox: true,
19130        image: true,
19131        hidden: true,
19132        radio: true,
19133        reset: true,
19134        submit: true
19135      }, VALID_ATTRIBUTE_NAME_REGEX = RegExp(
19136        "^[: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]*$"
19137      ), illegalAttributeNameCache = {}, validatedAttributeNameCache = {}, escapeSelectorAttributeValueInsideDoubleQuotesRegex = /[\n"\\]/g, didWarnValueDefaultValue$1 = false, didWarnCheckedDefaultChecked = false, didWarnSelectedSetOnOption = false, didWarnInvalidChild = false, didWarnInvalidInnerHTML = false;
19138      var didWarnValueDefaultValue = false;
19139      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(
19140        " "
19141      ), inScopeTags = "applet caption html table td th marquee object template foreignObject desc title".split(
19142        " "
19143      ), buttonScopeTags = inScopeTags.concat(["button"]), impliedEndTags = "dd dt li option optgroup p rp rt".split(" "), emptyAncestorInfoDev = {
19144        current: null,
19145        formTag: null,
19146        aTagInScope: null,
19147        buttonTagInScope: null,
19148        nobrTagInScope: null,
19149        pTagInButtonScope: null,
19150        listItemTagAutoclosing: null,
19151        dlItemTagAutoclosing: null,
19152        containerTagInScope: null,
19153        implicitRootScope: false
19154      }, didWarn = {}, shorthandToLonghand = {
19155        animation: "animationDelay animationDirection animationDuration animationFillMode animationIterationCount animationName animationPlayState animationTimingFunction".split(
19156          " "
19157        ),
19158        background: "backgroundAttachment backgroundClip backgroundColor backgroundImage backgroundOrigin backgroundPositionX backgroundPositionY backgroundRepeat backgroundSize".split(
19159          " "
19160        ),
19161        backgroundPosition: ["backgroundPositionX", "backgroundPositionY"],
19162        border: "borderBottomColor borderBottomStyle borderBottomWidth borderImageOutset borderImageRepeat borderImageSlice borderImageSource borderImageWidth borderLeftColor borderLeftStyle borderLeftWidth borderRightColor borderRightStyle borderRightWidth borderTopColor borderTopStyle borderTopWidth".split(
19163          " "
19164        ),
19165        borderBlockEnd: [
19166          "borderBlockEndColor",
19167          "borderBlockEndStyle",
19168          "borderBlockEndWidth"
19169        ],
19170        borderBlockStart: [
19171          "borderBlockStartColor",
19172          "borderBlockStartStyle",
19173          "borderBlockStartWidth"
19174        ],
19175        borderBottom: [
19176          "borderBottomColor",
19177          "borderBottomStyle",
19178          "borderBottomWidth"
19179        ],
19180        borderColor: [
19181          "borderBottomColor",
19182          "borderLeftColor",
19183          "borderRightColor",
19184          "borderTopColor"
19185        ],
19186        borderImage: [
19187          "borderImageOutset",
19188          "borderImageRepeat",
19189          "borderImageSlice",
19190          "borderImageSource",
19191          "borderImageWidth"
19192        ],
19193        borderInlineEnd: [
19194          "borderInlineEndColor",
19195          "borderInlineEndStyle",
19196          "borderInlineEndWidth"
19197        ],
19198        borderInlineStart: [
19199          "borderInlineStartColor",
19200          "borderInlineStartStyle",
19201          "borderInlineStartWidth"
19202        ],
19203        borderLeft: ["borderLeftColor", "borderLeftStyle", "borderLeftWidth"],
19204        borderRadius: [
19205          "borderBottomLeftRadius",
19206          "borderBottomRightRadius",
19207          "borderTopLeftRadius",
19208          "borderTopRightRadius"
19209        ],
19210        borderRight: [
19211          "borderRightColor",
19212          "borderRightStyle",
19213          "borderRightWidth"
19214        ],
19215        borderStyle: [
19216          "borderBottomStyle",
19217          "borderLeftStyle",
19218          "borderRightStyle",
19219          "borderTopStyle"
19220        ],
19221        borderTop: ["borderTopColor", "borderTopStyle", "borderTopWidth"],
19222        borderWidth: [
19223          "borderBottomWidth",
19224          "borderLeftWidth",
19225          "borderRightWidth",
19226          "borderTopWidth"
19227        ],
19228        columnRule: ["columnRuleColor", "columnRuleStyle", "columnRuleWidth"],
19229        columns: ["columnCount", "columnWidth"],
19230        flex: ["flexBasis", "flexGrow", "flexShrink"],
19231        flexFlow: ["flexDirection", "flexWrap"],
19232        font: "fontFamily fontFeatureSettings fontKerning fontLanguageOverride fontSize fontSizeAdjust fontStretch fontStyle fontVariant fontVariantAlternates fontVariantCaps fontVariantEastAsian fontVariantLigatures fontVariantNumeric fontVariantPosition fontWeight lineHeight".split(
19233          " "
19234        ),
19235        fontVariant: "fontVariantAlternates fontVariantCaps fontVariantEastAsian fontVariantLigatures fontVariantNumeric fontVariantPosition".split(
19236          " "
19237        ),
19238        gap: ["columnGap", "rowGap"],
19239        grid: "gridAutoColumns gridAutoFlow gridAutoRows gridTemplateAreas gridTemplateColumns gridTemplateRows".split(
19240          " "
19241        ),
19242        gridArea: [
19243          "gridColumnEnd",
19244          "gridColumnStart",
19245          "gridRowEnd",
19246          "gridRowStart"
19247        ],
19248        gridColumn: ["gridColumnEnd", "gridColumnStart"],
19249        gridColumnGap: ["columnGap"],
19250        gridGap: ["columnGap", "rowGap"],
19251        gridRow: ["gridRowEnd", "gridRowStart"],
19252        gridRowGap: ["rowGap"],
19253        gridTemplate: [
19254          "gridTemplateAreas",
19255          "gridTemplateColumns",
19256          "gridTemplateRows"
19257        ],
19258        listStyle: ["listStyleImage", "listStylePosition", "listStyleType"],
19259        margin: ["marginBottom", "marginLeft", "marginRight", "marginTop"],
19260        marker: ["markerEnd", "markerMid", "markerStart"],
19261        mask: "maskClip maskComposite maskImage maskMode maskOrigin maskPositionX maskPositionY maskRepeat maskSize".split(
19262          " "
19263        ),
19264        maskPosition: ["maskPositionX", "maskPositionY"],
19265        outline: ["outlineColor", "outlineStyle", "outlineWidth"],
19266        overflow: ["overflowX", "overflowY"],
19267        padding: ["paddingBottom", "paddingLeft", "paddingRight", "paddingTop"],
19268        placeContent: ["alignContent", "justifyContent"],
19269        placeItems: ["alignItems", "justifyItems"],
19270        placeSelf: ["alignSelf", "justifySelf"],
19271        textDecoration: [
19272          "textDecorationColor",
19273          "textDecorationLine",
19274          "textDecorationStyle"
19275        ],
19276        textEmphasis: ["textEmphasisColor", "textEmphasisStyle"],
19277        transition: [
19278          "transitionDelay",
19279          "transitionDuration",
19280          "transitionProperty",
19281          "transitionTimingFunction"
19282        ],
19283        wordWrap: ["overflowWrap"]
19284      }, 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(
19285        "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(
19286          " "
19287        )
19288      ), MATH_NAMESPACE = "http://www.w3.org/1998/Math/MathML", SVG_NAMESPACE = "http://www.w3.org/2000/svg", aliases = /* @__PURE__ */ new Map([
19289        ["acceptCharset", "accept-charset"],
19290        ["htmlFor", "for"],
19291        ["httpEquiv", "http-equiv"],
19292        ["crossOrigin", "crossorigin"],
19293        ["accentHeight", "accent-height"],
19294        ["alignmentBaseline", "alignment-baseline"],
19295        ["arabicForm", "arabic-form"],
19296        ["baselineShift", "baseline-shift"],
19297        ["capHeight", "cap-height"],
19298        ["clipPath", "clip-path"],
19299        ["clipRule", "clip-rule"],
19300        ["colorInterpolation", "color-interpolation"],
19301        ["colorInterpolationFilters", "color-interpolation-filters"],
19302        ["colorProfile", "color-profile"],
19303        ["colorRendering", "color-rendering"],
19304        ["dominantBaseline", "dominant-baseline"],
19305        ["enableBackground", "enable-background"],
19306        ["fillOpacity", "fill-opacity"],
19307        ["fillRule", "fill-rule"],
19308        ["floodColor", "flood-color"],
19309        ["floodOpacity", "flood-opacity"],
19310        ["fontFamily", "font-family"],
19311        ["fontSize", "font-size"],
19312        ["fontSizeAdjust", "font-size-adjust"],
19313        ["fontStretch", "font-stretch"],
19314        ["fontStyle", "font-style"],
19315        ["fontVariant", "font-variant"],
19316        ["fontWeight", "font-weight"],
19317        ["glyphName", "glyph-name"],
19318        ["glyphOrientationHorizontal", "glyph-orientation-horizontal"],
19319        ["glyphOrientationVertical", "glyph-orientation-vertical"],
19320        ["horizAdvX", "horiz-adv-x"],
19321        ["horizOriginX", "horiz-origin-x"],
19322        ["imageRendering", "image-rendering"],
19323        ["letterSpacing", "letter-spacing"],
19324        ["lightingColor", "lighting-color"],
19325        ["markerEnd", "marker-end"],
19326        ["markerMid", "marker-mid"],
19327        ["markerStart", "marker-start"],
19328        ["overlinePosition", "overline-position"],
19329        ["overlineThickness", "overline-thickness"],
19330        ["paintOrder", "paint-order"],
19331        ["panose-1", "panose-1"],
19332        ["pointerEvents", "pointer-events"],
19333        ["renderingIntent", "rendering-intent"],
19334        ["shapeRendering", "shape-rendering"],
19335        ["stopColor", "stop-color"],
19336        ["stopOpacity", "stop-opacity"],
19337        ["strikethroughPosition", "strikethrough-position"],
19338        ["strikethroughThickness", "strikethrough-thickness"],
19339        ["strokeDasharray", "stroke-dasharray"],
19340        ["strokeDashoffset", "stroke-dashoffset"],
19341        ["strokeLinecap", "stroke-linecap"],
19342        ["strokeLinejoin", "stroke-linejoin"],
19343        ["strokeMiterlimit", "stroke-miterlimit"],
19344        ["strokeOpacity", "stroke-opacity"],
19345        ["strokeWidth", "stroke-width"],
19346        ["textAnchor", "text-anchor"],
19347        ["textDecoration", "text-decoration"],
19348        ["textRendering", "text-rendering"],
19349        ["transformOrigin", "transform-origin"],
19350        ["underlinePosition", "underline-position"],
19351        ["underlineThickness", "underline-thickness"],
19352        ["unicodeBidi", "unicode-bidi"],
19353        ["unicodeRange", "unicode-range"],
19354        ["unitsPerEm", "units-per-em"],
19355        ["vAlphabetic", "v-alphabetic"],
19356        ["vHanging", "v-hanging"],
19357        ["vIdeographic", "v-ideographic"],
19358        ["vMathematical", "v-mathematical"],
19359        ["vectorEffect", "vector-effect"],
19360        ["vertAdvY", "vert-adv-y"],
19361        ["vertOriginX", "vert-origin-x"],
19362        ["vertOriginY", "vert-origin-y"],
19363        ["wordSpacing", "word-spacing"],
19364        ["writingMode", "writing-mode"],
19365        ["xmlnsXlink", "xmlns:xlink"],
19366        ["xHeight", "x-height"]
19367      ]), possibleStandardNames = {
19368        accept: "accept",
19369        acceptcharset: "acceptCharset",
19370        "accept-charset": "acceptCharset",
19371        accesskey: "accessKey",
19372        action: "action",
19373        allowfullscreen: "allowFullScreen",
19374        alt: "alt",
19375        as: "as",
19376        async: "async",
19377        autocapitalize: "autoCapitalize",
19378        autocomplete: "autoComplete",
19379        autocorrect: "autoCorrect",
19380        autofocus: "autoFocus",
19381        autoplay: "autoPlay",
19382        autosave: "autoSave",
19383        capture: "capture",
19384        cellpadding: "cellPadding",
19385        cellspacing: "cellSpacing",
19386        challenge: "challenge",
19387        charset: "charSet",
19388        checked: "checked",
19389        children: "children",
19390        cite: "cite",
19391        class: "className",
19392        classid: "classID",
19393        classname: "className",
19394        cols: "cols",
19395        colspan: "colSpan",
19396        content: "content",
19397        contenteditable: "contentEditable",
19398        contextmenu: "contextMenu",
19399        controls: "controls",
19400        controlslist: "controlsList",
19401        coords: "coords",
19402        crossorigin: "crossOrigin",
19403        dangerouslysetinnerhtml: "dangerouslySetInnerHTML",
19404        data: "data",
19405        datetime: "dateTime",
19406        default: "default",
19407        defaultchecked: "defaultChecked",
19408        defaultvalue: "defaultValue",
19409        defer: "defer",
19410        dir: "dir",
19411        disabled: "disabled",
19412        disablepictureinpicture: "disablePictureInPicture",
19413        disableremoteplayback: "disableRemotePlayback",
19414        download: "download",
19415        draggable: "draggable",
19416        enctype: "encType",
19417        enterkeyhint: "enterKeyHint",
19418        fetchpriority: "fetchPriority",
19419        for: "htmlFor",
19420        form: "form",
19421        formmethod: "formMethod",
19422        formaction: "formAction",
19423        formenctype: "formEncType",
19424        formnovalidate: "formNoValidate",
19425        formtarget: "formTarget",
19426        frameborder: "frameBorder",
19427        headers: "headers",
19428        height: "height",
19429        hidden: "hidden",
19430        high: "high",
19431        href: "href",
19432        hreflang: "hrefLang",
19433        htmlfor: "htmlFor",
19434        httpequiv: "httpEquiv",
19435        "http-equiv": "httpEquiv",
19436        icon: "icon",
19437        id: "id",
19438        imagesizes: "imageSizes",
19439        imagesrcset: "imageSrcSet",
19440        inert: "inert",
19441        innerhtml: "innerHTML",
19442        inputmode: "inputMode",
19443        integrity: "integrity",
19444        is: "is",
19445        itemid: "itemID",
19446        itemprop: "itemProp",
19447        itemref: "itemRef",
19448        itemscope: "itemScope",
19449        itemtype: "itemType",
19450        keyparams: "keyParams",
19451        keytype: "keyType",
19452        kind: "kind",
19453        label: "label",
19454        lang: "lang",
19455        list: "list",
19456        loop: "loop",
19457        low: "low",
19458        manifest: "manifest",
19459        marginwidth: "marginWidth",
19460        marginheight: "marginHeight",
19461        max: "max",
19462        maxlength: "maxLength",
19463        media: "media",
19464        mediagroup: "mediaGroup",
19465        method: "method",
19466        min: "min",
19467        minlength: "minLength",
19468        multiple: "multiple",
19469        muted: "muted",
19470        name: "name",
19471        nomodule: "noModule",
19472        nonce: "nonce",
19473        novalidate: "noValidate",
19474        open: "open",
19475        optimum: "optimum",
19476        pattern: "pattern",
19477        placeholder: "placeholder",
19478        playsinline: "playsInline",
19479        poster: "poster",
19480        preload: "preload",
19481        profile: "profile",
19482        radiogroup: "radioGroup",
19483        readonly: "readOnly",
19484        referrerpolicy: "referrerPolicy",
19485        rel: "rel",
19486        required: "required",
19487        reversed: "reversed",
19488        role: "role",
19489        rows: "rows",
19490        rowspan: "rowSpan",
19491        sandbox: "sandbox",
19492        scope: "scope",
19493        scoped: "scoped",
19494        scrolling: "scrolling",
19495        seamless: "seamless",
19496        selected: "selected",
19497        shape: "shape",
19498        size: "size",
19499        sizes: "sizes",
19500        span: "span",
19501        spellcheck: "spellCheck",
19502        src: "src",
19503        srcdoc: "srcDoc",
19504        srclang: "srcLang",
19505        srcset: "srcSet",
19506        start: "start",
19507        step: "step",
19508        style: "style",
19509        summary: "summary",
19510        tabindex: "tabIndex",
19511        target: "target",
19512        title: "title",
19513        type: "type",
19514        usemap: "useMap",
19515        value: "value",
19516        width: "width",
19517        wmode: "wmode",
19518        wrap: "wrap",
19519        about: "about",
19520        accentheight: "accentHeight",
19521        "accent-height": "accentHeight",
19522        accumulate: "accumulate",
19523        additive: "additive",
19524        alignmentbaseline: "alignmentBaseline",
19525        "alignment-baseline": "alignmentBaseline",
19526        allowreorder: "allowReorder",
19527        alphabetic: "alphabetic",
19528        amplitude: "amplitude",
19529        arabicform: "arabicForm",
19530        "arabic-form": "arabicForm",
19531        ascent: "ascent",
19532        attributename: "attributeName",
19533        attributetype: "attributeType",
19534        autoreverse: "autoReverse",
19535        azimuth: "azimuth",
19536        basefrequency: "baseFrequency",
19537        baselineshift: "baselineShift",
19538        "baseline-shift": "baselineShift",
19539        baseprofile: "baseProfile",
19540        bbox: "bbox",
19541        begin: "begin",
19542        bias: "bias",
19543        by: "by",
19544        calcmode: "calcMode",
19545        capheight: "capHeight",
19546        "cap-height": "capHeight",
19547        clip: "clip",
19548        clippath: "clipPath",
19549        "clip-path": "clipPath",
19550        clippathunits: "clipPathUnits",
19551        cliprule: "clipRule",
19552        "clip-rule": "clipRule",
19553        color: "color",
19554        colorinterpolation: "colorInterpolation",
19555        "color-interpolation": "colorInterpolation",
19556        colorinterpolationfilters: "colorInterpolationFilters",
19557        "color-interpolation-filters": "colorInterpolationFilters",
19558        colorprofile: "colorProfile",
19559        "color-profile": "colorProfile",
19560        colorrendering: "colorRendering",
19561        "color-rendering": "colorRendering",
19562        contentscripttype: "contentScriptType",
19563        contentstyletype: "contentStyleType",
19564        cursor: "cursor",
19565        cx: "cx",
19566        cy: "cy",
19567        d: "d",
19568        datatype: "datatype",
19569        decelerate: "decelerate",
19570        descent: "descent",
19571        diffuseconstant: "diffuseConstant",
19572        direction: "direction",
19573        display: "display",
19574        divisor: "divisor",
19575        dominantbaseline: "dominantBaseline",
19576        "dominant-baseline": "dominantBaseline",
19577        dur: "dur",
19578        dx: "dx",
19579        dy: "dy",
19580        edgemode: "edgeMode",
19581        elevation: "elevation",
19582        enablebackground: "enableBackground",
19583        "enable-background": "enableBackground",
19584        end: "end",
19585        exponent: "exponent",
19586        externalresourcesrequired: "externalResourcesRequired",
19587        fill: "fill",
19588        fillopacity: "fillOpacity",
19589        "fill-opacity": "fillOpacity",
19590        fillrule: "fillRule",
19591        "fill-rule": "fillRule",
19592        filter: "filter",
19593        filterres: "filterRes",
19594        filterunits: "filterUnits",
19595        floodopacity: "floodOpacity",
19596        "flood-opacity": "floodOpacity",
19597        floodcolor: "floodColor",
19598        "flood-color": "floodColor",
19599        focusable: "focusable",
19600        fontfamily: "fontFamily",
19601        "font-family": "fontFamily",
19602        fontsize: "fontSize",
19603        "font-size": "fontSize",
19604        fontsizeadjust: "fontSizeAdjust",
19605        "font-size-adjust": "fontSizeAdjust",
19606        fontstretch: "fontStretch",
19607        "font-stretch": "fontStretch",
19608        fontstyle: "fontStyle",
19609        "font-style": "fontStyle",
19610        fontvariant: "fontVariant",
19611        "font-variant": "fontVariant",
19612        fontweight: "fontWeight",
19613        "font-weight": "fontWeight",
19614        format: "format",
19615        from: "from",
19616        fx: "fx",
19617        fy: "fy",
19618        g1: "g1",
19619        g2: "g2",
19620        glyphname: "glyphName",
19621        "glyph-name": "glyphName",
19622        glyphorientationhorizontal: "glyphOrientationHorizontal",
19623        "glyph-orientation-horizontal": "glyphOrientationHorizontal",
19624        glyphorientationvertical: "glyphOrientationVertical",
19625        "glyph-orientation-vertical": "glyphOrientationVertical",
19626        glyphref: "glyphRef",
19627        gradienttransform: "gradientTransform",
19628        gradientunits: "gradientUnits",
19629        hanging: "hanging",
19630        horizadvx: "horizAdvX",
19631        "horiz-adv-x": "horizAdvX",
19632        horizoriginx: "horizOriginX",
19633        "horiz-origin-x": "horizOriginX",
19634        ideographic: "ideographic",
19635        imagerendering: "imageRendering",
19636        "image-rendering": "imageRendering",
19637        in2: "in2",
19638        in: "in",
19639        inlist: "inlist",
19640        intercept: "intercept",
19641        k1: "k1",
19642        k2: "k2",
19643        k3: "k3",
19644        k4: "k4",
19645        k: "k",
19646        kernelmatrix: "kernelMatrix",
19647        kernelunitlength: "kernelUnitLength",
19648        kerning: "kerning",
19649        keypoints: "keyPoints",
19650        keysplines: "keySplines",
19651        keytimes: "keyTimes",
19652        lengthadjust: "lengthAdjust",
19653        letterspacing: "letterSpacing",
19654        "letter-spacing": "letterSpacing",
19655        lightingcolor: "lightingColor",
19656        "lighting-color": "lightingColor",
19657        limitingconeangle: "limitingConeAngle",
19658        local: "local",
19659        markerend: "markerEnd",
19660        "marker-end": "markerEnd",
19661        markerheight: "markerHeight",
19662        markermid: "markerMid",
19663        "marker-mid": "markerMid",
19664        markerstart: "markerStart",
19665        "marker-start": "markerStart",
19666        markerunits: "markerUnits",
19667        markerwidth: "markerWidth",
19668        mask: "mask",
19669        maskcontentunits: "maskContentUnits",
19670        maskunits: "maskUnits",
19671        mathematical: "mathematical",
19672        mode: "mode",
19673        numoctaves: "numOctaves",
19674        offset: "offset",
19675        opacity: "opacity",
19676        operator: "operator",
19677        order: "order",
19678        orient: "orient",
19679        orientation: "orientation",
19680        origin: "origin",
19681        overflow: "overflow",
19682        overlineposition: "overlinePosition",
19683        "overline-position": "overlinePosition",
19684        overlinethickness: "overlineThickness",
19685        "overline-thickness": "overlineThickness",
19686        paintorder: "paintOrder",
19687        "paint-order": "paintOrder",
19688        panose1: "panose1",
19689        "panose-1": "panose1",
19690        pathlength: "pathLength",
19691        patterncontentunits: "patternContentUnits",
19692        patterntransform: "patternTransform",
19693        patternunits: "patternUnits",
19694        pointerevents: "pointerEvents",
19695        "pointer-events": "pointerEvents",
19696        points: "points",
19697        pointsatx: "pointsAtX",
19698        pointsaty: "pointsAtY",
19699        pointsatz: "pointsAtZ",
19700        popover: "popover",
19701        popovertarget: "popoverTarget",
19702        popovertargetaction: "popoverTargetAction",
19703        prefix: "prefix",
19704        preservealpha: "preserveAlpha",
19705        preserveaspectratio: "preserveAspectRatio",
19706        primitiveunits: "primitiveUnits",
19707        property: "property",
19708        r: "r",
19709        radius: "radius",
19710        refx: "refX",
19711        refy: "refY",
19712        renderingintent: "renderingIntent",
19713        "rendering-intent": "renderingIntent",
19714        repeatcount: "repeatCount",
19715        repeatdur: "repeatDur",
19716        requiredextensions: "requiredExtensions",
19717        requiredfeatures: "requiredFeatures",
19718        resource: "resource",
19719        restart: "restart",
19720        result: "result",
19721        results: "results",
19722        rotate: "rotate",
19723        rx: "rx",
19724        ry: "ry",
19725        scale: "scale",
19726        security: "security",
19727        seed: "seed",
19728        shaperendering: "shapeRendering",
19729        "shape-rendering": "shapeRendering",
19730        slope: "slope",
19731        spacing: "spacing",
19732        specularconstant: "specularConstant",
19733        specularexponent: "specularExponent",
19734        speed: "speed",
19735        spreadmethod: "spreadMethod",
19736        startoffset: "startOffset",
19737        stddeviation: "stdDeviation",
19738        stemh: "stemh",
19739        stemv: "stemv",
19740        stitchtiles: "stitchTiles",
19741        stopcolor: "stopColor",
19742        "stop-color": "stopColor",
19743        stopopacity: "stopOpacity",
19744        "stop-opacity": "stopOpacity",
19745        strikethroughposition: "strikethroughPosition",
19746        "strikethrough-position": "strikethroughPosition",
19747        strikethroughthickness: "strikethroughThickness",
19748        "strikethrough-thickness": "strikethroughThickness",
19749        string: "string",
19750        stroke: "stroke",
19751        strokedasharray: "strokeDasharray",
19752        "stroke-dasharray": "strokeDasharray",
19753        strokedashoffset: "strokeDashoffset",
19754        "stroke-dashoffset": "strokeDashoffset",
19755        strokelinecap: "strokeLinecap",
19756        "stroke-linecap": "strokeLinecap",
19757        strokelinejoin: "strokeLinejoin",
19758        "stroke-linejoin": "strokeLinejoin",
19759        strokemiterlimit: "strokeMiterlimit",
19760        "stroke-miterlimit": "strokeMiterlimit",
19761        strokewidth: "strokeWidth",
19762        "stroke-width": "strokeWidth",
19763        strokeopacity: "strokeOpacity",
19764        "stroke-opacity": "strokeOpacity",
19765        suppresscontenteditablewarning: "suppressContentEditableWarning",
19766        suppresshydrationwarning: "suppressHydrationWarning",
19767        surfacescale: "surfaceScale",
19768        systemlanguage: "systemLanguage",
19769        tablevalues: "tableValues",
19770        targetx: "targetX",
19771        targety: "targetY",
19772        textanchor: "textAnchor",
19773        "text-anchor": "textAnchor",
19774        textdecoration: "textDecoration",
19775        "text-decoration": "textDecoration",
19776        textlength: "textLength",
19777        textrendering: "textRendering",
19778        "text-rendering": "textRendering",
19779        to: "to",
19780        transform: "transform",
19781        transformorigin: "transformOrigin",
19782        "transform-origin": "transformOrigin",
19783        typeof: "typeof",
19784        u1: "u1",
19785        u2: "u2",
19786        underlineposition: "underlinePosition",
19787        "underline-position": "underlinePosition",
19788        underlinethickness: "underlineThickness",
19789        "underline-thickness": "underlineThickness",
19790        unicode: "unicode",
19791        unicodebidi: "unicodeBidi",
19792        "unicode-bidi": "unicodeBidi",
19793        unicoderange: "unicodeRange",
19794        "unicode-range": "unicodeRange",
19795        unitsperem: "unitsPerEm",
19796        "units-per-em": "unitsPerEm",
19797        unselectable: "unselectable",
19798        valphabetic: "vAlphabetic",
19799        "v-alphabetic": "vAlphabetic",
19800        values: "values",
19801        vectoreffect: "vectorEffect",
19802        "vector-effect": "vectorEffect",
19803        version: "version",
19804        vertadvy: "vertAdvY",
19805        "vert-adv-y": "vertAdvY",
19806        vertoriginx: "vertOriginX",
19807        "vert-origin-x": "vertOriginX",
19808        vertoriginy: "vertOriginY",
19809        "vert-origin-y": "vertOriginY",
19810        vhanging: "vHanging",
19811        "v-hanging": "vHanging",
19812        videographic: "vIdeographic",
19813        "v-ideographic": "vIdeographic",
19814        viewbox: "viewBox",
19815        viewtarget: "viewTarget",
19816        visibility: "visibility",
19817        vmathematical: "vMathematical",
19818        "v-mathematical": "vMathematical",
19819        vocab: "vocab",
19820        widths: "widths",
19821        wordspacing: "wordSpacing",
19822        "word-spacing": "wordSpacing",
19823        writingmode: "writingMode",
19824        "writing-mode": "writingMode",
19825        x1: "x1",
19826        x2: "x2",
19827        x: "x",
19828        xchannelselector: "xChannelSelector",
19829        xheight: "xHeight",
19830        "x-height": "xHeight",
19831        xlinkactuate: "xlinkActuate",
19832        "xlink:actuate": "xlinkActuate",
19833        xlinkarcrole: "xlinkArcrole",
19834        "xlink:arcrole": "xlinkArcrole",
19835        xlinkhref: "xlinkHref",
19836        "xlink:href": "xlinkHref",
19837        xlinkrole: "xlinkRole",
19838        "xlink:role": "xlinkRole",
19839        xlinkshow: "xlinkShow",
19840        "xlink:show": "xlinkShow",
19841        xlinktitle: "xlinkTitle",
19842        "xlink:title": "xlinkTitle",
19843        xlinktype: "xlinkType",
19844        "xlink:type": "xlinkType",
19845        xmlbase: "xmlBase",
19846        "xml:base": "xmlBase",
19847        xmllang: "xmlLang",
19848        "xml:lang": "xmlLang",
19849        xmlns: "xmlns",
19850        "xml:space": "xmlSpace",
19851        xmlnsxlink: "xmlnsXlink",
19852        "xmlns:xlink": "xmlnsXlink",
19853        xmlspace: "xmlSpace",
19854        y1: "y1",
19855        y2: "y2",
19856        y: "y",
19857        ychannelselector: "yChannelSelector",
19858        z: "z",
19859        zoomandpan: "zoomAndPan"
19860      }, ariaProperties = {
19861        "aria-current": 0,
19862        "aria-description": 0,
19863        "aria-details": 0,
19864        "aria-disabled": 0,
19865        "aria-hidden": 0,
19866        "aria-invalid": 0,
19867        "aria-keyshortcuts": 0,
19868        "aria-label": 0,
19869        "aria-roledescription": 0,
19870        "aria-autocomplete": 0,
19871        "aria-checked": 0,
19872        "aria-expanded": 0,
19873        "aria-haspopup": 0,
19874        "aria-level": 0,
19875        "aria-modal": 0,
19876        "aria-multiline": 0,
19877        "aria-multiselectable": 0,
19878        "aria-orientation": 0,
19879        "aria-placeholder": 0,
19880        "aria-pressed": 0,
19881        "aria-readonly": 0,
19882        "aria-required": 0,
19883        "aria-selected": 0,
19884        "aria-sort": 0,
19885        "aria-valuemax": 0,
19886        "aria-valuemin": 0,
19887        "aria-valuenow": 0,
19888        "aria-valuetext": 0,
19889        "aria-atomic": 0,
19890        "aria-busy": 0,
19891        "aria-live": 0,
19892        "aria-relevant": 0,
19893        "aria-dropeffect": 0,
19894        "aria-grabbed": 0,
19895        "aria-activedescendant": 0,
19896        "aria-colcount": 0,
19897        "aria-colindex": 0,
19898        "aria-colspan": 0,
19899        "aria-controls": 0,
19900        "aria-describedby": 0,
19901        "aria-errormessage": 0,
19902        "aria-flowto": 0,
19903        "aria-labelledby": 0,
19904        "aria-owns": 0,
19905        "aria-posinset": 0,
19906        "aria-rowcount": 0,
19907        "aria-rowindex": 0,
19908        "aria-rowspan": 0,
19909        "aria-setsize": 0,
19910        "aria-braillelabel": 0,
19911        "aria-brailleroledescription": 0,
19912        "aria-colindextext": 0,
19913        "aria-rowindextext": 0
19914      }, warnedProperties$1 = {}, rARIA$1 = RegExp(
19915        "^(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]*$"
19916      ), rARIACamel$1 = RegExp(
19917        "^(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]*$"
19918      ), didWarnValueNull = false, warnedProperties = {}, EVENT_NAME_REGEX = /^on./, INVALID_EVENT_NAME_REGEX = /^on[^A-Z]/, rARIA = RegExp(
19919        "^(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]*$"
19920      ), rARIACamel = RegExp(
19921        "^(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]*$"
19922      ), 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;
19923      if (canUseDOM)
19924        try {
19925          var options$jscomp$0 = {};
19926          Object.defineProperty(options$jscomp$0, "passive", {
19927            get: function() {
19928              passiveBrowserEventsSupported = true;
19929            }
19930          });
19931          window.addEventListener("test", options$jscomp$0, options$jscomp$0);
19932          window.removeEventListener("test", options$jscomp$0, options$jscomp$0);
19933        } catch (e3) {
19934          passiveBrowserEventsSupported = false;
19935        }
19936      var root2 = null, startText = null, fallbackText = null, EventInterface = {
19937        eventPhase: 0,
19938        bubbles: 0,
19939        cancelable: 0,
19940        timeStamp: function(event) {
19941          return event.timeStamp || Date.now();
19942        },
19943        defaultPrevented: 0,
19944        isTrusted: 0
19945      }, SyntheticEvent = createSyntheticEvent(EventInterface), UIEventInterface = assign({}, EventInterface, { view: 0, detail: 0 }), SyntheticUIEvent = createSyntheticEvent(UIEventInterface), lastMovementX, lastMovementY, lastMouseEvent, MouseEventInterface = assign({}, UIEventInterface, {
19946        screenX: 0,
19947        screenY: 0,
19948        clientX: 0,
19949        clientY: 0,
19950        pageX: 0,
19951        pageY: 0,
19952        ctrlKey: 0,
19953        shiftKey: 0,
19954        altKey: 0,
19955        metaKey: 0,
19956        getModifierState: getEventModifierState,
19957        button: 0,
19958        buttons: 0,
19959        relatedTarget: function(event) {
19960          return void 0 === event.relatedTarget ? event.fromElement === event.srcElement ? event.toElement : event.fromElement : event.relatedTarget;
19961        },
19962        movementX: function(event) {
19963          if ("movementX" in event) return event.movementX;
19964          event !== lastMouseEvent && (lastMouseEvent && "mousemove" === event.type ? (lastMovementX = event.screenX - lastMouseEvent.screenX, lastMovementY = event.screenY - lastMouseEvent.screenY) : lastMovementY = lastMovementX = 0, lastMouseEvent = event);
19965          return lastMovementX;
19966        },
19967        movementY: function(event) {
19968          return "movementY" in event ? event.movementY : lastMovementY;
19969        }
19970      }), SyntheticMouseEvent = createSyntheticEvent(MouseEventInterface), DragEventInterface = assign({}, MouseEventInterface, { dataTransfer: 0 }), SyntheticDragEvent = createSyntheticEvent(DragEventInterface), FocusEventInterface = assign({}, UIEventInterface, { relatedTarget: 0 }), SyntheticFocusEvent = createSyntheticEvent(FocusEventInterface), AnimationEventInterface = assign({}, EventInterface, {
19971        animationName: 0,
19972        elapsedTime: 0,
19973        pseudoElement: 0
19974      }), SyntheticAnimationEvent = createSyntheticEvent(AnimationEventInterface), ClipboardEventInterface = assign({}, EventInterface, {
19975        clipboardData: function(event) {
19976          return "clipboardData" in event ? event.clipboardData : window.clipboardData;
19977        }
19978      }), SyntheticClipboardEvent = createSyntheticEvent(ClipboardEventInterface), CompositionEventInterface = assign({}, EventInterface, { data: 0 }), SyntheticCompositionEvent = createSyntheticEvent(
19979        CompositionEventInterface
19980      ), SyntheticInputEvent = SyntheticCompositionEvent, normalizeKey = {
19981        Esc: "Escape",
19982        Spacebar: " ",
19983        Left: "ArrowLeft",
19984        Up: "ArrowUp",
19985        Right: "ArrowRight",
19986        Down: "ArrowDown",
19987        Del: "Delete",
19988        Win: "OS",
19989        Menu: "ContextMenu",
19990        Apps: "ContextMenu",
19991        Scroll: "ScrollLock",
19992        MozPrintableKey: "Unidentified"
19993      }, translateToKey = {
19994        8: "Backspace",
19995        9: "Tab",
19996        12: "Clear",
19997        13: "Enter",
19998        16: "Shift",
19999        17: "Control",
20000        18: "Alt",
20001        19: "Pause",
20002        20: "CapsLock",
20003        27: "Escape",
20004        32: " ",
20005        33: "PageUp",
20006        34: "PageDown",
20007        35: "End",
20008        36: "Home",
20009        37: "ArrowLeft",
20010        38: "ArrowUp",
20011        39: "ArrowRight",
20012        40: "ArrowDown",
20013        45: "Insert",
20014        46: "Delete",
20015        112: "F1",
20016        113: "F2",
20017        114: "F3",
20018        115: "F4",
20019        116: "F5",
20020        117: "F6",
20021        118: "F7",
20022        119: "F8",
20023        120: "F9",
20024        121: "F10",
20025        122: "F11",
20026        123: "F12",
20027        144: "NumLock",
20028        145: "ScrollLock",
20029        224: "Meta"
20030      }, modifierKeyToProp = {
20031        Alt: "altKey",
20032        Control: "ctrlKey",
20033        Meta: "metaKey",
20034        Shift: "shiftKey"
20035      }, KeyboardEventInterface = assign({}, UIEventInterface, {
20036        key: function(nativeEvent) {
20037          if (nativeEvent.key) {
20038            var key = normalizeKey[nativeEvent.key] || nativeEvent.key;
20039            if ("Unidentified" !== key) return key;
20040          }
20041          return "keypress" === nativeEvent.type ? (nativeEvent = getEventCharCode(nativeEvent), 13 === nativeEvent ? "Enter" : String.fromCharCode(nativeEvent)) : "keydown" === nativeEvent.type || "keyup" === nativeEvent.type ? translateToKey[nativeEvent.keyCode] || "Unidentified" : "";
20042        },
20043        code: 0,
20044        location: 0,
20045        ctrlKey: 0,
20046        shiftKey: 0,
20047        altKey: 0,
20048        metaKey: 0,
20049        repeat: 0,
20050        locale: 0,
20051        getModifierState: getEventModifierState,
20052        charCode: function(event) {
20053          return "keypress" === event.type ? getEventCharCode(event) : 0;
20054        },
20055        keyCode: function(event) {
20056          return "keydown" === event.type || "keyup" === event.type ? event.keyCode : 0;
20057        },
20058        which: function(event) {
20059          return "keypress" === event.type ? getEventCharCode(event) : "keydown" === event.type || "keyup" === event.type ? event.keyCode : 0;
20060        }
20061      }), SyntheticKeyboardEvent = createSyntheticEvent(KeyboardEventInterface), PointerEventInterface = assign({}, MouseEventInterface, {
20062        pointerId: 0,
20063        width: 0,
20064        height: 0,
20065        pressure: 0,
20066        tangentialPressure: 0,
20067        tiltX: 0,
20068        tiltY: 0,
20069        twist: 0,
20070        pointerType: 0,
20071        isPrimary: 0
20072      }), SyntheticPointerEvent = createSyntheticEvent(PointerEventInterface), TouchEventInterface = assign({}, UIEventInterface, {
20073        touches: 0,
20074        targetTouches: 0,
20075        changedTouches: 0,
20076        altKey: 0,
20077        metaKey: 0,
20078        ctrlKey: 0,
20079        shiftKey: 0,
20080        getModifierState: getEventModifierState
20081      }), SyntheticTouchEvent = createSyntheticEvent(TouchEventInterface), TransitionEventInterface = assign({}, EventInterface, {
20082        propertyName: 0,
20083        elapsedTime: 0,
20084        pseudoElement: 0
20085      }), SyntheticTransitionEvent = createSyntheticEvent(TransitionEventInterface), WheelEventInterface = assign({}, MouseEventInterface, {
20086        deltaX: function(event) {
20087          return "deltaX" in event ? event.deltaX : "wheelDeltaX" in event ? -event.wheelDeltaX : 0;
20088        },
20089        deltaY: function(event) {
20090          return "deltaY" in event ? event.deltaY : "wheelDeltaY" in event ? -event.wheelDeltaY : "wheelDelta" in event ? -event.wheelDelta : 0;
20091        },
20092        deltaZ: 0,
20093        deltaMode: 0
20094      }), SyntheticWheelEvent = createSyntheticEvent(WheelEventInterface), ToggleEventInterface = assign({}, EventInterface, {
20095        newState: 0,
20096        oldState: 0
20097      }), SyntheticToggleEvent = createSyntheticEvent(ToggleEventInterface), END_KEYCODES = [9, 13, 27, 32], START_KEYCODE = 229, canUseCompositionEvent = canUseDOM && "CompositionEvent" in window, documentMode = null;
20098      canUseDOM && "documentMode" in document && (documentMode = document.documentMode);
20099      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 = {
20100        color: true,
20101        date: true,
20102        datetime: true,
20103        "datetime-local": true,
20104        email: true,
20105        month: true,
20106        number: true,
20107        password: true,
20108        range: true,
20109        search: true,
20110        tel: true,
20111        text: true,
20112        time: true,
20113        url: true,
20114        week: true
20115      }, activeElement$1 = null, activeElementInst$1 = null, isInputEventSupported = false;
20116      canUseDOM && (isInputEventSupported = isEventSupported("input") && (!document.documentMode || 9 < document.documentMode));
20117      var objectIs = "function" === typeof Object.is ? Object.is : is3, skipSelectionChangeEvent = canUseDOM && "documentMode" in document && 11 >= document.documentMode, activeElement = null, activeElementInst = null, lastSelection = null, mouseDown = false, vendorPrefixes = {
20118        animationend: makePrefixMap("Animation", "AnimationEnd"),
20119        animationiteration: makePrefixMap("Animation", "AnimationIteration"),
20120        animationstart: makePrefixMap("Animation", "AnimationStart"),
20121        transitionrun: makePrefixMap("Transition", "TransitionRun"),
20122        transitionstart: makePrefixMap("Transition", "TransitionStart"),
20123        transitioncancel: makePrefixMap("Transition", "TransitionCancel"),
20124        transitionend: makePrefixMap("Transition", "TransitionEnd")
20125      }, prefixedEventNames = {}, style = {};
20126      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);
20127      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(
20128        " "
20129      );
20130      simpleEventPluginEvents.push("scrollEnd");
20131      var lastResetTime = 0;
20132      if ("object" === typeof performance && "function" === typeof performance.now) {
20133        var localPerformance = performance;
20134        var getCurrentTime = function() {
20135          return localPerformance.now();
20136        };
20137      } else {
20138        var localDate = Date;
20139        getCurrentTime = function() {
20140          return localDate.now();
20141        };
20142      }
20143      var reportGlobalError = "function" === typeof reportError ? reportError : function(error2) {
20144        if ("object" === typeof window && "function" === typeof window.ErrorEvent) {
20145          var event = new window.ErrorEvent("error", {
20146            bubbles: true,
20147            cancelable: true,
20148            message: "object" === typeof error2 && null !== error2 && "string" === typeof error2.message ? String(error2.message) : String(error2),
20149            error: error2
20150          });
20151          if (!window.dispatchEvent(event)) return;
20152        } else if ("object" === typeof process && "function" === typeof process.emit) {
20153          process.emit("uncaughtException", error2);
20154          return;
20155        }
20156        console.error(error2);
20157      }, 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 = "\u2013\xA0", ADDED = "+\xA0", UNCHANGED = "\u2007\xA0", supportsUserTiming = "undefined" !== typeof console && "function" === typeof console.timeStamp && "undefined" !== typeof performance && "function" === typeof performance.measure, COMPONENTS_TRACK = "Components \u269B", LANES_TRACK_GROUP = "Scheduler \u269B", currentTrack = "Blocking", alreadyWarnedForDeepEquality = false, reusableComponentDevToolDetails = {
20158        color: "primary",
20159        properties: null,
20160        tooltipText: "",
20161        track: COMPONENTS_TRACK
20162      }, reusableComponentOptions = {
20163        start: -0,
20164        end: -0,
20165        detail: { devtools: reusableComponentDevToolDetails }
20166      }, 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 = {};
20167      Object.freeze(emptyContextObject);
20168      var resolveFamily = null, failedBoundaries = null, NoMode = 0, ConcurrentMode = 1, ProfileMode = 2, StrictLegacyMode = 8, StrictEffectsMode = 16, SuspenseyImagesMode = 32;
20169      var hasBadMapPolyfill = false;
20170      try {
20171        var nonExtensibleObject = Object.preventExtensions({});
20172        /* @__PURE__ */ new Map([[nonExtensibleObject, null]]);
20173        /* @__PURE__ */ new Set([nonExtensibleObject]);
20174      } catch (e$3) {
20175        hasBadMapPolyfill = true;
20176      }
20177      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(
20178        "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."
20179      ), valueCursor = createCursor(null);
20180      var rendererCursorDEV = createCursor(null);
20181      var rendererSigil = {};
20182      var currentlyRenderingFiber$1 = null, lastContextDependency = null, isDisallowedContextReadInDEV = false, AbortControllerLocal = "undefined" !== typeof AbortController ? AbortController : function() {
20183        var listeners = [], signal = this.signal = {
20184          aborted: false,
20185          addEventListener: function(type, listener) {
20186            listeners.push(listener);
20187          }
20188        };
20189        this.abort = function() {
20190          signal.aborted = true;
20191          listeners.forEach(function(listener) {
20192            return listener();
20193          });
20194        };
20195      }, scheduleCallback$2 = Scheduler.unstable_scheduleCallback, NormalPriority = Scheduler.unstable_NormalPriority, CacheContext = {
20196        $$typeof: REACT_CONTEXT_TYPE,
20197        Consumer: null,
20198        Provider: null,
20199        _currentValue: null,
20200        _currentValue2: null,
20201        _threadCount: 0,
20202        _currentRenderer: null,
20203        _currentRenderer2: null
20204      }, now3 = Scheduler.unstable_now, createTask = console.createTask ? console.createTask : function() {
20205        return null;
20206      }, 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;
20207      ReactSharedInternals.S = function(transition, returnValue) {
20208        globalMostRecentTransitionTime = now$1();
20209        if ("object" === typeof returnValue && null !== returnValue && "function" === typeof returnValue.then) {
20210          if (0 > transitionStartTime && 0 > transitionUpdateTime) {
20211            transitionStartTime = now3();
20212            var newEventTime = resolveEventTimeStamp(), newEventType = resolveEventType();
20213            if (newEventTime !== transitionEventRepeatTime || newEventType !== transitionEventType)
20214              transitionEventRepeatTime = -1.1;
20215            transitionEventTime = newEventTime;
20216            transitionEventType = newEventType;
20217          }
20218          entangleAsyncAction(transition, returnValue);
20219        }
20220        null !== prevOnStartTransitionFinish && prevOnStartTransitionFinish(transition, returnValue);
20221      };
20222      var resumedCache = createCursor(null), ReactStrictModeWarnings = {
20223        recordUnsafeLifecycleWarnings: function() {
20224        },
20225        flushPendingUnsafeLifecycleWarnings: function() {
20226        },
20227        recordLegacyContextWarning: function() {
20228        },
20229        flushLegacyContextWarning: function() {
20230        },
20231        discardPendingWarnings: function() {
20232        }
20233      }, pendingComponentWillMountWarnings = [], pendingUNSAFE_ComponentWillMountWarnings = [], pendingComponentWillReceivePropsWarnings = [], pendingUNSAFE_ComponentWillReceivePropsWarnings = [], pendingComponentWillUpdateWarnings = [], pendingUNSAFE_ComponentWillUpdateWarnings = [], didWarnAboutUnsafeLifecycles = /* @__PURE__ */ new Set();
20234      ReactStrictModeWarnings.recordUnsafeLifecycleWarnings = function(fiber, instance) {
20235        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));
20236      };
20237      ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings = function() {
20238        var componentWillMountUniqueNames = /* @__PURE__ */ new Set();
20239        0 < pendingComponentWillMountWarnings.length && (pendingComponentWillMountWarnings.forEach(function(fiber) {
20240          componentWillMountUniqueNames.add(
20241            getComponentNameFromFiber(fiber) || "Component"
20242          );
20243          didWarnAboutUnsafeLifecycles.add(fiber.type);
20244        }), pendingComponentWillMountWarnings = []);
20245        var UNSAFE_componentWillMountUniqueNames = /* @__PURE__ */ new Set();
20246        0 < pendingUNSAFE_ComponentWillMountWarnings.length && (pendingUNSAFE_ComponentWillMountWarnings.forEach(function(fiber) {
20247          UNSAFE_componentWillMountUniqueNames.add(
20248            getComponentNameFromFiber(fiber) || "Component"
20249          );
20250          didWarnAboutUnsafeLifecycles.add(fiber.type);
20251        }), pendingUNSAFE_ComponentWillMountWarnings = []);
20252        var componentWillReceivePropsUniqueNames = /* @__PURE__ */ new Set();
20253        0 < pendingComponentWillReceivePropsWarnings.length && (pendingComponentWillReceivePropsWarnings.forEach(function(fiber) {
20254          componentWillReceivePropsUniqueNames.add(
20255            getComponentNameFromFiber(fiber) || "Component"
20256          );
20257          didWarnAboutUnsafeLifecycles.add(fiber.type);
20258        }), pendingComponentWillReceivePropsWarnings = []);
20259        var UNSAFE_componentWillReceivePropsUniqueNames = /* @__PURE__ */ new Set();
20260        0 < pendingUNSAFE_ComponentWillReceivePropsWarnings.length && (pendingUNSAFE_ComponentWillReceivePropsWarnings.forEach(
20261          function(fiber) {
20262            UNSAFE_componentWillReceivePropsUniqueNames.add(
20263              getComponentNameFromFiber(fiber) || "Component"
20264            );
20265            didWarnAboutUnsafeLifecycles.add(fiber.type);
20266          }
20267        ), pendingUNSAFE_ComponentWillReceivePropsWarnings = []);
20268        var componentWillUpdateUniqueNames = /* @__PURE__ */ new Set();
20269        0 < pendingComponentWillUpdateWarnings.length && (pendingComponentWillUpdateWarnings.forEach(function(fiber) {
20270          componentWillUpdateUniqueNames.add(
20271            getComponentNameFromFiber(fiber) || "Component"
20272          );
20273          didWarnAboutUnsafeLifecycles.add(fiber.type);
20274        }), pendingComponentWillUpdateWarnings = []);
20275        var UNSAFE_componentWillUpdateUniqueNames = /* @__PURE__ */ new Set();
20276        0 < pendingUNSAFE_ComponentWillUpdateWarnings.length && (pendingUNSAFE_ComponentWillUpdateWarnings.forEach(function(fiber) {
20277          UNSAFE_componentWillUpdateUniqueNames.add(
20278            getComponentNameFromFiber(fiber) || "Component"
20279          );
20280          didWarnAboutUnsafeLifecycles.add(fiber.type);
20281        }), pendingUNSAFE_ComponentWillUpdateWarnings = []);
20282        if (0 < UNSAFE_componentWillMountUniqueNames.size) {
20283          var sortedNames = setToSortedString(
20284            UNSAFE_componentWillMountUniqueNames
20285          );
20286          console.error(
20287            "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",
20288            sortedNames
20289          );
20290        }
20291        0 < UNSAFE_componentWillReceivePropsUniqueNames.size && (sortedNames = setToSortedString(
20292          UNSAFE_componentWillReceivePropsUniqueNames
20293        ), console.error(
20294          "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",
20295          sortedNames
20296        ));
20297        0 < UNSAFE_componentWillUpdateUniqueNames.size && (sortedNames = setToSortedString(
20298          UNSAFE_componentWillUpdateUniqueNames
20299        ), console.error(
20300          "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",
20301          sortedNames
20302        ));
20303        0 < componentWillMountUniqueNames.size && (sortedNames = setToSortedString(componentWillMountUniqueNames), console.warn(
20304          "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",
20305          sortedNames
20306        ));
20307        0 < componentWillReceivePropsUniqueNames.size && (sortedNames = setToSortedString(
20308          componentWillReceivePropsUniqueNames
20309        ), console.warn(
20310          "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",
20311          sortedNames
20312        ));
20313        0 < componentWillUpdateUniqueNames.size && (sortedNames = setToSortedString(componentWillUpdateUniqueNames), console.warn(
20314          "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",
20315          sortedNames
20316        ));
20317      };
20318      var pendingLegacyContextWarning = /* @__PURE__ */ new Map(), didWarnAboutLegacyContext = /* @__PURE__ */ new Set();
20319      ReactStrictModeWarnings.recordLegacyContextWarning = function(fiber, instance) {
20320        var strictRoot = null;
20321        for (var node = fiber; null !== node; )
20322          node.mode & StrictLegacyMode && (strictRoot = node), node = node.return;
20323        null === strictRoot ? console.error(
20324          "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."
20325        ) : !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));
20326      };
20327      ReactStrictModeWarnings.flushLegacyContextWarning = function() {
20328        pendingLegacyContextWarning.forEach(function(fiberArray) {
20329          if (0 !== fiberArray.length) {
20330            var firstFiber = fiberArray[0], uniqueNames = /* @__PURE__ */ new Set();
20331            fiberArray.forEach(function(fiber) {
20332              uniqueNames.add(getComponentNameFromFiber(fiber) || "Component");
20333              didWarnAboutLegacyContext.add(fiber.type);
20334            });
20335            var sortedNames = setToSortedString(uniqueNames);
20336            runWithFiberInDEV(firstFiber, function() {
20337              console.error(
20338                "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",
20339                sortedNames
20340              );
20341            });
20342          }
20343        });
20344      };
20345      ReactStrictModeWarnings.discardPendingWarnings = function() {
20346        pendingComponentWillMountWarnings = [];
20347        pendingUNSAFE_ComponentWillMountWarnings = [];
20348        pendingComponentWillReceivePropsWarnings = [];
20349        pendingUNSAFE_ComponentWillReceivePropsWarnings = [];
20350        pendingComponentWillUpdateWarnings = [];
20351        pendingUNSAFE_ComponentWillUpdateWarnings = [];
20352        pendingLegacyContextWarning = /* @__PURE__ */ new Map();
20353      };
20354      var callComponent = {
20355        react_stack_bottom_frame: function(Component, props, secondArg) {
20356          var wasRendering = isRendering;
20357          isRendering = true;
20358          try {
20359            return Component(props, secondArg);
20360          } finally {
20361            isRendering = wasRendering;
20362          }
20363        }
20364      }, callComponentInDEV = callComponent.react_stack_bottom_frame.bind(callComponent), callRender = {
20365        react_stack_bottom_frame: function(instance) {
20366          var wasRendering = isRendering;
20367          isRendering = true;
20368          try {
20369            return instance.render();
20370          } finally {
20371            isRendering = wasRendering;
20372          }
20373        }
20374      }, callRenderInDEV = callRender.react_stack_bottom_frame.bind(callRender), callComponentDidMount = {
20375        react_stack_bottom_frame: function(finishedWork, instance) {
20376          try {
20377            instance.componentDidMount();
20378          } catch (error2) {
20379            captureCommitPhaseError(finishedWork, finishedWork.return, error2);
20380          }
20381        }
20382      }, callComponentDidMountInDEV = callComponentDidMount.react_stack_bottom_frame.bind(
20383        callComponentDidMount
20384      ), callComponentDidUpdate = {
20385        react_stack_bottom_frame: function(finishedWork, instance, prevProps, prevState, snapshot) {
20386          try {
20387            instance.componentDidUpdate(prevProps, prevState, snapshot);
20388          } catch (error2) {
20389            captureCommitPhaseError(finishedWork, finishedWork.return, error2);
20390          }
20391        }
20392      }, callComponentDidUpdateInDEV = callComponentDidUpdate.react_stack_bottom_frame.bind(
20393        callComponentDidUpdate
20394      ), callComponentDidCatch = {
20395        react_stack_bottom_frame: function(instance, errorInfo) {
20396          var stack = errorInfo.stack;
20397          instance.componentDidCatch(errorInfo.value, {
20398            componentStack: null !== stack ? stack : ""
20399          });
20400        }
20401      }, callComponentDidCatchInDEV = callComponentDidCatch.react_stack_bottom_frame.bind(
20402        callComponentDidCatch
20403      ), callComponentWillUnmount = {
20404        react_stack_bottom_frame: function(current2, nearestMountedAncestor, instance) {
20405          try {
20406            instance.componentWillUnmount();
20407          } catch (error2) {
20408            captureCommitPhaseError(current2, nearestMountedAncestor, error2);
20409          }
20410        }
20411      }, callComponentWillUnmountInDEV = callComponentWillUnmount.react_stack_bottom_frame.bind(
20412        callComponentWillUnmount
20413      ), callCreate = {
20414        react_stack_bottom_frame: function(effect) {
20415          var create = effect.create;
20416          effect = effect.inst;
20417          create = create();
20418          return effect.destroy = create;
20419        }
20420      }, callCreateInDEV = callCreate.react_stack_bottom_frame.bind(callCreate), callDestroy = {
20421        react_stack_bottom_frame: function(current2, nearestMountedAncestor, destroy) {
20422          try {
20423            destroy();
20424          } catch (error2) {
20425            captureCommitPhaseError(current2, nearestMountedAncestor, error2);
20426          }
20427        }
20428      }, callDestroyInDEV = callDestroy.react_stack_bottom_frame.bind(callDestroy), callLazyInit = {
20429        react_stack_bottom_frame: function(lazy) {
20430          var init = lazy._init;
20431          return init(lazy._payload);
20432        }
20433      }, callLazyInitInDEV = callLazyInit.react_stack_bottom_frame.bind(callLazyInit), SuspenseException = Error(
20434        "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`."
20435      ), SuspenseyCommitException = Error(
20436        "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."
20437      ), SuspenseActionException = Error(
20438        "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."
20439      ), noopSuspenseyCommitThenable = {
20440        then: function() {
20441          console.error(
20442            'Internal React error: A listener was unexpectedly attached to a "noop" thenable. This is a bug in React. Please file an issue.'
20443          );
20444        }
20445      }, suspendedThenable = null, needsToResetSuspendedThenableDEV = false, thenableState$1 = null, thenableIndexCounter$1 = 0, currentDebugInfo = null, didWarnAboutMaps;
20446      var didWarnAboutGenerators = didWarnAboutMaps = false;
20447      var ownerHasKeyUseWarning = {};
20448      var ownerHasFunctionTypeWarning = {};
20449      var ownerHasSymbolTypeWarning = {};
20450      warnForMissingKey = function(returnFiber, workInProgress2, child) {
20451        if (null !== child && "object" === typeof child && child._store && (!child._store.validated && null == child.key || 2 === child._store.validated)) {
20452          if ("object" !== typeof child._store)
20453            throw Error(
20454              "React Component in warnForMissingKey should have a _store. This error is likely caused by a bug in React. Please file an issue."
20455            );
20456          child._store.validated = 1;
20457          var componentName2 = getComponentNameFromFiber(returnFiber), componentKey = componentName2 || "null";
20458          if (!ownerHasKeyUseWarning[componentKey]) {
20459            ownerHasKeyUseWarning[componentKey] = true;
20460            child = child._owner;
20461            returnFiber = returnFiber._debugOwner;
20462            var currentComponentErrorInfo = "";
20463            returnFiber && "number" === typeof returnFiber.tag && (componentKey = getComponentNameFromFiber(returnFiber)) && (currentComponentErrorInfo = "\n\nCheck the render method of `" + componentKey + "`.");
20464            currentComponentErrorInfo || componentName2 && (currentComponentErrorInfo = "\n\nCheck the top-level render call using <" + componentName2 + ">.");
20465            var childOwnerAppendix = "";
20466            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 + "."));
20467            runWithFiberInDEV(workInProgress2, function() {
20468              console.error(
20469                'Each child in a list should have a unique "key" prop.%s%s See https://react.dev/link/warning-keys for more information.',
20470                currentComponentErrorInfo,
20471                childOwnerAppendix
20472              );
20473            });
20474          }
20475        }
20476      };
20477      var reconcileChildFibers = createChildReconciler(true), mountChildFibers = createChildReconciler(false), UpdateState = 0, ReplaceState = 1, ForceUpdate = 2, CaptureUpdate = 3, hasForceUpdate = false;
20478      var didWarnUpdateInsideUpdate = false;
20479      var currentlyProcessingQueue = null;
20480      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;
20481      var didWarnAboutMismatchedHooksForComponent = /* @__PURE__ */ new Set();
20482      var didWarnAboutUseWrappedInTryCatch = /* @__PURE__ */ new Set();
20483      var didWarnAboutAsyncClientComponent = /* @__PURE__ */ new Set();
20484      var didWarnAboutUseFormState = /* @__PURE__ */ new Set();
20485      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 = {
20486        readContext,
20487        use,
20488        useCallback: throwInvalidHookError,
20489        useContext: throwInvalidHookError,
20490        useEffect: throwInvalidHookError,
20491        useImperativeHandle: throwInvalidHookError,
20492        useLayoutEffect: throwInvalidHookError,
20493        useInsertionEffect: throwInvalidHookError,
20494        useMemo: throwInvalidHookError,
20495        useReducer: throwInvalidHookError,
20496        useRef: throwInvalidHookError,
20497        useState: throwInvalidHookError,
20498        useDebugValue: throwInvalidHookError,
20499        useDeferredValue: throwInvalidHookError,
20500        useTransition: throwInvalidHookError,
20501        useSyncExternalStore: throwInvalidHookError,
20502        useId: throwInvalidHookError,
20503        useHostTransitionStatus: throwInvalidHookError,
20504        useFormState: throwInvalidHookError,
20505        useActionState: throwInvalidHookError,
20506        useOptimistic: throwInvalidHookError,
20507        useMemoCache: throwInvalidHookError,
20508        useCacheRefresh: throwInvalidHookError
20509      };
20510      ContextOnlyDispatcher.useEffectEvent = throwInvalidHookError;
20511      var HooksDispatcherOnMountInDEV = null, HooksDispatcherOnMountWithHookTypesInDEV = null, HooksDispatcherOnUpdateInDEV = null, HooksDispatcherOnRerenderInDEV = null, InvalidNestedHooksDispatcherOnMountInDEV = null, InvalidNestedHooksDispatcherOnUpdateInDEV = null, InvalidNestedHooksDispatcherOnRerenderInDEV = null;
20512      HooksDispatcherOnMountInDEV = {
20513        readContext: function(context) {
20514          return readContext(context);
20515        },
20516        use,
20517        useCallback: function(callback, deps) {
20518          currentHookNameInDev = "useCallback";
20519          mountHookTypesDev();
20520          checkDepsAreArrayDev(deps);
20521          return mountCallback(callback, deps);
20522        },
20523        useContext: function(context) {
20524          currentHookNameInDev = "useContext";
20525          mountHookTypesDev();
20526          return readContext(context);
20527        },
20528        useEffect: function(create, deps) {
20529          currentHookNameInDev = "useEffect";
20530          mountHookTypesDev();
20531          checkDepsAreArrayDev(deps);
20532          return mountEffect(create, deps);
20533        },
20534        useImperativeHandle: function(ref, create, deps) {
20535          currentHookNameInDev = "useImperativeHandle";
20536          mountHookTypesDev();
20537          checkDepsAreArrayDev(deps);
20538          return mountImperativeHandle(ref, create, deps);
20539        },
20540        useInsertionEffect: function(create, deps) {
20541          currentHookNameInDev = "useInsertionEffect";
20542          mountHookTypesDev();
20543          checkDepsAreArrayDev(deps);
20544          mountEffectImpl(4, Insertion, create, deps);
20545        },
20546        useLayoutEffect: function(create, deps) {
20547          currentHookNameInDev = "useLayoutEffect";
20548          mountHookTypesDev();
20549          checkDepsAreArrayDev(deps);
20550          return mountLayoutEffect(create, deps);
20551        },
20552        useMemo: function(create, deps) {
20553          currentHookNameInDev = "useMemo";
20554          mountHookTypesDev();
20555          checkDepsAreArrayDev(deps);
20556          var prevDispatcher = ReactSharedInternals.H;
20557          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnMountInDEV;
20558          try {
20559            return mountMemo(create, deps);
20560          } finally {
20561            ReactSharedInternals.H = prevDispatcher;
20562          }
20563        },
20564        useReducer: function(reducer, initialArg, init) {
20565          currentHookNameInDev = "useReducer";
20566          mountHookTypesDev();
20567          var prevDispatcher = ReactSharedInternals.H;
20568          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnMountInDEV;
20569          try {
20570            return mountReducer(reducer, initialArg, init);
20571          } finally {
20572            ReactSharedInternals.H = prevDispatcher;
20573          }
20574        },
20575        useRef: function(initialValue) {
20576          currentHookNameInDev = "useRef";
20577          mountHookTypesDev();
20578          return mountRef(initialValue);
20579        },
20580        useState: function(initialState) {
20581          currentHookNameInDev = "useState";
20582          mountHookTypesDev();
20583          var prevDispatcher = ReactSharedInternals.H;
20584          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnMountInDEV;
20585          try {
20586            return mountState(initialState);
20587          } finally {
20588            ReactSharedInternals.H = prevDispatcher;
20589          }
20590        },
20591        useDebugValue: function() {
20592          currentHookNameInDev = "useDebugValue";
20593          mountHookTypesDev();
20594        },
20595        useDeferredValue: function(value, initialValue) {
20596          currentHookNameInDev = "useDeferredValue";
20597          mountHookTypesDev();
20598          return mountDeferredValue(value, initialValue);
20599        },
20600        useTransition: function() {
20601          currentHookNameInDev = "useTransition";
20602          mountHookTypesDev();
20603          return mountTransition();
20604        },
20605        useSyncExternalStore: function(subscribe, getSnapshot, getServerSnapshot) {
20606          currentHookNameInDev = "useSyncExternalStore";
20607          mountHookTypesDev();
20608          return mountSyncExternalStore(
20609            subscribe,
20610            getSnapshot,
20611            getServerSnapshot
20612          );
20613        },
20614        useId: function() {
20615          currentHookNameInDev = "useId";
20616          mountHookTypesDev();
20617          return mountId();
20618        },
20619        useFormState: function(action, initialState) {
20620          currentHookNameInDev = "useFormState";
20621          mountHookTypesDev();
20622          warnOnUseFormStateInDev();
20623          return mountActionState(action, initialState);
20624        },
20625        useActionState: function(action, initialState) {
20626          currentHookNameInDev = "useActionState";
20627          mountHookTypesDev();
20628          return mountActionState(action, initialState);
20629        },
20630        useOptimistic: function(passthrough) {
20631          currentHookNameInDev = "useOptimistic";
20632          mountHookTypesDev();
20633          return mountOptimistic(passthrough);
20634        },
20635        useHostTransitionStatus,
20636        useMemoCache,
20637        useCacheRefresh: function() {
20638          currentHookNameInDev = "useCacheRefresh";
20639          mountHookTypesDev();
20640          return mountRefresh();
20641        },
20642        useEffectEvent: function(callback) {
20643          currentHookNameInDev = "useEffectEvent";
20644          mountHookTypesDev();
20645          return mountEvent(callback);
20646        }
20647      };
20648      HooksDispatcherOnMountWithHookTypesInDEV = {
20649        readContext: function(context) {
20650          return readContext(context);
20651        },
20652        use,
20653        useCallback: function(callback, deps) {
20654          currentHookNameInDev = "useCallback";
20655          updateHookTypesDev();
20656          return mountCallback(callback, deps);
20657        },
20658        useContext: function(context) {
20659          currentHookNameInDev = "useContext";
20660          updateHookTypesDev();
20661          return readContext(context);
20662        },
20663        useEffect: function(create, deps) {
20664          currentHookNameInDev = "useEffect";
20665          updateHookTypesDev();
20666          return mountEffect(create, deps);
20667        },
20668        useImperativeHandle: function(ref, create, deps) {
20669          currentHookNameInDev = "useImperativeHandle";
20670          updateHookTypesDev();
20671          return mountImperativeHandle(ref, create, deps);
20672        },
20673        useInsertionEffect: function(create, deps) {
20674          currentHookNameInDev = "useInsertionEffect";
20675          updateHookTypesDev();
20676          mountEffectImpl(4, Insertion, create, deps);
20677        },
20678        useLayoutEffect: function(create, deps) {
20679          currentHookNameInDev = "useLayoutEffect";
20680          updateHookTypesDev();
20681          return mountLayoutEffect(create, deps);
20682        },
20683        useMemo: function(create, deps) {
20684          currentHookNameInDev = "useMemo";
20685          updateHookTypesDev();
20686          var prevDispatcher = ReactSharedInternals.H;
20687          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnMountInDEV;
20688          try {
20689            return mountMemo(create, deps);
20690          } finally {
20691            ReactSharedInternals.H = prevDispatcher;
20692          }
20693        },
20694        useReducer: function(reducer, initialArg, init) {
20695          currentHookNameInDev = "useReducer";
20696          updateHookTypesDev();
20697          var prevDispatcher = ReactSharedInternals.H;
20698          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnMountInDEV;
20699          try {
20700            return mountReducer(reducer, initialArg, init);
20701          } finally {
20702            ReactSharedInternals.H = prevDispatcher;
20703          }
20704        },
20705        useRef: function(initialValue) {
20706          currentHookNameInDev = "useRef";
20707          updateHookTypesDev();
20708          return mountRef(initialValue);
20709        },
20710        useState: function(initialState) {
20711          currentHookNameInDev = "useState";
20712          updateHookTypesDev();
20713          var prevDispatcher = ReactSharedInternals.H;
20714          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnMountInDEV;
20715          try {
20716            return mountState(initialState);
20717          } finally {
20718            ReactSharedInternals.H = prevDispatcher;
20719          }
20720        },
20721        useDebugValue: function() {
20722          currentHookNameInDev = "useDebugValue";
20723          updateHookTypesDev();
20724        },
20725        useDeferredValue: function(value, initialValue) {
20726          currentHookNameInDev = "useDeferredValue";
20727          updateHookTypesDev();
20728          return mountDeferredValue(value, initialValue);
20729        },
20730        useTransition: function() {
20731          currentHookNameInDev = "useTransition";
20732          updateHookTypesDev();
20733          return mountTransition();
20734        },
20735        useSyncExternalStore: function(subscribe, getSnapshot, getServerSnapshot) {
20736          currentHookNameInDev = "useSyncExternalStore";
20737          updateHookTypesDev();
20738          return mountSyncExternalStore(
20739            subscribe,
20740            getSnapshot,
20741            getServerSnapshot
20742          );
20743        },
20744        useId: function() {
20745          currentHookNameInDev = "useId";
20746          updateHookTypesDev();
20747          return mountId();
20748        },
20749        useActionState: function(action, initialState) {
20750          currentHookNameInDev = "useActionState";
20751          updateHookTypesDev();
20752          return mountActionState(action, initialState);
20753        },
20754        useFormState: function(action, initialState) {
20755          currentHookNameInDev = "useFormState";
20756          updateHookTypesDev();
20757          warnOnUseFormStateInDev();
20758          return mountActionState(action, initialState);
20759        },
20760        useOptimistic: function(passthrough) {
20761          currentHookNameInDev = "useOptimistic";
20762          updateHookTypesDev();
20763          return mountOptimistic(passthrough);
20764        },
20765        useHostTransitionStatus,
20766        useMemoCache,
20767        useCacheRefresh: function() {
20768          currentHookNameInDev = "useCacheRefresh";
20769          updateHookTypesDev();
20770          return mountRefresh();
20771        },
20772        useEffectEvent: function(callback) {
20773          currentHookNameInDev = "useEffectEvent";
20774          updateHookTypesDev();
20775          return mountEvent(callback);
20776        }
20777      };
20778      HooksDispatcherOnUpdateInDEV = {
20779        readContext: function(context) {
20780          return readContext(context);
20781        },
20782        use,
20783        useCallback: function(callback, deps) {
20784          currentHookNameInDev = "useCallback";
20785          updateHookTypesDev();
20786          return updateCallback(callback, deps);
20787        },
20788        useContext: function(context) {
20789          currentHookNameInDev = "useContext";
20790          updateHookTypesDev();
20791          return readContext(context);
20792        },
20793        useEffect: function(create, deps) {
20794          currentHookNameInDev = "useEffect";
20795          updateHookTypesDev();
20796          updateEffectImpl(2048, Passive, create, deps);
20797        },
20798        useImperativeHandle: function(ref, create, deps) {
20799          currentHookNameInDev = "useImperativeHandle";
20800          updateHookTypesDev();
20801          return updateImperativeHandle(ref, create, deps);
20802        },
20803        useInsertionEffect: function(create, deps) {
20804          currentHookNameInDev = "useInsertionEffect";
20805          updateHookTypesDev();
20806          return updateEffectImpl(4, Insertion, create, deps);
20807        },
20808        useLayoutEffect: function(create, deps) {
20809          currentHookNameInDev = "useLayoutEffect";
20810          updateHookTypesDev();
20811          return updateEffectImpl(4, Layout, create, deps);
20812        },
20813        useMemo: function(create, deps) {
20814          currentHookNameInDev = "useMemo";
20815          updateHookTypesDev();
20816          var prevDispatcher = ReactSharedInternals.H;
20817          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
20818          try {
20819            return updateMemo(create, deps);
20820          } finally {
20821            ReactSharedInternals.H = prevDispatcher;
20822          }
20823        },
20824        useReducer: function(reducer, initialArg, init) {
20825          currentHookNameInDev = "useReducer";
20826          updateHookTypesDev();
20827          var prevDispatcher = ReactSharedInternals.H;
20828          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
20829          try {
20830            return updateReducer(reducer, initialArg, init);
20831          } finally {
20832            ReactSharedInternals.H = prevDispatcher;
20833          }
20834        },
20835        useRef: function() {
20836          currentHookNameInDev = "useRef";
20837          updateHookTypesDev();
20838          return updateWorkInProgressHook().memoizedState;
20839        },
20840        useState: function() {
20841          currentHookNameInDev = "useState";
20842          updateHookTypesDev();
20843          var prevDispatcher = ReactSharedInternals.H;
20844          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
20845          try {
20846            return updateReducer(basicStateReducer);
20847          } finally {
20848            ReactSharedInternals.H = prevDispatcher;
20849          }
20850        },
20851        useDebugValue: function() {
20852          currentHookNameInDev = "useDebugValue";
20853          updateHookTypesDev();
20854        },
20855        useDeferredValue: function(value, initialValue) {
20856          currentHookNameInDev = "useDeferredValue";
20857          updateHookTypesDev();
20858          return updateDeferredValue(value, initialValue);
20859        },
20860        useTransition: function() {
20861          currentHookNameInDev = "useTransition";
20862          updateHookTypesDev();
20863          return updateTransition();
20864        },
20865        useSyncExternalStore: function(subscribe, getSnapshot, getServerSnapshot) {
20866          currentHookNameInDev = "useSyncExternalStore";
20867          updateHookTypesDev();
20868          return updateSyncExternalStore(
20869            subscribe,
20870            getSnapshot,
20871            getServerSnapshot
20872          );
20873        },
20874        useId: function() {
20875          currentHookNameInDev = "useId";
20876          updateHookTypesDev();
20877          return updateWorkInProgressHook().memoizedState;
20878        },
20879        useFormState: function(action) {
20880          currentHookNameInDev = "useFormState";
20881          updateHookTypesDev();
20882          warnOnUseFormStateInDev();
20883          return updateActionState(action);
20884        },
20885        useActionState: function(action) {
20886          currentHookNameInDev = "useActionState";
20887          updateHookTypesDev();
20888          return updateActionState(action);
20889        },
20890        useOptimistic: function(passthrough, reducer) {
20891          currentHookNameInDev = "useOptimistic";
20892          updateHookTypesDev();
20893          return updateOptimistic(passthrough, reducer);
20894        },
20895        useHostTransitionStatus,
20896        useMemoCache,
20897        useCacheRefresh: function() {
20898          currentHookNameInDev = "useCacheRefresh";
20899          updateHookTypesDev();
20900          return updateWorkInProgressHook().memoizedState;
20901        },
20902        useEffectEvent: function(callback) {
20903          currentHookNameInDev = "useEffectEvent";
20904          updateHookTypesDev();
20905          return updateEvent(callback);
20906        }
20907      };
20908      HooksDispatcherOnRerenderInDEV = {
20909        readContext: function(context) {
20910          return readContext(context);
20911        },
20912        use,
20913        useCallback: function(callback, deps) {
20914          currentHookNameInDev = "useCallback";
20915          updateHookTypesDev();
20916          return updateCallback(callback, deps);
20917        },
20918        useContext: function(context) {
20919          currentHookNameInDev = "useContext";
20920          updateHookTypesDev();
20921          return readContext(context);
20922        },
20923        useEffect: function(create, deps) {
20924          currentHookNameInDev = "useEffect";
20925          updateHookTypesDev();
20926          updateEffectImpl(2048, Passive, create, deps);
20927        },
20928        useImperativeHandle: function(ref, create, deps) {
20929          currentHookNameInDev = "useImperativeHandle";
20930          updateHookTypesDev();
20931          return updateImperativeHandle(ref, create, deps);
20932        },
20933        useInsertionEffect: function(create, deps) {
20934          currentHookNameInDev = "useInsertionEffect";
20935          updateHookTypesDev();
20936          return updateEffectImpl(4, Insertion, create, deps);
20937        },
20938        useLayoutEffect: function(create, deps) {
20939          currentHookNameInDev = "useLayoutEffect";
20940          updateHookTypesDev();
20941          return updateEffectImpl(4, Layout, create, deps);
20942        },
20943        useMemo: function(create, deps) {
20944          currentHookNameInDev = "useMemo";
20945          updateHookTypesDev();
20946          var prevDispatcher = ReactSharedInternals.H;
20947          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnRerenderInDEV;
20948          try {
20949            return updateMemo(create, deps);
20950          } finally {
20951            ReactSharedInternals.H = prevDispatcher;
20952          }
20953        },
20954        useReducer: function(reducer, initialArg, init) {
20955          currentHookNameInDev = "useReducer";
20956          updateHookTypesDev();
20957          var prevDispatcher = ReactSharedInternals.H;
20958          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnRerenderInDEV;
20959          try {
20960            return rerenderReducer(reducer, initialArg, init);
20961          } finally {
20962            ReactSharedInternals.H = prevDispatcher;
20963          }
20964        },
20965        useRef: function() {
20966          currentHookNameInDev = "useRef";
20967          updateHookTypesDev();
20968          return updateWorkInProgressHook().memoizedState;
20969        },
20970        useState: function() {
20971          currentHookNameInDev = "useState";
20972          updateHookTypesDev();
20973          var prevDispatcher = ReactSharedInternals.H;
20974          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnRerenderInDEV;
20975          try {
20976            return rerenderReducer(basicStateReducer);
20977          } finally {
20978            ReactSharedInternals.H = prevDispatcher;
20979          }
20980        },
20981        useDebugValue: function() {
20982          currentHookNameInDev = "useDebugValue";
20983          updateHookTypesDev();
20984        },
20985        useDeferredValue: function(value, initialValue) {
20986          currentHookNameInDev = "useDeferredValue";
20987          updateHookTypesDev();
20988          return rerenderDeferredValue(value, initialValue);
20989        },
20990        useTransition: function() {
20991          currentHookNameInDev = "useTransition";
20992          updateHookTypesDev();
20993          return rerenderTransition();
20994        },
20995        useSyncExternalStore: function(subscribe, getSnapshot, getServerSnapshot) {
20996          currentHookNameInDev = "useSyncExternalStore";
20997          updateHookTypesDev();
20998          return updateSyncExternalStore(
20999            subscribe,
21000            getSnapshot,
21001            getServerSnapshot
21002          );
21003        },
21004        useId: function() {
21005          currentHookNameInDev = "useId";
21006          updateHookTypesDev();
21007          return updateWorkInProgressHook().memoizedState;
21008        },
21009        useFormState: function(action) {
21010          currentHookNameInDev = "useFormState";
21011          updateHookTypesDev();
21012          warnOnUseFormStateInDev();
21013          return rerenderActionState(action);
21014        },
21015        useActionState: function(action) {
21016          currentHookNameInDev = "useActionState";
21017          updateHookTypesDev();
21018          return rerenderActionState(action);
21019        },
21020        useOptimistic: function(passthrough, reducer) {
21021          currentHookNameInDev = "useOptimistic";
21022          updateHookTypesDev();
21023          return rerenderOptimistic(passthrough, reducer);
21024        },
21025        useHostTransitionStatus,
21026        useMemoCache,
21027        useCacheRefresh: function() {
21028          currentHookNameInDev = "useCacheRefresh";
21029          updateHookTypesDev();
21030          return updateWorkInProgressHook().memoizedState;
21031        },
21032        useEffectEvent: function(callback) {
21033          currentHookNameInDev = "useEffectEvent";
21034          updateHookTypesDev();
21035          return updateEvent(callback);
21036        }
21037      };
21038      InvalidNestedHooksDispatcherOnMountInDEV = {
21039        readContext: function(context) {
21040          warnInvalidContextAccess();
21041          return readContext(context);
21042        },
21043        use: function(usable) {
21044          warnInvalidHookAccess();
21045          return use(usable);
21046        },
21047        useCallback: function(callback, deps) {
21048          currentHookNameInDev = "useCallback";
21049          warnInvalidHookAccess();
21050          mountHookTypesDev();
21051          return mountCallback(callback, deps);
21052        },
21053        useContext: function(context) {
21054          currentHookNameInDev = "useContext";
21055          warnInvalidHookAccess();
21056          mountHookTypesDev();
21057          return readContext(context);
21058        },
21059        useEffect: function(create, deps) {
21060          currentHookNameInDev = "useEffect";
21061          warnInvalidHookAccess();
21062          mountHookTypesDev();
21063          return mountEffect(create, deps);
21064        },
21065        useImperativeHandle: function(ref, create, deps) {
21066          currentHookNameInDev = "useImperativeHandle";
21067          warnInvalidHookAccess();
21068          mountHookTypesDev();
21069          return mountImperativeHandle(ref, create, deps);
21070        },
21071        useInsertionEffect: function(create, deps) {
21072          currentHookNameInDev = "useInsertionEffect";
21073          warnInvalidHookAccess();
21074          mountHookTypesDev();
21075          mountEffectImpl(4, Insertion, create, deps);
21076        },
21077        useLayoutEffect: function(create, deps) {
21078          currentHookNameInDev = "useLayoutEffect";
21079          warnInvalidHookAccess();
21080          mountHookTypesDev();
21081          return mountLayoutEffect(create, deps);
21082        },
21083        useMemo: function(create, deps) {
21084          currentHookNameInDev = "useMemo";
21085          warnInvalidHookAccess();
21086          mountHookTypesDev();
21087          var prevDispatcher = ReactSharedInternals.H;
21088          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnMountInDEV;
21089          try {
21090            return mountMemo(create, deps);
21091          } finally {
21092            ReactSharedInternals.H = prevDispatcher;
21093          }
21094        },
21095        useReducer: function(reducer, initialArg, init) {
21096          currentHookNameInDev = "useReducer";
21097          warnInvalidHookAccess();
21098          mountHookTypesDev();
21099          var prevDispatcher = ReactSharedInternals.H;
21100          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnMountInDEV;
21101          try {
21102            return mountReducer(reducer, initialArg, init);
21103          } finally {
21104            ReactSharedInternals.H = prevDispatcher;
21105          }
21106        },
21107        useRef: function(initialValue) {
21108          currentHookNameInDev = "useRef";
21109          warnInvalidHookAccess();
21110          mountHookTypesDev();
21111          return mountRef(initialValue);
21112        },
21113        useState: function(initialState) {
21114          currentHookNameInDev = "useState";
21115          warnInvalidHookAccess();
21116          mountHookTypesDev();
21117          var prevDispatcher = ReactSharedInternals.H;
21118          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnMountInDEV;
21119          try {
21120            return mountState(initialState);
21121          } finally {
21122            ReactSharedInternals.H = prevDispatcher;
21123          }
21124        },
21125        useDebugValue: function() {
21126          currentHookNameInDev = "useDebugValue";
21127          warnInvalidHookAccess();
21128          mountHookTypesDev();
21129        },
21130        useDeferredValue: function(value, initialValue) {
21131          currentHookNameInDev = "useDeferredValue";
21132          warnInvalidHookAccess();
21133          mountHookTypesDev();
21134          return mountDeferredValue(value, initialValue);
21135        },
21136        useTransition: function() {
21137          currentHookNameInDev = "useTransition";
21138          warnInvalidHookAccess();
21139          mountHookTypesDev();
21140          return mountTransition();
21141        },
21142        useSyncExternalStore: function(subscribe, getSnapshot, getServerSnapshot) {
21143          currentHookNameInDev = "useSyncExternalStore";
21144          warnInvalidHookAccess();
21145          mountHookTypesDev();
21146          return mountSyncExternalStore(
21147            subscribe,
21148            getSnapshot,
21149            getServerSnapshot
21150          );
21151        },
21152        useId: function() {
21153          currentHookNameInDev = "useId";
21154          warnInvalidHookAccess();
21155          mountHookTypesDev();
21156          return mountId();
21157        },
21158        useFormState: function(action, initialState) {
21159          currentHookNameInDev = "useFormState";
21160          warnInvalidHookAccess();
21161          mountHookTypesDev();
21162          return mountActionState(action, initialState);
21163        },
21164        useActionState: function(action, initialState) {
21165          currentHookNameInDev = "useActionState";
21166          warnInvalidHookAccess();
21167          mountHookTypesDev();
21168          return mountActionState(action, initialState);
21169        },
21170        useOptimistic: function(passthrough) {
21171          currentHookNameInDev = "useOptimistic";
21172          warnInvalidHookAccess();
21173          mountHookTypesDev();
21174          return mountOptimistic(passthrough);
21175        },
21176        useMemoCache: function(size) {
21177          warnInvalidHookAccess();
21178          return useMemoCache(size);
21179        },
21180        useHostTransitionStatus,
21181        useCacheRefresh: function() {
21182          currentHookNameInDev = "useCacheRefresh";
21183          mountHookTypesDev();
21184          return mountRefresh();
21185        },
21186        useEffectEvent: function(callback) {
21187          currentHookNameInDev = "useEffectEvent";
21188          warnInvalidHookAccess();
21189          mountHookTypesDev();
21190          return mountEvent(callback);
21191        }
21192      };
21193      InvalidNestedHooksDispatcherOnUpdateInDEV = {
21194        readContext: function(context) {
21195          warnInvalidContextAccess();
21196          return readContext(context);
21197        },
21198        use: function(usable) {
21199          warnInvalidHookAccess();
21200          return use(usable);
21201        },
21202        useCallback: function(callback, deps) {
21203          currentHookNameInDev = "useCallback";
21204          warnInvalidHookAccess();
21205          updateHookTypesDev();
21206          return updateCallback(callback, deps);
21207        },
21208        useContext: function(context) {
21209          currentHookNameInDev = "useContext";
21210          warnInvalidHookAccess();
21211          updateHookTypesDev();
21212          return readContext(context);
21213        },
21214        useEffect: function(create, deps) {
21215          currentHookNameInDev = "useEffect";
21216          warnInvalidHookAccess();
21217          updateHookTypesDev();
21218          updateEffectImpl(2048, Passive, create, deps);
21219        },
21220        useImperativeHandle: function(ref, create, deps) {
21221          currentHookNameInDev = "useImperativeHandle";
21222          warnInvalidHookAccess();
21223          updateHookTypesDev();
21224          return updateImperativeHandle(ref, create, deps);
21225        },
21226        useInsertionEffect: function(create, deps) {
21227          currentHookNameInDev = "useInsertionEffect";
21228          warnInvalidHookAccess();
21229          updateHookTypesDev();
21230          return updateEffectImpl(4, Insertion, create, deps);
21231        },
21232        useLayoutEffect: function(create, deps) {
21233          currentHookNameInDev = "useLayoutEffect";
21234          warnInvalidHookAccess();
21235          updateHookTypesDev();
21236          return updateEffectImpl(4, Layout, create, deps);
21237        },
21238        useMemo: function(create, deps) {
21239          currentHookNameInDev = "useMemo";
21240          warnInvalidHookAccess();
21241          updateHookTypesDev();
21242          var prevDispatcher = ReactSharedInternals.H;
21243          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
21244          try {
21245            return updateMemo(create, deps);
21246          } finally {
21247            ReactSharedInternals.H = prevDispatcher;
21248          }
21249        },
21250        useReducer: function(reducer, initialArg, init) {
21251          currentHookNameInDev = "useReducer";
21252          warnInvalidHookAccess();
21253          updateHookTypesDev();
21254          var prevDispatcher = ReactSharedInternals.H;
21255          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
21256          try {
21257            return updateReducer(reducer, initialArg, init);
21258          } finally {
21259            ReactSharedInternals.H = prevDispatcher;
21260          }
21261        },
21262        useRef: function() {
21263          currentHookNameInDev = "useRef";
21264          warnInvalidHookAccess();
21265          updateHookTypesDev();
21266          return updateWorkInProgressHook().memoizedState;
21267        },
21268        useState: function() {
21269          currentHookNameInDev = "useState";
21270          warnInvalidHookAccess();
21271          updateHookTypesDev();
21272          var prevDispatcher = ReactSharedInternals.H;
21273          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
21274          try {
21275            return updateReducer(basicStateReducer);
21276          } finally {
21277            ReactSharedInternals.H = prevDispatcher;
21278          }
21279        },
21280        useDebugValue: function() {
21281          currentHookNameInDev = "useDebugValue";
21282          warnInvalidHookAccess();
21283          updateHookTypesDev();
21284        },
21285        useDeferredValue: function(value, initialValue) {
21286          currentHookNameInDev = "useDeferredValue";
21287          warnInvalidHookAccess();
21288          updateHookTypesDev();
21289          return updateDeferredValue(value, initialValue);
21290        },
21291        useTransition: function() {
21292          currentHookNameInDev = "useTransition";
21293          warnInvalidHookAccess();
21294          updateHookTypesDev();
21295          return updateTransition();
21296        },
21297        useSyncExternalStore: function(subscribe, getSnapshot, getServerSnapshot) {
21298          currentHookNameInDev = "useSyncExternalStore";
21299          warnInvalidHookAccess();
21300          updateHookTypesDev();
21301          return updateSyncExternalStore(
21302            subscribe,
21303            getSnapshot,
21304            getServerSnapshot
21305          );
21306        },
21307        useId: function() {
21308          currentHookNameInDev = "useId";
21309          warnInvalidHookAccess();
21310          updateHookTypesDev();
21311          return updateWorkInProgressHook().memoizedState;
21312        },
21313        useFormState: function(action) {
21314          currentHookNameInDev = "useFormState";
21315          warnInvalidHookAccess();
21316          updateHookTypesDev();
21317          return updateActionState(action);
21318        },
21319        useActionState: function(action) {
21320          currentHookNameInDev = "useActionState";
21321          warnInvalidHookAccess();
21322          updateHookTypesDev();
21323          return updateActionState(action);
21324        },
21325        useOptimistic: function(passthrough, reducer) {
21326          currentHookNameInDev = "useOptimistic";
21327          warnInvalidHookAccess();
21328          updateHookTypesDev();
21329          return updateOptimistic(passthrough, reducer);
21330        },
21331        useMemoCache: function(size) {
21332          warnInvalidHookAccess();
21333          return useMemoCache(size);
21334        },
21335        useHostTransitionStatus,
21336        useCacheRefresh: function() {
21337          currentHookNameInDev = "useCacheRefresh";
21338          updateHookTypesDev();
21339          return updateWorkInProgressHook().memoizedState;
21340        },
21341        useEffectEvent: function(callback) {
21342          currentHookNameInDev = "useEffectEvent";
21343          warnInvalidHookAccess();
21344          updateHookTypesDev();
21345          return updateEvent(callback);
21346        }
21347      };
21348      InvalidNestedHooksDispatcherOnRerenderInDEV = {
21349        readContext: function(context) {
21350          warnInvalidContextAccess();
21351          return readContext(context);
21352        },
21353        use: function(usable) {
21354          warnInvalidHookAccess();
21355          return use(usable);
21356        },
21357        useCallback: function(callback, deps) {
21358          currentHookNameInDev = "useCallback";
21359          warnInvalidHookAccess();
21360          updateHookTypesDev();
21361          return updateCallback(callback, deps);
21362        },
21363        useContext: function(context) {
21364          currentHookNameInDev = "useContext";
21365          warnInvalidHookAccess();
21366          updateHookTypesDev();
21367          return readContext(context);
21368        },
21369        useEffect: function(create, deps) {
21370          currentHookNameInDev = "useEffect";
21371          warnInvalidHookAccess();
21372          updateHookTypesDev();
21373          updateEffectImpl(2048, Passive, create, deps);
21374        },
21375        useImperativeHandle: function(ref, create, deps) {
21376          currentHookNameInDev = "useImperativeHandle";
21377          warnInvalidHookAccess();
21378          updateHookTypesDev();
21379          return updateImperativeHandle(ref, create, deps);
21380        },
21381        useInsertionEffect: function(create, deps) {
21382          currentHookNameInDev = "useInsertionEffect";
21383          warnInvalidHookAccess();
21384          updateHookTypesDev();
21385          return updateEffectImpl(4, Insertion, create, deps);
21386        },
21387        useLayoutEffect: function(create, deps) {
21388          currentHookNameInDev = "useLayoutEffect";
21389          warnInvalidHookAccess();
21390          updateHookTypesDev();
21391          return updateEffectImpl(4, Layout, create, deps);
21392        },
21393        useMemo: function(create, deps) {
21394          currentHookNameInDev = "useMemo";
21395          warnInvalidHookAccess();
21396          updateHookTypesDev();
21397          var prevDispatcher = ReactSharedInternals.H;
21398          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
21399          try {
21400            return updateMemo(create, deps);
21401          } finally {
21402            ReactSharedInternals.H = prevDispatcher;
21403          }
21404        },
21405        useReducer: function(reducer, initialArg, init) {
21406          currentHookNameInDev = "useReducer";
21407          warnInvalidHookAccess();
21408          updateHookTypesDev();
21409          var prevDispatcher = ReactSharedInternals.H;
21410          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
21411          try {
21412            return rerenderReducer(reducer, initialArg, init);
21413          } finally {
21414            ReactSharedInternals.H = prevDispatcher;
21415          }
21416        },
21417        useRef: function() {
21418          currentHookNameInDev = "useRef";
21419          warnInvalidHookAccess();
21420          updateHookTypesDev();
21421          return updateWorkInProgressHook().memoizedState;
21422        },
21423        useState: function() {
21424          currentHookNameInDev = "useState";
21425          warnInvalidHookAccess();
21426          updateHookTypesDev();
21427          var prevDispatcher = ReactSharedInternals.H;
21428          ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
21429          try {
21430            return rerenderReducer(basicStateReducer);
21431          } finally {
21432            ReactSharedInternals.H = prevDispatcher;
21433          }
21434        },
21435        useDebugValue: function() {
21436          currentHookNameInDev = "useDebugValue";
21437          warnInvalidHookAccess();
21438          updateHookTypesDev();
21439        },
21440        useDeferredValue: function(value, initialValue) {
21441          currentHookNameInDev = "useDeferredValue";
21442          warnInvalidHookAccess();
21443          updateHookTypesDev();
21444          return rerenderDeferredValue(value, initialValue);
21445        },
21446        useTransition: function() {
21447          currentHookNameInDev = "useTransition";
21448          warnInvalidHookAccess();
21449          updateHookTypesDev();
21450          return rerenderTransition();
21451        },
21452        useSyncExternalStore: function(subscribe, getSnapshot, getServerSnapshot) {
21453          currentHookNameInDev = "useSyncExternalStore";
21454          warnInvalidHookAccess();
21455          updateHookTypesDev();
21456          return updateSyncExternalStore(
21457            subscribe,
21458            getSnapshot,
21459            getServerSnapshot
21460          );
21461        },
21462        useId: function() {
21463          currentHookNameInDev = "useId";
21464          warnInvalidHookAccess();
21465          updateHookTypesDev();
21466          return updateWorkInProgressHook().memoizedState;
21467        },
21468        useFormState: function(action) {
21469          currentHookNameInDev = "useFormState";
21470          warnInvalidHookAccess();
21471          updateHookTypesDev();
21472          return rerenderActionState(action);
21473        },
21474        useActionState: function(action) {
21475          currentHookNameInDev = "useActionState";
21476          warnInvalidHookAccess();
21477          updateHookTypesDev();
21478          return rerenderActionState(action);
21479        },
21480        useOptimistic: function(passthrough, reducer) {
21481          currentHookNameInDev = "useOptimistic";
21482          warnInvalidHookAccess();
21483          updateHookTypesDev();
21484          return rerenderOptimistic(passthrough, reducer);
21485        },
21486        useMemoCache: function(size) {
21487          warnInvalidHookAccess();
21488          return useMemoCache(size);
21489        },
21490        useHostTransitionStatus,
21491        useCacheRefresh: function() {
21492          currentHookNameInDev = "useCacheRefresh";
21493          updateHookTypesDev();
21494          return updateWorkInProgressHook().memoizedState;
21495        },
21496        useEffectEvent: function(callback) {
21497          currentHookNameInDev = "useEffectEvent";
21498          warnInvalidHookAccess();
21499          updateHookTypesDev();
21500          return updateEvent(callback);
21501        }
21502      };
21503      var fakeInternalInstance = {};
21504      var didWarnAboutStateAssignmentForComponent = /* @__PURE__ */ new Set();
21505      var didWarnAboutUninitializedState = /* @__PURE__ */ new Set();
21506      var didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate = /* @__PURE__ */ new Set();
21507      var didWarnAboutLegacyLifecyclesAndDerivedState = /* @__PURE__ */ new Set();
21508      var didWarnAboutDirectlyAssigningPropsToState = /* @__PURE__ */ new Set();
21509      var didWarnAboutUndefinedDerivedState = /* @__PURE__ */ new Set();
21510      var didWarnAboutContextTypes$1 = /* @__PURE__ */ new Set();
21511      var didWarnAboutChildContextTypes = /* @__PURE__ */ new Set();
21512      var didWarnAboutInvalidateContextType = /* @__PURE__ */ new Set();
21513      var didWarnOnInvalidCallback = /* @__PURE__ */ new Set();
21514      Object.freeze(fakeInternalInstance);
21515      var classComponentUpdater = {
21516        enqueueSetState: function(inst, payload, callback) {
21517          inst = inst._reactInternals;
21518          var lane = requestUpdateLane(inst), update = createUpdate(lane);
21519          update.payload = payload;
21520          void 0 !== callback && null !== callback && (warnOnInvalidCallback(callback), update.callback = callback);
21521          payload = enqueueUpdate(inst, update, lane);
21522          null !== payload && (startUpdateTimerByLane(lane, "this.setState()", inst), scheduleUpdateOnFiber(payload, inst, lane), entangleTransitions(payload, inst, lane));
21523        },
21524        enqueueReplaceState: function(inst, payload, callback) {
21525          inst = inst._reactInternals;
21526          var lane = requestUpdateLane(inst), update = createUpdate(lane);
21527          update.tag = ReplaceState;
21528          update.payload = payload;
21529          void 0 !== callback && null !== callback && (warnOnInvalidCallback(callback), update.callback = callback);
21530          payload = enqueueUpdate(inst, update, lane);
21531          null !== payload && (startUpdateTimerByLane(lane, "this.replaceState()", inst), scheduleUpdateOnFiber(payload, inst, lane), entangleTransitions(payload, inst, lane));
21532        },
21533        enqueueForceUpdate: function(inst, callback) {
21534          inst = inst._reactInternals;
21535          var lane = requestUpdateLane(inst), update = createUpdate(lane);
21536          update.tag = ForceUpdate;
21537          void 0 !== callback && null !== callback && (warnOnInvalidCallback(callback), update.callback = callback);
21538          callback = enqueueUpdate(inst, update, lane);
21539          null !== callback && (startUpdateTimerByLane(lane, "this.forceUpdate()", inst), scheduleUpdateOnFiber(callback, inst, lane), entangleTransitions(callback, inst, lane));
21540        }
21541      }, componentName = null, errorBoundaryName = null, SelectiveHydrationException = Error(
21542        "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."
21543      ), didReceiveUpdate = false;
21544      var didWarnAboutBadClass = {};
21545      var didWarnAboutContextTypeOnFunctionComponent = {};
21546      var didWarnAboutContextTypes = {};
21547      var didWarnAboutGetDerivedStateOnFunctionComponent = {};
21548      var didWarnAboutReassigningProps = false;
21549      var didWarnAboutRevealOrder = {};
21550      var didWarnAboutTailOptions = {};
21551      var SUSPENDED_MARKER = {
21552        dehydrated: null,
21553        treeContext: null,
21554        retryLane: 0,
21555        hydrationErrors: null
21556      }, hasWarnedAboutUsingNoValuePropOnContextProvider = false, didWarnAboutUndefinedSnapshotBeforeUpdate = null;
21557      didWarnAboutUndefinedSnapshotBeforeUpdate = /* @__PURE__ */ new Set();
21558      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 = {
21559        getCacheForType: function(resourceType) {
21560          var cache2 = readContext(CacheContext), cacheForType = cache2.data.get(resourceType);
21561          void 0 === cacheForType && (cacheForType = resourceType(), cache2.data.set(resourceType, cacheForType));
21562          return cacheForType;
21563        },
21564        cacheSignal: function() {
21565          return readContext(CacheContext).controller.signal;
21566        },
21567        getOwner: function() {
21568          return current;
21569        }
21570      };
21571      if ("function" === typeof Symbol && Symbol.for) {
21572        var symbolFor = Symbol.for;
21573        symbolFor("selector.component");
21574        symbolFor("selector.has_pseudo_class");
21575        symbolFor("selector.role");
21576        symbolFor("selector.test_id");
21577        symbolFor("selector.text");
21578      }
21579      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;
21580      var didWarnAboutUpdateInRenderForAnotherComponent = /* @__PURE__ */ new Set();
21581      var fakeActCallbackNode$1 = {}, firstScheduledRoot = null, lastScheduledRoot = null, didScheduleMicrotask = false, didScheduleMicrotask_act = false, mightHavePendingSyncWork = false, isFlushingWork = false, currentEventTransitionLane = 0, fakeActCallbackNode = {};
21582      (function() {
21583        for (var i3 = 0; i3 < simpleEventPluginEvents.length; i3++) {
21584          var eventName = simpleEventPluginEvents[i3], domEventName = eventName.toLowerCase();
21585          eventName = eventName[0].toUpperCase() + eventName.slice(1);
21586          registerSimpleEvent(domEventName, "on" + eventName);
21587        }
21588        registerSimpleEvent(ANIMATION_END, "onAnimationEnd");
21589        registerSimpleEvent(ANIMATION_ITERATION, "onAnimationIteration");
21590        registerSimpleEvent(ANIMATION_START, "onAnimationStart");
21591        registerSimpleEvent("dblclick", "onDoubleClick");
21592        registerSimpleEvent("focusin", "onFocus");
21593        registerSimpleEvent("focusout", "onBlur");
21594        registerSimpleEvent(TRANSITION_RUN, "onTransitionRun");
21595        registerSimpleEvent(TRANSITION_START, "onTransitionStart");
21596        registerSimpleEvent(TRANSITION_CANCEL, "onTransitionCancel");
21597        registerSimpleEvent(TRANSITION_END, "onTransitionEnd");
21598      })();
21599      registerDirectEvent("onMouseEnter", ["mouseout", "mouseover"]);
21600      registerDirectEvent("onMouseLeave", ["mouseout", "mouseover"]);
21601      registerDirectEvent("onPointerEnter", ["pointerout", "pointerover"]);
21602      registerDirectEvent("onPointerLeave", ["pointerout", "pointerover"]);
21603      registerTwoPhaseEvent(
21604        "onChange",
21605        "change click focusin focusout input keydown keyup selectionchange".split(
21606          " "
21607        )
21608      );
21609      registerTwoPhaseEvent(
21610        "onSelect",
21611        "focusout contextmenu dragend focusin keydown keyup mousedown mouseup selectionchange".split(
21612          " "
21613        )
21614      );
21615      registerTwoPhaseEvent("onBeforeInput", [
21616        "compositionend",
21617        "keypress",
21618        "textInput",
21619        "paste"
21620      ]);
21621      registerTwoPhaseEvent(
21622        "onCompositionEnd",
21623        "compositionend focusout keydown keypress keyup mousedown".split(" ")
21624      );
21625      registerTwoPhaseEvent(
21626        "onCompositionStart",
21627        "compositionstart focusout keydown keypress keyup mousedown".split(" ")
21628      );
21629      registerTwoPhaseEvent(
21630        "onCompositionUpdate",
21631        "compositionupdate focusout keydown keypress keyup mousedown".split(" ")
21632      );
21633      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(
21634        " "
21635      ), nonDelegatedEvents = new Set(
21636        "beforetoggle cancel close invalid load scroll scrollend toggle".split(" ").concat(mediaEventTypes)
21637      ), listeningMarker = "_reactListening" + Math.random().toString(36).slice(2), didWarnControlledToUncontrolled = false, didWarnUncontrolledToControlled = false, didWarnFormActionType = false, didWarnFormActionName = false, didWarnFormActionTarget = false, didWarnFormActionMethod = false, didWarnPopoverTargetObject = false;
21638      var didWarnForNewBooleanPropsWithEmptyValue = {};
21639      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) {
21640        return localPromise.resolve(null).then(callback).catch(handleErrorInNextTick);
21641      } : scheduleTimeout, previousHydratableOnEnteringScopedSingleton = null, NotLoaded = 0, Loaded = 1, Errored = 2, Settled = 3, Inserted = 4, preloadPropsMap = /* @__PURE__ */ new Map(), preconnectsSet = /* @__PURE__ */ new Set(), previousDispatcher = ReactDOMSharedInternals.d;
21642      ReactDOMSharedInternals.d = {
21643        f: function() {
21644          var previousWasRendering = previousDispatcher.f(), wasRendering = flushSyncWork$1();
21645          return previousWasRendering || wasRendering;
21646        },
21647        r: function(form) {
21648          var formInst = getInstanceFromNode(form);
21649          null !== formInst && 5 === formInst.tag && "form" === formInst.type ? requestFormReset$1(formInst) : previousDispatcher.r(form);
21650        },
21651        D: function(href) {
21652          previousDispatcher.D(href);
21653          preconnectAs("dns-prefetch", href, null);
21654        },
21655        C: function(href, crossOrigin) {
21656          previousDispatcher.C(href, crossOrigin);
21657          preconnectAs("preconnect", href, crossOrigin);
21658        },
21659        L: function(href, as3, options) {
21660          previousDispatcher.L(href, as3, options);
21661          var ownerDocument = globalDocument;
21662          if (ownerDocument && href && as3) {
21663            var preloadSelector = 'link[rel="preload"][as="' + escapeSelectorAttributeValueInsideDoubleQuotes(as3) + '"]';
21664            "image" === as3 ? options && options.imageSrcSet ? (preloadSelector += '[imagesrcset="' + escapeSelectorAttributeValueInsideDoubleQuotes(
21665              options.imageSrcSet
21666            ) + '"]', "string" === typeof options.imageSizes && (preloadSelector += '[imagesizes="' + escapeSelectorAttributeValueInsideDoubleQuotes(
21667              options.imageSizes
21668            ) + '"]')) : preloadSelector += '[href="' + escapeSelectorAttributeValueInsideDoubleQuotes(href) + '"]' : preloadSelector += '[href="' + escapeSelectorAttributeValueInsideDoubleQuotes(href) + '"]';
21669            var key = preloadSelector;
21670            switch (as3) {
21671              case "style":
21672                key = getStyleKey(href);
21673                break;
21674              case "script":
21675                key = getScriptKey(href);
21676            }
21677            preloadPropsMap.has(key) || (href = assign(
21678              {
21679                rel: "preload",
21680                href: "image" === as3 && options && options.imageSrcSet ? void 0 : href,
21681                as: as3
21682              },
21683              options
21684            ), preloadPropsMap.set(key, href), null !== ownerDocument.querySelector(preloadSelector) || "style" === as3 && ownerDocument.querySelector(
21685              getStylesheetSelectorFromKey(key)
21686            ) || "script" === as3 && ownerDocument.querySelector(getScriptSelectorFromKey(key)) || (as3 = ownerDocument.createElement("link"), setInitialProperties(as3, "link", href), markNodeAsHoistable(as3), ownerDocument.head.appendChild(as3)));
21687          }
21688        },
21689        m: function(href, options) {
21690          previousDispatcher.m(href, options);
21691          var ownerDocument = globalDocument;
21692          if (ownerDocument && href) {
21693            var as3 = options && "string" === typeof options.as ? options.as : "script", preloadSelector = 'link[rel="modulepreload"][as="' + escapeSelectorAttributeValueInsideDoubleQuotes(as3) + '"][href="' + escapeSelectorAttributeValueInsideDoubleQuotes(href) + '"]', key = preloadSelector;
21694            switch (as3) {
21695              case "audioworklet":
21696              case "paintworklet":
21697              case "serviceworker":
21698              case "sharedworker":
21699              case "worker":
21700              case "script":
21701                key = getScriptKey(href);
21702            }
21703            if (!preloadPropsMap.has(key) && (href = assign({ rel: "modulepreload", href }, options), preloadPropsMap.set(key, href), null === ownerDocument.querySelector(preloadSelector))) {
21704              switch (as3) {
21705                case "audioworklet":
21706                case "paintworklet":
21707                case "serviceworker":
21708                case "sharedworker":
21709                case "worker":
21710                case "script":
21711                  if (ownerDocument.querySelector(getScriptSelectorFromKey(key)))
21712                    return;
21713              }
21714              as3 = ownerDocument.createElement("link");
21715              setInitialProperties(as3, "link", href);
21716              markNodeAsHoistable(as3);
21717              ownerDocument.head.appendChild(as3);
21718            }
21719          }
21720        },
21721        X: function(src, options) {
21722          previousDispatcher.X(src, options);
21723          var ownerDocument = globalDocument;
21724          if (ownerDocument && src) {
21725            var scripts = getResourcesFromRoot(ownerDocument).hoistableScripts, key = getScriptKey(src), resource = scripts.get(key);
21726            resource || (resource = ownerDocument.querySelector(
21727              getScriptSelectorFromKey(key)
21728            ), 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 = {
21729              type: "script",
21730              instance: resource,
21731              count: 1,
21732              state: null
21733            }, scripts.set(key, resource));
21734          }
21735        },
21736        S: function(href, precedence, options) {
21737          previousDispatcher.S(href, precedence, options);
21738          var ownerDocument = globalDocument;
21739          if (ownerDocument && href) {
21740            var styles = getResourcesFromRoot(ownerDocument).hoistableStyles, key = getStyleKey(href);
21741            precedence = precedence || "default";
21742            var resource = styles.get(key);
21743            if (!resource) {
21744              var state = { loading: NotLoaded, preload: null };
21745              if (resource = ownerDocument.querySelector(
21746                getStylesheetSelectorFromKey(key)
21747              ))
21748                state.loading = Loaded | Inserted;
21749              else {
21750                href = assign(
21751                  {
21752                    rel: "stylesheet",
21753                    href,
21754                    "data-precedence": precedence
21755                  },
21756                  options
21757                );
21758                (options = preloadPropsMap.get(key)) && adoptPreloadPropsForStylesheet(href, options);
21759                var link = resource = ownerDocument.createElement("link");
21760                markNodeAsHoistable(link);
21761                setInitialProperties(link, "link", href);
21762                link._p = new Promise(function(resolve, reject) {
21763                  link.onload = resolve;
21764                  link.onerror = reject;
21765                });
21766                link.addEventListener("load", function() {
21767                  state.loading |= Loaded;
21768                });
21769                link.addEventListener("error", function() {
21770                  state.loading |= Errored;
21771                });
21772                state.loading |= Inserted;
21773                insertStylesheet(resource, precedence, ownerDocument);
21774              }
21775              resource = {
21776                type: "stylesheet",
21777                instance: resource,
21778                count: 1,
21779                state
21780              };
21781              styles.set(key, resource);
21782            }
21783          }
21784        },
21785        M: function(src, options) {
21786          previousDispatcher.M(src, options);
21787          var ownerDocument = globalDocument;
21788          if (ownerDocument && src) {
21789            var scripts = getResourcesFromRoot(ownerDocument).hoistableScripts, key = getScriptKey(src), resource = scripts.get(key);
21790            resource || (resource = ownerDocument.querySelector(
21791              getScriptSelectorFromKey(key)
21792            ), 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 = {
21793              type: "script",
21794              instance: resource,
21795              count: 1,
21796              state: null
21797            }, scripts.set(key, resource));
21798          }
21799        }
21800      };
21801      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 = {
21802        $$typeof: REACT_CONTEXT_TYPE,
21803        Provider: null,
21804        Consumer: null,
21805        _currentValue: NotPendingTransition,
21806        _currentValue2: NotPendingTransition,
21807        _threadCount: 0
21808      }, 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;
21809      var didWarnAboutNestedUpdates = false;
21810      var overrideHookState = null, overrideHookStateDeletePath = null, overrideHookStateRenamePath = null, overrideProps = null, overridePropsDeletePath = null, overridePropsRenamePath = null, scheduleUpdate = null, scheduleRetry = null, setErrorHandler = null, setSuspenseHandler = null;
21811      overrideHookState = function(fiber, id, path, value) {
21812        id = findHook(fiber, id);
21813        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));
21814      };
21815      overrideHookStateDeletePath = function(fiber, id, path) {
21816        id = findHook(fiber, id);
21817        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));
21818      };
21819      overrideHookStateRenamePath = function(fiber, id, oldPath, newPath) {
21820        id = findHook(fiber, id);
21821        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));
21822      };
21823      overrideProps = function(fiber, path, value) {
21824        fiber.pendingProps = copyWithSetImpl(fiber.memoizedProps, path, 0, value);
21825        fiber.alternate && (fiber.alternate.pendingProps = fiber.pendingProps);
21826        path = enqueueConcurrentRenderForLane(fiber, 2);
21827        null !== path && scheduleUpdateOnFiber(path, fiber, 2);
21828      };
21829      overridePropsDeletePath = function(fiber, path) {
21830        fiber.pendingProps = copyWithDeleteImpl(fiber.memoizedProps, path, 0);
21831        fiber.alternate && (fiber.alternate.pendingProps = fiber.pendingProps);
21832        path = enqueueConcurrentRenderForLane(fiber, 2);
21833        null !== path && scheduleUpdateOnFiber(path, fiber, 2);
21834      };
21835      overridePropsRenamePath = function(fiber, oldPath, newPath) {
21836        fiber.pendingProps = copyWithRename(
21837          fiber.memoizedProps,
21838          oldPath,
21839          newPath
21840        );
21841        fiber.alternate && (fiber.alternate.pendingProps = fiber.pendingProps);
21842        oldPath = enqueueConcurrentRenderForLane(fiber, 2);
21843        null !== oldPath && scheduleUpdateOnFiber(oldPath, fiber, 2);
21844      };
21845      scheduleUpdate = function(fiber) {
21846        var root3 = enqueueConcurrentRenderForLane(fiber, 2);
21847        null !== root3 && scheduleUpdateOnFiber(root3, fiber, 2);
21848      };
21849      scheduleRetry = function(fiber) {
21850        var lane = claimNextRetryLane(), root3 = enqueueConcurrentRenderForLane(fiber, lane);
21851        null !== root3 && scheduleUpdateOnFiber(root3, fiber, lane);
21852      };
21853      setErrorHandler = function(newShouldErrorImpl) {
21854        shouldErrorImpl = newShouldErrorImpl;
21855      };
21856      setSuspenseHandler = function(newShouldSuspendImpl) {
21857        shouldSuspendImpl = newShouldSuspendImpl;
21858      };
21859      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(
21860        " "
21861      ), lastScheduledReplayQueue = null;
21862      ReactDOMHydrationRoot.prototype.render = ReactDOMRoot.prototype.render = function(children) {
21863        var root3 = this._internalRoot;
21864        if (null === root3) throw Error("Cannot update an unmounted root.");
21865        var args = arguments;
21866        "function" === typeof args[1] ? console.error(
21867          "does not support the second callback argument. To execute a side effect after rendering, declare it in a component body with useEffect()."
21868        ) : isValidContainer(args[1]) ? console.error(
21869          "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."
21870        ) : "undefined" !== typeof args[1] && console.error(
21871          "You passed a second argument to root.render(...) but it only accepts one argument."
21872        );
21873        args = children;
21874        var current2 = root3.current, lane = requestUpdateLane(current2);
21875        updateContainerImpl(current2, lane, args, root3, null, null);
21876      };
21877      ReactDOMHydrationRoot.prototype.unmount = ReactDOMRoot.prototype.unmount = function() {
21878        var args = arguments;
21879        "function" === typeof args[0] && console.error(
21880          "does not support a callback argument. To execute a side effect after rendering, declare it in a component body with useEffect()."
21881        );
21882        args = this._internalRoot;
21883        if (null !== args) {
21884          this._internalRoot = null;
21885          var container = args.containerInfo;
21886          (executionContext & (RenderContext | CommitContext)) !== NoContext && console.error(
21887            "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."
21888          );
21889          updateContainerImpl(args.current, 2, null, args, null, null);
21890          flushSyncWork$1();
21891          container[internalContainerInstanceKey] = null;
21892        }
21893      };
21894      ReactDOMHydrationRoot.prototype.unstable_scheduleHydration = function(target) {
21895        if (target) {
21896          var updatePriority = resolveUpdatePriority();
21897          target = { blockedOn: null, target, priority: updatePriority };
21898          for (var i3 = 0; i3 < queuedExplicitHydrationTargets.length && 0 !== updatePriority && updatePriority < queuedExplicitHydrationTargets[i3].priority; i3++) ;
21899          queuedExplicitHydrationTargets.splice(i3, 0, target);
21900          0 === i3 && attemptExplicitHydrationTarget(target);
21901        }
21902      };
21903      (function() {
21904        var isomorphicReactPackageVersion = React19.version;
21905        if ("19.2.4" !== isomorphicReactPackageVersion)
21906          throw Error(
21907            '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.4\nLearn more: https://react.dev/warnings/version-mismatch")
21908          );
21909      })();
21910      "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(
21911        "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"
21912      );
21913      ReactDOMSharedInternals.findDOMNode = function(componentOrElement) {
21914        var fiber = componentOrElement._reactInternals;
21915        if (void 0 === fiber) {
21916          if ("function" === typeof componentOrElement.render)
21917            throw Error("Unable to find node on an unmounted component.");
21918          componentOrElement = Object.keys(componentOrElement).join(",");
21919          throw Error(
21920            "Argument appears to not be a ReactComponent. Keys: " + componentOrElement
21921          );
21922        }
21923        componentOrElement = findCurrentFiberUsingSlowPath(fiber);
21924        componentOrElement = null !== componentOrElement ? findCurrentHostFiberImpl(componentOrElement) : null;
21925        componentOrElement = null === componentOrElement ? null : componentOrElement.stateNode;
21926        return componentOrElement;
21927      };
21928      if (!(function() {
21929        var internals = {
21930          bundleType: 1,
21931          version: "19.2.4",
21932          rendererPackageName: "react-dom",
21933          currentDispatcherRef: ReactSharedInternals,
21934          reconcilerVersion: "19.2.4"
21935        };
21936        internals.overrideHookState = overrideHookState;
21937        internals.overrideHookStateDeletePath = overrideHookStateDeletePath;
21938        internals.overrideHookStateRenamePath = overrideHookStateRenamePath;
21939        internals.overrideProps = overrideProps;
21940        internals.overridePropsDeletePath = overridePropsDeletePath;
21941        internals.overridePropsRenamePath = overridePropsRenamePath;
21942        internals.scheduleUpdate = scheduleUpdate;
21943        internals.scheduleRetry = scheduleRetry;
21944        internals.setErrorHandler = setErrorHandler;
21945        internals.setSuspenseHandler = setSuspenseHandler;
21946        internals.scheduleRefresh = scheduleRefresh;
21947        internals.scheduleRoot = scheduleRoot;
21948        internals.setRefreshHandler = setRefreshHandler;
21949        internals.getCurrentFiber = getCurrentFiberForDevTools;
21950        return injectInternals(internals);
21951      })() && canUseDOM && window.top === window.self && (-1 < navigator.userAgent.indexOf("Chrome") && -1 === navigator.userAgent.indexOf("Edge") || -1 < navigator.userAgent.indexOf("Firefox"))) {
21952        var protocol = window.location.protocol;
21953        /^(https?|file):$/.test(protocol) && console.info(
21954          "%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" : ""),
21955          "font-weight:bold"
21956        );
21957      }
21958      exports.createRoot = function(container, options) {
21959        if (!isValidContainer(container))
21960          throw Error("Target container is not a DOM element.");
21961        warnIfReactDOMContainerInDEV(container);
21962        var isStrictMode = false, identifierPrefix = "", onUncaughtError = defaultOnUncaughtError, onCaughtError = defaultOnCaughtError, onRecoverableError = defaultOnRecoverableError;
21963        null !== options && void 0 !== options && (options.hydrate ? console.warn(
21964          "hydrate through createRoot is deprecated. Use ReactDOMClient.hydrateRoot(container, <App />) instead."
21965        ) : "object" === typeof options && null !== options && options.$$typeof === REACT_ELEMENT_TYPE && console.error(
21966          "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 />);"
21967        ), 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));
21968        options = createFiberRoot(
21969          container,
21970          1,
21971          false,
21972          null,
21973          null,
21974          isStrictMode,
21975          identifierPrefix,
21976          null,
21977          onUncaughtError,
21978          onCaughtError,
21979          onRecoverableError,
21980          defaultOnDefaultTransitionIndicator
21981        );
21982        container[internalContainerInstanceKey] = options.current;
21983        listenToAllSupportedEvents(container);
21984        return new ReactDOMRoot(options);
21985      };
21986      exports.hydrateRoot = function(container, initialChildren, options) {
21987        if (!isValidContainer(container))
21988          throw Error("Target container is not a DOM element.");
21989        warnIfReactDOMContainerInDEV(container);
21990        void 0 === initialChildren && console.error(
21991          "Must provide initial children as second argument to hydrateRoot. Example usage: hydrateRoot(domContainer, <App />)"
21992        );
21993        var isStrictMode = false, identifierPrefix = "", onUncaughtError = defaultOnUncaughtError, onCaughtError = defaultOnCaughtError, onRecoverableError = defaultOnRecoverableError, formState = null;
21994        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));
21995        initialChildren = createFiberRoot(
21996          container,
21997          1,
21998          true,
21999          initialChildren,
22000          null != options ? options : null,
22001          isStrictMode,
22002          identifierPrefix,
22003          formState,
22004          onUncaughtError,
22005          onCaughtError,
22006          onRecoverableError,
22007          defaultOnDefaultTransitionIndicator
22008        );
22009        initialChildren.context = getContextForSubtree(null);
22010        options = initialChildren.current;
22011        isStrictMode = requestUpdateLane(options);
22012        isStrictMode = getBumpedLaneForHydrationByLane(isStrictMode);
22013        identifierPrefix = createUpdate(isStrictMode);
22014        identifierPrefix.callback = null;
22015        enqueueUpdate(options, identifierPrefix, isStrictMode);
22016        startUpdateTimerByLane(isStrictMode, "hydrateRoot()", null);
22017        options = isStrictMode;
22018        initialChildren.current.lanes = options;
22019        markRootUpdated$1(initialChildren, options);
22020        ensureRootIsScheduled(initialChildren);
22021        container[internalContainerInstanceKey] = initialChildren.current;
22022        listenToAllSupportedEvents(container);
22023        return new ReactDOMHydrationRoot(initialChildren);
22024      };
22025      exports.version = "19.2.4";
22026      "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
22027    })();
22028  }
22029});
22030