openplanr 2.2640.8 → 2.2641.0

package/lib/host-packages/openai/openplanr/runtime/design/scripts/runtime/packages/design/templates/studio/studio.js.sources/09-react-dom-client-public-roots.js

@@ -0,0 +1,705 @@
+
+      function FiberRootNode(containerInfo, tag, hydrate, identifierPrefix, onUncaughtError, onCaughtError, onRecoverableError, onDefaultTransitionIndicator, formState) {
+        this.tag = 1;
+        this.containerInfo = containerInfo;
+        this.pingCache = this.current = this.pendingChildren = null;
+        this.timeoutHandle = -1;
+        this.callbackNode = this.next = this.pendingContext = this.context = this.cancelPendingCommit = null;
+        this.callbackPriority = 0;
+        this.expirationTimes = createLaneMap(-1);
+        this.entangledLanes = this.shellSuspendCounter = this.errorRecoveryDisabledLanes = this.expiredLanes = this.warmLanes = this.pingedLanes = this.suspendedLanes = this.pendingLanes = 0;
+        this.entanglements = createLaneMap(0);
+        this.hiddenUpdates = createLaneMap(null);
+        this.identifierPrefix = identifierPrefix;
+        this.onUncaughtError = onUncaughtError;
+        this.onCaughtError = onCaughtError;
+        this.onRecoverableError = onRecoverableError;
+        this.pooledCache = null;
+        this.pooledCacheLanes = 0;
+        this.formState = formState;
+        this.incompleteTransitions = /* @__PURE__ */ new Map();
+      }
+      function createFiberRoot(containerInfo, tag, hydrate, initialChildren, hydrationCallbacks, isStrictMode, identifierPrefix, formState, onUncaughtError, onCaughtError, onRecoverableError, onDefaultTransitionIndicator) {
+        containerInfo = new FiberRootNode(
+          containerInfo,
+          tag,
+          hydrate,
+          identifierPrefix,
+          onUncaughtError,
+          onCaughtError,
+          onRecoverableError,
+          onDefaultTransitionIndicator,
+          formState
+        );
+        tag = 1;
+        true === isStrictMode && (tag |= 24);
+        isStrictMode = createFiberImplClass(3, null, null, tag);
+        containerInfo.current = isStrictMode;
+        isStrictMode.stateNode = containerInfo;
+        tag = createCache();
+        tag.refCount++;
+        containerInfo.pooledCache = tag;
+        tag.refCount++;
+        isStrictMode.memoizedState = {
+          element: initialChildren,
+          isDehydrated: hydrate,
+          cache: tag
+        };
+        initializeUpdateQueue(isStrictMode);
+        return containerInfo;
+      }
+      function getContextForSubtree(parentComponent) {
+        if (!parentComponent) return emptyContextObject;
+        parentComponent = emptyContextObject;
+        return parentComponent;
+      }
+      function updateContainerImpl(rootFiber, lane, element, container, parentComponent, callback) {
+        parentComponent = getContextForSubtree(parentComponent);
+        null === container.context ? container.context = parentComponent : container.pendingContext = parentComponent;
+        container = createUpdate(lane);
+        container.payload = { element };
+        callback = void 0 === callback ? null : callback;
+        null !== callback && (container.callback = callback);
+        element = enqueueUpdate(rootFiber, container, lane);
+        null !== element && (scheduleUpdateOnFiber(element, rootFiber, lane), entangleTransitions(element, rootFiber, lane));
+      }
+      function markRetryLaneImpl(fiber, retryLane) {
+        fiber = fiber.memoizedState;
+        if (null !== fiber && null !== fiber.dehydrated) {
+          var a = fiber.retryLane;
+          fiber.retryLane = 0 !== a && a < retryLane ? a : retryLane;
+        }
+      }
+      function markRetryLaneIfNotHydrated(fiber, retryLane) {
+        markRetryLaneImpl(fiber, retryLane);
+        (fiber = fiber.alternate) && markRetryLaneImpl(fiber, retryLane);
+      }
+      function attemptContinuousHydration(fiber) {
+        if (13 === fiber.tag || 31 === fiber.tag) {
+          var root2 = enqueueConcurrentRenderForLane(fiber, 67108864);
+          null !== root2 && scheduleUpdateOnFiber(root2, fiber, 67108864);
+          markRetryLaneIfNotHydrated(fiber, 67108864);
+        }
+      }
+      function attemptHydrationAtCurrentPriority(fiber) {
+        if (13 === fiber.tag || 31 === fiber.tag) {
+          var lane = requestUpdateLane();
+          lane = getBumpedLaneForHydrationByLane(lane);
+          var root2 = enqueueConcurrentRenderForLane(fiber, lane);
+          null !== root2 && scheduleUpdateOnFiber(root2, fiber, lane);
+          markRetryLaneIfNotHydrated(fiber, lane);
+        }
+      }
+      var _enabled = true;
+      function dispatchDiscreteEvent(domEventName, eventSystemFlags, container, nativeEvent) {
+        var prevTransition = ReactSharedInternals.T;
+        ReactSharedInternals.T = null;
+        var previousPriority = ReactDOMSharedInternals.p;
+        try {
+          ReactDOMSharedInternals.p = 2, dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
+        } finally {
+          ReactDOMSharedInternals.p = previousPriority, ReactSharedInternals.T = prevTransition;
+        }
+      }
+      function dispatchContinuousEvent(domEventName, eventSystemFlags, container, nativeEvent) {
+        var prevTransition = ReactSharedInternals.T;
+        ReactSharedInternals.T = null;
+        var previousPriority = ReactDOMSharedInternals.p;
+        try {
+          ReactDOMSharedInternals.p = 8, dispatchEvent(domEventName, eventSystemFlags, container, nativeEvent);
+        } finally {
+          ReactDOMSharedInternals.p = previousPriority, ReactSharedInternals.T = prevTransition;
+        }
+      }
+      function dispatchEvent(domEventName, eventSystemFlags, targetContainer, nativeEvent) {
+        if (_enabled) {
+          var blockedOn = findInstanceBlockingEvent(nativeEvent);
+          if (null === blockedOn)
+            dispatchEventForPluginEventSystem(
+              domEventName,
+              eventSystemFlags,
+              nativeEvent,
+              return_targetInst,
+              targetContainer
+            ), clearIfContinuousEvent(domEventName, nativeEvent);
+          else if (queueIfContinuousEvent(
+            blockedOn,
+            domEventName,
+            eventSystemFlags,
+            targetContainer,
+            nativeEvent
+          ))
+            nativeEvent.stopPropagation();
+          else if (clearIfContinuousEvent(domEventName, nativeEvent), eventSystemFlags & 4 && -1 < discreteReplayableEvents.indexOf(domEventName)) {
+            for (; null !== blockedOn; ) {
+              var fiber = getInstanceFromNode(blockedOn);
+              if (null !== fiber)
+                switch (fiber.tag) {
+                  case 3:
+                    fiber = fiber.stateNode;
+                    if (fiber.current.memoizedState.isDehydrated) {
+                      var lanes = getHighestPriorityLanes(fiber.pendingLanes);
+                      if (0 !== lanes) {
+                        var root2 = fiber;
+                        root2.pendingLanes |= 2;
+                        for (root2.entangledLanes |= 2; lanes; ) {
+                          var lane = 1 << 31 - clz32(lanes);
+                          root2.entanglements[1] |= lane;
+                          lanes &= ~lane;
+                        }
+                        ensureRootIsScheduled(fiber);
+                        0 === (executionContext & 6) && (workInProgressRootRenderTargetTime = now() + 500, flushSyncWorkAcrossRoots_impl(0, false));
+                      }
+                    }
+                    break;
+                  case 31:
+                  case 13:
+                    root2 = enqueueConcurrentRenderForLane(fiber, 2), null !== root2 && scheduleUpdateOnFiber(root2, fiber, 2), flushSyncWork$1(), markRetryLaneIfNotHydrated(fiber, 2);
+                }
+              fiber = findInstanceBlockingEvent(nativeEvent);
+              null === fiber && dispatchEventForPluginEventSystem(
+                domEventName,
+                eventSystemFlags,
+                nativeEvent,
+                return_targetInst,
+                targetContainer
+              );
+              if (fiber === blockedOn) break;
+              blockedOn = fiber;
+            }
+            null !== blockedOn && nativeEvent.stopPropagation();
+          } else
+            dispatchEventForPluginEventSystem(
+              domEventName,
+              eventSystemFlags,
+              nativeEvent,
+              null,
+              targetContainer
+            );
+        }
+      }
+      function findInstanceBlockingEvent(nativeEvent) {
+        nativeEvent = getEventTarget(nativeEvent);
+        return findInstanceBlockingTarget(nativeEvent);
+      }
+      var return_targetInst = null;
+      function findInstanceBlockingTarget(targetNode) {
+        return_targetInst = null;
+        targetNode = getClosestInstanceFromNode(targetNode);
+        if (null !== targetNode) {
+          var nearestMounted = getNearestMountedFiber(targetNode);
+          if (null === nearestMounted) targetNode = null;
+          else {
+            var tag = nearestMounted.tag;
+            if (13 === tag) {
+              targetNode = getSuspenseInstanceFromFiber(nearestMounted);
+              if (null !== targetNode) return targetNode;
+              targetNode = null;
+            } else if (31 === tag) {
+              targetNode = getActivityInstanceFromFiber(nearestMounted);
+              if (null !== targetNode) return targetNode;
+              targetNode = null;
+            } else if (3 === tag) {
+              if (nearestMounted.stateNode.current.memoizedState.isDehydrated)
+                return 3 === nearestMounted.tag ? nearestMounted.stateNode.containerInfo : null;
+              targetNode = null;
+            } else nearestMounted !== targetNode && (targetNode = null);
+          }
+        }
+        return_targetInst = targetNode;
+        return null;
+      }
+      function getEventPriority(domEventName) {
+        switch (domEventName) {
+          case "beforetoggle":
+          case "cancel":
+          case "click":
+          case "close":
+          case "contextmenu":
+          case "copy":
+          case "cut":
+          case "auxclick":
+          case "dblclick":
+          case "dragend":
+          case "dragstart":
+          case "drop":
+          case "focusin":
+          case "focusout":
+          case "input":
+          case "invalid":
+          case "keydown":
+          case "keypress":
+          case "keyup":
+          case "mousedown":
+          case "mouseup":
+          case "paste":
+          case "pause":
+          case "play":
+          case "pointercancel":
+          case "pointerdown":
+          case "pointerup":
+          case "ratechange":
+          case "reset":
+          case "resize":
+          case "seeked":
+          case "submit":
+          case "toggle":
+          case "touchcancel":
+          case "touchend":
+          case "touchstart":
+          case "volumechange":
+          case "change":
+          case "selectionchange":
+          case "textInput":
+          case "compositionstart":
+          case "compositionend":
+          case "compositionupdate":
+          case "beforeblur":
+          case "afterblur":
+          case "beforeinput":
+          case "blur":
+          case "fullscreenchange":
+          case "focus":
+          case "hashchange":
+          case "popstate":
+          case "select":
+          case "selectstart":
+            return 2;
+          case "drag":
+          case "dragenter":
+          case "dragexit":
+          case "dragleave":
+          case "dragover":
+          case "mousemove":
+          case "mouseout":
+          case "mouseover":
+          case "pointermove":
+          case "pointerout":
+          case "pointerover":
+          case "scroll":
+          case "touchmove":
+          case "wheel":
+          case "mouseenter":
+          case "mouseleave":
+          case "pointerenter":
+          case "pointerleave":
+            return 8;
+          case "message":
+            switch (getCurrentPriorityLevel()) {
+              case ImmediatePriority:
+                return 2;
+              case UserBlockingPriority:
+                return 8;
+              case NormalPriority$1:
+              case LowPriority:
+                return 32;
+              case IdlePriority:
+                return 268435456;
+              default:
+                return 32;
+            }
+          default:
+            return 32;
+        }
+      }
+      var hasScheduledReplayAttempt = false;
+      var queuedFocus = null;
+      var queuedDrag = null;
+      var queuedMouse = null;
+      var queuedPointers = /* @__PURE__ */ new Map();
+      var queuedPointerCaptures = /* @__PURE__ */ new Map();
+      var queuedExplicitHydrationTargets = [];
+      var discreteReplayableEvents = "mousedown mouseup touchcancel touchend touchstart auxclick dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend compositionstart keydown keypress keyup input textInput copy cut paste click change contextmenu reset".split(
+        " "
+      );
+      function clearIfContinuousEvent(domEventName, nativeEvent) {
+        switch (domEventName) {
+          case "focusin":
+          case "focusout":
+            queuedFocus = null;
+            break;
+          case "dragenter":
+          case "dragleave":
+            queuedDrag = null;
+            break;
+          case "mouseover":
+          case "mouseout":
+            queuedMouse = null;
+            break;
+          case "pointerover":
+          case "pointerout":
+            queuedPointers.delete(nativeEvent.pointerId);
+            break;
+          case "gotpointercapture":
+          case "lostpointercapture":
+            queuedPointerCaptures.delete(nativeEvent.pointerId);
+        }
+      }
+      function accumulateOrCreateContinuousQueuedReplayableEvent(existingQueuedEvent, blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent) {
+        if (null === existingQueuedEvent || existingQueuedEvent.nativeEvent !== nativeEvent)
+          return existingQueuedEvent = {
+            blockedOn,
+            domEventName,
+            eventSystemFlags,
+            nativeEvent,
+            targetContainers: [targetContainer]
+          }, null !== blockedOn && (blockedOn = getInstanceFromNode(blockedOn), null !== blockedOn && attemptContinuousHydration(blockedOn)), existingQueuedEvent;
+        existingQueuedEvent.eventSystemFlags |= eventSystemFlags;
+        blockedOn = existingQueuedEvent.targetContainers;
+        null !== targetContainer && -1 === blockedOn.indexOf(targetContainer) && blockedOn.push(targetContainer);
+        return existingQueuedEvent;
+      }
+      function queueIfContinuousEvent(blockedOn, domEventName, eventSystemFlags, targetContainer, nativeEvent) {
+        switch (domEventName) {
+          case "focusin":
+            return queuedFocus = accumulateOrCreateContinuousQueuedReplayableEvent(
+              queuedFocus,
+              blockedOn,
+              domEventName,
+              eventSystemFlags,
+              targetContainer,
+              nativeEvent
+            ), true;
+          case "dragenter":
+            return queuedDrag = accumulateOrCreateContinuousQueuedReplayableEvent(
+              queuedDrag,
+              blockedOn,
+              domEventName,
+              eventSystemFlags,
+              targetContainer,
+              nativeEvent
+            ), true;
+          case "mouseover":
+            return queuedMouse = accumulateOrCreateContinuousQueuedReplayableEvent(
+              queuedMouse,
+              blockedOn,
+              domEventName,
+              eventSystemFlags,
+              targetContainer,
+              nativeEvent
+            ), true;
+          case "pointerover":
+            var pointerId = nativeEvent.pointerId;
+            queuedPointers.set(
+              pointerId,
+              accumulateOrCreateContinuousQueuedReplayableEvent(
+                queuedPointers.get(pointerId) || null,
+                blockedOn,
+                domEventName,
+                eventSystemFlags,
+                targetContainer,
+                nativeEvent
+              )
+            );
+            return true;
+          case "gotpointercapture":
+            return pointerId = nativeEvent.pointerId, queuedPointerCaptures.set(
+              pointerId,
+              accumulateOrCreateContinuousQueuedReplayableEvent(
+                queuedPointerCaptures.get(pointerId) || null,
+                blockedOn,
+                domEventName,
+                eventSystemFlags,
+                targetContainer,
+                nativeEvent
+              )
+            ), true;
+        }
+        return false;
+      }
+      function attemptExplicitHydrationTarget(queuedTarget) {
+        var targetInst = getClosestInstanceFromNode(queuedTarget.target);
+        if (null !== targetInst) {
+          var nearestMounted = getNearestMountedFiber(targetInst);
+          if (null !== nearestMounted) {
+            if (targetInst = nearestMounted.tag, 13 === targetInst) {
+              if (targetInst = getSuspenseInstanceFromFiber(nearestMounted), null !== targetInst) {
+                queuedTarget.blockedOn = targetInst;
+                runWithPriority(queuedTarget.priority, function() {
+                  attemptHydrationAtCurrentPriority(nearestMounted);
+                });
+                return;
+              }
+            } else if (31 === targetInst) {
+              if (targetInst = getActivityInstanceFromFiber(nearestMounted), null !== targetInst) {
+                queuedTarget.blockedOn = targetInst;
+                runWithPriority(queuedTarget.priority, function() {
+                  attemptHydrationAtCurrentPriority(nearestMounted);
+                });
+                return;
+              }
+            } else if (3 === targetInst && nearestMounted.stateNode.current.memoizedState.isDehydrated) {
+              queuedTarget.blockedOn = 3 === nearestMounted.tag ? nearestMounted.stateNode.containerInfo : null;
+              return;
+            }
+          }
+        }
+        queuedTarget.blockedOn = null;
+      }
+      function attemptReplayContinuousQueuedEvent(queuedEvent) {
+        if (null !== queuedEvent.blockedOn) return false;
+        for (var targetContainers = queuedEvent.targetContainers; 0 < targetContainers.length; ) {
+          var nextBlockedOn = findInstanceBlockingEvent(queuedEvent.nativeEvent);
+          if (null === nextBlockedOn) {
+            nextBlockedOn = queuedEvent.nativeEvent;
+            var nativeEventClone = new nextBlockedOn.constructor(
+              nextBlockedOn.type,
+              nextBlockedOn
+            );
+            currentReplayingEvent = nativeEventClone;
+            nextBlockedOn.target.dispatchEvent(nativeEventClone);
+            currentReplayingEvent = null;
+          } else
+            return targetContainers = getInstanceFromNode(nextBlockedOn), null !== targetContainers && attemptContinuousHydration(targetContainers), queuedEvent.blockedOn = nextBlockedOn, false;
+          targetContainers.shift();
+        }
+        return true;
+      }
+      function attemptReplayContinuousQueuedEventInMap(queuedEvent, key, map) {
+        attemptReplayContinuousQueuedEvent(queuedEvent) && map.delete(key);
+      }
+      function replayUnblockedEvents() {
+        hasScheduledReplayAttempt = false;
+        null !== queuedFocus && attemptReplayContinuousQueuedEvent(queuedFocus) && (queuedFocus = null);
+        null !== queuedDrag && attemptReplayContinuousQueuedEvent(queuedDrag) && (queuedDrag = null);
+        null !== queuedMouse && attemptReplayContinuousQueuedEvent(queuedMouse) && (queuedMouse = null);
+        queuedPointers.forEach(attemptReplayContinuousQueuedEventInMap);
+        queuedPointerCaptures.forEach(attemptReplayContinuousQueuedEventInMap);
+      }
+      function scheduleCallbackIfUnblocked(queuedEvent, unblocked) {
+        queuedEvent.blockedOn === unblocked && (queuedEvent.blockedOn = null, hasScheduledReplayAttempt || (hasScheduledReplayAttempt = true, Scheduler.unstable_scheduleCallback(
+          Scheduler.unstable_NormalPriority,
+          replayUnblockedEvents
+        )));
+      }
+      var lastScheduledReplayQueue = null;
+      function scheduleReplayQueueIfNeeded(formReplayingQueue) {
+        lastScheduledReplayQueue !== formReplayingQueue && (lastScheduledReplayQueue = formReplayingQueue, Scheduler.unstable_scheduleCallback(
+          Scheduler.unstable_NormalPriority,
+          function() {
+            lastScheduledReplayQueue === formReplayingQueue && (lastScheduledReplayQueue = null);
+            for (var i = 0; i < formReplayingQueue.length; i += 3) {
+              var form = formReplayingQueue[i], submitterOrAction = formReplayingQueue[i + 1], formData = formReplayingQueue[i + 2];
+              if ("function" !== typeof submitterOrAction)
+                if (null === findInstanceBlockingTarget(submitterOrAction || form))
+                  continue;
+                else break;
+              var formInst = getInstanceFromNode(form);
+              null !== formInst && (formReplayingQueue.splice(i, 3), i -= 3, startHostTransition(
+                formInst,
+                {
+                  pending: true,
+                  data: formData,
+                  method: form.method,
+                  action: submitterOrAction
+                },
+                submitterOrAction,
+                formData
+              ));
+            }
+          }
+        ));
+      }
+      function retryIfBlockedOn(unblocked) {
+        function unblock(queuedEvent) {
+          return scheduleCallbackIfUnblocked(queuedEvent, unblocked);
+        }
+        null !== queuedFocus && scheduleCallbackIfUnblocked(queuedFocus, unblocked);
+        null !== queuedDrag && scheduleCallbackIfUnblocked(queuedDrag, unblocked);
+        null !== queuedMouse && scheduleCallbackIfUnblocked(queuedMouse, unblocked);
+        queuedPointers.forEach(unblock);
+        queuedPointerCaptures.forEach(unblock);
+        for (var i = 0; i < queuedExplicitHydrationTargets.length; i++) {
+          var queuedTarget = queuedExplicitHydrationTargets[i];
+          queuedTarget.blockedOn === unblocked && (queuedTarget.blockedOn = null);
+        }
+        for (; 0 < queuedExplicitHydrationTargets.length && (i = queuedExplicitHydrationTargets[0], null === i.blockedOn); )
+          attemptExplicitHydrationTarget(i), null === i.blockedOn && queuedExplicitHydrationTargets.shift();
+        i = (unblocked.ownerDocument || unblocked).$$reactFormReplay;
+        if (null != i)
+          for (queuedTarget = 0; queuedTarget < i.length; queuedTarget += 3) {
+            var form = i[queuedTarget], submitterOrAction = i[queuedTarget + 1], formProps = form[internalPropsKey] || null;
+            if ("function" === typeof submitterOrAction)
+              formProps || scheduleReplayQueueIfNeeded(i);
+            else if (formProps) {
+              var action = null;
+              if (submitterOrAction && submitterOrAction.hasAttribute("formAction"))
+                if (form = submitterOrAction, formProps = submitterOrAction[internalPropsKey] || null)
+                  action = formProps.formAction;
+                else {
+                  if (null !== findInstanceBlockingTarget(form)) continue;
+                }
+              else action = formProps.action;
+              "function" === typeof action ? i[queuedTarget + 1] = action : (i.splice(queuedTarget, 3), queuedTarget -= 3);
+              scheduleReplayQueueIfNeeded(i);
+            }
+          }
+      }
+      function defaultOnDefaultTransitionIndicator() {
+        function handleNavigate(event) {
+          event.canIntercept && "react-transition" === event.info && event.intercept({
+            handler: function() {
+              return new Promise(function(resolve) {
+                return pendingResolve = resolve;
+              });
+            },
+            focusReset: "manual",
+            scroll: "manual"
+          });
+        }
+        function handleNavigateComplete() {
+          null !== pendingResolve && (pendingResolve(), pendingResolve = null);
+          isCancelled || setTimeout(startFakeNavigation, 20);
+        }
+        function startFakeNavigation() {
+          if (!isCancelled && !navigation.transition) {
+            var currentEntry = navigation.currentEntry;
+            currentEntry && null != currentEntry.url && navigation.navigate(currentEntry.url, {
+              state: currentEntry.getState(),
+              info: "react-transition",
+              history: "replace"
+            });
+          }
+        }
+        if ("object" === typeof navigation) {
+          var isCancelled = false, pendingResolve = null;
+          navigation.addEventListener("navigate", handleNavigate);
+          navigation.addEventListener("navigatesuccess", handleNavigateComplete);
+          navigation.addEventListener("navigateerror", handleNavigateComplete);
+          setTimeout(startFakeNavigation, 100);
+          return function() {
+            isCancelled = true;
+            navigation.removeEventListener("navigate", handleNavigate);
+            navigation.removeEventListener("navigatesuccess", handleNavigateComplete);
+            navigation.removeEventListener("navigateerror", handleNavigateComplete);
+            null !== pendingResolve && (pendingResolve(), pendingResolve = null);
+          };
+        }
+      }
+      function ReactDOMRoot(internalRoot) {
+        this._internalRoot = internalRoot;
+      }
+      ReactDOMHydrationRoot.prototype.render = ReactDOMRoot.prototype.render = function(children) {
+        var root2 = this._internalRoot;
+        if (null === root2) throw Error(formatProdErrorMessage(409));
+        var current = root2.current, lane = requestUpdateLane();
+        updateContainerImpl(current, lane, children, root2, null, null);
+      };
+      ReactDOMHydrationRoot.prototype.unmount = ReactDOMRoot.prototype.unmount = function() {
+        var root2 = this._internalRoot;
+        if (null !== root2) {
+          this._internalRoot = null;
+          var container = root2.containerInfo;
+          updateContainerImpl(root2.current, 2, null, root2, null, null);
+          flushSyncWork$1();
+          container[internalContainerInstanceKey] = null;
+        }
+      };
+      function ReactDOMHydrationRoot(internalRoot) {
+        this._internalRoot = internalRoot;
+      }
+      ReactDOMHydrationRoot.prototype.unstable_scheduleHydration = function(target) {
+        if (target) {
+          var updatePriority = resolveUpdatePriority();
+          target = { blockedOn: null, target, priority: updatePriority };
+          for (var i = 0; i < queuedExplicitHydrationTargets.length && 0 !== updatePriority && updatePriority < queuedExplicitHydrationTargets[i].priority; i++) ;
+          queuedExplicitHydrationTargets.splice(i, 0, target);
+          0 === i && attemptExplicitHydrationTarget(target);
+        }
+      };
+      var isomorphicReactPackageVersion$jscomp$inline_1840 = React36.version;
+      if ("19.2.8" !== isomorphicReactPackageVersion$jscomp$inline_1840)
+        throw Error(
+          formatProdErrorMessage(
+            527,
+            isomorphicReactPackageVersion$jscomp$inline_1840,
+            "19.2.8"
+          )
+        );
+      ReactDOMSharedInternals.findDOMNode = function(componentOrElement) {
+        var fiber = componentOrElement._reactInternals;
+        if (void 0 === fiber) {
+          if ("function" === typeof componentOrElement.render)
+            throw Error(formatProdErrorMessage(188));
+          componentOrElement = Object.keys(componentOrElement).join(",");
+          throw Error(formatProdErrorMessage(268, componentOrElement));
+        }
+        componentOrElement = findCurrentFiberUsingSlowPath(fiber);
+        componentOrElement = null !== componentOrElement ? findCurrentHostFiberImpl(componentOrElement) : null;
+        componentOrElement = null === componentOrElement ? null : componentOrElement.stateNode;
+        return componentOrElement;
+      };
+      var internals$jscomp$inline_2347 = {
+        bundleType: 0,
+        version: "19.2.8",
+        rendererPackageName: "react-dom",
+        currentDispatcherRef: ReactSharedInternals,
+        reconcilerVersion: "19.2.8"
+      };
+      if ("undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__) {
+        hook$jscomp$inline_2348 = __REACT_DEVTOOLS_GLOBAL_HOOK__;
+        if (!hook$jscomp$inline_2348.isDisabled && hook$jscomp$inline_2348.supportsFiber)
+          try {
+            rendererID = hook$jscomp$inline_2348.inject(
+              internals$jscomp$inline_2347
+            ), injectedHook = hook$jscomp$inline_2348;
+          } catch (err) {
+          }
+      }
+      var hook$jscomp$inline_2348;
+      exports.createRoot = function(container, options3) {
+        if (!isValidContainer(container)) throw Error(formatProdErrorMessage(299));
+        var isStrictMode = false, identifierPrefix = "", onUncaughtError = defaultOnUncaughtError, onCaughtError = defaultOnCaughtError, onRecoverableError = defaultOnRecoverableError;
+        null !== options3 && void 0 !== options3 && (true === options3.unstable_strictMode && (isStrictMode = true), void 0 !== options3.identifierPrefix && (identifierPrefix = options3.identifierPrefix), void 0 !== options3.onUncaughtError && (onUncaughtError = options3.onUncaughtError), void 0 !== options3.onCaughtError && (onCaughtError = options3.onCaughtError), void 0 !== options3.onRecoverableError && (onRecoverableError = options3.onRecoverableError));
+        options3 = createFiberRoot(
+          container,
+          1,
+          false,
+          null,
+          null,
+          isStrictMode,
+          identifierPrefix,
+          null,
+          onUncaughtError,
+          onCaughtError,
+          onRecoverableError,
+          defaultOnDefaultTransitionIndicator
+        );
+        container[internalContainerInstanceKey] = options3.current;
+        listenToAllSupportedEvents(container);
+        return new ReactDOMRoot(options3);
+      };
+      exports.hydrateRoot = function(container, initialChildren, options3) {
+        if (!isValidContainer(container)) throw Error(formatProdErrorMessage(299));
+        var isStrictMode = false, identifierPrefix = "", onUncaughtError = defaultOnUncaughtError, onCaughtError = defaultOnCaughtError, onRecoverableError = defaultOnRecoverableError, formState = null;
+        null !== options3 && void 0 !== options3 && (true === options3.unstable_strictMode && (isStrictMode = true), void 0 !== options3.identifierPrefix && (identifierPrefix = options3.identifierPrefix), void 0 !== options3.onUncaughtError && (onUncaughtError = options3.onUncaughtError), void 0 !== options3.onCaughtError && (onCaughtError = options3.onCaughtError), void 0 !== options3.onRecoverableError && (onRecoverableError = options3.onRecoverableError), void 0 !== options3.formState && (formState = options3.formState));
+        initialChildren = createFiberRoot(
+          container,
+          1,
+          true,
+          initialChildren,
+          null != options3 ? options3 : null,
+          isStrictMode,
+          identifierPrefix,
+          formState,
+          onUncaughtError,
+          onCaughtError,
+          onRecoverableError,
+          defaultOnDefaultTransitionIndicator
+        );
+        initialChildren.context = getContextForSubtree(null);
+        options3 = initialChildren.current;
+        isStrictMode = requestUpdateLane();
+        isStrictMode = getBumpedLaneForHydrationByLane(isStrictMode);
+        identifierPrefix = createUpdate(isStrictMode);
+        identifierPrefix.callback = null;
+        enqueueUpdate(options3, identifierPrefix, isStrictMode);
+        options3 = isStrictMode;
+        initialChildren.current.lanes = options3;
+        markRootUpdated$1(initialChildren, options3);
+        ensureRootIsScheduled(initialChildren);
+        container[internalContainerInstanceKey] = initialChildren.current;
+        listenToAllSupportedEvents(container);
+        return new ReactDOMHydrationRoot(initialChildren);
+      };
+      exports.version = "19.2.8";