openplanr 2.2640.8 → 2.2641.0

package/lib/host-packages/cursor/openplanr/runtime/design/scripts/runtime/packages/design/templates/studio/studio.js.sources/04-react-dom-client-reconciliation-hooks.js

@@ -0,0 +1,1919 @@
+
+      function createChildReconciler(shouldTrackSideEffects) {
+        function deleteChild(returnFiber, childToDelete) {
+          if (shouldTrackSideEffects) {
+            var deletions = returnFiber.deletions;
+            null === deletions ? (returnFiber.deletions = [childToDelete], returnFiber.flags |= 16) : deletions.push(childToDelete);
+          }
+        }
+        function deleteRemainingChildren(returnFiber, currentFirstChild) {
+          if (!shouldTrackSideEffects) return null;
+          for (; null !== currentFirstChild; )
+            deleteChild(returnFiber, currentFirstChild), currentFirstChild = currentFirstChild.sibling;
+          return null;
+        }
+        function mapRemainingChildren(currentFirstChild) {
+          for (var existingChildren = /* @__PURE__ */ new Map(); null !== currentFirstChild; )
+            null !== currentFirstChild.key ? existingChildren.set(currentFirstChild.key, currentFirstChild) : existingChildren.set(currentFirstChild.index, currentFirstChild), currentFirstChild = currentFirstChild.sibling;
+          return existingChildren;
+        }
+        function useFiber(fiber, pendingProps) {
+          fiber = createWorkInProgress(fiber, pendingProps);
+          fiber.index = 0;
+          fiber.sibling = null;
+          return fiber;
+        }
+        function placeChild(newFiber, lastPlacedIndex, newIndex) {
+          newFiber.index = newIndex;
+          if (!shouldTrackSideEffects)
+            return newFiber.flags |= 1048576, lastPlacedIndex;
+          newIndex = newFiber.alternate;
+          if (null !== newIndex)
+            return newIndex = newIndex.index, newIndex < lastPlacedIndex ? (newFiber.flags |= 67108866, lastPlacedIndex) : newIndex;
+          newFiber.flags |= 67108866;
+          return lastPlacedIndex;
+        }
+        function placeSingleChild(newFiber) {
+          shouldTrackSideEffects && null === newFiber.alternate && (newFiber.flags |= 67108866);
+          return newFiber;
+        }
+        function updateTextNode(returnFiber, current, textContent, lanes) {
+          if (null === current || 6 !== current.tag)
+            return current = createFiberFromText(textContent, returnFiber.mode, lanes), current.return = returnFiber, current;
+          current = useFiber(current, textContent);
+          current.return = returnFiber;
+          return current;
+        }
+        function updateElement(returnFiber, current, element, lanes) {
+          var elementType = element.type;
+          if (elementType === REACT_FRAGMENT_TYPE)
+            return updateFragment(
+              returnFiber,
+              current,
+              element.props.children,
+              lanes,
+              element.key
+            );
+          if (null !== current && (current.elementType === elementType || "object" === typeof elementType && null !== elementType && elementType.$$typeof === REACT_LAZY_TYPE2 && resolveLazy(elementType) === current.type))
+            return current = useFiber(current, element.props), coerceRef(current, element), current.return = returnFiber, current;
+          current = createFiberFromTypeAndProps(
+            element.type,
+            element.key,
+            element.props,
+            null,
+            returnFiber.mode,
+            lanes
+          );
+          coerceRef(current, element);
+          current.return = returnFiber;
+          return current;
+        }
+        function updatePortal(returnFiber, current, portal, lanes) {
+          if (null === current || 4 !== current.tag || current.stateNode.containerInfo !== portal.containerInfo || current.stateNode.implementation !== portal.implementation)
+            return current = createFiberFromPortal(portal, returnFiber.mode, lanes), current.return = returnFiber, current;
+          current = useFiber(current, portal.children || []);
+          current.return = returnFiber;
+          return current;
+        }
+        function updateFragment(returnFiber, current, fragment, lanes, key) {
+          if (null === current || 7 !== current.tag)
+            return current = createFiberFromFragment(
+              fragment,
+              returnFiber.mode,
+              lanes,
+              key
+            ), current.return = returnFiber, current;
+          current = useFiber(current, fragment);
+          current.return = returnFiber;
+          return current;
+        }
+        function createChild(returnFiber, newChild, lanes) {
+          if ("string" === typeof newChild && "" !== newChild || "number" === typeof newChild || "bigint" === typeof newChild)
+            return newChild = createFiberFromText(
+              "" + newChild,
+              returnFiber.mode,
+              lanes
+            ), newChild.return = returnFiber, newChild;
+          if ("object" === typeof newChild && null !== newChild) {
+            switch (newChild.$$typeof) {
+              case REACT_ELEMENT_TYPE:
+                return lanes = createFiberFromTypeAndProps(
+                  newChild.type,
+                  newChild.key,
+                  newChild.props,
+                  null,
+                  returnFiber.mode,
+                  lanes
+                ), coerceRef(lanes, newChild), lanes.return = returnFiber, lanes;
+              case REACT_PORTAL_TYPE:
+                return newChild = createFiberFromPortal(
+                  newChild,
+                  returnFiber.mode,
+                  lanes
+                ), newChild.return = returnFiber, newChild;
+              case REACT_LAZY_TYPE2:
+                return newChild = resolveLazy(newChild), createChild(returnFiber, newChild, lanes);
+            }
+            if (isArrayImpl(newChild) || getIteratorFn(newChild))
+              return newChild = createFiberFromFragment(
+                newChild,
+                returnFiber.mode,
+                lanes,
+                null
+              ), newChild.return = returnFiber, newChild;
+            if ("function" === typeof newChild.then)
+              return createChild(returnFiber, unwrapThenable(newChild), lanes);
+            if (newChild.$$typeof === REACT_CONTEXT_TYPE)
+              return createChild(
+                returnFiber,
+                readContextDuringReconciliation(returnFiber, newChild),
+                lanes
+              );
+            throwOnInvalidObjectTypeImpl(returnFiber, newChild);
+          }
+          return null;
+        }
+        function updateSlot(returnFiber, oldFiber, newChild, lanes) {
+          var key = null !== oldFiber ? oldFiber.key : null;
+          if ("string" === typeof newChild && "" !== newChild || "number" === typeof newChild || "bigint" === typeof newChild)
+            return null !== key ? null : updateTextNode(returnFiber, oldFiber, "" + newChild, lanes);
+          if ("object" === typeof newChild && null !== newChild) {
+            switch (newChild.$$typeof) {
+              case REACT_ELEMENT_TYPE:
+                return newChild.key === key ? updateElement(returnFiber, oldFiber, newChild, lanes) : null;
+              case REACT_PORTAL_TYPE:
+                return newChild.key === key ? updatePortal(returnFiber, oldFiber, newChild, lanes) : null;
+              case REACT_LAZY_TYPE2:
+                return newChild = resolveLazy(newChild), updateSlot(returnFiber, oldFiber, newChild, lanes);
+            }
+            if (isArrayImpl(newChild) || getIteratorFn(newChild))
+              return null !== key ? null : updateFragment(returnFiber, oldFiber, newChild, lanes, null);
+            if ("function" === typeof newChild.then)
+              return updateSlot(
+                returnFiber,
+                oldFiber,
+                unwrapThenable(newChild),
+                lanes
+              );
+            if (newChild.$$typeof === REACT_CONTEXT_TYPE)
+              return updateSlot(
+                returnFiber,
+                oldFiber,
+                readContextDuringReconciliation(returnFiber, newChild),
+                lanes
+              );
+            throwOnInvalidObjectTypeImpl(returnFiber, newChild);
+          }
+          return null;
+        }
+        function updateFromMap(existingChildren, returnFiber, newIdx, newChild, lanes) {
+          if ("string" === typeof newChild && "" !== newChild || "number" === typeof newChild || "bigint" === typeof newChild)
+            return existingChildren = existingChildren.get(newIdx) || null, updateTextNode(returnFiber, existingChildren, "" + newChild, lanes);
+          if ("object" === typeof newChild && null !== newChild) {
+            switch (newChild.$$typeof) {
+              case REACT_ELEMENT_TYPE:
+                return existingChildren = existingChildren.get(
+                  null === newChild.key ? newIdx : newChild.key
+                ) || null, updateElement(returnFiber, existingChildren, newChild, lanes);
+              case REACT_PORTAL_TYPE:
+                return existingChildren = existingChildren.get(
+                  null === newChild.key ? newIdx : newChild.key
+                ) || null, updatePortal(returnFiber, existingChildren, newChild, lanes);
+              case REACT_LAZY_TYPE2:
+                return newChild = resolveLazy(newChild), updateFromMap(
+                  existingChildren,
+                  returnFiber,
+                  newIdx,
+                  newChild,
+                  lanes
+                );
+            }
+            if (isArrayImpl(newChild) || getIteratorFn(newChild))
+              return existingChildren = existingChildren.get(newIdx) || null, updateFragment(returnFiber, existingChildren, newChild, lanes, null);
+            if ("function" === typeof newChild.then)
+              return updateFromMap(
+                existingChildren,
+                returnFiber,
+                newIdx,
+                unwrapThenable(newChild),
+                lanes
+              );
+            if (newChild.$$typeof === REACT_CONTEXT_TYPE)
+              return updateFromMap(
+                existingChildren,
+                returnFiber,
+                newIdx,
+                readContextDuringReconciliation(returnFiber, newChild),
+                lanes
+              );
+            throwOnInvalidObjectTypeImpl(returnFiber, newChild);
+          }
+          return null;
+        }
+        function reconcileChildrenArray(returnFiber, currentFirstChild, newChildren, lanes) {
+          for (var resultingFirstChild = null, previousNewFiber = null, oldFiber = currentFirstChild, newIdx = currentFirstChild = 0, nextOldFiber = null; null !== oldFiber && newIdx < newChildren.length; newIdx++) {
+            oldFiber.index > newIdx ? (nextOldFiber = oldFiber, oldFiber = null) : nextOldFiber = oldFiber.sibling;
+            var newFiber = updateSlot(
+              returnFiber,
+              oldFiber,
+              newChildren[newIdx],
+              lanes
+            );
+            if (null === newFiber) {
+              null === oldFiber && (oldFiber = nextOldFiber);
+              break;
+            }
+            shouldTrackSideEffects && oldFiber && null === newFiber.alternate && deleteChild(returnFiber, oldFiber);
+            currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
+            null === previousNewFiber ? resultingFirstChild = newFiber : previousNewFiber.sibling = newFiber;
+            previousNewFiber = newFiber;
+            oldFiber = nextOldFiber;
+          }
+          if (newIdx === newChildren.length)
+            return deleteRemainingChildren(returnFiber, oldFiber), isHydrating && pushTreeFork(returnFiber, newIdx), resultingFirstChild;
+          if (null === oldFiber) {
+            for (; newIdx < newChildren.length; newIdx++)
+              oldFiber = createChild(returnFiber, newChildren[newIdx], lanes), null !== oldFiber && (currentFirstChild = placeChild(
+                oldFiber,
+                currentFirstChild,
+                newIdx
+              ), null === previousNewFiber ? resultingFirstChild = oldFiber : previousNewFiber.sibling = oldFiber, previousNewFiber = oldFiber);
+            isHydrating && pushTreeFork(returnFiber, newIdx);
+            return resultingFirstChild;
+          }
+          for (oldFiber = mapRemainingChildren(oldFiber); newIdx < newChildren.length; newIdx++)
+            nextOldFiber = updateFromMap(
+              oldFiber,
+              returnFiber,
+              newIdx,
+              newChildren[newIdx],
+              lanes
+            ), null !== nextOldFiber && (shouldTrackSideEffects && null !== nextOldFiber.alternate && oldFiber.delete(
+              null === nextOldFiber.key ? newIdx : nextOldFiber.key
+            ), currentFirstChild = placeChild(
+              nextOldFiber,
+              currentFirstChild,
+              newIdx
+            ), null === previousNewFiber ? resultingFirstChild = nextOldFiber : previousNewFiber.sibling = nextOldFiber, previousNewFiber = nextOldFiber);
+          shouldTrackSideEffects && oldFiber.forEach(function(child) {
+            return deleteChild(returnFiber, child);
+          });
+          isHydrating && pushTreeFork(returnFiber, newIdx);
+          return resultingFirstChild;
+        }
+        function reconcileChildrenIterator(returnFiber, currentFirstChild, newChildren, lanes) {
+          if (null == newChildren) throw Error(formatProdErrorMessage(151));
+          for (var resultingFirstChild = null, previousNewFiber = null, oldFiber = currentFirstChild, newIdx = currentFirstChild = 0, nextOldFiber = null, step = newChildren.next(); null !== oldFiber && !step.done; newIdx++, step = newChildren.next()) {
+            oldFiber.index > newIdx ? (nextOldFiber = oldFiber, oldFiber = null) : nextOldFiber = oldFiber.sibling;
+            var newFiber = updateSlot(returnFiber, oldFiber, step.value, lanes);
+            if (null === newFiber) {
+              null === oldFiber && (oldFiber = nextOldFiber);
+              break;
+            }
+            shouldTrackSideEffects && oldFiber && null === newFiber.alternate && deleteChild(returnFiber, oldFiber);
+            currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
+            null === previousNewFiber ? resultingFirstChild = newFiber : previousNewFiber.sibling = newFiber;
+            previousNewFiber = newFiber;
+            oldFiber = nextOldFiber;
+          }
+          if (step.done)
+            return deleteRemainingChildren(returnFiber, oldFiber), isHydrating && pushTreeFork(returnFiber, newIdx), resultingFirstChild;
+          if (null === oldFiber) {
+            for (; !step.done; newIdx++, step = newChildren.next())
+              step = createChild(returnFiber, step.value, lanes), null !== step && (currentFirstChild = placeChild(step, currentFirstChild, newIdx), null === previousNewFiber ? resultingFirstChild = step : previousNewFiber.sibling = step, previousNewFiber = step);
+            isHydrating && pushTreeFork(returnFiber, newIdx);
+            return resultingFirstChild;
+          }
+          for (oldFiber = mapRemainingChildren(oldFiber); !step.done; newIdx++, step = newChildren.next())
+            step = updateFromMap(oldFiber, returnFiber, newIdx, step.value, lanes), null !== step && (shouldTrackSideEffects && null !== step.alternate && oldFiber.delete(null === step.key ? newIdx : step.key), currentFirstChild = placeChild(step, currentFirstChild, newIdx), null === previousNewFiber ? resultingFirstChild = step : previousNewFiber.sibling = step, previousNewFiber = step);
+          shouldTrackSideEffects && oldFiber.forEach(function(child) {
+            return deleteChild(returnFiber, child);
+          });
+          isHydrating && pushTreeFork(returnFiber, newIdx);
+          return resultingFirstChild;
+        }
+        function reconcileChildFibersImpl(returnFiber, currentFirstChild, newChild, lanes) {
+          "object" === typeof newChild && null !== newChild && newChild.type === REACT_FRAGMENT_TYPE && null === newChild.key && (newChild = newChild.props.children);
+          if ("object" === typeof newChild && null !== newChild) {
+            switch (newChild.$$typeof) {
+              case REACT_ELEMENT_TYPE:
+                a: {
+                  for (var key = newChild.key; null !== currentFirstChild; ) {
+                    if (currentFirstChild.key === key) {
+                      key = newChild.type;
+                      if (key === REACT_FRAGMENT_TYPE) {
+                        if (7 === currentFirstChild.tag) {
+                          deleteRemainingChildren(
+                            returnFiber,
+                            currentFirstChild.sibling
+                          );
+                          lanes = useFiber(
+                            currentFirstChild,
+                            newChild.props.children
+                          );
+                          lanes.return = returnFiber;
+                          returnFiber = lanes;
+                          break a;
+                        }
+                      } else if (currentFirstChild.elementType === key || "object" === typeof key && null !== key && key.$$typeof === REACT_LAZY_TYPE2 && resolveLazy(key) === currentFirstChild.type) {
+                        deleteRemainingChildren(
+                          returnFiber,
+                          currentFirstChild.sibling
+                        );
+                        lanes = useFiber(currentFirstChild, newChild.props);
+                        coerceRef(lanes, newChild);
+                        lanes.return = returnFiber;
+                        returnFiber = lanes;
+                        break a;
+                      }
+                      deleteRemainingChildren(returnFiber, currentFirstChild);
+                      break;
+                    } else deleteChild(returnFiber, currentFirstChild);
+                    currentFirstChild = currentFirstChild.sibling;
+                  }
+                  newChild.type === REACT_FRAGMENT_TYPE ? (lanes = createFiberFromFragment(
+                    newChild.props.children,
+                    returnFiber.mode,
+                    lanes,
+                    newChild.key
+                  ), lanes.return = returnFiber, returnFiber = lanes) : (lanes = createFiberFromTypeAndProps(
+                    newChild.type,
+                    newChild.key,
+                    newChild.props,
+                    null,
+                    returnFiber.mode,
+                    lanes
+                  ), coerceRef(lanes, newChild), lanes.return = returnFiber, returnFiber = lanes);
+                }
+                return placeSingleChild(returnFiber);
+              case REACT_PORTAL_TYPE:
+                a: {
+                  for (key = newChild.key; null !== currentFirstChild; ) {
+                    if (currentFirstChild.key === key)
+                      if (4 === currentFirstChild.tag && currentFirstChild.stateNode.containerInfo === newChild.containerInfo && currentFirstChild.stateNode.implementation === newChild.implementation) {
+                        deleteRemainingChildren(
+                          returnFiber,
+                          currentFirstChild.sibling
+                        );
+                        lanes = useFiber(currentFirstChild, newChild.children || []);
+                        lanes.return = returnFiber;
+                        returnFiber = lanes;
+                        break a;
+                      } else {
+                        deleteRemainingChildren(returnFiber, currentFirstChild);
+                        break;
+                      }
+                    else deleteChild(returnFiber, currentFirstChild);
+                    currentFirstChild = currentFirstChild.sibling;
+                  }
+                  lanes = createFiberFromPortal(newChild, returnFiber.mode, lanes);
+                  lanes.return = returnFiber;
+                  returnFiber = lanes;
+                }
+                return placeSingleChild(returnFiber);
+              case REACT_LAZY_TYPE2:
+                return newChild = resolveLazy(newChild), reconcileChildFibersImpl(
+                  returnFiber,
+                  currentFirstChild,
+                  newChild,
+                  lanes
+                );
+            }
+            if (isArrayImpl(newChild))
+              return reconcileChildrenArray(
+                returnFiber,
+                currentFirstChild,
+                newChild,
+                lanes
+              );
+            if (getIteratorFn(newChild)) {
+              key = getIteratorFn(newChild);
+              if ("function" !== typeof key) throw Error(formatProdErrorMessage(150));
+              newChild = key.call(newChild);
+              return reconcileChildrenIterator(
+                returnFiber,
+                currentFirstChild,
+                newChild,
+                lanes
+              );
+            }
+            if ("function" === typeof newChild.then)
+              return reconcileChildFibersImpl(
+                returnFiber,
+                currentFirstChild,
+                unwrapThenable(newChild),
+                lanes
+              );
+            if (newChild.$$typeof === REACT_CONTEXT_TYPE)
+              return reconcileChildFibersImpl(
+                returnFiber,
+                currentFirstChild,
+                readContextDuringReconciliation(returnFiber, newChild),
+                lanes
+              );
+            throwOnInvalidObjectTypeImpl(returnFiber, newChild);
+          }
+          return "string" === typeof newChild && "" !== newChild || "number" === typeof newChild || "bigint" === typeof newChild ? (newChild = "" + newChild, null !== currentFirstChild && 6 === currentFirstChild.tag ? (deleteRemainingChildren(returnFiber, currentFirstChild.sibling), lanes = useFiber(currentFirstChild, newChild), lanes.return = returnFiber, returnFiber = lanes) : (deleteRemainingChildren(returnFiber, currentFirstChild), lanes = createFiberFromText(newChild, returnFiber.mode, lanes), lanes.return = returnFiber, returnFiber = lanes), placeSingleChild(returnFiber)) : deleteRemainingChildren(returnFiber, currentFirstChild);
+        }
+        return function(returnFiber, currentFirstChild, newChild, lanes) {
+          try {
+            thenableIndexCounter$1 = 0;
+            var firstChildFiber = reconcileChildFibersImpl(
+              returnFiber,
+              currentFirstChild,
+              newChild,
+              lanes
+            );
+            thenableState$1 = null;
+            return firstChildFiber;
+          } catch (x) {
+            if (x === SuspenseException || x === SuspenseActionException) throw x;
+            var fiber = createFiberImplClass(29, x, null, returnFiber.mode);
+            fiber.lanes = lanes;
+            fiber.return = returnFiber;
+            return fiber;
+          } finally {
+          }
+        };
+      }
+      var reconcileChildFibers = createChildReconciler(true);
+      var mountChildFibers = createChildReconciler(false);
+      var hasForceUpdate = false;
+      function initializeUpdateQueue(fiber) {
+        fiber.updateQueue = {
+          baseState: fiber.memoizedState,
+          firstBaseUpdate: null,
+          lastBaseUpdate: null,
+          shared: { pending: null, lanes: 0, hiddenCallbacks: null },
+          callbacks: null
+        };
+      }
+      function cloneUpdateQueue(current, workInProgress2) {
+        current = current.updateQueue;
+        workInProgress2.updateQueue === current && (workInProgress2.updateQueue = {
+          baseState: current.baseState,
+          firstBaseUpdate: current.firstBaseUpdate,
+          lastBaseUpdate: current.lastBaseUpdate,
+          shared: current.shared,
+          callbacks: null
+        });
+      }
+      function createUpdate(lane) {
+        return { lane, tag: 0, payload: null, callback: null, next: null };
+      }
+      function enqueueUpdate(fiber, update, lane) {
+        var updateQueue = fiber.updateQueue;
+        if (null === updateQueue) return null;
+        updateQueue = updateQueue.shared;
+        if (0 !== (executionContext & 2)) {
+          var pending = updateQueue.pending;
+          null === pending ? update.next = update : (update.next = pending.next, pending.next = update);
+          updateQueue.pending = update;
+          update = getRootForUpdatedFiber(fiber);
+          markUpdateLaneFromFiberToRoot(fiber, null, lane);
+          return update;
+        }
+        enqueueUpdate$1(fiber, updateQueue, update, lane);
+        return getRootForUpdatedFiber(fiber);
+      }
+      function entangleTransitions(root2, fiber, lane) {
+        fiber = fiber.updateQueue;
+        if (null !== fiber && (fiber = fiber.shared, 0 !== (lane & 4194048))) {
+          var queueLanes = fiber.lanes;
+          queueLanes &= root2.pendingLanes;
+          lane |= queueLanes;
+          fiber.lanes = lane;
+          markRootEntangled(root2, lane);
+        }
+      }
+      function enqueueCapturedUpdate(workInProgress2, capturedUpdate) {
+        var queue = workInProgress2.updateQueue, current = workInProgress2.alternate;
+        if (null !== current && (current = current.updateQueue, queue === current)) {
+          var newFirst = null, newLast = null;
+          queue = queue.firstBaseUpdate;
+          if (null !== queue) {
+            do {
+              var clone = {
+                lane: queue.lane,
+                tag: queue.tag,
+                payload: queue.payload,
+                callback: null,
+                next: null
+              };
+              null === newLast ? newFirst = newLast = clone : newLast = newLast.next = clone;
+              queue = queue.next;
+            } while (null !== queue);
+            null === newLast ? newFirst = newLast = capturedUpdate : newLast = newLast.next = capturedUpdate;
+          } else newFirst = newLast = capturedUpdate;
+          queue = {
+            baseState: current.baseState,
+            firstBaseUpdate: newFirst,
+            lastBaseUpdate: newLast,
+            shared: current.shared,
+            callbacks: current.callbacks
+          };
+          workInProgress2.updateQueue = queue;
+          return;
+        }
+        workInProgress2 = queue.lastBaseUpdate;
+        null === workInProgress2 ? queue.firstBaseUpdate = capturedUpdate : workInProgress2.next = capturedUpdate;
+        queue.lastBaseUpdate = capturedUpdate;
+      }
+      var didReadFromEntangledAsyncAction = false;
+      function suspendIfUpdateReadFromEntangledAsyncAction() {
+        if (didReadFromEntangledAsyncAction) {
+          var entangledActionThenable = currentEntangledActionThenable;
+          if (null !== entangledActionThenable) throw entangledActionThenable;
+        }
+      }
+      function processUpdateQueue(workInProgress$jscomp$0, props, instance$jscomp$0, renderLanes2) {
+        didReadFromEntangledAsyncAction = false;
+        var queue = workInProgress$jscomp$0.updateQueue;
+        hasForceUpdate = false;
+        var firstBaseUpdate = queue.firstBaseUpdate, lastBaseUpdate = queue.lastBaseUpdate, pendingQueue = queue.shared.pending;
+        if (null !== pendingQueue) {
+          queue.shared.pending = null;
+          var lastPendingUpdate = pendingQueue, firstPendingUpdate = lastPendingUpdate.next;
+          lastPendingUpdate.next = null;
+          null === lastBaseUpdate ? firstBaseUpdate = firstPendingUpdate : lastBaseUpdate.next = firstPendingUpdate;
+          lastBaseUpdate = lastPendingUpdate;
+          var current = workInProgress$jscomp$0.alternate;
+          null !== current && (current = current.updateQueue, pendingQueue = current.lastBaseUpdate, pendingQueue !== lastBaseUpdate && (null === pendingQueue ? current.firstBaseUpdate = firstPendingUpdate : pendingQueue.next = firstPendingUpdate, current.lastBaseUpdate = lastPendingUpdate));
+        }
+        if (null !== firstBaseUpdate) {
+          var newState = queue.baseState;
+          lastBaseUpdate = 0;
+          current = firstPendingUpdate = lastPendingUpdate = null;
+          pendingQueue = firstBaseUpdate;
+          do {
+            var updateLane = pendingQueue.lane & -536870913, isHiddenUpdate = updateLane !== pendingQueue.lane;
+            if (isHiddenUpdate ? (workInProgressRootRenderLanes & updateLane) === updateLane : (renderLanes2 & updateLane) === updateLane) {
+              0 !== updateLane && updateLane === currentEntangledLane && (didReadFromEntangledAsyncAction = true);
+              null !== current && (current = current.next = {
+                lane: 0,
+                tag: pendingQueue.tag,
+                payload: pendingQueue.payload,
+                callback: null,
+                next: null
+              });
+              a: {
+                var workInProgress2 = workInProgress$jscomp$0, update = pendingQueue;
+                updateLane = props;
+                var instance = instance$jscomp$0;
+                switch (update.tag) {
+                  case 1:
+                    workInProgress2 = update.payload;
+                    if ("function" === typeof workInProgress2) {
+                      newState = workInProgress2.call(instance, newState, updateLane);
+                      break a;
+                    }
+                    newState = workInProgress2;
+                    break a;
+                  case 3:
+                    workInProgress2.flags = workInProgress2.flags & -65537 | 128;
+                  case 0:
+                    workInProgress2 = update.payload;
+                    updateLane = "function" === typeof workInProgress2 ? workInProgress2.call(instance, newState, updateLane) : workInProgress2;
+                    if (null === updateLane || void 0 === updateLane) break a;
+                    newState = assign({}, newState, updateLane);
+                    break a;
+                  case 2:
+                    hasForceUpdate = true;
+                }
+              }
+              updateLane = pendingQueue.callback;
+              null !== updateLane && (workInProgress$jscomp$0.flags |= 64, isHiddenUpdate && (workInProgress$jscomp$0.flags |= 8192), isHiddenUpdate = queue.callbacks, null === isHiddenUpdate ? queue.callbacks = [updateLane] : isHiddenUpdate.push(updateLane));
+            } else
+              isHiddenUpdate = {
+                lane: updateLane,
+                tag: pendingQueue.tag,
+                payload: pendingQueue.payload,
+                callback: pendingQueue.callback,
+                next: null
+              }, null === current ? (firstPendingUpdate = current = isHiddenUpdate, lastPendingUpdate = newState) : current = current.next = isHiddenUpdate, lastBaseUpdate |= updateLane;
+            pendingQueue = pendingQueue.next;
+            if (null === pendingQueue)
+              if (pendingQueue = queue.shared.pending, null === pendingQueue)
+                break;
+              else
+                isHiddenUpdate = pendingQueue, pendingQueue = isHiddenUpdate.next, isHiddenUpdate.next = null, queue.lastBaseUpdate = isHiddenUpdate, queue.shared.pending = null;
+          } while (1);
+          null === current && (lastPendingUpdate = newState);
+          queue.baseState = lastPendingUpdate;
+          queue.firstBaseUpdate = firstPendingUpdate;
+          queue.lastBaseUpdate = current;
+          null === firstBaseUpdate && (queue.shared.lanes = 0);
+          workInProgressRootSkippedLanes |= lastBaseUpdate;
+          workInProgress$jscomp$0.lanes = lastBaseUpdate;
+          workInProgress$jscomp$0.memoizedState = newState;
+        }
+      }
+      function callCallback(callback, context) {
+        if ("function" !== typeof callback)
+          throw Error(formatProdErrorMessage(191, callback));
+        callback.call(context);
+      }
+      function commitCallbacks(updateQueue, context) {
+        var callbacks = updateQueue.callbacks;
+        if (null !== callbacks)
+          for (updateQueue.callbacks = null, updateQueue = 0; updateQueue < callbacks.length; updateQueue++)
+            callCallback(callbacks[updateQueue], context);
+      }
+      var currentTreeHiddenStackCursor = createCursor(null);
+      var prevEntangledRenderLanesCursor = createCursor(0);
+      function pushHiddenContext(fiber, context) {
+        fiber = entangledRenderLanes;
+        push(prevEntangledRenderLanesCursor, fiber);
+        push(currentTreeHiddenStackCursor, context);
+        entangledRenderLanes = fiber | context.baseLanes;
+      }
+      function reuseHiddenContextOnStack() {
+        push(prevEntangledRenderLanesCursor, entangledRenderLanes);
+        push(currentTreeHiddenStackCursor, currentTreeHiddenStackCursor.current);
+      }
+      function popHiddenContext() {
+        entangledRenderLanes = prevEntangledRenderLanesCursor.current;
+        pop(currentTreeHiddenStackCursor);
+        pop(prevEntangledRenderLanesCursor);
+      }
+      var suspenseHandlerStackCursor = createCursor(null);
+      var shellBoundary = null;
+      function pushPrimaryTreeSuspenseHandler(handler) {
+        var current = handler.alternate;
+        push(suspenseStackCursor, suspenseStackCursor.current & 1);
+        push(suspenseHandlerStackCursor, handler);
+        null === shellBoundary && (null === current || null !== currentTreeHiddenStackCursor.current ? shellBoundary = handler : null !== current.memoizedState && (shellBoundary = handler));
+      }
+      function pushDehydratedActivitySuspenseHandler(fiber) {
+        push(suspenseStackCursor, suspenseStackCursor.current);
+        push(suspenseHandlerStackCursor, fiber);
+        null === shellBoundary && (shellBoundary = fiber);
+      }
+      function pushOffscreenSuspenseHandler(fiber) {
+        22 === fiber.tag ? (push(suspenseStackCursor, suspenseStackCursor.current), push(suspenseHandlerStackCursor, fiber), null === shellBoundary && (shellBoundary = fiber)) : reuseSuspenseHandlerOnStack(fiber);
+      }
+      function reuseSuspenseHandlerOnStack() {
+        push(suspenseStackCursor, suspenseStackCursor.current);
+        push(suspenseHandlerStackCursor, suspenseHandlerStackCursor.current);
+      }
+      function popSuspenseHandler(fiber) {
+        pop(suspenseHandlerStackCursor);
+        shellBoundary === fiber && (shellBoundary = null);
+        pop(suspenseStackCursor);
+      }
+      var suspenseStackCursor = createCursor(0);
+      function findFirstSuspended(row) {
+        for (var node = row; null !== node; ) {
+          if (13 === node.tag) {
+            var state = node.memoizedState;
+            if (null !== state && (state = state.dehydrated, null === state || isSuspenseInstancePending(state) || isSuspenseInstanceFallback(state)))
+              return node;
+          } else if (19 === node.tag && ("forwards" === node.memoizedProps.revealOrder || "backwards" === node.memoizedProps.revealOrder || "unstable_legacy-backwards" === node.memoizedProps.revealOrder || "together" === node.memoizedProps.revealOrder)) {
+            if (0 !== (node.flags & 128)) return node;
+          } else if (null !== node.child) {
+            node.child.return = node;
+            node = node.child;
+            continue;
+          }
+          if (node === row) break;
+          for (; null === node.sibling; ) {
+            if (null === node.return || node.return === row) return null;
+            node = node.return;
+          }
+          node.sibling.return = node.return;
+          node = node.sibling;
+        }
+        return null;
+      }
+      var renderLanes = 0;
+      var currentlyRenderingFiber = null;
+      var currentHook = null;
+      var workInProgressHook = null;
+      var didScheduleRenderPhaseUpdate = false;
+      var didScheduleRenderPhaseUpdateDuringThisPass = false;
+      var shouldDoubleInvokeUserFnsInHooksDEV = false;
+      var localIdCounter = 0;
+      var thenableIndexCounter = 0;
+      var thenableState = null;
+      var globalClientIdCounter = 0;
+      function throwInvalidHookError() {
+        throw Error(formatProdErrorMessage(321));
+      }
+      function areHookInputsEqual(nextDeps, prevDeps) {
+        if (null === prevDeps) return false;
+        for (var i = 0; i < prevDeps.length && i < nextDeps.length; i++)
+          if (!objectIs(nextDeps[i], prevDeps[i])) return false;
+        return true;
+      }
+      function renderWithHooks(current, workInProgress2, Component, props, secondArg, nextRenderLanes) {
+        renderLanes = nextRenderLanes;
+        currentlyRenderingFiber = workInProgress2;
+        workInProgress2.memoizedState = null;
+        workInProgress2.updateQueue = null;
+        workInProgress2.lanes = 0;
+        ReactSharedInternals.H = null === current || null === current.memoizedState ? HooksDispatcherOnMount : HooksDispatcherOnUpdate;
+        shouldDoubleInvokeUserFnsInHooksDEV = false;
+        nextRenderLanes = Component(props, secondArg);
+        shouldDoubleInvokeUserFnsInHooksDEV = false;
+        didScheduleRenderPhaseUpdateDuringThisPass && (nextRenderLanes = renderWithHooksAgain(
+          workInProgress2,
+          Component,
+          props,
+          secondArg
+        ));
+        finishRenderingHooks(current);
+        return nextRenderLanes;
+      }
+      function finishRenderingHooks(current) {
+        ReactSharedInternals.H = ContextOnlyDispatcher;
+        var didRenderTooFewHooks = null !== currentHook && null !== currentHook.next;
+        renderLanes = 0;
+        workInProgressHook = currentHook = currentlyRenderingFiber = null;
+        didScheduleRenderPhaseUpdate = false;
+        thenableIndexCounter = 0;
+        thenableState = null;
+        if (didRenderTooFewHooks) throw Error(formatProdErrorMessage(300));
+        null === current || didReceiveUpdate || (current = current.dependencies, null !== current && checkIfContextChanged(current) && (didReceiveUpdate = true));
+      }
+      function renderWithHooksAgain(workInProgress2, Component, props, secondArg) {
+        currentlyRenderingFiber = workInProgress2;
+        var numberOfReRenders = 0;
+        do {
+          didScheduleRenderPhaseUpdateDuringThisPass && (thenableState = null);
+          thenableIndexCounter = 0;
+          didScheduleRenderPhaseUpdateDuringThisPass = false;
+          if (25 <= numberOfReRenders) throw Error(formatProdErrorMessage(301));
+          numberOfReRenders += 1;
+          workInProgressHook = currentHook = null;
+          if (null != workInProgress2.updateQueue) {
+            var children = workInProgress2.updateQueue;
+            children.lastEffect = null;
+            children.events = null;
+            children.stores = null;
+            null != children.memoCache && (children.memoCache.index = 0);
+          }
+          ReactSharedInternals.H = HooksDispatcherOnRerender;
+          children = Component(props, secondArg);
+        } while (didScheduleRenderPhaseUpdateDuringThisPass);
+        return children;
+      }
+      function TransitionAwareHostComponent() {
+        var dispatcher = ReactSharedInternals.H, maybeThenable = dispatcher.useState()[0];
+        maybeThenable = "function" === typeof maybeThenable.then ? useThenable(maybeThenable) : maybeThenable;
+        dispatcher = dispatcher.useState()[0];
+        (null !== currentHook ? currentHook.memoizedState : null) !== dispatcher && (currentlyRenderingFiber.flags |= 1024);
+        return maybeThenable;
+      }
+      function checkDidRenderIdHook() {
+        var didRenderIdHook = 0 !== localIdCounter;
+        localIdCounter = 0;
+        return didRenderIdHook;
+      }
+      function bailoutHooks(current, workInProgress2, lanes) {
+        workInProgress2.updateQueue = current.updateQueue;
+        workInProgress2.flags &= -2053;
+        current.lanes &= ~lanes;
+      }
+      function resetHooksOnUnwind(workInProgress2) {
+        if (didScheduleRenderPhaseUpdate) {
+          for (workInProgress2 = workInProgress2.memoizedState; null !== workInProgress2; ) {
+            var queue = workInProgress2.queue;
+            null !== queue && (queue.pending = null);
+            workInProgress2 = workInProgress2.next;
+          }
+          didScheduleRenderPhaseUpdate = false;
+        }
+        renderLanes = 0;
+        workInProgressHook = currentHook = currentlyRenderingFiber = null;
+        didScheduleRenderPhaseUpdateDuringThisPass = false;
+        thenableIndexCounter = localIdCounter = 0;
+        thenableState = null;
+      }
+      function mountWorkInProgressHook() {
+        var hook = {
+          memoizedState: null,
+          baseState: null,
+          baseQueue: null,
+          queue: null,
+          next: null
+        };
+        null === workInProgressHook ? currentlyRenderingFiber.memoizedState = workInProgressHook = hook : workInProgressHook = workInProgressHook.next = hook;
+        return workInProgressHook;
+      }
+      function updateWorkInProgressHook() {
+        if (null === currentHook) {
+          var nextCurrentHook = currentlyRenderingFiber.alternate;
+          nextCurrentHook = null !== nextCurrentHook ? nextCurrentHook.memoizedState : null;
+        } else nextCurrentHook = currentHook.next;
+        var nextWorkInProgressHook = null === workInProgressHook ? currentlyRenderingFiber.memoizedState : workInProgressHook.next;
+        if (null !== nextWorkInProgressHook)
+          workInProgressHook = nextWorkInProgressHook, currentHook = nextCurrentHook;
+        else {
+          if (null === nextCurrentHook) {
+            if (null === currentlyRenderingFiber.alternate)
+              throw Error(formatProdErrorMessage(467));
+            throw Error(formatProdErrorMessage(310));
+          }
+          currentHook = nextCurrentHook;
+          nextCurrentHook = {
+            memoizedState: currentHook.memoizedState,
+            baseState: currentHook.baseState,
+            baseQueue: currentHook.baseQueue,
+            queue: currentHook.queue,
+            next: null
+          };
+          null === workInProgressHook ? currentlyRenderingFiber.memoizedState = workInProgressHook = nextCurrentHook : workInProgressHook = workInProgressHook.next = nextCurrentHook;
+        }
+        return workInProgressHook;
+      }
+      function createFunctionComponentUpdateQueue() {
+        return { lastEffect: null, events: null, stores: null, memoCache: null };
+      }
+      function useThenable(thenable) {
+        var index3 = thenableIndexCounter;
+        thenableIndexCounter += 1;
+        null === thenableState && (thenableState = []);
+        thenable = trackUsedThenable(thenableState, thenable, index3);
+        index3 = currentlyRenderingFiber;
+        null === (null === workInProgressHook ? index3.memoizedState : workInProgressHook.next) && (index3 = index3.alternate, ReactSharedInternals.H = null === index3 || null === index3.memoizedState ? HooksDispatcherOnMount : HooksDispatcherOnUpdate);
+        return thenable;
+      }
+      function use2(usable) {
+        if (null !== usable && "object" === typeof usable) {
+          if ("function" === typeof usable.then) return useThenable(usable);
+          if (usable.$$typeof === REACT_CONTEXT_TYPE) return readContext(usable);
+        }
+        throw Error(formatProdErrorMessage(438, String(usable)));
+      }
+      function useMemoCache(size4) {
+        var memoCache = null, updateQueue = currentlyRenderingFiber.updateQueue;
+        null !== updateQueue && (memoCache = updateQueue.memoCache);
+        if (null == memoCache) {
+          var current = currentlyRenderingFiber.alternate;
+          null !== current && (current = current.updateQueue, null !== current && (current = current.memoCache, null != current && (memoCache = {
+            data: current.data.map(function(array) {
+              return array.slice();
+            }),
+            index: 0
+          })));
+        }
+        null == memoCache && (memoCache = { data: [], index: 0 });
+        null === updateQueue && (updateQueue = createFunctionComponentUpdateQueue(), currentlyRenderingFiber.updateQueue = updateQueue);
+        updateQueue.memoCache = memoCache;
+        updateQueue = memoCache.data[memoCache.index];
+        if (void 0 === updateQueue)
+          for (updateQueue = memoCache.data[memoCache.index] = Array(size4), current = 0; current < size4; current++)
+            updateQueue[current] = REACT_MEMO_CACHE_SENTINEL;
+        memoCache.index++;
+        return updateQueue;
+      }
+      function basicStateReducer(state, action) {
+        return "function" === typeof action ? action(state) : action;
+      }
+      function updateReducer(reducer) {
+        var hook = updateWorkInProgressHook();
+        return updateReducerImpl(hook, currentHook, reducer);
+      }
+      function updateReducerImpl(hook, current, reducer) {
+        var queue = hook.queue;
+        if (null === queue) throw Error(formatProdErrorMessage(311));
+        queue.lastRenderedReducer = reducer;
+        var baseQueue = hook.baseQueue, pendingQueue = queue.pending;
+        if (null !== pendingQueue) {
+          if (null !== baseQueue) {
+            var baseFirst = baseQueue.next;
+            baseQueue.next = pendingQueue.next;
+            pendingQueue.next = baseFirst;
+          }
+          current.baseQueue = baseQueue = pendingQueue;
+          queue.pending = null;
+        }
+        pendingQueue = hook.baseState;
+        if (null === baseQueue) hook.memoizedState = pendingQueue;
+        else {
+          current = baseQueue.next;
+          var newBaseQueueFirst = baseFirst = null, newBaseQueueLast = null, update = current, didReadFromEntangledAsyncAction$60 = false;
+          do {
+            var updateLane = update.lane & -536870913;
+            if (updateLane !== update.lane ? (workInProgressRootRenderLanes & updateLane) === updateLane : (renderLanes & updateLane) === updateLane) {
+              var revertLane = update.revertLane;
+              if (0 === revertLane)
+                null !== newBaseQueueLast && (newBaseQueueLast = newBaseQueueLast.next = {
+                  lane: 0,
+                  revertLane: 0,
+                  gesture: null,
+                  action: update.action,
+                  hasEagerState: update.hasEagerState,
+                  eagerState: update.eagerState,
+                  next: null
+                }), updateLane === currentEntangledLane && (didReadFromEntangledAsyncAction$60 = true);
+              else if ((renderLanes & revertLane) === revertLane) {
+                update = update.next;
+                revertLane === currentEntangledLane && (didReadFromEntangledAsyncAction$60 = true);
+                continue;
+              } else
+                updateLane = {
+                  lane: 0,
+                  revertLane: update.revertLane,
+                  gesture: null,
+                  action: update.action,
+                  hasEagerState: update.hasEagerState,
+                  eagerState: update.eagerState,
+                  next: null
+                }, null === newBaseQueueLast ? (newBaseQueueFirst = newBaseQueueLast = updateLane, baseFirst = pendingQueue) : newBaseQueueLast = newBaseQueueLast.next = updateLane, currentlyRenderingFiber.lanes |= revertLane, workInProgressRootSkippedLanes |= revertLane;
+              updateLane = update.action;
+              shouldDoubleInvokeUserFnsInHooksDEV && reducer(pendingQueue, updateLane);
+              pendingQueue = update.hasEagerState ? update.eagerState : reducer(pendingQueue, updateLane);
+            } else
+              revertLane = {
+                lane: updateLane,
+                revertLane: update.revertLane,
+                gesture: update.gesture,
+                action: update.action,
+                hasEagerState: update.hasEagerState,
+                eagerState: update.eagerState,
+                next: null
+              }, null === newBaseQueueLast ? (newBaseQueueFirst = newBaseQueueLast = revertLane, baseFirst = pendingQueue) : newBaseQueueLast = newBaseQueueLast.next = revertLane, currentlyRenderingFiber.lanes |= updateLane, workInProgressRootSkippedLanes |= updateLane;
+            update = update.next;
+          } while (null !== update && update !== current);
+          null === newBaseQueueLast ? baseFirst = pendingQueue : newBaseQueueLast.next = newBaseQueueFirst;
+          if (!objectIs(pendingQueue, hook.memoizedState) && (didReceiveUpdate = true, didReadFromEntangledAsyncAction$60 && (reducer = currentEntangledActionThenable, null !== reducer)))
+            throw reducer;
+          hook.memoizedState = pendingQueue;
+          hook.baseState = baseFirst;
+          hook.baseQueue = newBaseQueueLast;
+          queue.lastRenderedState = pendingQueue;
+        }
+        null === baseQueue && (queue.lanes = 0);
+        return [hook.memoizedState, queue.dispatch];
+      }
+      function rerenderReducer(reducer) {
+        var hook = updateWorkInProgressHook(), queue = hook.queue;
+        if (null === queue) throw Error(formatProdErrorMessage(311));
+        queue.lastRenderedReducer = reducer;
+        var dispatch = queue.dispatch, lastRenderPhaseUpdate = queue.pending, newState = hook.memoizedState;
+        if (null !== lastRenderPhaseUpdate) {
+          queue.pending = null;
+          var update = lastRenderPhaseUpdate = lastRenderPhaseUpdate.next;
+          do
+            newState = reducer(newState, update.action), update = update.next;
+          while (update !== lastRenderPhaseUpdate);
+          objectIs(newState, hook.memoizedState) || (didReceiveUpdate = true);
+          hook.memoizedState = newState;
+          null === hook.baseQueue && (hook.baseState = newState);
+          queue.lastRenderedState = newState;
+        }
+        return [newState, dispatch];
+      }
+      function updateSyncExternalStore(subscribe2, getSnapshot, getServerSnapshot) {
+        var fiber = currentlyRenderingFiber, hook = updateWorkInProgressHook(), isHydrating$jscomp$0 = isHydrating;
+        if (isHydrating$jscomp$0) {
+          if (void 0 === getServerSnapshot) throw Error(formatProdErrorMessage(407));
+          getServerSnapshot = getServerSnapshot();
+        } else getServerSnapshot = getSnapshot();
+        var snapshotChanged = !objectIs(
+          (currentHook || hook).memoizedState,
+          getServerSnapshot
+        );
+        snapshotChanged && (hook.memoizedState = getServerSnapshot, didReceiveUpdate = true);
+        hook = hook.queue;
+        updateEffect(subscribeToStore.bind(null, fiber, hook, subscribe2), [
+          subscribe2
+        ]);
+        if (hook.getSnapshot !== getSnapshot || snapshotChanged || null !== workInProgressHook && workInProgressHook.memoizedState.tag & 1) {
+          fiber.flags |= 2048;
+          pushSimpleEffect(
+            9,
+            { destroy: void 0 },
+            updateStoreInstance.bind(
+              null,
+              fiber,
+              hook,
+              getServerSnapshot,
+              getSnapshot
+            ),
+            null
+          );
+          if (null === workInProgressRoot) throw Error(formatProdErrorMessage(349));
+          isHydrating$jscomp$0 || 0 !== (renderLanes & 127) || pushStoreConsistencyCheck(fiber, getSnapshot, getServerSnapshot);
+        }
+        return getServerSnapshot;
+      }
+      function pushStoreConsistencyCheck(fiber, getSnapshot, renderedSnapshot) {
+        fiber.flags |= 16384;
+        fiber = { getSnapshot, value: renderedSnapshot };
+        getSnapshot = currentlyRenderingFiber.updateQueue;
+        null === getSnapshot ? (getSnapshot = createFunctionComponentUpdateQueue(), currentlyRenderingFiber.updateQueue = getSnapshot, getSnapshot.stores = [fiber]) : (renderedSnapshot = getSnapshot.stores, null === renderedSnapshot ? getSnapshot.stores = [fiber] : renderedSnapshot.push(fiber));
+      }
+      function updateStoreInstance(fiber, inst, nextSnapshot, getSnapshot) {
+        inst.value = nextSnapshot;
+        inst.getSnapshot = getSnapshot;
+        checkIfSnapshotChanged(inst) && forceStoreRerender(fiber);
+      }
+      function subscribeToStore(fiber, inst, subscribe2) {
+        return subscribe2(function() {
+          checkIfSnapshotChanged(inst) && forceStoreRerender(fiber);
+        });
+      }
+      function checkIfSnapshotChanged(inst) {
+        var latestGetSnapshot = inst.getSnapshot;
+        inst = inst.value;
+        try {
+          var nextValue = latestGetSnapshot();
+          return !objectIs(inst, nextValue);
+        } catch (error) {
+          return true;
+        }
+      }
+      function forceStoreRerender(fiber) {
+        var root2 = enqueueConcurrentRenderForLane(fiber, 2);
+        null !== root2 && scheduleUpdateOnFiber(root2, fiber, 2);
+      }
+      function mountStateImpl(initialState) {
+        var hook = mountWorkInProgressHook();
+        if ("function" === typeof initialState) {
+          var initialStateInitializer = initialState;
+          initialState = initialStateInitializer();
+          if (shouldDoubleInvokeUserFnsInHooksDEV) {
+            setIsStrictModeForDevtools(true);
+            try {
+              initialStateInitializer();
+            } finally {
+              setIsStrictModeForDevtools(false);
+            }
+          }
+        }
+        hook.memoizedState = hook.baseState = initialState;
+        hook.queue = {
+          pending: null,
+          lanes: 0,
+          dispatch: null,
+          lastRenderedReducer: basicStateReducer,
+          lastRenderedState: initialState
+        };
+        return hook;
+      }
+      function updateOptimisticImpl(hook, current, passthrough, reducer) {
+        hook.baseState = passthrough;
+        return updateReducerImpl(
+          hook,
+          currentHook,
+          "function" === typeof reducer ? reducer : basicStateReducer
+        );
+      }
+      function dispatchActionState(fiber, actionQueue, setPendingState, setState, payload) {
+        if (isRenderPhaseUpdate(fiber)) throw Error(formatProdErrorMessage(485));
+        fiber = actionQueue.action;
+        if (null !== fiber) {
+          var actionNode = {
+            payload,
+            action: fiber,
+            next: null,
+            isTransition: true,
+            status: "pending",
+            value: null,
+            reason: null,
+            listeners: [],
+            then: function(listener) {
+              actionNode.listeners.push(listener);
+            }
+          };
+          null !== ReactSharedInternals.T ? setPendingState(true) : actionNode.isTransition = false;
+          setState(actionNode);
+          setPendingState = actionQueue.pending;
+          null === setPendingState ? (actionNode.next = actionQueue.pending = actionNode, runActionStateAction(actionQueue, actionNode)) : (actionNode.next = setPendingState.next, actionQueue.pending = setPendingState.next = actionNode);
+        }
+      }
+      function runActionStateAction(actionQueue, node) {
+        var action = node.action, payload = node.payload, prevState = actionQueue.state;
+        if (node.isTransition) {
+          var prevTransition = ReactSharedInternals.T, currentTransition = {};
+          ReactSharedInternals.T = currentTransition;
+          try {
+            var returnValue = action(prevState, payload), onStartTransitionFinish = ReactSharedInternals.S;
+            null !== onStartTransitionFinish && onStartTransitionFinish(currentTransition, returnValue);
+            handleActionReturnValue(actionQueue, node, returnValue);
+          } catch (error) {
+            onActionError(actionQueue, node, error);
+          } finally {
+            null !== prevTransition && null !== currentTransition.types && (prevTransition.types = currentTransition.types), ReactSharedInternals.T = prevTransition;
+          }
+        } else
+          try {
+            prevTransition = action(prevState, payload), handleActionReturnValue(actionQueue, node, prevTransition);
+          } catch (error$66) {
+            onActionError(actionQueue, node, error$66);
+          }
+      }
+      function handleActionReturnValue(actionQueue, node, returnValue) {
+        null !== returnValue && "object" === typeof returnValue && "function" === typeof returnValue.then ? returnValue.then(
+          function(nextState) {
+            onActionSuccess(actionQueue, node, nextState);
+          },
+          function(error) {
+            return onActionError(actionQueue, node, error);
+          }
+        ) : onActionSuccess(actionQueue, node, returnValue);
+      }
+      function onActionSuccess(actionQueue, actionNode, nextState) {
+        actionNode.status = "fulfilled";
+        actionNode.value = nextState;
+        notifyActionListeners(actionNode);
+        actionQueue.state = nextState;
+        actionNode = actionQueue.pending;
+        null !== actionNode && (nextState = actionNode.next, nextState === actionNode ? actionQueue.pending = null : (nextState = nextState.next, actionNode.next = nextState, runActionStateAction(actionQueue, nextState)));
+      }
+      function onActionError(actionQueue, actionNode, error) {
+        var last = actionQueue.pending;
+        actionQueue.pending = null;
+        if (null !== last) {
+          last = last.next;
+          do
+            actionNode.status = "rejected", actionNode.reason = error, notifyActionListeners(actionNode), actionNode = actionNode.next;
+          while (actionNode !== last);
+        }
+        actionQueue.action = null;
+      }
+      function notifyActionListeners(actionNode) {
+        actionNode = actionNode.listeners;
+        for (var i = 0; i < actionNode.length; i++) (0, actionNode[i])();
+      }
+      function actionStateReducer(oldState, newState) {
+        return newState;
+      }
+      function mountActionState(action, initialStateProp) {
+        if (isHydrating) {
+          var ssrFormState = workInProgressRoot.formState;
+          if (null !== ssrFormState) {
+            a: {
+              var JSCompiler_inline_result = currentlyRenderingFiber;
+              if (isHydrating) {
+                if (nextHydratableInstance) {
+                  b: {
+                    var JSCompiler_inline_result$jscomp$0 = nextHydratableInstance;
+                    for (var inRootOrSingleton = rootOrSingletonContext; 8 !== JSCompiler_inline_result$jscomp$0.nodeType; ) {
+                      if (!inRootOrSingleton) {
+                        JSCompiler_inline_result$jscomp$0 = null;
+                        break b;
+                      }
+                      JSCompiler_inline_result$jscomp$0 = getNextHydratable(
+                        JSCompiler_inline_result$jscomp$0.nextSibling
+                      );
+                      if (null === JSCompiler_inline_result$jscomp$0) {
+                        JSCompiler_inline_result$jscomp$0 = null;
+                        break b;
+                      }
+                    }
+                    inRootOrSingleton = JSCompiler_inline_result$jscomp$0.data;
+                    JSCompiler_inline_result$jscomp$0 = "F!" === inRootOrSingleton || "F" === inRootOrSingleton ? JSCompiler_inline_result$jscomp$0 : null;
+                  }
+                  if (JSCompiler_inline_result$jscomp$0) {
+                    nextHydratableInstance = getNextHydratable(
+                      JSCompiler_inline_result$jscomp$0.nextSibling
+                    );
+                    JSCompiler_inline_result = "F!" === JSCompiler_inline_result$jscomp$0.data;
+                    break a;
+                  }
+                }
+                throwOnHydrationMismatch(JSCompiler_inline_result);
+              }
+              JSCompiler_inline_result = false;
+            }
+            JSCompiler_inline_result && (initialStateProp = ssrFormState[0]);
+          }
+        }
+        ssrFormState = mountWorkInProgressHook();
+        ssrFormState.memoizedState = ssrFormState.baseState = initialStateProp;
+        JSCompiler_inline_result = {
+          pending: null,
+          lanes: 0,
+          dispatch: null,
+          lastRenderedReducer: actionStateReducer,
+          lastRenderedState: initialStateProp
+        };
+        ssrFormState.queue = JSCompiler_inline_result;
+        ssrFormState = dispatchSetState.bind(
+          null,
+          currentlyRenderingFiber,
+          JSCompiler_inline_result
+        );
+        JSCompiler_inline_result.dispatch = ssrFormState;
+        JSCompiler_inline_result = mountStateImpl(false);
+        inRootOrSingleton = dispatchOptimisticSetState.bind(
+          null,
+          currentlyRenderingFiber,
+          false,
+          JSCompiler_inline_result.queue
+        );
+        JSCompiler_inline_result = mountWorkInProgressHook();
+        JSCompiler_inline_result$jscomp$0 = {
+          state: initialStateProp,
+          dispatch: null,
+          action,
+          pending: null
+        };
+        JSCompiler_inline_result.queue = JSCompiler_inline_result$jscomp$0;
+        ssrFormState = dispatchActionState.bind(
+          null,
+          currentlyRenderingFiber,
+          JSCompiler_inline_result$jscomp$0,
+          inRootOrSingleton,
+          ssrFormState
+        );
+        JSCompiler_inline_result$jscomp$0.dispatch = ssrFormState;
+        JSCompiler_inline_result.memoizedState = action;
+        return [initialStateProp, ssrFormState, false];
+      }
+      function updateActionState(action) {
+        var stateHook = updateWorkInProgressHook();
+        return updateActionStateImpl(stateHook, currentHook, action);
+      }
+      function updateActionStateImpl(stateHook, currentStateHook, action) {
+        currentStateHook = updateReducerImpl(
+          stateHook,
+          currentStateHook,
+          actionStateReducer
+        )[0];
+        stateHook = updateReducer(basicStateReducer)[0];
+        if ("object" === typeof currentStateHook && null !== currentStateHook && "function" === typeof currentStateHook.then)
+          try {
+            var state = useThenable(currentStateHook);
+          } catch (x) {
+            if (x === SuspenseException) throw SuspenseActionException;
+            throw x;
+          }
+        else state = currentStateHook;
+        currentStateHook = updateWorkInProgressHook();
+        var actionQueue = currentStateHook.queue, dispatch = actionQueue.dispatch;
+        action !== currentStateHook.memoizedState && (currentlyRenderingFiber.flags |= 2048, pushSimpleEffect(
+          9,
+          { destroy: void 0 },
+          actionStateActionEffect.bind(null, actionQueue, action),
+          null
+        ));
+        return [state, dispatch, stateHook];
+      }
+      function actionStateActionEffect(actionQueue, action) {
+        actionQueue.action = action;
+      }
+      function rerenderActionState(action) {
+        var stateHook = updateWorkInProgressHook(), currentStateHook = currentHook;
+        if (null !== currentStateHook)
+          return updateActionStateImpl(stateHook, currentStateHook, action);
+        updateWorkInProgressHook();
+        stateHook = stateHook.memoizedState;
+        currentStateHook = updateWorkInProgressHook();
+        var dispatch = currentStateHook.queue.dispatch;
+        currentStateHook.memoizedState = action;
+        return [stateHook, dispatch, false];
+      }
+      function pushSimpleEffect(tag, inst, create, deps) {
+        tag = { tag, create, deps, inst, next: null };
+        inst = currentlyRenderingFiber.updateQueue;
+        null === inst && (inst = createFunctionComponentUpdateQueue(), currentlyRenderingFiber.updateQueue = inst);
+        create = inst.lastEffect;
+        null === create ? inst.lastEffect = tag.next = tag : (deps = create.next, create.next = tag, tag.next = deps, inst.lastEffect = tag);
+        return tag;
+      }
+      function updateRef() {
+        return updateWorkInProgressHook().memoizedState;
+      }
+      function mountEffectImpl(fiberFlags, hookFlags, create, deps) {
+        var hook = mountWorkInProgressHook();
+        currentlyRenderingFiber.flags |= fiberFlags;
+        hook.memoizedState = pushSimpleEffect(
+          1 | hookFlags,
+          { destroy: void 0 },
+          create,
+          void 0 === deps ? null : deps
+        );
+      }
+      function updateEffectImpl(fiberFlags, hookFlags, create, deps) {
+        var hook = updateWorkInProgressHook();
+        deps = void 0 === deps ? null : deps;
+        var inst = hook.memoizedState.inst;
+        null !== currentHook && null !== deps && areHookInputsEqual(deps, currentHook.memoizedState.deps) ? hook.memoizedState = pushSimpleEffect(hookFlags, inst, create, deps) : (currentlyRenderingFiber.flags |= fiberFlags, hook.memoizedState = pushSimpleEffect(
+          1 | hookFlags,
+          inst,
+          create,
+          deps
+        ));
+      }
+      function mountEffect(create, deps) {
+        mountEffectImpl(8390656, 8, create, deps);
+      }
+      function updateEffect(create, deps) {
+        updateEffectImpl(2048, 8, create, deps);
+      }
+      function useEffectEventImpl(payload) {
+        currentlyRenderingFiber.flags |= 4;
+        var componentUpdateQueue = currentlyRenderingFiber.updateQueue;
+        if (null === componentUpdateQueue)
+          componentUpdateQueue = createFunctionComponentUpdateQueue(), currentlyRenderingFiber.updateQueue = componentUpdateQueue, componentUpdateQueue.events = [payload];
+        else {
+          var events = componentUpdateQueue.events;
+          null === events ? componentUpdateQueue.events = [payload] : events.push(payload);
+        }
+      }
+      function updateEvent(callback) {
+        var ref = updateWorkInProgressHook().memoizedState;
+        useEffectEventImpl({ ref, nextImpl: callback });
+        return function() {
+          if (0 !== (executionContext & 2)) throw Error(formatProdErrorMessage(440));
+          return ref.impl.apply(void 0, arguments);
+        };
+      }
+      function updateInsertionEffect(create, deps) {
+        return updateEffectImpl(4, 2, create, deps);
+      }
+      function updateLayoutEffect(create, deps) {
+        return updateEffectImpl(4, 4, create, deps);
+      }
+      function imperativeHandleEffect(create, ref) {
+        if ("function" === typeof ref) {
+          create = create();
+          var refCleanup = ref(create);
+          return function() {
+            "function" === typeof refCleanup ? refCleanup() : ref(null);
+          };
+        }
+        if (null !== ref && void 0 !== ref)
+          return create = create(), ref.current = create, function() {
+            ref.current = null;
+          };
+      }
+      function updateImperativeHandle(ref, create, deps) {
+        deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
+        updateEffectImpl(4, 4, imperativeHandleEffect.bind(null, create, ref), deps);
+      }
+      function mountDebugValue() {
+      }
+      function updateCallback(callback, deps) {
+        var hook = updateWorkInProgressHook();
+        deps = void 0 === deps ? null : deps;
+        var prevState = hook.memoizedState;
+        if (null !== deps && areHookInputsEqual(deps, prevState[1]))
+          return prevState[0];
+        hook.memoizedState = [callback, deps];
+        return callback;
+      }
+      function updateMemo(nextCreate, deps) {
+        var hook = updateWorkInProgressHook();
+        deps = void 0 === deps ? null : deps;
+        var prevState = hook.memoizedState;
+        if (null !== deps && areHookInputsEqual(deps, prevState[1]))
+          return prevState[0];
+        prevState = nextCreate();
+        if (shouldDoubleInvokeUserFnsInHooksDEV) {
+          setIsStrictModeForDevtools(true);
+          try {
+            nextCreate();
+          } finally {
+            setIsStrictModeForDevtools(false);
+          }
+        }
+        hook.memoizedState = [prevState, deps];
+        return prevState;
+      }
+      function mountDeferredValueImpl(hook, value, initialValue) {
+        if (void 0 === initialValue || 0 !== (renderLanes & 1073741824) && 0 === (workInProgressRootRenderLanes & 261930))
+          return hook.memoizedState = value;
+        hook.memoizedState = initialValue;
+        hook = requestDeferredLane();
+        currentlyRenderingFiber.lanes |= hook;
+        workInProgressRootSkippedLanes |= hook;
+        return initialValue;
+      }
+      function updateDeferredValueImpl(hook, prevValue, value, initialValue) {
+        if (objectIs(value, prevValue)) return value;
+        if (null !== currentTreeHiddenStackCursor.current)
+          return hook = mountDeferredValueImpl(hook, value, initialValue), objectIs(hook, prevValue) || (didReceiveUpdate = true), hook;
+        if (0 === (renderLanes & 42) || 0 !== (renderLanes & 1073741824) && 0 === (workInProgressRootRenderLanes & 261930))
+          return didReceiveUpdate = true, hook.memoizedState = value;
+        hook = requestDeferredLane();
+        currentlyRenderingFiber.lanes |= hook;
+        workInProgressRootSkippedLanes |= hook;
+        return prevValue;
+      }
+      function startTransition(fiber, queue, pendingState, finishedState, callback) {
+        var previousPriority = ReactDOMSharedInternals.p;
+        ReactDOMSharedInternals.p = 0 !== previousPriority && 8 > previousPriority ? previousPriority : 8;
+        var prevTransition = ReactSharedInternals.T, currentTransition = {};
+        ReactSharedInternals.T = currentTransition;
+        dispatchOptimisticSetState(fiber, false, queue, pendingState);
+        try {
+          var returnValue = callback(), onStartTransitionFinish = ReactSharedInternals.S;
+          null !== onStartTransitionFinish && onStartTransitionFinish(currentTransition, returnValue);
+          if (null !== returnValue && "object" === typeof returnValue && "function" === typeof returnValue.then) {
+            var thenableForFinishedState = chainThenableValue(
+              returnValue,
+              finishedState
+            );
+            dispatchSetStateInternal(
+              fiber,
+              queue,
+              thenableForFinishedState,
+              requestUpdateLane(fiber)
+            );
+          } else
+            dispatchSetStateInternal(
+              fiber,
+              queue,
+              finishedState,
+              requestUpdateLane(fiber)
+            );
+        } catch (error) {
+          dispatchSetStateInternal(
+            fiber,
+            queue,
+            { then: function() {
+            }, status: "rejected", reason: error },
+            requestUpdateLane()
+          );
+        } finally {
+          ReactDOMSharedInternals.p = previousPriority, null !== prevTransition && null !== currentTransition.types && (prevTransition.types = currentTransition.types), ReactSharedInternals.T = prevTransition;
+        }
+      }
+      function noop3() {
+      }
+      function startHostTransition(formFiber, pendingState, action, formData) {
+        if (5 !== formFiber.tag) throw Error(formatProdErrorMessage(476));
+        var queue = ensureFormComponentIsStateful(formFiber).queue;
+        startTransition(
+          formFiber,
+          queue,
+          pendingState,
+          sharedNotPendingObject,
+          null === action ? noop3 : function() {
+            requestFormReset$1(formFiber);
+            return action(formData);
+          }
+        );
+      }
+      function ensureFormComponentIsStateful(formFiber) {
+        var existingStateHook = formFiber.memoizedState;
+        if (null !== existingStateHook) return existingStateHook;
+        existingStateHook = {
+          memoizedState: sharedNotPendingObject,
+          baseState: sharedNotPendingObject,
+          baseQueue: null,
+          queue: {
+            pending: null,
+            lanes: 0,
+            dispatch: null,
+            lastRenderedReducer: basicStateReducer,
+            lastRenderedState: sharedNotPendingObject
+          },
+          next: null
+        };
+        var initialResetState = {};
+        existingStateHook.next = {
+          memoizedState: initialResetState,
+          baseState: initialResetState,
+          baseQueue: null,
+          queue: {
+            pending: null,
+            lanes: 0,
+            dispatch: null,
+            lastRenderedReducer: basicStateReducer,
+            lastRenderedState: initialResetState
+          },
+          next: null
+        };
+        formFiber.memoizedState = existingStateHook;
+        formFiber = formFiber.alternate;
+        null !== formFiber && (formFiber.memoizedState = existingStateHook);
+        return existingStateHook;
+      }
+      function requestFormReset$1(formFiber) {
+        var stateHook = ensureFormComponentIsStateful(formFiber);
+        null === stateHook.next && (stateHook = formFiber.alternate.memoizedState);
+        dispatchSetStateInternal(
+          formFiber,
+          stateHook.next.queue,
+          {},
+          requestUpdateLane()
+        );
+      }
+      function useHostTransitionStatus() {
+        return readContext(HostTransitionContext);
+      }
+      function updateId() {
+        return updateWorkInProgressHook().memoizedState;
+      }
+      function updateRefresh() {
+        return updateWorkInProgressHook().memoizedState;
+      }
+      function refreshCache(fiber) {
+        for (var provider = fiber.return; null !== provider; ) {
+          switch (provider.tag) {
+            case 24:
+            case 3:
+              var lane = requestUpdateLane();
+              fiber = createUpdate(lane);
+              var root$69 = enqueueUpdate(provider, fiber, lane);
+              null !== root$69 && (scheduleUpdateOnFiber(root$69, provider, lane), entangleTransitions(root$69, provider, lane));
+              provider = { cache: createCache() };
+              fiber.payload = provider;
+              return;
+          }
+          provider = provider.return;
+        }
+      }
+      function dispatchReducerAction(fiber, queue, action) {
+        var lane = requestUpdateLane();
+        action = {
+          lane,
+          revertLane: 0,
+          gesture: null,
+          action,
+          hasEagerState: false,
+          eagerState: null,
+          next: null
+        };
+        isRenderPhaseUpdate(fiber) ? enqueueRenderPhaseUpdate(queue, action) : (action = enqueueConcurrentHookUpdate(fiber, queue, action, lane), null !== action && (scheduleUpdateOnFiber(action, fiber, lane), entangleTransitionUpdate(action, queue, lane)));
+      }
+      function dispatchSetState(fiber, queue, action) {
+        var lane = requestUpdateLane();
+        dispatchSetStateInternal(fiber, queue, action, lane);
+      }
+      function dispatchSetStateInternal(fiber, queue, action, lane) {
+        var update = {
+          lane,
+          revertLane: 0,
+          gesture: null,
+          action,
+          hasEagerState: false,
+          eagerState: null,
+          next: null
+        };
+        if (isRenderPhaseUpdate(fiber)) enqueueRenderPhaseUpdate(queue, update);
+        else {
+          var alternate = fiber.alternate;
+          if (0 === fiber.lanes && (null === alternate || 0 === alternate.lanes) && (alternate = queue.lastRenderedReducer, null !== alternate))
+            try {
+              var currentState = queue.lastRenderedState, eagerState = alternate(currentState, action);
+              update.hasEagerState = true;
+              update.eagerState = eagerState;
+              if (objectIs(eagerState, currentState))
+                return enqueueUpdate$1(fiber, queue, update, 0), null === workInProgressRoot && finishQueueingConcurrentUpdates(), false;
+            } catch (error) {
+            } finally {
+            }
+          action = enqueueConcurrentHookUpdate(fiber, queue, update, lane);
+          if (null !== action)
+            return scheduleUpdateOnFiber(action, fiber, lane), entangleTransitionUpdate(action, queue, lane), true;
+        }
+        return false;
+      }
+      function dispatchOptimisticSetState(fiber, throwIfDuringRender, queue, action) {
+        action = {
+          lane: 2,
+          revertLane: requestTransitionLane(),
+          gesture: null,
+          action,
+          hasEagerState: false,
+          eagerState: null,
+          next: null
+        };
+        if (isRenderPhaseUpdate(fiber)) {
+          if (throwIfDuringRender) throw Error(formatProdErrorMessage(479));
+        } else
+          throwIfDuringRender = enqueueConcurrentHookUpdate(
+            fiber,
+            queue,
+            action,
+            2
+          ), null !== throwIfDuringRender && scheduleUpdateOnFiber(throwIfDuringRender, fiber, 2);
+      }
+      function isRenderPhaseUpdate(fiber) {
+        var alternate = fiber.alternate;
+        return fiber === currentlyRenderingFiber || null !== alternate && alternate === currentlyRenderingFiber;
+      }
+      function enqueueRenderPhaseUpdate(queue, update) {
+        didScheduleRenderPhaseUpdateDuringThisPass = didScheduleRenderPhaseUpdate = true;
+        var pending = queue.pending;
+        null === pending ? update.next = update : (update.next = pending.next, pending.next = update);
+        queue.pending = update;
+      }
+      function entangleTransitionUpdate(root2, queue, lane) {
+        if (0 !== (lane & 4194048)) {
+          var queueLanes = queue.lanes;
+          queueLanes &= root2.pendingLanes;
+          lane |= queueLanes;
+          queue.lanes = lane;
+          markRootEntangled(root2, lane);
+        }
+      }
+      var ContextOnlyDispatcher = {
+        readContext,
+        use: use2,
+        useCallback: throwInvalidHookError,
+        useContext: throwInvalidHookError,
+        useEffect: throwInvalidHookError,
+        useImperativeHandle: throwInvalidHookError,
+        useLayoutEffect: throwInvalidHookError,
+        useInsertionEffect: throwInvalidHookError,
+        useMemo: throwInvalidHookError,
+        useReducer: throwInvalidHookError,
+        useRef: throwInvalidHookError,
+        useState: throwInvalidHookError,
+        useDebugValue: throwInvalidHookError,
+        useDeferredValue: throwInvalidHookError,
+        useTransition: throwInvalidHookError,
+        useSyncExternalStore: throwInvalidHookError,
+        useId: throwInvalidHookError,
+        useHostTransitionStatus: throwInvalidHookError,
+        useFormState: throwInvalidHookError,
+        useActionState: throwInvalidHookError,
+        useOptimistic: throwInvalidHookError,
+        useMemoCache: throwInvalidHookError,
+        useCacheRefresh: throwInvalidHookError
+      };
+      ContextOnlyDispatcher.useEffectEvent = throwInvalidHookError;
+      var HooksDispatcherOnMount = {
+        readContext,
+        use: use2,
+        useCallback: function(callback, deps) {
+          mountWorkInProgressHook().memoizedState = [
+            callback,
+            void 0 === deps ? null : deps
+          ];
+          return callback;
+        },
+        useContext: readContext,
+        useEffect: mountEffect,
+        useImperativeHandle: function(ref, create, deps) {
+          deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
+          mountEffectImpl(
+            4194308,
+            4,
+            imperativeHandleEffect.bind(null, create, ref),
+            deps
+          );
+        },
+        useLayoutEffect: function(create, deps) {
+          return mountEffectImpl(4194308, 4, create, deps);
+        },
+        useInsertionEffect: function(create, deps) {
+          mountEffectImpl(4, 2, create, deps);
+        },
+        useMemo: function(nextCreate, deps) {
+          var hook = mountWorkInProgressHook();
+          deps = void 0 === deps ? null : deps;
+          var nextValue = nextCreate();
+          if (shouldDoubleInvokeUserFnsInHooksDEV) {
+            setIsStrictModeForDevtools(true);
+            try {
+              nextCreate();
+            } finally {
+              setIsStrictModeForDevtools(false);
+            }
+          }
+          hook.memoizedState = [nextValue, deps];
+          return nextValue;
+        },
+        useReducer: function(reducer, initialArg, init) {
+          var hook = mountWorkInProgressHook();
+          if (void 0 !== init) {
+            var initialState = init(initialArg);
+            if (shouldDoubleInvokeUserFnsInHooksDEV) {
+              setIsStrictModeForDevtools(true);
+              try {
+                init(initialArg);
+              } finally {
+                setIsStrictModeForDevtools(false);
+              }
+            }
+          } else initialState = initialArg;
+          hook.memoizedState = hook.baseState = initialState;
+          reducer = {
+            pending: null,
+            lanes: 0,
+            dispatch: null,
+            lastRenderedReducer: reducer,
+            lastRenderedState: initialState
+          };
+          hook.queue = reducer;
+          reducer = reducer.dispatch = dispatchReducerAction.bind(
+            null,
+            currentlyRenderingFiber,
+            reducer
+          );
+          return [hook.memoizedState, reducer];
+        },
+        useRef: function(initialValue) {
+          var hook = mountWorkInProgressHook();
+          initialValue = { current: initialValue };
+          return hook.memoizedState = initialValue;
+        },
+        useState: function(initialState) {
+          initialState = mountStateImpl(initialState);
+          var queue = initialState.queue, dispatch = dispatchSetState.bind(null, currentlyRenderingFiber, queue);
+          queue.dispatch = dispatch;
+          return [initialState.memoizedState, dispatch];
+        },
+        useDebugValue: mountDebugValue,
+        useDeferredValue: function(value, initialValue) {
+          var hook = mountWorkInProgressHook();
+          return mountDeferredValueImpl(hook, value, initialValue);
+        },
+        useTransition: function() {
+          var stateHook = mountStateImpl(false);
+          stateHook = startTransition.bind(
+            null,
+            currentlyRenderingFiber,
+            stateHook.queue,
+            true,
+            false
+          );
+          mountWorkInProgressHook().memoizedState = stateHook;
+          return [false, stateHook];
+        },
+        useSyncExternalStore: function(subscribe2, getSnapshot, getServerSnapshot) {
+          var fiber = currentlyRenderingFiber, hook = mountWorkInProgressHook();
+          if (isHydrating) {
+            if (void 0 === getServerSnapshot)
+              throw Error(formatProdErrorMessage(407));
+            getServerSnapshot = getServerSnapshot();
+          } else {
+            getServerSnapshot = getSnapshot();
+            if (null === workInProgressRoot)
+              throw Error(formatProdErrorMessage(349));
+            0 !== (workInProgressRootRenderLanes & 127) || pushStoreConsistencyCheck(fiber, getSnapshot, getServerSnapshot);
+          }
+          hook.memoizedState = getServerSnapshot;
+          var inst = { value: getServerSnapshot, getSnapshot };
+          hook.queue = inst;
+          mountEffect(subscribeToStore.bind(null, fiber, inst, subscribe2), [
+            subscribe2
+          ]);
+          fiber.flags |= 2048;
+          pushSimpleEffect(
+            9,
+            { destroy: void 0 },
+            updateStoreInstance.bind(
+              null,
+              fiber,
+              inst,
+              getServerSnapshot,
+              getSnapshot
+            ),
+            null
+          );
+          return getServerSnapshot;
+        },
+        useId: function() {
+          var hook = mountWorkInProgressHook(), identifierPrefix = workInProgressRoot.identifierPrefix;
+          if (isHydrating) {
+            var JSCompiler_inline_result = treeContextOverflow;
+            var idWithLeadingBit = treeContextId;
+            JSCompiler_inline_result = (idWithLeadingBit & ~(1 << 32 - clz32(idWithLeadingBit) - 1)).toString(32) + JSCompiler_inline_result;
+            identifierPrefix = "_" + identifierPrefix + "R_" + JSCompiler_inline_result;
+            JSCompiler_inline_result = localIdCounter++;
+            0 < JSCompiler_inline_result && (identifierPrefix += "H" + JSCompiler_inline_result.toString(32));
+            identifierPrefix += "_";
+          } else
+            JSCompiler_inline_result = globalClientIdCounter++, identifierPrefix = "_" + identifierPrefix + "r_" + JSCompiler_inline_result.toString(32) + "_";
+          return hook.memoizedState = identifierPrefix;
+        },
+        useHostTransitionStatus,
+        useFormState: mountActionState,
+        useActionState: mountActionState,
+        useOptimistic: function(passthrough) {
+          var hook = mountWorkInProgressHook();
+          hook.memoizedState = hook.baseState = passthrough;
+          var queue = {
+            pending: null,
+            lanes: 0,
+            dispatch: null,
+            lastRenderedReducer: null,
+            lastRenderedState: null
+          };
+          hook.queue = queue;
+          hook = dispatchOptimisticSetState.bind(
+            null,
+            currentlyRenderingFiber,
+            true,
+            queue
+          );
+          queue.dispatch = hook;
+          return [passthrough, hook];
+        },
+        useMemoCache,
+        useCacheRefresh: function() {
+          return mountWorkInProgressHook().memoizedState = refreshCache.bind(
+            null,
+            currentlyRenderingFiber
+          );
+        },
+        useEffectEvent: function(callback) {
+          var hook = mountWorkInProgressHook(), ref = { impl: callback };
+          hook.memoizedState = ref;
+          return function() {
+            if (0 !== (executionContext & 2))
+              throw Error(formatProdErrorMessage(440));
+            return ref.impl.apply(void 0, arguments);
+          };
+        }
+      };
+      var HooksDispatcherOnUpdate = {
+        readContext,
+        use: use2,
+        useCallback: updateCallback,
+        useContext: readContext,
+        useEffect: updateEffect,
+        useImperativeHandle: updateImperativeHandle,
+        useInsertionEffect: updateInsertionEffect,
+        useLayoutEffect: updateLayoutEffect,
+        useMemo: updateMemo,
+        useReducer: updateReducer,
+        useRef: updateRef,
+        useState: function() {
+          return updateReducer(basicStateReducer);
+        },
+        useDebugValue: mountDebugValue,
+        useDeferredValue: function(value, initialValue) {
+          var hook = updateWorkInProgressHook();
+          return updateDeferredValueImpl(
+            hook,
+            currentHook.memoizedState,
+            value,
+            initialValue
+          );
+        },
+        useTransition: function() {
+          var booleanOrThenable = updateReducer(basicStateReducer)[0], start2 = updateWorkInProgressHook().memoizedState;
+          return [
+            "boolean" === typeof booleanOrThenable ? booleanOrThenable : useThenable(booleanOrThenable),
+            start2
+          ];
+        },
+        useSyncExternalStore: updateSyncExternalStore,
+        useId: updateId,
+        useHostTransitionStatus,
+        useFormState: updateActionState,
+        useActionState: updateActionState,
+        useOptimistic: function(passthrough, reducer) {
+          var hook = updateWorkInProgressHook();
+          return updateOptimisticImpl(hook, currentHook, passthrough, reducer);
+        },
+        useMemoCache,
+        useCacheRefresh: updateRefresh
+      };
+      HooksDispatcherOnUpdate.useEffectEvent = updateEvent;
+      var HooksDispatcherOnRerender = {
+        readContext,
+        use: use2,
+        useCallback: updateCallback,
+        useContext: readContext,
+        useEffect: updateEffect,
+        useImperativeHandle: updateImperativeHandle,
+        useInsertionEffect: updateInsertionEffect,
+        useLayoutEffect: updateLayoutEffect,
+        useMemo: updateMemo,
+        useReducer: rerenderReducer,
+        useRef: updateRef,
+        useState: function() {
+          return rerenderReducer(basicStateReducer);
+        },
+        useDebugValue: mountDebugValue,
+        useDeferredValue: function(value, initialValue) {
+          var hook = updateWorkInProgressHook();
+          return null === currentHook ? mountDeferredValueImpl(hook, value, initialValue) : updateDeferredValueImpl(
+            hook,
+            currentHook.memoizedState,
+            value,
+            initialValue
+          );
+        },
+        useTransition: function() {
+          var booleanOrThenable = rerenderReducer(basicStateReducer)[0], start2 = updateWorkInProgressHook().memoizedState;
+          return [
+            "boolean" === typeof booleanOrThenable ? booleanOrThenable : useThenable(booleanOrThenable),
+            start2
+          ];
+        },
+        useSyncExternalStore: updateSyncExternalStore,
+        useId: updateId,
+        useHostTransitionStatus,
+        useFormState: rerenderActionState,
+        useActionState: rerenderActionState,
+        useOptimistic: function(passthrough, reducer) {
+          var hook = updateWorkInProgressHook();
+          if (null !== currentHook)
+            return updateOptimisticImpl(hook, currentHook, passthrough, reducer);
+          hook.baseState = passthrough;
+          return [passthrough, hook.queue.dispatch];
+        },
+        useMemoCache,
+        useCacheRefresh: updateRefresh
+      };
+      HooksDispatcherOnRerender.useEffectEvent = updateEvent;
+      function applyDerivedStateFromProps(workInProgress2, ctor, getDerivedStateFromProps, nextProps) {
+        ctor = workInProgress2.memoizedState;
+        getDerivedStateFromProps = getDerivedStateFromProps(nextProps, ctor);
+        getDerivedStateFromProps = null === getDerivedStateFromProps || void 0 === getDerivedStateFromProps ? ctor : assign({}, ctor, getDerivedStateFromProps);
+        workInProgress2.memoizedState = getDerivedStateFromProps;
+        0 === workInProgress2.lanes && (workInProgress2.updateQueue.baseState = getDerivedStateFromProps);
+      }