openplanr 2.2640.8 → 2.2640.9

package/lib/host-packages/openai/openplanr/runtime/design/scripts/runtime/packages/design/templates/studio/studio.js.sources/07-react-dom-client-work-loop-scheduling.js

@@ -0,0 +1,1121 @@
+
+      var executionContext = 0;
+      var workInProgressRoot = null;
+      var workInProgress = null;
+      var workInProgressRootRenderLanes = 0;
+      var workInProgressSuspendedReason = 0;
+      var workInProgressThrownValue = null;
+      var workInProgressRootDidSkipSuspendedSiblings = false;
+      var workInProgressRootIsPrerendering = false;
+      var workInProgressRootDidAttachPingListener = false;
+      var entangledRenderLanes = 0;
+      var workInProgressRootExitStatus = 0;
+      var workInProgressRootSkippedLanes = 0;
+      var workInProgressRootInterleavedUpdatedLanes = 0;
+      var workInProgressRootPingedLanes = 0;
+      var workInProgressDeferredLane = 0;
+      var workInProgressSuspendedRetryLanes = 0;
+      var workInProgressRootConcurrentErrors = null;
+      var workInProgressRootRecoverableErrors = null;
+      var workInProgressRootDidIncludeRecursiveRenderUpdate = false;
+      var globalMostRecentFallbackTime = 0;
+      var globalMostRecentTransitionTime = 0;
+      var workInProgressRootRenderTargetTime = Infinity;
+      var workInProgressTransitions = null;
+      var legacyErrorBoundariesThatAlreadyFailed = null;
+      var pendingEffectsStatus = 0;
+      var pendingEffectsRoot = null;
+      var pendingFinishedWork = null;
+      var pendingEffectsLanes = 0;
+      var pendingEffectsRemainingLanes = 0;
+      var pendingPassiveTransitions = null;
+      var pendingRecoverableErrors = null;
+      var nestedUpdateCount = 0;
+      var rootWithNestedUpdates = null;
+      function requestUpdateLane() {
+        return 0 !== (executionContext & 2) && 0 !== workInProgressRootRenderLanes ? workInProgressRootRenderLanes & -workInProgressRootRenderLanes : null !== ReactSharedInternals.T ? requestTransitionLane() : resolveUpdatePriority();
+      }
+      function requestDeferredLane() {
+        if (0 === workInProgressDeferredLane)
+          if (0 === (workInProgressRootRenderLanes & 536870912) || isHydrating) {
+            var lane = nextTransitionDeferredLane;
+            nextTransitionDeferredLane <<= 1;
+            0 === (nextTransitionDeferredLane & 3932160) && (nextTransitionDeferredLane = 262144);
+            workInProgressDeferredLane = lane;
+          } else workInProgressDeferredLane = 536870912;
+        lane = suspenseHandlerStackCursor.current;
+        null !== lane && (lane.flags |= 32);
+        return workInProgressDeferredLane;
+      }
+      function scheduleUpdateOnFiber(root2, fiber, lane) {
+        if (root2 === workInProgressRoot && (2 === workInProgressSuspendedReason || 9 === workInProgressSuspendedReason) || null !== root2.cancelPendingCommit)
+          prepareFreshStack(root2, 0), markRootSuspended(
+            root2,
+            workInProgressRootRenderLanes,
+            workInProgressDeferredLane,
+            false
+          );
+        markRootUpdated$1(root2, lane);
+        if (0 === (executionContext & 2) || root2 !== workInProgressRoot)
+          root2 === workInProgressRoot && (0 === (executionContext & 2) && (workInProgressRootInterleavedUpdatedLanes |= lane), 4 === workInProgressRootExitStatus && markRootSuspended(
+            root2,
+            workInProgressRootRenderLanes,
+            workInProgressDeferredLane,
+            false
+          )), ensureRootIsScheduled(root2);
+      }
+      function performWorkOnRoot(root$jscomp$0, lanes, forceSync) {
+        if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(327));
+        var shouldTimeSlice = !forceSync && 0 === (lanes & 127) && 0 === (lanes & root$jscomp$0.expiredLanes) || checkIfRootIsPrerendering(root$jscomp$0, lanes), exitStatus = shouldTimeSlice ? renderRootConcurrent(root$jscomp$0, lanes) : renderRootSync(root$jscomp$0, lanes, true), renderWasConcurrent = shouldTimeSlice;
+        do {
+          if (0 === exitStatus) {
+            workInProgressRootIsPrerendering && !shouldTimeSlice && markRootSuspended(root$jscomp$0, lanes, 0, false);
+            break;
+          } else {
+            forceSync = root$jscomp$0.current.alternate;
+            if (renderWasConcurrent && !isRenderConsistentWithExternalStores(forceSync)) {
+              exitStatus = renderRootSync(root$jscomp$0, lanes, false);
+              renderWasConcurrent = false;
+              continue;
+            }
+            if (2 === exitStatus) {
+              renderWasConcurrent = lanes;
+              if (root$jscomp$0.errorRecoveryDisabledLanes & renderWasConcurrent)
+                var JSCompiler_inline_result = 0;
+              else
+                JSCompiler_inline_result = root$jscomp$0.pendingLanes & -536870913, JSCompiler_inline_result = 0 !== JSCompiler_inline_result ? JSCompiler_inline_result : JSCompiler_inline_result & 536870912 ? 536870912 : 0;
+              if (0 !== JSCompiler_inline_result) {
+                lanes = JSCompiler_inline_result;
+                a: {
+                  var root2 = root$jscomp$0;
+                  exitStatus = workInProgressRootConcurrentErrors;
+                  var wasRootDehydrated = root2.current.memoizedState.isDehydrated;
+                  wasRootDehydrated && (prepareFreshStack(root2, JSCompiler_inline_result).flags |= 256);
+                  JSCompiler_inline_result = renderRootSync(
+                    root2,
+                    JSCompiler_inline_result,
+                    false
+                  );
+                  if (2 !== JSCompiler_inline_result) {
+                    if (workInProgressRootDidAttachPingListener && !wasRootDehydrated) {
+                      root2.errorRecoveryDisabledLanes |= renderWasConcurrent;
+                      workInProgressRootInterleavedUpdatedLanes |= renderWasConcurrent;
+                      exitStatus = 4;
+                      break a;
+                    }
+                    renderWasConcurrent = workInProgressRootRecoverableErrors;
+                    workInProgressRootRecoverableErrors = exitStatus;
+                    null !== renderWasConcurrent && (null === workInProgressRootRecoverableErrors ? workInProgressRootRecoverableErrors = renderWasConcurrent : workInProgressRootRecoverableErrors.push.apply(
+                      workInProgressRootRecoverableErrors,
+                      renderWasConcurrent
+                    ));
+                  }
+                  exitStatus = JSCompiler_inline_result;
+                }
+                renderWasConcurrent = false;
+                if (2 !== exitStatus) continue;
+              }
+            }
+            if (1 === exitStatus) {
+              prepareFreshStack(root$jscomp$0, 0);
+              markRootSuspended(root$jscomp$0, lanes, 0, true);
+              break;
+            }
+            a: {
+              shouldTimeSlice = root$jscomp$0;
+              renderWasConcurrent = exitStatus;
+              switch (renderWasConcurrent) {
+                case 0:
+                case 1:
+                  throw Error(formatProdErrorMessage(345));
+                case 4:
+                  if ((lanes & 4194048) !== lanes) break;
+                case 6:
+                  markRootSuspended(
+                    shouldTimeSlice,
+                    lanes,
+                    workInProgressDeferredLane,
+                    !workInProgressRootDidSkipSuspendedSiblings
+                  );
+                  break a;
+                case 2:
+                  workInProgressRootRecoverableErrors = null;
+                  break;
+                case 3:
+                case 5:
+                  break;
+                default:
+                  throw Error(formatProdErrorMessage(329));
+              }
+              if ((lanes & 62914560) === lanes && (exitStatus = globalMostRecentFallbackTime + 300 - now(), 10 < exitStatus)) {
+                markRootSuspended(
+                  shouldTimeSlice,
+                  lanes,
+                  workInProgressDeferredLane,
+                  !workInProgressRootDidSkipSuspendedSiblings
+                );
+                if (0 !== getNextLanes(shouldTimeSlice, 0, true)) break a;
+                pendingEffectsLanes = lanes;
+                shouldTimeSlice.timeoutHandle = scheduleTimeout(
+                  commitRootWhenReady.bind(
+                    null,
+                    shouldTimeSlice,
+                    forceSync,
+                    workInProgressRootRecoverableErrors,
+                    workInProgressTransitions,
+                    workInProgressRootDidIncludeRecursiveRenderUpdate,
+                    lanes,
+                    workInProgressDeferredLane,
+                    workInProgressRootInterleavedUpdatedLanes,
+                    workInProgressSuspendedRetryLanes,
+                    workInProgressRootDidSkipSuspendedSiblings,
+                    renderWasConcurrent,
+                    "Throttled",
+                    -0,
+                    0
+                  ),
+                  exitStatus
+                );
+                break a;
+              }
+              commitRootWhenReady(
+                shouldTimeSlice,
+                forceSync,
+                workInProgressRootRecoverableErrors,
+                workInProgressTransitions,
+                workInProgressRootDidIncludeRecursiveRenderUpdate,
+                lanes,
+                workInProgressDeferredLane,
+                workInProgressRootInterleavedUpdatedLanes,
+                workInProgressSuspendedRetryLanes,
+                workInProgressRootDidSkipSuspendedSiblings,
+                renderWasConcurrent,
+                null,
+                -0,
+                0
+              );
+            }
+          }
+          break;
+        } while (1);
+        ensureRootIsScheduled(root$jscomp$0);
+      }
+      function commitRootWhenReady(root2, finishedWork, recoverableErrors, transitions, didIncludeRenderPhaseUpdate, lanes, spawnedLane, updatedLanes, suspendedRetryLanes, didSkipSuspendedSiblings, exitStatus, suspendedCommitReason, completedRenderStartTime, completedRenderEndTime) {
+        root2.timeoutHandle = -1;
+        suspendedCommitReason = finishedWork.subtreeFlags;
+        if (suspendedCommitReason & 8192 || 16785408 === (suspendedCommitReason & 16785408)) {
+          suspendedCommitReason = {
+            stylesheets: null,
+            count: 0,
+            imgCount: 0,
+            imgBytes: 0,
+            suspenseyImages: [],
+            waitingForImages: true,
+            waitingForViewTransition: false,
+            unsuspend: noop$1
+          };
+          accumulateSuspenseyCommitOnFiber(
+            finishedWork,
+            lanes,
+            suspendedCommitReason
+          );
+          var timeoutOffset = (lanes & 62914560) === lanes ? globalMostRecentFallbackTime - now() : (lanes & 4194048) === lanes ? globalMostRecentTransitionTime - now() : 0;
+          timeoutOffset = waitForCommitToBeReady(
+            suspendedCommitReason,
+            timeoutOffset
+          );
+          if (null !== timeoutOffset) {
+            pendingEffectsLanes = lanes;
+            root2.cancelPendingCommit = timeoutOffset(
+              commitRoot.bind(
+                null,
+                root2,
+                finishedWork,
+                lanes,
+                recoverableErrors,
+                transitions,
+                didIncludeRenderPhaseUpdate,
+                spawnedLane,
+                updatedLanes,
+                suspendedRetryLanes,
+                exitStatus,
+                suspendedCommitReason,
+                null,
+                completedRenderStartTime,
+                completedRenderEndTime
+              )
+            );
+            markRootSuspended(root2, lanes, spawnedLane, !didSkipSuspendedSiblings);
+            return;
+          }
+        }
+        commitRoot(
+          root2,
+          finishedWork,
+          lanes,
+          recoverableErrors,
+          transitions,
+          didIncludeRenderPhaseUpdate,
+          spawnedLane,
+          updatedLanes,
+          suspendedRetryLanes
+        );
+      }
+      function isRenderConsistentWithExternalStores(finishedWork) {
+        for (var node = finishedWork; ; ) {
+          var tag = node.tag;
+          if ((0 === tag || 11 === tag || 15 === tag) && node.flags & 16384 && (tag = node.updateQueue, null !== tag && (tag = tag.stores, null !== tag)))
+            for (var i = 0; i < tag.length; i++) {
+              var check = tag[i], getSnapshot = check.getSnapshot;
+              check = check.value;
+              try {
+                if (!objectIs(getSnapshot(), check)) return false;
+              } catch (error) {
+                return false;
+              }
+            }
+          tag = node.child;
+          if (node.subtreeFlags & 16384 && null !== tag)
+            tag.return = node, node = tag;
+          else {
+            if (node === finishedWork) break;
+            for (; null === node.sibling; ) {
+              if (null === node.return || node.return === finishedWork) return true;
+              node = node.return;
+            }
+            node.sibling.return = node.return;
+            node = node.sibling;
+          }
+        }
+        return true;
+      }
+      function markRootSuspended(root2, suspendedLanes, spawnedLane, didAttemptEntireTree) {
+        suspendedLanes &= ~workInProgressRootPingedLanes;
+        suspendedLanes &= ~workInProgressRootInterleavedUpdatedLanes;
+        root2.suspendedLanes |= suspendedLanes;
+        root2.pingedLanes &= ~suspendedLanes;
+        didAttemptEntireTree && (root2.warmLanes |= suspendedLanes);
+        didAttemptEntireTree = root2.expirationTimes;
+        for (var lanes = suspendedLanes; 0 < lanes; ) {
+          var index$6 = 31 - clz32(lanes), lane = 1 << index$6;
+          didAttemptEntireTree[index$6] = -1;
+          lanes &= ~lane;
+        }
+        0 !== spawnedLane && markSpawnedDeferredLane(root2, spawnedLane, suspendedLanes);
+      }
+      function flushSyncWork$1() {
+        return 0 === (executionContext & 6) ? (flushSyncWorkAcrossRoots_impl(0, false), false) : true;
+      }
+      function resetWorkInProgressStack() {
+        if (null !== workInProgress) {
+          if (0 === workInProgressSuspendedReason)
+            var interruptedWork = workInProgress.return;
+          else
+            interruptedWork = workInProgress, lastContextDependency = currentlyRenderingFiber$1 = null, resetHooksOnUnwind(interruptedWork), thenableState$1 = null, thenableIndexCounter$1 = 0, interruptedWork = workInProgress;
+          for (; null !== interruptedWork; )
+            unwindInterruptedWork(interruptedWork.alternate, interruptedWork), interruptedWork = interruptedWork.return;
+          workInProgress = null;
+        }
+      }
+      function prepareFreshStack(root2, lanes) {
+        var timeoutHandle = root2.timeoutHandle;
+        -1 !== timeoutHandle && (root2.timeoutHandle = -1, cancelTimeout(timeoutHandle));
+        timeoutHandle = root2.cancelPendingCommit;
+        null !== timeoutHandle && (root2.cancelPendingCommit = null, timeoutHandle());
+        pendingEffectsLanes = 0;
+        resetWorkInProgressStack();
+        workInProgressRoot = root2;
+        workInProgress = timeoutHandle = createWorkInProgress(root2.current, null);
+        workInProgressRootRenderLanes = lanes;
+        workInProgressSuspendedReason = 0;
+        workInProgressThrownValue = null;
+        workInProgressRootDidSkipSuspendedSiblings = false;
+        workInProgressRootIsPrerendering = checkIfRootIsPrerendering(root2, lanes);
+        workInProgressRootDidAttachPingListener = false;
+        workInProgressSuspendedRetryLanes = workInProgressDeferredLane = workInProgressRootPingedLanes = workInProgressRootInterleavedUpdatedLanes = workInProgressRootSkippedLanes = workInProgressRootExitStatus = 0;
+        workInProgressRootRecoverableErrors = workInProgressRootConcurrentErrors = null;
+        workInProgressRootDidIncludeRecursiveRenderUpdate = false;
+        0 !== (lanes & 8) && (lanes |= lanes & 32);
+        var allEntangledLanes = root2.entangledLanes;
+        if (0 !== allEntangledLanes)
+          for (root2 = root2.entanglements, allEntangledLanes &= lanes; 0 < allEntangledLanes; ) {
+            var index$4 = 31 - clz32(allEntangledLanes), lane = 1 << index$4;
+            lanes |= root2[index$4];
+            allEntangledLanes &= ~lane;
+          }
+        entangledRenderLanes = lanes;
+        finishQueueingConcurrentUpdates();
+        return timeoutHandle;
+      }
+      function handleThrow(root2, thrownValue) {
+        currentlyRenderingFiber = null;
+        ReactSharedInternals.H = ContextOnlyDispatcher;
+        thrownValue === SuspenseException || thrownValue === SuspenseActionException ? (thrownValue = getSuspendedThenable(), workInProgressSuspendedReason = 3) : thrownValue === SuspenseyCommitException ? (thrownValue = getSuspendedThenable(), workInProgressSuspendedReason = 4) : workInProgressSuspendedReason = thrownValue === SelectiveHydrationException ? 8 : null !== thrownValue && "object" === typeof thrownValue && "function" === typeof thrownValue.then ? 6 : 1;
+        workInProgressThrownValue = thrownValue;
+        null === workInProgress && (workInProgressRootExitStatus = 1, logUncaughtError(
+          root2,
+          createCapturedValueAtFiber(thrownValue, root2.current)
+        ));
+      }
+      function shouldRemainOnPreviousScreen() {
+        var handler = suspenseHandlerStackCursor.current;
+        return null === handler ? true : (workInProgressRootRenderLanes & 4194048) === workInProgressRootRenderLanes ? null === shellBoundary ? true : false : (workInProgressRootRenderLanes & 62914560) === workInProgressRootRenderLanes || 0 !== (workInProgressRootRenderLanes & 536870912) ? handler === shellBoundary : false;
+      }
+      function pushDispatcher() {
+        var prevDispatcher = ReactSharedInternals.H;
+        ReactSharedInternals.H = ContextOnlyDispatcher;
+        return null === prevDispatcher ? ContextOnlyDispatcher : prevDispatcher;
+      }
+      function pushAsyncDispatcher() {
+        var prevAsyncDispatcher = ReactSharedInternals.A;
+        ReactSharedInternals.A = DefaultAsyncDispatcher;
+        return prevAsyncDispatcher;
+      }
+      function renderDidSuspendDelayIfPossible() {
+        workInProgressRootExitStatus = 4;
+        workInProgressRootDidSkipSuspendedSiblings || (workInProgressRootRenderLanes & 4194048) !== workInProgressRootRenderLanes && null !== suspenseHandlerStackCursor.current || (workInProgressRootIsPrerendering = true);
+        0 === (workInProgressRootSkippedLanes & 134217727) && 0 === (workInProgressRootInterleavedUpdatedLanes & 134217727) || null === workInProgressRoot || markRootSuspended(
+          workInProgressRoot,
+          workInProgressRootRenderLanes,
+          workInProgressDeferredLane,
+          false
+        );
+      }
+      function renderRootSync(root2, lanes, shouldYieldForPrerendering) {
+        var prevExecutionContext = executionContext;
+        executionContext |= 2;
+        var prevDispatcher = pushDispatcher(), prevAsyncDispatcher = pushAsyncDispatcher();
+        if (workInProgressRoot !== root2 || workInProgressRootRenderLanes !== lanes)
+          workInProgressTransitions = null, prepareFreshStack(root2, lanes);
+        lanes = false;
+        var exitStatus = workInProgressRootExitStatus;
+        a: do
+          try {
+            if (0 !== workInProgressSuspendedReason && null !== workInProgress) {
+              var unitOfWork = workInProgress, thrownValue = workInProgressThrownValue;
+              switch (workInProgressSuspendedReason) {
+                case 8:
+                  resetWorkInProgressStack();
+                  exitStatus = 6;
+                  break a;
+                case 3:
+                case 2:
+                case 9:
+                case 6:
+                  null === suspenseHandlerStackCursor.current && (lanes = true);
+                  var reason = workInProgressSuspendedReason;
+                  workInProgressSuspendedReason = 0;
+                  workInProgressThrownValue = null;
+                  throwAndUnwindWorkLoop(root2, unitOfWork, thrownValue, reason);
+                  if (shouldYieldForPrerendering && workInProgressRootIsPrerendering) {
+                    exitStatus = 0;
+                    break a;
+                  }
+                  break;
+                default:
+                  reason = workInProgressSuspendedReason, workInProgressSuspendedReason = 0, workInProgressThrownValue = null, throwAndUnwindWorkLoop(root2, unitOfWork, thrownValue, reason);
+              }
+            }
+            workLoopSync();
+            exitStatus = workInProgressRootExitStatus;
+            break;
+          } catch (thrownValue$165) {
+            handleThrow(root2, thrownValue$165);
+          }
+        while (1);
+        lanes && root2.shellSuspendCounter++;
+        lastContextDependency = currentlyRenderingFiber$1 = null;
+        executionContext = prevExecutionContext;
+        ReactSharedInternals.H = prevDispatcher;
+        ReactSharedInternals.A = prevAsyncDispatcher;
+        null === workInProgress && (workInProgressRoot = null, workInProgressRootRenderLanes = 0, finishQueueingConcurrentUpdates());
+        return exitStatus;
+      }
+      function workLoopSync() {
+        for (; null !== workInProgress; ) performUnitOfWork(workInProgress);
+      }
+      function renderRootConcurrent(root2, lanes) {
+        var prevExecutionContext = executionContext;
+        executionContext |= 2;
+        var prevDispatcher = pushDispatcher(), prevAsyncDispatcher = pushAsyncDispatcher();
+        workInProgressRoot !== root2 || workInProgressRootRenderLanes !== lanes ? (workInProgressTransitions = null, workInProgressRootRenderTargetTime = now() + 500, prepareFreshStack(root2, lanes)) : workInProgressRootIsPrerendering = checkIfRootIsPrerendering(
+          root2,
+          lanes
+        );
+        a: do
+          try {
+            if (0 !== workInProgressSuspendedReason && null !== workInProgress) {
+              lanes = workInProgress;
+              var thrownValue = workInProgressThrownValue;
+              b: switch (workInProgressSuspendedReason) {
+                case 1:
+                  workInProgressSuspendedReason = 0;
+                  workInProgressThrownValue = null;
+                  throwAndUnwindWorkLoop(root2, lanes, thrownValue, 1);
+                  break;
+                case 2:
+                case 9:
+                  if (isThenableResolved(thrownValue)) {
+                    workInProgressSuspendedReason = 0;
+                    workInProgressThrownValue = null;
+                    replaySuspendedUnitOfWork(lanes);
+                    break;
+                  }
+                  lanes = function() {
+                    2 !== workInProgressSuspendedReason && 9 !== workInProgressSuspendedReason || workInProgressRoot !== root2 || (workInProgressSuspendedReason = 7);
+                    ensureRootIsScheduled(root2);
+                  };
+                  thrownValue.then(lanes, lanes);
+                  break a;
+                case 3:
+                  workInProgressSuspendedReason = 7;
+                  break a;
+                case 4:
+                  workInProgressSuspendedReason = 5;
+                  break a;
+                case 7:
+                  isThenableResolved(thrownValue) ? (workInProgressSuspendedReason = 0, workInProgressThrownValue = null, replaySuspendedUnitOfWork(lanes)) : (workInProgressSuspendedReason = 0, workInProgressThrownValue = null, throwAndUnwindWorkLoop(root2, lanes, thrownValue, 7));
+                  break;
+                case 5:
+                  var resource = null;
+                  switch (workInProgress.tag) {
+                    case 26:
+                      resource = workInProgress.memoizedState;
+                    case 5:
+                    case 27:
+                      var hostFiber = workInProgress;
+                      if (resource ? preloadResource(resource) : hostFiber.stateNode.complete) {
+                        workInProgressSuspendedReason = 0;
+                        workInProgressThrownValue = null;
+                        var sibling = hostFiber.sibling;
+                        if (null !== sibling) workInProgress = sibling;
+                        else {
+                          var returnFiber = hostFiber.return;
+                          null !== returnFiber ? (workInProgress = returnFiber, completeUnitOfWork(returnFiber)) : workInProgress = null;
+                        }
+                        break b;
+                      }
+                  }
+                  workInProgressSuspendedReason = 0;
+                  workInProgressThrownValue = null;
+                  throwAndUnwindWorkLoop(root2, lanes, thrownValue, 5);
+                  break;
+                case 6:
+                  workInProgressSuspendedReason = 0;
+                  workInProgressThrownValue = null;
+                  throwAndUnwindWorkLoop(root2, lanes, thrownValue, 6);
+                  break;
+                case 8:
+                  resetWorkInProgressStack();
+                  workInProgressRootExitStatus = 6;
+                  break a;
+                default:
+                  throw Error(formatProdErrorMessage(462));
+              }
+            }
+            workLoopConcurrentByScheduler();
+            break;
+          } catch (thrownValue$167) {
+            handleThrow(root2, thrownValue$167);
+          }
+        while (1);
+        lastContextDependency = currentlyRenderingFiber$1 = null;
+        ReactSharedInternals.H = prevDispatcher;
+        ReactSharedInternals.A = prevAsyncDispatcher;
+        executionContext = prevExecutionContext;
+        if (null !== workInProgress) return 0;
+        workInProgressRoot = null;
+        workInProgressRootRenderLanes = 0;
+        finishQueueingConcurrentUpdates();
+        return workInProgressRootExitStatus;
+      }
+      function workLoopConcurrentByScheduler() {
+        for (; null !== workInProgress && !shouldYield(); )
+          performUnitOfWork(workInProgress);
+      }
+      function performUnitOfWork(unitOfWork) {
+        var next = beginWork(unitOfWork.alternate, unitOfWork, entangledRenderLanes);
+        unitOfWork.memoizedProps = unitOfWork.pendingProps;
+        null === next ? completeUnitOfWork(unitOfWork) : workInProgress = next;
+      }
+      function replaySuspendedUnitOfWork(unitOfWork) {
+        var next = unitOfWork;
+        var current = next.alternate;
+        switch (next.tag) {
+          case 15:
+          case 0:
+            next = replayFunctionComponent(
+              current,
+              next,
+              next.pendingProps,
+              next.type,
+              void 0,
+              workInProgressRootRenderLanes
+            );
+            break;
+          case 11:
+            next = replayFunctionComponent(
+              current,
+              next,
+              next.pendingProps,
+              next.type.render,
+              next.ref,
+              workInProgressRootRenderLanes
+            );
+            break;
+          case 5:
+            resetHooksOnUnwind(next);
+          default:
+            unwindInterruptedWork(current, next), next = workInProgress = resetWorkInProgress(next, entangledRenderLanes), next = beginWork(current, next, entangledRenderLanes);
+        }
+        unitOfWork.memoizedProps = unitOfWork.pendingProps;
+        null === next ? completeUnitOfWork(unitOfWork) : workInProgress = next;
+      }
+      function throwAndUnwindWorkLoop(root2, unitOfWork, thrownValue, suspendedReason) {
+        lastContextDependency = currentlyRenderingFiber$1 = null;
+        resetHooksOnUnwind(unitOfWork);
+        thenableState$1 = null;
+        thenableIndexCounter$1 = 0;
+        var returnFiber = unitOfWork.return;
+        try {
+          if (throwException(
+            root2,
+            returnFiber,
+            unitOfWork,
+            thrownValue,
+            workInProgressRootRenderLanes
+          )) {
+            workInProgressRootExitStatus = 1;
+            logUncaughtError(
+              root2,
+              createCapturedValueAtFiber(thrownValue, root2.current)
+            );
+            workInProgress = null;
+            return;
+          }
+        } catch (error) {
+          if (null !== returnFiber) throw workInProgress = returnFiber, error;
+          workInProgressRootExitStatus = 1;
+          logUncaughtError(
+            root2,
+            createCapturedValueAtFiber(thrownValue, root2.current)
+          );
+          workInProgress = null;
+          return;
+        }
+        if (unitOfWork.flags & 32768) {
+          if (isHydrating || 1 === suspendedReason) root2 = true;
+          else if (workInProgressRootIsPrerendering || 0 !== (workInProgressRootRenderLanes & 536870912))
+            root2 = false;
+          else if (workInProgressRootDidSkipSuspendedSiblings = root2 = true, 2 === suspendedReason || 9 === suspendedReason || 3 === suspendedReason || 6 === suspendedReason)
+            suspendedReason = suspenseHandlerStackCursor.current, null !== suspendedReason && 13 === suspendedReason.tag && (suspendedReason.flags |= 16384);
+          unwindUnitOfWork(unitOfWork, root2);
+        } else completeUnitOfWork(unitOfWork);
+      }
+      function completeUnitOfWork(unitOfWork) {
+        var completedWork = unitOfWork;
+        do {
+          if (0 !== (completedWork.flags & 32768)) {
+            unwindUnitOfWork(
+              completedWork,
+              workInProgressRootDidSkipSuspendedSiblings
+            );
+            return;
+          }
+          unitOfWork = completedWork.return;
+          var next = completeWork(
+            completedWork.alternate,
+            completedWork,
+            entangledRenderLanes
+          );
+          if (null !== next) {
+            workInProgress = next;
+            return;
+          }
+          completedWork = completedWork.sibling;
+          if (null !== completedWork) {
+            workInProgress = completedWork;
+            return;
+          }
+          workInProgress = completedWork = unitOfWork;
+        } while (null !== completedWork);
+        0 === workInProgressRootExitStatus && (workInProgressRootExitStatus = 5);
+      }
+      function unwindUnitOfWork(unitOfWork, skipSiblings) {
+        do {
+          var next = unwindWork(unitOfWork.alternate, unitOfWork);
+          if (null !== next) {
+            next.flags &= 32767;
+            workInProgress = next;
+            return;
+          }
+          next = unitOfWork.return;
+          null !== next && (next.flags |= 32768, next.subtreeFlags = 0, next.deletions = null);
+          if (!skipSiblings && (unitOfWork = unitOfWork.sibling, null !== unitOfWork)) {
+            workInProgress = unitOfWork;
+            return;
+          }
+          workInProgress = unitOfWork = next;
+        } while (null !== unitOfWork);
+        workInProgressRootExitStatus = 6;
+        workInProgress = null;
+      }
+      function commitRoot(root2, finishedWork, lanes, recoverableErrors, transitions, didIncludeRenderPhaseUpdate, spawnedLane, updatedLanes, suspendedRetryLanes) {
+        root2.cancelPendingCommit = null;
+        do
+          flushPendingEffects();
+        while (0 !== pendingEffectsStatus);
+        if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(327));
+        if (null !== finishedWork) {
+          if (finishedWork === root2.current) throw Error(formatProdErrorMessage(177));
+          didIncludeRenderPhaseUpdate = finishedWork.lanes | finishedWork.childLanes;
+          didIncludeRenderPhaseUpdate |= concurrentlyUpdatedLanes;
+          markRootFinished(
+            root2,
+            lanes,
+            didIncludeRenderPhaseUpdate,
+            spawnedLane,
+            updatedLanes,
+            suspendedRetryLanes
+          );
+          root2 === workInProgressRoot && (workInProgress = workInProgressRoot = null, workInProgressRootRenderLanes = 0);
+          pendingFinishedWork = finishedWork;
+          pendingEffectsRoot = root2;
+          pendingEffectsLanes = lanes;
+          pendingEffectsRemainingLanes = didIncludeRenderPhaseUpdate;
+          pendingPassiveTransitions = transitions;
+          pendingRecoverableErrors = recoverableErrors;
+          0 !== (finishedWork.subtreeFlags & 10256) || 0 !== (finishedWork.flags & 10256) ? (root2.callbackNode = null, root2.callbackPriority = 0, scheduleCallback$1(NormalPriority$1, function() {
+            flushPassiveEffects();
+            return null;
+          })) : (root2.callbackNode = null, root2.callbackPriority = 0);
+          recoverableErrors = 0 !== (finishedWork.flags & 13878);
+          if (0 !== (finishedWork.subtreeFlags & 13878) || recoverableErrors) {
+            recoverableErrors = ReactSharedInternals.T;
+            ReactSharedInternals.T = null;
+            transitions = ReactDOMSharedInternals.p;
+            ReactDOMSharedInternals.p = 2;
+            spawnedLane = executionContext;
+            executionContext |= 4;
+            try {
+              commitBeforeMutationEffects(root2, finishedWork, lanes);
+            } finally {
+              executionContext = spawnedLane, ReactDOMSharedInternals.p = transitions, ReactSharedInternals.T = recoverableErrors;
+            }
+          }
+          pendingEffectsStatus = 1;
+          flushMutationEffects();
+          flushLayoutEffects();
+          flushSpawnedWork();
+        }
+      }
+      function flushMutationEffects() {
+        if (1 === pendingEffectsStatus) {
+          pendingEffectsStatus = 0;
+          var root2 = pendingEffectsRoot, finishedWork = pendingFinishedWork, rootMutationHasEffect = 0 !== (finishedWork.flags & 13878);
+          if (0 !== (finishedWork.subtreeFlags & 13878) || rootMutationHasEffect) {
+            rootMutationHasEffect = ReactSharedInternals.T;
+            ReactSharedInternals.T = null;
+            var previousPriority = ReactDOMSharedInternals.p;
+            ReactDOMSharedInternals.p = 2;
+            var prevExecutionContext = executionContext;
+            executionContext |= 4;
+            try {
+              commitMutationEffectsOnFiber(finishedWork, root2);
+              var priorSelectionInformation = selectionInformation, curFocusedElem = getActiveElementDeep(root2.containerInfo), priorFocusedElem = priorSelectionInformation.focusedElem, priorSelectionRange = priorSelectionInformation.selectionRange;
+              if (curFocusedElem !== priorFocusedElem && priorFocusedElem && priorFocusedElem.ownerDocument && containsNode(
+                priorFocusedElem.ownerDocument.documentElement,
+                priorFocusedElem
+              )) {
+                if (null !== priorSelectionRange && hasSelectionCapabilities(priorFocusedElem)) {
+                  var start2 = priorSelectionRange.start, end = priorSelectionRange.end;
+                  void 0 === end && (end = start2);
+                  if ("selectionStart" in priorFocusedElem)
+                    priorFocusedElem.selectionStart = start2, priorFocusedElem.selectionEnd = Math.min(
+                      end,
+                      priorFocusedElem.value.length
+                    );
+                  else {
+                    var doc = priorFocusedElem.ownerDocument || document, win = doc && doc.defaultView || window;
+                    if (win.getSelection) {
+                      var selection = win.getSelection(), length = priorFocusedElem.textContent.length, start$jscomp$0 = Math.min(priorSelectionRange.start, length), end$jscomp$0 = void 0 === priorSelectionRange.end ? start$jscomp$0 : Math.min(priorSelectionRange.end, length);
+                      !selection.extend && start$jscomp$0 > end$jscomp$0 && (curFocusedElem = end$jscomp$0, end$jscomp$0 = start$jscomp$0, start$jscomp$0 = curFocusedElem);
+                      var startMarker = getNodeForCharacterOffset(
+                        priorFocusedElem,
+                        start$jscomp$0
+                      ), endMarker = getNodeForCharacterOffset(
+                        priorFocusedElem,
+                        end$jscomp$0
+                      );
+                      if (startMarker && endMarker && (1 !== selection.rangeCount || selection.anchorNode !== startMarker.node || selection.anchorOffset !== startMarker.offset || selection.focusNode !== endMarker.node || selection.focusOffset !== endMarker.offset)) {
+                        var range = doc.createRange();
+                        range.setStart(startMarker.node, startMarker.offset);
+                        selection.removeAllRanges();
+                        start$jscomp$0 > end$jscomp$0 ? (selection.addRange(range), selection.extend(endMarker.node, endMarker.offset)) : (range.setEnd(endMarker.node, endMarker.offset), selection.addRange(range));
+                      }
+                    }
+                  }
+                }
+                doc = [];
+                for (selection = priorFocusedElem; selection = selection.parentNode; )
+                  1 === selection.nodeType && doc.push({
+                    element: selection,
+                    left: selection.scrollLeft,
+                    top: selection.scrollTop
+                  });
+                "function" === typeof priorFocusedElem.focus && priorFocusedElem.focus();
+                for (priorFocusedElem = 0; priorFocusedElem < doc.length; priorFocusedElem++) {
+                  var info = doc[priorFocusedElem];
+                  info.element.scrollLeft = info.left;
+                  info.element.scrollTop = info.top;
+                }
+              }
+              _enabled = !!eventsEnabled;
+              selectionInformation = eventsEnabled = null;
+            } finally {
+              executionContext = prevExecutionContext, ReactDOMSharedInternals.p = previousPriority, ReactSharedInternals.T = rootMutationHasEffect;
+            }
+          }
+          root2.current = finishedWork;
+          pendingEffectsStatus = 2;
+        }
+      }
+      function flushLayoutEffects() {
+        if (2 === pendingEffectsStatus) {
+          pendingEffectsStatus = 0;
+          var root2 = pendingEffectsRoot, finishedWork = pendingFinishedWork, rootHasLayoutEffect = 0 !== (finishedWork.flags & 8772);
+          if (0 !== (finishedWork.subtreeFlags & 8772) || rootHasLayoutEffect) {
+            rootHasLayoutEffect = ReactSharedInternals.T;
+            ReactSharedInternals.T = null;
+            var previousPriority = ReactDOMSharedInternals.p;
+            ReactDOMSharedInternals.p = 2;
+            var prevExecutionContext = executionContext;
+            executionContext |= 4;
+            try {
+              commitLayoutEffectOnFiber(root2, finishedWork.alternate, finishedWork);
+            } finally {
+              executionContext = prevExecutionContext, ReactDOMSharedInternals.p = previousPriority, ReactSharedInternals.T = rootHasLayoutEffect;
+            }
+          }
+          pendingEffectsStatus = 3;
+        }
+      }
+      function flushSpawnedWork() {
+        if (4 === pendingEffectsStatus || 3 === pendingEffectsStatus) {
+          pendingEffectsStatus = 0;
+          requestPaint();
+          var root2 = pendingEffectsRoot, finishedWork = pendingFinishedWork, lanes = pendingEffectsLanes, recoverableErrors = pendingRecoverableErrors;
+          0 !== (finishedWork.subtreeFlags & 10256) || 0 !== (finishedWork.flags & 10256) ? pendingEffectsStatus = 5 : (pendingEffectsStatus = 0, pendingFinishedWork = pendingEffectsRoot = null, releaseRootPooledCache(root2, root2.pendingLanes));
+          var remainingLanes = root2.pendingLanes;
+          0 === remainingLanes && (legacyErrorBoundariesThatAlreadyFailed = null);
+          lanesToEventPriority(lanes);
+          finishedWork = finishedWork.stateNode;
+          if (injectedHook && "function" === typeof injectedHook.onCommitFiberRoot)
+            try {
+              injectedHook.onCommitFiberRoot(
+                rendererID,
+                finishedWork,
+                void 0,
+                128 === (finishedWork.current.flags & 128)
+              );
+            } catch (err) {
+            }
+          if (null !== recoverableErrors) {
+            finishedWork = ReactSharedInternals.T;
+            remainingLanes = ReactDOMSharedInternals.p;
+            ReactDOMSharedInternals.p = 2;
+            ReactSharedInternals.T = null;
+            try {
+              for (var onRecoverableError = root2.onRecoverableError, i = 0; i < recoverableErrors.length; i++) {
+                var recoverableError = recoverableErrors[i];
+                onRecoverableError(recoverableError.value, {
+                  componentStack: recoverableError.stack
+                });
+              }
+            } finally {
+              ReactSharedInternals.T = finishedWork, ReactDOMSharedInternals.p = remainingLanes;
+            }
+          }
+          0 !== (pendingEffectsLanes & 3) && flushPendingEffects();
+          ensureRootIsScheduled(root2);
+          remainingLanes = root2.pendingLanes;
+          0 !== (lanes & 261930) && 0 !== (remainingLanes & 42) ? root2 === rootWithNestedUpdates ? nestedUpdateCount++ : (nestedUpdateCount = 0, rootWithNestedUpdates = root2) : nestedUpdateCount = 0;
+          flushSyncWorkAcrossRoots_impl(0, false);
+        }
+      }
+      function releaseRootPooledCache(root2, remainingLanes) {
+        0 === (root2.pooledCacheLanes &= remainingLanes) && (remainingLanes = root2.pooledCache, null != remainingLanes && (root2.pooledCache = null, releaseCache(remainingLanes)));
+      }
+      function flushPendingEffects() {
+        flushMutationEffects();
+        flushLayoutEffects();
+        flushSpawnedWork();
+        return flushPassiveEffects();
+      }
+      function flushPassiveEffects() {
+        if (5 !== pendingEffectsStatus) return false;
+        var root2 = pendingEffectsRoot, remainingLanes = pendingEffectsRemainingLanes;
+        pendingEffectsRemainingLanes = 0;
+        var renderPriority = lanesToEventPriority(pendingEffectsLanes), prevTransition = ReactSharedInternals.T, previousPriority = ReactDOMSharedInternals.p;
+        try {
+          ReactDOMSharedInternals.p = 32 > renderPriority ? 32 : renderPriority;
+          ReactSharedInternals.T = null;
+          renderPriority = pendingPassiveTransitions;
+          pendingPassiveTransitions = null;
+          var root$jscomp$0 = pendingEffectsRoot, lanes = pendingEffectsLanes;
+          pendingEffectsStatus = 0;
+          pendingFinishedWork = pendingEffectsRoot = null;
+          pendingEffectsLanes = 0;
+          if (0 !== (executionContext & 6)) throw Error(formatProdErrorMessage(331));
+          var prevExecutionContext = executionContext;
+          executionContext |= 4;
+          commitPassiveUnmountOnFiber(root$jscomp$0.current);
+          commitPassiveMountOnFiber(
+            root$jscomp$0,
+            root$jscomp$0.current,
+            lanes,
+            renderPriority
+          );
+          executionContext = prevExecutionContext;
+          flushSyncWorkAcrossRoots_impl(0, false);
+          if (injectedHook && "function" === typeof injectedHook.onPostCommitFiberRoot)
+            try {
+              injectedHook.onPostCommitFiberRoot(rendererID, root$jscomp$0);
+            } catch (err) {
+            }
+          return true;
+        } finally {
+          ReactDOMSharedInternals.p = previousPriority, ReactSharedInternals.T = prevTransition, releaseRootPooledCache(root2, remainingLanes);
+        }
+      }
+      function captureCommitPhaseErrorOnRoot(rootFiber, sourceFiber, error) {
+        sourceFiber = createCapturedValueAtFiber(error, sourceFiber);
+        sourceFiber = createRootErrorUpdate(rootFiber.stateNode, sourceFiber, 2);
+        rootFiber = enqueueUpdate(rootFiber, sourceFiber, 2);
+        null !== rootFiber && (markRootUpdated$1(rootFiber, 2), ensureRootIsScheduled(rootFiber));
+      }
+      function captureCommitPhaseError(sourceFiber, nearestMountedAncestor, error) {
+        if (3 === sourceFiber.tag)
+          captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error);
+        else
+          for (; null !== nearestMountedAncestor; ) {
+            if (3 === nearestMountedAncestor.tag) {
+              captureCommitPhaseErrorOnRoot(
+                nearestMountedAncestor,
+                sourceFiber,
+                error
+              );
+              break;
+            } else if (1 === nearestMountedAncestor.tag) {
+              var instance = nearestMountedAncestor.stateNode;
+              if ("function" === typeof nearestMountedAncestor.type.getDerivedStateFromError || "function" === typeof instance.componentDidCatch && (null === legacyErrorBoundariesThatAlreadyFailed || !legacyErrorBoundariesThatAlreadyFailed.has(instance))) {
+                sourceFiber = createCapturedValueAtFiber(error, sourceFiber);
+                error = createClassErrorUpdate(2);
+                instance = enqueueUpdate(nearestMountedAncestor, error, 2);
+                null !== instance && (initializeClassErrorUpdate(
+                  error,
+                  instance,
+                  nearestMountedAncestor,
+                  sourceFiber
+                ), markRootUpdated$1(instance, 2), ensureRootIsScheduled(instance));
+                break;
+              }
+            }
+            nearestMountedAncestor = nearestMountedAncestor.return;
+          }
+      }
+      function attachPingListener(root2, wakeable, lanes) {
+        var pingCache = root2.pingCache;
+        if (null === pingCache) {
+          pingCache = root2.pingCache = new PossiblyWeakMap();
+          var threadIDs = /* @__PURE__ */ new Set();
+          pingCache.set(wakeable, threadIDs);
+        } else
+          threadIDs = pingCache.get(wakeable), void 0 === threadIDs && (threadIDs = /* @__PURE__ */ new Set(), pingCache.set(wakeable, threadIDs));
+        threadIDs.has(lanes) || (workInProgressRootDidAttachPingListener = true, threadIDs.add(lanes), root2 = pingSuspendedRoot.bind(null, root2, wakeable, lanes), wakeable.then(root2, root2));
+      }
+      function pingSuspendedRoot(root2, wakeable, pingedLanes) {
+        var pingCache = root2.pingCache;
+        null !== pingCache && pingCache.delete(wakeable);
+        root2.pingedLanes |= root2.suspendedLanes & pingedLanes;
+        root2.warmLanes &= ~pingedLanes;
+        workInProgressRoot === root2 && (workInProgressRootRenderLanes & pingedLanes) === pingedLanes && (4 === workInProgressRootExitStatus || 3 === workInProgressRootExitStatus && (workInProgressRootRenderLanes & 62914560) === workInProgressRootRenderLanes && 300 > now() - globalMostRecentFallbackTime ? 0 === (executionContext & 2) && prepareFreshStack(root2, 0) : workInProgressRootPingedLanes |= pingedLanes, workInProgressSuspendedRetryLanes === workInProgressRootRenderLanes && (workInProgressSuspendedRetryLanes = 0));
+        ensureRootIsScheduled(root2);
+      }
+      function retryTimedOutBoundary(boundaryFiber, retryLane) {
+        0 === retryLane && (retryLane = claimNextRetryLane());
+        boundaryFiber = enqueueConcurrentRenderForLane(boundaryFiber, retryLane);
+        null !== boundaryFiber && (markRootUpdated$1(boundaryFiber, retryLane), ensureRootIsScheduled(boundaryFiber));
+      }
+      function retryDehydratedSuspenseBoundary(boundaryFiber) {
+        var suspenseState = boundaryFiber.memoizedState, retryLane = 0;
+        null !== suspenseState && (retryLane = suspenseState.retryLane);
+        retryTimedOutBoundary(boundaryFiber, retryLane);
+      }
+      function resolveRetryWakeable(boundaryFiber, wakeable) {
+        var retryLane = 0;
+        switch (boundaryFiber.tag) {
+          case 31:
+          case 13:
+            var retryCache = boundaryFiber.stateNode;
+            var suspenseState = boundaryFiber.memoizedState;
+            null !== suspenseState && (retryLane = suspenseState.retryLane);
+            break;
+          case 19:
+            retryCache = boundaryFiber.stateNode;
+            break;
+          case 22:
+            retryCache = boundaryFiber.stateNode._retryCache;
+            break;
+          default:
+            throw Error(formatProdErrorMessage(314));
+        }
+        null !== retryCache && retryCache.delete(wakeable);
+        retryTimedOutBoundary(boundaryFiber, retryLane);
+      }
+      function scheduleCallback$1(priorityLevel, callback) {
+        return scheduleCallback$3(priorityLevel, callback);
+      }
+      var firstScheduledRoot = null;
+      var lastScheduledRoot = null;
+      var didScheduleMicrotask = false;
+      var mightHavePendingSyncWork = false;
+      var isFlushingWork = false;
+      var currentEventTransitionLane = 0;
+      function ensureRootIsScheduled(root2) {
+        root2 !== lastScheduledRoot && null === root2.next && (null === lastScheduledRoot ? firstScheduledRoot = lastScheduledRoot = root2 : lastScheduledRoot = lastScheduledRoot.next = root2);
+        mightHavePendingSyncWork = true;
+        didScheduleMicrotask || (didScheduleMicrotask = true, scheduleImmediateRootScheduleTask());
+      }
+      function flushSyncWorkAcrossRoots_impl(syncTransitionLanes, onlyLegacy) {
+        if (!isFlushingWork && mightHavePendingSyncWork) {
+          isFlushingWork = true;
+          do {
+            var didPerformSomeWork = false;
+            for (var root$170 = firstScheduledRoot; null !== root$170; ) {
+              if (!onlyLegacy)
+                if (0 !== syncTransitionLanes) {
+                  var pendingLanes = root$170.pendingLanes;
+                  if (0 === pendingLanes) var JSCompiler_inline_result = 0;
+                  else {
+                    var suspendedLanes = root$170.suspendedLanes, pingedLanes = root$170.pingedLanes;
+                    JSCompiler_inline_result = (1 << 31 - clz32(42 | syncTransitionLanes) + 1) - 1;
+                    JSCompiler_inline_result &= pendingLanes & ~(suspendedLanes & ~pingedLanes);
+                    JSCompiler_inline_result = JSCompiler_inline_result & 201326741 ? JSCompiler_inline_result & 201326741 | 1 : JSCompiler_inline_result ? JSCompiler_inline_result | 2 : 0;
+                  }
+                  0 !== JSCompiler_inline_result && (didPerformSomeWork = true, performSyncWorkOnRoot(root$170, JSCompiler_inline_result));
+                } else
+                  JSCompiler_inline_result = workInProgressRootRenderLanes, JSCompiler_inline_result = getNextLanes(
+                    root$170,
+                    root$170 === workInProgressRoot ? JSCompiler_inline_result : 0,
+                    null !== root$170.cancelPendingCommit || -1 !== root$170.timeoutHandle
+                  ), 0 === (JSCompiler_inline_result & 3) || checkIfRootIsPrerendering(root$170, JSCompiler_inline_result) || (didPerformSomeWork = true, performSyncWorkOnRoot(root$170, JSCompiler_inline_result));
+              root$170 = root$170.next;
+            }
+          } while (didPerformSomeWork);
+          isFlushingWork = false;
+        }
+      }
+      function processRootScheduleInImmediateTask() {
+        processRootScheduleInMicrotask();
+      }
+      function processRootScheduleInMicrotask() {
+        mightHavePendingSyncWork = didScheduleMicrotask = false;
+        var syncTransitionLanes = 0;
+        0 !== currentEventTransitionLane && shouldAttemptEagerTransition() && (syncTransitionLanes = currentEventTransitionLane);
+        for (var currentTime = now(), prev = null, root2 = firstScheduledRoot; null !== root2; ) {
+          var next = root2.next, nextLanes = scheduleTaskForRootDuringMicrotask(root2, currentTime);
+          if (0 === nextLanes)
+            root2.next = null, null === prev ? firstScheduledRoot = next : prev.next = next, null === next && (lastScheduledRoot = prev);
+          else if (prev = root2, 0 !== syncTransitionLanes || 0 !== (nextLanes & 3))
+            mightHavePendingSyncWork = true;
+          root2 = next;
+        }
+        0 !== pendingEffectsStatus && 5 !== pendingEffectsStatus || flushSyncWorkAcrossRoots_impl(syncTransitionLanes, false);
+        0 !== currentEventTransitionLane && (currentEventTransitionLane = 0);
+      }
+      function scheduleTaskForRootDuringMicrotask(root2, currentTime) {
+        for (var suspendedLanes = root2.suspendedLanes, pingedLanes = root2.pingedLanes, expirationTimes = root2.expirationTimes, lanes = root2.pendingLanes & -62914561; 0 < lanes; ) {
+          var index$5 = 31 - clz32(lanes), lane = 1 << index$5, expirationTime = expirationTimes[index$5];
+          if (-1 === expirationTime) {
+            if (0 === (lane & suspendedLanes) || 0 !== (lane & pingedLanes))
+              expirationTimes[index$5] = computeExpirationTime(lane, currentTime);
+          } else expirationTime <= currentTime && (root2.expiredLanes |= lane);
+          lanes &= ~lane;
+        }
+        currentTime = workInProgressRoot;
+        suspendedLanes = workInProgressRootRenderLanes;
+        suspendedLanes = getNextLanes(
+          root2,
+          root2 === currentTime ? suspendedLanes : 0,
+          null !== root2.cancelPendingCommit || -1 !== root2.timeoutHandle
+        );
+        pingedLanes = root2.callbackNode;
+        if (0 === suspendedLanes || root2 === currentTime && (2 === workInProgressSuspendedReason || 9 === workInProgressSuspendedReason) || null !== root2.cancelPendingCommit)
+          return null !== pingedLanes && null !== pingedLanes && cancelCallback$1(pingedLanes), root2.callbackNode = null, root2.callbackPriority = 0;
+        if (0 === (suspendedLanes & 3) || checkIfRootIsPrerendering(root2, suspendedLanes)) {
+          currentTime = suspendedLanes & -suspendedLanes;
+          if (currentTime === root2.callbackPriority) return currentTime;
+          null !== pingedLanes && cancelCallback$1(pingedLanes);
+          switch (lanesToEventPriority(suspendedLanes)) {
+            case 2:
+            case 8:
+              suspendedLanes = UserBlockingPriority;
+              break;
+            case 32:
+              suspendedLanes = NormalPriority$1;
+              break;
+            case 268435456:
+              suspendedLanes = IdlePriority;
+              break;
+            default:
+              suspendedLanes = NormalPriority$1;
+          }
+          pingedLanes = performWorkOnRootViaSchedulerTask.bind(null, root2);
+          suspendedLanes = scheduleCallback$3(suspendedLanes, pingedLanes);
+          root2.callbackPriority = currentTime;
+          root2.callbackNode = suspendedLanes;
+          return currentTime;
+        }
+        null !== pingedLanes && null !== pingedLanes && cancelCallback$1(pingedLanes);
+        root2.callbackPriority = 2;
+        root2.callbackNode = null;
+        return 2;
+      }
+      function performWorkOnRootViaSchedulerTask(root2, didTimeout) {
+        if (0 !== pendingEffectsStatus && 5 !== pendingEffectsStatus)
+          return root2.callbackNode = null, root2.callbackPriority = 0, null;
+        var originalCallbackNode = root2.callbackNode;
+        if (flushPendingEffects() && root2.callbackNode !== originalCallbackNode)
+          return null;
+        var workInProgressRootRenderLanes$jscomp$0 = workInProgressRootRenderLanes;
+        workInProgressRootRenderLanes$jscomp$0 = getNextLanes(
+          root2,
+          root2 === workInProgressRoot ? workInProgressRootRenderLanes$jscomp$0 : 0,
+          null !== root2.cancelPendingCommit || -1 !== root2.timeoutHandle
+        );
+        if (0 === workInProgressRootRenderLanes$jscomp$0) return null;
+        performWorkOnRoot(root2, workInProgressRootRenderLanes$jscomp$0, didTimeout);
+        scheduleTaskForRootDuringMicrotask(root2, now());
+        return null != root2.callbackNode && root2.callbackNode === originalCallbackNode ? performWorkOnRootViaSchedulerTask.bind(null, root2) : null;
+      }
+      function performSyncWorkOnRoot(root2, lanes) {
+        if (flushPendingEffects()) return null;
+        performWorkOnRoot(root2, lanes, true);
+      }
+      function scheduleImmediateRootScheduleTask() {
+        scheduleMicrotask(function() {
+          0 !== (executionContext & 6) ? scheduleCallback$3(
+            ImmediatePriority,
+            processRootScheduleInImmediateTask
+          ) : processRootScheduleInMicrotask();
+        });
+      }
+      function requestTransitionLane() {
+        if (0 === currentEventTransitionLane) {
+          var actionScopeLane = currentEntangledLane;
+          0 === actionScopeLane && (actionScopeLane = nextTransitionUpdateLane, nextTransitionUpdateLane <<= 1, 0 === (nextTransitionUpdateLane & 261888) && (nextTransitionUpdateLane = 256));
+          currentEventTransitionLane = actionScopeLane;
+        }
+        return currentEventTransitionLane;
+      }