openplanr 2.2640.8 → 2.2640.9

package/lib/host-packages/cursor/openplanr/runtime/design/scripts/runtime/packages/design/templates/studio/studio.js.sources/05-react-dom-client-render-phases.js

@@ -0,0 +1,1759 @@
+
+      var classComponentUpdater = {
+        enqueueSetState: function(inst, payload, callback) {
+          inst = inst._reactInternals;
+          var lane = requestUpdateLane(), update = createUpdate(lane);
+          update.payload = payload;
+          void 0 !== callback && null !== callback && (update.callback = callback);
+          payload = enqueueUpdate(inst, update, lane);
+          null !== payload && (scheduleUpdateOnFiber(payload, inst, lane), entangleTransitions(payload, inst, lane));
+        },
+        enqueueReplaceState: function(inst, payload, callback) {
+          inst = inst._reactInternals;
+          var lane = requestUpdateLane(), update = createUpdate(lane);
+          update.tag = 1;
+          update.payload = payload;
+          void 0 !== callback && null !== callback && (update.callback = callback);
+          payload = enqueueUpdate(inst, update, lane);
+          null !== payload && (scheduleUpdateOnFiber(payload, inst, lane), entangleTransitions(payload, inst, lane));
+        },
+        enqueueForceUpdate: function(inst, callback) {
+          inst = inst._reactInternals;
+          var lane = requestUpdateLane(), update = createUpdate(lane);
+          update.tag = 2;
+          void 0 !== callback && null !== callback && (update.callback = callback);
+          callback = enqueueUpdate(inst, update, lane);
+          null !== callback && (scheduleUpdateOnFiber(callback, inst, lane), entangleTransitions(callback, inst, lane));
+        }
+      };
+      function checkShouldComponentUpdate(workInProgress2, ctor, oldProps, newProps, oldState, newState, nextContext) {
+        workInProgress2 = workInProgress2.stateNode;
+        return "function" === typeof workInProgress2.shouldComponentUpdate ? workInProgress2.shouldComponentUpdate(newProps, newState, nextContext) : ctor.prototype && ctor.prototype.isPureReactComponent ? !shallowEqual2(oldProps, newProps) || !shallowEqual2(oldState, newState) : true;
+      }
+      function callComponentWillReceiveProps(workInProgress2, instance, newProps, nextContext) {
+        workInProgress2 = instance.state;
+        "function" === typeof instance.componentWillReceiveProps && instance.componentWillReceiveProps(newProps, nextContext);
+        "function" === typeof instance.UNSAFE_componentWillReceiveProps && instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
+        instance.state !== workInProgress2 && classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
+      }
+      function resolveClassComponentProps(Component, baseProps) {
+        var newProps = baseProps;
+        if ("ref" in baseProps) {
+          newProps = {};
+          for (var propName in baseProps)
+            "ref" !== propName && (newProps[propName] = baseProps[propName]);
+        }
+        if (Component = Component.defaultProps) {
+          newProps === baseProps && (newProps = assign({}, newProps));
+          for (var propName$73 in Component)
+            void 0 === newProps[propName$73] && (newProps[propName$73] = Component[propName$73]);
+        }
+        return newProps;
+      }
+      function defaultOnUncaughtError(error) {
+        reportGlobalError(error);
+      }
+      function defaultOnCaughtError(error) {
+        console.error(error);
+      }
+      function defaultOnRecoverableError(error) {
+        reportGlobalError(error);
+      }
+      function logUncaughtError(root2, errorInfo) {
+        try {
+          var onUncaughtError = root2.onUncaughtError;
+          onUncaughtError(errorInfo.value, { componentStack: errorInfo.stack });
+        } catch (e$74) {
+          setTimeout(function() {
+            throw e$74;
+          });
+        }
+      }
+      function logCaughtError(root2, boundary, errorInfo) {
+        try {
+          var onCaughtError = root2.onCaughtError;
+          onCaughtError(errorInfo.value, {
+            componentStack: errorInfo.stack,
+            errorBoundary: 1 === boundary.tag ? boundary.stateNode : null
+          });
+        } catch (e$75) {
+          setTimeout(function() {
+            throw e$75;
+          });
+        }
+      }
+      function createRootErrorUpdate(root2, errorInfo, lane) {
+        lane = createUpdate(lane);
+        lane.tag = 3;
+        lane.payload = { element: null };
+        lane.callback = function() {
+          logUncaughtError(root2, errorInfo);
+        };
+        return lane;
+      }
+      function createClassErrorUpdate(lane) {
+        lane = createUpdate(lane);
+        lane.tag = 3;
+        return lane;
+      }
+      function initializeClassErrorUpdate(update, root2, fiber, errorInfo) {
+        var getDerivedStateFromError = fiber.type.getDerivedStateFromError;
+        if ("function" === typeof getDerivedStateFromError) {
+          var error = errorInfo.value;
+          update.payload = function() {
+            return getDerivedStateFromError(error);
+          };
+          update.callback = function() {
+            logCaughtError(root2, fiber, errorInfo);
+          };
+        }
+        var inst = fiber.stateNode;
+        null !== inst && "function" === typeof inst.componentDidCatch && (update.callback = function() {
+          logCaughtError(root2, fiber, errorInfo);
+          "function" !== typeof getDerivedStateFromError && (null === legacyErrorBoundariesThatAlreadyFailed ? legacyErrorBoundariesThatAlreadyFailed = /* @__PURE__ */ new Set([this]) : legacyErrorBoundariesThatAlreadyFailed.add(this));
+          var stack = errorInfo.stack;
+          this.componentDidCatch(errorInfo.value, {
+            componentStack: null !== stack ? stack : ""
+          });
+        });
+      }
+      function throwException(root2, returnFiber, sourceFiber, value, rootRenderLanes) {
+        sourceFiber.flags |= 32768;
+        if (null !== value && "object" === typeof value && "function" === typeof value.then) {
+          returnFiber = sourceFiber.alternate;
+          null !== returnFiber && propagateParentContextChanges(
+            returnFiber,
+            sourceFiber,
+            rootRenderLanes,
+            true
+          );
+          sourceFiber = suspenseHandlerStackCursor.current;
+          if (null !== sourceFiber) {
+            switch (sourceFiber.tag) {
+              case 31:
+              case 13:
+                return null === shellBoundary ? renderDidSuspendDelayIfPossible() : null === sourceFiber.alternate && 0 === workInProgressRootExitStatus && (workInProgressRootExitStatus = 3), sourceFiber.flags &= -257, sourceFiber.flags |= 65536, sourceFiber.lanes = rootRenderLanes, value === noopSuspenseyCommitThenable ? sourceFiber.flags |= 16384 : (returnFiber = sourceFiber.updateQueue, null === returnFiber ? sourceFiber.updateQueue = /* @__PURE__ */ new Set([value]) : returnFiber.add(value), attachPingListener(root2, value, rootRenderLanes)), false;
+              case 22:
+                return sourceFiber.flags |= 65536, value === noopSuspenseyCommitThenable ? sourceFiber.flags |= 16384 : (returnFiber = sourceFiber.updateQueue, null === returnFiber ? (returnFiber = {
+                  transitions: null,
+                  markerInstances: null,
+                  retryQueue: /* @__PURE__ */ new Set([value])
+                }, sourceFiber.updateQueue = returnFiber) : (sourceFiber = returnFiber.retryQueue, null === sourceFiber ? returnFiber.retryQueue = /* @__PURE__ */ new Set([value]) : sourceFiber.add(value)), attachPingListener(root2, value, rootRenderLanes)), false;
+            }
+            throw Error(formatProdErrorMessage(435, sourceFiber.tag));
+          }
+          attachPingListener(root2, value, rootRenderLanes);
+          renderDidSuspendDelayIfPossible();
+          return false;
+        }
+        if (isHydrating)
+          return returnFiber = suspenseHandlerStackCursor.current, null !== returnFiber ? (0 === (returnFiber.flags & 65536) && (returnFiber.flags |= 256), returnFiber.flags |= 65536, returnFiber.lanes = rootRenderLanes, value !== HydrationMismatchException && (root2 = Error(formatProdErrorMessage(422), { cause: value }), queueHydrationError(createCapturedValueAtFiber(root2, sourceFiber)))) : (value !== HydrationMismatchException && (returnFiber = Error(formatProdErrorMessage(423), {
+            cause: value
+          }), queueHydrationError(
+            createCapturedValueAtFiber(returnFiber, sourceFiber)
+          )), root2 = root2.current.alternate, root2.flags |= 65536, rootRenderLanes &= -rootRenderLanes, root2.lanes |= rootRenderLanes, value = createCapturedValueAtFiber(value, sourceFiber), rootRenderLanes = createRootErrorUpdate(
+            root2.stateNode,
+            value,
+            rootRenderLanes
+          ), enqueueCapturedUpdate(root2, rootRenderLanes), 4 !== workInProgressRootExitStatus && (workInProgressRootExitStatus = 2)), false;
+        var wrapperError = Error(formatProdErrorMessage(520), { cause: value });
+        wrapperError = createCapturedValueAtFiber(wrapperError, sourceFiber);
+        null === workInProgressRootConcurrentErrors ? workInProgressRootConcurrentErrors = [wrapperError] : workInProgressRootConcurrentErrors.push(wrapperError);
+        4 !== workInProgressRootExitStatus && (workInProgressRootExitStatus = 2);
+        if (null === returnFiber) return true;
+        value = createCapturedValueAtFiber(value, sourceFiber);
+        sourceFiber = returnFiber;
+        do {
+          switch (sourceFiber.tag) {
+            case 3:
+              return sourceFiber.flags |= 65536, root2 = rootRenderLanes & -rootRenderLanes, sourceFiber.lanes |= root2, root2 = createRootErrorUpdate(sourceFiber.stateNode, value, root2), enqueueCapturedUpdate(sourceFiber, root2), false;
+            case 1:
+              if (returnFiber = sourceFiber.type, wrapperError = sourceFiber.stateNode, 0 === (sourceFiber.flags & 128) && ("function" === typeof returnFiber.getDerivedStateFromError || null !== wrapperError && "function" === typeof wrapperError.componentDidCatch && (null === legacyErrorBoundariesThatAlreadyFailed || !legacyErrorBoundariesThatAlreadyFailed.has(wrapperError))))
+                return sourceFiber.flags |= 65536, rootRenderLanes &= -rootRenderLanes, sourceFiber.lanes |= rootRenderLanes, rootRenderLanes = createClassErrorUpdate(rootRenderLanes), initializeClassErrorUpdate(
+                  rootRenderLanes,
+                  root2,
+                  sourceFiber,
+                  value
+                ), enqueueCapturedUpdate(sourceFiber, rootRenderLanes), false;
+          }
+          sourceFiber = sourceFiber.return;
+        } while (null !== sourceFiber);
+        return false;
+      }
+      var SelectiveHydrationException = Error(formatProdErrorMessage(461));
+      var didReceiveUpdate = false;
+      function reconcileChildren(current, workInProgress2, nextChildren, renderLanes2) {
+        workInProgress2.child = null === current ? mountChildFibers(workInProgress2, null, nextChildren, renderLanes2) : reconcileChildFibers(
+          workInProgress2,
+          current.child,
+          nextChildren,
+          renderLanes2
+        );
+      }
+      function updateForwardRef(current, workInProgress2, Component, nextProps, renderLanes2) {
+        Component = Component.render;
+        var ref = workInProgress2.ref;
+        if ("ref" in nextProps) {
+          var propsWithoutRef = {};
+          for (var key in nextProps)
+            "ref" !== key && (propsWithoutRef[key] = nextProps[key]);
+        } else propsWithoutRef = nextProps;
+        prepareToReadContext(workInProgress2);
+        nextProps = renderWithHooks(
+          current,
+          workInProgress2,
+          Component,
+          propsWithoutRef,
+          ref,
+          renderLanes2
+        );
+        key = checkDidRenderIdHook();
+        if (null !== current && !didReceiveUpdate)
+          return bailoutHooks(current, workInProgress2, renderLanes2), bailoutOnAlreadyFinishedWork(current, workInProgress2, renderLanes2);
+        isHydrating && key && pushMaterializedTreeId(workInProgress2);
+        workInProgress2.flags |= 1;
+        reconcileChildren(current, workInProgress2, nextProps, renderLanes2);
+        return workInProgress2.child;
+      }
+      function updateMemoComponent(current, workInProgress2, Component, nextProps, renderLanes2) {
+        if (null === current) {
+          var type = Component.type;
+          if ("function" === typeof type && !shouldConstruct(type) && void 0 === type.defaultProps && null === Component.compare)
+            return workInProgress2.tag = 15, workInProgress2.type = type, updateSimpleMemoComponent(
+              current,
+              workInProgress2,
+              type,
+              nextProps,
+              renderLanes2
+            );
+          current = createFiberFromTypeAndProps(
+            Component.type,
+            null,
+            nextProps,
+            workInProgress2,
+            workInProgress2.mode,
+            renderLanes2
+          );
+          current.ref = workInProgress2.ref;
+          current.return = workInProgress2;
+          return workInProgress2.child = current;
+        }
+        type = current.child;
+        if (!checkScheduledUpdateOrContext(current, renderLanes2)) {
+          var prevProps = type.memoizedProps;
+          Component = Component.compare;
+          Component = null !== Component ? Component : shallowEqual2;
+          if (Component(prevProps, nextProps) && current.ref === workInProgress2.ref)
+            return bailoutOnAlreadyFinishedWork(current, workInProgress2, renderLanes2);
+        }
+        workInProgress2.flags |= 1;
+        current = createWorkInProgress(type, nextProps);
+        current.ref = workInProgress2.ref;
+        current.return = workInProgress2;
+        return workInProgress2.child = current;
+      }
+      function updateSimpleMemoComponent(current, workInProgress2, Component, nextProps, renderLanes2) {
+        if (null !== current) {
+          var prevProps = current.memoizedProps;
+          if (shallowEqual2(prevProps, nextProps) && current.ref === workInProgress2.ref)
+            if (didReceiveUpdate = false, workInProgress2.pendingProps = nextProps = prevProps, checkScheduledUpdateOrContext(current, renderLanes2))
+              0 !== (current.flags & 131072) && (didReceiveUpdate = true);
+            else
+              return workInProgress2.lanes = current.lanes, bailoutOnAlreadyFinishedWork(current, workInProgress2, renderLanes2);
+        }
+        return updateFunctionComponent(
+          current,
+          workInProgress2,
+          Component,
+          nextProps,
+          renderLanes2
+        );
+      }
+      function updateOffscreenComponent(current, workInProgress2, renderLanes2, nextProps) {
+        var nextChildren = nextProps.children, prevState = null !== current ? current.memoizedState : null;
+        null === current && null === workInProgress2.stateNode && (workInProgress2.stateNode = {
+          _visibility: 1,
+          _pendingMarkers: null,
+          _retryCache: null,
+          _transitions: null
+        });
+        if ("hidden" === nextProps.mode) {
+          if (0 !== (workInProgress2.flags & 128)) {
+            prevState = null !== prevState ? prevState.baseLanes | renderLanes2 : renderLanes2;
+            if (null !== current) {
+              nextProps = workInProgress2.child = current.child;
+              for (nextChildren = 0; null !== nextProps; )
+                nextChildren = nextChildren | nextProps.lanes | nextProps.childLanes, nextProps = nextProps.sibling;
+              nextProps = nextChildren & ~prevState;
+            } else nextProps = 0, workInProgress2.child = null;
+            return deferHiddenOffscreenComponent(
+              current,
+              workInProgress2,
+              prevState,
+              renderLanes2,
+              nextProps
+            );
+          }
+          if (0 !== (renderLanes2 & 536870912))
+            workInProgress2.memoizedState = { baseLanes: 0, cachePool: null }, null !== current && pushTransition(
+              workInProgress2,
+              null !== prevState ? prevState.cachePool : null
+            ), null !== prevState ? pushHiddenContext(workInProgress2, prevState) : reuseHiddenContextOnStack(), pushOffscreenSuspenseHandler(workInProgress2);
+          else
+            return nextProps = workInProgress2.lanes = 536870912, deferHiddenOffscreenComponent(
+              current,
+              workInProgress2,
+              null !== prevState ? prevState.baseLanes | renderLanes2 : renderLanes2,
+              renderLanes2,
+              nextProps
+            );
+        } else
+          null !== prevState ? (pushTransition(workInProgress2, prevState.cachePool), pushHiddenContext(workInProgress2, prevState), reuseSuspenseHandlerOnStack(workInProgress2), workInProgress2.memoizedState = null) : (null !== current && pushTransition(workInProgress2, null), reuseHiddenContextOnStack(), reuseSuspenseHandlerOnStack(workInProgress2));
+        reconcileChildren(current, workInProgress2, nextChildren, renderLanes2);
+        return workInProgress2.child;
+      }
+      function bailoutOffscreenComponent(current, workInProgress2) {
+        null !== current && 22 === current.tag || null !== workInProgress2.stateNode || (workInProgress2.stateNode = {
+          _visibility: 1,
+          _pendingMarkers: null,
+          _retryCache: null,
+          _transitions: null
+        });
+        return workInProgress2.sibling;
+      }
+      function deferHiddenOffscreenComponent(current, workInProgress2, nextBaseLanes, renderLanes2, remainingChildLanes) {
+        var JSCompiler_inline_result = peekCacheFromPool();
+        JSCompiler_inline_result = null === JSCompiler_inline_result ? null : { parent: CacheContext._currentValue, pool: JSCompiler_inline_result };
+        workInProgress2.memoizedState = {
+          baseLanes: nextBaseLanes,
+          cachePool: JSCompiler_inline_result
+        };
+        null !== current && pushTransition(workInProgress2, null);
+        reuseHiddenContextOnStack();
+        pushOffscreenSuspenseHandler(workInProgress2);
+        null !== current && propagateParentContextChanges(current, workInProgress2, renderLanes2, true);
+        workInProgress2.childLanes = remainingChildLanes;
+        return null;
+      }
+      function mountActivityChildren(workInProgress2, nextProps) {
+        nextProps = mountWorkInProgressOffscreenFiber(
+          { mode: nextProps.mode, children: nextProps.children },
+          workInProgress2.mode
+        );
+        nextProps.ref = workInProgress2.ref;
+        workInProgress2.child = nextProps;
+        nextProps.return = workInProgress2;
+        return nextProps;
+      }
+      function retryActivityComponentWithoutHydrating(current, workInProgress2, renderLanes2) {
+        reconcileChildFibers(workInProgress2, current.child, null, renderLanes2);
+        current = mountActivityChildren(workInProgress2, workInProgress2.pendingProps);
+        current.flags |= 2;
+        popSuspenseHandler(workInProgress2);
+        workInProgress2.memoizedState = null;
+        return current;
+      }
+      function updateActivityComponent(current, workInProgress2, renderLanes2) {
+        var nextProps = workInProgress2.pendingProps, didSuspend = 0 !== (workInProgress2.flags & 128);
+        workInProgress2.flags &= -129;
+        if (null === current) {
+          if (isHydrating) {
+            if ("hidden" === nextProps.mode)
+              return current = mountActivityChildren(workInProgress2, nextProps), workInProgress2.lanes = 536870912, bailoutOffscreenComponent(null, current);
+            pushDehydratedActivitySuspenseHandler(workInProgress2);
+            (current = nextHydratableInstance) ? (current = canHydrateHydrationBoundary(
+              current,
+              rootOrSingletonContext
+            ), current = null !== current && "&" === current.data ? current : null, null !== current && (workInProgress2.memoizedState = {
+              dehydrated: current,
+              treeContext: null !== treeContextProvider ? { id: treeContextId, overflow: treeContextOverflow } : null,
+              retryLane: 536870912,
+              hydrationErrors: null
+            }, renderLanes2 = createFiberFromDehydratedFragment(current), renderLanes2.return = workInProgress2, workInProgress2.child = renderLanes2, hydrationParentFiber = workInProgress2, nextHydratableInstance = null)) : current = null;
+            if (null === current) throw throwOnHydrationMismatch(workInProgress2);
+            workInProgress2.lanes = 536870912;
+            return null;
+          }
+          return mountActivityChildren(workInProgress2, nextProps);
+        }
+        var prevState = current.memoizedState;
+        if (null !== prevState) {
+          var dehydrated = prevState.dehydrated;
+          pushDehydratedActivitySuspenseHandler(workInProgress2);
+          if (didSuspend)
+            if (workInProgress2.flags & 256)
+              workInProgress2.flags &= -257, workInProgress2 = retryActivityComponentWithoutHydrating(
+                current,
+                workInProgress2,
+                renderLanes2
+              );
+            else if (null !== workInProgress2.memoizedState)
+              workInProgress2.child = current.child, workInProgress2.flags |= 128, workInProgress2 = null;
+            else throw Error(formatProdErrorMessage(558));
+          else if (didReceiveUpdate || propagateParentContextChanges(current, workInProgress2, renderLanes2, false), didSuspend = 0 !== (renderLanes2 & current.childLanes), didReceiveUpdate || didSuspend) {
+            nextProps = workInProgressRoot;
+            if (null !== nextProps && (dehydrated = getBumpedLaneForHydration(nextProps, renderLanes2), 0 !== dehydrated && dehydrated !== prevState.retryLane))
+              throw prevState.retryLane = dehydrated, enqueueConcurrentRenderForLane(current, dehydrated), scheduleUpdateOnFiber(nextProps, current, dehydrated), SelectiveHydrationException;
+            renderDidSuspendDelayIfPossible();
+            workInProgress2 = retryActivityComponentWithoutHydrating(
+              current,
+              workInProgress2,
+              renderLanes2
+            );
+          } else
+            current = prevState.treeContext, nextHydratableInstance = getNextHydratable(dehydrated.nextSibling), hydrationParentFiber = workInProgress2, isHydrating = true, hydrationErrors = null, rootOrSingletonContext = false, null !== current && restoreSuspendedTreeContext(workInProgress2, current), workInProgress2 = mountActivityChildren(workInProgress2, nextProps), workInProgress2.flags |= 4096;
+          return workInProgress2;
+        }
+        current = createWorkInProgress(current.child, {
+          mode: nextProps.mode,
+          children: nextProps.children
+        });
+        current.ref = workInProgress2.ref;
+        workInProgress2.child = current;
+        current.return = workInProgress2;
+        return current;
+      }
+      function markRef(current, workInProgress2) {
+        var ref = workInProgress2.ref;
+        if (null === ref)
+          null !== current && null !== current.ref && (workInProgress2.flags |= 4194816);
+        else {
+          if ("function" !== typeof ref && "object" !== typeof ref)
+            throw Error(formatProdErrorMessage(284));
+          if (null === current || current.ref !== ref)
+            workInProgress2.flags |= 4194816;
+        }
+      }
+      function updateFunctionComponent(current, workInProgress2, Component, nextProps, renderLanes2) {
+        prepareToReadContext(workInProgress2);
+        Component = renderWithHooks(
+          current,
+          workInProgress2,
+          Component,
+          nextProps,
+          void 0,
+          renderLanes2
+        );
+        nextProps = checkDidRenderIdHook();
+        if (null !== current && !didReceiveUpdate)
+          return bailoutHooks(current, workInProgress2, renderLanes2), bailoutOnAlreadyFinishedWork(current, workInProgress2, renderLanes2);
+        isHydrating && nextProps && pushMaterializedTreeId(workInProgress2);
+        workInProgress2.flags |= 1;
+        reconcileChildren(current, workInProgress2, Component, renderLanes2);
+        return workInProgress2.child;
+      }
+      function replayFunctionComponent(current, workInProgress2, nextProps, Component, secondArg, renderLanes2) {
+        prepareToReadContext(workInProgress2);
+        workInProgress2.updateQueue = null;
+        nextProps = renderWithHooksAgain(
+          workInProgress2,
+          Component,
+          nextProps,
+          secondArg
+        );
+        finishRenderingHooks(current);
+        Component = checkDidRenderIdHook();
+        if (null !== current && !didReceiveUpdate)
+          return bailoutHooks(current, workInProgress2, renderLanes2), bailoutOnAlreadyFinishedWork(current, workInProgress2, renderLanes2);
+        isHydrating && Component && pushMaterializedTreeId(workInProgress2);
+        workInProgress2.flags |= 1;
+        reconcileChildren(current, workInProgress2, nextProps, renderLanes2);
+        return workInProgress2.child;
+      }
+      function updateClassComponent(current, workInProgress2, Component, nextProps, renderLanes2) {
+        prepareToReadContext(workInProgress2);
+        if (null === workInProgress2.stateNode) {
+          var context = emptyContextObject, contextType = Component.contextType;
+          "object" === typeof contextType && null !== contextType && (context = readContext(contextType));
+          context = new Component(nextProps, context);
+          workInProgress2.memoizedState = null !== context.state && void 0 !== context.state ? context.state : null;
+          context.updater = classComponentUpdater;
+          workInProgress2.stateNode = context;
+          context._reactInternals = workInProgress2;
+          context = workInProgress2.stateNode;
+          context.props = nextProps;
+          context.state = workInProgress2.memoizedState;
+          context.refs = {};
+          initializeUpdateQueue(workInProgress2);
+          contextType = Component.contextType;
+          context.context = "object" === typeof contextType && null !== contextType ? readContext(contextType) : emptyContextObject;
+          context.state = workInProgress2.memoizedState;
+          contextType = Component.getDerivedStateFromProps;
+          "function" === typeof contextType && (applyDerivedStateFromProps(
+            workInProgress2,
+            Component,
+            contextType,
+            nextProps
+          ), context.state = workInProgress2.memoizedState);
+          "function" === typeof Component.getDerivedStateFromProps || "function" === typeof context.getSnapshotBeforeUpdate || "function" !== typeof context.UNSAFE_componentWillMount && "function" !== typeof context.componentWillMount || (contextType = context.state, "function" === typeof context.componentWillMount && context.componentWillMount(), "function" === typeof context.UNSAFE_componentWillMount && context.UNSAFE_componentWillMount(), contextType !== context.state && classComponentUpdater.enqueueReplaceState(context, context.state, null), processUpdateQueue(workInProgress2, nextProps, context, renderLanes2), suspendIfUpdateReadFromEntangledAsyncAction(), context.state = workInProgress2.memoizedState);
+          "function" === typeof context.componentDidMount && (workInProgress2.flags |= 4194308);
+          nextProps = true;
+        } else if (null === current) {
+          context = workInProgress2.stateNode;
+          var unresolvedOldProps = workInProgress2.memoizedProps, oldProps = resolveClassComponentProps(Component, unresolvedOldProps);
+          context.props = oldProps;
+          var oldContext = context.context, contextType$jscomp$0 = Component.contextType;
+          contextType = emptyContextObject;
+          "object" === typeof contextType$jscomp$0 && null !== contextType$jscomp$0 && (contextType = readContext(contextType$jscomp$0));
+          var getDerivedStateFromProps = Component.getDerivedStateFromProps;
+          contextType$jscomp$0 = "function" === typeof getDerivedStateFromProps || "function" === typeof context.getSnapshotBeforeUpdate;
+          unresolvedOldProps = workInProgress2.pendingProps !== unresolvedOldProps;
+          contextType$jscomp$0 || "function" !== typeof context.UNSAFE_componentWillReceiveProps && "function" !== typeof context.componentWillReceiveProps || (unresolvedOldProps || oldContext !== contextType) && callComponentWillReceiveProps(
+            workInProgress2,
+            context,
+            nextProps,
+            contextType
+          );
+          hasForceUpdate = false;
+          var oldState = workInProgress2.memoizedState;
+          context.state = oldState;
+          processUpdateQueue(workInProgress2, nextProps, context, renderLanes2);
+          suspendIfUpdateReadFromEntangledAsyncAction();
+          oldContext = workInProgress2.memoizedState;
+          unresolvedOldProps || oldState !== oldContext || hasForceUpdate ? ("function" === typeof getDerivedStateFromProps && (applyDerivedStateFromProps(
+            workInProgress2,
+            Component,
+            getDerivedStateFromProps,
+            nextProps
+          ), oldContext = workInProgress2.memoizedState), (oldProps = hasForceUpdate || checkShouldComponentUpdate(
+            workInProgress2,
+            Component,
+            oldProps,
+            nextProps,
+            oldState,
+            oldContext,
+            contextType
+          )) ? (contextType$jscomp$0 || "function" !== typeof context.UNSAFE_componentWillMount && "function" !== typeof context.componentWillMount || ("function" === typeof context.componentWillMount && context.componentWillMount(), "function" === typeof context.UNSAFE_componentWillMount && context.UNSAFE_componentWillMount()), "function" === typeof context.componentDidMount && (workInProgress2.flags |= 4194308)) : ("function" === typeof context.componentDidMount && (workInProgress2.flags |= 4194308), workInProgress2.memoizedProps = nextProps, workInProgress2.memoizedState = oldContext), context.props = nextProps, context.state = oldContext, context.context = contextType, nextProps = oldProps) : ("function" === typeof context.componentDidMount && (workInProgress2.flags |= 4194308), nextProps = false);
+        } else {
+          context = workInProgress2.stateNode;
+          cloneUpdateQueue(current, workInProgress2);
+          contextType = workInProgress2.memoizedProps;
+          contextType$jscomp$0 = resolveClassComponentProps(Component, contextType);
+          context.props = contextType$jscomp$0;
+          getDerivedStateFromProps = workInProgress2.pendingProps;
+          oldState = context.context;
+          oldContext = Component.contextType;
+          oldProps = emptyContextObject;
+          "object" === typeof oldContext && null !== oldContext && (oldProps = readContext(oldContext));
+          unresolvedOldProps = Component.getDerivedStateFromProps;
+          (oldContext = "function" === typeof unresolvedOldProps || "function" === typeof context.getSnapshotBeforeUpdate) || "function" !== typeof context.UNSAFE_componentWillReceiveProps && "function" !== typeof context.componentWillReceiveProps || (contextType !== getDerivedStateFromProps || oldState !== oldProps) && callComponentWillReceiveProps(
+            workInProgress2,
+            context,
+            nextProps,
+            oldProps
+          );
+          hasForceUpdate = false;
+          oldState = workInProgress2.memoizedState;
+          context.state = oldState;
+          processUpdateQueue(workInProgress2, nextProps, context, renderLanes2);
+          suspendIfUpdateReadFromEntangledAsyncAction();
+          var newState = workInProgress2.memoizedState;
+          contextType !== getDerivedStateFromProps || oldState !== newState || hasForceUpdate || null !== current && null !== current.dependencies && checkIfContextChanged(current.dependencies) ? ("function" === typeof unresolvedOldProps && (applyDerivedStateFromProps(
+            workInProgress2,
+            Component,
+            unresolvedOldProps,
+            nextProps
+          ), newState = workInProgress2.memoizedState), (contextType$jscomp$0 = hasForceUpdate || checkShouldComponentUpdate(
+            workInProgress2,
+            Component,
+            contextType$jscomp$0,
+            nextProps,
+            oldState,
+            newState,
+            oldProps
+          ) || null !== current && null !== current.dependencies && checkIfContextChanged(current.dependencies)) ? (oldContext || "function" !== typeof context.UNSAFE_componentWillUpdate && "function" !== typeof context.componentWillUpdate || ("function" === typeof context.componentWillUpdate && context.componentWillUpdate(nextProps, newState, oldProps), "function" === typeof context.UNSAFE_componentWillUpdate && context.UNSAFE_componentWillUpdate(
+            nextProps,
+            newState,
+            oldProps
+          )), "function" === typeof context.componentDidUpdate && (workInProgress2.flags |= 4), "function" === typeof context.getSnapshotBeforeUpdate && (workInProgress2.flags |= 1024)) : ("function" !== typeof context.componentDidUpdate || contextType === current.memoizedProps && oldState === current.memoizedState || (workInProgress2.flags |= 4), "function" !== typeof context.getSnapshotBeforeUpdate || contextType === current.memoizedProps && oldState === current.memoizedState || (workInProgress2.flags |= 1024), workInProgress2.memoizedProps = nextProps, workInProgress2.memoizedState = newState), context.props = nextProps, context.state = newState, context.context = oldProps, nextProps = contextType$jscomp$0) : ("function" !== typeof context.componentDidUpdate || contextType === current.memoizedProps && oldState === current.memoizedState || (workInProgress2.flags |= 4), "function" !== typeof context.getSnapshotBeforeUpdate || contextType === current.memoizedProps && oldState === current.memoizedState || (workInProgress2.flags |= 1024), nextProps = false);
+        }
+        context = nextProps;
+        markRef(current, workInProgress2);
+        nextProps = 0 !== (workInProgress2.flags & 128);
+        context || nextProps ? (context = workInProgress2.stateNode, Component = nextProps && "function" !== typeof Component.getDerivedStateFromError ? null : context.render(), workInProgress2.flags |= 1, null !== current && nextProps ? (workInProgress2.child = reconcileChildFibers(
+          workInProgress2,
+          current.child,
+          null,
+          renderLanes2
+        ), workInProgress2.child = reconcileChildFibers(
+          workInProgress2,
+          null,
+          Component,
+          renderLanes2
+        )) : reconcileChildren(current, workInProgress2, Component, renderLanes2), workInProgress2.memoizedState = context.state, current = workInProgress2.child) : current = bailoutOnAlreadyFinishedWork(
+          current,
+          workInProgress2,
+          renderLanes2
+        );
+        return current;
+      }
+      function mountHostRootWithoutHydrating(current, workInProgress2, nextChildren, renderLanes2) {
+        resetHydrationState();
+        workInProgress2.flags |= 256;
+        reconcileChildren(current, workInProgress2, nextChildren, renderLanes2);
+        return workInProgress2.child;
+      }
+      var SUSPENDED_MARKER = {
+        dehydrated: null,
+        treeContext: null,
+        retryLane: 0,
+        hydrationErrors: null
+      };
+      function mountSuspenseOffscreenState(renderLanes2) {
+        return { baseLanes: renderLanes2, cachePool: getSuspendedCache() };
+      }
+      function getRemainingWorkInPrimaryTree(current, primaryTreeDidDefer, renderLanes2) {
+        current = null !== current ? current.childLanes & ~renderLanes2 : 0;
+        primaryTreeDidDefer && (current |= workInProgressDeferredLane);
+        return current;
+      }
+      function updateSuspenseComponent(current, workInProgress2, renderLanes2) {
+        var nextProps = workInProgress2.pendingProps, showFallback = false, didSuspend = 0 !== (workInProgress2.flags & 128), JSCompiler_temp;
+        (JSCompiler_temp = didSuspend) || (JSCompiler_temp = null !== current && null === current.memoizedState ? false : 0 !== (suspenseStackCursor.current & 2));
+        JSCompiler_temp && (showFallback = true, workInProgress2.flags &= -129);
+        JSCompiler_temp = 0 !== (workInProgress2.flags & 32);
+        workInProgress2.flags &= -33;
+        if (null === current) {
+          if (isHydrating) {
+            showFallback ? pushPrimaryTreeSuspenseHandler(workInProgress2) : reuseSuspenseHandlerOnStack(workInProgress2);
+            (current = nextHydratableInstance) ? (current = canHydrateHydrationBoundary(
+              current,
+              rootOrSingletonContext
+            ), current = null !== current && "&" !== current.data ? current : null, null !== current && (workInProgress2.memoizedState = {
+              dehydrated: current,
+              treeContext: null !== treeContextProvider ? { id: treeContextId, overflow: treeContextOverflow } : null,
+              retryLane: 536870912,
+              hydrationErrors: null
+            }, renderLanes2 = createFiberFromDehydratedFragment(current), renderLanes2.return = workInProgress2, workInProgress2.child = renderLanes2, hydrationParentFiber = workInProgress2, nextHydratableInstance = null)) : current = null;
+            if (null === current) throw throwOnHydrationMismatch(workInProgress2);
+            isSuspenseInstanceFallback(current) ? workInProgress2.lanes = 32 : workInProgress2.lanes = 536870912;
+            return null;
+          }
+          var nextPrimaryChildren = nextProps.children;
+          nextProps = nextProps.fallback;
+          if (showFallback)
+            return reuseSuspenseHandlerOnStack(workInProgress2), showFallback = workInProgress2.mode, nextPrimaryChildren = mountWorkInProgressOffscreenFiber(
+              { mode: "hidden", children: nextPrimaryChildren },
+              showFallback
+            ), nextProps = createFiberFromFragment(
+              nextProps,
+              showFallback,
+              renderLanes2,
+              null
+            ), nextPrimaryChildren.return = workInProgress2, nextProps.return = workInProgress2, nextPrimaryChildren.sibling = nextProps, workInProgress2.child = nextPrimaryChildren, nextProps = workInProgress2.child, nextProps.memoizedState = mountSuspenseOffscreenState(renderLanes2), nextProps.childLanes = getRemainingWorkInPrimaryTree(
+              current,
+              JSCompiler_temp,
+              renderLanes2
+            ), workInProgress2.memoizedState = SUSPENDED_MARKER, bailoutOffscreenComponent(null, nextProps);
+          pushPrimaryTreeSuspenseHandler(workInProgress2);
+          return mountSuspensePrimaryChildren(workInProgress2, nextPrimaryChildren);
+        }
+        var prevState = current.memoizedState;
+        if (null !== prevState && (nextPrimaryChildren = prevState.dehydrated, null !== nextPrimaryChildren)) {
+          if (didSuspend)
+            workInProgress2.flags & 256 ? (pushPrimaryTreeSuspenseHandler(workInProgress2), workInProgress2.flags &= -257, workInProgress2 = retrySuspenseComponentWithoutHydrating(
+              current,
+              workInProgress2,
+              renderLanes2
+            )) : null !== workInProgress2.memoizedState ? (reuseSuspenseHandlerOnStack(workInProgress2), workInProgress2.child = current.child, workInProgress2.flags |= 128, workInProgress2 = null) : (reuseSuspenseHandlerOnStack(workInProgress2), nextPrimaryChildren = nextProps.fallback, showFallback = workInProgress2.mode, nextProps = mountWorkInProgressOffscreenFiber(
+              { mode: "visible", children: nextProps.children },
+              showFallback
+            ), nextPrimaryChildren = createFiberFromFragment(
+              nextPrimaryChildren,
+              showFallback,
+              renderLanes2,
+              null
+            ), nextPrimaryChildren.flags |= 2, nextProps.return = workInProgress2, nextPrimaryChildren.return = workInProgress2, nextProps.sibling = nextPrimaryChildren, workInProgress2.child = nextProps, reconcileChildFibers(
+              workInProgress2,
+              current.child,
+              null,
+              renderLanes2
+            ), nextProps = workInProgress2.child, nextProps.memoizedState = mountSuspenseOffscreenState(renderLanes2), nextProps.childLanes = getRemainingWorkInPrimaryTree(
+              current,
+              JSCompiler_temp,
+              renderLanes2
+            ), workInProgress2.memoizedState = SUSPENDED_MARKER, workInProgress2 = bailoutOffscreenComponent(null, nextProps));
+          else if (pushPrimaryTreeSuspenseHandler(workInProgress2), isSuspenseInstanceFallback(nextPrimaryChildren)) {
+            JSCompiler_temp = nextPrimaryChildren.nextSibling && nextPrimaryChildren.nextSibling.dataset;
+            if (JSCompiler_temp) var digest = JSCompiler_temp.dgst;
+            JSCompiler_temp = digest;
+            nextProps = Error(formatProdErrorMessage(419));
+            nextProps.stack = "";
+            nextProps.digest = JSCompiler_temp;
+            queueHydrationError({ value: nextProps, source: null, stack: null });
+            workInProgress2 = retrySuspenseComponentWithoutHydrating(
+              current,
+              workInProgress2,
+              renderLanes2
+            );
+          } else if (didReceiveUpdate || propagateParentContextChanges(current, workInProgress2, renderLanes2, false), JSCompiler_temp = 0 !== (renderLanes2 & current.childLanes), didReceiveUpdate || JSCompiler_temp) {
+            JSCompiler_temp = workInProgressRoot;
+            if (null !== JSCompiler_temp && (nextProps = getBumpedLaneForHydration(JSCompiler_temp, renderLanes2), 0 !== nextProps && nextProps !== prevState.retryLane))
+              throw prevState.retryLane = nextProps, enqueueConcurrentRenderForLane(current, nextProps), scheduleUpdateOnFiber(JSCompiler_temp, current, nextProps), SelectiveHydrationException;
+            isSuspenseInstancePending(nextPrimaryChildren) || renderDidSuspendDelayIfPossible();
+            workInProgress2 = retrySuspenseComponentWithoutHydrating(
+              current,
+              workInProgress2,
+              renderLanes2
+            );
+          } else
+            isSuspenseInstancePending(nextPrimaryChildren) ? (workInProgress2.flags |= 192, workInProgress2.child = current.child, workInProgress2 = null) : (current = prevState.treeContext, nextHydratableInstance = getNextHydratable(
+              nextPrimaryChildren.nextSibling
+            ), hydrationParentFiber = workInProgress2, isHydrating = true, hydrationErrors = null, rootOrSingletonContext = false, null !== current && restoreSuspendedTreeContext(workInProgress2, current), workInProgress2 = mountSuspensePrimaryChildren(
+              workInProgress2,
+              nextProps.children
+            ), workInProgress2.flags |= 4096);
+          return workInProgress2;
+        }
+        if (showFallback)
+          return reuseSuspenseHandlerOnStack(workInProgress2), nextPrimaryChildren = nextProps.fallback, showFallback = workInProgress2.mode, prevState = current.child, digest = prevState.sibling, nextProps = createWorkInProgress(prevState, {
+            mode: "hidden",
+            children: nextProps.children
+          }), nextProps.subtreeFlags = prevState.subtreeFlags & 65011712, null !== digest ? nextPrimaryChildren = createWorkInProgress(
+            digest,
+            nextPrimaryChildren
+          ) : (nextPrimaryChildren = createFiberFromFragment(
+            nextPrimaryChildren,
+            showFallback,
+            renderLanes2,
+            null
+          ), nextPrimaryChildren.flags |= 2), nextPrimaryChildren.return = workInProgress2, nextProps.return = workInProgress2, nextProps.sibling = nextPrimaryChildren, workInProgress2.child = nextProps, bailoutOffscreenComponent(null, nextProps), nextProps = workInProgress2.child, nextPrimaryChildren = current.child.memoizedState, null === nextPrimaryChildren ? nextPrimaryChildren = mountSuspenseOffscreenState(renderLanes2) : (showFallback = nextPrimaryChildren.cachePool, null !== showFallback ? (prevState = CacheContext._currentValue, showFallback = showFallback.parent !== prevState ? { parent: prevState, pool: prevState } : showFallback) : showFallback = getSuspendedCache(), nextPrimaryChildren = {
+            baseLanes: nextPrimaryChildren.baseLanes | renderLanes2,
+            cachePool: showFallback
+          }), nextProps.memoizedState = nextPrimaryChildren, nextProps.childLanes = getRemainingWorkInPrimaryTree(
+            current,
+            JSCompiler_temp,
+            renderLanes2
+          ), workInProgress2.memoizedState = SUSPENDED_MARKER, bailoutOffscreenComponent(current.child, nextProps);
+        pushPrimaryTreeSuspenseHandler(workInProgress2);
+        renderLanes2 = current.child;
+        current = renderLanes2.sibling;
+        renderLanes2 = createWorkInProgress(renderLanes2, {
+          mode: "visible",
+          children: nextProps.children
+        });
+        renderLanes2.return = workInProgress2;
+        renderLanes2.sibling = null;
+        null !== current && (JSCompiler_temp = workInProgress2.deletions, null === JSCompiler_temp ? (workInProgress2.deletions = [current], workInProgress2.flags |= 16) : JSCompiler_temp.push(current));
+        workInProgress2.child = renderLanes2;
+        workInProgress2.memoizedState = null;
+        return renderLanes2;
+      }
+      function mountSuspensePrimaryChildren(workInProgress2, primaryChildren) {
+        primaryChildren = mountWorkInProgressOffscreenFiber(
+          { mode: "visible", children: primaryChildren },
+          workInProgress2.mode
+        );
+        primaryChildren.return = workInProgress2;
+        return workInProgress2.child = primaryChildren;
+      }
+      function mountWorkInProgressOffscreenFiber(offscreenProps, mode) {
+        offscreenProps = createFiberImplClass(22, offscreenProps, null, mode);
+        offscreenProps.lanes = 0;
+        return offscreenProps;
+      }
+      function retrySuspenseComponentWithoutHydrating(current, workInProgress2, renderLanes2) {
+        reconcileChildFibers(workInProgress2, current.child, null, renderLanes2);
+        current = mountSuspensePrimaryChildren(
+          workInProgress2,
+          workInProgress2.pendingProps.children
+        );
+        current.flags |= 2;
+        workInProgress2.memoizedState = null;
+        return current;
+      }
+      function scheduleSuspenseWorkOnFiber(fiber, renderLanes2, propagationRoot) {
+        fiber.lanes |= renderLanes2;
+        var alternate = fiber.alternate;
+        null !== alternate && (alternate.lanes |= renderLanes2);
+        scheduleContextWorkOnParentPath(fiber.return, renderLanes2, propagationRoot);
+      }
+      function initSuspenseListRenderState(workInProgress2, isBackwards, tail, lastContentRow, tailMode, treeForkCount2) {
+        var renderState = workInProgress2.memoizedState;
+        null === renderState ? workInProgress2.memoizedState = {
+          isBackwards,
+          rendering: null,
+          renderingStartTime: 0,
+          last: lastContentRow,
+          tail,
+          tailMode,
+          treeForkCount: treeForkCount2
+        } : (renderState.isBackwards = isBackwards, renderState.rendering = null, renderState.renderingStartTime = 0, renderState.last = lastContentRow, renderState.tail = tail, renderState.tailMode = tailMode, renderState.treeForkCount = treeForkCount2);
+      }
+      function updateSuspenseListComponent(current, workInProgress2, renderLanes2) {
+        var nextProps = workInProgress2.pendingProps, revealOrder = nextProps.revealOrder, tailMode = nextProps.tail;
+        nextProps = nextProps.children;
+        var suspenseContext = suspenseStackCursor.current, shouldForceFallback = 0 !== (suspenseContext & 2);
+        shouldForceFallback ? (suspenseContext = suspenseContext & 1 | 2, workInProgress2.flags |= 128) : suspenseContext &= 1;
+        push(suspenseStackCursor, suspenseContext);
+        reconcileChildren(current, workInProgress2, nextProps, renderLanes2);
+        nextProps = isHydrating ? treeForkCount : 0;
+        if (!shouldForceFallback && null !== current && 0 !== (current.flags & 128))
+          a: for (current = workInProgress2.child; null !== current; ) {
+            if (13 === current.tag)
+              null !== current.memoizedState && scheduleSuspenseWorkOnFiber(current, renderLanes2, workInProgress2);
+            else if (19 === current.tag)
+              scheduleSuspenseWorkOnFiber(current, renderLanes2, workInProgress2);
+            else if (null !== current.child) {
+              current.child.return = current;
+              current = current.child;
+              continue;
+            }
+            if (current === workInProgress2) break a;
+            for (; null === current.sibling; ) {
+              if (null === current.return || current.return === workInProgress2)
+                break a;
+              current = current.return;
+            }
+            current.sibling.return = current.return;
+            current = current.sibling;
+          }
+        switch (revealOrder) {
+          case "forwards":
+            renderLanes2 = workInProgress2.child;
+            for (revealOrder = null; null !== renderLanes2; )
+              current = renderLanes2.alternate, null !== current && null === findFirstSuspended(current) && (revealOrder = renderLanes2), renderLanes2 = renderLanes2.sibling;
+            renderLanes2 = revealOrder;
+            null === renderLanes2 ? (revealOrder = workInProgress2.child, workInProgress2.child = null) : (revealOrder = renderLanes2.sibling, renderLanes2.sibling = null);
+            initSuspenseListRenderState(
+              workInProgress2,
+              false,
+              revealOrder,
+              renderLanes2,
+              tailMode,
+              nextProps
+            );
+            break;
+          case "backwards":
+          case "unstable_legacy-backwards":
+            renderLanes2 = null;
+            revealOrder = workInProgress2.child;
+            for (workInProgress2.child = null; null !== revealOrder; ) {
+              current = revealOrder.alternate;
+              if (null !== current && null === findFirstSuspended(current)) {
+                workInProgress2.child = revealOrder;
+                break;
+              }
+              current = revealOrder.sibling;
+              revealOrder.sibling = renderLanes2;
+              renderLanes2 = revealOrder;
+              revealOrder = current;
+            }
+            initSuspenseListRenderState(
+              workInProgress2,
+              true,
+              renderLanes2,
+              null,
+              tailMode,
+              nextProps
+            );
+            break;
+          case "together":
+            initSuspenseListRenderState(
+              workInProgress2,
+              false,
+              null,
+              null,
+              void 0,
+              nextProps
+            );
+            break;
+          default:
+            workInProgress2.memoizedState = null;
+        }
+        return workInProgress2.child;
+      }
+      function bailoutOnAlreadyFinishedWork(current, workInProgress2, renderLanes2) {
+        null !== current && (workInProgress2.dependencies = current.dependencies);
+        workInProgressRootSkippedLanes |= workInProgress2.lanes;
+        if (0 === (renderLanes2 & workInProgress2.childLanes))
+          if (null !== current) {
+            if (propagateParentContextChanges(
+              current,
+              workInProgress2,
+              renderLanes2,
+              false
+            ), 0 === (renderLanes2 & workInProgress2.childLanes))
+              return null;
+          } else return null;
+        if (null !== current && workInProgress2.child !== current.child)
+          throw Error(formatProdErrorMessage(153));
+        if (null !== workInProgress2.child) {
+          current = workInProgress2.child;
+          renderLanes2 = createWorkInProgress(current, current.pendingProps);
+          workInProgress2.child = renderLanes2;
+          for (renderLanes2.return = workInProgress2; null !== current.sibling; )
+            current = current.sibling, renderLanes2 = renderLanes2.sibling = createWorkInProgress(current, current.pendingProps), renderLanes2.return = workInProgress2;
+          renderLanes2.sibling = null;
+        }
+        return workInProgress2.child;
+      }
+      function checkScheduledUpdateOrContext(current, renderLanes2) {
+        if (0 !== (current.lanes & renderLanes2)) return true;
+        current = current.dependencies;
+        return null !== current && checkIfContextChanged(current) ? true : false;
+      }
+      function attemptEarlyBailoutIfNoScheduledUpdate(current, workInProgress2, renderLanes2) {
+        switch (workInProgress2.tag) {
+          case 3:
+            pushHostContainer(workInProgress2, workInProgress2.stateNode.containerInfo);
+            pushProvider(workInProgress2, CacheContext, current.memoizedState.cache);
+            resetHydrationState();
+            break;
+          case 27:
+          case 5:
+            pushHostContext(workInProgress2);
+            break;
+          case 4:
+            pushHostContainer(workInProgress2, workInProgress2.stateNode.containerInfo);
+            break;
+          case 10:
+            pushProvider(
+              workInProgress2,
+              workInProgress2.type,
+              workInProgress2.memoizedProps.value
+            );
+            break;
+          case 31:
+            if (null !== workInProgress2.memoizedState)
+              return workInProgress2.flags |= 128, pushDehydratedActivitySuspenseHandler(workInProgress2), null;
+            break;
+          case 13:
+            var state$102 = workInProgress2.memoizedState;
+            if (null !== state$102) {
+              if (null !== state$102.dehydrated)
+                return pushPrimaryTreeSuspenseHandler(workInProgress2), workInProgress2.flags |= 128, null;
+              if (0 !== (renderLanes2 & workInProgress2.child.childLanes))
+                return updateSuspenseComponent(current, workInProgress2, renderLanes2);
+              pushPrimaryTreeSuspenseHandler(workInProgress2);
+              current = bailoutOnAlreadyFinishedWork(
+                current,
+                workInProgress2,
+                renderLanes2
+              );
+              return null !== current ? current.sibling : null;
+            }
+            pushPrimaryTreeSuspenseHandler(workInProgress2);
+            break;
+          case 19:
+            var didSuspendBefore = 0 !== (current.flags & 128);
+            state$102 = 0 !== (renderLanes2 & workInProgress2.childLanes);
+            state$102 || (propagateParentContextChanges(
+              current,
+              workInProgress2,
+              renderLanes2,
+              false
+            ), state$102 = 0 !== (renderLanes2 & workInProgress2.childLanes));
+            if (didSuspendBefore) {
+              if (state$102)
+                return updateSuspenseListComponent(
+                  current,
+                  workInProgress2,
+                  renderLanes2
+                );
+              workInProgress2.flags |= 128;
+            }
+            didSuspendBefore = workInProgress2.memoizedState;
+            null !== didSuspendBefore && (didSuspendBefore.rendering = null, didSuspendBefore.tail = null, didSuspendBefore.lastEffect = null);
+            push(suspenseStackCursor, suspenseStackCursor.current);
+            if (state$102) break;
+            else return null;
+          case 22:
+            return workInProgress2.lanes = 0, updateOffscreenComponent(
+              current,
+              workInProgress2,
+              renderLanes2,
+              workInProgress2.pendingProps
+            );
+          case 24:
+            pushProvider(workInProgress2, CacheContext, current.memoizedState.cache);
+        }
+        return bailoutOnAlreadyFinishedWork(current, workInProgress2, renderLanes2);
+      }
+      function beginWork(current, workInProgress2, renderLanes2) {
+        if (null !== current)
+          if (current.memoizedProps !== workInProgress2.pendingProps)
+            didReceiveUpdate = true;
+          else {
+            if (!checkScheduledUpdateOrContext(current, renderLanes2) && 0 === (workInProgress2.flags & 128))
+              return didReceiveUpdate = false, attemptEarlyBailoutIfNoScheduledUpdate(
+                current,
+                workInProgress2,
+                renderLanes2
+              );
+            didReceiveUpdate = 0 !== (current.flags & 131072) ? true : false;
+          }
+        else
+          didReceiveUpdate = false, isHydrating && 0 !== (workInProgress2.flags & 1048576) && pushTreeId(workInProgress2, treeForkCount, workInProgress2.index);
+        workInProgress2.lanes = 0;
+        switch (workInProgress2.tag) {
+          case 16:
+            a: {
+              var props = workInProgress2.pendingProps;
+              current = resolveLazy(workInProgress2.elementType);
+              workInProgress2.type = current;
+              if ("function" === typeof current)
+                shouldConstruct(current) ? (props = resolveClassComponentProps(current, props), workInProgress2.tag = 1, workInProgress2 = updateClassComponent(
+                  null,
+                  workInProgress2,
+                  current,
+                  props,
+                  renderLanes2
+                )) : (workInProgress2.tag = 0, workInProgress2 = updateFunctionComponent(
+                  null,
+                  workInProgress2,
+                  current,
+                  props,
+                  renderLanes2
+                ));
+              else {
+                if (void 0 !== current && null !== current) {
+                  var $$typeof = current.$$typeof;
+                  if ($$typeof === REACT_FORWARD_REF_TYPE) {
+                    workInProgress2.tag = 11;
+                    workInProgress2 = updateForwardRef(
+                      null,
+                      workInProgress2,
+                      current,
+                      props,
+                      renderLanes2
+                    );
+                    break a;
+                  } else if ($$typeof === REACT_MEMO_TYPE) {
+                    workInProgress2.tag = 14;
+                    workInProgress2 = updateMemoComponent(
+                      null,
+                      workInProgress2,
+                      current,
+                      props,
+                      renderLanes2
+                    );
+                    break a;
+                  }
+                }
+                workInProgress2 = getComponentNameFromType(current) || current;
+                throw Error(formatProdErrorMessage(306, workInProgress2, ""));
+              }
+            }
+            return workInProgress2;
+          case 0:
+            return updateFunctionComponent(
+              current,
+              workInProgress2,
+              workInProgress2.type,
+              workInProgress2.pendingProps,
+              renderLanes2
+            );
+          case 1:
+            return props = workInProgress2.type, $$typeof = resolveClassComponentProps(
+              props,
+              workInProgress2.pendingProps
+            ), updateClassComponent(
+              current,
+              workInProgress2,
+              props,
+              $$typeof,
+              renderLanes2
+            );
+          case 3:
+            a: {
+              pushHostContainer(
+                workInProgress2,
+                workInProgress2.stateNode.containerInfo
+              );
+              if (null === current) throw Error(formatProdErrorMessage(387));
+              props = workInProgress2.pendingProps;
+              var prevState = workInProgress2.memoizedState;
+              $$typeof = prevState.element;
+              cloneUpdateQueue(current, workInProgress2);
+              processUpdateQueue(workInProgress2, props, null, renderLanes2);
+              var nextState = workInProgress2.memoizedState;
+              props = nextState.cache;
+              pushProvider(workInProgress2, CacheContext, props);
+              props !== prevState.cache && propagateContextChanges(
+                workInProgress2,
+                [CacheContext],
+                renderLanes2,
+                true
+              );
+              suspendIfUpdateReadFromEntangledAsyncAction();
+              props = nextState.element;
+              if (prevState.isDehydrated)
+                if (prevState = {
+                  element: props,
+                  isDehydrated: false,
+                  cache: nextState.cache
+                }, workInProgress2.updateQueue.baseState = prevState, workInProgress2.memoizedState = prevState, workInProgress2.flags & 256) {
+                  workInProgress2 = mountHostRootWithoutHydrating(
+                    current,
+                    workInProgress2,
+                    props,
+                    renderLanes2
+                  );
+                  break a;
+                } else if (props !== $$typeof) {
+                  $$typeof = createCapturedValueAtFiber(
+                    Error(formatProdErrorMessage(424)),
+                    workInProgress2
+                  );
+                  queueHydrationError($$typeof);
+                  workInProgress2 = mountHostRootWithoutHydrating(
+                    current,
+                    workInProgress2,
+                    props,
+                    renderLanes2
+                  );
+                  break a;
+                } else {
+                  current = workInProgress2.stateNode.containerInfo;
+                  switch (current.nodeType) {
+                    case 9:
+                      current = current.body;
+                      break;
+                    default:
+                      current = "HTML" === current.nodeName ? current.ownerDocument.body : current;
+                  }
+                  nextHydratableInstance = getNextHydratable(current.firstChild);
+                  hydrationParentFiber = workInProgress2;
+                  isHydrating = true;
+                  hydrationErrors = null;
+                  rootOrSingletonContext = true;
+                  renderLanes2 = mountChildFibers(
+                    workInProgress2,
+                    null,
+                    props,
+                    renderLanes2
+                  );
+                  for (workInProgress2.child = renderLanes2; renderLanes2; )
+                    renderLanes2.flags = renderLanes2.flags & -3 | 4096, renderLanes2 = renderLanes2.sibling;
+                }
+              else {
+                resetHydrationState();
+                if (props === $$typeof) {
+                  workInProgress2 = bailoutOnAlreadyFinishedWork(
+                    current,
+                    workInProgress2,
+                    renderLanes2
+                  );
+                  break a;
+                }
+                reconcileChildren(current, workInProgress2, props, renderLanes2);
+              }
+              workInProgress2 = workInProgress2.child;
+            }
+            return workInProgress2;
+          case 26:
+            return markRef(current, workInProgress2), null === current ? (renderLanes2 = getResource(
+              workInProgress2.type,
+              null,
+              workInProgress2.pendingProps,
+              null
+            )) ? workInProgress2.memoizedState = renderLanes2 : isHydrating || (renderLanes2 = workInProgress2.type, current = workInProgress2.pendingProps, props = getOwnerDocumentFromRootContainer(
+              rootInstanceStackCursor.current
+            ).createElement(renderLanes2), props[internalInstanceKey] = workInProgress2, props[internalPropsKey] = current, setInitialProperties(props, renderLanes2, current), markNodeAsHoistable(props), workInProgress2.stateNode = props) : workInProgress2.memoizedState = getResource(
+              workInProgress2.type,
+              current.memoizedProps,
+              workInProgress2.pendingProps,
+              current.memoizedState
+            ), null;
+          case 27:
+            return pushHostContext(workInProgress2), null === current && isHydrating && (props = workInProgress2.stateNode = resolveSingletonInstance(
+              workInProgress2.type,
+              workInProgress2.pendingProps,
+              rootInstanceStackCursor.current
+            ), hydrationParentFiber = workInProgress2, rootOrSingletonContext = true, $$typeof = nextHydratableInstance, isSingletonScope(workInProgress2.type) ? (previousHydratableOnEnteringScopedSingleton = $$typeof, nextHydratableInstance = getNextHydratable(props.firstChild)) : nextHydratableInstance = $$typeof), reconcileChildren(
+              current,
+              workInProgress2,
+              workInProgress2.pendingProps.children,
+              renderLanes2
+            ), markRef(current, workInProgress2), null === current && (workInProgress2.flags |= 4194304), workInProgress2.child;
+          case 5:
+            if (null === current && isHydrating) {
+              if ($$typeof = props = nextHydratableInstance)
+                props = canHydrateInstance(
+                  props,
+                  workInProgress2.type,
+                  workInProgress2.pendingProps,
+                  rootOrSingletonContext
+                ), null !== props ? (workInProgress2.stateNode = props, hydrationParentFiber = workInProgress2, nextHydratableInstance = getNextHydratable(props.firstChild), rootOrSingletonContext = false, $$typeof = true) : $$typeof = false;
+              $$typeof || throwOnHydrationMismatch(workInProgress2);
+            }
+            pushHostContext(workInProgress2);
+            $$typeof = workInProgress2.type;
+            prevState = workInProgress2.pendingProps;
+            nextState = null !== current ? current.memoizedProps : null;
+            props = prevState.children;
+            shouldSetTextContent($$typeof, prevState) ? props = null : null !== nextState && shouldSetTextContent($$typeof, nextState) && (workInProgress2.flags |= 32);
+            null !== workInProgress2.memoizedState && ($$typeof = renderWithHooks(
+              current,
+              workInProgress2,
+              TransitionAwareHostComponent,
+              null,
+              null,
+              renderLanes2
+            ), HostTransitionContext._currentValue = $$typeof);
+            markRef(current, workInProgress2);
+            reconcileChildren(current, workInProgress2, props, renderLanes2);
+            return workInProgress2.child;
+          case 6:
+            if (null === current && isHydrating) {
+              if (current = renderLanes2 = nextHydratableInstance)
+                renderLanes2 = canHydrateTextInstance(
+                  renderLanes2,
+                  workInProgress2.pendingProps,
+                  rootOrSingletonContext
+                ), null !== renderLanes2 ? (workInProgress2.stateNode = renderLanes2, hydrationParentFiber = workInProgress2, nextHydratableInstance = null, current = true) : current = false;
+              current || throwOnHydrationMismatch(workInProgress2);
+            }
+            return null;
+          case 13:
+            return updateSuspenseComponent(current, workInProgress2, renderLanes2);
+          case 4:
+            return pushHostContainer(
+              workInProgress2,
+              workInProgress2.stateNode.containerInfo
+            ), props = workInProgress2.pendingProps, null === current ? workInProgress2.child = reconcileChildFibers(
+              workInProgress2,
+              null,
+              props,
+              renderLanes2
+            ) : reconcileChildren(current, workInProgress2, props, renderLanes2), workInProgress2.child;
+          case 11:
+            return updateForwardRef(
+              current,
+              workInProgress2,
+              workInProgress2.type,
+              workInProgress2.pendingProps,
+              renderLanes2
+            );
+          case 7:
+            return reconcileChildren(
+              current,
+              workInProgress2,
+              workInProgress2.pendingProps,
+              renderLanes2
+            ), workInProgress2.child;
+          case 8:
+            return reconcileChildren(
+              current,
+              workInProgress2,
+              workInProgress2.pendingProps.children,
+              renderLanes2
+            ), workInProgress2.child;
+          case 12:
+            return reconcileChildren(
+              current,
+              workInProgress2,
+              workInProgress2.pendingProps.children,
+              renderLanes2
+            ), workInProgress2.child;
+          case 10:
+            return props = workInProgress2.pendingProps, pushProvider(workInProgress2, workInProgress2.type, props.value), reconcileChildren(current, workInProgress2, props.children, renderLanes2), workInProgress2.child;
+          case 9:
+            return $$typeof = workInProgress2.type._context, props = workInProgress2.pendingProps.children, prepareToReadContext(workInProgress2), $$typeof = readContext($$typeof), props = props($$typeof), workInProgress2.flags |= 1, reconcileChildren(current, workInProgress2, props, renderLanes2), workInProgress2.child;
+          case 14:
+            return updateMemoComponent(
+              current,
+              workInProgress2,
+              workInProgress2.type,
+              workInProgress2.pendingProps,
+              renderLanes2
+            );
+          case 15:
+            return updateSimpleMemoComponent(
+              current,
+              workInProgress2,
+              workInProgress2.type,
+              workInProgress2.pendingProps,
+              renderLanes2
+            );
+          case 19:
+            return updateSuspenseListComponent(current, workInProgress2, renderLanes2);
+          case 31:
+            return updateActivityComponent(current, workInProgress2, renderLanes2);
+          case 22:
+            return updateOffscreenComponent(
+              current,
+              workInProgress2,
+              renderLanes2,
+              workInProgress2.pendingProps
+            );
+          case 24:
+            return prepareToReadContext(workInProgress2), props = readContext(CacheContext), null === current ? ($$typeof = peekCacheFromPool(), null === $$typeof && ($$typeof = workInProgressRoot, prevState = createCache(), $$typeof.pooledCache = prevState, prevState.refCount++, null !== prevState && ($$typeof.pooledCacheLanes |= renderLanes2), $$typeof = prevState), workInProgress2.memoizedState = { parent: props, cache: $$typeof }, initializeUpdateQueue(workInProgress2), pushProvider(workInProgress2, CacheContext, $$typeof)) : (0 !== (current.lanes & renderLanes2) && (cloneUpdateQueue(current, workInProgress2), processUpdateQueue(workInProgress2, null, null, renderLanes2), suspendIfUpdateReadFromEntangledAsyncAction()), $$typeof = current.memoizedState, prevState = workInProgress2.memoizedState, $$typeof.parent !== props ? ($$typeof = { parent: props, cache: props }, workInProgress2.memoizedState = $$typeof, 0 === workInProgress2.lanes && (workInProgress2.memoizedState = workInProgress2.updateQueue.baseState = $$typeof), pushProvider(workInProgress2, CacheContext, props)) : (props = prevState.cache, pushProvider(workInProgress2, CacheContext, props), props !== $$typeof.cache && propagateContextChanges(
+              workInProgress2,
+              [CacheContext],
+              renderLanes2,
+              true
+            ))), reconcileChildren(
+              current,
+              workInProgress2,
+              workInProgress2.pendingProps.children,
+              renderLanes2
+            ), workInProgress2.child;
+          case 29:
+            throw workInProgress2.pendingProps;
+        }
+        throw Error(formatProdErrorMessage(156, workInProgress2.tag));
+      }
+      function markUpdate(workInProgress2) {
+        workInProgress2.flags |= 4;
+      }
+      function preloadInstanceAndSuspendIfNeeded(workInProgress2, type, oldProps, newProps, renderLanes2) {
+        if (type = 0 !== (workInProgress2.mode & 32)) type = false;
+        if (type) {
+          if (workInProgress2.flags |= 16777216, (renderLanes2 & 335544128) === renderLanes2)
+            if (workInProgress2.stateNode.complete) workInProgress2.flags |= 8192;
+            else if (shouldRemainOnPreviousScreen()) workInProgress2.flags |= 8192;
+            else
+              throw suspendedThenable = noopSuspenseyCommitThenable, SuspenseyCommitException;
+        } else workInProgress2.flags &= -16777217;
+      }
+      function preloadResourceAndSuspendIfNeeded(workInProgress2, resource) {
+        if ("stylesheet" !== resource.type || 0 !== (resource.state.loading & 4))
+          workInProgress2.flags &= -16777217;
+        else if (workInProgress2.flags |= 16777216, !preloadResource(resource))
+          if (shouldRemainOnPreviousScreen()) workInProgress2.flags |= 8192;
+          else
+            throw suspendedThenable = noopSuspenseyCommitThenable, SuspenseyCommitException;
+      }
+      function scheduleRetryEffect(workInProgress2, retryQueue) {
+        null !== retryQueue && (workInProgress2.flags |= 4);
+        workInProgress2.flags & 16384 && (retryQueue = 22 !== workInProgress2.tag ? claimNextRetryLane() : 536870912, workInProgress2.lanes |= retryQueue, workInProgressSuspendedRetryLanes |= retryQueue);
+      }
+      function cutOffTailIfNeeded(renderState, hasRenderedATailFallback) {
+        if (!isHydrating)
+          switch (renderState.tailMode) {
+            case "hidden":
+              hasRenderedATailFallback = renderState.tail;
+              for (var lastTailNode = null; null !== hasRenderedATailFallback; )
+                null !== hasRenderedATailFallback.alternate && (lastTailNode = hasRenderedATailFallback), hasRenderedATailFallback = hasRenderedATailFallback.sibling;
+              null === lastTailNode ? renderState.tail = null : lastTailNode.sibling = null;
+              break;
+            case "collapsed":
+              lastTailNode = renderState.tail;
+              for (var lastTailNode$106 = null; null !== lastTailNode; )
+                null !== lastTailNode.alternate && (lastTailNode$106 = lastTailNode), lastTailNode = lastTailNode.sibling;
+              null === lastTailNode$106 ? hasRenderedATailFallback || null === renderState.tail ? renderState.tail = null : renderState.tail.sibling = null : lastTailNode$106.sibling = null;
+          }
+      }
+      function bubbleProperties(completedWork) {
+        var didBailout = null !== completedWork.alternate && completedWork.alternate.child === completedWork.child, newChildLanes = 0, subtreeFlags = 0;
+        if (didBailout)
+          for (var child$107 = completedWork.child; null !== child$107; )
+            newChildLanes |= child$107.lanes | child$107.childLanes, subtreeFlags |= child$107.subtreeFlags & 65011712, subtreeFlags |= child$107.flags & 65011712, child$107.return = completedWork, child$107 = child$107.sibling;
+        else
+          for (child$107 = completedWork.child; null !== child$107; )
+            newChildLanes |= child$107.lanes | child$107.childLanes, subtreeFlags |= child$107.subtreeFlags, subtreeFlags |= child$107.flags, child$107.return = completedWork, child$107 = child$107.sibling;
+        completedWork.subtreeFlags |= subtreeFlags;
+        completedWork.childLanes = newChildLanes;
+        return didBailout;
+      }
+      function completeWork(current, workInProgress2, renderLanes2) {
+        var newProps = workInProgress2.pendingProps;
+        popTreeContext(workInProgress2);
+        switch (workInProgress2.tag) {
+          case 16:
+          case 15:
+          case 0:
+          case 11:
+          case 7:
+          case 8:
+          case 12:
+          case 9:
+          case 14:
+            return bubbleProperties(workInProgress2), null;
+          case 1:
+            return bubbleProperties(workInProgress2), null;
+          case 3:
+            renderLanes2 = workInProgress2.stateNode;
+            newProps = null;
+            null !== current && (newProps = current.memoizedState.cache);
+            workInProgress2.memoizedState.cache !== newProps && (workInProgress2.flags |= 2048);
+            popProvider(CacheContext);
+            popHostContainer();
+            renderLanes2.pendingContext && (renderLanes2.context = renderLanes2.pendingContext, renderLanes2.pendingContext = null);
+            if (null === current || null === current.child)
+              popHydrationState(workInProgress2) ? markUpdate(workInProgress2) : null === current || current.memoizedState.isDehydrated && 0 === (workInProgress2.flags & 256) || (workInProgress2.flags |= 1024, upgradeHydrationErrorsToRecoverable());
+            bubbleProperties(workInProgress2);
+            return null;
+          case 26:
+            var type = workInProgress2.type, nextResource = workInProgress2.memoizedState;
+            null === current ? (markUpdate(workInProgress2), null !== nextResource ? (bubbleProperties(workInProgress2), preloadResourceAndSuspendIfNeeded(workInProgress2, nextResource)) : (bubbleProperties(workInProgress2), preloadInstanceAndSuspendIfNeeded(
+              workInProgress2,
+              type,
+              null,
+              newProps,
+              renderLanes2
+            ))) : nextResource ? nextResource !== current.memoizedState ? (markUpdate(workInProgress2), bubbleProperties(workInProgress2), preloadResourceAndSuspendIfNeeded(workInProgress2, nextResource)) : (bubbleProperties(workInProgress2), workInProgress2.flags &= -16777217) : (current = current.memoizedProps, current !== newProps && markUpdate(workInProgress2), bubbleProperties(workInProgress2), preloadInstanceAndSuspendIfNeeded(
+              workInProgress2,
+              type,
+              current,
+              newProps,
+              renderLanes2
+            ));
+            return null;
+          case 27:
+            popHostContext(workInProgress2);
+            renderLanes2 = rootInstanceStackCursor.current;
+            type = workInProgress2.type;
+            if (null !== current && null != workInProgress2.stateNode)
+              current.memoizedProps !== newProps && markUpdate(workInProgress2);
+            else {
+              if (!newProps) {
+                if (null === workInProgress2.stateNode)
+                  throw Error(formatProdErrorMessage(166));
+                bubbleProperties(workInProgress2);
+                return null;
+              }
+              current = contextStackCursor.current;
+              popHydrationState(workInProgress2) ? prepareToHydrateHostInstance(workInProgress2, current) : (current = resolveSingletonInstance(type, newProps, renderLanes2), workInProgress2.stateNode = current, markUpdate(workInProgress2));
+            }
+            bubbleProperties(workInProgress2);
+            return null;
+          case 5:
+            popHostContext(workInProgress2);
+            type = workInProgress2.type;
+            if (null !== current && null != workInProgress2.stateNode)
+              current.memoizedProps !== newProps && markUpdate(workInProgress2);
+            else {
+              if (!newProps) {
+                if (null === workInProgress2.stateNode)
+                  throw Error(formatProdErrorMessage(166));
+                bubbleProperties(workInProgress2);
+                return null;
+              }
+              nextResource = contextStackCursor.current;
+              if (popHydrationState(workInProgress2))
+                prepareToHydrateHostInstance(workInProgress2, nextResource);
+              else {
+                var ownerDocument = getOwnerDocumentFromRootContainer(
+                  rootInstanceStackCursor.current
+                );
+                switch (nextResource) {
+                  case 1:
+                    nextResource = ownerDocument.createElementNS(
+                      "http://www.w3.org/2000/svg",
+                      type
+                    );
+                    break;
+                  case 2:
+                    nextResource = ownerDocument.createElementNS(
+                      "http://www.w3.org/1998/Math/MathML",
+                      type
+                    );
+                    break;
+                  default:
+                    switch (type) {
+                      case "svg":
+                        nextResource = ownerDocument.createElementNS(
+                          "http://www.w3.org/2000/svg",
+                          type
+                        );
+                        break;
+                      case "math":
+                        nextResource = ownerDocument.createElementNS(
+                          "http://www.w3.org/1998/Math/MathML",
+                          type
+                        );
+                        break;
+                      case "script":
+                        nextResource = ownerDocument.createElement("div");
+                        nextResource.innerHTML = "<script><\/script>";
+                        nextResource = nextResource.removeChild(
+                          nextResource.firstChild
+                        );
+                        break;
+                      case "select":
+                        nextResource = "string" === typeof newProps.is ? ownerDocument.createElement("select", {
+                          is: newProps.is
+                        }) : ownerDocument.createElement("select");
+                        newProps.multiple ? nextResource.multiple = true : newProps.size && (nextResource.size = newProps.size);
+                        break;
+                      default:
+                        nextResource = "string" === typeof newProps.is ? ownerDocument.createElement(type, { is: newProps.is }) : ownerDocument.createElement(type);
+                    }
+                }
+                nextResource[internalInstanceKey] = workInProgress2;
+                nextResource[internalPropsKey] = newProps;
+                a: for (ownerDocument = workInProgress2.child; null !== ownerDocument; ) {
+                  if (5 === ownerDocument.tag || 6 === ownerDocument.tag)
+                    nextResource.appendChild(ownerDocument.stateNode);
+                  else if (4 !== ownerDocument.tag && 27 !== ownerDocument.tag && null !== ownerDocument.child) {
+                    ownerDocument.child.return = ownerDocument;
+                    ownerDocument = ownerDocument.child;
+                    continue;
+                  }
+                  if (ownerDocument === workInProgress2) break a;
+                  for (; null === ownerDocument.sibling; ) {
+                    if (null === ownerDocument.return || ownerDocument.return === workInProgress2)
+                      break a;
+                    ownerDocument = ownerDocument.return;
+                  }
+                  ownerDocument.sibling.return = ownerDocument.return;
+                  ownerDocument = ownerDocument.sibling;
+                }
+                workInProgress2.stateNode = nextResource;
+                a: switch (setInitialProperties(nextResource, type, newProps), type) {
+                  case "button":
+                  case "input":
+                  case "select":
+                  case "textarea":
+                    newProps = !!newProps.autoFocus;
+                    break a;
+                  case "img":
+                    newProps = true;
+                    break a;
+                  default:
+                    newProps = false;
+                }
+                newProps && markUpdate(workInProgress2);
+              }
+            }
+            bubbleProperties(workInProgress2);
+            preloadInstanceAndSuspendIfNeeded(
+              workInProgress2,
+              workInProgress2.type,
+              null === current ? null : current.memoizedProps,
+              workInProgress2.pendingProps,
+              renderLanes2
+            );
+            return null;
+          case 6:
+            if (current && null != workInProgress2.stateNode)
+              current.memoizedProps !== newProps && markUpdate(workInProgress2);
+            else {
+              if ("string" !== typeof newProps && null === workInProgress2.stateNode)
+                throw Error(formatProdErrorMessage(166));
+              current = rootInstanceStackCursor.current;
+              if (popHydrationState(workInProgress2)) {
+                current = workInProgress2.stateNode;
+                renderLanes2 = workInProgress2.memoizedProps;
+                newProps = null;
+                type = hydrationParentFiber;
+                if (null !== type)
+                  switch (type.tag) {
+                    case 27:
+                    case 5:
+                      newProps = type.memoizedProps;
+                  }
+                current[internalInstanceKey] = workInProgress2;
+                current = current.nodeValue === renderLanes2 || null !== newProps && true === newProps.suppressHydrationWarning || checkForUnmatchedText(current.nodeValue, renderLanes2) ? true : false;
+                current || throwOnHydrationMismatch(workInProgress2, true);
+              } else
+                current = getOwnerDocumentFromRootContainer(current).createTextNode(
+                  newProps
+                ), current[internalInstanceKey] = workInProgress2, workInProgress2.stateNode = current;
+            }
+            bubbleProperties(workInProgress2);
+            return null;
+          case 31:
+            renderLanes2 = workInProgress2.memoizedState;
+            if (null === current || null !== current.memoizedState) {
+              newProps = popHydrationState(workInProgress2);
+              if (null !== renderLanes2) {
+                if (null === current) {
+                  if (!newProps) throw Error(formatProdErrorMessage(318));
+                  current = workInProgress2.memoizedState;
+                  current = null !== current ? current.dehydrated : null;
+                  if (!current) throw Error(formatProdErrorMessage(557));
+                  current[internalInstanceKey] = workInProgress2;
+                } else
+                  resetHydrationState(), 0 === (workInProgress2.flags & 128) && (workInProgress2.memoizedState = null), workInProgress2.flags |= 4;
+                bubbleProperties(workInProgress2);
+                current = false;
+              } else
+                renderLanes2 = upgradeHydrationErrorsToRecoverable(), null !== current && null !== current.memoizedState && (current.memoizedState.hydrationErrors = renderLanes2), current = true;
+              if (!current) {
+                if (workInProgress2.flags & 256)
+                  return popSuspenseHandler(workInProgress2), workInProgress2;
+                popSuspenseHandler(workInProgress2);
+                return null;
+              }
+              if (0 !== (workInProgress2.flags & 128))
+                throw Error(formatProdErrorMessage(558));
+            }
+            bubbleProperties(workInProgress2);
+            return null;
+          case 13:
+            newProps = workInProgress2.memoizedState;
+            if (null === current || null !== current.memoizedState && null !== current.memoizedState.dehydrated) {
+              type = popHydrationState(workInProgress2);
+              if (null !== newProps && null !== newProps.dehydrated) {
+                if (null === current) {
+                  if (!type) throw Error(formatProdErrorMessage(318));
+                  type = workInProgress2.memoizedState;
+                  type = null !== type ? type.dehydrated : null;
+                  if (!type) throw Error(formatProdErrorMessage(317));
+                  type[internalInstanceKey] = workInProgress2;
+                } else
+                  resetHydrationState(), 0 === (workInProgress2.flags & 128) && (workInProgress2.memoizedState = null), workInProgress2.flags |= 4;
+                bubbleProperties(workInProgress2);
+                type = false;
+              } else
+                type = upgradeHydrationErrorsToRecoverable(), null !== current && null !== current.memoizedState && (current.memoizedState.hydrationErrors = type), type = true;
+              if (!type) {
+                if (workInProgress2.flags & 256)
+                  return popSuspenseHandler(workInProgress2), workInProgress2;
+                popSuspenseHandler(workInProgress2);
+                return null;
+              }
+            }
+            popSuspenseHandler(workInProgress2);
+            if (0 !== (workInProgress2.flags & 128))
+              return workInProgress2.lanes = renderLanes2, workInProgress2;
+            renderLanes2 = null !== newProps;
+            current = null !== current && null !== current.memoizedState;
+            renderLanes2 && (newProps = workInProgress2.child, type = null, null !== newProps.alternate && null !== newProps.alternate.memoizedState && null !== newProps.alternate.memoizedState.cachePool && (type = newProps.alternate.memoizedState.cachePool.pool), nextResource = null, null !== newProps.memoizedState && null !== newProps.memoizedState.cachePool && (nextResource = newProps.memoizedState.cachePool.pool), nextResource !== type && (newProps.flags |= 2048));
+            renderLanes2 !== current && renderLanes2 && (workInProgress2.child.flags |= 8192);
+            scheduleRetryEffect(workInProgress2, workInProgress2.updateQueue);
+            bubbleProperties(workInProgress2);
+            return null;
+          case 4:
+            return popHostContainer(), null === current && listenToAllSupportedEvents(workInProgress2.stateNode.containerInfo), bubbleProperties(workInProgress2), null;
+          case 10:
+            return popProvider(workInProgress2.type), bubbleProperties(workInProgress2), null;
+          case 19:
+            pop(suspenseStackCursor);
+            newProps = workInProgress2.memoizedState;
+            if (null === newProps) return bubbleProperties(workInProgress2), null;
+            type = 0 !== (workInProgress2.flags & 128);
+            nextResource = newProps.rendering;
+            if (null === nextResource)
+              if (type) cutOffTailIfNeeded(newProps, false);
+              else {
+                if (0 !== workInProgressRootExitStatus || null !== current && 0 !== (current.flags & 128))
+                  for (current = workInProgress2.child; null !== current; ) {
+                    nextResource = findFirstSuspended(current);
+                    if (null !== nextResource) {
+                      workInProgress2.flags |= 128;
+                      cutOffTailIfNeeded(newProps, false);
+                      current = nextResource.updateQueue;
+                      workInProgress2.updateQueue = current;
+                      scheduleRetryEffect(workInProgress2, current);
+                      workInProgress2.subtreeFlags = 0;
+                      current = renderLanes2;
+                      for (renderLanes2 = workInProgress2.child; null !== renderLanes2; )
+                        resetWorkInProgress(renderLanes2, current), renderLanes2 = renderLanes2.sibling;
+                      push(
+                        suspenseStackCursor,
+                        suspenseStackCursor.current & 1 | 2
+                      );
+                      isHydrating && pushTreeFork(workInProgress2, newProps.treeForkCount);
+                      return workInProgress2.child;
+                    }
+                    current = current.sibling;
+                  }
+                null !== newProps.tail && now() > workInProgressRootRenderTargetTime && (workInProgress2.flags |= 128, type = true, cutOffTailIfNeeded(newProps, false), workInProgress2.lanes = 4194304);
+              }
+            else {
+              if (!type)
+                if (current = findFirstSuspended(nextResource), null !== current) {
+                  if (workInProgress2.flags |= 128, type = true, current = current.updateQueue, workInProgress2.updateQueue = current, scheduleRetryEffect(workInProgress2, current), cutOffTailIfNeeded(newProps, true), null === newProps.tail && "hidden" === newProps.tailMode && !nextResource.alternate && !isHydrating)
+                    return bubbleProperties(workInProgress2), null;
+                } else
+                  2 * now() - newProps.renderingStartTime > workInProgressRootRenderTargetTime && 536870912 !== renderLanes2 && (workInProgress2.flags |= 128, type = true, cutOffTailIfNeeded(newProps, false), workInProgress2.lanes = 4194304);
+              newProps.isBackwards ? (nextResource.sibling = workInProgress2.child, workInProgress2.child = nextResource) : (current = newProps.last, null !== current ? current.sibling = nextResource : workInProgress2.child = nextResource, newProps.last = nextResource);
+            }
+            if (null !== newProps.tail)
+              return current = newProps.tail, newProps.rendering = current, newProps.tail = current.sibling, newProps.renderingStartTime = now(), current.sibling = null, renderLanes2 = suspenseStackCursor.current, push(
+                suspenseStackCursor,
+                type ? renderLanes2 & 1 | 2 : renderLanes2 & 1
+              ), isHydrating && pushTreeFork(workInProgress2, newProps.treeForkCount), current;
+            bubbleProperties(workInProgress2);
+            return null;
+          case 22:
+          case 23:
+            return popSuspenseHandler(workInProgress2), popHiddenContext(), newProps = null !== workInProgress2.memoizedState, null !== current ? null !== current.memoizedState !== newProps && (workInProgress2.flags |= 8192) : newProps && (workInProgress2.flags |= 8192), newProps ? 0 !== (renderLanes2 & 536870912) && 0 === (workInProgress2.flags & 128) && (bubbleProperties(workInProgress2), workInProgress2.subtreeFlags & 6 && (workInProgress2.flags |= 8192)) : bubbleProperties(workInProgress2), renderLanes2 = workInProgress2.updateQueue, null !== renderLanes2 && scheduleRetryEffect(workInProgress2, renderLanes2.retryQueue), renderLanes2 = null, null !== current && null !== current.memoizedState && null !== current.memoizedState.cachePool && (renderLanes2 = current.memoizedState.cachePool.pool), newProps = null, null !== workInProgress2.memoizedState && null !== workInProgress2.memoizedState.cachePool && (newProps = workInProgress2.memoizedState.cachePool.pool), newProps !== renderLanes2 && (workInProgress2.flags |= 2048), null !== current && pop(resumedCache), null;
+          case 24:
+            return renderLanes2 = null, null !== current && (renderLanes2 = current.memoizedState.cache), workInProgress2.memoizedState.cache !== renderLanes2 && (workInProgress2.flags |= 2048), popProvider(CacheContext), bubbleProperties(workInProgress2), null;
+          case 25:
+            return null;
+          case 30:
+            return null;
+        }
+        throw Error(formatProdErrorMessage(156, workInProgress2.tag));
+      }
+      function unwindWork(current, workInProgress2) {
+        popTreeContext(workInProgress2);
+        switch (workInProgress2.tag) {
+          case 1:
+            return current = workInProgress2.flags, current & 65536 ? (workInProgress2.flags = current & -65537 | 128, workInProgress2) : null;
+          case 3:
+            return popProvider(CacheContext), popHostContainer(), current = workInProgress2.flags, 0 !== (current & 65536) && 0 === (current & 128) ? (workInProgress2.flags = current & -65537 | 128, workInProgress2) : null;
+          case 26:
+          case 27:
+          case 5:
+            return popHostContext(workInProgress2), null;
+          case 31:
+            if (null !== workInProgress2.memoizedState) {
+              popSuspenseHandler(workInProgress2);
+              if (null === workInProgress2.alternate)
+                throw Error(formatProdErrorMessage(340));
+              resetHydrationState();
+            }
+            current = workInProgress2.flags;
+            return current & 65536 ? (workInProgress2.flags = current & -65537 | 128, workInProgress2) : null;
+          case 13:
+            popSuspenseHandler(workInProgress2);
+            current = workInProgress2.memoizedState;
+            if (null !== current && null !== current.dehydrated) {
+              if (null === workInProgress2.alternate)
+                throw Error(formatProdErrorMessage(340));
+              resetHydrationState();
+            }
+            current = workInProgress2.flags;
+            return current & 65536 ? (workInProgress2.flags = current & -65537 | 128, workInProgress2) : null;
+          case 19:
+            return pop(suspenseStackCursor), null;
+          case 4:
+            return popHostContainer(), null;
+          case 10:
+            return popProvider(workInProgress2.type), null;
+          case 22:
+          case 23:
+            return popSuspenseHandler(workInProgress2), popHiddenContext(), null !== current && pop(resumedCache), current = workInProgress2.flags, current & 65536 ? (workInProgress2.flags = current & -65537 | 128, workInProgress2) : null;
+          case 24:
+            return popProvider(CacheContext), null;
+          case 25:
+            return null;
+          default:
+            return null;
+        }
+      }
+      function unwindInterruptedWork(current, interruptedWork) {
+        popTreeContext(interruptedWork);
+        switch (interruptedWork.tag) {
+          case 3:
+            popProvider(CacheContext);
+            popHostContainer();
+            break;
+          case 26:
+          case 27:
+          case 5:
+            popHostContext(interruptedWork);
+            break;
+          case 4:
+            popHostContainer();
+            break;
+          case 31:
+            null !== interruptedWork.memoizedState && popSuspenseHandler(interruptedWork);
+            break;
+          case 13:
+            popSuspenseHandler(interruptedWork);
+            break;
+          case 19:
+            pop(suspenseStackCursor);
+            break;
+          case 10:
+            popProvider(interruptedWork.type);
+            break;
+          case 22:
+          case 23:
+            popSuspenseHandler(interruptedWork);
+            popHiddenContext();
+            null !== current && pop(resumedCache);
+            break;
+          case 24:
+            popProvider(CacheContext);
+        }
+      }