openplanr 2.2640.8 → 2.2641.0

package/lib/host-packages/openai/openplanr/runtime/design/scripts/runtime/packages/design/templates/studio/studio.js.sources/08-react-dom-client-dom-events-properties-hydration.js

@@ -0,0 +1,2183 @@
+
+      function coerceFormActionProp(actionProp) {
+        return null == actionProp || "symbol" === typeof actionProp || "boolean" === typeof actionProp ? null : "function" === typeof actionProp ? actionProp : sanitizeURL("" + actionProp);
+      }
+      function createFormDataWithSubmitter(form, submitter) {
+        var temp = submitter.ownerDocument.createElement("input");
+        temp.name = submitter.name;
+        temp.value = submitter.value;
+        form.id && temp.setAttribute("form", form.id);
+        submitter.parentNode.insertBefore(temp, submitter);
+        form = new FormData(form);
+        temp.parentNode.removeChild(temp);
+        return form;
+      }
+      function extractEvents$1(dispatchQueue, domEventName, maybeTargetInst, nativeEvent, nativeEventTarget) {
+        if ("submit" === domEventName && maybeTargetInst && maybeTargetInst.stateNode === nativeEventTarget) {
+          var action = coerceFormActionProp(
+            (nativeEventTarget[internalPropsKey] || null).action
+          ), submitter = nativeEvent.submitter;
+          submitter && (domEventName = (domEventName = submitter[internalPropsKey] || null) ? coerceFormActionProp(domEventName.formAction) : submitter.getAttribute("formAction"), null !== domEventName && (action = domEventName, submitter = null));
+          var event = new SyntheticEvent(
+            "action",
+            "action",
+            null,
+            nativeEvent,
+            nativeEventTarget
+          );
+          dispatchQueue.push({
+            event,
+            listeners: [
+              {
+                instance: null,
+                listener: function() {
+                  if (nativeEvent.defaultPrevented) {
+                    if (0 !== currentEventTransitionLane) {
+                      var formData = submitter ? createFormDataWithSubmitter(nativeEventTarget, submitter) : new FormData(nativeEventTarget);
+                      startHostTransition(
+                        maybeTargetInst,
+                        {
+                          pending: true,
+                          data: formData,
+                          method: nativeEventTarget.method,
+                          action
+                        },
+                        null,
+                        formData
+                      );
+                    }
+                  } else
+                    "function" === typeof action && (event.preventDefault(), formData = submitter ? createFormDataWithSubmitter(nativeEventTarget, submitter) : new FormData(nativeEventTarget), startHostTransition(
+                      maybeTargetInst,
+                      {
+                        pending: true,
+                        data: formData,
+                        method: nativeEventTarget.method,
+                        action
+                      },
+                      action,
+                      formData
+                    ));
+                },
+                currentTarget: nativeEventTarget
+              }
+            ]
+          });
+        }
+      }
+      for (i$jscomp$inline_1577 = 0; i$jscomp$inline_1577 < simpleEventPluginEvents.length; i$jscomp$inline_1577++) {
+        eventName$jscomp$inline_1578 = simpleEventPluginEvents[i$jscomp$inline_1577], domEventName$jscomp$inline_1579 = eventName$jscomp$inline_1578.toLowerCase(), capitalizedEvent$jscomp$inline_1580 = eventName$jscomp$inline_1578[0].toUpperCase() + eventName$jscomp$inline_1578.slice(1);
+        registerSimpleEvent(
+          domEventName$jscomp$inline_1579,
+          "on" + capitalizedEvent$jscomp$inline_1580
+        );
+      }
+      var eventName$jscomp$inline_1578;
+      var domEventName$jscomp$inline_1579;
+      var capitalizedEvent$jscomp$inline_1580;
+      var i$jscomp$inline_1577;
+      registerSimpleEvent(ANIMATION_END, "onAnimationEnd");
+      registerSimpleEvent(ANIMATION_ITERATION, "onAnimationIteration");
+      registerSimpleEvent(ANIMATION_START, "onAnimationStart");
+      registerSimpleEvent("dblclick", "onDoubleClick");
+      registerSimpleEvent("focusin", "onFocus");
+      registerSimpleEvent("focusout", "onBlur");
+      registerSimpleEvent(TRANSITION_RUN, "onTransitionRun");
+      registerSimpleEvent(TRANSITION_START, "onTransitionStart");
+      registerSimpleEvent(TRANSITION_CANCEL, "onTransitionCancel");
+      registerSimpleEvent(TRANSITION_END, "onTransitionEnd");
+      registerDirectEvent("onMouseEnter", ["mouseout", "mouseover"]);
+      registerDirectEvent("onMouseLeave", ["mouseout", "mouseover"]);
+      registerDirectEvent("onPointerEnter", ["pointerout", "pointerover"]);
+      registerDirectEvent("onPointerLeave", ["pointerout", "pointerover"]);
+      registerTwoPhaseEvent(
+        "onChange",
+        "change click focusin focusout input keydown keyup selectionchange".split(" ")
+      );
+      registerTwoPhaseEvent(
+        "onSelect",
+        "focusout contextmenu dragend focusin keydown keyup mousedown mouseup selectionchange".split(
+          " "
+        )
+      );
+      registerTwoPhaseEvent("onBeforeInput", [
+        "compositionend",
+        "keypress",
+        "textInput",
+        "paste"
+      ]);
+      registerTwoPhaseEvent(
+        "onCompositionEnd",
+        "compositionend focusout keydown keypress keyup mousedown".split(" ")
+      );
+      registerTwoPhaseEvent(
+        "onCompositionStart",
+        "compositionstart focusout keydown keypress keyup mousedown".split(" ")
+      );
+      registerTwoPhaseEvent(
+        "onCompositionUpdate",
+        "compositionupdate focusout keydown keypress keyup mousedown".split(" ")
+      );
+      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(
+        " "
+      );
+      var nonDelegatedEvents = new Set(
+        "beforetoggle cancel close invalid load scroll scrollend toggle".split(" ").concat(mediaEventTypes)
+      );
+      function processDispatchQueue(dispatchQueue, eventSystemFlags) {
+        eventSystemFlags = 0 !== (eventSystemFlags & 4);
+        for (var i = 0; i < dispatchQueue.length; i++) {
+          var _dispatchQueue$i = dispatchQueue[i], event = _dispatchQueue$i.event;
+          _dispatchQueue$i = _dispatchQueue$i.listeners;
+          a: {
+            var previousInstance = void 0;
+            if (eventSystemFlags)
+              for (var i$jscomp$0 = _dispatchQueue$i.length - 1; 0 <= i$jscomp$0; i$jscomp$0--) {
+                var _dispatchListeners$i = _dispatchQueue$i[i$jscomp$0], instance = _dispatchListeners$i.instance, currentTarget = _dispatchListeners$i.currentTarget;
+                _dispatchListeners$i = _dispatchListeners$i.listener;
+                if (instance !== previousInstance && event.isPropagationStopped())
+                  break a;
+                previousInstance = _dispatchListeners$i;
+                event.currentTarget = currentTarget;
+                try {
+                  previousInstance(event);
+                } catch (error) {
+                  reportGlobalError(error);
+                }
+                event.currentTarget = null;
+                previousInstance = instance;
+              }
+            else
+              for (i$jscomp$0 = 0; i$jscomp$0 < _dispatchQueue$i.length; i$jscomp$0++) {
+                _dispatchListeners$i = _dispatchQueue$i[i$jscomp$0];
+                instance = _dispatchListeners$i.instance;
+                currentTarget = _dispatchListeners$i.currentTarget;
+                _dispatchListeners$i = _dispatchListeners$i.listener;
+                if (instance !== previousInstance && event.isPropagationStopped())
+                  break a;
+                previousInstance = _dispatchListeners$i;
+                event.currentTarget = currentTarget;
+                try {
+                  previousInstance(event);
+                } catch (error) {
+                  reportGlobalError(error);
+                }
+                event.currentTarget = null;
+                previousInstance = instance;
+              }
+          }
+        }
+      }
+      function listenToNonDelegatedEvent(domEventName, targetElement) {
+        var JSCompiler_inline_result = targetElement[internalEventHandlersKey];
+        void 0 === JSCompiler_inline_result && (JSCompiler_inline_result = targetElement[internalEventHandlersKey] = /* @__PURE__ */ new Set());
+        var listenerSetKey = domEventName + "__bubble";
+        JSCompiler_inline_result.has(listenerSetKey) || (addTrappedEventListener(targetElement, domEventName, 2, false), JSCompiler_inline_result.add(listenerSetKey));
+      }
+      function listenToNativeEvent(domEventName, isCapturePhaseListener, target) {
+        var eventSystemFlags = 0;
+        isCapturePhaseListener && (eventSystemFlags |= 4);
+        addTrappedEventListener(
+          target,
+          domEventName,
+          eventSystemFlags,
+          isCapturePhaseListener
+        );
+      }
+      var listeningMarker = "_reactListening" + Math.random().toString(36).slice(2);
+      function listenToAllSupportedEvents(rootContainerElement) {
+        if (!rootContainerElement[listeningMarker]) {
+          rootContainerElement[listeningMarker] = true;
+          allNativeEvents.forEach(function(domEventName) {
+            "selectionchange" !== domEventName && (nonDelegatedEvents.has(domEventName) || listenToNativeEvent(domEventName, false, rootContainerElement), listenToNativeEvent(domEventName, true, rootContainerElement));
+          });
+          var ownerDocument = 9 === rootContainerElement.nodeType ? rootContainerElement : rootContainerElement.ownerDocument;
+          null === ownerDocument || ownerDocument[listeningMarker] || (ownerDocument[listeningMarker] = true, listenToNativeEvent("selectionchange", false, ownerDocument));
+        }
+      }
+      function addTrappedEventListener(targetContainer, domEventName, eventSystemFlags, isCapturePhaseListener) {
+        switch (getEventPriority(domEventName)) {
+          case 2:
+            var listenerWrapper = dispatchDiscreteEvent;
+            break;
+          case 8:
+            listenerWrapper = dispatchContinuousEvent;
+            break;
+          default:
+            listenerWrapper = dispatchEvent;
+        }
+        eventSystemFlags = listenerWrapper.bind(
+          null,
+          domEventName,
+          eventSystemFlags,
+          targetContainer
+        );
+        listenerWrapper = void 0;
+        !passiveBrowserEventsSupported || "touchstart" !== domEventName && "touchmove" !== domEventName && "wheel" !== domEventName || (listenerWrapper = true);
+        isCapturePhaseListener ? void 0 !== listenerWrapper ? targetContainer.addEventListener(domEventName, eventSystemFlags, {
+          capture: true,
+          passive: listenerWrapper
+        }) : targetContainer.addEventListener(domEventName, eventSystemFlags, true) : void 0 !== listenerWrapper ? targetContainer.addEventListener(domEventName, eventSystemFlags, {
+          passive: listenerWrapper
+        }) : targetContainer.addEventListener(domEventName, eventSystemFlags, false);
+      }
+      function dispatchEventForPluginEventSystem(domEventName, eventSystemFlags, nativeEvent, targetInst$jscomp$0, targetContainer) {
+        var ancestorInst = targetInst$jscomp$0;
+        if (0 === (eventSystemFlags & 1) && 0 === (eventSystemFlags & 2) && null !== targetInst$jscomp$0)
+          a: for (; ; ) {
+            if (null === targetInst$jscomp$0) return;
+            var nodeTag = targetInst$jscomp$0.tag;
+            if (3 === nodeTag || 4 === nodeTag) {
+              var container = targetInst$jscomp$0.stateNode.containerInfo;
+              if (container === targetContainer) break;
+              if (4 === nodeTag)
+                for (nodeTag = targetInst$jscomp$0.return; null !== nodeTag; ) {
+                  var grandTag = nodeTag.tag;
+                  if ((3 === grandTag || 4 === grandTag) && nodeTag.stateNode.containerInfo === targetContainer)
+                    return;
+                  nodeTag = nodeTag.return;
+                }
+              for (; null !== container; ) {
+                nodeTag = getClosestInstanceFromNode(container);
+                if (null === nodeTag) return;
+                grandTag = nodeTag.tag;
+                if (5 === grandTag || 6 === grandTag || 26 === grandTag || 27 === grandTag) {
+                  targetInst$jscomp$0 = ancestorInst = nodeTag;
+                  continue a;
+                }
+                container = container.parentNode;
+              }
+            }
+            targetInst$jscomp$0 = targetInst$jscomp$0.return;
+          }
+        batchedUpdates$1(function() {
+          var targetInst = ancestorInst, nativeEventTarget = getEventTarget(nativeEvent), dispatchQueue = [];
+          a: {
+            var reactName = topLevelEventsToReactNames.get(domEventName);
+            if (void 0 !== reactName) {
+              var SyntheticEventCtor = SyntheticEvent, reactEventType = domEventName;
+              switch (domEventName) {
+                case "keypress":
+                  if (0 === getEventCharCode(nativeEvent)) break a;
+                case "keydown":
+                case "keyup":
+                  SyntheticEventCtor = SyntheticKeyboardEvent;
+                  break;
+                case "focusin":
+                  reactEventType = "focus";
+                  SyntheticEventCtor = SyntheticFocusEvent;
+                  break;
+                case "focusout":
+                  reactEventType = "blur";
+                  SyntheticEventCtor = SyntheticFocusEvent;
+                  break;
+                case "beforeblur":
+                case "afterblur":
+                  SyntheticEventCtor = SyntheticFocusEvent;
+                  break;
+                case "click":
+                  if (2 === nativeEvent.button) break a;
+                case "auxclick":
+                case "dblclick":
+                case "mousedown":
+                case "mousemove":
+                case "mouseup":
+                case "mouseout":
+                case "mouseover":
+                case "contextmenu":
+                  SyntheticEventCtor = SyntheticMouseEvent;
+                  break;
+                case "drag":
+                case "dragend":
+                case "dragenter":
+                case "dragexit":
+                case "dragleave":
+                case "dragover":
+                case "dragstart":
+                case "drop":
+                  SyntheticEventCtor = SyntheticDragEvent;
+                  break;
+                case "touchcancel":
+                case "touchend":
+                case "touchmove":
+                case "touchstart":
+                  SyntheticEventCtor = SyntheticTouchEvent;
+                  break;
+                case ANIMATION_END:
+                case ANIMATION_ITERATION:
+                case ANIMATION_START:
+                  SyntheticEventCtor = SyntheticAnimationEvent;
+                  break;
+                case TRANSITION_END:
+                  SyntheticEventCtor = SyntheticTransitionEvent;
+                  break;
+                case "scroll":
+                case "scrollend":
+                  SyntheticEventCtor = SyntheticUIEvent;
+                  break;
+                case "wheel":
+                  SyntheticEventCtor = SyntheticWheelEvent;
+                  break;
+                case "copy":
+                case "cut":
+                case "paste":
+                  SyntheticEventCtor = SyntheticClipboardEvent;
+                  break;
+                case "gotpointercapture":
+                case "lostpointercapture":
+                case "pointercancel":
+                case "pointerdown":
+                case "pointermove":
+                case "pointerout":
+                case "pointerover":
+                case "pointerup":
+                  SyntheticEventCtor = SyntheticPointerEvent;
+                  break;
+                case "toggle":
+                case "beforetoggle":
+                  SyntheticEventCtor = SyntheticToggleEvent;
+              }
+              var inCapturePhase = 0 !== (eventSystemFlags & 4), accumulateTargetOnly = !inCapturePhase && ("scroll" === domEventName || "scrollend" === domEventName), reactEventName = inCapturePhase ? null !== reactName ? reactName + "Capture" : null : reactName;
+              inCapturePhase = [];
+              for (var instance = targetInst, lastHostComponent; null !== instance; ) {
+                var _instance = instance;
+                lastHostComponent = _instance.stateNode;
+                _instance = _instance.tag;
+                5 !== _instance && 26 !== _instance && 27 !== _instance || null === lastHostComponent || null === reactEventName || (_instance = getListener(instance, reactEventName), null != _instance && inCapturePhase.push(
+                  createDispatchListener(instance, _instance, lastHostComponent)
+                ));
+                if (accumulateTargetOnly) break;
+                instance = instance.return;
+              }
+              0 < inCapturePhase.length && (reactName = new SyntheticEventCtor(
+                reactName,
+                reactEventType,
+                null,
+                nativeEvent,
+                nativeEventTarget
+              ), dispatchQueue.push({ event: reactName, listeners: inCapturePhase }));
+            }
+          }
+          if (0 === (eventSystemFlags & 7)) {
+            a: {
+              reactName = "mouseover" === domEventName || "pointerover" === domEventName;
+              SyntheticEventCtor = "mouseout" === domEventName || "pointerout" === domEventName;
+              if (reactName && nativeEvent !== currentReplayingEvent && (reactEventType = nativeEvent.relatedTarget || nativeEvent.fromElement) && (getClosestInstanceFromNode(reactEventType) || reactEventType[internalContainerInstanceKey]))
+                break a;
+              if (SyntheticEventCtor || reactName) {
+                reactName = nativeEventTarget.window === nativeEventTarget ? nativeEventTarget : (reactName = nativeEventTarget.ownerDocument) ? reactName.defaultView || reactName.parentWindow : window;
+                if (SyntheticEventCtor) {
+                  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))
+                    reactEventType = null;
+                } else SyntheticEventCtor = null, reactEventType = targetInst;
+                if (SyntheticEventCtor !== reactEventType) {
+                  inCapturePhase = SyntheticMouseEvent;
+                  _instance = "onMouseLeave";
+                  reactEventName = "onMouseEnter";
+                  instance = "mouse";
+                  if ("pointerout" === domEventName || "pointerover" === domEventName)
+                    inCapturePhase = SyntheticPointerEvent, _instance = "onPointerLeave", reactEventName = "onPointerEnter", instance = "pointer";
+                  accumulateTargetOnly = null == SyntheticEventCtor ? reactName : getNodeFromInstance(SyntheticEventCtor);
+                  lastHostComponent = null == reactEventType ? reactName : getNodeFromInstance(reactEventType);
+                  reactName = new inCapturePhase(
+                    _instance,
+                    instance + "leave",
+                    SyntheticEventCtor,
+                    nativeEvent,
+                    nativeEventTarget
+                  );
+                  reactName.target = accumulateTargetOnly;
+                  reactName.relatedTarget = lastHostComponent;
+                  _instance = null;
+                  getClosestInstanceFromNode(nativeEventTarget) === targetInst && (inCapturePhase = new inCapturePhase(
+                    reactEventName,
+                    instance + "enter",
+                    reactEventType,
+                    nativeEvent,
+                    nativeEventTarget
+                  ), inCapturePhase.target = lastHostComponent, inCapturePhase.relatedTarget = accumulateTargetOnly, _instance = inCapturePhase);
+                  accumulateTargetOnly = _instance;
+                  if (SyntheticEventCtor && reactEventType)
+                    b: {
+                      inCapturePhase = getParent;
+                      reactEventName = SyntheticEventCtor;
+                      instance = reactEventType;
+                      lastHostComponent = 0;
+                      for (_instance = reactEventName; _instance; _instance = inCapturePhase(_instance))
+                        lastHostComponent++;
+                      _instance = 0;
+                      for (var tempB = instance; tempB; tempB = inCapturePhase(tempB))
+                        _instance++;
+                      for (; 0 < lastHostComponent - _instance; )
+                        reactEventName = inCapturePhase(reactEventName), lastHostComponent--;
+                      for (; 0 < _instance - lastHostComponent; )
+                        instance = inCapturePhase(instance), _instance--;
+                      for (; lastHostComponent--; ) {
+                        if (reactEventName === instance || null !== instance && reactEventName === instance.alternate) {
+                          inCapturePhase = reactEventName;
+                          break b;
+                        }
+                        reactEventName = inCapturePhase(reactEventName);
+                        instance = inCapturePhase(instance);
+                      }
+                      inCapturePhase = null;
+                    }
+                  else inCapturePhase = null;
+                  null !== SyntheticEventCtor && accumulateEnterLeaveListenersForEvent(
+                    dispatchQueue,
+                    reactName,
+                    SyntheticEventCtor,
+                    inCapturePhase,
+                    false
+                  );
+                  null !== reactEventType && null !== accumulateTargetOnly && accumulateEnterLeaveListenersForEvent(
+                    dispatchQueue,
+                    accumulateTargetOnly,
+                    reactEventType,
+                    inCapturePhase,
+                    true
+                  );
+                }
+              }
+            }
+            a: {
+              reactName = targetInst ? getNodeFromInstance(targetInst) : window;
+              SyntheticEventCtor = reactName.nodeName && reactName.nodeName.toLowerCase();
+              if ("select" === SyntheticEventCtor || "input" === SyntheticEventCtor && "file" === reactName.type)
+                var getTargetInstFunc = getTargetInstForChangeEvent;
+              else if (isTextInputElement(reactName))
+                if (isInputEventSupported)
+                  getTargetInstFunc = getTargetInstForInputOrChangeEvent;
+                else {
+                  getTargetInstFunc = getTargetInstForInputEventPolyfill;
+                  var handleEventFunc = handleEventsForInputEventPolyfill;
+                }
+              else
+                SyntheticEventCtor = reactName.nodeName, !SyntheticEventCtor || "input" !== SyntheticEventCtor.toLowerCase() || "checkbox" !== reactName.type && "radio" !== reactName.type ? targetInst && isCustomElement(targetInst.elementType) && (getTargetInstFunc = getTargetInstForChangeEvent) : getTargetInstFunc = getTargetInstForClickEvent;
+              if (getTargetInstFunc && (getTargetInstFunc = getTargetInstFunc(domEventName, targetInst))) {
+                createAndAccumulateChangeEvent(
+                  dispatchQueue,
+                  getTargetInstFunc,
+                  nativeEvent,
+                  nativeEventTarget
+                );
+                break a;
+              }
+              handleEventFunc && handleEventFunc(domEventName, reactName, targetInst);
+              "focusout" === domEventName && targetInst && "number" === reactName.type && null != targetInst.memoizedProps.value && setDefaultValue(reactName, "number", reactName.value);
+            }
+            handleEventFunc = targetInst ? getNodeFromInstance(targetInst) : window;
+            switch (domEventName) {
+              case "focusin":
+                if (isTextInputElement(handleEventFunc) || "true" === handleEventFunc.contentEditable)
+                  activeElement = handleEventFunc, activeElementInst = targetInst, lastSelection = null;
+                break;
+              case "focusout":
+                lastSelection = activeElementInst = activeElement = null;
+                break;
+              case "mousedown":
+                mouseDown = true;
+                break;
+              case "contextmenu":
+              case "mouseup":
+              case "dragend":
+                mouseDown = false;
+                constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
+                break;
+              case "selectionchange":
+                if (skipSelectionChangeEvent) break;
+              case "keydown":
+              case "keyup":
+                constructSelectEvent(dispatchQueue, nativeEvent, nativeEventTarget);
+            }
+            var fallbackData;
+            if (canUseCompositionEvent)
+              b: {
+                switch (domEventName) {
+                  case "compositionstart":
+                    var eventType = "onCompositionStart";
+                    break b;
+                  case "compositionend":
+                    eventType = "onCompositionEnd";
+                    break b;
+                  case "compositionupdate":
+                    eventType = "onCompositionUpdate";
+                    break b;
+                }
+                eventType = void 0;
+              }
+            else
+              isComposing ? isFallbackCompositionEnd(domEventName, nativeEvent) && (eventType = "onCompositionEnd") : "keydown" === domEventName && 229 === nativeEvent.keyCode && (eventType = "onCompositionStart");
+            eventType && (useFallbackCompositionData && "ko" !== nativeEvent.locale && (isComposing || "onCompositionStart" !== eventType ? "onCompositionEnd" === eventType && isComposing && (fallbackData = getData()) : (root = nativeEventTarget, startText = "value" in root ? root.value : root.textContent, isComposing = true)), handleEventFunc = accumulateTwoPhaseListeners(targetInst, eventType), 0 < handleEventFunc.length && (eventType = new SyntheticCompositionEvent(
+              eventType,
+              domEventName,
+              null,
+              nativeEvent,
+              nativeEventTarget
+            ), dispatchQueue.push({ event: eventType, listeners: handleEventFunc }), fallbackData ? eventType.data = fallbackData : (fallbackData = getDataFromCustomEvent(nativeEvent), null !== fallbackData && (eventType.data = fallbackData))));
+            if (fallbackData = canUseTextInputEvent ? getNativeBeforeInputChars(domEventName, nativeEvent) : getFallbackBeforeInputChars(domEventName, nativeEvent))
+              eventType = accumulateTwoPhaseListeners(targetInst, "onBeforeInput"), 0 < eventType.length && (handleEventFunc = new SyntheticCompositionEvent(
+                "onBeforeInput",
+                "beforeinput",
+                null,
+                nativeEvent,
+                nativeEventTarget
+              ), dispatchQueue.push({
+                event: handleEventFunc,
+                listeners: eventType
+              }), handleEventFunc.data = fallbackData);
+            extractEvents$1(
+              dispatchQueue,
+              domEventName,
+              targetInst,
+              nativeEvent,
+              nativeEventTarget
+            );
+          }
+          processDispatchQueue(dispatchQueue, eventSystemFlags);
+        });
+      }
+      function createDispatchListener(instance, listener, currentTarget) {
+        return {
+          instance,
+          listener,
+          currentTarget
+        };
+      }
+      function accumulateTwoPhaseListeners(targetFiber, reactName) {
+        for (var captureName = reactName + "Capture", listeners = []; null !== targetFiber; ) {
+          var _instance2 = targetFiber, stateNode = _instance2.stateNode;
+          _instance2 = _instance2.tag;
+          5 !== _instance2 && 26 !== _instance2 && 27 !== _instance2 || null === stateNode || (_instance2 = getListener(targetFiber, captureName), null != _instance2 && listeners.unshift(
+            createDispatchListener(targetFiber, _instance2, stateNode)
+          ), _instance2 = getListener(targetFiber, reactName), null != _instance2 && listeners.push(
+            createDispatchListener(targetFiber, _instance2, stateNode)
+          ));
+          if (3 === targetFiber.tag) return listeners;
+          targetFiber = targetFiber.return;
+        }
+        return [];
+      }
+      function getParent(inst) {
+        if (null === inst) return null;
+        do
+          inst = inst.return;
+        while (inst && 5 !== inst.tag && 27 !== inst.tag);
+        return inst ? inst : null;
+      }
+      function accumulateEnterLeaveListenersForEvent(dispatchQueue, event, target, common, inCapturePhase) {
+        for (var registrationName = event._reactName, listeners = []; null !== target && target !== common; ) {
+          var _instance3 = target, alternate = _instance3.alternate, stateNode = _instance3.stateNode;
+          _instance3 = _instance3.tag;
+          if (null !== alternate && alternate === common) break;
+          5 !== _instance3 && 26 !== _instance3 && 27 !== _instance3 || null === stateNode || (alternate = stateNode, inCapturePhase ? (stateNode = getListener(target, registrationName), null != stateNode && listeners.unshift(
+            createDispatchListener(target, stateNode, alternate)
+          )) : inCapturePhase || (stateNode = getListener(target, registrationName), null != stateNode && listeners.push(
+            createDispatchListener(target, stateNode, alternate)
+          )));
+          target = target.return;
+        }
+        0 !== listeners.length && dispatchQueue.push({ event, listeners });
+      }
+      var NORMALIZE_NEWLINES_REGEX = /\r\n?/g;
+      var NORMALIZE_NULL_AND_REPLACEMENT_REGEX = /\u0000|\uFFFD/g;
+      function normalizeMarkupForTextOrAttribute(markup) {
+        return ("string" === typeof markup ? markup : "" + markup).replace(NORMALIZE_NEWLINES_REGEX, "\n").replace(NORMALIZE_NULL_AND_REPLACEMENT_REGEX, "");
+      }
+      function checkForUnmatchedText(serverText, clientText) {
+        clientText = normalizeMarkupForTextOrAttribute(clientText);
+        return normalizeMarkupForTextOrAttribute(serverText) === clientText ? true : false;
+      }
+      function setProp(domElement, tag, key, value, props, prevValue) {
+        switch (key) {
+          case "children":
+            "string" === typeof value ? "body" === tag || "textarea" === tag && "" === value || setTextContent(domElement, value) : ("number" === typeof value || "bigint" === typeof value) && "body" !== tag && setTextContent(domElement, "" + value);
+            break;
+          case "className":
+            setValueForKnownAttribute(domElement, "class", value);
+            break;
+          case "tabIndex":
+            setValueForKnownAttribute(domElement, "tabindex", value);
+            break;
+          case "dir":
+          case "role":
+          case "viewBox":
+          case "width":
+          case "height":
+            setValueForKnownAttribute(domElement, key, value);
+            break;
+          case "style":
+            setValueForStyles(domElement, value, prevValue);
+            break;
+          case "data":
+            if ("object" !== tag) {
+              setValueForKnownAttribute(domElement, "data", value);
+              break;
+            }
+          case "src":
+          case "href":
+            if ("" === value && ("a" !== tag || "href" !== key)) {
+              domElement.removeAttribute(key);
+              break;
+            }
+            if (null == value || "function" === typeof value || "symbol" === typeof value || "boolean" === typeof value) {
+              domElement.removeAttribute(key);
+              break;
+            }
+            value = sanitizeURL("" + value);
+            domElement.setAttribute(key, value);
+            break;
+          case "action":
+          case "formAction":
+            if ("function" === typeof value) {
+              domElement.setAttribute(
+                key,
+                "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().')"
+              );
+              break;
+            } else
+              "function" === typeof prevValue && ("formAction" === key ? ("input" !== tag && setProp(domElement, tag, "name", props.name, props, null), setProp(
+                domElement,
+                tag,
+                "formEncType",
+                props.formEncType,
+                props,
+                null
+              ), setProp(
+                domElement,
+                tag,
+                "formMethod",
+                props.formMethod,
+                props,
+                null
+              ), setProp(
+                domElement,
+                tag,
+                "formTarget",
+                props.formTarget,
+                props,
+                null
+              )) : (setProp(domElement, tag, "encType", props.encType, props, null), setProp(domElement, tag, "method", props.method, props, null), setProp(domElement, tag, "target", props.target, props, null)));
+            if (null == value || "symbol" === typeof value || "boolean" === typeof value) {
+              domElement.removeAttribute(key);
+              break;
+            }
+            value = sanitizeURL("" + value);
+            domElement.setAttribute(key, value);
+            break;
+          case "onClick":
+            null != value && (domElement.onclick = noop$1);
+            break;
+          case "onScroll":
+            null != value && listenToNonDelegatedEvent("scroll", domElement);
+            break;
+          case "onScrollEnd":
+            null != value && listenToNonDelegatedEvent("scrollend", domElement);
+            break;
+          case "dangerouslySetInnerHTML":
+            if (null != value) {
+              if ("object" !== typeof value || !("__html" in value))
+                throw Error(formatProdErrorMessage(61));
+              key = value.__html;
+              if (null != key) {
+                if (null != props.children) throw Error(formatProdErrorMessage(60));
+                domElement.innerHTML = key;
+              }
+            }
+            break;
+          case "multiple":
+            domElement.multiple = value && "function" !== typeof value && "symbol" !== typeof value;
+            break;
+          case "muted":
+            domElement.muted = value && "function" !== typeof value && "symbol" !== typeof value;
+            break;
+          case "suppressContentEditableWarning":
+          case "suppressHydrationWarning":
+          case "defaultValue":
+          case "defaultChecked":
+          case "innerHTML":
+          case "ref":
+            break;
+          case "autoFocus":
+            break;
+          case "xlinkHref":
+            if (null == value || "function" === typeof value || "boolean" === typeof value || "symbol" === typeof value) {
+              domElement.removeAttribute("xlink:href");
+              break;
+            }
+            key = sanitizeURL("" + value);
+            domElement.setAttributeNS(
+              "http://www.w3.org/1999/xlink",
+              "xlink:href",
+              key
+            );
+            break;
+          case "contentEditable":
+          case "spellCheck":
+          case "draggable":
+          case "value":
+          case "autoReverse":
+          case "externalResourcesRequired":
+          case "focusable":
+          case "preserveAlpha":
+            null != value && "function" !== typeof value && "symbol" !== typeof value ? domElement.setAttribute(key, "" + value) : domElement.removeAttribute(key);
+            break;
+          case "inert":
+          case "allowFullScreen":
+          case "async":
+          case "autoPlay":
+          case "controls":
+          case "default":
+          case "defer":
+          case "disabled":
+          case "disablePictureInPicture":
+          case "disableRemotePlayback":
+          case "formNoValidate":
+          case "hidden":
+          case "loop":
+          case "noModule":
+          case "noValidate":
+          case "open":
+          case "playsInline":
+          case "readOnly":
+          case "required":
+          case "reversed":
+          case "scoped":
+          case "seamless":
+          case "itemScope":
+            value && "function" !== typeof value && "symbol" !== typeof value ? domElement.setAttribute(key, "") : domElement.removeAttribute(key);
+            break;
+          case "capture":
+          case "download":
+            true === value ? domElement.setAttribute(key, "") : false !== value && null != value && "function" !== typeof value && "symbol" !== typeof value ? domElement.setAttribute(key, value) : domElement.removeAttribute(key);
+            break;
+          case "cols":
+          case "rows":
+          case "size":
+          case "span":
+            null != value && "function" !== typeof value && "symbol" !== typeof value && !isNaN(value) && 1 <= value ? domElement.setAttribute(key, value) : domElement.removeAttribute(key);
+            break;
+          case "rowSpan":
+          case "start":
+            null == value || "function" === typeof value || "symbol" === typeof value || isNaN(value) ? domElement.removeAttribute(key) : domElement.setAttribute(key, value);
+            break;
+          case "popover":
+            listenToNonDelegatedEvent("beforetoggle", domElement);
+            listenToNonDelegatedEvent("toggle", domElement);
+            setValueForAttribute(domElement, "popover", value);
+            break;
+          case "xlinkActuate":
+            setValueForNamespacedAttribute(
+              domElement,
+              "http://www.w3.org/1999/xlink",
+              "xlink:actuate",
+              value
+            );
+            break;
+          case "xlinkArcrole":
+            setValueForNamespacedAttribute(
+              domElement,
+              "http://www.w3.org/1999/xlink",
+              "xlink:arcrole",
+              value
+            );
+            break;
+          case "xlinkRole":
+            setValueForNamespacedAttribute(
+              domElement,
+              "http://www.w3.org/1999/xlink",
+              "xlink:role",
+              value
+            );
+            break;
+          case "xlinkShow":
+            setValueForNamespacedAttribute(
+              domElement,
+              "http://www.w3.org/1999/xlink",
+              "xlink:show",
+              value
+            );
+            break;
+          case "xlinkTitle":
+            setValueForNamespacedAttribute(
+              domElement,
+              "http://www.w3.org/1999/xlink",
+              "xlink:title",
+              value
+            );
+            break;
+          case "xlinkType":
+            setValueForNamespacedAttribute(
+              domElement,
+              "http://www.w3.org/1999/xlink",
+              "xlink:type",
+              value
+            );
+            break;
+          case "xmlBase":
+            setValueForNamespacedAttribute(
+              domElement,
+              "http://www.w3.org/XML/1998/namespace",
+              "xml:base",
+              value
+            );
+            break;
+          case "xmlLang":
+            setValueForNamespacedAttribute(
+              domElement,
+              "http://www.w3.org/XML/1998/namespace",
+              "xml:lang",
+              value
+            );
+            break;
+          case "xmlSpace":
+            setValueForNamespacedAttribute(
+              domElement,
+              "http://www.w3.org/XML/1998/namespace",
+              "xml:space",
+              value
+            );
+            break;
+          case "is":
+            setValueForAttribute(domElement, "is", value);
+            break;
+          case "innerText":
+          case "textContent":
+            break;
+          default:
+            if (!(2 < key.length) || "o" !== key[0] && "O" !== key[0] || "n" !== key[1] && "N" !== key[1])
+              key = aliases.get(key) || key, setValueForAttribute(domElement, key, value);
+        }
+      }
+      function setPropOnCustomElement(domElement, tag, key, value, props, prevValue) {
+        switch (key) {
+          case "style":
+            setValueForStyles(domElement, value, prevValue);
+            break;
+          case "dangerouslySetInnerHTML":
+            if (null != value) {
+              if ("object" !== typeof value || !("__html" in value))
+                throw Error(formatProdErrorMessage(61));
+              key = value.__html;
+              if (null != key) {
+                if (null != props.children) throw Error(formatProdErrorMessage(60));
+                domElement.innerHTML = key;
+              }
+            }
+            break;
+          case "children":
+            "string" === typeof value ? setTextContent(domElement, value) : ("number" === typeof value || "bigint" === typeof value) && setTextContent(domElement, "" + value);
+            break;
+          case "onScroll":
+            null != value && listenToNonDelegatedEvent("scroll", domElement);
+            break;
+          case "onScrollEnd":
+            null != value && listenToNonDelegatedEvent("scrollend", domElement);
+            break;
+          case "onClick":
+            null != value && (domElement.onclick = noop$1);
+            break;
+          case "suppressContentEditableWarning":
+          case "suppressHydrationWarning":
+          case "innerHTML":
+          case "ref":
+            break;
+          case "innerText":
+          case "textContent":
+            break;
+          default:
+            if (!registrationNameDependencies.hasOwnProperty(key))
+              a: {
+                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)) {
+                  "function" !== typeof prevValue && null !== prevValue && (key in domElement ? domElement[key] = null : domElement.hasAttribute(key) && domElement.removeAttribute(key));
+                  domElement.addEventListener(tag, value, props);
+                  break a;
+                }
+                key in domElement ? domElement[key] = value : true === value ? domElement.setAttribute(key, "") : setValueForAttribute(domElement, key, value);
+              }
+        }
+      }
+      function setInitialProperties(domElement, tag, props) {
+        switch (tag) {
+          case "div":
+          case "span":
+          case "svg":
+          case "path":
+          case "a":
+          case "g":
+          case "p":
+          case "li":
+            break;
+          case "img":
+            listenToNonDelegatedEvent("error", domElement);
+            listenToNonDelegatedEvent("load", domElement);
+            var hasSrc = false, hasSrcSet = false, propKey;
+            for (propKey in props)
+              if (props.hasOwnProperty(propKey)) {
+                var propValue = props[propKey];
+                if (null != propValue)
+                  switch (propKey) {
+                    case "src":
+                      hasSrc = true;
+                      break;
+                    case "srcSet":
+                      hasSrcSet = true;
+                      break;
+                    case "children":
+                    case "dangerouslySetInnerHTML":
+                      throw Error(formatProdErrorMessage(137, tag));
+                    default:
+                      setProp(domElement, tag, propKey, propValue, props, null);
+                  }
+              }
+            hasSrcSet && setProp(domElement, tag, "srcSet", props.srcSet, props, null);
+            hasSrc && setProp(domElement, tag, "src", props.src, props, null);
+            return;
+          case "input":
+            listenToNonDelegatedEvent("invalid", domElement);
+            var defaultValue = propKey = propValue = hasSrcSet = null, checked = null, defaultChecked = null;
+            for (hasSrc in props)
+              if (props.hasOwnProperty(hasSrc)) {
+                var propValue$184 = props[hasSrc];
+                if (null != propValue$184)
+                  switch (hasSrc) {
+                    case "name":
+                      hasSrcSet = propValue$184;
+                      break;
+                    case "type":
+                      propValue = propValue$184;
+                      break;
+                    case "checked":
+                      checked = propValue$184;
+                      break;
+                    case "defaultChecked":
+                      defaultChecked = propValue$184;
+                      break;
+                    case "value":
+                      propKey = propValue$184;
+                      break;
+                    case "defaultValue":
+                      defaultValue = propValue$184;
+                      break;
+                    case "children":
+                    case "dangerouslySetInnerHTML":
+                      if (null != propValue$184)
+                        throw Error(formatProdErrorMessage(137, tag));
+                      break;
+                    default:
+                      setProp(domElement, tag, hasSrc, propValue$184, props, null);
+                  }
+              }
+            initInput(
+              domElement,
+              propKey,
+              defaultValue,
+              checked,
+              defaultChecked,
+              propValue,
+              hasSrcSet,
+              false
+            );
+            return;
+          case "select":
+            listenToNonDelegatedEvent("invalid", domElement);
+            hasSrc = propValue = propKey = null;
+            for (hasSrcSet in props)
+              if (props.hasOwnProperty(hasSrcSet) && (defaultValue = props[hasSrcSet], null != defaultValue))
+                switch (hasSrcSet) {
+                  case "value":
+                    propKey = defaultValue;
+                    break;
+                  case "defaultValue":
+                    propValue = defaultValue;
+                    break;
+                  case "multiple":
+                    hasSrc = defaultValue;
+                  default:
+                    setProp(domElement, tag, hasSrcSet, defaultValue, props, null);
+                }
+            tag = propKey;
+            props = propValue;
+            domElement.multiple = !!hasSrc;
+            null != tag ? updateOptions(domElement, !!hasSrc, tag, false) : null != props && updateOptions(domElement, !!hasSrc, props, true);
+            return;
+          case "textarea":
+            listenToNonDelegatedEvent("invalid", domElement);
+            propKey = hasSrcSet = hasSrc = null;
+            for (propValue in props)
+              if (props.hasOwnProperty(propValue) && (defaultValue = props[propValue], null != defaultValue))
+                switch (propValue) {
+                  case "value":
+                    hasSrc = defaultValue;
+                    break;
+                  case "defaultValue":
+                    hasSrcSet = defaultValue;
+                    break;
+                  case "children":
+                    propKey = defaultValue;
+                    break;
+                  case "dangerouslySetInnerHTML":
+                    if (null != defaultValue) throw Error(formatProdErrorMessage(91));
+                    break;
+                  default:
+                    setProp(domElement, tag, propValue, defaultValue, props, null);
+                }
+            initTextarea(domElement, hasSrc, hasSrcSet, propKey);
+            return;
+          case "option":
+            for (checked in props)
+              if (props.hasOwnProperty(checked) && (hasSrc = props[checked], null != hasSrc))
+                switch (checked) {
+                  case "selected":
+                    domElement.selected = hasSrc && "function" !== typeof hasSrc && "symbol" !== typeof hasSrc;
+                    break;
+                  default:
+                    setProp(domElement, tag, checked, hasSrc, props, null);
+                }
+            return;
+          case "dialog":
+            listenToNonDelegatedEvent("beforetoggle", domElement);
+            listenToNonDelegatedEvent("toggle", domElement);
+            listenToNonDelegatedEvent("cancel", domElement);
+            listenToNonDelegatedEvent("close", domElement);
+            break;
+          case "iframe":
+          case "object":
+            listenToNonDelegatedEvent("load", domElement);
+            break;
+          case "video":
+          case "audio":
+            for (hasSrc = 0; hasSrc < mediaEventTypes.length; hasSrc++)
+              listenToNonDelegatedEvent(mediaEventTypes[hasSrc], domElement);
+            break;
+          case "image":
+            listenToNonDelegatedEvent("error", domElement);
+            listenToNonDelegatedEvent("load", domElement);
+            break;
+          case "details":
+            listenToNonDelegatedEvent("toggle", domElement);
+            break;
+          case "embed":
+          case "source":
+          case "link":
+            listenToNonDelegatedEvent("error", domElement), listenToNonDelegatedEvent("load", domElement);
+          case "area":
+          case "base":
+          case "br":
+          case "col":
+          case "hr":
+          case "keygen":
+          case "meta":
+          case "param":
+          case "track":
+          case "wbr":
+          case "menuitem":
+            for (defaultChecked in props)
+              if (props.hasOwnProperty(defaultChecked) && (hasSrc = props[defaultChecked], null != hasSrc))
+                switch (defaultChecked) {
+                  case "children":
+                  case "dangerouslySetInnerHTML":
+                    throw Error(formatProdErrorMessage(137, tag));
+                  default:
+                    setProp(domElement, tag, defaultChecked, hasSrc, props, null);
+                }
+            return;
+          default:
+            if (isCustomElement(tag)) {
+              for (propValue$184 in props)
+                props.hasOwnProperty(propValue$184) && (hasSrc = props[propValue$184], void 0 !== hasSrc && setPropOnCustomElement(
+                  domElement,
+                  tag,
+                  propValue$184,
+                  hasSrc,
+                  props,
+                  void 0
+                ));
+              return;
+            }
+        }
+        for (defaultValue in props)
+          props.hasOwnProperty(defaultValue) && (hasSrc = props[defaultValue], null != hasSrc && setProp(domElement, tag, defaultValue, hasSrc, props, null));
+      }
+      function updateProperties(domElement, tag, lastProps, nextProps) {
+        switch (tag) {
+          case "div":
+          case "span":
+          case "svg":
+          case "path":
+          case "a":
+          case "g":
+          case "p":
+          case "li":
+            break;
+          case "input":
+            var name = null, type = null, value = null, defaultValue = null, lastDefaultValue = null, checked = null, defaultChecked = null;
+            for (propKey in lastProps) {
+              var lastProp = lastProps[propKey];
+              if (lastProps.hasOwnProperty(propKey) && null != lastProp)
+                switch (propKey) {
+                  case "checked":
+                    break;
+                  case "value":
+                    break;
+                  case "defaultValue":
+                    lastDefaultValue = lastProp;
+                  default:
+                    nextProps.hasOwnProperty(propKey) || setProp(domElement, tag, propKey, null, nextProps, lastProp);
+                }
+            }
+            for (var propKey$201 in nextProps) {
+              var propKey = nextProps[propKey$201];
+              lastProp = lastProps[propKey$201];
+              if (nextProps.hasOwnProperty(propKey$201) && (null != propKey || null != lastProp))
+                switch (propKey$201) {
+                  case "type":
+                    type = propKey;
+                    break;
+                  case "name":
+                    name = propKey;
+                    break;
+                  case "checked":
+                    checked = propKey;
+                    break;
+                  case "defaultChecked":
+                    defaultChecked = propKey;
+                    break;
+                  case "value":
+                    value = propKey;
+                    break;
+                  case "defaultValue":
+                    defaultValue = propKey;
+                    break;
+                  case "children":
+                  case "dangerouslySetInnerHTML":
+                    if (null != propKey)
+                      throw Error(formatProdErrorMessage(137, tag));
+                    break;
+                  default:
+                    propKey !== lastProp && setProp(
+                      domElement,
+                      tag,
+                      propKey$201,
+                      propKey,
+                      nextProps,
+                      lastProp
+                    );
+                }
+            }
+            updateInput(
+              domElement,
+              value,
+              defaultValue,
+              lastDefaultValue,
+              checked,
+              defaultChecked,
+              type,
+              name
+            );
+            return;
+          case "select":
+            propKey = value = defaultValue = propKey$201 = null;
+            for (type in lastProps)
+              if (lastDefaultValue = lastProps[type], lastProps.hasOwnProperty(type) && null != lastDefaultValue)
+                switch (type) {
+                  case "value":
+                    break;
+                  case "multiple":
+                    propKey = lastDefaultValue;
+                  default:
+                    nextProps.hasOwnProperty(type) || setProp(
+                      domElement,
+                      tag,
+                      type,
+                      null,
+                      nextProps,
+                      lastDefaultValue
+                    );
+                }
+            for (name in nextProps)
+              if (type = nextProps[name], lastDefaultValue = lastProps[name], nextProps.hasOwnProperty(name) && (null != type || null != lastDefaultValue))
+                switch (name) {
+                  case "value":
+                    propKey$201 = type;
+                    break;
+                  case "defaultValue":
+                    defaultValue = type;
+                    break;
+                  case "multiple":
+                    value = type;
+                  default:
+                    type !== lastDefaultValue && setProp(
+                      domElement,
+                      tag,
+                      name,
+                      type,
+                      nextProps,
+                      lastDefaultValue
+                    );
+                }
+            tag = defaultValue;
+            lastProps = value;
+            nextProps = propKey;
+            null != propKey$201 ? updateOptions(domElement, !!lastProps, propKey$201, false) : !!nextProps !== !!lastProps && (null != tag ? updateOptions(domElement, !!lastProps, tag, true) : updateOptions(domElement, !!lastProps, lastProps ? [] : "", false));
+            return;
+          case "textarea":
+            propKey = propKey$201 = null;
+            for (defaultValue in lastProps)
+              if (name = lastProps[defaultValue], lastProps.hasOwnProperty(defaultValue) && null != name && !nextProps.hasOwnProperty(defaultValue))
+                switch (defaultValue) {
+                  case "value":
+                    break;
+                  case "children":
+                    break;
+                  default:
+                    setProp(domElement, tag, defaultValue, null, nextProps, name);
+                }
+            for (value in nextProps)
+              if (name = nextProps[value], type = lastProps[value], nextProps.hasOwnProperty(value) && (null != name || null != type))
+                switch (value) {
+                  case "value":
+                    propKey$201 = name;
+                    break;
+                  case "defaultValue":
+                    propKey = name;
+                    break;
+                  case "children":
+                    break;
+                  case "dangerouslySetInnerHTML":
+                    if (null != name) throw Error(formatProdErrorMessage(91));
+                    break;
+                  default:
+                    name !== type && setProp(domElement, tag, value, name, nextProps, type);
+                }
+            updateTextarea(domElement, propKey$201, propKey);
+            return;
+          case "option":
+            for (var propKey$217 in lastProps)
+              if (propKey$201 = lastProps[propKey$217], lastProps.hasOwnProperty(propKey$217) && null != propKey$201 && !nextProps.hasOwnProperty(propKey$217))
+                switch (propKey$217) {
+                  case "selected":
+                    domElement.selected = false;
+                    break;
+                  default:
+                    setProp(
+                      domElement,
+                      tag,
+                      propKey$217,
+                      null,
+                      nextProps,
+                      propKey$201
+                    );
+                }
+            for (lastDefaultValue in nextProps)
+              if (propKey$201 = nextProps[lastDefaultValue], propKey = lastProps[lastDefaultValue], nextProps.hasOwnProperty(lastDefaultValue) && propKey$201 !== propKey && (null != propKey$201 || null != propKey))
+                switch (lastDefaultValue) {
+                  case "selected":
+                    domElement.selected = propKey$201 && "function" !== typeof propKey$201 && "symbol" !== typeof propKey$201;
+                    break;
+                  default:
+                    setProp(
+                      domElement,
+                      tag,
+                      lastDefaultValue,
+                      propKey$201,
+                      nextProps,
+                      propKey
+                    );
+                }
+            return;
+          case "img":
+          case "link":
+          case "area":
+          case "base":
+          case "br":
+          case "col":
+          case "embed":
+          case "hr":
+          case "keygen":
+          case "meta":
+          case "param":
+          case "source":
+          case "track":
+          case "wbr":
+          case "menuitem":
+            for (var propKey$222 in lastProps)
+              propKey$201 = lastProps[propKey$222], lastProps.hasOwnProperty(propKey$222) && null != propKey$201 && !nextProps.hasOwnProperty(propKey$222) && setProp(domElement, tag, propKey$222, null, nextProps, propKey$201);
+            for (checked in nextProps)
+              if (propKey$201 = nextProps[checked], propKey = lastProps[checked], nextProps.hasOwnProperty(checked) && propKey$201 !== propKey && (null != propKey$201 || null != propKey))
+                switch (checked) {
+                  case "children":
+                  case "dangerouslySetInnerHTML":
+                    if (null != propKey$201)
+                      throw Error(formatProdErrorMessage(137, tag));
+                    break;
+                  default:
+                    setProp(
+                      domElement,
+                      tag,
+                      checked,
+                      propKey$201,
+                      nextProps,
+                      propKey
+                    );
+                }
+            return;
+          default:
+            if (isCustomElement(tag)) {
+              for (var propKey$227 in lastProps)
+                propKey$201 = lastProps[propKey$227], lastProps.hasOwnProperty(propKey$227) && void 0 !== propKey$201 && !nextProps.hasOwnProperty(propKey$227) && setPropOnCustomElement(
+                  domElement,
+                  tag,
+                  propKey$227,
+                  void 0,
+                  nextProps,
+                  propKey$201
+                );
+              for (defaultChecked in nextProps)
+                propKey$201 = nextProps[defaultChecked], propKey = lastProps[defaultChecked], !nextProps.hasOwnProperty(defaultChecked) || propKey$201 === propKey || void 0 === propKey$201 && void 0 === propKey || setPropOnCustomElement(
+                  domElement,
+                  tag,
+                  defaultChecked,
+                  propKey$201,
+                  nextProps,
+                  propKey
+                );
+              return;
+            }
+        }
+        for (var propKey$232 in lastProps)
+          propKey$201 = lastProps[propKey$232], lastProps.hasOwnProperty(propKey$232) && null != propKey$201 && !nextProps.hasOwnProperty(propKey$232) && setProp(domElement, tag, propKey$232, null, nextProps, propKey$201);
+        for (lastProp in nextProps)
+          propKey$201 = nextProps[lastProp], propKey = lastProps[lastProp], !nextProps.hasOwnProperty(lastProp) || propKey$201 === propKey || null == propKey$201 && null == propKey || setProp(domElement, tag, lastProp, propKey$201, nextProps, propKey);
+      }
+      function isLikelyStaticResource(initiatorType) {
+        switch (initiatorType) {
+          case "css":
+          case "script":
+          case "font":
+          case "img":
+          case "image":
+          case "input":
+          case "link":
+            return true;
+          default:
+            return false;
+        }
+      }
+      function estimateBandwidth() {
+        if ("function" === typeof performance.getEntriesByType) {
+          for (var count3 = 0, bits = 0, resourceEntries = performance.getEntriesByType("resource"), i = 0; i < resourceEntries.length; i++) {
+            var entry = resourceEntries[i], transferSize = entry.transferSize, initiatorType = entry.initiatorType, duration = entry.duration;
+            if (transferSize && duration && isLikelyStaticResource(initiatorType)) {
+              initiatorType = 0;
+              duration = entry.responseEnd;
+              for (i += 1; i < resourceEntries.length; i++) {
+                var overlapEntry = resourceEntries[i], overlapStartTime = overlapEntry.startTime;
+                if (overlapStartTime > duration) break;
+                var overlapTransferSize = overlapEntry.transferSize, overlapInitiatorType = overlapEntry.initiatorType;
+                overlapTransferSize && isLikelyStaticResource(overlapInitiatorType) && (overlapEntry = overlapEntry.responseEnd, initiatorType += overlapTransferSize * (overlapEntry < duration ? 1 : (duration - overlapStartTime) / (overlapEntry - overlapStartTime)));
+              }
+              --i;
+              bits += 8 * (transferSize + initiatorType) / (entry.duration / 1e3);
+              count3++;
+              if (10 < count3) break;
+            }
+          }
+          if (0 < count3) return bits / count3 / 1e6;
+        }
+        return navigator.connection && (count3 = navigator.connection.downlink, "number" === typeof count3) ? count3 : 5;
+      }
+      var eventsEnabled = null;
+      var selectionInformation = null;
+      function getOwnerDocumentFromRootContainer(rootContainerElement) {
+        return 9 === rootContainerElement.nodeType ? rootContainerElement : rootContainerElement.ownerDocument;
+      }
+      function getOwnHostContext(namespaceURI) {
+        switch (namespaceURI) {
+          case "http://www.w3.org/2000/svg":
+            return 1;
+          case "http://www.w3.org/1998/Math/MathML":
+            return 2;
+          default:
+            return 0;
+        }
+      }
+      function getChildHostContextProd(parentNamespace, type) {
+        if (0 === parentNamespace)
+          switch (type) {
+            case "svg":
+              return 1;
+            case "math":
+              return 2;
+            default:
+              return 0;
+          }
+        return 1 === parentNamespace && "foreignObject" === type ? 0 : parentNamespace;
+      }
+      function shouldSetTextContent(type, props) {
+        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;
+      }
+      var currentPopstateTransitionEvent = null;
+      function shouldAttemptEagerTransition() {
+        var event = window.event;
+        if (event && "popstate" === event.type) {
+          if (event === currentPopstateTransitionEvent) return false;
+          currentPopstateTransitionEvent = event;
+          return true;
+        }
+        currentPopstateTransitionEvent = null;
+        return false;
+      }
+      var scheduleTimeout = "function" === typeof setTimeout ? setTimeout : void 0;
+      var cancelTimeout = "function" === typeof clearTimeout ? clearTimeout : void 0;
+      var localPromise = "function" === typeof Promise ? Promise : void 0;
+      var scheduleMicrotask = "function" === typeof queueMicrotask ? queueMicrotask : "undefined" !== typeof localPromise ? function(callback) {
+        return localPromise.resolve(null).then(callback).catch(handleErrorInNextTick);
+      } : scheduleTimeout;
+      function handleErrorInNextTick(error) {
+        setTimeout(function() {
+          throw error;
+        });
+      }
+      function isSingletonScope(type) {
+        return "head" === type;
+      }
+      function clearHydrationBoundary(parentInstance, hydrationInstance) {
+        var node = hydrationInstance, depth = 0;
+        do {
+          var nextNode = node.nextSibling;
+          parentInstance.removeChild(node);
+          if (nextNode && 8 === nextNode.nodeType)
+            if (node = nextNode.data, "/$" === node || "/&" === node) {
+              if (0 === depth) {
+                parentInstance.removeChild(nextNode);
+                retryIfBlockedOn(hydrationInstance);
+                return;
+              }
+              depth--;
+            } else if ("$" === node || "$?" === node || "$~" === node || "$!" === node || "&" === node)
+              depth++;
+            else if ("html" === node)
+              releaseSingletonInstance(parentInstance.ownerDocument.documentElement);
+            else if ("head" === node) {
+              node = parentInstance.ownerDocument.head;
+              releaseSingletonInstance(node);
+              for (var node$jscomp$0 = node.firstChild; node$jscomp$0; ) {
+                var nextNode$jscomp$0 = node$jscomp$0.nextSibling, nodeName = node$jscomp$0.nodeName;
+                node$jscomp$0[internalHoistableMarker] || "SCRIPT" === nodeName || "STYLE" === nodeName || "LINK" === nodeName && "stylesheet" === node$jscomp$0.rel.toLowerCase() || node.removeChild(node$jscomp$0);
+                node$jscomp$0 = nextNode$jscomp$0;
+              }
+            } else
+              "body" === node && releaseSingletonInstance(parentInstance.ownerDocument.body);
+          node = nextNode;
+        } while (node);
+        retryIfBlockedOn(hydrationInstance);
+      }
+      function hideOrUnhideDehydratedBoundary(suspenseInstance, isHidden2) {
+        var node = suspenseInstance;
+        suspenseInstance = 0;
+        do {
+          var nextNode = node.nextSibling;
+          1 === node.nodeType ? isHidden2 ? (node._stashedDisplay = node.style.display, node.style.display = "none") : (node.style.display = node._stashedDisplay || "", "" === node.getAttribute("style") && node.removeAttribute("style")) : 3 === node.nodeType && (isHidden2 ? (node._stashedText = node.nodeValue, node.nodeValue = "") : node.nodeValue = node._stashedText || "");
+          if (nextNode && 8 === nextNode.nodeType)
+            if (node = nextNode.data, "/$" === node)
+              if (0 === suspenseInstance) break;
+              else suspenseInstance--;
+            else
+              "$" !== node && "$?" !== node && "$~" !== node && "$!" !== node || suspenseInstance++;
+          node = nextNode;
+        } while (node);
+      }
+      function clearContainerSparingly(container) {
+        var nextNode = container.firstChild;
+        nextNode && 10 === nextNode.nodeType && (nextNode = nextNode.nextSibling);
+        for (; nextNode; ) {
+          var node = nextNode;
+          nextNode = nextNode.nextSibling;
+          switch (node.nodeName) {
+            case "HTML":
+            case "HEAD":
+            case "BODY":
+              clearContainerSparingly(node);
+              detachDeletedInstance(node);
+              continue;
+            case "SCRIPT":
+            case "STYLE":
+              continue;
+            case "LINK":
+              if ("stylesheet" === node.rel.toLowerCase()) continue;
+          }
+          container.removeChild(node);
+        }
+      }
+      function canHydrateInstance(instance, type, props, inRootOrSingleton) {
+        for (; 1 === instance.nodeType; ) {
+          var anyProps = props;
+          if (instance.nodeName.toLowerCase() !== type.toLowerCase()) {
+            if (!inRootOrSingleton && ("INPUT" !== instance.nodeName || "hidden" !== instance.type))
+              break;
+          } else if (!inRootOrSingleton)
+            if ("input" === type && "hidden" === instance.type) {
+              var name = null == anyProps.name ? null : "" + anyProps.name;
+              if ("hidden" === anyProps.type && instance.getAttribute("name") === name)
+                return instance;
+            } else return instance;
+          else if (!instance[internalHoistableMarker])
+            switch (type) {
+              case "meta":
+                if (!instance.hasAttribute("itemprop")) break;
+                return instance;
+              case "link":
+                name = instance.getAttribute("rel");
+                if ("stylesheet" === name && instance.hasAttribute("data-precedence"))
+                  break;
+                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))
+                  break;
+                return instance;
+              case "style":
+                if (instance.hasAttribute("data-precedence")) break;
+                return instance;
+              case "script":
+                name = instance.getAttribute("src");
+                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"))
+                  break;
+                return instance;
+              default:
+                return instance;
+            }
+          instance = getNextHydratable(instance.nextSibling);
+          if (null === instance) break;
+        }
+        return null;
+      }
+      function canHydrateTextInstance(instance, text, inRootOrSingleton) {
+        if ("" === text) return null;
+        for (; 3 !== instance.nodeType; ) {
+          if ((1 !== instance.nodeType || "INPUT" !== instance.nodeName || "hidden" !== instance.type) && !inRootOrSingleton)
+            return null;
+          instance = getNextHydratable(instance.nextSibling);
+          if (null === instance) return null;
+        }
+        return instance;
+      }
+      function canHydrateHydrationBoundary(instance, inRootOrSingleton) {
+        for (; 8 !== instance.nodeType; ) {
+          if ((1 !== instance.nodeType || "INPUT" !== instance.nodeName || "hidden" !== instance.type) && !inRootOrSingleton)
+            return null;
+          instance = getNextHydratable(instance.nextSibling);
+          if (null === instance) return null;
+        }
+        return instance;
+      }
+      function isSuspenseInstancePending(instance) {
+        return "$?" === instance.data || "$~" === instance.data;
+      }
+      function isSuspenseInstanceFallback(instance) {
+        return "$!" === instance.data || "$?" === instance.data && "loading" !== instance.ownerDocument.readyState;
+      }
+      function registerSuspenseInstanceRetry(instance, callback) {
+        var ownerDocument = instance.ownerDocument;
+        if ("$~" === instance.data) instance._reactRetry = callback;
+        else if ("$?" !== instance.data || "loading" !== ownerDocument.readyState)
+          callback();
+        else {
+          var listener = function() {
+            callback();
+            ownerDocument.removeEventListener("DOMContentLoaded", listener);
+          };
+          ownerDocument.addEventListener("DOMContentLoaded", listener);
+          instance._reactRetry = listener;
+        }
+      }
+      function getNextHydratable(node) {
+        for (; null != node; node = node.nextSibling) {
+          var nodeType = node.nodeType;
+          if (1 === nodeType || 3 === nodeType) break;
+          if (8 === nodeType) {
+            nodeType = node.data;
+            if ("$" === nodeType || "$!" === nodeType || "$?" === nodeType || "$~" === nodeType || "&" === nodeType || "F!" === nodeType || "F" === nodeType)
+              break;
+            if ("/$" === nodeType || "/&" === nodeType) return null;
+          }
+        }
+        return node;
+      }
+      var previousHydratableOnEnteringScopedSingleton = null;
+      function getNextHydratableInstanceAfterHydrationBoundary(hydrationInstance) {
+        hydrationInstance = hydrationInstance.nextSibling;
+        for (var depth = 0; hydrationInstance; ) {
+          if (8 === hydrationInstance.nodeType) {
+            var data = hydrationInstance.data;
+            if ("/$" === data || "/&" === data) {
+              if (0 === depth)
+                return getNextHydratable(hydrationInstance.nextSibling);
+              depth--;
+            } else
+              "$" !== data && "$!" !== data && "$?" !== data && "$~" !== data && "&" !== data || depth++;
+          }
+          hydrationInstance = hydrationInstance.nextSibling;
+        }
+        return null;
+      }
+      function getParentHydrationBoundary(targetInstance) {
+        targetInstance = targetInstance.previousSibling;
+        for (var depth = 0; targetInstance; ) {
+          if (8 === targetInstance.nodeType) {
+            var data = targetInstance.data;
+            if ("$" === data || "$!" === data || "$?" === data || "$~" === data || "&" === data) {
+              if (0 === depth) return targetInstance;
+              depth--;
+            } else "/$" !== data && "/&" !== data || depth++;
+          }
+          targetInstance = targetInstance.previousSibling;
+        }
+        return null;
+      }
+      function resolveSingletonInstance(type, props, rootContainerInstance) {
+        props = getOwnerDocumentFromRootContainer(rootContainerInstance);
+        switch (type) {
+          case "html":
+            type = props.documentElement;
+            if (!type) throw Error(formatProdErrorMessage(452));
+            return type;
+          case "head":
+            type = props.head;
+            if (!type) throw Error(formatProdErrorMessage(453));
+            return type;
+          case "body":
+            type = props.body;
+            if (!type) throw Error(formatProdErrorMessage(454));
+            return type;
+          default:
+            throw Error(formatProdErrorMessage(451));
+        }
+      }
+      function releaseSingletonInstance(instance) {
+        for (var attributes = instance.attributes; attributes.length; )
+          instance.removeAttributeNode(attributes[0]);
+        detachDeletedInstance(instance);
+      }
+      var preloadPropsMap = /* @__PURE__ */ new Map();
+      var preconnectsSet = /* @__PURE__ */ new Set();
+      function getHoistableRoot(container) {
+        return "function" === typeof container.getRootNode ? container.getRootNode() : 9 === container.nodeType ? container : container.ownerDocument;
+      }
+      var previousDispatcher = ReactDOMSharedInternals.d;
+      ReactDOMSharedInternals.d = {
+        f: flushSyncWork,
+        r: requestFormReset,
+        D: prefetchDNS,
+        C: preconnect,
+        L: preload,
+        m: preloadModule,
+        X: preinitScript,
+        S: preinitStyle,
+        M: preinitModuleScript
+      };
+      function flushSyncWork() {
+        var previousWasRendering = previousDispatcher.f(), wasRendering = flushSyncWork$1();
+        return previousWasRendering || wasRendering;
+      }
+      function requestFormReset(form) {
+        var formInst = getInstanceFromNode(form);
+        null !== formInst && 5 === formInst.tag && "form" === formInst.type ? requestFormReset$1(formInst) : previousDispatcher.r(form);
+      }
+      var globalDocument = "undefined" === typeof document ? null : document;
+      function preconnectAs(rel, href, crossOrigin) {
+        var ownerDocument = globalDocument;
+        if (ownerDocument && "string" === typeof href && href) {
+          var limitedEscapedHref = escapeSelectorAttributeValueInsideDoubleQuotes(href);
+          limitedEscapedHref = 'link[rel="' + rel + '"][href="' + limitedEscapedHref + '"]';
+          "string" === typeof crossOrigin && (limitedEscapedHref += '[crossorigin="' + crossOrigin + '"]');
+          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)));
+        }
+      }
+      function prefetchDNS(href) {
+        previousDispatcher.D(href);
+        preconnectAs("dns-prefetch", href, null);
+      }
+      function preconnect(href, crossOrigin) {
+        previousDispatcher.C(href, crossOrigin);
+        preconnectAs("preconnect", href, crossOrigin);
+      }
+      function preload(href, as, options3) {
+        previousDispatcher.L(href, as, options3);
+        var ownerDocument = globalDocument;
+        if (ownerDocument && href && as) {
+          var preloadSelector = 'link[rel="preload"][as="' + escapeSelectorAttributeValueInsideDoubleQuotes(as) + '"]';
+          "image" === as ? options3 && options3.imageSrcSet ? (preloadSelector += '[imagesrcset="' + escapeSelectorAttributeValueInsideDoubleQuotes(
+            options3.imageSrcSet
+          ) + '"]', "string" === typeof options3.imageSizes && (preloadSelector += '[imagesizes="' + escapeSelectorAttributeValueInsideDoubleQuotes(
+            options3.imageSizes
+          ) + '"]')) : preloadSelector += '[href="' + escapeSelectorAttributeValueInsideDoubleQuotes(href) + '"]' : preloadSelector += '[href="' + escapeSelectorAttributeValueInsideDoubleQuotes(href) + '"]';
+          var key = preloadSelector;
+          switch (as) {
+            case "style":
+              key = getStyleKey(href);
+              break;
+            case "script":
+              key = getScriptKey(href);
+          }
+          preloadPropsMap.has(key) || (href = assign(
+            {
+              rel: "preload",
+              href: "image" === as && options3 && options3.imageSrcSet ? void 0 : href,
+              as
+            },
+            options3
+          ), preloadPropsMap.set(key, href), null !== ownerDocument.querySelector(preloadSelector) || "style" === as && ownerDocument.querySelector(getStylesheetSelectorFromKey(key)) || "script" === as && ownerDocument.querySelector(getScriptSelectorFromKey(key)) || (as = ownerDocument.createElement("link"), setInitialProperties(as, "link", href), markNodeAsHoistable(as), ownerDocument.head.appendChild(as)));
+        }
+      }
+      function preloadModule(href, options3) {
+        previousDispatcher.m(href, options3);
+        var ownerDocument = globalDocument;
+        if (ownerDocument && href) {
+          var as = options3 && "string" === typeof options3.as ? options3.as : "script", preloadSelector = 'link[rel="modulepreload"][as="' + escapeSelectorAttributeValueInsideDoubleQuotes(as) + '"][href="' + escapeSelectorAttributeValueInsideDoubleQuotes(href) + '"]', key = preloadSelector;
+          switch (as) {
+            case "audioworklet":
+            case "paintworklet":
+            case "serviceworker":
+            case "sharedworker":
+            case "worker":
+            case "script":
+              key = getScriptKey(href);
+          }
+          if (!preloadPropsMap.has(key) && (href = assign({ rel: "modulepreload", href }, options3), preloadPropsMap.set(key, href), null === ownerDocument.querySelector(preloadSelector))) {
+            switch (as) {
+              case "audioworklet":
+              case "paintworklet":
+              case "serviceworker":
+              case "sharedworker":
+              case "worker":
+              case "script":
+                if (ownerDocument.querySelector(getScriptSelectorFromKey(key)))
+                  return;
+            }
+            as = ownerDocument.createElement("link");
+            setInitialProperties(as, "link", href);
+            markNodeAsHoistable(as);
+            ownerDocument.head.appendChild(as);
+          }
+        }
+      }
+      function preinitStyle(href, precedence, options3) {
+        previousDispatcher.S(href, precedence, options3);
+        var ownerDocument = globalDocument;
+        if (ownerDocument && href) {
+          var styles = getResourcesFromRoot(ownerDocument).hoistableStyles, key = getStyleKey(href);
+          precedence = precedence || "default";
+          var resource = styles.get(key);
+          if (!resource) {
+            var state = { loading: 0, preload: null };
+            if (resource = ownerDocument.querySelector(
+              getStylesheetSelectorFromKey(key)
+            ))
+              state.loading = 5;
+            else {
+              href = assign(
+                { rel: "stylesheet", href, "data-precedence": precedence },
+                options3
+              );
+              (options3 = preloadPropsMap.get(key)) && adoptPreloadPropsForStylesheet(href, options3);
+              var link = resource = ownerDocument.createElement("link");
+              markNodeAsHoistable(link);
+              setInitialProperties(link, "link", href);
+              link._p = new Promise(function(resolve, reject) {
+                link.onload = resolve;
+                link.onerror = reject;
+              });
+              link.addEventListener("load", function() {
+                state.loading |= 1;
+              });
+              link.addEventListener("error", function() {
+                state.loading |= 2;
+              });
+              state.loading |= 4;
+              insertStylesheet(resource, precedence, ownerDocument);
+            }
+            resource = {
+              type: "stylesheet",
+              instance: resource,
+              count: 1,
+              state
+            };
+            styles.set(key, resource);
+          }
+        }
+      }
+      function preinitScript(src, options3) {
+        previousDispatcher.X(src, options3);
+        var ownerDocument = globalDocument;
+        if (ownerDocument && src) {
+          var scripts = getResourcesFromRoot(ownerDocument).hoistableScripts, key = getScriptKey(src), resource = scripts.get(key);
+          resource || (resource = ownerDocument.querySelector(getScriptSelectorFromKey(key)), resource || (src = assign({ src, async: true }, options3), (options3 = preloadPropsMap.get(key)) && adoptPreloadPropsForScript(src, options3), resource = ownerDocument.createElement("script"), markNodeAsHoistable(resource), setInitialProperties(resource, "link", src), ownerDocument.head.appendChild(resource)), resource = {
+            type: "script",
+            instance: resource,
+            count: 1,
+            state: null
+          }, scripts.set(key, resource));
+        }
+      }
+      function preinitModuleScript(src, options3) {
+        previousDispatcher.M(src, options3);
+        var ownerDocument = globalDocument;
+        if (ownerDocument && src) {
+          var scripts = getResourcesFromRoot(ownerDocument).hoistableScripts, key = getScriptKey(src), resource = scripts.get(key);
+          resource || (resource = ownerDocument.querySelector(getScriptSelectorFromKey(key)), resource || (src = assign({ src, async: true, type: "module" }, options3), (options3 = preloadPropsMap.get(key)) && adoptPreloadPropsForScript(src, options3), resource = ownerDocument.createElement("script"), markNodeAsHoistable(resource), setInitialProperties(resource, "link", src), ownerDocument.head.appendChild(resource)), resource = {
+            type: "script",
+            instance: resource,
+            count: 1,
+            state: null
+          }, scripts.set(key, resource));
+        }
+      }
+      function getResource(type, currentProps, pendingProps, currentResource) {
+        var JSCompiler_inline_result = (JSCompiler_inline_result = rootInstanceStackCursor.current) ? getHoistableRoot(JSCompiler_inline_result) : null;
+        if (!JSCompiler_inline_result) throw Error(formatProdErrorMessage(446));
+        switch (type) {
+          case "meta":
+          case "title":
+            return null;
+          case "style":
+            return "string" === typeof pendingProps.precedence && "string" === typeof pendingProps.href ? (currentProps = getStyleKey(pendingProps.href), pendingProps = getResourcesFromRoot(
+              JSCompiler_inline_result
+            ).hoistableStyles, currentResource = pendingProps.get(currentProps), currentResource || (currentResource = {
+              type: "style",
+              instance: null,
+              count: 0,
+              state: null
+            }, pendingProps.set(currentProps, currentResource)), currentResource) : { type: "void", instance: null, count: 0, state: null };
+          case "link":
+            if ("stylesheet" === pendingProps.rel && "string" === typeof pendingProps.href && "string" === typeof pendingProps.precedence) {
+              type = getStyleKey(pendingProps.href);
+              var styles$243 = getResourcesFromRoot(
+                JSCompiler_inline_result
+              ).hoistableStyles, resource$244 = styles$243.get(type);
+              resource$244 || (JSCompiler_inline_result = JSCompiler_inline_result.ownerDocument || JSCompiler_inline_result, resource$244 = {
+                type: "stylesheet",
+                instance: null,
+                count: 0,
+                state: { loading: 0, preload: null }
+              }, styles$243.set(type, resource$244), (styles$243 = JSCompiler_inline_result.querySelector(
+                getStylesheetSelectorFromKey(type)
+              )) && !styles$243._p && (resource$244.instance = styles$243, resource$244.state.loading = 5), preloadPropsMap.has(type) || (pendingProps = {
+                rel: "preload",
+                as: "style",
+                href: pendingProps.href,
+                crossOrigin: pendingProps.crossOrigin,
+                integrity: pendingProps.integrity,
+                media: pendingProps.media,
+                hrefLang: pendingProps.hrefLang,
+                referrerPolicy: pendingProps.referrerPolicy
+              }, preloadPropsMap.set(type, pendingProps), styles$243 || preloadStylesheet(
+                JSCompiler_inline_result,
+                type,
+                pendingProps,
+                resource$244.state
+              )));
+              if (currentProps && null === currentResource)
+                throw Error(formatProdErrorMessage(528, ""));
+              return resource$244;
+            }
+            if (currentProps && null !== currentResource)
+              throw Error(formatProdErrorMessage(529, ""));
+            return null;
+          case "script":
+            return currentProps = pendingProps.async, pendingProps = pendingProps.src, "string" === typeof pendingProps && currentProps && "function" !== typeof currentProps && "symbol" !== typeof currentProps ? (currentProps = getScriptKey(pendingProps), pendingProps = getResourcesFromRoot(
+              JSCompiler_inline_result
+            ).hoistableScripts, currentResource = pendingProps.get(currentProps), currentResource || (currentResource = {
+              type: "script",
+              instance: null,
+              count: 0,
+              state: null
+            }, pendingProps.set(currentProps, currentResource)), currentResource) : { type: "void", instance: null, count: 0, state: null };
+          default:
+            throw Error(formatProdErrorMessage(444, type));
+        }
+      }
+      function getStyleKey(href) {
+        return 'href="' + escapeSelectorAttributeValueInsideDoubleQuotes(href) + '"';
+      }
+      function getStylesheetSelectorFromKey(key) {
+        return 'link[rel="stylesheet"][' + key + "]";
+      }
+      function stylesheetPropsFromRawProps(rawProps) {
+        return assign({}, rawProps, {
+          "data-precedence": rawProps.precedence,
+          precedence: null
+        });
+      }
+      function preloadStylesheet(ownerDocument, key, preloadProps, state) {
+        ownerDocument.querySelector('link[rel="preload"][as="style"][' + key + "]") ? state.loading = 1 : (key = ownerDocument.createElement("link"), state.preload = key, key.addEventListener("load", function() {
+          return state.loading |= 1;
+        }), key.addEventListener("error", function() {
+          return state.loading |= 2;
+        }), setInitialProperties(key, "link", preloadProps), markNodeAsHoistable(key), ownerDocument.head.appendChild(key));
+      }
+      function getScriptKey(src) {
+        return '[src="' + escapeSelectorAttributeValueInsideDoubleQuotes(src) + '"]';
+      }
+      function getScriptSelectorFromKey(key) {
+        return "script[async]" + key;
+      }
+      function acquireResource(hoistableRoot, resource, props) {
+        resource.count++;
+        if (null === resource.instance)
+          switch (resource.type) {
+            case "style":
+              var instance = hoistableRoot.querySelector(
+                'style[data-href~="' + escapeSelectorAttributeValueInsideDoubleQuotes(props.href) + '"]'
+              );
+              if (instance)
+                return resource.instance = instance, markNodeAsHoistable(instance), instance;
+              var styleProps = assign({}, props, {
+                "data-href": props.href,
+                "data-precedence": props.precedence,
+                href: null,
+                precedence: null
+              });
+              instance = (hoistableRoot.ownerDocument || hoistableRoot).createElement(
+                "style"
+              );
+              markNodeAsHoistable(instance);
+              setInitialProperties(instance, "style", styleProps);
+              insertStylesheet(instance, props.precedence, hoistableRoot);
+              return resource.instance = instance;
+            case "stylesheet":
+              styleProps = getStyleKey(props.href);
+              var instance$249 = hoistableRoot.querySelector(
+                getStylesheetSelectorFromKey(styleProps)
+              );
+              if (instance$249)
+                return resource.state.loading |= 4, resource.instance = instance$249, markNodeAsHoistable(instance$249), instance$249;
+              instance = stylesheetPropsFromRawProps(props);
+              (styleProps = preloadPropsMap.get(styleProps)) && adoptPreloadPropsForStylesheet(instance, styleProps);
+              instance$249 = (hoistableRoot.ownerDocument || hoistableRoot).createElement("link");
+              markNodeAsHoistable(instance$249);
+              var linkInstance = instance$249;
+              linkInstance._p = new Promise(function(resolve, reject) {
+                linkInstance.onload = resolve;
+                linkInstance.onerror = reject;
+              });
+              setInitialProperties(instance$249, "link", instance);
+              resource.state.loading |= 4;
+              insertStylesheet(instance$249, props.precedence, hoistableRoot);
+              return resource.instance = instance$249;
+            case "script":
+              instance$249 = getScriptKey(props.src);
+              if (styleProps = hoistableRoot.querySelector(
+                getScriptSelectorFromKey(instance$249)
+              ))
+                return resource.instance = styleProps, markNodeAsHoistable(styleProps), styleProps;
+              instance = props;
+              if (styleProps = preloadPropsMap.get(instance$249))
+                instance = assign({}, props), adoptPreloadPropsForScript(instance, styleProps);
+              hoistableRoot = hoistableRoot.ownerDocument || hoistableRoot;
+              styleProps = hoistableRoot.createElement("script");
+              markNodeAsHoistable(styleProps);
+              setInitialProperties(styleProps, "link", instance);
+              hoistableRoot.head.appendChild(styleProps);
+              return resource.instance = styleProps;
+            case "void":
+              return null;
+            default:
+              throw Error(formatProdErrorMessage(443, resource.type));
+          }
+        else
+          "stylesheet" === resource.type && 0 === (resource.state.loading & 4) && (instance = resource.instance, resource.state.loading |= 4, insertStylesheet(instance, props.precedence, hoistableRoot));
+        return resource.instance;
+      }
+      function insertStylesheet(instance, precedence, root2) {
+        for (var nodes = root2.querySelectorAll(
+          'link[rel="stylesheet"][data-precedence],style[data-precedence]'
+        ), last = nodes.length ? nodes[nodes.length - 1] : null, prior = last, i = 0; i < nodes.length; i++) {
+          var node = nodes[i];
+          if (node.dataset.precedence === precedence) prior = node;
+          else if (prior !== last) break;
+        }
+        prior ? prior.parentNode.insertBefore(instance, prior.nextSibling) : (precedence = 9 === root2.nodeType ? root2.head : root2, precedence.insertBefore(instance, precedence.firstChild));
+      }
+      function adoptPreloadPropsForStylesheet(stylesheetProps, preloadProps) {
+        null == stylesheetProps.crossOrigin && (stylesheetProps.crossOrigin = preloadProps.crossOrigin);
+        null == stylesheetProps.referrerPolicy && (stylesheetProps.referrerPolicy = preloadProps.referrerPolicy);
+        null == stylesheetProps.title && (stylesheetProps.title = preloadProps.title);
+      }
+      function adoptPreloadPropsForScript(scriptProps, preloadProps) {
+        null == scriptProps.crossOrigin && (scriptProps.crossOrigin = preloadProps.crossOrigin);
+        null == scriptProps.referrerPolicy && (scriptProps.referrerPolicy = preloadProps.referrerPolicy);
+        null == scriptProps.integrity && (scriptProps.integrity = preloadProps.integrity);
+      }
+      var tagCaches = null;
+      function getHydratableHoistableCache(type, keyAttribute, ownerDocument) {
+        if (null === tagCaches) {
+          var cache = /* @__PURE__ */ new Map();
+          var caches = tagCaches = /* @__PURE__ */ new Map();
+          caches.set(ownerDocument, cache);
+        } else
+          caches = tagCaches, cache = caches.get(ownerDocument), cache || (cache = /* @__PURE__ */ new Map(), caches.set(ownerDocument, cache));
+        if (cache.has(type)) return cache;
+        cache.set(type, null);
+        ownerDocument = ownerDocument.getElementsByTagName(type);
+        for (caches = 0; caches < ownerDocument.length; caches++) {
+          var node = ownerDocument[caches];
+          if (!(node[internalHoistableMarker] || node[internalInstanceKey] || "link" === type && "stylesheet" === node.getAttribute("rel")) && "http://www.w3.org/2000/svg" !== node.namespaceURI) {
+            var nodeKey = node.getAttribute(keyAttribute) || "";
+            nodeKey = type + nodeKey;
+            var existing = cache.get(nodeKey);
+            existing ? existing.push(node) : cache.set(nodeKey, [node]);
+          }
+        }
+        return cache;
+      }
+      function mountHoistable(hoistableRoot, type, instance) {
+        hoistableRoot = hoistableRoot.ownerDocument || hoistableRoot;
+        hoistableRoot.head.insertBefore(
+          instance,
+          "title" === type ? hoistableRoot.querySelector("head > title") : null
+        );
+      }
+      function isHostHoistableType(type, props, hostContext) {
+        if (1 === hostContext || null != props.itemProp) return false;
+        switch (type) {
+          case "meta":
+          case "title":
+            return true;
+          case "style":
+            if ("string" !== typeof props.precedence || "string" !== typeof props.href || "" === props.href)
+              break;
+            return true;
+          case "link":
+            if ("string" !== typeof props.rel || "string" !== typeof props.href || "" === props.href || props.onLoad || props.onError)
+              break;
+            switch (props.rel) {
+              case "stylesheet":
+                return type = props.disabled, "string" === typeof props.precedence && null == type;
+              default:
+                return true;
+            }
+          case "script":
+            if (props.async && "function" !== typeof props.async && "symbol" !== typeof props.async && !props.onLoad && !props.onError && props.src && "string" === typeof props.src)
+              return true;
+        }
+        return false;
+      }
+      function preloadResource(resource) {
+        return "stylesheet" === resource.type && 0 === (resource.state.loading & 3) ? false : true;
+      }
+      function suspendResource(state, hoistableRoot, resource, props) {
+        if ("stylesheet" === resource.type && ("string" !== typeof props.media || false !== matchMedia(props.media).matches) && 0 === (resource.state.loading & 4)) {
+          if (null === resource.instance) {
+            var key = getStyleKey(props.href), instance = hoistableRoot.querySelector(
+              getStylesheetSelectorFromKey(key)
+            );
+            if (instance) {
+              hoistableRoot = instance._p;
+              null !== hoistableRoot && "object" === typeof hoistableRoot && "function" === typeof hoistableRoot.then && (state.count++, state = onUnsuspend.bind(state), hoistableRoot.then(state, state));
+              resource.state.loading |= 4;
+              resource.instance = instance;
+              markNodeAsHoistable(instance);
+              return;
+            }
+            instance = hoistableRoot.ownerDocument || hoistableRoot;
+            props = stylesheetPropsFromRawProps(props);
+            (key = preloadPropsMap.get(key)) && adoptPreloadPropsForStylesheet(props, key);
+            instance = instance.createElement("link");
+            markNodeAsHoistable(instance);
+            var linkInstance = instance;
+            linkInstance._p = new Promise(function(resolve, reject) {
+              linkInstance.onload = resolve;
+              linkInstance.onerror = reject;
+            });
+            setInitialProperties(instance, "link", props);
+            resource.instance = instance;
+          }
+          null === state.stylesheets && (state.stylesheets = /* @__PURE__ */ new Map());
+          state.stylesheets.set(resource, hoistableRoot);
+          (hoistableRoot = resource.state.preload) && 0 === (resource.state.loading & 3) && (state.count++, resource = onUnsuspend.bind(state), hoistableRoot.addEventListener("load", resource), hoistableRoot.addEventListener("error", resource));
+        }
+      }
+      var estimatedBytesWithinLimit = 0;
+      function waitForCommitToBeReady(state, timeoutOffset) {
+        state.stylesheets && 0 === state.count && insertSuspendedStylesheets(state, state.stylesheets);
+        return 0 < state.count || 0 < state.imgCount ? function(commit) {
+          var stylesheetTimer = setTimeout(function() {
+            state.stylesheets && insertSuspendedStylesheets(state, state.stylesheets);
+            if (state.unsuspend) {
+              var unsuspend = state.unsuspend;
+              state.unsuspend = null;
+              unsuspend();
+            }
+          }, 6e4 + timeoutOffset);
+          0 < state.imgBytes && 0 === estimatedBytesWithinLimit && (estimatedBytesWithinLimit = 62500 * estimateBandwidth());
+          var imgTimer = setTimeout(
+            function() {
+              state.waitingForImages = false;
+              if (0 === state.count && (state.stylesheets && insertSuspendedStylesheets(state, state.stylesheets), state.unsuspend)) {
+                var unsuspend = state.unsuspend;
+                state.unsuspend = null;
+                unsuspend();
+              }
+            },
+            (state.imgBytes > estimatedBytesWithinLimit ? 50 : 800) + timeoutOffset
+          );
+          state.unsuspend = commit;
+          return function() {
+            state.unsuspend = null;
+            clearTimeout(stylesheetTimer);
+            clearTimeout(imgTimer);
+          };
+        } : null;
+      }
+      function onUnsuspend() {
+        this.count--;
+        if (0 === this.count && (0 === this.imgCount || !this.waitingForImages)) {
+          if (this.stylesheets) insertSuspendedStylesheets(this, this.stylesheets);
+          else if (this.unsuspend) {
+            var unsuspend = this.unsuspend;
+            this.unsuspend = null;
+            unsuspend();
+          }
+        }
+      }
+      var precedencesByRoot = null;
+      function insertSuspendedStylesheets(state, resources) {
+        state.stylesheets = null;
+        null !== state.unsuspend && (state.count++, precedencesByRoot = /* @__PURE__ */ new Map(), resources.forEach(insertStylesheetIntoRoot, state), precedencesByRoot = null, onUnsuspend.call(state));
+      }
+      function insertStylesheetIntoRoot(root2, resource) {
+        if (!(resource.state.loading & 4)) {
+          var precedences = precedencesByRoot.get(root2);
+          if (precedences) var last = precedences.get(null);
+          else {
+            precedences = /* @__PURE__ */ new Map();
+            precedencesByRoot.set(root2, precedences);
+            for (var nodes = root2.querySelectorAll(
+              "link[data-precedence],style[data-precedence]"
+            ), i = 0; i < nodes.length; i++) {
+              var node = nodes[i];
+              if ("LINK" === node.nodeName || "not all" !== node.getAttribute("media"))
+                precedences.set(node.dataset.precedence, node), last = node;
+            }
+            last && precedences.set(null, last);
+          }
+          nodes = resource.instance;
+          node = nodes.getAttribute("data-precedence");
+          i = precedences.get(node) || last;
+          i === last && precedences.set(null, nodes);
+          precedences.set(node, nodes);
+          this.count++;
+          last = onUnsuspend.bind(this);
+          nodes.addEventListener("load", last);
+          nodes.addEventListener("error", last);
+          i ? i.parentNode.insertBefore(nodes, i.nextSibling) : (root2 = 9 === root2.nodeType ? root2.head : root2, root2.insertBefore(nodes, root2.firstChild));
+          resource.state.loading |= 4;
+        }
+      }
+      var HostTransitionContext = {
+        $$typeof: REACT_CONTEXT_TYPE,
+        Provider: null,
+        Consumer: null,
+        _currentValue: sharedNotPendingObject,
+        _currentValue2: sharedNotPendingObject,
+        _threadCount: 0
+      };